projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix autotune to not actually crack hashes
[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 136
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 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * hashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 double speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 speed_cnt += device_param->speed_cnt[i];
811 speed_ms += device_param->speed_ms[i];
812 }
813
814 speed_cnt /= SPEED_CACHE;
815 speed_ms /= SPEED_CACHE;
816
817 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
818 }
819
820 /**
821 * exec time
822 */
823
824 fprintf (out, "EXEC_RUNTIME\t");
825
826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
827 {
828 hc_device_param_t *device_param = &data.devices_param[device_id];
829
830 if (device_param->skipped) continue;
831
832 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
833
834 fprintf (out, "%f\t", exec_ms_avg);
835 }
836
837 /**
838 * words_cur
839 */
840
841 u64 words_cur = get_lowest_words_done ();
842
843 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
844
845 /**
846 * counter
847 */
848
849 u64 progress_total = data.words_cnt * data.salts_cnt;
850
851 u64 all_done = 0;
852 u64 all_rejected = 0;
853 u64 all_restored = 0;
854
855 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
856 {
857 all_done += data.words_progress_done[salt_pos];
858 all_rejected += data.words_progress_rejected[salt_pos];
859 all_restored += data.words_progress_restored[salt_pos];
860 }
861
862 u64 progress_cur = all_restored + all_done + all_rejected;
863 u64 progress_end = progress_total;
864
865 u64 progress_skip = 0;
866
867 if (data.skip)
868 {
869 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
870
871 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
872 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
873 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
874 }
875
876 if (data.limit)
877 {
878 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
879
880 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
881 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
882 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
883 }
884
885 u64 progress_cur_relative_skip = progress_cur - progress_skip;
886 u64 progress_end_relative_skip = progress_end - progress_skip;
887
888 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
889
890 /**
891 * cracks
892 */
893
894 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
895 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
896
897 /**
898 * temperature
899 */
900
901 #ifdef HAVE_HWMON
902 if (data.gpu_temp_disable == 0)
903 {
904 fprintf (out, "TEMP\t");
905
906 hc_thread_mutex_lock (mux_adl);
907
908 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
909 {
910 hc_device_param_t *device_param = &data.devices_param[device_id];
911
912 if (device_param->skipped) continue;
913
914 int temp = hm_get_temperature_with_device_id (device_id);
915
916 fprintf (out, "%d\t", temp);
917 }
918
919 hc_thread_mutex_unlock (mux_adl);
920 }
921 #endif // HAVE_HWMON
922
923 /**
924 * flush
925 */
926
927 #ifdef _WIN
928 fputc ('\r', out);
929 fputc ('\n', out);
930 #endif
931
932 #ifdef _POSIX
933 fputc ('\n', out);
934 #endif
935
936 fflush (out);
937 }
938
939 void status_display ()
940 {
941 if (data.devices_status == STATUS_INIT) return;
942 if (data.devices_status == STATUS_STARTING) return;
943 if (data.devices_status == STATUS_BYPASS) return;
944
945 if (data.status_automat == 1)
946 {
947 status_display_automat ();
948
949 return;
950 }
951
952 char tmp_buf[1000] = { 0 };
953
954 uint tmp_len = 0;
955
956 log_info ("Session.Name...: %s", data.session);
957
958 char *status_type = strstatus (data.devices_status);
959
960 uint hash_mode = data.hash_mode;
961
962 char *hash_type = strhashtype (hash_mode); // not a bug
963
964 log_info ("Status.........: %s", status_type);
965
966 /**
967 * show rules
968 */
969
970 if (data.rp_files_cnt)
971 {
972 uint i;
973
974 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
975 {
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
977 }
978
979 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
980
981 log_info ("Rules.Type.....: %s", tmp_buf);
982
983 tmp_len = 0;
984 }
985
986 if (data.rp_gen)
987 {
988 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
989
990 if (data.rp_gen_seed)
991 {
992 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
993 }
994 }
995
996 /**
997 * show input
998 */
999
1000 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1001 {
1002 if (data.wordlist_mode == WL_MODE_FILE)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1005 }
1006 else if (data.wordlist_mode == WL_MODE_STDIN)
1007 {
1008 log_info ("Input.Mode.....: Pipe");
1009 }
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_COMBI)
1012 {
1013 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1014 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1015 }
1016 else if (data.attack_mode == ATTACK_MODE_BF)
1017 {
1018 char *mask = data.mask;
1019
1020 if (mask != NULL)
1021 {
1022 uint mask_len = data.css_cnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1025
1026 if (mask_len > 0)
1027 {
1028 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1029 {
1030 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1031 {
1032 mask_len -= data.salts_buf[0].salt_len;
1033 }
1034 }
1035
1036 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1037
1038 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1039 }
1040
1041 if (data.maskcnt > 1)
1042 {
1043 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1044
1045 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1046 }
1047
1048 log_info ("Input.Mode.....: %s", tmp_buf);
1049 }
1050
1051 tmp_len = 0;
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1054 {
1055 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1056 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1057 }
1058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1059 {
1060 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1062 }
1063
1064 if (data.digests_cnt == 1)
1065 {
1066 if (data.hash_mode == 2500)
1067 {
1068 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1069
1070 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1071 (char *) data.salts_buf[0].salt_buf,
1072 wpa->orig_mac1[0],
1073 wpa->orig_mac1[1],
1074 wpa->orig_mac1[2],
1075 wpa->orig_mac1[3],
1076 wpa->orig_mac1[4],
1077 wpa->orig_mac1[5],
1078 wpa->orig_mac2[0],
1079 wpa->orig_mac2[1],
1080 wpa->orig_mac2[2],
1081 wpa->orig_mac2[3],
1082 wpa->orig_mac2[4],
1083 wpa->orig_mac2[5]);
1084 }
1085 else if (data.hash_mode == 5200)
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else if (data.hash_mode == 9000)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else
1098 {
1099 char out_buf[HCBUFSIZ] = { 0 };
1100
1101 ascii_digest (out_buf, 0, 0);
1102
1103 // limit length
1104 if (strlen (out_buf) > 40)
1105 {
1106 out_buf[41] = '.';
1107 out_buf[42] = '.';
1108 out_buf[43] = '.';
1109 out_buf[44] = 0;
1110 }
1111
1112 log_info ("Hash.Target....: %s", out_buf);
1113 }
1114 }
1115 else
1116 {
1117 if (data.hash_mode == 3000)
1118 {
1119 char out_buf1[32] = { 0 };
1120 char out_buf2[32] = { 0 };
1121
1122 ascii_digest (out_buf1, 0, 0);
1123 ascii_digest (out_buf2, 0, 1);
1124
1125 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1126 }
1127 else
1128 {
1129 log_info ("Hash.Target....: File (%s)", data.hashfile);
1130 }
1131 }
1132
1133 log_info ("Hash.Type......: %s", hash_type);
1134
1135 /**
1136 * speed new
1137 */
1138
1139 u64 speed_cnt[DEVICES_MAX] = { 0 };
1140 double speed_ms[DEVICES_MAX] = { 0 };
1141
1142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1143 {
1144 hc_device_param_t *device_param = &data.devices_param[device_id];
1145
1146 if (device_param->skipped) continue;
1147
1148 speed_cnt[device_id] = 0;
1149 speed_ms[device_id] = 0;
1150
1151 for (int i = 0; i < SPEED_CACHE; i++)
1152 {
1153 speed_cnt[device_id] += device_param->speed_cnt[i];
1154 speed_ms[device_id] += device_param->speed_ms[i];
1155 }
1156
1157 speed_cnt[device_id] /= SPEED_CACHE;
1158 speed_ms[device_id] /= SPEED_CACHE;
1159 }
1160
1161 float hashes_all_ms = 0;
1162
1163 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1164
1165 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1166 {
1167 hc_device_param_t *device_param = &data.devices_param[device_id];
1168
1169 if (device_param->skipped) continue;
1170
1171 hashes_dev_ms[device_id] = 0;
1172
1173 if (speed_ms[device_id])
1174 {
1175 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1176
1177 hashes_all_ms += hashes_dev_ms[device_id];
1178 }
1179 }
1180
1181 /**
1182 * exec time
1183 */
1184
1185 double exec_all_ms[DEVICES_MAX] = { 0 };
1186
1187 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1188 {
1189 hc_device_param_t *device_param = &data.devices_param[device_id];
1190
1191 if (device_param->skipped) continue;
1192
1193 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1194
1195 exec_all_ms[device_id] = exec_ms_avg;
1196 }
1197
1198 /**
1199 * timers
1200 */
1201
1202 double ms_running = 0;
1203
1204 hc_timer_get (data.timer_running, ms_running);
1205
1206 double ms_paused = data.ms_paused;
1207
1208 if (data.devices_status == STATUS_PAUSED)
1209 {
1210 double ms_paused_tmp = 0;
1211
1212 hc_timer_get (data.timer_paused, ms_paused_tmp);
1213
1214 ms_paused += ms_paused_tmp;
1215 }
1216
1217 #ifdef WIN
1218
1219 __time64_t sec_run = ms_running / 1000;
1220
1221 #else
1222
1223 time_t sec_run = ms_running / 1000;
1224
1225 #endif
1226
1227 if (sec_run)
1228 {
1229 char display_run[32] = { 0 };
1230
1231 struct tm tm_run;
1232
1233 struct tm *tmp = NULL;
1234
1235 #ifdef WIN
1236
1237 tmp = _gmtime64 (&sec_run);
1238
1239 #else
1240
1241 tmp = gmtime (&sec_run);
1242
1243 #endif
1244
1245 if (tmp != NULL)
1246 {
1247 memset (&tm_run, 0, sizeof (tm_run));
1248
1249 memcpy (&tm_run, tmp, sizeof (tm_run));
1250
1251 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1252
1253 char *start = ctime (&data.proc_start);
1254
1255 size_t start_len = strlen (start);
1256
1257 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1258 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1259
1260 log_info ("Time.Started...: %s (%s)", start, display_run);
1261 }
1262 }
1263 else
1264 {
1265 log_info ("Time.Started...: 0 secs");
1266 }
1267
1268 /**
1269 * counters
1270 */
1271
1272 u64 progress_total = data.words_cnt * data.salts_cnt;
1273
1274 u64 all_done = 0;
1275 u64 all_rejected = 0;
1276 u64 all_restored = 0;
1277
1278 u64 progress_noneed = 0;
1279
1280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1281 {
1282 all_done += data.words_progress_done[salt_pos];
1283 all_rejected += data.words_progress_rejected[salt_pos];
1284 all_restored += data.words_progress_restored[salt_pos];
1285
1286 // Important for ETA only
1287
1288 if (data.salts_shown[salt_pos] == 1)
1289 {
1290 const u64 all = data.words_progress_done[salt_pos]
1291 + data.words_progress_rejected[salt_pos]
1292 + data.words_progress_restored[salt_pos];
1293
1294 const u64 left = data.words_cnt - all;
1295
1296 progress_noneed += left;
1297 }
1298 }
1299
1300 u64 progress_cur = all_restored + all_done + all_rejected;
1301 u64 progress_end = progress_total;
1302
1303 u64 progress_skip = 0;
1304
1305 if (data.skip)
1306 {
1307 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1308
1309 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1312 }
1313
1314 if (data.limit)
1315 {
1316 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1317
1318 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1321 }
1322
1323 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1324 u64 progress_end_relative_skip = progress_end - progress_skip;
1325
1326 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1327 {
1328 if (data.devices_status != STATUS_CRACKED)
1329 {
1330 #ifdef WIN
1331 __time64_t sec_etc = 0;
1332 #else
1333 time_t sec_etc = 0;
1334 #endif
1335
1336 if (hashes_all_ms)
1337 {
1338 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1339
1340 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1341
1342 sec_etc = ms_left / 1000;
1343 }
1344
1345 if (sec_etc == 0)
1346 {
1347 //log_info ("Time.Estimated.: 0 secs");
1348 }
1349 else if ((u64) sec_etc > ETC_MAX)
1350 {
1351 log_info ("Time.Estimated.: > 10 Years");
1352 }
1353 else
1354 {
1355 char display_etc[32] = { 0 };
1356
1357 struct tm tm_etc;
1358
1359 struct tm *tmp = NULL;
1360
1361 #ifdef WIN
1362
1363 tmp = _gmtime64 (&sec_etc);
1364
1365 #else
1366
1367 tmp = gmtime (&sec_etc);
1368
1369 #endif
1370
1371 if (tmp != NULL)
1372 {
1373 memset (&tm_etc, 0, sizeof (tm_etc));
1374
1375 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1376
1377 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1378
1379 time_t now;
1380
1381 time (&now);
1382
1383 now += sec_etc;
1384
1385 char *etc = ctime (&now);
1386
1387 size_t etc_len = strlen (etc);
1388
1389 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1390 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1391
1392 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1393 }
1394 }
1395 }
1396 }
1397
1398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1399 {
1400 hc_device_param_t *device_param = &data.devices_param[device_id];
1401
1402 if (device_param->skipped) continue;
1403
1404 char display_dev_cur[16] = { 0 };
1405
1406 strncpy (display_dev_cur, "0.00", 4);
1407
1408 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1409
1410 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1411 }
1412
1413 char display_all_cur[16] = { 0 };
1414
1415 strncpy (display_all_cur, "0.00", 4);
1416
1417 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1418
1419 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1420
1421 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1422 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1423
1424 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);
1425
1426 // crack-per-time
1427
1428 if (data.digests_cnt > 100)
1429 {
1430 time_t now = time (NULL);
1431
1432 int cpt_cur_min = 0;
1433 int cpt_cur_hour = 0;
1434 int cpt_cur_day = 0;
1435
1436 for (int i = 0; i < CPT_BUF; i++)
1437 {
1438 const uint cracked = data.cpt_buf[i].cracked;
1439 const time_t timestamp = data.cpt_buf[i].timestamp;
1440
1441 if ((timestamp + 60) > now)
1442 {
1443 cpt_cur_min += cracked;
1444 }
1445
1446 if ((timestamp + 3600) > now)
1447 {
1448 cpt_cur_hour += cracked;
1449 }
1450
1451 if ((timestamp + 86400) > now)
1452 {
1453 cpt_cur_day += cracked;
1454 }
1455 }
1456
1457 double ms_real = ms_running - ms_paused;
1458
1459 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1460 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1461 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1462
1463 if ((data.cpt_start + 86400) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_cur_hour,
1468 cpt_cur_day,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else if ((data.cpt_start + 3600) < now)
1474 {
1475 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_cur_min,
1477 cpt_cur_hour,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else if ((data.cpt_start + 60) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else
1491 {
1492 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 }
1498
1499 // Restore point
1500
1501 u64 restore_point = get_lowest_words_done ();
1502
1503 u64 restore_total = data.words_base;
1504
1505 float percent_restore = 0;
1506
1507 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1508
1509 if (progress_end_relative_skip)
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1514 float percent_rejected = 0.0;
1515
1516 if (progress_cur)
1517 {
1518 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1519 }
1520
1521 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);
1522 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1523
1524 if (data.restore_disable == 0)
1525 {
1526 if (percent_finished != 1)
1527 {
1528 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1529 }
1530 }
1531 }
1532 }
1533 else
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539
1540 if (data.restore_disable == 0)
1541 {
1542 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1543 }
1544 }
1545 else
1546 {
1547 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1548 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1549
1550 // --restore not allowed if stdin is used -- really? why?
1551
1552 //if (data.restore_disable == 0)
1553 //{
1554 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1555 //}
1556 }
1557 }
1558
1559 #ifdef HAVE_HWMON
1560 if (data.gpu_temp_disable == 0)
1561 {
1562 hc_thread_mutex_lock (mux_adl);
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hc_device_param_t *device_param = &data.devices_param[device_id];
1567
1568 if (device_param->skipped) continue;
1569
1570 #define HM_STR_BUF_SIZE 255
1571
1572 if (data.hm_device[device_id].fan_supported == 1)
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1577
1578 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1579 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1580
1581 if (device_param->vendor_id == VENDOR_ID_AMD)
1582 {
1583 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1584 }
1585 else if (device_param->vendor_id == VENDOR_ID_NV)
1586 {
1587 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1588 }
1589
1590 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1591 }
1592 else
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596
1597 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1598 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1599
1600 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1601 }
1602 }
1603
1604 hc_thread_mutex_unlock (mux_adl);
1605 }
1606 #endif // HAVE_HWMON
1607 }
1608
1609 static void status_benchmark ()
1610 {
1611 if (data.devices_status == STATUS_INIT) return;
1612 if (data.devices_status == STATUS_STARTING) return;
1613
1614 if (data.words_cnt == 0) return;
1615
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 float hashes_all_ms = 0;
1630
1631 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 hashes_dev_ms[device_id] = 0;
1640
1641 if (speed_ms[device_id])
1642 {
1643 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1644
1645 hashes_all_ms += hashes_dev_ms[device_id];
1646 }
1647 }
1648
1649 /**
1650 * exec time
1651 */
1652
1653 double exec_all_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1662
1663 exec_all_ms[device_id] = exec_ms_avg;
1664 }
1665
1666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667 {
1668 hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670 if (device_param->skipped) continue;
1671
1672 char display_dev_cur[16] = { 0 };
1673
1674 strncpy (display_dev_cur, "0.00", 4);
1675
1676 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1677
1678 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1679 }
1680
1681 char display_all_cur[16] = { 0 };
1682
1683 strncpy (display_all_cur, "0.00", 4);
1684
1685 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1686
1687 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1688 }
1689
1690 /**
1691 * hashcat -only- functions
1692 */
1693
1694 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1695 {
1696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1697 {
1698 if (attack_kern == ATTACK_KERN_STRAIGHT)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_COMBI)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_BF)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1704 }
1705 else
1706 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1707 }
1708
1709 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)
1710 {
1711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1712 {
1713 if (attack_kern == ATTACK_KERN_STRAIGHT)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_COMBI)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_BF)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 }
1720 else
1721 {
1722 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 }
1724 }
1725
1726 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1727 {
1728 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1729 {
1730 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1731 }
1732 else
1733 {
1734 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1735 }
1736 }
1737
1738 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)
1739 {
1740 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1741 {
1742 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1743 }
1744 else
1745 {
1746 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1747 }
1748 }
1749
1750 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1753 }
1754
1755 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1756 {
1757 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1758 }
1759
1760 static uint convert_from_hex (char *line_buf, const uint line_len)
1761 {
1762 if (line_len & 1) return (line_len); // not in hex
1763
1764 if (data.hex_wordlist == 1)
1765 {
1766 uint i;
1767 uint j;
1768
1769 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1770 {
1771 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1772 }
1773
1774 memset (line_buf + i, 0, line_len - i);
1775
1776 return (i);
1777 }
1778 else if (line_len >= 6) // $HEX[] = 6
1779 {
1780 if (line_buf[0] != '$') return (line_len);
1781 if (line_buf[1] != 'H') return (line_len);
1782 if (line_buf[2] != 'E') return (line_len);
1783 if (line_buf[3] != 'X') return (line_len);
1784 if (line_buf[4] != '[') return (line_len);
1785 if (line_buf[line_len - 1] != ']') return (line_len);
1786
1787 uint i;
1788 uint j;
1789
1790 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1791 {
1792 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1793 }
1794
1795 memset (line_buf + i, 0, line_len - i);
1796
1797 return (i);
1798 }
1799
1800 return (line_len);
1801 }
1802
1803 static void clear_prompt ()
1804 {
1805 fputc ('\r', stdout);
1806
1807 for (size_t i = 0; i < strlen (PROMPT); i++)
1808 {
1809 fputc (' ', stdout);
1810 }
1811
1812 fputc ('\r', stdout);
1813
1814 fflush (stdout);
1815 }
1816
1817 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1818 {
1819 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);
1820 }
1821
1822 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1823 {
1824 char *outfile = data.outfile;
1825 uint quiet = data.quiet;
1826 FILE *pot_fp = data.pot_fp;
1827 uint loopback = data.loopback;
1828 uint debug_mode = data.debug_mode;
1829 char *debug_file = data.debug_file;
1830
1831 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1832 int debug_rule_len = 0; // -1 error
1833 uint debug_plain_len = 0;
1834
1835 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1836
1837 // hash
1838
1839 char out_buf[HCBUFSIZ] = { 0 };
1840
1841 ascii_digest (out_buf, salt_pos, digest_pos);
1842
1843 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1844
1845 // plain
1846
1847 plain_t plain;
1848
1849 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);
1850
1851 uint gidvid = plain.gidvid;
1852 uint il_pos = plain.il_pos;
1853
1854 u64 crackpos = device_param->words_off;
1855
1856 uint plain_buf[16] = { 0 };
1857
1858 u8 *plain_ptr = (u8 *) plain_buf;
1859 unsigned int plain_len = 0;
1860
1861 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1862 {
1863 u64 gidd = gidvid;
1864 u64 gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.i[j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 const uint off = device_param->innerloop_pos + il_pos;
1878
1879 if (debug_mode > 0)
1880 {
1881 debug_rule_len = 0;
1882
1883 // save rule
1884 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1885 {
1886 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1887
1888 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1889 }
1890
1891 // save plain
1892 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1895
1896 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1897
1898 debug_plain_len = plain_len;
1899 }
1900 }
1901
1902 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1903
1904 crackpos += gidvid;
1905 crackpos *= data.kernel_rules_cnt;
1906 crackpos += device_param->innerloop_pos + il_pos;
1907
1908 if (plain_len > data.pw_max) plain_len = data.pw_max;
1909 }
1910 else if (data.attack_mode == ATTACK_MODE_COMBI)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1927 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1928
1929 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1930 {
1931 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1932 }
1933 else
1934 {
1935 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1936
1937 memcpy (plain_ptr, comb_buf, comb_len);
1938 }
1939
1940 plain_len += comb_len;
1941
1942 crackpos += gidvid;
1943 crackpos *= data.combs_cnt;
1944 crackpos += device_param->innerloop_pos + il_pos;
1945
1946 if (data.pw_max != PW_DICTMAX1)
1947 {
1948 if (plain_len > data.pw_max) plain_len = data.pw_max;
1949 }
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_BF)
1952 {
1953 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1954 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1955
1956 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1957 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1958
1959 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1960 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1961
1962 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1963 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1964
1965 plain_len = data.css_cnt;
1966
1967 crackpos += gidvid;
1968 crackpos *= data.bfs_cnt;
1969 crackpos += device_param->innerloop_pos + il_pos;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.i[j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1988
1989 uint start = 0;
1990 uint stop = device_param->kernel_params_mp_buf32[4];
1991
1992 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1993
1994 plain_len += start + stop;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.i[j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 memmove (plain_ptr + stop, plain_ptr, plain_len);
2027
2028 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041
2042 if (data.attack_mode == ATTACK_MODE_BF)
2043 {
2044 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2045 {
2046 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2047 {
2048 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2049 {
2050 plain_len = plain_len - data.salts_buf[0].salt_len;
2051 }
2052 }
2053
2054 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2055 {
2056 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2057 {
2058 plain_ptr[j] = plain_ptr[i];
2059 }
2060
2061 plain_len = plain_len / 2;
2062 }
2063 }
2064 }
2065
2066 // if enabled, update also the potfile
2067
2068 if (pot_fp)
2069 {
2070 lock_file (pot_fp);
2071
2072 fprintf (pot_fp, "%s:", out_buf);
2073
2074 format_plain (pot_fp, plain_ptr, plain_len, 1);
2075
2076 fputc ('\n', pot_fp);
2077
2078 fflush (pot_fp);
2079
2080 unlock_file (pot_fp);
2081 }
2082
2083 // outfile
2084
2085 FILE *out_fp = NULL;
2086
2087 if (outfile != NULL)
2088 {
2089 if ((out_fp = fopen (outfile, "ab")) == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2092
2093 out_fp = stdout;
2094 }
2095 lock_file (out_fp);
2096 }
2097 else
2098 {
2099 out_fp = stdout;
2100
2101 if (quiet == 0) clear_prompt ();
2102 }
2103
2104 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2105
2106 if (outfile != NULL)
2107 {
2108 if (out_fp != stdout)
2109 {
2110 fclose (out_fp);
2111 }
2112 }
2113 else
2114 {
2115 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2116 {
2117 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2118 {
2119 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2120 if (quiet == 0) fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 // loopback
2126
2127 if (loopback)
2128 {
2129 char *loopback_file = data.loopback_file;
2130
2131 FILE *fb_fp = NULL;
2132
2133 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2134 {
2135 lock_file (fb_fp);
2136
2137 format_plain (fb_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', fb_fp);
2140
2141 fclose (fb_fp);
2142 }
2143 }
2144
2145 // (rule) debug mode
2146
2147 // the next check implies that:
2148 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2149 // - debug_mode > 0
2150
2151 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2152 {
2153 if (debug_rule_len < 0) debug_rule_len = 0;
2154
2155 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2156
2157 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2158
2159 if ((quiet == 0) && (debug_file == NULL))
2160 {
2161 fprintf (stdout, "%s", PROMPT);
2162 fflush (stdout);
2163 }
2164 }
2165 }
2166
2167 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2168 {
2169 salt_t *salt_buf = &data.salts_buf[salt_pos];
2170
2171 int found = 0;
2172
2173 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);
2174
2175 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2176
2177 if (found == 1)
2178 {
2179 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2180
2181 log_info_nn ("");
2182
2183 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);
2184
2185 uint cpt_cracked = 0;
2186
2187 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2188 {
2189 uint idx = salt_buf->digests_offset + digest_pos;
2190
2191 if (data.digests_shown_tmp[idx] == 0) continue;
2192
2193 if (data.digests_shown[idx] == 1) continue;
2194
2195 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2196 {
2197 data.digests_shown[idx] = 1;
2198
2199 data.digests_done++;
2200
2201 cpt_cracked++;
2202
2203 salt_buf->digests_done++;
2204
2205 if (salt_buf->digests_done == salt_buf->digests_cnt)
2206 {
2207 data.salts_shown[salt_pos] = 1;
2208
2209 data.salts_done++;
2210 }
2211 }
2212
2213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2214
2215 check_hash (device_param, salt_pos, digest_pos);
2216 }
2217
2218 if (cpt_cracked > 0)
2219 {
2220 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2221 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2222
2223 data.cpt_pos++;
2224
2225 data.cpt_total += cpt_cracked;
2226
2227 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2228 }
2229
2230 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2231 {
2232 // we need to reset cracked state on the device
2233 // otherwise host thinks again and again the hash was cracked
2234 // and returns invalid password each time
2235
2236 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2237
2238 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);
2239 }
2240
2241 memset (device_param->result, 0, device_param->size_results);
2242
2243 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);
2244 }
2245 }
2246
2247 static void save_hash ()
2248 {
2249 char *hashfile = data.hashfile;
2250
2251 char new_hashfile[256] = { 0 };
2252 char old_hashfile[256] = { 0 };
2253
2254 snprintf (new_hashfile, 255, "%s.new", hashfile);
2255 snprintf (old_hashfile, 255, "%s.old", hashfile);
2256
2257 unlink (new_hashfile);
2258
2259 char separator = data.separator;
2260
2261 FILE *fp = fopen (new_hashfile, "wb");
2262
2263 if (fp == NULL)
2264 {
2265 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2266
2267 exit (-1);
2268 }
2269
2270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2271 {
2272 if (data.salts_shown[salt_pos] == 1) continue;
2273
2274 salt_t *salt_buf = &data.salts_buf[salt_pos];
2275
2276 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2277 {
2278 uint idx = salt_buf->digests_offset + digest_pos;
2279
2280 if (data.digests_shown[idx] == 1) continue;
2281
2282 if (data.hash_mode != 2500)
2283 {
2284 char out_buf[HCBUFSIZ] = { 0 };
2285
2286 if (data.username == 1)
2287 {
2288 user_t *user = data.hash_info[idx]->user;
2289
2290 uint i;
2291
2292 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2293
2294 fputc (separator, fp);
2295 }
2296
2297 ascii_digest (out_buf, salt_pos, digest_pos);
2298
2299 fputs (out_buf, fp);
2300
2301 log_out (fp, "");
2302 }
2303 else
2304 {
2305 hccap_t hccap;
2306
2307 to_hccap_t (&hccap, salt_pos, digest_pos);
2308
2309 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2310 }
2311 }
2312 }
2313
2314 fflush (fp);
2315
2316 fclose (fp);
2317
2318 unlink (old_hashfile);
2319
2320 if (rename (hashfile, old_hashfile) != 0)
2321 {
2322 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 unlink (hashfile);
2328
2329 if (rename (new_hashfile, hashfile) != 0)
2330 {
2331 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 unlink (old_hashfile);
2337 }
2338
2339 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2340 {
2341 // function called only in case kernel_power_all > words_left
2342
2343 float kernel_power_div = (float) (total_left) / kernel_power_all;
2344
2345 kernel_power_div += kernel_power_div / 100;
2346
2347 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2348
2349 while (kernel_power_new < total_left)
2350 {
2351 kernel_power_div += kernel_power_div / 100;
2352
2353 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2354 }
2355
2356 if (data.quiet == 0)
2357 {
2358 clear_prompt ();
2359
2360 log_info ("");
2361
2362 log_info ("INFO: approaching final keyspace, workload adjusted");
2363
2364 log_info ("");
2365
2366 fprintf (stdout, "%s", PROMPT);
2367
2368 fflush (stdout);
2369 }
2370
2371 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2372
2373 return kernel_power_div;
2374 }
2375
2376 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2377 {
2378 uint num_elements = num;
2379
2380 device_param->kernel_params_buf32[30] = data.combs_mode;
2381 device_param->kernel_params_buf32[31] = num;
2382
2383 uint kernel_threads = device_param->kernel_threads;
2384
2385 while (num_elements % kernel_threads) num_elements++;
2386
2387 cl_kernel kernel = NULL;
2388
2389 switch (kern_run)
2390 {
2391 case KERN_RUN_1: kernel = device_param->kernel1; break;
2392 case KERN_RUN_12: kernel = device_param->kernel12; break;
2393 case KERN_RUN_2: kernel = device_param->kernel2; break;
2394 case KERN_RUN_23: kernel = device_param->kernel23; break;
2395 case KERN_RUN_3: kernel = device_param->kernel3; break;
2396 }
2397
2398 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2399 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2400 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2401 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2402 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2403 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2404 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2405 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2406 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2407 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2408 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2409
2410 hc_timer_t timer;
2411
2412 hc_timer_set (&timer);
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, NULL);
2420 }
2421 else
2422 {
2423 size_t workgroup_size = 0;
2424
2425 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2426
2427 if (kern_run == KERN_RUN_2)
2428 {
2429 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2430 {
2431 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2432 }
2433 }
2434
2435 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 const size_t global_work_size[3] = { num_elements, 1, 1 };
2440 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2443 }
2444
2445 hc_clFlush (data.ocl, device_param->command_queue);
2446
2447 hc_clFinish (data.ocl, device_param->command_queue);
2448
2449 if (event_update)
2450 {
2451 double exec_time;
2452
2453 hc_timer_get (timer, exec_time);
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468 }
2469
2470 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2471 {
2472 uint num_elements = num;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2477 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2478 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2479 }
2480
2481 // causes problems with special threads like in bcrypt
2482 // const uint kernel_threads = device_param->kernel_threads;
2483
2484 uint kernel_threads = device_param->kernel_threads;
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 cl_kernel kernel = NULL;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2493 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2494 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2495 }
2496
2497 switch (kern_run)
2498 {
2499 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2500 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2501 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2502 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2503 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2504 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2505 break;
2506 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2507 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2508 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2509 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2510 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2511 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2512 break;
2513 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2514 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2515 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2516 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2517 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2518 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2519 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2520 break;
2521 }
2522
2523 size_t workgroup_size = 0;
2524
2525 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2526
2527 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2528
2529 const size_t global_work_size[3] = { num_elements, 1, 1 };
2530 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2531
2532 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2533
2534 hc_clFlush (data.ocl, device_param->command_queue);
2535
2536 hc_clFinish (data.ocl, device_param->command_queue);
2537 }
2538
2539 static void run_kernel_tm (hc_device_param_t *device_param)
2540 {
2541 const uint num_elements = 1024; // fixed
2542
2543 uint kernel_threads = 32;
2544
2545 cl_kernel kernel = device_param->kernel_tm;
2546
2547 size_t workgroup_size = 0;
2548
2549 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2550
2551 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2568 device_param->kernel_params_amp_buf32[6] = num_elements;
2569
2570 // causes problems with special threads like in bcrypt
2571 // const uint kernel_threads = device_param->kernel_threads;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_amp;
2578
2579 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2580 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2581
2582 size_t workgroup_size = 0;
2583
2584 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2585
2586 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2599 {
2600 int rc = -1;
2601
2602 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2603 {
2604 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2605
2606 const cl_uchar zero = 0;
2607
2608 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2609 }
2610
2611 if (rc != 0)
2612 {
2613 // NOTE: clEnqueueFillBuffer () always fails with -59
2614 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2615 // How's that possible, OpenCL 1.2 support is advertised??
2616 // We need to workaround...
2617
2618 #define FILLSZ 0x100000
2619
2620 char *tmp = (char *) mymalloc (FILLSZ);
2621
2622 for (size_t i = 0; i < size; i += FILLSZ)
2623 {
2624 const size_t left = size - i;
2625
2626 const size_t fillsz = MIN (FILLSZ, left);
2627
2628 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2629 }
2630
2631 myfree (tmp);
2632 }
2633 }
2634
2635 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)
2636 {
2637 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2638 {
2639 if (attack_mode == ATTACK_MODE_BF)
2640 {
2641 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2642 {
2643 const uint size_tm = 32 * sizeof (bs_word_t);
2644
2645 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2646
2647 run_kernel_tm (device_param);
2648
2649 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);
2650 }
2651 }
2652
2653 if (highest_pw_len < 16)
2654 {
2655 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2656 }
2657 else if (highest_pw_len < 32)
2658 {
2659 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2660 }
2661 else
2662 {
2663 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2664 }
2665 }
2666 else
2667 {
2668 run_kernel_amp (device_param, pws_cnt);
2669
2670 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2671
2672 if (opts_type & OPTS_TYPE_HOOK12)
2673 {
2674 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2675 }
2676
2677 uint iter = salt_buf->salt_iter;
2678
2679 uint loop_step = device_param->kernel_loops;
2680
2681 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2682 {
2683 uint loop_left = iter - loop_pos;
2684
2685 loop_left = MIN (loop_left, loop_step);
2686
2687 device_param->kernel_params_buf32[25] = loop_pos;
2688 device_param->kernel_params_buf32[26] = loop_left;
2689
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691
2692 if (data.devices_status == STATUS_CRACKED) break;
2693 if (data.devices_status == STATUS_ABORTED) break;
2694 if (data.devices_status == STATUS_QUIT) break;
2695
2696 /**
2697 * speed
2698 */
2699
2700 const float iter_part = (float) (loop_pos + loop_left) / iter;
2701
2702 const u64 perf_sum_all = pws_cnt * iter_part;
2703
2704 double speed_ms;
2705
2706 hc_timer_get (device_param->timer_speed, speed_ms);
2707
2708 const u32 speed_pos = device_param->speed_pos;
2709
2710 device_param->speed_cnt[speed_pos] = perf_sum_all;
2711
2712 device_param->speed_ms[speed_pos] = speed_ms;
2713
2714 if (data.benchmark == 1)
2715 {
2716 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2717 }
2718 }
2719
2720 if (opts_type & OPTS_TYPE_HOOK23)
2721 {
2722 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2723
2724 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);
2725
2726 // do something with data
2727
2728 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);
2729 }
2730
2731 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2732 }
2733 }
2734
2735 static int run_rule_engine (const int rule_len, const char *rule_buf)
2736 {
2737 if (rule_len == 0)
2738 {
2739 return 0;
2740 }
2741 else if (rule_len == 1)
2742 {
2743 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2744 }
2745
2746 return 1;
2747 }
2748
2749 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2750 {
2751 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2752 {
2753 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);
2754 }
2755 else if (data.attack_kern == ATTACK_KERN_COMBI)
2756 {
2757 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2758 {
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x01;
2768 }
2769 }
2770 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2771 {
2772 for (u32 i = 0; i < pws_cnt; i++)
2773 {
2774 const u32 pw_len = device_param->pws_buf[i].pw_len;
2775
2776 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2777
2778 ptr[pw_len] = 0x80;
2779 }
2780 }
2781 }
2782
2783 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);
2784 }
2785 else if (data.attack_kern == ATTACK_KERN_BF)
2786 {
2787 const u64 off = device_param->words_off;
2788
2789 device_param->kernel_params_mp_l_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2792 }
2793 }
2794
2795 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2796 {
2797 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2798
2799 device_param->kernel_params_buf32[25] = 0;
2800 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2801 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2802
2803 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2804 {
2805 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2806 }
2807 else
2808 {
2809 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2810 }
2811
2812 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2813
2814 return exec_ms_prev;
2815 }
2816
2817 static void autotune (hc_device_param_t *device_param)
2818 {
2819 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2820
2821 const u32 kernel_accel_min = device_param->kernel_accel_min;
2822 const u32 kernel_accel_max = device_param->kernel_accel_max;
2823
2824 const u32 kernel_loops_min = device_param->kernel_loops_min;
2825 const u32 kernel_loops_max = device_param->kernel_loops_max;
2826
2827 u32 kernel_accel = kernel_accel_min;
2828 u32 kernel_loops = kernel_loops_min;
2829
2830 // init some fake words
2831
2832 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2833
2834 for (u32 i = 0; i < kernel_power_max; i++)
2835 {
2836 device_param->pws_buf[i].i[0] = i;
2837 device_param->pws_buf[i].i[1] = 0x01234567;
2838 device_param->pws_buf[i].pw_len = 7;
2839 }
2840
2841 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);
2842
2843 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2844 {
2845 run_kernel_amp (device_param, kernel_power_max);
2846 }
2847
2848 // begin actual testing
2849
2850 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2851
2852 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2853 {
2854 // we do this in case the user specified a fixed -u and -n on the commandline
2855 // so we have a cached kernel for benchmark
2856
2857 try_run (device_param, kernel_accel, kernel_loops);
2858 try_run (device_param, kernel_accel, kernel_loops);
2859 try_run (device_param, kernel_accel, kernel_loops);
2860 try_run (device_param, kernel_accel, kernel_loops);
2861 try_run (device_param, kernel_accel, kernel_loops);
2862 }
2863
2864 // first find out highest kernel-loops that stays below target_ms
2865
2866 #define STEPS_CNT 10
2867
2868 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2869 {
2870 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2871
2872 if (exec_ms < target_ms) break;
2873 }
2874
2875 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2876
2877 if (kernel_accel_min < kernel_accel_max)
2878 {
2879 for (int i = 0; i < STEPS_CNT; i++)
2880 {
2881 const u32 kernel_accel_try = 1 << i;
2882
2883 if (kernel_accel_try < kernel_accel_min) continue;
2884 if (kernel_accel_try > kernel_accel_max) break;
2885
2886 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2887
2888 if (exec_ms > target_ms) break;
2889
2890 exec_ms_final = exec_ms;
2891
2892 kernel_accel = kernel_accel_try;
2893 }
2894 }
2895
2896 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2897 // in such a case the above function would not create any change
2898 // we'll use the runtime to find out if we're allow to do last improvement
2899
2900 if (exec_ms_final > 0)
2901 {
2902 if ((exec_ms_final * 2) <= target_ms)
2903 {
2904 const double exec_left = target_ms / exec_ms_final;
2905
2906 const double accel_left = kernel_accel_max / kernel_accel;
2907
2908 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2909
2910 if (exec_accel_min >= 2)
2911 {
2912 kernel_accel *= exec_accel_min;
2913 }
2914 }
2915 }
2916
2917 // sometimes we're in a bad situation that the algorithm is so slow that we can not
2918 // create enough kernel_accel to do both, keep the gpu busy and stay below target_ms.
2919 // however, we need to have a minimum kernel_accel and kernel_loops of 32.
2920 // luckily, at this level of workload, it became a linear function
2921
2922 if (kernel_accel < 32 || kernel_loops < 32)
2923 {
2924 const u32 kernel_power = kernel_accel * kernel_loops;
2925
2926 // find sqrt
2927
2928 u32 sqrtv;
2929
2930 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2931 {
2932 if ((sqrtv * sqrtv) >= kernel_power) break;
2933 }
2934
2935 const u32 kernel_accel_try = sqrtv;
2936 const u32 kernel_loops_try = sqrtv;
2937
2938 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2939 {
2940 kernel_accel = kernel_accel_try;
2941 kernel_loops = kernel_loops_try;
2942 }
2943 }
2944
2945 // reset fake words
2946
2947 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2948
2949 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);
2950 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);
2951
2952 // reset timer
2953
2954 device_param->exec_pos = 0;
2955
2956 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2957
2958 // store
2959
2960 device_param->kernel_accel = kernel_accel;
2961 device_param->kernel_loops = kernel_loops;
2962
2963 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2964
2965 device_param->kernel_power = kernel_power;
2966
2967 #ifdef DEBUG
2968
2969 if (data.quiet == 0)
2970 {
2971 clear_prompt ();
2972
2973 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2974 "Device #%u: autotuned kernel-loops to %u\n",
2975 device_param->device_id + 1, kernel_accel,
2976 device_param->device_id + 1, kernel_loops);
2977
2978 fprintf (stdout, "%s", PROMPT);
2979
2980 fflush (stdout);
2981 }
2982
2983 #endif
2984 }
2985
2986 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
2987 {
2988 char *line_buf = (char *) mymalloc (HCBUFSIZ);
2989
2990 // init speed timer
2991
2992 uint speed_pos = device_param->speed_pos;
2993
2994 #ifdef _POSIX
2995 if (device_param->timer_speed.tv_sec == 0)
2996 {
2997 hc_timer_set (&device_param->timer_speed);
2998 }
2999 #endif
3000
3001 #ifdef _WIN
3002 if (device_param->timer_speed.QuadPart == 0)
3003 {
3004 hc_timer_set (&device_param->timer_speed);
3005 }
3006 #endif
3007
3008 // find higest password length, this is for optimization stuff
3009
3010 uint highest_pw_len = 0;
3011
3012 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3013 {
3014 }
3015 else if (data.attack_kern == ATTACK_KERN_COMBI)
3016 {
3017 }
3018 else if (data.attack_kern == ATTACK_KERN_BF)
3019 {
3020 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3021 + device_param->kernel_params_mp_l_buf32[5];
3022 }
3023
3024 // iteration type
3025
3026 uint innerloop_step = 0;
3027 uint innerloop_cnt = 0;
3028
3029 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3030 else innerloop_step = 1;
3031
3032 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3033 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3034 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3035
3036 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3037
3038 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3039 {
3040 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3041
3042 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3043
3044 if (data.devices_status == STATUS_CRACKED) break;
3045 if (data.devices_status == STATUS_ABORTED) break;
3046 if (data.devices_status == STATUS_QUIT) break;
3047 if (data.devices_status == STATUS_BYPASS) break;
3048
3049 salt_t *salt_buf = &data.salts_buf[salt_pos];
3050
3051 device_param->kernel_params_buf32[24] = salt_pos;
3052 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3053 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3054
3055 FILE *combs_fp = device_param->combs_fp;
3056
3057 if (data.attack_mode == ATTACK_MODE_COMBI)
3058 {
3059 rewind (combs_fp);
3060 }
3061
3062 // innerloops
3063
3064 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3065 {
3066 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3067
3068 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3069
3070 if (data.devices_status == STATUS_CRACKED) break;
3071 if (data.devices_status == STATUS_ABORTED) break;
3072 if (data.devices_status == STATUS_QUIT) break;
3073 if (data.devices_status == STATUS_BYPASS) break;
3074
3075 uint innerloop_left = innerloop_cnt - innerloop_pos;
3076
3077 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3078
3079 device_param->innerloop_pos = innerloop_pos;
3080 device_param->innerloop_left = innerloop_left;
3081
3082 device_param->kernel_params_buf32[27] = innerloop_left;
3083
3084 // i think we can get rid of this
3085 if (innerloop_left == 0)
3086 {
3087 puts ("bug, how should this happen????\n");
3088
3089 continue;
3090 }
3091
3092 if (data.salts_shown[salt_pos] == 1)
3093 {
3094 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3095
3096 continue;
3097 }
3098
3099 // initialize amplifiers
3100
3101 if (data.attack_mode == ATTACK_MODE_COMBI)
3102 {
3103 uint i = 0;
3104
3105 while (i < innerloop_left)
3106 {
3107 if (feof (combs_fp)) break;
3108
3109 int line_len = fgetl (combs_fp, line_buf);
3110
3111 if (line_len >= PW_MAX1) continue;
3112
3113 line_len = convert_from_hex (line_buf, line_len);
3114
3115 char *line_buf_new = line_buf;
3116
3117 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3118 {
3119 char rule_buf_out[BLOCK_SIZE] = { 0 };
3120
3121 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3122
3123 if (rule_len_out < 0)
3124 {
3125 data.words_progress_rejected[salt_pos] += pws_cnt;
3126
3127 continue;
3128 }
3129
3130 line_len = rule_len_out;
3131
3132 line_buf_new = rule_buf_out;
3133 }
3134
3135 line_len = MIN (line_len, PW_DICTMAX);
3136
3137 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3138
3139 memcpy (ptr, line_buf_new, line_len);
3140
3141 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3142
3143 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3144 {
3145 uppercase (ptr, line_len);
3146 }
3147
3148 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3149 {
3150 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3151 {
3152 ptr[line_len] = 0x80;
3153 }
3154
3155 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3156 {
3157 ptr[line_len] = 0x01;
3158 }
3159 }
3160
3161 device_param->combs_buf[i].pw_len = line_len;
3162
3163 i++;
3164 }
3165
3166 for (uint j = i; j < innerloop_left; j++)
3167 {
3168 device_param->combs_buf[j].i[0] = 0;
3169 device_param->combs_buf[j].i[1] = 0;
3170 device_param->combs_buf[j].i[2] = 0;
3171 device_param->combs_buf[j].i[3] = 0;
3172 device_param->combs_buf[j].i[4] = 0;
3173 device_param->combs_buf[j].i[5] = 0;
3174 device_param->combs_buf[j].i[6] = 0;
3175 device_param->combs_buf[j].i[7] = 0;
3176
3177 device_param->combs_buf[j].pw_len = 0;
3178 }
3179
3180 innerloop_left = i;
3181 }
3182 else if (data.attack_mode == ATTACK_MODE_BF)
3183 {
3184 u64 off = innerloop_pos;
3185
3186 device_param->kernel_params_mp_r_buf64[3] = off;
3187
3188 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3189 }
3190 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3191 {
3192 u64 off = innerloop_pos;
3193
3194 device_param->kernel_params_mp_buf64[3] = off;
3195
3196 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3197 }
3198 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3199 {
3200 u64 off = innerloop_pos;
3201
3202 device_param->kernel_params_mp_buf64[3] = off;
3203
3204 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3205 }
3206
3207 // copy amplifiers
3208
3209 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3210 {
3211 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);
3212 }
3213 else if (data.attack_mode == ATTACK_MODE_COMBI)
3214 {
3215 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);
3216 }
3217 else if (data.attack_mode == ATTACK_MODE_BF)
3218 {
3219 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);
3220 }
3221 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3222 {
3223 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);
3224 }
3225 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3226 {
3227 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);
3228 }
3229
3230 if (data.benchmark == 1)
3231 {
3232 hc_timer_set (&device_param->timer_speed);
3233 }
3234
3235 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3236
3237 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3238
3239 if (data.devices_status == STATUS_CRACKED) break;
3240 if (data.devices_status == STATUS_ABORTED) break;
3241 if (data.devices_status == STATUS_QUIT) break;
3242
3243 /**
3244 * result
3245 */
3246
3247 hc_thread_mutex_lock (mux_display);
3248
3249 check_cracked (device_param, salt_pos);
3250
3251 hc_thread_mutex_unlock (mux_display);
3252
3253 /**
3254 * progress
3255 */
3256
3257 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3258
3259 hc_thread_mutex_lock (mux_counter);
3260
3261 data.words_progress_done[salt_pos] += perf_sum_all;
3262
3263 hc_thread_mutex_unlock (mux_counter);
3264
3265 /**
3266 * speed
3267 */
3268
3269 double speed_ms;
3270
3271 hc_timer_get (device_param->timer_speed, speed_ms);
3272
3273 hc_timer_set (&device_param->timer_speed);
3274
3275 hc_thread_mutex_lock (mux_display);
3276
3277 // current speed
3278
3279 device_param->speed_cnt[speed_pos] = perf_sum_all;
3280
3281 device_param->speed_ms[speed_pos] = speed_ms;
3282
3283 hc_thread_mutex_unlock (mux_display);
3284
3285 speed_pos++;
3286
3287 if (speed_pos == SPEED_CACHE)
3288 {
3289 speed_pos = 0;
3290 }
3291
3292 /**
3293 * benchmark
3294 */
3295
3296 if (data.benchmark == 1) break;
3297 }
3298 }
3299
3300 device_param->speed_pos = speed_pos;
3301
3302 myfree (line_buf);
3303 }
3304
3305 static void load_segment (wl_data_t *wl_data, FILE *fd)
3306 {
3307 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3308
3309 wl_data->pos = 0;
3310
3311 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3312
3313 wl_data->buf[wl_data->cnt] = 0;
3314
3315 if (wl_data->cnt == 0) return;
3316
3317 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3318
3319 while (!feof (fd))
3320 {
3321 if (wl_data->cnt == wl_data->avail)
3322 {
3323 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3324
3325 wl_data->avail += wl_data->incr;
3326 }
3327
3328 const int c = fgetc (fd);
3329
3330 if (c == EOF) break;
3331
3332 wl_data->buf[wl_data->cnt] = (char) c;
3333
3334 wl_data->cnt++;
3335
3336 if (c == '\n') break;
3337 }
3338
3339 // ensure stream ends with a newline
3340
3341 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3342 {
3343 wl_data->cnt++;
3344
3345 wl_data->buf[wl_data->cnt - 1] = '\n';
3346 }
3347
3348 return;
3349 }
3350
3351 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3352 {
3353 char *ptr = buf;
3354
3355 for (u32 i = 0; i < sz; i++, ptr++)
3356 {
3357 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3358
3359 if (i == 7)
3360 {
3361 *off = i;
3362 *len = i;
3363
3364 return;
3365 }
3366
3367 if (*ptr != '\n') continue;
3368
3369 *off = i + 1;
3370
3371 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3372
3373 *len = i;
3374
3375 return;
3376 }
3377
3378 *off = sz;
3379 *len = sz;
3380 }
3381
3382 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3383 {
3384 char *ptr = buf;
3385
3386 for (u32 i = 0; i < sz; i++, ptr++)
3387 {
3388 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
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_std (char *buf, u32 sz, u32 *len, u32 *off)
3406 {
3407 char *ptr = buf;
3408
3409 for (u32 i = 0; i < sz; i++, ptr++)
3410 {
3411 if (*ptr != '\n') continue;
3412
3413 *off = i + 1;
3414
3415 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3416
3417 *len = i;
3418
3419 return;
3420 }
3421
3422 *off = sz;
3423 *len = sz;
3424 }
3425
3426 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3427 {
3428 while (wl_data->pos < wl_data->cnt)
3429 {
3430 uint off;
3431 uint len;
3432
3433 char *ptr = wl_data->buf + wl_data->pos;
3434
3435 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3436
3437 wl_data->pos += off;
3438
3439 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3440 {
3441 char rule_buf_out[BLOCK_SIZE] = { 0 };
3442
3443 int rule_len_out = -1;
3444
3445 if (len < BLOCK_SIZE)
3446 {
3447 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3448 }
3449
3450 if (rule_len_out < 0)
3451 {
3452 continue;
3453 }
3454
3455 if (rule_len_out > PW_MAX)
3456 {
3457 continue;
3458 }
3459 }
3460 else
3461 {
3462 if (len > PW_MAX)
3463 {
3464 continue;
3465 }
3466 }
3467
3468 *out_buf = ptr;
3469 *out_len = len;
3470
3471 return;
3472 }
3473
3474 if (feof (fd))
3475 {
3476 fprintf (stderr, "BUG feof()!!\n");
3477
3478 return;
3479 }
3480
3481 load_segment (wl_data, fd);
3482
3483 get_next_word (wl_data, fd, out_buf, out_len);
3484 }
3485
3486 #ifdef _POSIX
3487 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3488 #endif
3489
3490 #ifdef _WIN
3491 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3492 #endif
3493 {
3494 hc_signal (NULL);
3495
3496 dictstat_t d;
3497
3498 d.cnt = 0;
3499
3500 #ifdef _POSIX
3501 fstat (fileno (fd), &d.stat);
3502 #endif
3503
3504 #ifdef _WIN
3505 _fstat64 (fileno (fd), &d.stat);
3506 #endif
3507
3508 d.stat.st_mode = 0;
3509 d.stat.st_nlink = 0;
3510 d.stat.st_uid = 0;
3511 d.stat.st_gid = 0;
3512 d.stat.st_rdev = 0;
3513 d.stat.st_atime = 0;
3514
3515 #ifdef _POSIX
3516 d.stat.st_blksize = 0;
3517 d.stat.st_blocks = 0;
3518 #endif
3519
3520 if (d.stat.st_size == 0) return 0;
3521
3522 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3523
3524 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3525 {
3526 if (d_cache)
3527 {
3528 u64 cnt = d_cache->cnt;
3529
3530 u64 keyspace = cnt;
3531
3532 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3533 {
3534 keyspace *= data.kernel_rules_cnt;
3535 }
3536 else if (data.attack_kern == ATTACK_KERN_COMBI)
3537 {
3538 keyspace *= data.combs_cnt;
3539 }
3540
3541 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);
3542 if (data.quiet == 0) log_info ("");
3543
3544 hc_signal (sigHandler_default);
3545
3546 return (keyspace);
3547 }
3548 }
3549
3550 time_t now = 0;
3551 time_t prev = 0;
3552
3553 u64 comp = 0;
3554 u64 cnt = 0;
3555 u64 cnt2 = 0;
3556
3557 while (!feof (fd))
3558 {
3559 load_segment (wl_data, fd);
3560
3561 comp += wl_data->cnt;
3562
3563 u32 i = 0;
3564
3565 while (i < wl_data->cnt)
3566 {
3567 u32 len;
3568 u32 off;
3569
3570 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3571
3572 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = -1;
3577
3578 if (len < BLOCK_SIZE)
3579 {
3580 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3581 }
3582
3583 if (rule_len_out < 0)
3584 {
3585 len = PW_MAX1;
3586 }
3587 else
3588 {
3589 len = rule_len_out;
3590 }
3591 }
3592
3593 if (len < PW_MAX1)
3594 {
3595 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3596 {
3597 cnt += data.kernel_rules_cnt;
3598 }
3599 else if (data.attack_kern == ATTACK_KERN_COMBI)
3600 {
3601 cnt += data.combs_cnt;
3602 }
3603
3604 d.cnt++;
3605 }
3606
3607 i += off;
3608
3609 cnt2++;
3610 }
3611
3612 time (&now);
3613
3614 if ((now - prev) == 0) continue;
3615
3616 float percent = (float) comp / (float) d.stat.st_size;
3617
3618 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);
3619
3620 time (&prev);
3621 }
3622
3623 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);
3624 if (data.quiet == 0) log_info ("");
3625
3626 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3627
3628 hc_signal (sigHandler_default);
3629
3630 return (cnt);
3631 }
3632
3633 static void *thread_monitor (void *p)
3634 {
3635 uint runtime_check = 0;
3636 uint remove_check = 0;
3637 uint status_check = 0;
3638 uint restore_check = 0;
3639
3640 uint restore_left = data.restore_timer;
3641 uint remove_left = data.remove_timer;
3642 uint status_left = data.status_timer;
3643
3644 #ifdef HAVE_HWMON
3645 uint hwmon_check = 0;
3646
3647 // these variables are mainly used for fan control (AMD only)
3648
3649 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3650
3651 // temperature controller "loopback" values
3652
3653 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3654 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3655
3656 #ifdef HAVE_ADL
3657 int temp_threshold = 1; // degrees celcius
3658
3659 int fan_speed_min = 15; // in percentage
3660 int fan_speed_max = 100;
3661 #endif // HAVE_ADL
3662
3663 time_t last_temp_check_time;
3664 #endif // HAVE_HWMON
3665
3666 uint sleep_time = 1;
3667
3668 if (data.runtime)
3669 {
3670 runtime_check = 1;
3671 }
3672
3673 if (data.restore_timer)
3674 {
3675 restore_check = 1;
3676 }
3677
3678 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3679 {
3680 remove_check = 1;
3681 }
3682
3683 if (data.status == 1)
3684 {
3685 status_check = 1;
3686 }
3687
3688 #ifdef HAVE_HWMON
3689 if (data.gpu_temp_disable == 0)
3690 {
3691 time (&last_temp_check_time);
3692
3693 hwmon_check = 1;
3694 }
3695 #endif
3696
3697 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3698 {
3699 #ifdef HAVE_HWMON
3700 if (hwmon_check == 0)
3701 #endif
3702 return (p);
3703 }
3704
3705 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3706 {
3707 hc_sleep (sleep_time);
3708
3709 if (data.devices_status != STATUS_RUNNING) continue;
3710
3711 #ifdef HAVE_HWMON
3712 if (hwmon_check == 1)
3713 {
3714 hc_thread_mutex_lock (mux_adl);
3715
3716 time_t temp_check_time;
3717
3718 time (&temp_check_time);
3719
3720 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3721
3722 if (Ta == 0) Ta = 1;
3723
3724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3725 {
3726 hc_device_param_t *device_param = &data.devices_param[device_id];
3727
3728 if (device_param->skipped) continue;
3729
3730 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3731
3732 const int temperature = hm_get_temperature_with_device_id (device_id);
3733
3734 if (temperature > (int) data.gpu_temp_abort)
3735 {
3736 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3737
3738 if (data.devices_status != STATUS_QUIT) myabort ();
3739
3740 break;
3741 }
3742
3743 #ifdef HAVE_ADL
3744 const int gpu_temp_retain = data.gpu_temp_retain;
3745
3746 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3747 {
3748 if (data.hm_device[device_id].fan_supported == 1)
3749 {
3750 int temp_cur = temperature;
3751
3752 int temp_diff_new = gpu_temp_retain - temp_cur;
3753
3754 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3755
3756 // calculate Ta value (time difference in seconds between the last check and this check)
3757
3758 last_temp_check_time = temp_check_time;
3759
3760 float Kp = 1.8;
3761 float Ki = 0.005;
3762 float Kd = 6;
3763
3764 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3765
3766 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);
3767
3768 if (abs (fan_diff_required) >= temp_threshold)
3769 {
3770 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3771
3772 int fan_speed_level = fan_speed_cur;
3773
3774 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3775
3776 int fan_speed_new = fan_speed_level - fan_diff_required;
3777
3778 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3779 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3780
3781 if (fan_speed_new != fan_speed_cur)
3782 {
3783 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3784 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3785
3786 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3787 {
3788 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3789
3790 fan_speed_chgd[device_id] = 1;
3791 }
3792
3793 temp_diff_old[device_id] = temp_diff_new;
3794 }
3795 }
3796 }
3797 }
3798 #endif // HAVE_ADL
3799 }
3800
3801 hc_thread_mutex_unlock (mux_adl);
3802 }
3803 #endif // HAVE_HWMON
3804
3805 if (restore_check == 1)
3806 {
3807 restore_left--;
3808
3809 if (restore_left == 0)
3810 {
3811 if (data.restore_disable == 0) cycle_restore ();
3812
3813 restore_left = data.restore_timer;
3814 }
3815 }
3816
3817 if ((runtime_check == 1) && (data.runtime_start > 0))
3818 {
3819 time_t runtime_cur;
3820
3821 time (&runtime_cur);
3822
3823 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3824
3825 if (runtime_left <= 0)
3826 {
3827 if (data.benchmark == 0)
3828 {
3829 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3830 }
3831
3832 if (data.devices_status != STATUS_QUIT) myabort ();
3833 }
3834 }
3835
3836 if (remove_check == 1)
3837 {
3838 remove_left--;
3839
3840 if (remove_left == 0)
3841 {
3842 if (data.digests_saved != data.digests_done)
3843 {
3844 data.digests_saved = data.digests_done;
3845
3846 save_hash ();
3847 }
3848
3849 remove_left = data.remove_timer;
3850 }
3851 }
3852
3853 if (status_check == 1)
3854 {
3855 status_left--;
3856
3857 if (status_left == 0)
3858 {
3859 hc_thread_mutex_lock (mux_display);
3860
3861 if (data.quiet == 0) clear_prompt ();
3862
3863 if (data.quiet == 0) log_info ("");
3864
3865 status_display ();
3866
3867 if (data.quiet == 0) log_info ("");
3868
3869 hc_thread_mutex_unlock (mux_display);
3870
3871 status_left = data.status_timer;
3872 }
3873 }
3874 }
3875
3876 #ifdef HAVE_HWMON
3877 myfree (fan_speed_chgd);
3878
3879 myfree (temp_diff_old);
3880 myfree (temp_diff_sum);
3881 #endif
3882
3883 p = NULL;
3884
3885 return (p);
3886 }
3887
3888 static void *thread_outfile_remove (void *p)
3889 {
3890 // some hash-dependent constants
3891 char *outfile_dir = data.outfile_check_directory;
3892 uint dgst_size = data.dgst_size;
3893 uint isSalted = data.isSalted;
3894 uint esalt_size = data.esalt_size;
3895 uint hash_mode = data.hash_mode;
3896
3897 uint outfile_check_timer = data.outfile_check_timer;
3898
3899 char separator = data.separator;
3900
3901 // some hash-dependent functions
3902 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3903 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3904
3905 // buffers
3906 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3907
3908 hash_buf.digest = mymalloc (dgst_size);
3909
3910 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3911
3912 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3913
3914 uint digest_buf[64] = { 0 };
3915
3916 outfile_data_t *out_info = NULL;
3917
3918 char **out_files = NULL;
3919
3920 time_t folder_mtime = 0;
3921
3922 int out_cnt = 0;
3923
3924 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3925
3926 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3927 {
3928 hc_sleep (1);
3929
3930 if (data.devices_status != STATUS_RUNNING) continue;
3931
3932 check_left--;
3933
3934 if (check_left == 0)
3935 {
3936 struct stat outfile_check_stat;
3937
3938 if (stat (outfile_dir, &outfile_check_stat) == 0)
3939 {
3940 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3941
3942 if (is_dir == 1)
3943 {
3944 if (outfile_check_stat.st_mtime > folder_mtime)
3945 {
3946 char **out_files_new = scan_directory (outfile_dir);
3947
3948 int out_cnt_new = count_dictionaries (out_files_new);
3949
3950 outfile_data_t *out_info_new = NULL;
3951
3952 if (out_cnt_new > 0)
3953 {
3954 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3955
3956 for (int i = 0; i < out_cnt_new; i++)
3957 {
3958 out_info_new[i].file_name = out_files_new[i];
3959
3960 // check if there are files that we have seen/checked before (and not changed)
3961
3962 for (int j = 0; j < out_cnt; j++)
3963 {
3964 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3965 {
3966 struct stat outfile_stat;
3967
3968 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3969 {
3970 if (outfile_stat.st_ctime == out_info[j].ctime)
3971 {
3972 out_info_new[i].ctime = out_info[j].ctime;
3973 out_info_new[i].seek = out_info[j].seek;
3974 }
3975 }
3976 }
3977 }
3978 }
3979 }
3980
3981 local_free (out_info);
3982 local_free (out_files);
3983
3984 out_files = out_files_new;
3985 out_cnt = out_cnt_new;
3986 out_info = out_info_new;
3987
3988 folder_mtime = outfile_check_stat.st_mtime;
3989 }
3990
3991 for (int j = 0; j < out_cnt; j++)
3992 {
3993 FILE *fp = fopen (out_info[j].file_name, "rb");
3994
3995 if (fp != NULL)
3996 {
3997 //hc_thread_mutex_lock (mux_display);
3998
3999 #ifdef _POSIX
4000 struct stat outfile_stat;
4001
4002 fstat (fileno (fp), &outfile_stat);
4003 #endif
4004
4005 #ifdef _WIN
4006 struct stat64 outfile_stat;
4007
4008 _fstat64 (fileno (fp), &outfile_stat);
4009 #endif
4010
4011 if (outfile_stat.st_ctime > out_info[j].ctime)
4012 {
4013 out_info[j].ctime = outfile_stat.st_ctime;
4014 out_info[j].seek = 0;
4015 }
4016
4017 fseek (fp, out_info[j].seek, SEEK_SET);
4018
4019 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4020
4021 while (!feof (fp))
4022 {
4023 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4024
4025 if (ptr == NULL) break;
4026
4027 int line_len = strlen (line_buf);
4028
4029 if (line_len <= 0) continue;
4030
4031 int iter = MAX_CUT_TRIES;
4032
4033 for (uint i = line_len - 1; i && iter; i--, line_len--)
4034 {
4035 if (line_buf[i] != separator) continue;
4036
4037 int parser_status = PARSER_OK;
4038
4039 if ((hash_mode != 2500) && (hash_mode != 6800))
4040 {
4041 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4042 }
4043
4044 uint found = 0;
4045
4046 if (parser_status == PARSER_OK)
4047 {
4048 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4049 {
4050 if (data.salts_shown[salt_pos] == 1) continue;
4051
4052 salt_t *salt_buf = &data.salts_buf[salt_pos];
4053
4054 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4055 {
4056 uint idx = salt_buf->digests_offset + digest_pos;
4057
4058 if (data.digests_shown[idx] == 1) continue;
4059
4060 uint cracked = 0;
4061
4062 if (hash_mode == 6800)
4063 {
4064 if (i == salt_buf->salt_len)
4065 {
4066 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4067 }
4068 }
4069 else if (hash_mode == 2500)
4070 {
4071 // BSSID : MAC1 : MAC2 (:plain)
4072 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4073 {
4074 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4075
4076 if (!cracked) continue;
4077
4078 // now compare MAC1 and MAC2 too, since we have this additional info
4079 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4080 char *mac2_pos = mac1_pos + 12 + 1;
4081
4082 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4083 wpa_t *wpa = &wpas[salt_pos];
4084
4085 // compare hex string(s) vs binary MAC address(es)
4086
4087 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4088 {
4089 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4090 {
4091 cracked = 0;
4092
4093 break;
4094 }
4095 }
4096
4097 // early skip ;)
4098 if (!cracked) continue;
4099
4100 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4101 {
4102 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4103 {
4104 cracked = 0;
4105
4106 break;
4107 }
4108 }
4109 }
4110 }
4111 else
4112 {
4113 char *digests_buf_ptr = (char *) data.digests_buf;
4114
4115 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4116
4117 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4118 }
4119
4120 if (cracked == 1)
4121 {
4122 found = 1;
4123
4124 data.digests_shown[idx] = 1;
4125
4126 data.digests_done++;
4127
4128 salt_buf->digests_done++;
4129
4130 if (salt_buf->digests_done == salt_buf->digests_cnt)
4131 {
4132 data.salts_shown[salt_pos] = 1;
4133
4134 data.salts_done++;
4135
4136 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4137 }
4138 }
4139 }
4140
4141 if (data.devices_status == STATUS_CRACKED) break;
4142 }
4143 }
4144
4145 if (found) break;
4146
4147 if (data.devices_status == STATUS_CRACKED) break;
4148
4149 iter--;
4150 }
4151
4152 if (data.devices_status == STATUS_CRACKED) break;
4153 }
4154
4155 myfree (line_buf);
4156
4157 out_info[j].seek = ftell (fp);
4158
4159 //hc_thread_mutex_unlock (mux_display);
4160
4161 fclose (fp);
4162 }
4163 }
4164 }
4165 }
4166
4167 check_left = outfile_check_timer;
4168 }
4169 }
4170
4171 if (esalt_size) local_free (hash_buf.esalt);
4172
4173 if (isSalted) local_free (hash_buf.salt);
4174
4175 local_free (hash_buf.digest);
4176
4177 local_free (out_info);
4178
4179 local_free (out_files);
4180
4181 p = NULL;
4182
4183 return (p);
4184 }
4185
4186 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4187 {
4188 if (device_param->pws_cnt < device_param->kernel_power)
4189 {
4190 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4191
4192 u8 *ptr = (u8 *) pw->i;
4193
4194 memcpy (ptr, pw_buf, pw_len);
4195
4196 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4197
4198 pw->pw_len = pw_len;
4199
4200 device_param->pws_cnt++;
4201 }
4202 else
4203 {
4204 fprintf (stderr, "BUG pw_add()!!\n");
4205
4206 return;
4207 }
4208 }
4209
4210 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4211 {
4212 hc_thread_mutex_lock (mux_dispatcher);
4213
4214 const u64 words_cur = data.words_cur;
4215 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4216
4217 device_param->words_off = words_cur;
4218
4219 const u64 words_left = words_base - words_cur;
4220
4221 if (allow_div)
4222 {
4223 if (data.kernel_power_all > words_left)
4224 {
4225 if (data.kernel_power_div == 0)
4226 {
4227 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4228 }
4229 }
4230
4231 if (data.kernel_power_div)
4232 {
4233 if (device_param->kernel_power == device_param->kernel_power_user)
4234 {
4235 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4236
4237 if (kernel_power_new < device_param->kernel_power)
4238 {
4239 device_param->kernel_power = kernel_power_new;
4240 }
4241 }
4242 }
4243 }
4244
4245 const uint kernel_power = device_param->kernel_power;
4246
4247 uint work = MIN (words_left, kernel_power);
4248
4249 work = MIN (work, max);
4250
4251 data.words_cur += work;
4252
4253 hc_thread_mutex_unlock (mux_dispatcher);
4254
4255 return work;
4256 }
4257
4258 static void *thread_calc_stdin (void *p)
4259 {
4260 hc_device_param_t *device_param = (hc_device_param_t *) p;
4261
4262 if (device_param->skipped) return NULL;
4263
4264 autotune (device_param);
4265
4266 char *buf = (char *) mymalloc (HCBUFSIZ);
4267
4268 const uint attack_kern = data.attack_kern;
4269
4270 const uint kernel_power = device_param->kernel_power;
4271
4272 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4273 {
4274 hc_thread_mutex_lock (mux_dispatcher);
4275
4276 if (feof (stdin) != 0)
4277 {
4278 hc_thread_mutex_unlock (mux_dispatcher);
4279
4280 break;
4281 }
4282
4283 uint words_cur = 0;
4284
4285 while (words_cur < kernel_power)
4286 {
4287 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4288
4289 if (line_buf == NULL) break;
4290
4291 uint line_len = in_superchop (line_buf);
4292
4293 line_len = convert_from_hex (line_buf, line_len);
4294
4295 // post-process rule engine
4296
4297 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4298 {
4299 char rule_buf_out[BLOCK_SIZE] = { 0 };
4300
4301 int rule_len_out = -1;
4302
4303 if (line_len < BLOCK_SIZE)
4304 {
4305 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4306 }
4307
4308 if (rule_len_out < 0) continue;
4309
4310 line_buf = rule_buf_out;
4311 line_len = rule_len_out;
4312 }
4313
4314 if (line_len > PW_MAX)
4315 {
4316 continue;
4317 }
4318
4319 if (attack_kern == ATTACK_KERN_STRAIGHT)
4320 {
4321 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4322 {
4323 hc_thread_mutex_lock (mux_counter);
4324
4325 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4326 {
4327 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4328 }
4329
4330 hc_thread_mutex_unlock (mux_counter);
4331
4332 continue;
4333 }
4334 }
4335 else if (attack_kern == ATTACK_KERN_COMBI)
4336 {
4337 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4338 // since we still need to combine the plains
4339
4340 if (line_len > data.pw_max)
4341 {
4342 hc_thread_mutex_lock (mux_counter);
4343
4344 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4345 {
4346 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4347 }
4348
4349 hc_thread_mutex_unlock (mux_counter);
4350
4351 continue;
4352 }
4353 }
4354
4355 pw_add (device_param, (u8 *) line_buf, line_len);
4356
4357 words_cur++;
4358
4359 if (data.devices_status == STATUS_CRACKED) break;
4360 if (data.devices_status == STATUS_ABORTED) break;
4361 if (data.devices_status == STATUS_QUIT) break;
4362 if (data.devices_status == STATUS_BYPASS) break;
4363 }
4364
4365 hc_thread_mutex_unlock (mux_dispatcher);
4366
4367 if (data.devices_status == STATUS_CRACKED) break;
4368 if (data.devices_status == STATUS_ABORTED) break;
4369 if (data.devices_status == STATUS_QUIT) break;
4370 if (data.devices_status == STATUS_BYPASS) break;
4371
4372 // flush
4373
4374 const uint pws_cnt = device_param->pws_cnt;
4375
4376 if (pws_cnt)
4377 {
4378 run_copy (device_param, pws_cnt);
4379
4380 run_cracker (device_param, pws_cnt);
4381
4382 device_param->pws_cnt = 0;
4383
4384 if (attack_kern == ATTACK_KERN_STRAIGHT)
4385 {
4386 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4387 }
4388 else if (attack_kern == ATTACK_KERN_COMBI)
4389 {
4390 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4391 }
4392 }
4393 }
4394
4395 device_param->kernel_accel = 0;
4396 device_param->kernel_loops = 0;
4397
4398 myfree (buf);
4399
4400 return NULL;
4401 }
4402
4403 static void *thread_calc (void *p)
4404 {
4405 hc_device_param_t *device_param = (hc_device_param_t *) p;
4406
4407 if (device_param->skipped) return NULL;
4408
4409 autotune (device_param);
4410
4411 const uint attack_mode = data.attack_mode;
4412 const uint attack_kern = data.attack_kern;
4413
4414 if (attack_mode == ATTACK_MODE_BF)
4415 {
4416 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4417 {
4418 const uint work = get_work (device_param, -1, true);
4419
4420 if (work == 0) break;
4421
4422 const u64 words_off = device_param->words_off;
4423 const u64 words_fin = words_off + work;
4424
4425 const uint pws_cnt = work;
4426
4427 device_param->pws_cnt = pws_cnt;
4428
4429 if (pws_cnt)
4430 {
4431 run_copy (device_param, pws_cnt);
4432
4433 run_cracker (device_param, pws_cnt);
4434
4435 device_param->pws_cnt = 0;
4436
4437 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4438 }
4439
4440 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4441
4442 if (data.devices_status == STATUS_CRACKED) break;
4443 if (data.devices_status == STATUS_ABORTED) break;
4444 if (data.devices_status == STATUS_QUIT) break;
4445 if (data.devices_status == STATUS_BYPASS) break;
4446
4447 if (data.benchmark == 1) break;
4448
4449 device_param->words_done = words_fin;
4450 }
4451 }
4452 else
4453 {
4454 const uint segment_size = data.segment_size;
4455
4456 char *dictfile = data.dictfile;
4457
4458 if (attack_mode == ATTACK_MODE_COMBI)
4459 {
4460 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4461 {
4462 dictfile = data.dictfile2;
4463 }
4464 }
4465
4466 FILE *fd = fopen (dictfile, "rb");
4467
4468 if (fd == NULL)
4469 {
4470 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4471
4472 return NULL;
4473 }
4474
4475 if (attack_mode == ATTACK_MODE_COMBI)
4476 {
4477 const uint combs_mode = data.combs_mode;
4478
4479 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4480 {
4481 const char *dictfilec = data.dictfile2;
4482
4483 FILE *combs_fp = fopen (dictfilec, "rb");
4484
4485 if (combs_fp == NULL)
4486 {
4487 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4488
4489 fclose (fd);
4490
4491 return NULL;
4492 }
4493
4494 device_param->combs_fp = combs_fp;
4495 }
4496 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4497 {
4498 const char *dictfilec = data.dictfile;
4499
4500 FILE *combs_fp = fopen (dictfilec, "rb");
4501
4502 if (combs_fp == NULL)
4503 {
4504 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4505
4506 fclose (fd);
4507
4508 return NULL;
4509 }
4510
4511 device_param->combs_fp = combs_fp;
4512 }
4513 }
4514
4515 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4516
4517 wl_data->buf = (char *) mymalloc (segment_size);
4518 wl_data->avail = segment_size;
4519 wl_data->incr = segment_size;
4520 wl_data->cnt = 0;
4521 wl_data->pos = 0;
4522
4523 u64 words_cur = 0;
4524
4525 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4526 {
4527 u64 words_off = 0;
4528 u64 words_fin = 0;
4529
4530 bool allow_div = true;
4531
4532 u64 max = -1;
4533
4534 while (max)
4535 {
4536 const uint work = get_work (device_param, max, allow_div);
4537
4538 allow_div = false;
4539
4540 if (work == 0) break;
4541
4542 words_off = device_param->words_off;
4543 words_fin = words_off + work;
4544
4545 char *line_buf;
4546 uint line_len;
4547
4548 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4549
4550 max = 0;
4551
4552 for ( ; words_cur < words_fin; words_cur++)
4553 {
4554 get_next_word (wl_data, fd, &line_buf, &line_len);
4555
4556 line_len = convert_from_hex (line_buf, line_len);
4557
4558 // post-process rule engine
4559
4560 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4561 {
4562 char rule_buf_out[BLOCK_SIZE] = { 0 };
4563
4564 int rule_len_out = -1;
4565
4566 if (line_len < BLOCK_SIZE)
4567 {
4568 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4569 }
4570
4571 if (rule_len_out < 0) continue;
4572
4573 line_buf = rule_buf_out;
4574 line_len = rule_len_out;
4575 }
4576
4577 if (attack_kern == ATTACK_KERN_STRAIGHT)
4578 {
4579 if ((line_len < data.pw_min) || (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.kernel_rules_cnt;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_counter);
4591
4592 continue;
4593 }
4594 }
4595 else if (attack_kern == ATTACK_KERN_COMBI)
4596 {
4597 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4598 // since we still need to combine the plains
4599
4600 if (line_len > data.pw_max)
4601 {
4602 max++;
4603
4604 hc_thread_mutex_lock (mux_counter);
4605
4606 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4607 {
4608 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4609 }
4610
4611 hc_thread_mutex_unlock (mux_counter);
4612
4613 continue;
4614 }
4615 }
4616
4617 pw_add (device_param, (u8 *) line_buf, line_len);
4618
4619 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4620
4621 if (data.devices_status == STATUS_CRACKED) break;
4622 if (data.devices_status == STATUS_ABORTED) break;
4623 if (data.devices_status == STATUS_QUIT) break;
4624 if (data.devices_status == STATUS_BYPASS) break;
4625 }
4626
4627 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4628
4629 if (data.devices_status == STATUS_CRACKED) break;
4630 if (data.devices_status == STATUS_ABORTED) break;
4631 if (data.devices_status == STATUS_QUIT) break;
4632 if (data.devices_status == STATUS_BYPASS) break;
4633 }
4634
4635 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4636
4637 if (data.devices_status == STATUS_CRACKED) break;
4638 if (data.devices_status == STATUS_ABORTED) break;
4639 if (data.devices_status == STATUS_QUIT) break;
4640 if (data.devices_status == STATUS_BYPASS) break;
4641
4642 //
4643 // flush
4644 //
4645
4646 const uint pws_cnt = device_param->pws_cnt;
4647
4648 if (pws_cnt)
4649 {
4650 run_copy (device_param, pws_cnt);
4651
4652 run_cracker (device_param, pws_cnt);
4653
4654 device_param->pws_cnt = 0;
4655
4656 if (attack_kern == ATTACK_KERN_STRAIGHT)
4657 {
4658 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4659 }
4660 else if (attack_kern == ATTACK_KERN_COMBI)
4661 {
4662 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4663 }
4664 }
4665
4666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4667
4668 if (data.devices_status == STATUS_CRACKED) break;
4669 if (data.devices_status == STATUS_ABORTED) break;
4670 if (data.devices_status == STATUS_QUIT) break;
4671 if (data.devices_status == STATUS_BYPASS) break;
4672
4673 if (words_fin == 0) break;
4674
4675 device_param->words_done = words_fin;
4676 }
4677
4678 if (attack_mode == ATTACK_MODE_COMBI)
4679 {
4680 fclose (device_param->combs_fp);
4681 }
4682
4683 free (wl_data->buf);
4684 free (wl_data);
4685
4686 fclose (fd);
4687 }
4688
4689 device_param->kernel_accel = 0;
4690 device_param->kernel_loops = 0;
4691
4692 return NULL;
4693 }
4694
4695 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4696 {
4697 if (!device_param)
4698 {
4699 log_error ("ERROR: %s : Invalid argument", __func__);
4700
4701 exit (-1);
4702 }
4703
4704 salt_t *salt_buf = &data.salts_buf[salt_pos];
4705
4706 device_param->kernel_params_buf32[24] = salt_pos;
4707 device_param->kernel_params_buf32[27] = 1;
4708 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4709 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4710 device_param->kernel_params_buf32[30] = 0;
4711 device_param->kernel_params_buf32[31] = 1;
4712
4713 char *dictfile_old = data.dictfile;
4714
4715 const char *weak_hash_check = "weak-hash-check";
4716
4717 data.dictfile = (char *) weak_hash_check;
4718
4719 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4720
4721 data.kernel_rules_buf[0].cmds[0] = 0;
4722
4723 /**
4724 * run the kernel
4725 */
4726
4727 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4728 {
4729 run_kernel (KERN_RUN_1, device_param, 1, false);
4730 }
4731 else
4732 {
4733 run_kernel (KERN_RUN_1, device_param, 1, false);
4734
4735 uint loop_step = 16;
4736
4737 const uint iter = salt_buf->salt_iter;
4738
4739 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4740 {
4741 uint loop_left = iter - loop_pos;
4742
4743 loop_left = MIN (loop_left, loop_step);
4744
4745 device_param->kernel_params_buf32[25] = loop_pos;
4746 device_param->kernel_params_buf32[26] = loop_left;
4747
4748 run_kernel (KERN_RUN_2, device_param, 1, false);
4749 }
4750
4751 run_kernel (KERN_RUN_3, device_param, 1, false);
4752 }
4753
4754 /**
4755 * result
4756 */
4757
4758 check_cracked (device_param, salt_pos);
4759
4760 /**
4761 * cleanup
4762 */
4763
4764 device_param->kernel_params_buf32[24] = 0;
4765 device_param->kernel_params_buf32[25] = 0;
4766 device_param->kernel_params_buf32[26] = 0;
4767 device_param->kernel_params_buf32[27] = 0;
4768 device_param->kernel_params_buf32[28] = 0;
4769 device_param->kernel_params_buf32[29] = 0;
4770 device_param->kernel_params_buf32[30] = 0;
4771 device_param->kernel_params_buf32[31] = 0;
4772
4773 data.dictfile = dictfile_old;
4774
4775 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4776 }
4777
4778 // hlfmt hashcat
4779
4780 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4781 {
4782 if (data.username == 0)
4783 {
4784 *hashbuf_pos = line_buf;
4785 *hashbuf_len = line_len;
4786 }
4787 else
4788 {
4789 char *pos = line_buf;
4790 int len = line_len;
4791
4792 for (int i = 0; i < line_len; i++, pos++, len--)
4793 {
4794 if (line_buf[i] == data.separator)
4795 {
4796 pos++;
4797
4798 len--;
4799
4800 break;
4801 }
4802 }
4803
4804 *hashbuf_pos = pos;
4805 *hashbuf_len = len;
4806 }
4807 }
4808
4809 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4810 {
4811 char *pos = NULL;
4812 int len = 0;
4813
4814 int sep_cnt = 0;
4815
4816 for (int i = 0; i < line_len; i++)
4817 {
4818 if (line_buf[i] == data.separator)
4819 {
4820 sep_cnt++;
4821
4822 continue;
4823 }
4824
4825 if (sep_cnt == 0)
4826 {
4827 if (pos == NULL) pos = line_buf + i;
4828
4829 len++;
4830 }
4831 }
4832
4833 *userbuf_pos = pos;
4834 *userbuf_len = len;
4835 }
4836
4837 // hlfmt pwdump
4838
4839 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4840 {
4841 int sep_cnt = 0;
4842
4843 int sep2_len = 0;
4844 int sep3_len = 0;
4845
4846 for (int i = 0; i < line_len; i++)
4847 {
4848 if (line_buf[i] == ':')
4849 {
4850 sep_cnt++;
4851
4852 continue;
4853 }
4854
4855 if (sep_cnt == 2) sep2_len++;
4856 if (sep_cnt == 3) sep3_len++;
4857 }
4858
4859 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4860
4861 return 0;
4862 }
4863
4864 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4865 {
4866 char *pos = NULL;
4867 int len = 0;
4868
4869 int sep_cnt = 0;
4870
4871 for (int i = 0; i < line_len; i++)
4872 {
4873 if (line_buf[i] == ':')
4874 {
4875 sep_cnt++;
4876
4877 continue;
4878 }
4879
4880 if (data.hash_mode == 1000)
4881 {
4882 if (sep_cnt == 3)
4883 {
4884 if (pos == NULL) pos = line_buf + i;
4885
4886 len++;
4887 }
4888 }
4889 else if (data.hash_mode == 3000)
4890 {
4891 if (sep_cnt == 2)
4892 {
4893 if (pos == NULL) pos = line_buf + i;
4894
4895 len++;
4896 }
4897 }
4898 }
4899
4900 *hashbuf_pos = pos;
4901 *hashbuf_len = len;
4902 }
4903
4904 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4905 {
4906 char *pos = NULL;
4907 int len = 0;
4908
4909 int sep_cnt = 0;
4910
4911 for (int i = 0; i < line_len; i++)
4912 {
4913 if (line_buf[i] == ':')
4914 {
4915 sep_cnt++;
4916
4917 continue;
4918 }
4919
4920 if (sep_cnt == 0)
4921 {
4922 if (pos == NULL) pos = line_buf + i;
4923
4924 len++;
4925 }
4926 }
4927
4928 *userbuf_pos = pos;
4929 *userbuf_len = len;
4930 }
4931
4932 // hlfmt passwd
4933
4934 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4935 {
4936 int sep_cnt = 0;
4937
4938 char sep5_first = 0;
4939 char sep6_first = 0;
4940
4941 for (int i = 0; i < line_len; i++)
4942 {
4943 if (line_buf[i] == ':')
4944 {
4945 sep_cnt++;
4946
4947 continue;
4948 }
4949
4950 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4951 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4952 }
4953
4954 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4955
4956 return 0;
4957 }
4958
4959 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4960 {
4961 char *pos = NULL;
4962 int len = 0;
4963
4964 int sep_cnt = 0;
4965
4966 for (int i = 0; i < line_len; i++)
4967 {
4968 if (line_buf[i] == ':')
4969 {
4970 sep_cnt++;
4971
4972 continue;
4973 }
4974
4975 if (sep_cnt == 1)
4976 {
4977 if (pos == NULL) pos = line_buf + i;
4978
4979 len++;
4980 }
4981 }
4982
4983 *hashbuf_pos = pos;
4984 *hashbuf_len = len;
4985 }
4986
4987 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4988 {
4989 char *pos = NULL;
4990 int len = 0;
4991
4992 int sep_cnt = 0;
4993
4994 for (int i = 0; i < line_len; i++)
4995 {
4996 if (line_buf[i] == ':')
4997 {
4998 sep_cnt++;
4999
5000 continue;
5001 }
5002
5003 if (sep_cnt == 0)
5004 {
5005 if (pos == NULL) pos = line_buf + i;
5006
5007 len++;
5008 }
5009 }
5010
5011 *userbuf_pos = pos;
5012 *userbuf_len = len;
5013 }
5014
5015 // hlfmt shadow
5016
5017 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5018 {
5019 int sep_cnt = 0;
5020
5021 for (int i = 0; i < line_len; i++)
5022 {
5023 if (line_buf[i] == ':') sep_cnt++;
5024 }
5025
5026 if (sep_cnt == 8) return 1;
5027
5028 return 0;
5029 }
5030
5031 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5032 {
5033 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5034 }
5035
5036 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5037 {
5038 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5039 }
5040
5041 // hlfmt main
5042
5043 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5044 {
5045 switch (hashfile_format)
5046 {
5047 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5048 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5049 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5050 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5051 }
5052 }
5053
5054 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5055 {
5056 switch (hashfile_format)
5057 {
5058 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5059 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5060 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5061 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5062 }
5063 }
5064
5065 char *strhlfmt (const uint hashfile_format)
5066 {
5067 switch (hashfile_format)
5068 {
5069 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5070 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5071 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5072 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5073 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5074 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5075 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5076 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5077 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5078 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5079 }
5080
5081 return ((char *) "Unknown");
5082 }
5083
5084 static uint hlfmt_detect (FILE *fp, uint max_check)
5085 {
5086 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5087
5088 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5089 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5090
5091 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5092
5093 uint num_check = 0;
5094
5095 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5096
5097 while (!feof (fp))
5098 {
5099 int line_len = fgetl (fp, line_buf);
5100
5101 if (line_len == 0) continue;
5102
5103 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5104 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5105 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5106
5107 if (num_check == max_check) break;
5108
5109 num_check++;
5110 }
5111
5112 myfree (line_buf);
5113
5114 uint hashlist_format = HLFMT_HASHCAT;
5115
5116 for (int i = 1; i < HLFMTS_CNT; i++)
5117 {
5118 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5119
5120 hashlist_format = i;
5121 }
5122
5123 free (formats_cnt);
5124
5125 return hashlist_format;
5126 }
5127
5128 /**
5129 * some further helper function
5130 */
5131
5132 // wrapper around mymalloc for ADL
5133
5134 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5135 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5136 {
5137 return mymalloc (iSize);
5138 }
5139 #endif
5140
5141 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)
5142 {
5143 u64 collisions = 0;
5144
5145 const uint dgst_pos0 = data.dgst_pos0;
5146 const uint dgst_pos1 = data.dgst_pos1;
5147 const uint dgst_pos2 = data.dgst_pos2;
5148 const uint dgst_pos3 = data.dgst_pos3;
5149
5150 memset (bitmap_a, 0, bitmap_size);
5151 memset (bitmap_b, 0, bitmap_size);
5152 memset (bitmap_c, 0, bitmap_size);
5153 memset (bitmap_d, 0, bitmap_size);
5154
5155 for (uint i = 0; i < digests_cnt; i++)
5156 {
5157 uint *digest_ptr = (uint *) digests_buf_ptr;
5158
5159 digests_buf_ptr += dgst_size;
5160
5161 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5162 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5163 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5164 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5165
5166 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5167 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5168 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5169 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5170
5171 if (bitmap_a[idx0] & val0) collisions++;
5172 if (bitmap_b[idx1] & val1) collisions++;
5173 if (bitmap_c[idx2] & val2) collisions++;
5174 if (bitmap_d[idx3] & val3) collisions++;
5175
5176 bitmap_a[idx0] |= val0;
5177 bitmap_b[idx1] |= val1;
5178 bitmap_c[idx2] |= val2;
5179 bitmap_d[idx3] |= val3;
5180
5181 if (collisions >= collisions_max) return 0x7fffffff;
5182 }
5183
5184 return collisions;
5185 }
5186
5187 /**
5188 * main
5189 */
5190
5191 int main (int argc, char **argv)
5192 {
5193 /**
5194 * To help users a bit
5195 */
5196
5197 char *compute = getenv ("COMPUTE");
5198
5199 if (compute)
5200 {
5201 static char display[100];
5202
5203 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5204
5205 putenv (display);
5206 }
5207 else
5208 {
5209 if (getenv ("DISPLAY") == NULL)
5210 putenv ((char *) "DISPLAY=:0");
5211 }
5212
5213 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5214 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5215
5216 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5217 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5218
5219 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5220 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5221
5222 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5223 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5224
5225 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5226 putenv ((char *) "POCL_KERNEL_CACHE=0");
5227
5228 /**
5229 * Real init
5230 */
5231
5232 memset (&data, 0, sizeof (hc_global_data_t));
5233
5234 time_t proc_start;
5235
5236 time (&proc_start);
5237
5238 data.proc_start = proc_start;
5239
5240 int myargc = argc;
5241 char **myargv = argv;
5242
5243 hc_thread_mutex_init (mux_dispatcher);
5244 hc_thread_mutex_init (mux_counter);
5245 hc_thread_mutex_init (mux_display);
5246 hc_thread_mutex_init (mux_adl);
5247
5248 /**
5249 * commandline parameters
5250 */
5251
5252 uint usage = USAGE;
5253 uint version = VERSION;
5254 uint quiet = QUIET;
5255 uint benchmark = BENCHMARK;
5256 uint show = SHOW;
5257 uint left = LEFT;
5258 uint username = USERNAME;
5259 uint remove = REMOVE;
5260 uint remove_timer = REMOVE_TIMER;
5261 u64 skip = SKIP;
5262 u64 limit = LIMIT;
5263 uint keyspace = KEYSPACE;
5264 uint potfile_disable = POTFILE_DISABLE;
5265 char *potfile_path = NULL;
5266 uint debug_mode = DEBUG_MODE;
5267 char *debug_file = NULL;
5268 char *induction_dir = NULL;
5269 char *outfile_check_dir = NULL;
5270 uint force = FORCE;
5271 uint runtime = RUNTIME;
5272 uint hash_mode = HASH_MODE;
5273 uint attack_mode = ATTACK_MODE;
5274 uint markov_disable = MARKOV_DISABLE;
5275 uint markov_classic = MARKOV_CLASSIC;
5276 uint markov_threshold = MARKOV_THRESHOLD;
5277 char *markov_hcstat = NULL;
5278 char *outfile = NULL;
5279 uint outfile_format = OUTFILE_FORMAT;
5280 uint outfile_autohex = OUTFILE_AUTOHEX;
5281 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5282 uint restore = RESTORE;
5283 uint restore_timer = RESTORE_TIMER;
5284 uint restore_disable = RESTORE_DISABLE;
5285 uint status = STATUS;
5286 uint status_timer = STATUS_TIMER;
5287 uint status_automat = STATUS_AUTOMAT;
5288 uint loopback = LOOPBACK;
5289 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5290 char *session = NULL;
5291 uint hex_charset = HEX_CHARSET;
5292 uint hex_salt = HEX_SALT;
5293 uint hex_wordlist = HEX_WORDLIST;
5294 uint rp_gen = RP_GEN;
5295 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5296 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5297 uint rp_gen_seed = RP_GEN_SEED;
5298 char *rule_buf_l = (char *) RULE_BUF_L;
5299 char *rule_buf_r = (char *) RULE_BUF_R;
5300 uint increment = INCREMENT;
5301 uint increment_min = INCREMENT_MIN;
5302 uint increment_max = INCREMENT_MAX;
5303 char *cpu_affinity = NULL;
5304 OCL_PTR *ocl = NULL;
5305 char *opencl_devices = NULL;
5306 char *opencl_platforms = NULL;
5307 char *opencl_device_types = NULL;
5308 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5309 char *truecrypt_keyfiles = NULL;
5310 uint workload_profile = WORKLOAD_PROFILE;
5311 uint kernel_accel = KERNEL_ACCEL;
5312 uint kernel_loops = KERNEL_LOOPS;
5313 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5314 #ifdef HAVE_HWMON
5315 uint gpu_temp_abort = GPU_TEMP_ABORT;
5316 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5317 #ifdef HAVE_ADL
5318 uint powertune_enable = POWERTUNE_ENABLE;
5319 #endif
5320 #endif
5321 uint logfile_disable = LOGFILE_DISABLE;
5322 uint segment_size = SEGMENT_SIZE;
5323 uint scrypt_tmto = SCRYPT_TMTO;
5324 char separator = SEPARATOR;
5325 uint bitmap_min = BITMAP_MIN;
5326 uint bitmap_max = BITMAP_MAX;
5327 char *custom_charset_1 = NULL;
5328 char *custom_charset_2 = NULL;
5329 char *custom_charset_3 = NULL;
5330 char *custom_charset_4 = NULL;
5331
5332 #define IDX_HELP 'h'
5333 #define IDX_VERSION 'V'
5334 #define IDX_VERSION_LOWER 'v'
5335 #define IDX_QUIET 0xff02
5336 #define IDX_SHOW 0xff03
5337 #define IDX_LEFT 0xff04
5338 #define IDX_REMOVE 0xff05
5339 #define IDX_REMOVE_TIMER 0xff37
5340 #define IDX_SKIP 's'
5341 #define IDX_LIMIT 'l'
5342 #define IDX_KEYSPACE 0xff35
5343 #define IDX_POTFILE_DISABLE 0xff06
5344 #define IDX_POTFILE_PATH 0xffe0
5345 #define IDX_DEBUG_MODE 0xff43
5346 #define IDX_DEBUG_FILE 0xff44
5347 #define IDX_INDUCTION_DIR 0xff46
5348 #define IDX_OUTFILE_CHECK_DIR 0xff47
5349 #define IDX_USERNAME 0xff07
5350 #define IDX_FORCE 0xff08
5351 #define IDX_RUNTIME 0xff09
5352 #define IDX_BENCHMARK 'b'
5353 #define IDX_HASH_MODE 'm'
5354 #define IDX_ATTACK_MODE 'a'
5355 #define IDX_RP_FILE 'r'
5356 #define IDX_RP_GEN 'g'
5357 #define IDX_RP_GEN_FUNC_MIN 0xff10
5358 #define IDX_RP_GEN_FUNC_MAX 0xff11
5359 #define IDX_RP_GEN_SEED 0xff34
5360 #define IDX_RULE_BUF_L 'j'
5361 #define IDX_RULE_BUF_R 'k'
5362 #define IDX_INCREMENT 'i'
5363 #define IDX_INCREMENT_MIN 0xff12
5364 #define IDX_INCREMENT_MAX 0xff13
5365 #define IDX_OUTFILE 'o'
5366 #define IDX_OUTFILE_FORMAT 0xff14
5367 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5368 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5369 #define IDX_RESTORE 0xff15
5370 #define IDX_RESTORE_DISABLE 0xff27
5371 #define IDX_STATUS 0xff17
5372 #define IDX_STATUS_TIMER 0xff18
5373 #define IDX_STATUS_AUTOMAT 0xff50
5374 #define IDX_LOOPBACK 0xff38
5375 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5376 #define IDX_SESSION 0xff19
5377 #define IDX_HEX_CHARSET 0xff20
5378 #define IDX_HEX_SALT 0xff21
5379 #define IDX_HEX_WORDLIST 0xff40
5380 #define IDX_MARKOV_DISABLE 0xff22
5381 #define IDX_MARKOV_CLASSIC 0xff23
5382 #define IDX_MARKOV_THRESHOLD 't'
5383 #define IDX_MARKOV_HCSTAT 0xff24
5384 #define IDX_CPU_AFFINITY 0xff25
5385 #define IDX_OPENCL_DEVICES 'd'
5386 #define IDX_OPENCL_PLATFORMS 0xff72
5387 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5388 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5389 #define IDX_WORKLOAD_PROFILE 'w'
5390 #define IDX_KERNEL_ACCEL 'n'
5391 #define IDX_KERNEL_LOOPS 'u'
5392 #define IDX_GPU_TEMP_DISABLE 0xff29
5393 #define IDX_GPU_TEMP_ABORT 0xff30
5394 #define IDX_GPU_TEMP_RETAIN 0xff31
5395 #define IDX_POWERTUNE_ENABLE 0xff41
5396 #define IDX_LOGFILE_DISABLE 0xff51
5397 #define IDX_TRUECRYPT_KEYFILES 0xff52
5398 #define IDX_SCRYPT_TMTO 0xff61
5399 #define IDX_SEGMENT_SIZE 'c'
5400 #define IDX_SEPARATOR 'p'
5401 #define IDX_BITMAP_MIN 0xff70
5402 #define IDX_BITMAP_MAX 0xff71
5403 #define IDX_CUSTOM_CHARSET_1 '1'
5404 #define IDX_CUSTOM_CHARSET_2 '2'
5405 #define IDX_CUSTOM_CHARSET_3 '3'
5406 #define IDX_CUSTOM_CHARSET_4 '4'
5407
5408 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5409
5410 struct option long_options[] =
5411 {
5412 {"help", no_argument, 0, IDX_HELP},
5413 {"version", no_argument, 0, IDX_VERSION},
5414 {"quiet", no_argument, 0, IDX_QUIET},
5415 {"show", no_argument, 0, IDX_SHOW},
5416 {"left", no_argument, 0, IDX_LEFT},
5417 {"username", no_argument, 0, IDX_USERNAME},
5418 {"remove", no_argument, 0, IDX_REMOVE},
5419 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5420 {"skip", required_argument, 0, IDX_SKIP},
5421 {"limit", required_argument, 0, IDX_LIMIT},
5422 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5423 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5424 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5425 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5426 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5427 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5428 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5429 {"force", no_argument, 0, IDX_FORCE},
5430 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5431 {"restore", no_argument, 0, IDX_RESTORE},
5432 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5433 {"status", no_argument, 0, IDX_STATUS},
5434 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5435 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5436 {"loopback", no_argument, 0, IDX_LOOPBACK},
5437 {"weak-hash-threshold",
5438 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5439 {"session", required_argument, 0, IDX_SESSION},
5440 {"runtime", required_argument, 0, IDX_RUNTIME},
5441 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5442 {"generate-rules-func-min",
5443 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5444 {"generate-rules-func-max",
5445 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5446 {"generate-rules-seed",
5447 required_argument, 0, IDX_RP_GEN_SEED},
5448 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5449 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5450 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5451 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5452 {"rules-file", required_argument, 0, IDX_RP_FILE},
5453 {"outfile", required_argument, 0, IDX_OUTFILE},
5454 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5455 {"outfile-autohex-disable",
5456 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5457 {"outfile-check-timer",
5458 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5459 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5460 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5461 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5462 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5463 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5464 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5465 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5466 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5467 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5468 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5469 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5470 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5471 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5472 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5473 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5474 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5475 #ifdef HAVE_HWMON
5476 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5477 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5478 #ifdef HAVE_ADL
5479 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5480 #endif
5481 #endif // HAVE_HWMON
5482 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5483 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5484 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5485 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5486 // deprecated
5487 {"seperator", required_argument, 0, IDX_SEPARATOR},
5488 {"separator", required_argument, 0, IDX_SEPARATOR},
5489 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5490 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5491 {"increment", no_argument, 0, IDX_INCREMENT},
5492 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5493 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5494 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5495 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5496 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5497 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5498
5499 {0, 0, 0, 0}
5500 };
5501
5502 uint rp_files_cnt = 0;
5503
5504 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5505
5506 int option_index = 0;
5507 int c = -1;
5508
5509 optind = 1;
5510 optopt = 0;
5511
5512 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5513 {
5514 switch (c)
5515 {
5516 case IDX_HELP: usage = 1; break;
5517 case IDX_VERSION:
5518 case IDX_VERSION_LOWER: version = 1; break;
5519 case IDX_RESTORE: restore = 1; break;
5520 case IDX_SESSION: session = optarg; break;
5521 case IDX_SHOW: show = 1; break;
5522 case IDX_LEFT: left = 1; break;
5523 case '?': return (-1);
5524 }
5525 }
5526
5527 if (optopt != 0)
5528 {
5529 log_error ("ERROR: Invalid argument specified");
5530
5531 return (-1);
5532 }
5533
5534 /**
5535 * exit functions
5536 */
5537
5538 if (version)
5539 {
5540 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5541
5542 return (0);
5543 }
5544
5545 if (usage)
5546 {
5547 usage_big_print (PROGNAME);
5548
5549 return (0);
5550 }
5551
5552 /**
5553 * session needs to be set, always!
5554 */
5555
5556 if (session == NULL) session = (char *) PROGNAME;
5557
5558 /**
5559 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5560 */
5561
5562 char *exec_path = get_exec_path ();
5563
5564 #ifdef LINUX
5565
5566 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5567 char *resolved_exec_path = realpath (exec_path, NULL);
5568
5569 char *install_dir = get_install_dir (resolved_exec_path);
5570 char *profile_dir = NULL;
5571 char *session_dir = NULL;
5572 char *shared_dir = NULL;
5573
5574 if (strcmp (install_dir, resolved_install_folder) == 0)
5575 {
5576 struct passwd *pw = getpwuid (getuid ());
5577
5578 const char *homedir = pw->pw_dir;
5579
5580 profile_dir = get_profile_dir (homedir);
5581 session_dir = get_session_dir (profile_dir);
5582 shared_dir = strdup (SHARED_FOLDER);
5583
5584 mkdir (profile_dir, 0700);
5585 mkdir (session_dir, 0700);
5586 }
5587 else
5588 {
5589 profile_dir = install_dir;
5590 session_dir = install_dir;
5591 shared_dir = install_dir;
5592 }
5593
5594 myfree (resolved_install_folder);
5595 myfree (resolved_exec_path);
5596
5597 #else
5598
5599 char *install_dir = get_install_dir (exec_path);
5600 char *profile_dir = install_dir;
5601 char *session_dir = install_dir;
5602 char *shared_dir = install_dir;
5603
5604 #endif
5605
5606 data.install_dir = install_dir;
5607 data.profile_dir = profile_dir;
5608 data.session_dir = session_dir;
5609 data.shared_dir = shared_dir;
5610
5611 myfree (exec_path);
5612
5613 /**
5614 * kernel cache, we need to make sure folder exist
5615 */
5616
5617 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5618
5619 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5620
5621 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5622
5623 mkdir (kernels_folder, 0700);
5624
5625 myfree (kernels_folder);
5626
5627 /**
5628 * session
5629 */
5630
5631 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5632
5633 data.session = session;
5634
5635 char *eff_restore_file = (char *) mymalloc (session_size);
5636 char *new_restore_file = (char *) mymalloc (session_size);
5637
5638 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5639 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5640
5641 data.eff_restore_file = eff_restore_file;
5642 data.new_restore_file = new_restore_file;
5643
5644 if (((show == 1) || (left == 1)) && (restore == 1))
5645 {
5646 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5647 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5648
5649 return (-1);
5650 }
5651
5652 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5653 if ((show == 1) || (left == 1))
5654 {
5655 restore_disable = 1;
5656
5657 restore = 0;
5658 }
5659
5660 data.restore_disable = restore_disable;
5661
5662 restore_data_t *rd = init_restore (argc, argv);
5663
5664 data.rd = rd;
5665
5666 /**
5667 * restore file
5668 */
5669
5670 if (restore == 1)
5671 {
5672 read_restore (eff_restore_file, rd);
5673
5674 if (rd->version_bin < RESTORE_MIN)
5675 {
5676 log_error ("ERROR: Incompatible restore-file version");
5677
5678 return (-1);
5679 }
5680
5681 myargc = rd->argc;
5682 myargv = rd->argv;
5683
5684 #ifdef _POSIX
5685 rd->pid = getpid ();
5686 #elif _WIN
5687 rd->pid = GetCurrentProcessId ();
5688 #endif
5689 }
5690
5691 uint hash_mode_chgd = 0;
5692 uint runtime_chgd = 0;
5693 uint kernel_loops_chgd = 0;
5694 uint kernel_accel_chgd = 0;
5695 uint attack_mode_chgd = 0;
5696 uint outfile_format_chgd = 0;
5697 uint rp_gen_seed_chgd = 0;
5698 uint remove_timer_chgd = 0;
5699 uint increment_min_chgd = 0;
5700 uint increment_max_chgd = 0;
5701 uint workload_profile_chgd = 0;
5702 uint opencl_vector_width_chgd = 0;
5703
5704 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5705 uint gpu_temp_retain_chgd = 0;
5706 uint gpu_temp_abort_chgd = 0;
5707 #endif
5708
5709 optind = 1;
5710 optopt = 0;
5711 option_index = 0;
5712
5713 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5714 {
5715 switch (c)
5716 {
5717 //case IDX_HELP: usage = 1; break;
5718 //case IDX_VERSION: version = 1; break;
5719 //case IDX_RESTORE: restore = 1; break;
5720 case IDX_QUIET: quiet = 1; break;
5721 //case IDX_SHOW: show = 1; break;
5722 case IDX_SHOW: break;
5723 //case IDX_LEFT: left = 1; break;
5724 case IDX_LEFT: break;
5725 case IDX_USERNAME: username = 1; break;
5726 case IDX_REMOVE: remove = 1; break;
5727 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5728 remove_timer_chgd = 1; break;
5729 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5730 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5731 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5732 case IDX_DEBUG_FILE: debug_file = optarg; break;
5733 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5734 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5735 case IDX_FORCE: force = 1; break;
5736 case IDX_SKIP: skip = atoll (optarg); break;
5737 case IDX_LIMIT: limit = atoll (optarg); break;
5738 case IDX_KEYSPACE: keyspace = 1; break;
5739 case IDX_BENCHMARK: benchmark = 1; break;
5740 case IDX_RESTORE: break;
5741 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5742 case IDX_STATUS: status = 1; break;
5743 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5744 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5745 case IDX_LOOPBACK: loopback = 1; break;
5746 case IDX_WEAK_HASH_THRESHOLD:
5747 weak_hash_threshold = atoi (optarg); break;
5748 //case IDX_SESSION: session = optarg; break;
5749 case IDX_SESSION: break;
5750 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5751 hash_mode_chgd = 1; break;
5752 case IDX_RUNTIME: runtime = atoi (optarg);
5753 runtime_chgd = 1; break;
5754 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5755 attack_mode_chgd = 1; break;
5756 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5757 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5758 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5759 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5760 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5761 rp_gen_seed_chgd = 1; break;
5762 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5763 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5764 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5765 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5766 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5767 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5768 case IDX_OUTFILE: outfile = optarg; break;
5769 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5770 outfile_format_chgd = 1; break;
5771 case IDX_OUTFILE_AUTOHEX_DISABLE:
5772 outfile_autohex = 0; break;
5773 case IDX_OUTFILE_CHECK_TIMER:
5774 outfile_check_timer = atoi (optarg); break;
5775 case IDX_HEX_CHARSET: hex_charset = 1; break;
5776 case IDX_HEX_SALT: hex_salt = 1; break;
5777 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5778 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5779 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5780 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5781 case IDX_OPENCL_DEVICE_TYPES:
5782 opencl_device_types = optarg; break;
5783 case IDX_OPENCL_VECTOR_WIDTH:
5784 opencl_vector_width = atoi (optarg);
5785 opencl_vector_width_chgd = 1; break;
5786 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5787 workload_profile_chgd = 1; break;
5788 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5789 kernel_accel_chgd = 1; break;
5790 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5791 kernel_loops_chgd = 1; break;
5792 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5793 #ifdef HAVE_HWMON
5794 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5795 #ifdef HAVE_ADL
5796 gpu_temp_abort_chgd = 1;
5797 #endif
5798 break;
5799 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5800 #ifdef HAVE_ADL
5801 gpu_temp_retain_chgd = 1;
5802 #endif
5803 break;
5804 #ifdef HAVE_ADL
5805 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5806 #endif
5807 #endif // HAVE_HWMON
5808 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5809 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5810 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5811 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5812 case IDX_SEPARATOR: separator = optarg[0]; break;
5813 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5814 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5815 case IDX_INCREMENT: increment = 1; break;
5816 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5817 increment_min_chgd = 1; break;
5818 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5819 increment_max_chgd = 1; break;
5820 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5821 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5822 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5823 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5824
5825 default:
5826 log_error ("ERROR: Invalid argument specified");
5827 return (-1);
5828 }
5829 }
5830
5831 if (optopt != 0)
5832 {
5833 log_error ("ERROR: Invalid argument specified");
5834
5835 return (-1);
5836 }
5837
5838 /**
5839 * Inform user things getting started,
5840 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5841 * - we do not need to check algorithm_pos
5842 */
5843
5844 if (quiet == 0)
5845 {
5846 if (benchmark == 1)
5847 {
5848 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5849
5850 log_info ("");
5851 }
5852 else if (restore == 1)
5853 {
5854 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5855
5856 log_info ("");
5857 }
5858 else
5859 {
5860 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5861
5862 log_info ("");
5863 }
5864 }
5865
5866 /**
5867 * sanity check
5868 */
5869
5870 if (attack_mode > 7)
5871 {
5872 log_error ("ERROR: Invalid attack-mode specified");
5873
5874 return (-1);
5875 }
5876
5877 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5878 {
5879 log_error ("ERROR: Invalid runtime specified");
5880
5881 return (-1);
5882 }
5883
5884 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5885 {
5886 log_error ("ERROR: Invalid hash-type specified");
5887
5888 return (-1);
5889 }
5890
5891 // renamed hash modes
5892
5893 if (hash_mode_chgd)
5894 {
5895 int n = -1;
5896
5897 switch (hash_mode)
5898 {
5899 case 123: n = 124;
5900 break;
5901 }
5902
5903 if (n >= 0)
5904 {
5905 log_error ("Old -m specified, use -m %d instead", n);
5906
5907 return (-1);
5908 }
5909 }
5910
5911 if (username == 1)
5912 {
5913 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5914 {
5915 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5916
5917 return (-1);
5918 }
5919 }
5920
5921 if (outfile_format > 16)
5922 {
5923 log_error ("ERROR: Invalid outfile-format specified");
5924
5925 return (-1);
5926 }
5927
5928 if (left == 1)
5929 {
5930 if (outfile_format_chgd == 1)
5931 {
5932 if (outfile_format > 1)
5933 {
5934 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5935
5936 return (-1);
5937 }
5938 }
5939 else
5940 {
5941 outfile_format = OUTFILE_FMT_HASH;
5942 }
5943 }
5944
5945 if (show == 1)
5946 {
5947 if (outfile_format_chgd == 1)
5948 {
5949 if ((outfile_format > 7) && (outfile_format < 16))
5950 {
5951 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5952
5953 return (-1);
5954 }
5955 }
5956 }
5957
5958 if (increment_min < INCREMENT_MIN)
5959 {
5960 log_error ("ERROR: Invalid increment-min specified");
5961
5962 return (-1);
5963 }
5964
5965 if (increment_max > INCREMENT_MAX)
5966 {
5967 log_error ("ERROR: Invalid increment-max specified");
5968
5969 return (-1);
5970 }
5971
5972 if (increment_min > increment_max)
5973 {
5974 log_error ("ERROR: Invalid increment-min specified");
5975
5976 return (-1);
5977 }
5978
5979 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5980 {
5981 log_error ("ERROR: increment is not allowed in attack-mode 0");
5982
5983 return (-1);
5984 }
5985
5986 if ((increment == 0) && (increment_min_chgd == 1))
5987 {
5988 log_error ("ERROR: increment-min is only supported together with increment switch");
5989
5990 return (-1);
5991 }
5992
5993 if ((increment == 0) && (increment_max_chgd == 1))
5994 {
5995 log_error ("ERROR: increment-max is only supported together with increment switch");
5996
5997 return (-1);
5998 }
5999
6000 if (rp_files_cnt && rp_gen)
6001 {
6002 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6003
6004 return (-1);
6005 }
6006
6007 if (rp_files_cnt || rp_gen)
6008 {
6009 if (attack_mode != ATTACK_MODE_STRAIGHT)
6010 {
6011 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6012
6013 return (-1);
6014 }
6015 }
6016
6017 if (rp_gen_func_min > rp_gen_func_max)
6018 {
6019 log_error ("ERROR: Invalid rp-gen-func-min specified");
6020
6021 return (-1);
6022 }
6023
6024 if (kernel_accel_chgd == 1)
6025 {
6026 if (kernel_accel < 1)
6027 {
6028 log_error ("ERROR: Invalid kernel-accel specified");
6029
6030 return (-1);
6031 }
6032
6033 if (kernel_accel > 1024)
6034 {
6035 log_error ("ERROR: Invalid kernel-accel specified");
6036
6037 return (-1);
6038 }
6039 }
6040
6041 if (kernel_loops_chgd == 1)
6042 {
6043 if (kernel_loops < 1)
6044 {
6045 log_error ("ERROR: Invalid kernel-loops specified");
6046
6047 return (-1);
6048 }
6049
6050 if (kernel_loops > 1024)
6051 {
6052 log_error ("ERROR: Invalid kernel-loops specified");
6053
6054 return (-1);
6055 }
6056 }
6057
6058 if ((workload_profile < 1) || (workload_profile > 3))
6059 {
6060 log_error ("ERROR: workload-profile %i not available", workload_profile);
6061
6062 return (-1);
6063 }
6064
6065 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6066 {
6067 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6068
6069 return (-1);
6070 }
6071
6072 if (show == 1 || left == 1)
6073 {
6074 attack_mode = ATTACK_MODE_NONE;
6075
6076 if (remove == 1)
6077 {
6078 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6079
6080 return (-1);
6081 }
6082
6083 if (potfile_disable == 1)
6084 {
6085 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 uint attack_kern = ATTACK_KERN_NONE;
6092
6093 switch (attack_mode)
6094 {
6095 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6096 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6097 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6098 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6099 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6100 }
6101
6102 if (benchmark == 0)
6103 {
6104 if (keyspace == 1)
6105 {
6106 int num_additional_params = 1;
6107
6108 if (attack_kern == ATTACK_KERN_COMBI)
6109 {
6110 num_additional_params = 2;
6111 }
6112
6113 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6114
6115 if (keyspace_wordlist_specified == 0) optind--;
6116 }
6117
6118 if (attack_kern == ATTACK_KERN_NONE)
6119 {
6120 if ((optind + 1) != myargc)
6121 {
6122 usage_mini_print (myargv[0]);
6123
6124 return (-1);
6125 }
6126 }
6127 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6128 {
6129 if ((optind + 1) > myargc)
6130 {
6131 usage_mini_print (myargv[0]);
6132
6133 return (-1);
6134 }
6135 }
6136 else if (attack_kern == ATTACK_KERN_COMBI)
6137 {
6138 if ((optind + 3) != myargc)
6139 {
6140 usage_mini_print (myargv[0]);
6141
6142 return (-1);
6143 }
6144 }
6145 else if (attack_kern == ATTACK_KERN_BF)
6146 {
6147 if ((optind + 1) > myargc)
6148 {
6149 usage_mini_print (myargv[0]);
6150
6151 return (-1);
6152 }
6153 }
6154 else
6155 {
6156 usage_mini_print (myargv[0]);
6157
6158 return (-1);
6159 }
6160 }
6161 else
6162 {
6163 if (myargv[optind] != 0)
6164 {
6165 log_error ("ERROR: Invalid argument for benchmark mode specified");
6166
6167 return (-1);
6168 }
6169
6170 if (attack_mode_chgd == 1)
6171 {
6172 if (attack_mode != ATTACK_MODE_BF)
6173 {
6174 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6175
6176 return (-1);
6177 }
6178 }
6179 }
6180
6181 if (skip != 0 && limit != 0)
6182 {
6183 limit += skip;
6184 }
6185
6186 if (keyspace == 1)
6187 {
6188 if (show == 1)
6189 {
6190 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6191
6192 return (-1);
6193 }
6194 else if (left == 1)
6195 {
6196 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6197
6198 return (-1);
6199 }
6200
6201 potfile_disable = 1;
6202
6203 restore_disable = 1;
6204
6205 restore = 0;
6206
6207 weak_hash_threshold = 0;
6208
6209 quiet = 1;
6210 }
6211
6212 if (remove_timer_chgd == 1)
6213 {
6214 if (remove == 0)
6215 {
6216 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6217
6218 return (-1);
6219 }
6220
6221 if (remove_timer < 1)
6222 {
6223 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6224
6225 return (-1);
6226 }
6227 }
6228
6229 if (loopback == 1)
6230 {
6231 if (attack_mode == ATTACK_MODE_STRAIGHT)
6232 {
6233 if ((rp_files_cnt == 0) && (rp_gen == 0))
6234 {
6235 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6236
6237 return (-1);
6238 }
6239 }
6240 else
6241 {
6242 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6243
6244 return (-1);
6245 }
6246 }
6247
6248 if (debug_mode > 0)
6249 {
6250 if (attack_mode != ATTACK_MODE_STRAIGHT)
6251 {
6252 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6253
6254 return (-1);
6255 }
6256
6257 if ((rp_files_cnt == 0) && (rp_gen == 0))
6258 {
6259 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6260
6261 return (-1);
6262 }
6263 }
6264
6265 if (debug_mode > 4)
6266 {
6267 log_error ("ERROR: Invalid debug-mode specified");
6268
6269 return (-1);
6270 }
6271
6272 if (debug_file != NULL)
6273 {
6274 if (debug_mode < 1)
6275 {
6276 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6277
6278 return (-1);
6279 }
6280 }
6281
6282 if (induction_dir != NULL)
6283 {
6284 if (attack_mode == ATTACK_MODE_BF)
6285 {
6286 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6287
6288 return (-1);
6289 }
6290 }
6291
6292 if (attack_mode != ATTACK_MODE_STRAIGHT)
6293 {
6294 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6295 {
6296 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6297
6298 return (-1);
6299 }
6300
6301 weak_hash_threshold = 0;
6302 }
6303
6304 /**
6305 * induction directory
6306 */
6307
6308 char *induction_directory = NULL;
6309
6310 if (attack_mode != ATTACK_MODE_BF)
6311 {
6312 if (induction_dir == NULL)
6313 {
6314 induction_directory = (char *) mymalloc (session_size);
6315
6316 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6317
6318 // create induction folder if it does not already exist
6319
6320 if (keyspace == 0)
6321 {
6322 if (rmdir (induction_directory) == -1)
6323 {
6324 if (errno == ENOENT)
6325 {
6326 // good, we can ignore
6327 }
6328 else if (errno == ENOTEMPTY)
6329 {
6330 char *induction_directory_mv = (char *) mymalloc (session_size);
6331
6332 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6333
6334 if (rename (induction_directory, induction_directory_mv) != 0)
6335 {
6336 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6337
6338 return (-1);
6339 }
6340 }
6341 else
6342 {
6343 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6344
6345 return (-1);
6346 }
6347 }
6348
6349 if (mkdir (induction_directory, 0700) == -1)
6350 {
6351 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6352
6353 return (-1);
6354 }
6355 }
6356 }
6357 else
6358 {
6359 induction_directory = induction_dir;
6360 }
6361 }
6362
6363 data.induction_directory = induction_directory;
6364
6365 /**
6366 * loopback
6367 */
6368
6369 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6370
6371 char *loopback_file = (char *) mymalloc (loopback_size);
6372
6373 /**
6374 * tuning db
6375 */
6376
6377 char tuning_db_file[256] = { 0 };
6378
6379 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6380
6381 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6382
6383 /**
6384 * outfile-check directory
6385 */
6386
6387 char *outfile_check_directory = NULL;
6388
6389 if (outfile_check_dir == NULL)
6390 {
6391 outfile_check_directory = (char *) mymalloc (session_size);
6392
6393 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6394 }
6395 else
6396 {
6397 outfile_check_directory = outfile_check_dir;
6398 }
6399
6400 data.outfile_check_directory = outfile_check_directory;
6401
6402 if (keyspace == 0)
6403 {
6404 struct stat outfile_check_stat;
6405
6406 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6407 {
6408 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6409
6410 if (is_dir == 0)
6411 {
6412 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6413
6414 return (-1);
6415 }
6416 }
6417 else if (outfile_check_dir == NULL)
6418 {
6419 if (mkdir (outfile_check_directory, 0700) == -1)
6420 {
6421 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6422
6423 return (-1);
6424 }
6425 }
6426 }
6427
6428 /**
6429 * special other stuff
6430 */
6431
6432 if (hash_mode == 9710)
6433 {
6434 outfile_format = 5;
6435 outfile_format_chgd = 1;
6436 }
6437
6438 if (hash_mode == 9810)
6439 {
6440 outfile_format = 5;
6441 outfile_format_chgd = 1;
6442 }
6443
6444 if (hash_mode == 10410)
6445 {
6446 outfile_format = 5;
6447 outfile_format_chgd = 1;
6448 }
6449
6450 /**
6451 * store stuff
6452 */
6453
6454 data.hash_mode = hash_mode;
6455 data.restore = restore;
6456 data.restore_timer = restore_timer;
6457 data.restore_disable = restore_disable;
6458 data.status = status;
6459 data.status_timer = status_timer;
6460 data.status_automat = status_automat;
6461 data.loopback = loopback;
6462 data.runtime = runtime;
6463 data.remove = remove;
6464 data.remove_timer = remove_timer;
6465 data.debug_mode = debug_mode;
6466 data.debug_file = debug_file;
6467 data.username = username;
6468 data.quiet = quiet;
6469 data.outfile = outfile;
6470 data.outfile_format = outfile_format;
6471 data.outfile_autohex = outfile_autohex;
6472 data.hex_charset = hex_charset;
6473 data.hex_salt = hex_salt;
6474 data.hex_wordlist = hex_wordlist;
6475 data.separator = separator;
6476 data.rp_files = rp_files;
6477 data.rp_files_cnt = rp_files_cnt;
6478 data.rp_gen = rp_gen;
6479 data.rp_gen_seed = rp_gen_seed;
6480 data.force = force;
6481 data.benchmark = benchmark;
6482 data.skip = skip;
6483 data.limit = limit;
6484 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6485 data.powertune_enable = powertune_enable;
6486 #endif
6487 data.logfile_disable = logfile_disable;
6488 data.truecrypt_keyfiles = truecrypt_keyfiles;
6489 data.scrypt_tmto = scrypt_tmto;
6490 data.workload_profile = workload_profile;
6491
6492 /**
6493 * cpu affinity
6494 */
6495
6496 if (cpu_affinity)
6497 {
6498 set_cpu_affinity (cpu_affinity);
6499 }
6500
6501 if (rp_gen_seed_chgd == 0)
6502 {
6503 srand (proc_start);
6504 }
6505 else
6506 {
6507 srand (rp_gen_seed);
6508 }
6509
6510 /**
6511 * logfile init
6512 */
6513
6514 if (logfile_disable == 0)
6515 {
6516 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6517
6518 char *logfile = (char *) mymalloc (logfile_size);
6519
6520 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6521
6522 data.logfile = logfile;
6523
6524 char *topid = logfile_generate_topid ();
6525
6526 data.topid = topid;
6527 }
6528
6529 // logfile_append() checks for logfile_disable internally to make it easier from here
6530
6531 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6532 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6533 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6534 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6535 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6536 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6537 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6538 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6539 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6540 #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));
6541
6542 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6543 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6544 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6545 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6546 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6547 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6548 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6549 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6550
6551 logfile_top_msg ("START");
6552
6553 logfile_top_uint (attack_mode);
6554 logfile_top_uint (attack_kern);
6555 logfile_top_uint (benchmark);
6556 logfile_top_uint (bitmap_min);
6557 logfile_top_uint (bitmap_max);
6558 logfile_top_uint (debug_mode);
6559 logfile_top_uint (force);
6560 logfile_top_uint (kernel_accel);
6561 logfile_top_uint (kernel_loops);
6562 logfile_top_uint (gpu_temp_disable);
6563 #ifdef HAVE_HWMON
6564 logfile_top_uint (gpu_temp_abort);
6565 logfile_top_uint (gpu_temp_retain);
6566 #endif
6567 logfile_top_uint (hash_mode);
6568 logfile_top_uint (hex_charset);
6569 logfile_top_uint (hex_salt);
6570 logfile_top_uint (hex_wordlist);
6571 logfile_top_uint (increment);
6572 logfile_top_uint (increment_max);
6573 logfile_top_uint (increment_min);
6574 logfile_top_uint (keyspace);
6575 logfile_top_uint (left);
6576 logfile_top_uint (logfile_disable);
6577 logfile_top_uint (loopback);
6578 logfile_top_uint (markov_classic);
6579 logfile_top_uint (markov_disable);
6580 logfile_top_uint (markov_threshold);
6581 logfile_top_uint (outfile_autohex);
6582 logfile_top_uint (outfile_check_timer);
6583 logfile_top_uint (outfile_format);
6584 logfile_top_uint (potfile_disable);
6585 logfile_top_string (potfile_path);
6586 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6587 logfile_top_uint (powertune_enable);
6588 #endif
6589 logfile_top_uint (scrypt_tmto);
6590 logfile_top_uint (quiet);
6591 logfile_top_uint (remove);
6592 logfile_top_uint (remove_timer);
6593 logfile_top_uint (restore);
6594 logfile_top_uint (restore_disable);
6595 logfile_top_uint (restore_timer);
6596 logfile_top_uint (rp_gen);
6597 logfile_top_uint (rp_gen_func_max);
6598 logfile_top_uint (rp_gen_func_min);
6599 logfile_top_uint (rp_gen_seed);
6600 logfile_top_uint (runtime);
6601 logfile_top_uint (segment_size);
6602 logfile_top_uint (show);
6603 logfile_top_uint (status);
6604 logfile_top_uint (status_automat);
6605 logfile_top_uint (status_timer);
6606 logfile_top_uint (usage);
6607 logfile_top_uint (username);
6608 logfile_top_uint (version);
6609 logfile_top_uint (weak_hash_threshold);
6610 logfile_top_uint (workload_profile);
6611 logfile_top_uint64 (limit);
6612 logfile_top_uint64 (skip);
6613 logfile_top_char (separator);
6614 logfile_top_string (cpu_affinity);
6615 logfile_top_string (custom_charset_1);
6616 logfile_top_string (custom_charset_2);
6617 logfile_top_string (custom_charset_3);
6618 logfile_top_string (custom_charset_4);
6619 logfile_top_string (debug_file);
6620 logfile_top_string (opencl_devices);
6621 logfile_top_string (opencl_platforms);
6622 logfile_top_string (opencl_device_types);
6623 logfile_top_uint (opencl_vector_width);
6624 logfile_top_string (induction_dir);
6625 logfile_top_string (markov_hcstat);
6626 logfile_top_string (outfile);
6627 logfile_top_string (outfile_check_dir);
6628 logfile_top_string (rule_buf_l);
6629 logfile_top_string (rule_buf_r);
6630 logfile_top_string (session);
6631 logfile_top_string (truecrypt_keyfiles);
6632
6633 /**
6634 * Init OpenCL library loader
6635 */
6636
6637 if (keyspace == 0)
6638 {
6639 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6640
6641 ocl_init (ocl);
6642
6643 data.ocl = ocl;
6644 }
6645
6646 /**
6647 * OpenCL platform selection
6648 */
6649
6650 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6651
6652 /**
6653 * OpenCL device selection
6654 */
6655
6656 u32 devices_filter = setup_devices_filter (opencl_devices);
6657
6658 /**
6659 * OpenCL device type selection
6660 */
6661
6662 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6663
6664 /**
6665 * benchmark
6666 */
6667
6668 if (benchmark == 1)
6669 {
6670 /**
6671 * disable useless stuff for benchmark
6672 */
6673
6674 status_timer = 0;
6675 restore_timer = 0;
6676 restore_disable = 1;
6677 potfile_disable = 1;
6678 weak_hash_threshold = 0;
6679 gpu_temp_disable = 1;
6680
6681 data.status_timer = status_timer;
6682 data.restore_timer = restore_timer;
6683 data.restore_disable = restore_disable;
6684
6685 /**
6686 * force attack mode to be bruteforce
6687 */
6688
6689 attack_mode = ATTACK_MODE_BF;
6690 attack_kern = ATTACK_KERN_BF;
6691
6692 if (workload_profile_chgd == 0)
6693 {
6694 workload_profile = 3;
6695
6696 data.workload_profile = workload_profile;
6697 }
6698 }
6699
6700 /**
6701 * config
6702 */
6703
6704 uint hash_type = 0;
6705 uint salt_type = 0;
6706 uint attack_exec = 0;
6707 uint opts_type = 0;
6708 uint kern_type = 0;
6709 uint dgst_size = 0;
6710 uint esalt_size = 0;
6711 uint opti_type = 0;
6712 uint dgst_pos0 = -1;
6713 uint dgst_pos1 = -1;
6714 uint dgst_pos2 = -1;
6715 uint dgst_pos3 = -1;
6716
6717 int (*parse_func) (char *, uint, hash_t *);
6718 int (*sort_by_digest) (const void *, const void *);
6719
6720 uint algorithm_pos = 0;
6721 uint algorithm_max = 1;
6722
6723 uint *algorithms = default_benchmark_algorithms;
6724
6725 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6726
6727 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6728 {
6729 /*
6730 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6731 * the following algos are skipped entirely
6732 */
6733
6734 if (algorithm_pos > 0)
6735 {
6736 local_free (rd);
6737
6738 rd = init_restore (argc, argv);
6739
6740 data.rd = rd;
6741 }
6742
6743 /**
6744 * update hash_mode in case of multihash benchmark
6745 */
6746
6747 if (benchmark == 1)
6748 {
6749 if (hash_mode_chgd == 0)
6750 {
6751 hash_mode = algorithms[algorithm_pos];
6752
6753 data.hash_mode = hash_mode;
6754 }
6755
6756 quiet = 1;
6757
6758 data.quiet = quiet;
6759 }
6760
6761 switch (hash_mode)
6762 {
6763 case 0: hash_type = HASH_TYPE_MD5;
6764 salt_type = SALT_TYPE_NONE;
6765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6766 opts_type = OPTS_TYPE_PT_GENERATE_LE
6767 | OPTS_TYPE_PT_ADD80
6768 | OPTS_TYPE_PT_ADDBITS14;
6769 kern_type = KERN_TYPE_MD5;
6770 dgst_size = DGST_SIZE_4_4;
6771 parse_func = md5_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_NOT_SALTED
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 10: 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 = md5s_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 11: 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 = joomla_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 12: 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_ST_ADD80
6840 | OPTS_TYPE_ST_ADDBITS14;
6841 kern_type = KERN_TYPE_MD5_PWSLT;
6842 dgst_size = DGST_SIZE_4_4;
6843 parse_func = postgresql_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_MEET_IN_MIDDLE
6849 | OPTI_TYPE_EARLY_SKIP
6850 | OPTI_TYPE_NOT_ITERATED
6851 | OPTI_TYPE_APPENDED_SALT
6852 | OPTI_TYPE_RAW_HASH;
6853 dgst_pos0 = 0;
6854 dgst_pos1 = 3;
6855 dgst_pos2 = 2;
6856 dgst_pos3 = 1;
6857 break;
6858
6859 case 20: hash_type = HASH_TYPE_MD5;
6860 salt_type = SALT_TYPE_INTERN;
6861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6862 opts_type = OPTS_TYPE_PT_GENERATE_LE
6863 | OPTS_TYPE_PT_ADD80
6864 | OPTS_TYPE_PT_ADDBITS14;
6865 kern_type = KERN_TYPE_MD5_SLTPW;
6866 dgst_size = DGST_SIZE_4_4;
6867 parse_func = md5s_parse_hash;
6868 sort_by_digest = sort_by_digest_4_4;
6869 opti_type = OPTI_TYPE_ZERO_BYTE
6870 | OPTI_TYPE_PRECOMPUTE_INIT
6871 | OPTI_TYPE_PRECOMPUTE_MERKLE
6872 | OPTI_TYPE_EARLY_SKIP
6873 | OPTI_TYPE_NOT_ITERATED
6874 | OPTI_TYPE_PREPENDED_SALT
6875 | OPTI_TYPE_RAW_HASH;
6876 dgst_pos0 = 0;
6877 dgst_pos1 = 3;
6878 dgst_pos2 = 2;
6879 dgst_pos3 = 1;
6880 break;
6881
6882 case 21: hash_type = HASH_TYPE_MD5;
6883 salt_type = SALT_TYPE_INTERN;
6884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6885 opts_type = OPTS_TYPE_PT_GENERATE_LE
6886 | OPTS_TYPE_PT_ADD80
6887 | OPTS_TYPE_PT_ADDBITS14;
6888 kern_type = KERN_TYPE_MD5_SLTPW;
6889 dgst_size = DGST_SIZE_4_4;
6890 parse_func = osc_parse_hash;
6891 sort_by_digest = sort_by_digest_4_4;
6892 opti_type = OPTI_TYPE_ZERO_BYTE
6893 | OPTI_TYPE_PRECOMPUTE_INIT
6894 | OPTI_TYPE_PRECOMPUTE_MERKLE
6895 | OPTI_TYPE_EARLY_SKIP
6896 | OPTI_TYPE_NOT_ITERATED
6897 | OPTI_TYPE_PREPENDED_SALT
6898 | OPTI_TYPE_RAW_HASH;
6899 dgst_pos0 = 0;
6900 dgst_pos1 = 3;
6901 dgst_pos2 = 2;
6902 dgst_pos3 = 1;
6903 break;
6904
6905 case 22: hash_type = HASH_TYPE_MD5;
6906 salt_type = SALT_TYPE_EMBEDDED;
6907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6908 opts_type = OPTS_TYPE_PT_GENERATE_LE
6909 | OPTS_TYPE_PT_ADD80
6910 | OPTS_TYPE_PT_ADDBITS14;
6911 kern_type = KERN_TYPE_MD5_SLTPW;
6912 dgst_size = DGST_SIZE_4_4;
6913 parse_func = netscreen_parse_hash;
6914 sort_by_digest = sort_by_digest_4_4;
6915 opti_type = OPTI_TYPE_ZERO_BYTE
6916 | OPTI_TYPE_PRECOMPUTE_INIT
6917 | OPTI_TYPE_PRECOMPUTE_MERKLE
6918 | OPTI_TYPE_EARLY_SKIP
6919 | OPTI_TYPE_NOT_ITERATED
6920 | OPTI_TYPE_PREPENDED_SALT
6921 | OPTI_TYPE_RAW_HASH;
6922 dgst_pos0 = 0;
6923 dgst_pos1 = 3;
6924 dgst_pos2 = 2;
6925 dgst_pos3 = 1;
6926 break;
6927
6928 case 23: hash_type = HASH_TYPE_MD5;
6929 salt_type = SALT_TYPE_EMBEDDED;
6930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6931 opts_type = OPTS_TYPE_PT_GENERATE_LE
6932 | OPTS_TYPE_PT_ADD80
6933 | OPTS_TYPE_PT_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5_SLTPW;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = skype_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_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_PREPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 30: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_INTERN;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_UNICODE
6956 | OPTS_TYPE_ST_ADD80
6957 | OPTS_TYPE_ST_ADDBITS14;
6958 kern_type = KERN_TYPE_MD5_PWUSLT;
6959 dgst_size = DGST_SIZE_4_4;
6960 parse_func = md5s_parse_hash;
6961 sort_by_digest = sort_by_digest_4_4;
6962 opti_type = OPTI_TYPE_ZERO_BYTE
6963 | OPTI_TYPE_PRECOMPUTE_INIT
6964 | OPTI_TYPE_PRECOMPUTE_MERKLE
6965 | OPTI_TYPE_MEET_IN_MIDDLE
6966 | OPTI_TYPE_EARLY_SKIP
6967 | OPTI_TYPE_NOT_ITERATED
6968 | OPTI_TYPE_APPENDED_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 40: 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_PT_ADD80
6981 | OPTS_TYPE_PT_ADDBITS14
6982 | OPTS_TYPE_PT_UNICODE;
6983 kern_type = KERN_TYPE_MD5_SLTPWU;
6984 dgst_size = DGST_SIZE_4_4;
6985 parse_func = md5s_parse_hash;
6986 sort_by_digest = sort_by_digest_4_4;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_PREPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 0;
6995 dgst_pos1 = 3;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 50: hash_type = HASH_TYPE_MD5;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_LE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS14;
7006 kern_type = KERN_TYPE_HMACMD5_PW;
7007 dgst_size = DGST_SIZE_4_4;
7008 parse_func = hmacmd5_parse_hash;
7009 sort_by_digest = sort_by_digest_4_4;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_NOT_ITERATED;
7012 dgst_pos0 = 0;
7013 dgst_pos1 = 3;
7014 dgst_pos2 = 2;
7015 dgst_pos3 = 1;
7016 break;
7017
7018 case 60: hash_type = HASH_TYPE_MD5;
7019 salt_type = SALT_TYPE_INTERN;
7020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7021 opts_type = OPTS_TYPE_PT_GENERATE_LE
7022 | OPTS_TYPE_PT_ADD80
7023 | OPTS_TYPE_PT_ADDBITS14;
7024 kern_type = KERN_TYPE_HMACMD5_SLT;
7025 dgst_size = DGST_SIZE_4_4;
7026 parse_func = hmacmd5_parse_hash;
7027 sort_by_digest = sort_by_digest_4_4;
7028 opti_type = OPTI_TYPE_ZERO_BYTE
7029 | OPTI_TYPE_NOT_ITERATED;
7030 dgst_pos0 = 0;
7031 dgst_pos1 = 3;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 100: hash_type = HASH_TYPE_SHA1;
7037 salt_type = SALT_TYPE_NONE;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_BE
7040 | OPTS_TYPE_PT_ADD80
7041 | OPTS_TYPE_PT_ADDBITS15;
7042 kern_type = KERN_TYPE_SHA1;
7043 dgst_size = DGST_SIZE_4_5;
7044 parse_func = sha1_parse_hash;
7045 sort_by_digest = sort_by_digest_4_5;
7046 opti_type = OPTI_TYPE_ZERO_BYTE
7047 | OPTI_TYPE_PRECOMPUTE_INIT
7048 | OPTI_TYPE_PRECOMPUTE_MERKLE
7049 | OPTI_TYPE_EARLY_SKIP
7050 | OPTI_TYPE_NOT_ITERATED
7051 | OPTI_TYPE_NOT_SALTED
7052 | OPTI_TYPE_RAW_HASH;
7053 dgst_pos0 = 3;
7054 dgst_pos1 = 4;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 101: hash_type = HASH_TYPE_SHA1;
7060 salt_type = SALT_TYPE_NONE;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_BE
7063 | OPTS_TYPE_PT_ADD80
7064 | OPTS_TYPE_PT_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = sha1b64_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 110: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_ST_ADD80
7087 | OPTS_TYPE_ST_ADDBITS15;
7088 kern_type = KERN_TYPE_SHA1_PWSLT;
7089 dgst_size = DGST_SIZE_4_5;
7090 parse_func = sha1s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_5;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_APPENDED_SALT
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 3;
7100 dgst_pos1 = 4;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 111: hash_type = HASH_TYPE_SHA1;
7106 salt_type = SALT_TYPE_EMBEDDED;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_BE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS15;
7111 kern_type = KERN_TYPE_SHA1_PWSLT;
7112 dgst_size = DGST_SIZE_4_5;
7113 parse_func = sha1b64s_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 112: 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_ST_ADD80
7133 | OPTS_TYPE_ST_ADDBITS15
7134 | OPTS_TYPE_ST_HEX;
7135 kern_type = KERN_TYPE_SHA1_PWSLT;
7136 dgst_size = DGST_SIZE_4_5;
7137 parse_func = oracles_parse_hash;
7138 sort_by_digest = sort_by_digest_4_5;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_APPENDED_SALT
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 3;
7147 dgst_pos1 = 4;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 120: hash_type = HASH_TYPE_SHA1;
7153 salt_type = SALT_TYPE_INTERN;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_BE
7156 | OPTS_TYPE_PT_ADD80
7157 | OPTS_TYPE_PT_ADDBITS15;
7158 kern_type = KERN_TYPE_SHA1_SLTPW;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = sha1s_parse_hash;
7161 sort_by_digest = sort_by_digest_4_5;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_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 121: hash_type = HASH_TYPE_SHA1;
7176 salt_type = SALT_TYPE_INTERN;
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_LOWER;
7182 kern_type = KERN_TYPE_SHA1_SLTPW;
7183 dgst_size = DGST_SIZE_4_5;
7184 parse_func = smf_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 122: 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 | OPTS_TYPE_ST_HEX;
7206 kern_type = KERN_TYPE_SHA1_SLTPW;
7207 dgst_size = DGST_SIZE_4_5;
7208 parse_func = osx1_parse_hash;
7209 sort_by_digest = sort_by_digest_4_5;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_PRECOMPUTE_INIT
7212 | OPTI_TYPE_PRECOMPUTE_MERKLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_PREPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 3;
7218 dgst_pos1 = 4;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 124: hash_type = HASH_TYPE_SHA1;
7224 salt_type = SALT_TYPE_EMBEDDED;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_BE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS15;
7229 kern_type = KERN_TYPE_SHA1_SLTPW;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = djangosha1_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 125: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_EMBEDDED;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS15
7252 | OPTS_TYPE_ST_HEX;
7253 kern_type = KERN_TYPE_SHA1_SLTPW;
7254 dgst_size = DGST_SIZE_4_5;
7255 parse_func = arubaos_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_PREPENDED_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 130: hash_type = HASH_TYPE_SHA1;
7271 salt_type = SALT_TYPE_INTERN;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_BE
7274 | OPTS_TYPE_PT_UNICODE
7275 | OPTS_TYPE_ST_ADD80
7276 | OPTS_TYPE_ST_ADDBITS15;
7277 kern_type = KERN_TYPE_SHA1_PWUSLT;
7278 dgst_size = DGST_SIZE_4_5;
7279 parse_func = sha1s_parse_hash;
7280 sort_by_digest = sort_by_digest_4_5;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_EARLY_SKIP
7285 | OPTI_TYPE_NOT_ITERATED
7286 | OPTI_TYPE_APPENDED_SALT
7287 | OPTI_TYPE_RAW_HASH;
7288 dgst_pos0 = 3;
7289 dgst_pos1 = 4;
7290 dgst_pos2 = 2;
7291 dgst_pos3 = 1;
7292 break;
7293
7294 case 131: hash_type = HASH_TYPE_SHA1;
7295 salt_type = SALT_TYPE_EMBEDDED;
7296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7297 opts_type = OPTS_TYPE_PT_GENERATE_BE
7298 | OPTS_TYPE_PT_UNICODE
7299 | OPTS_TYPE_PT_UPPER
7300 | OPTS_TYPE_ST_ADD80
7301 | OPTS_TYPE_ST_ADDBITS15
7302 | OPTS_TYPE_ST_HEX;
7303 kern_type = KERN_TYPE_SHA1_PWUSLT;
7304 dgst_size = DGST_SIZE_4_5;
7305 parse_func = mssql2000_parse_hash;
7306 sort_by_digest = sort_by_digest_4_5;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_APPENDED_SALT
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 3;
7315 dgst_pos1 = 4;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 132: hash_type = HASH_TYPE_SHA1;
7321 salt_type = SALT_TYPE_EMBEDDED;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_BE
7324 | OPTS_TYPE_PT_UNICODE
7325 | OPTS_TYPE_ST_ADD80
7326 | OPTS_TYPE_ST_ADDBITS15
7327 | OPTS_TYPE_ST_HEX;
7328 kern_type = KERN_TYPE_SHA1_PWUSLT;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = mssql2005_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 133: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_EMBEDDED;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_UNICODE
7350 | OPTS_TYPE_ST_ADD80
7351 | OPTS_TYPE_ST_ADDBITS15;
7352 kern_type = KERN_TYPE_SHA1_PWUSLT;
7353 dgst_size = DGST_SIZE_4_5;
7354 parse_func = peoplesoft_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_APPENDED_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 140: hash_type = HASH_TYPE_SHA1;
7370 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA1_SLTPWU;
7377 dgst_size = DGST_SIZE_4_5;
7378 parse_func = sha1s_parse_hash;
7379 sort_by_digest = sort_by_digest_4_5;
7380 opti_type = OPTI_TYPE_ZERO_BYTE
7381 | OPTI_TYPE_PRECOMPUTE_INIT
7382 | OPTI_TYPE_PRECOMPUTE_MERKLE
7383 | OPTI_TYPE_EARLY_SKIP
7384 | OPTI_TYPE_NOT_ITERATED
7385 | OPTI_TYPE_PREPENDED_SALT
7386 | OPTI_TYPE_RAW_HASH;
7387 dgst_pos0 = 3;
7388 dgst_pos1 = 4;
7389 dgst_pos2 = 2;
7390 dgst_pos3 = 1;
7391 break;
7392
7393 case 141: hash_type = HASH_TYPE_SHA1;
7394 salt_type = SALT_TYPE_EMBEDDED;
7395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7396 opts_type = OPTS_TYPE_PT_GENERATE_BE
7397 | OPTS_TYPE_PT_ADD80
7398 | OPTS_TYPE_PT_ADDBITS15
7399 | OPTS_TYPE_PT_UNICODE
7400 | OPTS_TYPE_ST_BASE64;
7401 kern_type = KERN_TYPE_SHA1_SLTPWU;
7402 dgst_size = DGST_SIZE_4_5;
7403 parse_func = episerver_parse_hash;
7404 sort_by_digest = sort_by_digest_4_5;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_PREPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 3;
7413 dgst_pos1 = 4;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 1;
7416 break;
7417
7418 case 150: hash_type = HASH_TYPE_SHA1;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_BE
7422 | OPTS_TYPE_ST_ADD80
7423 | OPTS_TYPE_ST_ADDBITS15;
7424 kern_type = KERN_TYPE_HMACSHA1_PW;
7425 dgst_size = DGST_SIZE_4_5;
7426 parse_func = hmacsha1_parse_hash;
7427 sort_by_digest = sort_by_digest_4_5;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_NOT_ITERATED;
7430 dgst_pos0 = 3;
7431 dgst_pos1 = 4;
7432 dgst_pos2 = 2;
7433 dgst_pos3 = 1;
7434 break;
7435
7436 case 160: hash_type = HASH_TYPE_SHA1;
7437 salt_type = SALT_TYPE_INTERN;
7438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7439 opts_type = OPTS_TYPE_PT_GENERATE_BE
7440 | OPTS_TYPE_PT_ADD80
7441 | OPTS_TYPE_PT_ADDBITS15;
7442 kern_type = KERN_TYPE_HMACSHA1_SLT;
7443 dgst_size = DGST_SIZE_4_5;
7444 parse_func = hmacsha1_parse_hash;
7445 sort_by_digest = sort_by_digest_4_5;
7446 opti_type = OPTI_TYPE_ZERO_BYTE
7447 | OPTI_TYPE_NOT_ITERATED;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 190: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_NONE;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_ADD80
7459 | OPTS_TYPE_PT_ADDBITS15;
7460 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7461 dgst_size = DGST_SIZE_4_5;
7462 parse_func = sha1linkedin_parse_hash;
7463 sort_by_digest = sort_by_digest_4_5;
7464 opti_type = OPTI_TYPE_ZERO_BYTE
7465 | OPTI_TYPE_PRECOMPUTE_INIT
7466 | OPTI_TYPE_EARLY_SKIP
7467 | OPTI_TYPE_NOT_ITERATED
7468 | OPTI_TYPE_NOT_SALTED;
7469 dgst_pos0 = 0;
7470 dgst_pos1 = 4;
7471 dgst_pos2 = 3;
7472 dgst_pos3 = 2;
7473 break;
7474
7475 case 200: hash_type = HASH_TYPE_MYSQL;
7476 salt_type = SALT_TYPE_NONE;
7477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7478 opts_type = 0;
7479 kern_type = KERN_TYPE_MYSQL;
7480 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7481 parse_func = mysql323_parse_hash;
7482 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7483 opti_type = OPTI_TYPE_ZERO_BYTE;
7484 dgst_pos0 = 0;
7485 dgst_pos1 = 1;
7486 dgst_pos2 = 2;
7487 dgst_pos3 = 3;
7488 break;
7489
7490 case 300: hash_type = HASH_TYPE_SHA1;
7491 salt_type = SALT_TYPE_NONE;
7492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7493 opts_type = OPTS_TYPE_PT_GENERATE_BE
7494 | OPTS_TYPE_PT_ADD80
7495 | OPTS_TYPE_PT_ADDBITS15;
7496 kern_type = KERN_TYPE_MYSQL41;
7497 dgst_size = DGST_SIZE_4_5;
7498 parse_func = sha1_parse_hash;
7499 sort_by_digest = sort_by_digest_4_5;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_NOT_SALTED;
7506 dgst_pos0 = 3;
7507 dgst_pos1 = 4;
7508 dgst_pos2 = 2;
7509 dgst_pos3 = 1;
7510 break;
7511
7512 case 400: hash_type = HASH_TYPE_MD5;
7513 salt_type = SALT_TYPE_EMBEDDED;
7514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7516 kern_type = KERN_TYPE_PHPASS;
7517 dgst_size = DGST_SIZE_4_4;
7518 parse_func = phpass_parse_hash;
7519 sort_by_digest = sort_by_digest_4_4;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_SLOW_HASH_SIMD;
7522 dgst_pos0 = 0;
7523 dgst_pos1 = 1;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 3;
7526 break;
7527
7528 case 500: hash_type = HASH_TYPE_MD5;
7529 salt_type = SALT_TYPE_EMBEDDED;
7530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7532 kern_type = KERN_TYPE_MD5CRYPT;
7533 dgst_size = DGST_SIZE_4_4;
7534 parse_func = md5crypt_parse_hash;
7535 sort_by_digest = sort_by_digest_4_4;
7536 opti_type = OPTI_TYPE_ZERO_BYTE;
7537 dgst_pos0 = 0;
7538 dgst_pos1 = 1;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 3;
7541 break;
7542
7543 case 501: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE
7547 | OPTS_TYPE_HASH_COPY;
7548 kern_type = KERN_TYPE_MD5CRYPT;
7549 dgst_size = DGST_SIZE_4_4;
7550 parse_func = juniper_parse_hash;
7551 sort_by_digest = sort_by_digest_4_4;
7552 opti_type = OPTI_TYPE_ZERO_BYTE;
7553 dgst_pos0 = 0;
7554 dgst_pos1 = 1;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 3;
7557 break;
7558
7559 case 900: 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 kern_type = KERN_TYPE_MD4;
7566 dgst_size = DGST_SIZE_4_4;
7567 parse_func = md4_parse_hash;
7568 sort_by_digest = sort_by_digest_4_4;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_PRECOMPUTE_MERKLE
7572 | OPTI_TYPE_MEET_IN_MIDDLE
7573 | OPTI_TYPE_EARLY_SKIP
7574 | OPTI_TYPE_NOT_ITERATED
7575 | OPTI_TYPE_NOT_SALTED
7576 | OPTI_TYPE_RAW_HASH;
7577 dgst_pos0 = 0;
7578 dgst_pos1 = 3;
7579 dgst_pos2 = 2;
7580 dgst_pos3 = 1;
7581 break;
7582
7583 case 1000: hash_type = HASH_TYPE_MD4;
7584 salt_type = SALT_TYPE_NONE;
7585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7586 opts_type = OPTS_TYPE_PT_GENERATE_LE
7587 | OPTS_TYPE_PT_ADD80
7588 | OPTS_TYPE_PT_ADDBITS14
7589 | OPTS_TYPE_PT_UNICODE;
7590 kern_type = KERN_TYPE_MD4_PWU;
7591 dgst_size = DGST_SIZE_4_4;
7592 parse_func = md4_parse_hash;
7593 sort_by_digest = sort_by_digest_4_4;
7594 opti_type = OPTI_TYPE_ZERO_BYTE
7595 | OPTI_TYPE_PRECOMPUTE_INIT
7596 | OPTI_TYPE_PRECOMPUTE_MERKLE
7597 | OPTI_TYPE_MEET_IN_MIDDLE
7598 | OPTI_TYPE_EARLY_SKIP
7599 | OPTI_TYPE_NOT_ITERATED
7600 | OPTI_TYPE_NOT_SALTED
7601 | OPTI_TYPE_RAW_HASH;
7602 dgst_pos0 = 0;
7603 dgst_pos1 = 3;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 1;
7606 break;
7607
7608 case 1100: hash_type = HASH_TYPE_MD4;
7609 salt_type = SALT_TYPE_INTERN;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_LE
7612 | OPTS_TYPE_PT_ADD80
7613 | OPTS_TYPE_PT_ADDBITS14
7614 | OPTS_TYPE_PT_UNICODE
7615 | OPTS_TYPE_ST_ADD80
7616 | OPTS_TYPE_ST_UNICODE
7617 | OPTS_TYPE_ST_LOWER;
7618 kern_type = KERN_TYPE_MD44_PWUSLT;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = dcc_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_PRECOMPUTE_INIT
7624 | OPTI_TYPE_PRECOMPUTE_MERKLE
7625 | OPTI_TYPE_EARLY_SKIP
7626 | OPTI_TYPE_NOT_ITERATED;
7627 dgst_pos0 = 0;
7628 dgst_pos1 = 3;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 1400: hash_type = HASH_TYPE_SHA256;
7634 salt_type = SALT_TYPE_NONE;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS15;
7639 kern_type = KERN_TYPE_SHA256;
7640 dgst_size = DGST_SIZE_4_8;
7641 parse_func = sha256_parse_hash;
7642 sort_by_digest = sort_by_digest_4_8;
7643 opti_type = OPTI_TYPE_ZERO_BYTE
7644 | OPTI_TYPE_PRECOMPUTE_INIT
7645 | OPTI_TYPE_PRECOMPUTE_MERKLE
7646 | OPTI_TYPE_EARLY_SKIP
7647 | OPTI_TYPE_NOT_ITERATED
7648 | OPTI_TYPE_NOT_SALTED
7649 | OPTI_TYPE_RAW_HASH;
7650 dgst_pos0 = 3;
7651 dgst_pos1 = 7;
7652 dgst_pos2 = 2;
7653 dgst_pos3 = 6;
7654 break;
7655
7656 case 1410: hash_type = HASH_TYPE_SHA256;
7657 salt_type = SALT_TYPE_INTERN;
7658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7659 opts_type = OPTS_TYPE_PT_GENERATE_BE
7660 | OPTS_TYPE_ST_ADD80
7661 | OPTS_TYPE_ST_ADDBITS15;
7662 kern_type = KERN_TYPE_SHA256_PWSLT;
7663 dgst_size = DGST_SIZE_4_8;
7664 parse_func = sha256s_parse_hash;
7665 sort_by_digest = sort_by_digest_4_8;
7666 opti_type = OPTI_TYPE_ZERO_BYTE
7667 | OPTI_TYPE_PRECOMPUTE_INIT
7668 | OPTI_TYPE_PRECOMPUTE_MERKLE
7669 | OPTI_TYPE_EARLY_SKIP
7670 | OPTI_TYPE_NOT_ITERATED
7671 | OPTI_TYPE_APPENDED_SALT
7672 | OPTI_TYPE_RAW_HASH;
7673 dgst_pos0 = 3;
7674 dgst_pos1 = 7;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 6;
7677 break;
7678
7679 case 1420: hash_type = HASH_TYPE_SHA256;
7680 salt_type = SALT_TYPE_INTERN;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_BE
7683 | OPTS_TYPE_PT_ADD80
7684 | OPTS_TYPE_PT_ADDBITS15;
7685 kern_type = KERN_TYPE_SHA256_SLTPW;
7686 dgst_size = DGST_SIZE_4_8;
7687 parse_func = sha256s_parse_hash;
7688 sort_by_digest = sort_by_digest_4_8;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_PREPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 3;
7697 dgst_pos1 = 7;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 6;
7700 break;
7701
7702 case 1421: hash_type = HASH_TYPE_SHA256;
7703 salt_type = SALT_TYPE_EMBEDDED;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15;
7708 kern_type = KERN_TYPE_SHA256_SLTPW;
7709 dgst_size = DGST_SIZE_4_8;
7710 parse_func = hmailserver_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_PREPENDED_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 1430: 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_UNICODE
7730 | OPTS_TYPE_ST_ADD80
7731 | OPTS_TYPE_ST_ADDBITS15;
7732 kern_type = KERN_TYPE_SHA256_PWUSLT;
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_APPENDED_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 1440: hash_type = HASH_TYPE_SHA256;
7750 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA256_SLTPWU;
7757 dgst_size = DGST_SIZE_4_8;
7758 parse_func = sha256s_parse_hash;
7759 sort_by_digest = sort_by_digest_4_8;
7760 opti_type = OPTI_TYPE_ZERO_BYTE
7761 | OPTI_TYPE_PRECOMPUTE_INIT
7762 | OPTI_TYPE_PRECOMPUTE_MERKLE
7763 | OPTI_TYPE_EARLY_SKIP
7764 | OPTI_TYPE_NOT_ITERATED
7765 | OPTI_TYPE_PREPENDED_SALT
7766 | OPTI_TYPE_RAW_HASH;
7767 dgst_pos0 = 3;
7768 dgst_pos1 = 7;
7769 dgst_pos2 = 2;
7770 dgst_pos3 = 6;
7771 break;
7772
7773 case 1441: hash_type = HASH_TYPE_SHA256;
7774 salt_type = SALT_TYPE_EMBEDDED;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_PT_ADD80
7778 | OPTS_TYPE_PT_ADDBITS15
7779 | OPTS_TYPE_PT_UNICODE
7780 | OPTS_TYPE_ST_BASE64;
7781 kern_type = KERN_TYPE_SHA256_SLTPWU;
7782 dgst_size = DGST_SIZE_4_8;
7783 parse_func = episerver4_parse_hash;
7784 sort_by_digest = sort_by_digest_4_8;
7785 opti_type = OPTI_TYPE_ZERO_BYTE
7786 | OPTI_TYPE_PRECOMPUTE_INIT
7787 | OPTI_TYPE_PRECOMPUTE_MERKLE
7788 | OPTI_TYPE_EARLY_SKIP
7789 | OPTI_TYPE_NOT_ITERATED
7790 | OPTI_TYPE_PREPENDED_SALT
7791 | OPTI_TYPE_RAW_HASH;
7792 dgst_pos0 = 3;
7793 dgst_pos1 = 7;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 6;
7796 break;
7797
7798 case 1450: hash_type = HASH_TYPE_SHA256;
7799 salt_type = SALT_TYPE_INTERN;
7800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_BE
7802 | OPTS_TYPE_ST_ADD80;
7803 kern_type = KERN_TYPE_HMACSHA256_PW;
7804 dgst_size = DGST_SIZE_4_8;
7805 parse_func = hmacsha256_parse_hash;
7806 sort_by_digest = sort_by_digest_4_8;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_NOT_ITERATED;
7809 dgst_pos0 = 3;
7810 dgst_pos1 = 7;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 6;
7813 break;
7814
7815 case 1460: hash_type = HASH_TYPE_SHA256;
7816 salt_type = SALT_TYPE_INTERN;
7817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7818 opts_type = OPTS_TYPE_PT_GENERATE_BE
7819 | OPTS_TYPE_PT_ADD80
7820 | OPTS_TYPE_PT_ADDBITS15;
7821 kern_type = KERN_TYPE_HMACSHA256_SLT;
7822 dgst_size = DGST_SIZE_4_8;
7823 parse_func = hmacsha256_parse_hash;
7824 sort_by_digest = sort_by_digest_4_8;
7825 opti_type = OPTI_TYPE_ZERO_BYTE
7826 | OPTI_TYPE_NOT_ITERATED;
7827 dgst_pos0 = 3;
7828 dgst_pos1 = 7;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 6;
7831 break;
7832
7833 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7834 salt_type = SALT_TYPE_EMBEDDED;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_LE
7837 | OPTS_TYPE_PT_BITSLICE;
7838 kern_type = KERN_TYPE_DESCRYPT;
7839 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7840 parse_func = descrypt_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7844 dgst_pos0 = 0;
7845 dgst_pos1 = 1;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 3;
7848 break;
7849
7850 case 1600: hash_type = HASH_TYPE_MD5;
7851 salt_type = SALT_TYPE_EMBEDDED;
7852 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7854 kern_type = KERN_TYPE_APR1CRYPT;
7855 dgst_size = DGST_SIZE_4_4;
7856 parse_func = md5apr1_parse_hash;
7857 sort_by_digest = sort_by_digest_4_4;
7858 opti_type = OPTI_TYPE_ZERO_BYTE;
7859 dgst_pos0 = 0;
7860 dgst_pos1 = 1;
7861 dgst_pos2 = 2;
7862 dgst_pos3 = 3;
7863 break;
7864
7865 case 1700: hash_type = HASH_TYPE_SHA512;
7866 salt_type = SALT_TYPE_NONE;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_BE
7869 | OPTS_TYPE_PT_ADD80
7870 | OPTS_TYPE_PT_ADDBITS15;
7871 kern_type = KERN_TYPE_SHA512;
7872 dgst_size = DGST_SIZE_8_8;
7873 parse_func = sha512_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_NOT_SALTED
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 1710: hash_type = HASH_TYPE_SHA512;
7890 salt_type = SALT_TYPE_INTERN;
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 = sha512s_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 1711: hash_type = HASH_TYPE_SHA512;
7914 salt_type = SALT_TYPE_EMBEDDED;
7915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_BE
7917 | OPTS_TYPE_ST_ADD80
7918 | OPTS_TYPE_ST_ADDBITS15;
7919 kern_type = KERN_TYPE_SHA512_PWSLT;
7920 dgst_size = DGST_SIZE_8_8;
7921 parse_func = sha512b64s_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_APPENDED_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 1720: hash_type = HASH_TYPE_SHA512;
7938 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA512_SLTPW;
7944 dgst_size = DGST_SIZE_8_8;
7945 parse_func = sha512s_parse_hash;
7946 sort_by_digest = sort_by_digest_8_8;
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_PRECOMPUTE_INIT
7949 | OPTI_TYPE_PRECOMPUTE_MERKLE
7950 | OPTI_TYPE_EARLY_SKIP
7951 | OPTI_TYPE_NOT_ITERATED
7952 | OPTI_TYPE_PREPENDED_SALT
7953 | OPTI_TYPE_USES_BITS_64
7954 | OPTI_TYPE_RAW_HASH;
7955 dgst_pos0 = 14;
7956 dgst_pos1 = 15;
7957 dgst_pos2 = 6;
7958 dgst_pos3 = 7;
7959 break;
7960
7961 case 1722: hash_type = HASH_TYPE_SHA512;
7962 salt_type = SALT_TYPE_EMBEDDED;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_PT_ADD80
7966 | OPTS_TYPE_PT_ADDBITS15
7967 | OPTS_TYPE_ST_HEX;
7968 kern_type = KERN_TYPE_SHA512_SLTPW;
7969 dgst_size = DGST_SIZE_8_8;
7970 parse_func = osx512_parse_hash;
7971 sort_by_digest = sort_by_digest_8_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_PREPENDED_SALT
7978 | OPTI_TYPE_USES_BITS_64
7979 | OPTI_TYPE_RAW_HASH;
7980 dgst_pos0 = 14;
7981 dgst_pos1 = 15;
7982 dgst_pos2 = 6;
7983 dgst_pos3 = 7;
7984 break;
7985
7986 case 1730: hash_type = HASH_TYPE_SHA512;
7987 salt_type = SALT_TYPE_INTERN;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_PT_UNICODE
7991 | OPTS_TYPE_ST_ADD80
7992 | OPTS_TYPE_ST_ADDBITS15;
7993 kern_type = KERN_TYPE_SHA512_PWSLTU;
7994 dgst_size = DGST_SIZE_8_8;
7995 parse_func = sha512s_parse_hash;
7996 sort_by_digest = sort_by_digest_8_8;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED
8002 | OPTI_TYPE_APPENDED_SALT
8003 | OPTI_TYPE_USES_BITS_64
8004 | OPTI_TYPE_RAW_HASH;
8005 dgst_pos0 = 14;
8006 dgst_pos1 = 15;
8007 dgst_pos2 = 6;
8008 dgst_pos3 = 7;
8009 break;
8010
8011 case 1731: hash_type = HASH_TYPE_SHA512;
8012 salt_type = SALT_TYPE_EMBEDDED;
8013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8014 opts_type = OPTS_TYPE_PT_GENERATE_BE
8015 | OPTS_TYPE_PT_UNICODE
8016 | OPTS_TYPE_ST_ADD80
8017 | OPTS_TYPE_ST_ADDBITS15
8018 | OPTS_TYPE_ST_HEX;
8019 kern_type = KERN_TYPE_SHA512_PWSLTU;
8020 dgst_size = DGST_SIZE_8_8;
8021 parse_func = mssql2012_parse_hash;
8022 sort_by_digest = sort_by_digest_8_8;
8023 opti_type = OPTI_TYPE_ZERO_BYTE
8024 | OPTI_TYPE_PRECOMPUTE_INIT
8025 | OPTI_TYPE_PRECOMPUTE_MERKLE
8026 | OPTI_TYPE_EARLY_SKIP
8027 | OPTI_TYPE_NOT_ITERATED
8028 | OPTI_TYPE_APPENDED_SALT
8029 | OPTI_TYPE_USES_BITS_64
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 14;
8032 dgst_pos1 = 15;
8033 dgst_pos2 = 6;
8034 dgst_pos3 = 7;
8035 break;
8036
8037 case 1740: hash_type = HASH_TYPE_SHA512;
8038 salt_type = SALT_TYPE_INTERN;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_ADD80
8042 | OPTS_TYPE_PT_ADDBITS15
8043 | OPTS_TYPE_PT_UNICODE;
8044 kern_type = KERN_TYPE_SHA512_SLTPWU;
8045 dgst_size = DGST_SIZE_8_8;
8046 parse_func = sha512s_parse_hash;
8047 sort_by_digest = sort_by_digest_8_8;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_PREPENDED_SALT
8054 | OPTI_TYPE_USES_BITS_64
8055 | OPTI_TYPE_RAW_HASH;
8056 dgst_pos0 = 14;
8057 dgst_pos1 = 15;
8058 dgst_pos2 = 6;
8059 dgst_pos3 = 7;
8060 break;
8061
8062 case 1750: hash_type = HASH_TYPE_SHA512;
8063 salt_type = SALT_TYPE_INTERN;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_ST_ADD80;
8067 kern_type = KERN_TYPE_HMACSHA512_PW;
8068 dgst_size = DGST_SIZE_8_8;
8069 parse_func = hmacsha512_parse_hash;
8070 sort_by_digest = sort_by_digest_8_8;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_USES_BITS_64
8073 | OPTI_TYPE_NOT_ITERATED;
8074 dgst_pos0 = 14;
8075 dgst_pos1 = 15;
8076 dgst_pos2 = 6;
8077 dgst_pos3 = 7;
8078 break;
8079
8080 case 1760: hash_type = HASH_TYPE_SHA512;
8081 salt_type = SALT_TYPE_INTERN;
8082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8083 opts_type = OPTS_TYPE_PT_GENERATE_BE
8084 | OPTS_TYPE_PT_ADD80
8085 | OPTS_TYPE_PT_ADDBITS15;
8086 kern_type = KERN_TYPE_HMACSHA512_SLT;
8087 dgst_size = DGST_SIZE_8_8;
8088 parse_func = hmacsha512_parse_hash;
8089 sort_by_digest = sort_by_digest_8_8;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_USES_BITS_64
8092 | OPTI_TYPE_NOT_ITERATED;
8093 dgst_pos0 = 14;
8094 dgst_pos1 = 15;
8095 dgst_pos2 = 6;
8096 dgst_pos3 = 7;
8097 break;
8098
8099 case 1800: hash_type = HASH_TYPE_SHA512;
8100 salt_type = SALT_TYPE_EMBEDDED;
8101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8103 kern_type = KERN_TYPE_SHA512CRYPT;
8104 dgst_size = DGST_SIZE_8_8;
8105 parse_func = sha512crypt_parse_hash;
8106 sort_by_digest = sort_by_digest_8_8;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_USES_BITS_64;
8109 dgst_pos0 = 0;
8110 dgst_pos1 = 1;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 3;
8113 break;
8114
8115 case 2100: hash_type = HASH_TYPE_DCC2;
8116 salt_type = SALT_TYPE_EMBEDDED;
8117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_ST_LOWER
8120 | OPTS_TYPE_ST_UNICODE;
8121 kern_type = KERN_TYPE_DCC2;
8122 dgst_size = DGST_SIZE_4_4;
8123 parse_func = dcc2_parse_hash;
8124 sort_by_digest = sort_by_digest_4_4;
8125 opti_type = OPTI_TYPE_ZERO_BYTE;
8126 dgst_pos0 = 0;
8127 dgst_pos1 = 1;
8128 dgst_pos2 = 2;
8129 dgst_pos3 = 3;
8130 break;
8131
8132 case 2400: hash_type = HASH_TYPE_MD5;
8133 salt_type = SALT_TYPE_NONE;
8134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8136 kern_type = KERN_TYPE_MD5PIX;
8137 dgst_size = DGST_SIZE_4_4;
8138 parse_func = md5pix_parse_hash;
8139 sort_by_digest = sort_by_digest_4_4;
8140 opti_type = OPTI_TYPE_ZERO_BYTE
8141 | OPTI_TYPE_PRECOMPUTE_INIT
8142 | OPTI_TYPE_PRECOMPUTE_MERKLE
8143 | OPTI_TYPE_EARLY_SKIP
8144 | OPTI_TYPE_NOT_ITERATED
8145 | OPTI_TYPE_NOT_SALTED;
8146 dgst_pos0 = 0;
8147 dgst_pos1 = 3;
8148 dgst_pos2 = 2;
8149 dgst_pos3 = 1;
8150 break;
8151
8152 case 2410: hash_type = HASH_TYPE_MD5;
8153 salt_type = SALT_TYPE_INTERN;
8154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8156 kern_type = KERN_TYPE_MD5ASA;
8157 dgst_size = DGST_SIZE_4_4;
8158 parse_func = md5asa_parse_hash;
8159 sort_by_digest = sort_by_digest_4_4;
8160 opti_type = OPTI_TYPE_ZERO_BYTE
8161 | OPTI_TYPE_PRECOMPUTE_INIT
8162 | OPTI_TYPE_PRECOMPUTE_MERKLE
8163 | OPTI_TYPE_EARLY_SKIP
8164 | OPTI_TYPE_NOT_ITERATED;
8165 dgst_pos0 = 0;
8166 dgst_pos1 = 3;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 1;
8169 break;
8170
8171 case 2500: hash_type = HASH_TYPE_WPA;
8172 salt_type = SALT_TYPE_EMBEDDED;
8173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8175 kern_type = KERN_TYPE_WPA;
8176 dgst_size = DGST_SIZE_4_4;
8177 parse_func = wpa_parse_hash;
8178 sort_by_digest = sort_by_digest_4_4;
8179 opti_type = OPTI_TYPE_ZERO_BYTE;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 1;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 3;
8184 break;
8185
8186 case 2600: hash_type = HASH_TYPE_MD5;
8187 salt_type = SALT_TYPE_VIRTUAL;
8188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_LE
8190 | OPTS_TYPE_PT_ADD80
8191 | OPTS_TYPE_PT_ADDBITS14
8192 | OPTS_TYPE_ST_ADD80;
8193 kern_type = KERN_TYPE_MD55_PWSLT1;
8194 dgst_size = DGST_SIZE_4_4;
8195 parse_func = md5md5_parse_hash;
8196 sort_by_digest = sort_by_digest_4_4;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_PRECOMPUTE_INIT
8199 | OPTI_TYPE_PRECOMPUTE_MERKLE
8200 | OPTI_TYPE_EARLY_SKIP;
8201 dgst_pos0 = 0;
8202 dgst_pos1 = 3;
8203 dgst_pos2 = 2;
8204 dgst_pos3 = 1;
8205 break;
8206
8207 case 2611: hash_type = HASH_TYPE_MD5;
8208 salt_type = SALT_TYPE_INTERN;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_LE
8211 | OPTS_TYPE_PT_ADD80
8212 | OPTS_TYPE_PT_ADDBITS14
8213 | OPTS_TYPE_ST_ADD80;
8214 kern_type = KERN_TYPE_MD55_PWSLT1;
8215 dgst_size = DGST_SIZE_4_4;
8216 parse_func = vb3_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 2612: hash_type = HASH_TYPE_MD5;
8229 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
8236 kern_type = KERN_TYPE_MD55_PWSLT1;
8237 dgst_size = DGST_SIZE_4_4;
8238 parse_func = phps_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_PRECOMPUTE_INIT
8242 | OPTI_TYPE_PRECOMPUTE_MERKLE
8243 | OPTI_TYPE_EARLY_SKIP;
8244 dgst_pos0 = 0;
8245 dgst_pos1 = 3;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 1;
8248 break;
8249
8250 case 2711: hash_type = HASH_TYPE_MD5;
8251 salt_type = SALT_TYPE_INTERN;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_PT_ADD80
8255 | OPTS_TYPE_PT_ADDBITS14
8256 | OPTS_TYPE_ST_ADD80;
8257 kern_type = KERN_TYPE_MD55_PWSLT2;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = vb30_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_EARLY_SKIP;
8264 dgst_pos0 = 0;
8265 dgst_pos1 = 3;
8266 dgst_pos2 = 2;
8267 dgst_pos3 = 1;
8268 break;
8269
8270 case 2811: hash_type = HASH_TYPE_MD5;
8271 salt_type = SALT_TYPE_INTERN;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_LE
8274 | OPTS_TYPE_PT_ADD80
8275 | OPTS_TYPE_PT_ADDBITS14;
8276 kern_type = KERN_TYPE_MD55_SLTPW;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = ipb2_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_EARLY_SKIP;
8283 dgst_pos0 = 0;
8284 dgst_pos1 = 3;
8285 dgst_pos2 = 2;
8286 dgst_pos3 = 1;
8287 break;
8288
8289 case 3000: hash_type = HASH_TYPE_LM;
8290 salt_type = SALT_TYPE_NONE;
8291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292 opts_type = OPTS_TYPE_PT_GENERATE_LE
8293 | OPTS_TYPE_PT_UPPER
8294 | OPTS_TYPE_PT_BITSLICE;
8295 kern_type = KERN_TYPE_LM;
8296 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8297 parse_func = lm_parse_hash;
8298 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8299 opti_type = OPTI_TYPE_ZERO_BYTE
8300 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8301 dgst_pos0 = 0;
8302 dgst_pos1 = 1;
8303 dgst_pos2 = 2;
8304 dgst_pos3 = 3;
8305 break;
8306
8307 case 3100: hash_type = HASH_TYPE_ORACLEH;
8308 salt_type = SALT_TYPE_INTERN;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_LE
8311 | OPTS_TYPE_PT_UPPER
8312 | OPTS_TYPE_ST_UPPER;
8313 kern_type = KERN_TYPE_ORACLEH;
8314 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8315 parse_func = oracleh_parse_hash;
8316 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8317 opti_type = OPTI_TYPE_ZERO_BYTE;
8318 dgst_pos0 = 0;
8319 dgst_pos1 = 1;
8320 dgst_pos2 = 2;
8321 dgst_pos3 = 3;
8322 break;
8323
8324 case 3200: hash_type = HASH_TYPE_BCRYPT;
8325 salt_type = SALT_TYPE_EMBEDDED;
8326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8327 opts_type = OPTS_TYPE_PT_GENERATE_LE
8328 | OPTS_TYPE_ST_GENERATE_LE;
8329 kern_type = KERN_TYPE_BCRYPT;
8330 dgst_size = DGST_SIZE_4_6;
8331 parse_func = bcrypt_parse_hash;
8332 sort_by_digest = sort_by_digest_4_6;
8333 opti_type = OPTI_TYPE_ZERO_BYTE;
8334 dgst_pos0 = 0;
8335 dgst_pos1 = 1;
8336 dgst_pos2 = 2;
8337 dgst_pos3 = 3;
8338 break;
8339
8340 case 3710: hash_type = HASH_TYPE_MD5;
8341 salt_type = SALT_TYPE_INTERN;
8342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8343 opts_type = OPTS_TYPE_PT_GENERATE_LE
8344 | OPTS_TYPE_PT_ADD80
8345 | OPTS_TYPE_PT_ADDBITS14;
8346 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8347 dgst_size = DGST_SIZE_4_4;
8348 parse_func = md5s_parse_hash;
8349 sort_by_digest = sort_by_digest_4_4;
8350 opti_type = OPTI_TYPE_ZERO_BYTE
8351 | OPTI_TYPE_PRECOMPUTE_INIT
8352 | OPTI_TYPE_PRECOMPUTE_MERKLE
8353 | OPTI_TYPE_EARLY_SKIP;
8354 dgst_pos0 = 0;
8355 dgst_pos1 = 3;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 1;
8358 break;
8359
8360 case 3711: hash_type = HASH_TYPE_MD5;
8361 salt_type = SALT_TYPE_EMBEDDED;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_LE
8364 | OPTS_TYPE_PT_ADD80
8365 | OPTS_TYPE_PT_ADDBITS14;
8366 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8367 dgst_size = DGST_SIZE_4_4;
8368 parse_func = mediawiki_b_parse_hash;
8369 sort_by_digest = sort_by_digest_4_4;
8370 opti_type = OPTI_TYPE_ZERO_BYTE
8371 | OPTI_TYPE_PRECOMPUTE_INIT
8372 | OPTI_TYPE_PRECOMPUTE_MERKLE
8373 | OPTI_TYPE_EARLY_SKIP;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 3;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 3800: hash_type = HASH_TYPE_MD5;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_ST_ADDBITS14;
8385 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8386 dgst_size = DGST_SIZE_4_4;
8387 parse_func = md5s_parse_hash;
8388 sort_by_digest = sort_by_digest_4_4;
8389 opti_type = OPTI_TYPE_ZERO_BYTE
8390 | OPTI_TYPE_PRECOMPUTE_INIT
8391 | OPTI_TYPE_PRECOMPUTE_MERKLE
8392 | OPTI_TYPE_EARLY_SKIP
8393 | OPTI_TYPE_NOT_ITERATED
8394 | OPTI_TYPE_RAW_HASH;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 3;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 1;
8399 break;
8400
8401 case 4300: hash_type = HASH_TYPE_MD5;
8402 salt_type = SALT_TYPE_VIRTUAL;
8403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE
8405 | OPTS_TYPE_PT_ADD80
8406 | OPTS_TYPE_PT_ADDBITS14
8407 | OPTS_TYPE_ST_ADD80;
8408 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8409 dgst_size = DGST_SIZE_4_4;
8410 parse_func = md5md5_parse_hash;
8411 sort_by_digest = sort_by_digest_4_4;
8412 opti_type = OPTI_TYPE_ZERO_BYTE
8413 | OPTI_TYPE_PRECOMPUTE_INIT
8414 | OPTI_TYPE_PRECOMPUTE_MERKLE
8415 | OPTI_TYPE_EARLY_SKIP;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 3;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 1;
8420 break;
8421
8422
8423 case 4400: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_NONE;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_BE
8427 | OPTS_TYPE_PT_ADD80
8428 | OPTS_TYPE_PT_ADDBITS15;
8429 kern_type = KERN_TYPE_MD5_SHA1;
8430 dgst_size = DGST_SIZE_4_4;
8431 parse_func = md5_parse_hash;
8432 sort_by_digest = sort_by_digest_4_4;
8433 opti_type = OPTI_TYPE_ZERO_BYTE
8434 | OPTI_TYPE_PRECOMPUTE_INIT
8435 | OPTI_TYPE_PRECOMPUTE_MERKLE
8436 | OPTI_TYPE_EARLY_SKIP
8437 | OPTI_TYPE_NOT_ITERATED
8438 | OPTI_TYPE_NOT_SALTED
8439 | OPTI_TYPE_RAW_HASH;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 3;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 1;
8444 break;
8445
8446 case 4500: hash_type = HASH_TYPE_SHA1;
8447 salt_type = SALT_TYPE_NONE;
8448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_BE
8450 | OPTS_TYPE_PT_ADD80
8451 | OPTS_TYPE_PT_ADDBITS15;
8452 kern_type = KERN_TYPE_SHA11;
8453 dgst_size = DGST_SIZE_4_5;
8454 parse_func = sha1_parse_hash;
8455 sort_by_digest = sort_by_digest_4_5;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_SALTED;
8461 dgst_pos0 = 3;
8462 dgst_pos1 = 4;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 4700: hash_type = HASH_TYPE_SHA1;
8468 salt_type = SALT_TYPE_NONE;
8469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE
8471 | OPTS_TYPE_PT_ADD80
8472 | OPTS_TYPE_PT_ADDBITS14;
8473 kern_type = KERN_TYPE_SHA1_MD5;
8474 dgst_size = DGST_SIZE_4_5;
8475 parse_func = sha1_parse_hash;
8476 sort_by_digest = sort_by_digest_4_5;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_EARLY_SKIP
8481 | OPTI_TYPE_NOT_ITERATED
8482 | OPTI_TYPE_NOT_SALTED
8483 | OPTI_TYPE_RAW_HASH;
8484 dgst_pos0 = 3;
8485 dgst_pos1 = 4;
8486 dgst_pos2 = 2;
8487 dgst_pos3 = 1;
8488 break;
8489
8490 case 4800: hash_type = HASH_TYPE_MD5;
8491 salt_type = SALT_TYPE_EMBEDDED;
8492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8493 opts_type = OPTS_TYPE_PT_GENERATE_LE
8494 | OPTS_TYPE_PT_ADDBITS14;
8495 kern_type = KERN_TYPE_MD5_CHAP;
8496 dgst_size = DGST_SIZE_4_4;
8497 parse_func = chap_parse_hash;
8498 sort_by_digest = sort_by_digest_4_4;
8499 opti_type = OPTI_TYPE_ZERO_BYTE
8500 | OPTI_TYPE_PRECOMPUTE_INIT
8501 | OPTI_TYPE_PRECOMPUTE_MERKLE
8502 | OPTI_TYPE_MEET_IN_MIDDLE
8503 | OPTI_TYPE_EARLY_SKIP
8504 | OPTI_TYPE_NOT_ITERATED
8505 | OPTI_TYPE_RAW_HASH;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 4900: hash_type = HASH_TYPE_SHA1;
8513 salt_type = SALT_TYPE_INTERN;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8516 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8517 dgst_size = DGST_SIZE_4_5;
8518 parse_func = sha1s_parse_hash;
8519 sort_by_digest = sort_by_digest_4_5;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP;
8524 dgst_pos0 = 3;
8525 dgst_pos1 = 4;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 5000: hash_type = HASH_TYPE_KECCAK;
8531 salt_type = SALT_TYPE_EMBEDDED;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_LE
8534 | OPTS_TYPE_PT_ADD01;
8535 kern_type = KERN_TYPE_KECCAK;
8536 dgst_size = DGST_SIZE_8_25;
8537 parse_func = keccak_parse_hash;
8538 sort_by_digest = sort_by_digest_8_25;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_USES_BITS_64
8541 | OPTI_TYPE_RAW_HASH;
8542 dgst_pos0 = 2;
8543 dgst_pos1 = 3;
8544 dgst_pos2 = 4;
8545 dgst_pos3 = 5;
8546 break;
8547
8548 case 5100: hash_type = HASH_TYPE_MD5H;
8549 salt_type = SALT_TYPE_NONE;
8550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE
8552 | OPTS_TYPE_PT_ADD80
8553 | OPTS_TYPE_PT_ADDBITS14;
8554 kern_type = KERN_TYPE_MD5H;
8555 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8556 parse_func = md5half_parse_hash;
8557 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_RAW_HASH;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 1;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 3;
8564 break;
8565
8566 case 5200: hash_type = HASH_TYPE_SHA256;
8567 salt_type = SALT_TYPE_EMBEDDED;
8568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8570 kern_type = KERN_TYPE_PSAFE3;
8571 dgst_size = DGST_SIZE_4_8;
8572 parse_func = psafe3_parse_hash;
8573 sort_by_digest = sort_by_digest_4_8;
8574 opti_type = OPTI_TYPE_ZERO_BYTE;
8575 dgst_pos0 = 0;
8576 dgst_pos1 = 1;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 3;
8579 break;
8580
8581 case 5300: hash_type = HASH_TYPE_MD5;
8582 salt_type = SALT_TYPE_EMBEDDED;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_ST_ADD80;
8586 kern_type = KERN_TYPE_IKEPSK_MD5;
8587 dgst_size = DGST_SIZE_4_4;
8588 parse_func = ikepsk_md5_parse_hash;
8589 sort_by_digest = sort_by_digest_4_4;
8590 opti_type = OPTI_TYPE_ZERO_BYTE;
8591 dgst_pos0 = 0;
8592 dgst_pos1 = 3;
8593 dgst_pos2 = 2;
8594 dgst_pos3 = 1;
8595 break;
8596
8597 case 5400: hash_type = HASH_TYPE_SHA1;
8598 salt_type = SALT_TYPE_EMBEDDED;
8599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8600 opts_type = OPTS_TYPE_PT_GENERATE_BE
8601 | OPTS_TYPE_ST_ADD80;
8602 kern_type = KERN_TYPE_IKEPSK_SHA1;
8603 dgst_size = DGST_SIZE_4_5;
8604 parse_func = ikepsk_sha1_parse_hash;
8605 sort_by_digest = sort_by_digest_4_5;
8606 opti_type = OPTI_TYPE_ZERO_BYTE;
8607 dgst_pos0 = 3;
8608 dgst_pos1 = 4;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 1;
8611 break;
8612
8613 case 5500: hash_type = HASH_TYPE_NETNTLM;
8614 salt_type = SALT_TYPE_EMBEDDED;
8615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE
8617 | OPTS_TYPE_PT_ADD80
8618 | OPTS_TYPE_PT_ADDBITS14
8619 | OPTS_TYPE_PT_UNICODE
8620 | OPTS_TYPE_ST_HEX;
8621 kern_type = KERN_TYPE_NETNTLMv1;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = netntlmv1_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE
8626 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8627 dgst_pos0 = 0;
8628 dgst_pos1 = 1;
8629 dgst_pos2 = 2;
8630 dgst_pos3 = 3;
8631 break;
8632
8633 case 5600: hash_type = HASH_TYPE_MD5;
8634 salt_type = SALT_TYPE_EMBEDDED;
8635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8636 opts_type = OPTS_TYPE_PT_GENERATE_LE
8637 | OPTS_TYPE_PT_ADD80
8638 | OPTS_TYPE_PT_ADDBITS14
8639 | OPTS_TYPE_PT_UNICODE;
8640 kern_type = KERN_TYPE_NETNTLMv2;
8641 dgst_size = DGST_SIZE_4_4;
8642 parse_func = netntlmv2_parse_hash;
8643 sort_by_digest = sort_by_digest_4_4;
8644 opti_type = OPTI_TYPE_ZERO_BYTE;
8645 dgst_pos0 = 0;
8646 dgst_pos1 = 3;
8647 dgst_pos2 = 2;
8648 dgst_pos3 = 1;
8649 break;
8650
8651 case 5700: hash_type = HASH_TYPE_SHA256;
8652 salt_type = SALT_TYPE_NONE;
8653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8654 opts_type = OPTS_TYPE_PT_GENERATE_BE
8655 | OPTS_TYPE_PT_ADD80
8656 | OPTS_TYPE_PT_ADDBITS15;
8657 kern_type = KERN_TYPE_SHA256;
8658 dgst_size = DGST_SIZE_4_8;
8659 parse_func = cisco4_parse_hash;
8660 sort_by_digest = sort_by_digest_4_8;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_PRECOMPUTE_INIT
8663 | OPTI_TYPE_PRECOMPUTE_MERKLE
8664 | OPTI_TYPE_EARLY_SKIP
8665 | OPTI_TYPE_NOT_ITERATED
8666 | OPTI_TYPE_NOT_SALTED
8667 | OPTI_TYPE_RAW_HASH;
8668 dgst_pos0 = 3;
8669 dgst_pos1 = 7;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 6;
8672 break;
8673
8674 case 5800: hash_type = HASH_TYPE_SHA1;
8675 salt_type = SALT_TYPE_INTERN;
8676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8678 | OPTS_TYPE_ST_ADD80;
8679 kern_type = KERN_TYPE_ANDROIDPIN;
8680 dgst_size = DGST_SIZE_4_5;
8681 parse_func = androidpin_parse_hash;
8682 sort_by_digest = sort_by_digest_4_5;
8683 opti_type = OPTI_TYPE_ZERO_BYTE;
8684 dgst_pos0 = 0;
8685 dgst_pos1 = 1;
8686 dgst_pos2 = 2;
8687 dgst_pos3 = 3;
8688 break;
8689
8690 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8691 salt_type = SALT_TYPE_NONE;
8692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8693 opts_type = OPTS_TYPE_PT_GENERATE_LE
8694 | OPTS_TYPE_PT_ADD80;
8695 kern_type = KERN_TYPE_RIPEMD160;
8696 dgst_size = DGST_SIZE_4_5;
8697 parse_func = ripemd160_parse_hash;
8698 sort_by_digest = sort_by_digest_4_5;
8699 opti_type = OPTI_TYPE_ZERO_BYTE;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 1;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 3;
8704 break;
8705
8706 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8707 salt_type = SALT_TYPE_NONE;
8708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_BE
8710 | OPTS_TYPE_PT_ADD80;
8711 kern_type = KERN_TYPE_WHIRLPOOL;
8712 dgst_size = DGST_SIZE_4_16;
8713 parse_func = whirlpool_parse_hash;
8714 sort_by_digest = sort_by_digest_4_16;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8726 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8727 dgst_size = DGST_SIZE_4_5;
8728 parse_func = truecrypt_parse_hash_2k;
8729 sort_by_digest = sort_by_digest_4_5;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8741 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8742 dgst_size = DGST_SIZE_4_5;
8743 parse_func = truecrypt_parse_hash_2k;
8744 sort_by_digest = sort_by_digest_4_5;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8756 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8757 dgst_size = DGST_SIZE_4_5;
8758 parse_func = truecrypt_parse_hash_2k;
8759 sort_by_digest = sort_by_digest_4_5;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6221: hash_type = HASH_TYPE_SHA512;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8771 kern_type = KERN_TYPE_TCSHA512_XTS512;
8772 dgst_size = DGST_SIZE_8_8;
8773 parse_func = truecrypt_parse_hash_1k;
8774 sort_by_digest = sort_by_digest_8_8;
8775 opti_type = OPTI_TYPE_ZERO_BYTE
8776 | OPTI_TYPE_USES_BITS_64;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 6222: hash_type = HASH_TYPE_SHA512;
8784 salt_type = SALT_TYPE_EMBEDDED;
8785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8787 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8788 dgst_size = DGST_SIZE_8_8;
8789 parse_func = truecrypt_parse_hash_1k;
8790 sort_by_digest = sort_by_digest_8_8;
8791 opti_type = OPTI_TYPE_ZERO_BYTE
8792 | OPTI_TYPE_USES_BITS_64;
8793 dgst_pos0 = 0;
8794 dgst_pos1 = 1;
8795 dgst_pos2 = 2;
8796 dgst_pos3 = 3;
8797 break;
8798
8799 case 6223: hash_type = HASH_TYPE_SHA512;
8800 salt_type = SALT_TYPE_EMBEDDED;
8801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8802 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8803 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8804 dgst_size = DGST_SIZE_8_8;
8805 parse_func = truecrypt_parse_hash_1k;
8806 sort_by_digest = sort_by_digest_8_8;
8807 opti_type = OPTI_TYPE_ZERO_BYTE
8808 | OPTI_TYPE_USES_BITS_64;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 1;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 3;
8813 break;
8814
8815 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8819 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8820 dgst_size = DGST_SIZE_4_8;
8821 parse_func = truecrypt_parse_hash_1k;
8822 sort_by_digest = sort_by_digest_4_8;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8834 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8835 dgst_size = DGST_SIZE_4_8;
8836 parse_func = truecrypt_parse_hash_1k;
8837 sort_by_digest = sort_by_digest_4_8;
8838 opti_type = OPTI_TYPE_ZERO_BYTE;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8849 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8850 dgst_size = DGST_SIZE_4_8;
8851 parse_func = truecrypt_parse_hash_1k;
8852 sort_by_digest = sort_by_digest_4_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8864 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8865 dgst_size = DGST_SIZE_4_5;
8866 parse_func = truecrypt_parse_hash_1k;
8867 sort_by_digest = sort_by_digest_4_5;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8879 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8880 dgst_size = DGST_SIZE_4_5;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_4_5;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8894 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8895 dgst_size = DGST_SIZE_4_5;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_4_5;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6300: hash_type = HASH_TYPE_MD5;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8909 kern_type = KERN_TYPE_MD5AIX;
8910 dgst_size = DGST_SIZE_4_4;
8911 parse_func = md5aix_parse_hash;
8912 sort_by_digest = sort_by_digest_4_4;
8913 opti_type = OPTI_TYPE_ZERO_BYTE;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6400: hash_type = HASH_TYPE_SHA256;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8924 kern_type = KERN_TYPE_SHA256AIX;
8925 dgst_size = DGST_SIZE_4_8;
8926 parse_func = sha256aix_parse_hash;
8927 sort_by_digest = sort_by_digest_4_8;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 0;
8930 dgst_pos1 = 1;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 3;
8933 break;
8934
8935 case 6500: hash_type = HASH_TYPE_SHA512;
8936 salt_type = SALT_TYPE_EMBEDDED;
8937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8939 kern_type = KERN_TYPE_SHA512AIX;
8940 dgst_size = DGST_SIZE_8_8;
8941 parse_func = sha512aix_parse_hash;
8942 sort_by_digest = sort_by_digest_8_8;
8943 opti_type = OPTI_TYPE_ZERO_BYTE
8944 | OPTI_TYPE_USES_BITS_64;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6600: hash_type = HASH_TYPE_AES;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_AGILEKEY;
8956 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8957 parse_func = agilekey_parse_hash;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6700: hash_type = HASH_TYPE_SHA1;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8970 kern_type = KERN_TYPE_SHA1AIX;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = sha1aix_parse_hash;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6800: hash_type = HASH_TYPE_AES;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_LASTPASS;
8986 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8987 parse_func = lastpass_parse_hash;
8988 sort_by_digest = sort_by_digest_4_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6900: hash_type = HASH_TYPE_GOST;
8997 salt_type = SALT_TYPE_NONE;
8998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_GOST;
9001 dgst_size = DGST_SIZE_4_8;
9002 parse_func = gost_parse_hash;
9003 sort_by_digest = sort_by_digest_4_8;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 7100: hash_type = HASH_TYPE_SHA512;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_PBKDF2_SHA512;
9016 dgst_size = DGST_SIZE_8_16;
9017 parse_func = sha512osx_parse_hash;
9018 sort_by_digest = sort_by_digest_8_16;
9019 opti_type = OPTI_TYPE_ZERO_BYTE
9020 | OPTI_TYPE_USES_BITS_64;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 7200: hash_type = HASH_TYPE_SHA512;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_PBKDF2_SHA512;
9032 dgst_size = DGST_SIZE_8_16;
9033 parse_func = sha512grub_parse_hash;
9034 sort_by_digest = sort_by_digest_8_16;
9035 opti_type = OPTI_TYPE_ZERO_BYTE
9036 | OPTI_TYPE_USES_BITS_64;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 7300: hash_type = HASH_TYPE_SHA1;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_BE
9047 | OPTS_TYPE_ST_ADD80
9048 | OPTS_TYPE_ST_ADDBITS15;
9049 kern_type = KERN_TYPE_RAKP;
9050 dgst_size = DGST_SIZE_4_5;
9051 parse_func = rakp_parse_hash;
9052 sort_by_digest = sort_by_digest_4_5;
9053 opti_type = OPTI_TYPE_ZERO_BYTE
9054 | OPTI_TYPE_NOT_ITERATED;
9055 dgst_pos0 = 3;
9056 dgst_pos1 = 4;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 1;
9059 break;
9060
9061 case 7400: hash_type = HASH_TYPE_SHA256;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9065 kern_type = KERN_TYPE_SHA256CRYPT;
9066 dgst_size = DGST_SIZE_4_8;
9067 parse_func = sha256crypt_parse_hash;
9068 sort_by_digest = sort_by_digest_4_8;
9069 opti_type = OPTI_TYPE_ZERO_BYTE;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 7500: hash_type = HASH_TYPE_KRB5PA;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9080 kern_type = KERN_TYPE_KRB5PA;
9081 dgst_size = DGST_SIZE_4_4;
9082 parse_func = krb5pa_parse_hash;
9083 sort_by_digest = sort_by_digest_4_4;
9084 opti_type = OPTI_TYPE_ZERO_BYTE
9085 | OPTI_TYPE_NOT_ITERATED;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 7600: hash_type = HASH_TYPE_SHA1;
9093 salt_type = SALT_TYPE_INTERN;
9094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_BE
9096 | OPTS_TYPE_PT_ADD80
9097 | OPTS_TYPE_PT_ADDBITS15;
9098 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9099 dgst_size = DGST_SIZE_4_5;
9100 parse_func = redmine_parse_hash;
9101 sort_by_digest = sort_by_digest_4_5;
9102 opti_type = OPTI_TYPE_ZERO_BYTE
9103 | OPTI_TYPE_PRECOMPUTE_INIT
9104 | OPTI_TYPE_EARLY_SKIP
9105 | OPTI_TYPE_NOT_ITERATED
9106 | OPTI_TYPE_PREPENDED_SALT;
9107 dgst_pos0 = 3;
9108 dgst_pos1 = 4;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 1;
9111 break;
9112
9113 case 7700: hash_type = HASH_TYPE_SAPB;
9114 salt_type = SALT_TYPE_EMBEDDED;
9115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_LE
9117 | OPTS_TYPE_PT_UPPER
9118 | OPTS_TYPE_ST_UPPER;
9119 kern_type = KERN_TYPE_SAPB;
9120 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9121 parse_func = sapb_parse_hash;
9122 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9123 opti_type = OPTI_TYPE_ZERO_BYTE
9124 | OPTI_TYPE_PRECOMPUTE_INIT
9125 | OPTI_TYPE_NOT_ITERATED;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 7800: hash_type = HASH_TYPE_SAPG;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_BE
9136 | OPTS_TYPE_ST_ADD80
9137 | OPTS_TYPE_ST_UPPER;
9138 kern_type = KERN_TYPE_SAPG;
9139 dgst_size = DGST_SIZE_4_5;
9140 parse_func = sapg_parse_hash;
9141 sort_by_digest = sort_by_digest_4_5;
9142 opti_type = OPTI_TYPE_ZERO_BYTE
9143 | OPTI_TYPE_PRECOMPUTE_INIT
9144 | OPTI_TYPE_NOT_ITERATED;
9145 dgst_pos0 = 3;
9146 dgst_pos1 = 4;
9147 dgst_pos2 = 2;
9148 dgst_pos3 = 1;
9149 break;
9150
9151 case 7900: hash_type = HASH_TYPE_SHA512;
9152 salt_type = SALT_TYPE_EMBEDDED;
9153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9154 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9155 kern_type = KERN_TYPE_DRUPAL7;
9156 dgst_size = DGST_SIZE_8_8;
9157 parse_func = drupal7_parse_hash;
9158 sort_by_digest = sort_by_digest_8_8;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_USES_BITS_64;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 8000: hash_type = HASH_TYPE_SHA256;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_BE
9171 | OPTS_TYPE_PT_UNICODE
9172 | OPTS_TYPE_ST_ADD80
9173 | OPTS_TYPE_ST_HEX;
9174 kern_type = KERN_TYPE_SYBASEASE;
9175 dgst_size = DGST_SIZE_4_8;
9176 parse_func = sybasease_parse_hash;
9177 sort_by_digest = sort_by_digest_4_8;
9178 opti_type = OPTI_TYPE_ZERO_BYTE
9179 | OPTI_TYPE_PRECOMPUTE_INIT
9180 | OPTI_TYPE_EARLY_SKIP
9181 | OPTI_TYPE_NOT_ITERATED
9182 | OPTI_TYPE_RAW_HASH;
9183 dgst_pos0 = 3;
9184 dgst_pos1 = 7;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 6;
9187 break;
9188
9189 case 8100: hash_type = HASH_TYPE_SHA1;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9193 kern_type = KERN_TYPE_NETSCALER;
9194 dgst_size = DGST_SIZE_4_5;
9195 parse_func = netscaler_parse_hash;
9196 sort_by_digest = sort_by_digest_4_5;
9197 opti_type = OPTI_TYPE_ZERO_BYTE
9198 | OPTI_TYPE_PRECOMPUTE_INIT
9199 | OPTI_TYPE_PRECOMPUTE_MERKLE
9200 | OPTI_TYPE_EARLY_SKIP
9201 | OPTI_TYPE_NOT_ITERATED
9202 | OPTI_TYPE_PREPENDED_SALT
9203 | OPTI_TYPE_RAW_HASH;
9204 dgst_pos0 = 3;
9205 dgst_pos1 = 4;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 1;
9208 break;
9209
9210 case 8200: hash_type = HASH_TYPE_SHA256;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_CLOUDKEY;
9215 dgst_size = DGST_SIZE_4_8;
9216 parse_func = cloudkey_parse_hash;
9217 sort_by_digest = sort_by_digest_4_8;
9218 opti_type = OPTI_TYPE_ZERO_BYTE;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 8300: hash_type = HASH_TYPE_SHA1;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_BE
9229 | OPTS_TYPE_ST_HEX
9230 | OPTS_TYPE_ST_ADD80;
9231 kern_type = KERN_TYPE_NSEC3;
9232 dgst_size = DGST_SIZE_4_5;
9233 parse_func = nsec3_parse_hash;
9234 sort_by_digest = sort_by_digest_4_5;
9235 opti_type = OPTI_TYPE_ZERO_BYTE;
9236 dgst_pos0 = 3;
9237 dgst_pos1 = 4;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 1;
9240 break;
9241
9242 case 8400: hash_type = HASH_TYPE_SHA1;
9243 salt_type = SALT_TYPE_INTERN;
9244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_BE
9246 | OPTS_TYPE_PT_ADD80
9247 | OPTS_TYPE_PT_ADDBITS15;
9248 kern_type = KERN_TYPE_WBB3;
9249 dgst_size = DGST_SIZE_4_5;
9250 parse_func = wbb3_parse_hash;
9251 sort_by_digest = sort_by_digest_4_5;
9252 opti_type = OPTI_TYPE_ZERO_BYTE
9253 | OPTI_TYPE_PRECOMPUTE_INIT
9254 | OPTI_TYPE_NOT_ITERATED;
9255 dgst_pos0 = 3;
9256 dgst_pos1 = 4;
9257 dgst_pos2 = 2;
9258 dgst_pos3 = 1;
9259 break;
9260
9261 case 8500: hash_type = HASH_TYPE_DESRACF;
9262 salt_type = SALT_TYPE_EMBEDDED;
9263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_LE
9265 | OPTS_TYPE_ST_UPPER;
9266 kern_type = KERN_TYPE_RACF;
9267 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9268 parse_func = racf_parse_hash;
9269 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9270 opti_type = OPTI_TYPE_ZERO_BYTE
9271 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 8600: hash_type = HASH_TYPE_LOTUS5;
9279 salt_type = SALT_TYPE_NONE;
9280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_LOTUS5;
9283 dgst_size = DGST_SIZE_4_4;
9284 parse_func = lotus5_parse_hash;
9285 sort_by_digest = sort_by_digest_4_4;
9286 opti_type = OPTI_TYPE_EARLY_SKIP
9287 | OPTI_TYPE_NOT_ITERATED
9288 | OPTI_TYPE_NOT_SALTED
9289 | OPTI_TYPE_RAW_HASH;
9290 dgst_pos0 = 0;
9291 dgst_pos1 = 1;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 3;
9294 break;
9295
9296 case 8700: hash_type = HASH_TYPE_LOTUS6;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9300 kern_type = KERN_TYPE_LOTUS6;
9301 dgst_size = DGST_SIZE_4_4;
9302 parse_func = lotus6_parse_hash;
9303 sort_by_digest = sort_by_digest_4_4;
9304 opti_type = OPTI_TYPE_EARLY_SKIP
9305 | OPTI_TYPE_NOT_ITERATED
9306 | OPTI_TYPE_RAW_HASH;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 1;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 3;
9311 break;
9312
9313 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9317 kern_type = KERN_TYPE_ANDROIDFDE;
9318 dgst_size = DGST_SIZE_4_4;
9319 parse_func = androidfde_parse_hash;
9320 sort_by_digest = sort_by_digest_4_4;
9321 opti_type = OPTI_TYPE_ZERO_BYTE;
9322 dgst_pos0 = 0;
9323 dgst_pos1 = 1;
9324 dgst_pos2 = 2;
9325 dgst_pos3 = 3;
9326 break;
9327
9328 case 8900: hash_type = HASH_TYPE_SCRYPT;
9329 salt_type = SALT_TYPE_EMBEDDED;
9330 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9331 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9332 kern_type = KERN_TYPE_SCRYPT;
9333 dgst_size = DGST_SIZE_4_8;
9334 parse_func = scrypt_parse_hash;
9335 sort_by_digest = sort_by_digest_4_8;
9336 opti_type = OPTI_TYPE_ZERO_BYTE;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 9000: hash_type = HASH_TYPE_SHA1;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE
9347 | OPTS_TYPE_ST_GENERATE_LE;
9348 kern_type = KERN_TYPE_PSAFE2;
9349 dgst_size = DGST_SIZE_4_5;
9350 parse_func = psafe2_parse_hash;
9351 sort_by_digest = sort_by_digest_4_5;
9352 opti_type = OPTI_TYPE_ZERO_BYTE;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 9100: hash_type = HASH_TYPE_LOTUS8;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9363 kern_type = KERN_TYPE_LOTUS8;
9364 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9365 parse_func = lotus8_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9367 opti_type = OPTI_TYPE_ZERO_BYTE;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 9200: hash_type = HASH_TYPE_SHA256;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9378 kern_type = KERN_TYPE_PBKDF2_SHA256;
9379 dgst_size = DGST_SIZE_4_32;
9380 parse_func = cisco8_parse_hash;
9381 sort_by_digest = sort_by_digest_4_32;
9382 opti_type = OPTI_TYPE_ZERO_BYTE;
9383 dgst_pos0 = 0;
9384 dgst_pos1 = 1;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 3;
9387 break;
9388
9389 case 9300: hash_type = HASH_TYPE_SCRYPT;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9393 kern_type = KERN_TYPE_SCRYPT;
9394 dgst_size = DGST_SIZE_4_8;
9395 parse_func = cisco9_parse_hash;
9396 sort_by_digest = sort_by_digest_4_8;
9397 opti_type = OPTI_TYPE_ZERO_BYTE;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_OFFICE2007;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = office2007_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_ZERO_BYTE;
9413 dgst_pos0 = 0;
9414 dgst_pos1 = 1;
9415 dgst_pos2 = 2;
9416 dgst_pos3 = 3;
9417 break;
9418
9419 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9420 salt_type = SALT_TYPE_EMBEDDED;
9421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9422 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9423 kern_type = KERN_TYPE_OFFICE2010;
9424 dgst_size = DGST_SIZE_4_4;
9425 parse_func = office2010_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_OFFICE2013;
9439 dgst_size = DGST_SIZE_4_4;
9440 parse_func = office2013_parse_hash;
9441 sort_by_digest = sort_by_digest_4_4;
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9700: 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 | OPTS_TYPE_PT_UNICODE;
9455 kern_type = KERN_TYPE_OLDOFFICE01;
9456 dgst_size = DGST_SIZE_4_4;
9457 parse_func = oldoffice01_parse_hash;
9458 sort_by_digest = sort_by_digest_4_4;
9459 opti_type = OPTI_TYPE_ZERO_BYTE
9460 | OPTI_TYPE_PRECOMPUTE_INIT
9461 | OPTI_TYPE_NOT_ITERATED;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE
9472 | OPTS_TYPE_PT_ADD80;
9473 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9474 dgst_size = DGST_SIZE_4_4;
9475 parse_func = oldoffice01cm1_parse_hash;
9476 sort_by_digest = sort_by_digest_4_4;
9477 opti_type = OPTI_TYPE_ZERO_BYTE
9478 | OPTI_TYPE_PRECOMPUTE_INIT
9479 | OPTI_TYPE_NOT_ITERATED;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE
9490 | OPTS_TYPE_PT_ADD80
9491 | OPTS_TYPE_PT_UNICODE
9492 | OPTS_TYPE_PT_NEVERCRACK;
9493 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9494 dgst_size = DGST_SIZE_4_4;
9495 parse_func = oldoffice01cm2_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 9800: 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_BE
9510 | OPTS_TYPE_PT_ADD80
9511 | OPTS_TYPE_PT_UNICODE;
9512 kern_type = KERN_TYPE_OLDOFFICE34;
9513 dgst_size = DGST_SIZE_4_4;
9514 parse_func = oldoffice34_parse_hash;
9515 sort_by_digest = sort_by_digest_4_4;
9516 opti_type = OPTI_TYPE_ZERO_BYTE
9517 | OPTI_TYPE_PRECOMPUTE_INIT
9518 | OPTI_TYPE_NOT_ITERATED;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9530 dgst_size = DGST_SIZE_4_4;
9531 parse_func = oldoffice34cm1_parse_hash;
9532 sort_by_digest = sort_by_digest_4_4;
9533 opti_type = OPTI_TYPE_ZERO_BYTE
9534 | OPTI_TYPE_PRECOMPUTE_INIT
9535 | OPTI_TYPE_NOT_ITERATED;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_BE
9546 | OPTS_TYPE_PT_ADD80
9547 | OPTS_TYPE_PT_UNICODE
9548 | OPTS_TYPE_PT_NEVERCRACK;
9549 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = oldoffice34cm2_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE
9554 | OPTI_TYPE_PRECOMPUTE_INIT
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 9900: hash_type = HASH_TYPE_MD5;
9563 salt_type = SALT_TYPE_NONE;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9566 kern_type = KERN_TYPE_RADMIN2;
9567 dgst_size = DGST_SIZE_4_4;
9568 parse_func = radmin2_parse_hash;
9569 sort_by_digest = sort_by_digest_4_4;
9570 opti_type = OPTI_TYPE_ZERO_BYTE
9571 | OPTI_TYPE_PRECOMPUTE_INIT
9572 | OPTI_TYPE_EARLY_SKIP
9573 | OPTI_TYPE_NOT_ITERATED
9574 | OPTI_TYPE_NOT_SALTED;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 3;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 1;
9579 break;
9580
9581 case 10000: hash_type = HASH_TYPE_SHA256;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9585 kern_type = KERN_TYPE_PBKDF2_SHA256;
9586 dgst_size = DGST_SIZE_4_32;
9587 parse_func = djangopbkdf2_parse_hash;
9588 sort_by_digest = sort_by_digest_4_32;
9589 opti_type = OPTI_TYPE_ZERO_BYTE;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 10100: hash_type = HASH_TYPE_SIPHASH;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9600 kern_type = KERN_TYPE_SIPHASH;
9601 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9602 parse_func = siphash_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9604 opti_type = OPTI_TYPE_ZERO_BYTE
9605 | OPTI_TYPE_NOT_ITERATED
9606 | OPTI_TYPE_RAW_HASH;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 10200: hash_type = HASH_TYPE_MD5;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE
9617 | OPTS_TYPE_ST_ADD80
9618 | OPTS_TYPE_ST_ADDBITS14;
9619 kern_type = KERN_TYPE_HMACMD5_PW;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = crammd5_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE
9624 | OPTI_TYPE_NOT_ITERATED;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 3;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 1;
9629 break;
9630
9631 case 10300: hash_type = HASH_TYPE_SHA1;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9635 kern_type = KERN_TYPE_SAPH_SHA1;
9636 dgst_size = DGST_SIZE_4_5;
9637 parse_func = saph_sha1_parse_hash;
9638 sort_by_digest = sort_by_digest_4_5;
9639 opti_type = OPTI_TYPE_ZERO_BYTE;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 10400: hash_type = HASH_TYPE_PDFU16;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9650 kern_type = KERN_TYPE_PDF11;
9651 dgst_size = DGST_SIZE_4_4;
9652 parse_func = pdf11_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_NOT_ITERATED;
9656 dgst_pos0 = 0;
9657 dgst_pos1 = 1;
9658 dgst_pos2 = 2;
9659 dgst_pos3 = 3;
9660 break;
9661
9662 case 10410: hash_type = HASH_TYPE_PDFU16;
9663 salt_type = SALT_TYPE_EMBEDDED;
9664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9666 kern_type = KERN_TYPE_PDF11CM1;
9667 dgst_size = DGST_SIZE_4_4;
9668 parse_func = pdf11cm1_parse_hash;
9669 sort_by_digest = sort_by_digest_4_4;
9670 opti_type = OPTI_TYPE_ZERO_BYTE
9671 | OPTI_TYPE_NOT_ITERATED;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 10420: hash_type = HASH_TYPE_PDFU16;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9682 kern_type = KERN_TYPE_PDF11CM2;
9683 dgst_size = DGST_SIZE_4_4;
9684 parse_func = pdf11cm2_parse_hash;
9685 sort_by_digest = sort_by_digest_4_4;
9686 opti_type = OPTI_TYPE_ZERO_BYTE
9687 | OPTI_TYPE_NOT_ITERATED;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 10500: hash_type = HASH_TYPE_PDFU16;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_PDF14;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = pdf14_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE
9703 | OPTI_TYPE_NOT_ITERATED;
9704 dgst_pos0 = 0;
9705 dgst_pos1 = 1;
9706 dgst_pos2 = 2;
9707 dgst_pos3 = 3;
9708 break;
9709
9710 case 10600: hash_type = HASH_TYPE_SHA256;
9711 salt_type = SALT_TYPE_EMBEDDED;
9712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9713 opts_type = OPTS_TYPE_PT_GENERATE_BE
9714 | OPTS_TYPE_ST_ADD80
9715 | OPTS_TYPE_ST_ADDBITS15
9716 | OPTS_TYPE_HASH_COPY;
9717 kern_type = KERN_TYPE_SHA256_PWSLT;
9718 dgst_size = DGST_SIZE_4_8;
9719 parse_func = pdf17l3_parse_hash;
9720 sort_by_digest = sort_by_digest_4_8;
9721 opti_type = OPTI_TYPE_ZERO_BYTE
9722 | OPTI_TYPE_PRECOMPUTE_INIT
9723 | OPTI_TYPE_PRECOMPUTE_MERKLE
9724 | OPTI_TYPE_EARLY_SKIP
9725 | OPTI_TYPE_NOT_ITERATED
9726 | OPTI_TYPE_APPENDED_SALT
9727 | OPTI_TYPE_RAW_HASH;
9728 dgst_pos0 = 3;
9729 dgst_pos1 = 7;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 6;
9732 break;
9733
9734 case 10700: hash_type = HASH_TYPE_PDFU32;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE
9738 | OPTS_TYPE_HASH_COPY;
9739 kern_type = KERN_TYPE_PDF17L8;
9740 dgst_size = DGST_SIZE_4_8;
9741 parse_func = pdf17l8_parse_hash;
9742 sort_by_digest = sort_by_digest_4_8;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 10800: hash_type = HASH_TYPE_SHA384;
9752 salt_type = SALT_TYPE_NONE;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_PT_ADD80
9756 | OPTS_TYPE_PT_ADDBITS15;
9757 kern_type = KERN_TYPE_SHA384;
9758 dgst_size = DGST_SIZE_8_8;
9759 parse_func = sha384_parse_hash;
9760 sort_by_digest = sort_by_digest_8_8;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_PRECOMPUTE_INIT
9763 | OPTI_TYPE_PRECOMPUTE_MERKLE
9764 | OPTI_TYPE_EARLY_SKIP
9765 | OPTI_TYPE_NOT_ITERATED
9766 | OPTI_TYPE_NOT_SALTED
9767 | OPTI_TYPE_USES_BITS_64
9768 | OPTI_TYPE_RAW_HASH;
9769 dgst_pos0 = 6;
9770 dgst_pos1 = 7;
9771 dgst_pos2 = 4;
9772 dgst_pos3 = 5;
9773 break;
9774
9775 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_ST_BASE64
9780 | OPTS_TYPE_HASH_COPY;
9781 kern_type = KERN_TYPE_PBKDF2_SHA256;
9782 dgst_size = DGST_SIZE_4_32;
9783 parse_func = pbkdf2_sha256_parse_hash;
9784 sort_by_digest = sort_by_digest_4_32;
9785 opti_type = OPTI_TYPE_ZERO_BYTE;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 11000: hash_type = HASH_TYPE_MD5;
9793 salt_type = SALT_TYPE_INTERN;
9794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_LE
9796 | OPTS_TYPE_PT_ADD80;
9797 kern_type = KERN_TYPE_PRESTASHOP;
9798 dgst_size = DGST_SIZE_4_4;
9799 parse_func = prestashop_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4;
9801 opti_type = OPTI_TYPE_ZERO_BYTE
9802 | OPTI_TYPE_PRECOMPUTE_INIT
9803 | OPTI_TYPE_NOT_ITERATED
9804 | OPTI_TYPE_PREPENDED_SALT;
9805 dgst_pos0 = 0;
9806 dgst_pos1 = 3;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 1;
9809 break;
9810
9811 case 11100: hash_type = HASH_TYPE_MD5;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_LE
9815 | OPTS_TYPE_ST_ADD80;
9816 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9817 dgst_size = DGST_SIZE_4_4;
9818 parse_func = postgresql_auth_parse_hash;
9819 sort_by_digest = sort_by_digest_4_4;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_PRECOMPUTE_INIT
9822 | OPTI_TYPE_PRECOMPUTE_MERKLE
9823 | OPTI_TYPE_EARLY_SKIP;
9824 dgst_pos0 = 0;
9825 dgst_pos1 = 3;
9826 dgst_pos2 = 2;
9827 dgst_pos3 = 1;
9828 break;
9829
9830 case 11200: hash_type = HASH_TYPE_SHA1;
9831 salt_type = SALT_TYPE_EMBEDDED;
9832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_BE
9834 | OPTS_TYPE_PT_ADD80
9835 | OPTS_TYPE_ST_HEX;
9836 kern_type = KERN_TYPE_MYSQL_AUTH;
9837 dgst_size = DGST_SIZE_4_5;
9838 parse_func = mysql_auth_parse_hash;
9839 sort_by_digest = sort_by_digest_4_5;
9840 opti_type = OPTI_TYPE_ZERO_BYTE
9841 | OPTI_TYPE_EARLY_SKIP;
9842 dgst_pos0 = 3;
9843 dgst_pos1 = 4;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 1;
9846 break;
9847
9848 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_HEX
9853 | OPTS_TYPE_ST_ADD80;
9854 kern_type = KERN_TYPE_BITCOIN_WALLET;
9855 dgst_size = DGST_SIZE_4_4;
9856 parse_func = bitcoin_wallet_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 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 11400: hash_type = HASH_TYPE_MD5;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_PT_ADD80
9870 | OPTS_TYPE_HASH_COPY;
9871 kern_type = KERN_TYPE_SIP_AUTH;
9872 dgst_size = DGST_SIZE_4_4;
9873 parse_func = sip_auth_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4;
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 3;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 1;
9880 break;
9881
9882 case 11500: hash_type = HASH_TYPE_CRC32;
9883 salt_type = SALT_TYPE_INTERN;
9884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_ST_GENERATE_LE
9887 | OPTS_TYPE_ST_HEX;
9888 kern_type = KERN_TYPE_CRC32;
9889 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9890 parse_func = crc32_parse_hash;
9891 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9892 opti_type = OPTI_TYPE_ZERO_BYTE;
9893 dgst_pos0 = 0;
9894 dgst_pos1 = 1;
9895 dgst_pos2 = 2;
9896 dgst_pos3 = 3;
9897 break;
9898
9899 case 11600: hash_type = HASH_TYPE_AES;
9900 salt_type = SALT_TYPE_EMBEDDED;
9901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9902 opts_type = OPTS_TYPE_PT_GENERATE_LE
9903 | OPTS_TYPE_PT_NEVERCRACK;
9904 kern_type = KERN_TYPE_SEVEN_ZIP;
9905 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9906 parse_func = seven_zip_parse_hash;
9907 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9908 opti_type = OPTI_TYPE_ZERO_BYTE;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 1;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 3;
9913 break;
9914
9915 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9916 salt_type = SALT_TYPE_NONE;
9917 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_PT_ADD01;
9920 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9921 dgst_size = DGST_SIZE_4_8;
9922 parse_func = gost2012sbog_256_parse_hash;
9923 sort_by_digest = sort_by_digest_4_8;
9924 opti_type = OPTI_TYPE_ZERO_BYTE;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 1;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 3;
9929 break;
9930
9931 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9932 salt_type = SALT_TYPE_NONE;
9933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE
9935 | OPTS_TYPE_PT_ADD01;
9936 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9937 dgst_size = DGST_SIZE_4_16;
9938 parse_func = gost2012sbog_512_parse_hash;
9939 sort_by_digest = sort_by_digest_4_16;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE
9951 | OPTS_TYPE_ST_BASE64
9952 | OPTS_TYPE_HASH_COPY;
9953 kern_type = KERN_TYPE_PBKDF2_MD5;
9954 dgst_size = DGST_SIZE_4_32;
9955 parse_func = pbkdf2_md5_parse_hash;
9956 sort_by_digest = sort_by_digest_4_32;
9957 opti_type = OPTI_TYPE_ZERO_BYTE;
9958 dgst_pos0 = 0;
9959 dgst_pos1 = 1;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 3;
9962 break;
9963
9964 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9965 salt_type = SALT_TYPE_EMBEDDED;
9966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_ST_BASE64
9969 | OPTS_TYPE_HASH_COPY;
9970 kern_type = KERN_TYPE_PBKDF2_SHA1;
9971 dgst_size = DGST_SIZE_4_32;
9972 parse_func = pbkdf2_sha1_parse_hash;
9973 sort_by_digest = sort_by_digest_4_32;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_ST_BASE64
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_PBKDF2_SHA512;
9988 dgst_size = DGST_SIZE_8_16;
9989 parse_func = pbkdf2_sha512_parse_hash;
9990 sort_by_digest = sort_by_digest_8_16;
9991 opti_type = OPTI_TYPE_ZERO_BYTE
9992 | OPTI_TYPE_USES_BITS_64;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10000 salt_type = SALT_TYPE_EMBEDDED;
10001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10003 kern_type = KERN_TYPE_ECRYPTFS;
10004 dgst_size = DGST_SIZE_8_8;
10005 parse_func = ecryptfs_parse_hash;
10006 sort_by_digest = sort_by_digest_8_8;
10007 opti_type = OPTI_TYPE_ZERO_BYTE
10008 | OPTI_TYPE_USES_BITS_64;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 12300: hash_type = HASH_TYPE_ORACLET;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10019 kern_type = KERN_TYPE_ORACLET;
10020 dgst_size = DGST_SIZE_8_16;
10021 parse_func = oraclet_parse_hash;
10022 sort_by_digest = sort_by_digest_8_16;
10023 opti_type = OPTI_TYPE_ZERO_BYTE
10024 | OPTI_TYPE_USES_BITS_64;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10035 kern_type = KERN_TYPE_BSDICRYPT;
10036 dgst_size = DGST_SIZE_4_4;
10037 parse_func = bsdicrypt_parse_hash;
10038 sort_by_digest = sort_by_digest_4_4;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 12500: hash_type = HASH_TYPE_RAR3HP;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10051 kern_type = KERN_TYPE_RAR3;
10052 dgst_size = DGST_SIZE_4_4;
10053 parse_func = rar3hp_parse_hash;
10054 sort_by_digest = sort_by_digest_4_4;
10055 opti_type = OPTI_TYPE_ZERO_BYTE;
10056 dgst_pos0 = 0;
10057 dgst_pos1 = 1;
10058 dgst_pos2 = 2;
10059 dgst_pos3 = 3;
10060 break;
10061
10062 case 12600: hash_type = HASH_TYPE_SHA256;
10063 salt_type = SALT_TYPE_INTERN;
10064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10065 opts_type = OPTS_TYPE_PT_GENERATE_BE
10066 | OPTS_TYPE_PT_ADD80;
10067 kern_type = KERN_TYPE_CF10;
10068 dgst_size = DGST_SIZE_4_8;
10069 parse_func = cf10_parse_hash;
10070 sort_by_digest = sort_by_digest_4_8;
10071 opti_type = OPTI_TYPE_ZERO_BYTE
10072 | OPTI_TYPE_PRECOMPUTE_INIT
10073 | OPTI_TYPE_EARLY_SKIP
10074 | OPTI_TYPE_NOT_ITERATED;
10075 dgst_pos0 = 3;
10076 dgst_pos1 = 7;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 6;
10079 break;
10080
10081 case 12700: hash_type = HASH_TYPE_AES;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE
10085 | OPTS_TYPE_HASH_COPY;
10086 kern_type = KERN_TYPE_MYWALLET;
10087 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10088 parse_func = mywallet_parse_hash;
10089 sort_by_digest = sort_by_digest_4_5;
10090 opti_type = OPTI_TYPE_ZERO_BYTE;
10091 dgst_pos0 = 0;
10092 dgst_pos1 = 1;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 3;
10095 break;
10096
10097 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10101 kern_type = KERN_TYPE_MS_DRSR;
10102 dgst_size = DGST_SIZE_4_8;
10103 parse_func = ms_drsr_parse_hash;
10104 sort_by_digest = sort_by_digest_4_8;
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10116 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10117 dgst_size = DGST_SIZE_4_8;
10118 parse_func = androidfde_samsung_parse_hash;
10119 sort_by_digest = sort_by_digest_4_8;
10120 opti_type = OPTI_TYPE_ZERO_BYTE;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 1;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 3;
10125 break;
10126
10127 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10131 kern_type = KERN_TYPE_RAR5;
10132 dgst_size = DGST_SIZE_4_4;
10133 parse_func = rar5_parse_hash;
10134 sort_by_digest = sort_by_digest_4_4;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10146 kern_type = KERN_TYPE_KRB5TGS;
10147 dgst_size = DGST_SIZE_4_4;
10148 parse_func = krb5tgs_parse_hash;
10149 sort_by_digest = sort_by_digest_4_4;
10150 opti_type = OPTI_TYPE_ZERO_BYTE
10151 | OPTI_TYPE_NOT_ITERATED;
10152 dgst_pos0 = 0;
10153 dgst_pos1 = 1;
10154 dgst_pos2 = 2;
10155 dgst_pos3 = 3;
10156 break;
10157
10158 case 13200: hash_type = HASH_TYPE_AES;
10159 salt_type = SALT_TYPE_EMBEDDED;
10160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10161 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10162 kern_type = KERN_TYPE_AXCRYPT;
10163 dgst_size = DGST_SIZE_4_4;
10164 parse_func = axcrypt_parse_hash;
10165 sort_by_digest = sort_by_digest_4_4;
10166 opti_type = OPTI_TYPE_ZERO_BYTE;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 1;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 3;
10171 break;
10172
10173 case 13300: hash_type = HASH_TYPE_SHA1;
10174 salt_type = SALT_TYPE_NONE;
10175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_BE
10177 | OPTS_TYPE_PT_ADD80
10178 | OPTS_TYPE_PT_ADDBITS15;
10179 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10180 dgst_size = DGST_SIZE_4_5;
10181 parse_func = sha1axcrypt_parse_hash;
10182 sort_by_digest = sort_by_digest_4_5;
10183 opti_type = OPTI_TYPE_ZERO_BYTE
10184 | OPTI_TYPE_PRECOMPUTE_INIT
10185 | OPTI_TYPE_EARLY_SKIP
10186 | OPTI_TYPE_NOT_ITERATED
10187 | OPTI_TYPE_NOT_SALTED;
10188 dgst_pos0 = 0;
10189 dgst_pos1 = 4;
10190 dgst_pos2 = 3;
10191 dgst_pos3 = 2;
10192 break;
10193
10194 case 13400: hash_type = HASH_TYPE_AES;
10195 salt_type = SALT_TYPE_EMBEDDED;
10196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10198 kern_type = KERN_TYPE_KEEPASS;
10199 dgst_size = DGST_SIZE_4_4;
10200 parse_func = keepass_parse_hash;
10201 sort_by_digest = sort_by_digest_4_4;
10202 opti_type = OPTI_TYPE_ZERO_BYTE;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 13500: hash_type = HASH_TYPE_SHA1;
10210 salt_type = SALT_TYPE_EMBEDDED;
10211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_BE
10213 | OPTS_TYPE_PT_UNICODE
10214 | OPTS_TYPE_PT_ADD80;
10215 kern_type = KERN_TYPE_PSTOKEN;
10216 dgst_size = DGST_SIZE_4_5;
10217 parse_func = pstoken_parse_hash;
10218 sort_by_digest = sort_by_digest_4_5;
10219 opti_type = OPTI_TYPE_ZERO_BYTE
10220 | OPTI_TYPE_PRECOMPUTE_INIT
10221 | OPTI_TYPE_EARLY_SKIP
10222 | OPTI_TYPE_NOT_ITERATED
10223 | OPTI_TYPE_PREPENDED_SALT
10224 | OPTI_TYPE_RAW_HASH;
10225 dgst_pos0 = 3;
10226 dgst_pos1 = 4;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 1;
10229 break;
10230
10231 default: usage_mini_print (PROGNAME); return (-1);
10232 }
10233
10234 /**
10235 * parser
10236 */
10237
10238 data.parse_func = parse_func;
10239
10240 /**
10241 * misc stuff
10242 */
10243
10244 if (hex_salt)
10245 {
10246 if (salt_type == SALT_TYPE_INTERN)
10247 {
10248 opts_type |= OPTS_TYPE_ST_HEX;
10249 }
10250 else
10251 {
10252 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10253
10254 return (-1);
10255 }
10256 }
10257
10258 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10259 | (salt_type == SALT_TYPE_EXTERN)
10260 | (salt_type == SALT_TYPE_EMBEDDED)
10261 | (salt_type == SALT_TYPE_VIRTUAL));
10262
10263 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10264
10265 data.hash_type = hash_type;
10266 data.attack_mode = attack_mode;
10267 data.attack_kern = attack_kern;
10268 data.attack_exec = attack_exec;
10269 data.kern_type = kern_type;
10270 data.opts_type = opts_type;
10271 data.dgst_size = dgst_size;
10272 data.salt_type = salt_type;
10273 data.isSalted = isSalted;
10274 data.sort_by_digest = sort_by_digest;
10275 data.dgst_pos0 = dgst_pos0;
10276 data.dgst_pos1 = dgst_pos1;
10277 data.dgst_pos2 = dgst_pos2;
10278 data.dgst_pos3 = dgst_pos3;
10279
10280 esalt_size = 0;
10281
10282 switch (hash_mode)
10283 {
10284 case 2500: esalt_size = sizeof (wpa_t); break;
10285 case 5300: esalt_size = sizeof (ikepsk_t); break;
10286 case 5400: esalt_size = sizeof (ikepsk_t); break;
10287 case 5500: esalt_size = sizeof (netntlm_t); break;
10288 case 5600: esalt_size = sizeof (netntlm_t); break;
10289 case 6211: esalt_size = sizeof (tc_t); break;
10290 case 6212: esalt_size = sizeof (tc_t); break;
10291 case 6213: esalt_size = sizeof (tc_t); break;
10292 case 6221: esalt_size = sizeof (tc_t); break;
10293 case 6222: esalt_size = sizeof (tc_t); break;
10294 case 6223: esalt_size = sizeof (tc_t); break;
10295 case 6231: esalt_size = sizeof (tc_t); break;
10296 case 6232: esalt_size = sizeof (tc_t); break;
10297 case 6233: esalt_size = sizeof (tc_t); break;
10298 case 6241: esalt_size = sizeof (tc_t); break;
10299 case 6242: esalt_size = sizeof (tc_t); break;
10300 case 6243: esalt_size = sizeof (tc_t); break;
10301 case 6600: esalt_size = sizeof (agilekey_t); break;
10302 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10303 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10304 case 7300: esalt_size = sizeof (rakp_t); break;
10305 case 7500: esalt_size = sizeof (krb5pa_t); break;
10306 case 8200: esalt_size = sizeof (cloudkey_t); break;
10307 case 8800: esalt_size = sizeof (androidfde_t); break;
10308 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10309 case 9400: esalt_size = sizeof (office2007_t); break;
10310 case 9500: esalt_size = sizeof (office2010_t); break;
10311 case 9600: esalt_size = sizeof (office2013_t); break;
10312 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10313 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10314 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10315 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10316 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10317 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10318 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10319 case 10200: esalt_size = sizeof (cram_md5_t); break;
10320 case 10400: esalt_size = sizeof (pdf_t); break;
10321 case 10410: esalt_size = sizeof (pdf_t); break;
10322 case 10420: esalt_size = sizeof (pdf_t); break;
10323 case 10500: esalt_size = sizeof (pdf_t); break;
10324 case 10600: esalt_size = sizeof (pdf_t); break;
10325 case 10700: esalt_size = sizeof (pdf_t); break;
10326 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10327 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10328 case 11400: esalt_size = sizeof (sip_t); break;
10329 case 11600: esalt_size = sizeof (seven_zip_t); break;
10330 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10331 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10332 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10333 case 13000: esalt_size = sizeof (rar5_t); break;
10334 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10335 case 13400: esalt_size = sizeof (keepass_t); break;
10336 case 13500: esalt_size = sizeof (pstoken_t); break;
10337 }
10338
10339 data.esalt_size = esalt_size;
10340
10341 /**
10342 * choose dictionary parser
10343 */
10344
10345 if (hash_type == HASH_TYPE_LM)
10346 {
10347 get_next_word_func = get_next_word_lm;
10348 }
10349 else if (opts_type & OPTS_TYPE_PT_UPPER)
10350 {
10351 get_next_word_func = get_next_word_uc;
10352 }
10353 else
10354 {
10355 get_next_word_func = get_next_word_std;
10356 }
10357
10358 /**
10359 * dictstat
10360 */
10361
10362 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10363
10364 #ifdef _POSIX
10365 size_t dictstat_nmemb = 0;
10366 #endif
10367
10368 #ifdef _WIN
10369 uint dictstat_nmemb = 0;
10370 #endif
10371
10372 char dictstat[256] = { 0 };
10373
10374 FILE *dictstat_fp = NULL;
10375
10376 if (keyspace == 0)
10377 {
10378 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10379
10380 dictstat_fp = fopen (dictstat, "rb");
10381
10382 if (dictstat_fp)
10383 {
10384 #ifdef _POSIX
10385 struct stat tmpstat;
10386
10387 fstat (fileno (dictstat_fp), &tmpstat);
10388 #endif
10389
10390 #ifdef _WIN
10391 struct stat64 tmpstat;
10392
10393 _fstat64 (fileno (dictstat_fp), &tmpstat);
10394 #endif
10395
10396 if (tmpstat.st_mtime < COMPTIME)
10397 {
10398 /* with v0.15 the format changed so we have to ensure user is using a good version
10399 since there is no version-header in the dictstat file */
10400
10401 fclose (dictstat_fp);
10402
10403 unlink (dictstat);
10404 }
10405 else
10406 {
10407 while (!feof (dictstat_fp))
10408 {
10409 dictstat_t d;
10410
10411 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10412
10413 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10414
10415 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10416 {
10417 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10418
10419 return -1;
10420 }
10421 }
10422
10423 fclose (dictstat_fp);
10424 }
10425 }
10426 }
10427
10428 /**
10429 * potfile
10430 */
10431
10432 char potfile[256] = { 0 };
10433
10434 if (potfile_path == NULL)
10435 {
10436 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10437 }
10438 else
10439 {
10440 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10441 }
10442
10443 data.pot_fp = NULL;
10444
10445 FILE *out_fp = NULL;
10446 FILE *pot_fp = NULL;
10447
10448 if (show == 1 || left == 1)
10449 {
10450 pot_fp = fopen (potfile, "rb");
10451
10452 if (pot_fp == NULL)
10453 {
10454 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10455
10456 return (-1);
10457 }
10458
10459 if (outfile != NULL)
10460 {
10461 if ((out_fp = fopen (outfile, "ab")) == NULL)
10462 {
10463 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10464
10465 fclose (pot_fp);
10466
10467 return (-1);
10468 }
10469 }
10470 else
10471 {
10472 out_fp = stdout;
10473 }
10474 }
10475 else
10476 {
10477 if (potfile_disable == 0)
10478 {
10479 pot_fp = fopen (potfile, "ab");
10480
10481 if (pot_fp == NULL)
10482 {
10483 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10484
10485 return (-1);
10486 }
10487
10488 data.pot_fp = pot_fp;
10489 }
10490 }
10491
10492 pot_t *pot = NULL;
10493
10494 uint pot_cnt = 0;
10495 uint pot_avail = 0;
10496
10497 if (show == 1 || left == 1)
10498 {
10499 SUPPRESS_OUTPUT = 1;
10500
10501 pot_avail = count_lines (pot_fp);
10502
10503 rewind (pot_fp);
10504
10505 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10506
10507 uint pot_hashes_avail = 0;
10508
10509 uint line_num = 0;
10510
10511 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10512
10513 while (!feof (pot_fp))
10514 {
10515 line_num++;
10516
10517 int line_len = fgetl (pot_fp, line_buf);
10518
10519 if (line_len == 0) continue;
10520
10521 char *plain_buf = line_buf + line_len;
10522
10523 pot_t *pot_ptr = &pot[pot_cnt];
10524
10525 hash_t *hashes_buf = &pot_ptr->hash;
10526
10527 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10528 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10529
10530 if (pot_cnt == pot_hashes_avail)
10531 {
10532 uint pos = 0;
10533
10534 for (pos = 0; pos < INCR_POT; pos++)
10535 {
10536 if ((pot_cnt + pos) >= pot_avail) break;
10537
10538 pot_t *tmp_pot = &pot[pot_cnt + pos];
10539
10540 hash_t *tmp_hash = &tmp_pot->hash;
10541
10542 tmp_hash->digest = mymalloc (dgst_size);
10543
10544 if (isSalted)
10545 {
10546 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10547 }
10548
10549 if (esalt_size)
10550 {
10551 tmp_hash->esalt = mymalloc (esalt_size);
10552 }
10553
10554 pot_hashes_avail++;
10555 }
10556 }
10557
10558 int plain_len = 0;
10559
10560 int parser_status;
10561
10562 int iter = MAX_CUT_TRIES;
10563
10564 do
10565 {
10566 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10567 {
10568 if (line_buf[i] == ':')
10569 {
10570 line_len--;
10571
10572 break;
10573 }
10574 }
10575
10576 if (data.hash_mode != 2500)
10577 {
10578 parser_status = parse_func (line_buf, line_len, hashes_buf);
10579 }
10580 else
10581 {
10582 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10583
10584 if (line_len > max_salt_size)
10585 {
10586 parser_status = PARSER_GLOBAL_LENGTH;
10587 }
10588 else
10589 {
10590 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10591
10592 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10593
10594 hashes_buf->salt->salt_len = line_len;
10595
10596 parser_status = PARSER_OK;
10597 }
10598 }
10599
10600 // if NOT parsed without error, we add the ":" to the plain
10601
10602 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10603 {
10604 plain_len++;
10605 plain_buf--;
10606 }
10607
10608 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10609
10610 if (parser_status < PARSER_GLOBAL_ZERO)
10611 {
10612 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10613
10614 continue;
10615 }
10616
10617 if (plain_len >= 255) continue;
10618
10619 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10620
10621 pot_ptr->plain_len = plain_len;
10622
10623 pot_cnt++;
10624 }
10625
10626 myfree (line_buf);
10627
10628 fclose (pot_fp);
10629
10630 SUPPRESS_OUTPUT = 0;
10631
10632 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10633 }
10634
10635 /**
10636 * word len
10637 */
10638
10639 uint pw_min = PW_MIN;
10640 uint pw_max = PW_MAX;
10641
10642 switch (hash_mode)
10643 {
10644 case 125: if (pw_max > 32) pw_max = 32;
10645 break;
10646 case 400: if (pw_max > 40) pw_max = 40;
10647 break;
10648 case 500: if (pw_max > 16) pw_max = 16;
10649 break;
10650 case 1500: if (pw_max > 8) pw_max = 8;
10651 break;
10652 case 1600: if (pw_max > 16) pw_max = 16;
10653 break;
10654 case 1800: if (pw_max > 16) pw_max = 16;
10655 break;
10656 case 2100: if (pw_max > 16) pw_max = 16;
10657 break;
10658 case 2500: if (pw_min < 8) pw_min = 8;
10659 break;
10660 case 3000: if (pw_max > 7) pw_max = 7;
10661 break;
10662 case 5200: if (pw_max > 24) pw_max = 24;
10663 break;
10664 case 5800: if (pw_max > 16) pw_max = 16;
10665 break;
10666 case 6300: if (pw_max > 16) pw_max = 16;
10667 break;
10668 case 7400: if (pw_max > 16) pw_max = 16;
10669 break;
10670 case 7900: if (pw_max > 48) pw_max = 48;
10671 break;
10672 case 8500: if (pw_max > 8) pw_max = 8;
10673 break;
10674 case 8600: if (pw_max > 16) pw_max = 16;
10675 break;
10676 case 9710: pw_min = 5;
10677 pw_max = 5;
10678 break;
10679 case 9810: pw_min = 5;
10680 pw_max = 5;
10681 break;
10682 case 10410: pw_min = 5;
10683 pw_max = 5;
10684 break;
10685 case 10300: if (pw_max < 3) pw_min = 3;
10686 if (pw_max > 40) pw_max = 40;
10687 break;
10688 case 10500: if (pw_max < 3) pw_min = 3;
10689 if (pw_max > 40) pw_max = 40;
10690 break;
10691 case 10700: if (pw_max > 16) pw_max = 16;
10692 break;
10693 case 11300: if (pw_max > 40) pw_max = 40;
10694 break;
10695 case 11600: if (pw_max > 32) pw_max = 32;
10696 break;
10697 case 12500: if (pw_max > 20) pw_max = 20;
10698 break;
10699 case 12800: if (pw_max > 24) pw_max = 24;
10700 break;
10701 }
10702
10703 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10704 {
10705 switch (attack_kern)
10706 {
10707 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10708 break;
10709 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10710 break;
10711 }
10712 }
10713
10714 /**
10715 * charsets : keep them together for more easy maintainnce
10716 */
10717
10718 cs_t mp_sys[6] = { { { 0 }, 0 } };
10719 cs_t mp_usr[4] = { { { 0 }, 0 } };
10720
10721 mp_setup_sys (mp_sys);
10722
10723 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10724 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10725 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10726 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10727
10728 /**
10729 * load hashes, part I: find input mode, count hashes
10730 */
10731
10732 uint hashlist_mode = 0;
10733 uint hashlist_format = HLFMT_HASHCAT;
10734
10735 uint hashes_avail = 0;
10736
10737 if (benchmark == 0)
10738 {
10739 struct stat f;
10740
10741 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10742
10743 if ((hash_mode == 2500) ||
10744 (hash_mode == 5200) ||
10745 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10746 (hash_mode == 9000))
10747 {
10748 hashlist_mode = HL_MODE_ARG;
10749
10750 char *hashfile = myargv[optind];
10751
10752 data.hashfile = hashfile;
10753
10754 logfile_top_var_string ("target", hashfile);
10755 }
10756
10757 if (hashlist_mode == HL_MODE_ARG)
10758 {
10759 if (hash_mode == 2500)
10760 {
10761 struct stat st;
10762
10763 if (stat (data.hashfile, &st) == -1)
10764 {
10765 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10766
10767 return (-1);
10768 }
10769
10770 hashes_avail = st.st_size / sizeof (hccap_t);
10771 }
10772 else
10773 {
10774 hashes_avail = 1;
10775 }
10776 }
10777 else if (hashlist_mode == HL_MODE_FILE)
10778 {
10779 char *hashfile = myargv[optind];
10780
10781 data.hashfile = hashfile;
10782
10783 logfile_top_var_string ("target", hashfile);
10784
10785 FILE *fp = NULL;
10786
10787 if ((fp = fopen (hashfile, "rb")) == NULL)
10788 {
10789 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10790
10791 return (-1);
10792 }
10793
10794 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10795
10796 hashes_avail = count_lines (fp);
10797
10798 rewind (fp);
10799
10800 if (hashes_avail == 0)
10801 {
10802 log_error ("ERROR: hashfile is empty or corrupt");
10803
10804 fclose (fp);
10805
10806 return (-1);
10807 }
10808
10809 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10810
10811 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10812 {
10813 log_error ("ERROR: remove not supported in native hashfile-format mode");
10814
10815 fclose (fp);
10816
10817 return (-1);
10818 }
10819
10820 fclose (fp);
10821 }
10822 }
10823 else
10824 {
10825 hashlist_mode = HL_MODE_ARG;
10826
10827 hashes_avail = 1;
10828 }
10829
10830 if (hash_mode == 3000) hashes_avail *= 2;
10831
10832 data.hashlist_mode = hashlist_mode;
10833 data.hashlist_format = hashlist_format;
10834
10835 logfile_top_uint (hashlist_mode);
10836 logfile_top_uint (hashlist_format);
10837
10838 /**
10839 * load hashes, part II: allocate required memory, set pointers
10840 */
10841
10842 hash_t *hashes_buf = NULL;
10843 void *digests_buf = NULL;
10844 salt_t *salts_buf = NULL;
10845 void *esalts_buf = NULL;
10846
10847 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10848
10849 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10850
10851 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10852 {
10853 u32 hash_pos;
10854
10855 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10856 {
10857 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10858
10859 hashes_buf[hash_pos].hash_info = hash_info;
10860
10861 if (username && (remove || show || left))
10862 {
10863 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10864 }
10865
10866 if (benchmark)
10867 {
10868 hash_info->orighash = (char *) mymalloc (256);
10869 }
10870 }
10871 }
10872
10873 if (isSalted)
10874 {
10875 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10876
10877 if (esalt_size)
10878 {
10879 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10880 }
10881 }
10882 else
10883 {
10884 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10885 }
10886
10887 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10888 {
10889 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10890
10891 if (isSalted)
10892 {
10893 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10894
10895 if (esalt_size)
10896 {
10897 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10898 }
10899 }
10900 else
10901 {
10902 hashes_buf[hash_pos].salt = &salts_buf[0];
10903 }
10904 }
10905
10906 /**
10907 * load hashes, part III: parse hashes or generate them if benchmark
10908 */
10909
10910 uint hashes_cnt = 0;
10911
10912 if (benchmark == 0)
10913 {
10914 if (keyspace == 1)
10915 {
10916 // useless to read hash file for keyspace, cheat a little bit w/ optind
10917 }
10918 else if (hashes_avail == 0)
10919 {
10920 }
10921 else if (hashlist_mode == HL_MODE_ARG)
10922 {
10923 char *input_buf = myargv[optind];
10924
10925 uint input_len = strlen (input_buf);
10926
10927 logfile_top_var_string ("target", input_buf);
10928
10929 char *hash_buf = NULL;
10930 int hash_len = 0;
10931
10932 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10933
10934 bool hash_fmt_error = 0;
10935
10936 if (hash_len < 1) hash_fmt_error = 1;
10937 if (hash_buf == NULL) hash_fmt_error = 1;
10938
10939 if (hash_fmt_error)
10940 {
10941 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10942 }
10943 else
10944 {
10945 if (opts_type & OPTS_TYPE_HASH_COPY)
10946 {
10947 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10948
10949 hash_info_tmp->orighash = mystrdup (hash_buf);
10950 }
10951
10952 if (isSalted)
10953 {
10954 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10955 }
10956
10957 int parser_status = PARSER_OK;
10958
10959 if (hash_mode == 2500)
10960 {
10961 if (hash_len == 0)
10962 {
10963 log_error ("ERROR: hccap file not specified");
10964
10965 return (-1);
10966 }
10967
10968 hashlist_mode = HL_MODE_FILE;
10969
10970 data.hashlist_mode = hashlist_mode;
10971
10972 FILE *fp = fopen (hash_buf, "rb");
10973
10974 if (fp == NULL)
10975 {
10976 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10977
10978 return (-1);
10979 }
10980
10981 if (hashes_avail < 1)
10982 {
10983 log_error ("ERROR: hccap file is empty or corrupt");
10984
10985 fclose (fp);
10986
10987 return (-1);
10988 }
10989
10990 uint hccap_size = sizeof (hccap_t);
10991
10992 char *in = (char *) mymalloc (hccap_size);
10993
10994 while (!feof (fp))
10995 {
10996 int n = fread (in, hccap_size, 1, fp);
10997
10998 if (n != 1)
10999 {
11000 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11001
11002 break;
11003 }
11004
11005 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11006
11007 if (parser_status != PARSER_OK)
11008 {
11009 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11010
11011 continue;
11012 }
11013
11014 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11015
11016 if ((show == 1) || (left == 1))
11017 {
11018 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11019
11020 char *salt_ptr = (char *) tmp_salt->salt_buf;
11021
11022 int cur_pos = tmp_salt->salt_len;
11023 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11024
11025 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11026
11027 // do the appending task
11028
11029 snprintf (salt_ptr + cur_pos,
11030 rem_len,
11031 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11032 wpa->orig_mac1[0],
11033 wpa->orig_mac1[1],
11034 wpa->orig_mac1[2],
11035 wpa->orig_mac1[3],
11036 wpa->orig_mac1[4],
11037 wpa->orig_mac1[5],
11038 wpa->orig_mac2[0],
11039 wpa->orig_mac2[1],
11040 wpa->orig_mac2[2],
11041 wpa->orig_mac2[3],
11042 wpa->orig_mac2[4],
11043 wpa->orig_mac2[5]);
11044
11045 // memset () the remaining part of the salt
11046
11047 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11048 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11049
11050 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11051
11052 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11053 }
11054
11055 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);
11056 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);
11057
11058 hashes_cnt++;
11059 }
11060
11061 fclose (fp);
11062
11063 myfree (in);
11064 }
11065 else if (hash_mode == 3000)
11066 {
11067 if (hash_len == 32)
11068 {
11069 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11070
11071 hash_t *lm_hash_left = NULL;
11072
11073 if (parser_status == PARSER_OK)
11074 {
11075 lm_hash_left = &hashes_buf[hashes_cnt];
11076
11077 hashes_cnt++;
11078 }
11079 else
11080 {
11081 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11082 }
11083
11084 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11085
11086 hash_t *lm_hash_right = NULL;
11087
11088 if (parser_status == PARSER_OK)
11089 {
11090 lm_hash_right = &hashes_buf[hashes_cnt];
11091
11092 hashes_cnt++;
11093 }
11094 else
11095 {
11096 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11097 }
11098
11099 // show / left
11100
11101 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11102 {
11103 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);
11104 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);
11105 }
11106 }
11107 else
11108 {
11109 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11110
11111 if (parser_status == PARSER_OK)
11112 {
11113 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11114 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11115 }
11116
11117 if (parser_status == PARSER_OK)
11118 {
11119 hashes_cnt++;
11120 }
11121 else
11122 {
11123 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11124 }
11125 }
11126 }
11127 else
11128 {
11129 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11130
11131 if (parser_status == PARSER_OK)
11132 {
11133 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11135 }
11136
11137 if (parser_status == PARSER_OK)
11138 {
11139 hashes_cnt++;
11140 }
11141 else
11142 {
11143 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11144 }
11145 }
11146 }
11147 }
11148 else if (hashlist_mode == HL_MODE_FILE)
11149 {
11150 char *hashfile = data.hashfile;
11151
11152 FILE *fp;
11153
11154 if ((fp = fopen (hashfile, "rb")) == NULL)
11155 {
11156 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11157
11158 return (-1);
11159 }
11160
11161 uint line_num = 0;
11162
11163 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11164
11165 while (!feof (fp))
11166 {
11167 line_num++;
11168
11169 int line_len = fgetl (fp, line_buf);
11170
11171 if (line_len == 0) continue;
11172
11173 char *hash_buf = NULL;
11174 int hash_len = 0;
11175
11176 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11177
11178 bool hash_fmt_error = 0;
11179
11180 if (hash_len < 1) hash_fmt_error = 1;
11181 if (hash_buf == NULL) hash_fmt_error = 1;
11182
11183 if (hash_fmt_error)
11184 {
11185 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11186
11187 continue;
11188 }
11189
11190 if (username)
11191 {
11192 char *user_buf = NULL;
11193 int user_len = 0;
11194
11195 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11196
11197 if (remove || show)
11198 {
11199 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11200
11201 *user = (user_t *) mymalloc (sizeof (user_t));
11202
11203 user_t *user_ptr = *user;
11204
11205 if (user_buf != NULL)
11206 {
11207 user_ptr->user_name = mystrdup (user_buf);
11208 }
11209 else
11210 {
11211 user_ptr->user_name = mystrdup ("");
11212 }
11213
11214 user_ptr->user_len = user_len;
11215 }
11216 }
11217
11218 if (opts_type & OPTS_TYPE_HASH_COPY)
11219 {
11220 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11221
11222 hash_info_tmp->orighash = mystrdup (hash_buf);
11223 }
11224
11225 if (isSalted)
11226 {
11227 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11228 }
11229
11230 if (hash_mode == 3000)
11231 {
11232 if (hash_len == 32)
11233 {
11234 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11235
11236 if (parser_status < PARSER_GLOBAL_ZERO)
11237 {
11238 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11239
11240 continue;
11241 }
11242
11243 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11244
11245 hashes_cnt++;
11246
11247 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11248
11249 if (parser_status < PARSER_GLOBAL_ZERO)
11250 {
11251 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11252
11253 continue;
11254 }
11255
11256 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11257
11258 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);
11259
11260 hashes_cnt++;
11261
11262 // show / left
11263
11264 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);
11265 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);
11266 }
11267 else
11268 {
11269 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11270
11271 if (parser_status < PARSER_GLOBAL_ZERO)
11272 {
11273 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11274
11275 continue;
11276 }
11277
11278 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);
11279
11280 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11281 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11282
11283 hashes_cnt++;
11284 }
11285 }
11286 else
11287 {
11288 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11289
11290 if (parser_status < PARSER_GLOBAL_ZERO)
11291 {
11292 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11293
11294 continue;
11295 }
11296
11297 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);
11298
11299 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11300 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11301
11302 hashes_cnt++;
11303 }
11304 }
11305
11306 myfree (line_buf);
11307
11308 fclose (fp);
11309
11310 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11311
11312 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11313 }
11314 }
11315 else
11316 {
11317 if (isSalted)
11318 {
11319 hashes_buf[0].salt->salt_len = 8;
11320
11321 // special salt handling
11322
11323 switch (hash_mode)
11324 {
11325 case 1500: hashes_buf[0].salt->salt_len = 2;
11326 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11327 break;
11328 case 1731: hashes_buf[0].salt->salt_len = 4;
11329 break;
11330 case 2410: hashes_buf[0].salt->salt_len = 4;
11331 break;
11332 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11333 break;
11334 case 3100: hashes_buf[0].salt->salt_len = 1;
11335 break;
11336 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11337 break;
11338 case 5800: hashes_buf[0].salt->salt_len = 16;
11339 break;
11340 case 6800: hashes_buf[0].salt->salt_len = 32;
11341 break;
11342 case 8400: hashes_buf[0].salt->salt_len = 40;
11343 break;
11344 case 8800: hashes_buf[0].salt->salt_len = 16;
11345 break;
11346 case 8900: hashes_buf[0].salt->salt_len = 16;
11347 hashes_buf[0].salt->scrypt_N = 1024;
11348 hashes_buf[0].salt->scrypt_r = 1;
11349 hashes_buf[0].salt->scrypt_p = 1;
11350 break;
11351 case 9100: hashes_buf[0].salt->salt_len = 16;
11352 break;
11353 case 9300: hashes_buf[0].salt->salt_len = 14;
11354 hashes_buf[0].salt->scrypt_N = 16384;
11355 hashes_buf[0].salt->scrypt_r = 1;
11356 hashes_buf[0].salt->scrypt_p = 1;
11357 break;
11358 case 9400: hashes_buf[0].salt->salt_len = 16;
11359 break;
11360 case 9500: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 9600: hashes_buf[0].salt->salt_len = 16;
11363 break;
11364 case 9700: hashes_buf[0].salt->salt_len = 16;
11365 break;
11366 case 9710: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 9720: hashes_buf[0].salt->salt_len = 16;
11369 break;
11370 case 9800: hashes_buf[0].salt->salt_len = 16;
11371 break;
11372 case 9810: hashes_buf[0].salt->salt_len = 16;
11373 break;
11374 case 9820: hashes_buf[0].salt->salt_len = 16;
11375 break;
11376 case 10300: hashes_buf[0].salt->salt_len = 12;
11377 break;
11378 case 11500: hashes_buf[0].salt->salt_len = 4;
11379 break;
11380 case 11600: hashes_buf[0].salt->salt_len = 4;
11381 break;
11382 case 12400: hashes_buf[0].salt->salt_len = 4;
11383 break;
11384 case 12500: hashes_buf[0].salt->salt_len = 8;
11385 break;
11386 case 12600: hashes_buf[0].salt->salt_len = 64;
11387 break;
11388 }
11389
11390 // special esalt handling
11391
11392 switch (hash_mode)
11393 {
11394 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11395 break;
11396 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11397 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11398 break;
11399 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11400 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11401 break;
11402 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11403 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11404 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11405 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11406 break;
11407 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11408 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11409 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11410 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11411 break;
11412 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11413 break;
11414 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11415 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11416 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11417 break;
11418 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11419 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11420 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11421 break;
11422 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11423 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11424 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11425 break;
11426 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11427 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11428 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11429 break;
11430 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11431 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11432 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11433 break;
11434 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11435 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11436 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11437 break;
11438 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11439 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11440 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11441 break;
11442 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11443 break;
11444 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11445 break;
11446 }
11447 }
11448
11449 // set hashfile
11450
11451 switch (hash_mode)
11452 {
11453 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11454 break;
11455 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11456 break;
11457 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11458 break;
11459 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11460 break;
11461 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11462 break;
11463 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11464 break;
11465 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11466 break;
11467 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11468 break;
11469 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11470 break;
11471 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11472 break;
11473 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11474 break;
11475 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11476 break;
11477 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11478 break;
11479 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11480 break;
11481 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11482 break;
11483 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11484 break;
11485 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11486 break;
11487 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11488 break;
11489 }
11490
11491 // set default iterations
11492
11493 switch (hash_mode)
11494 {
11495 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11496 break;
11497 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11498 break;
11499 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11500 break;
11501 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11502 break;
11503 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11504 break;
11505 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11506 break;
11507 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11508 break;
11509 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11510 break;
11511 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11512 break;
11513 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11514 break;
11515 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11516 break;
11517 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11518 break;
11519 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11520 break;
11521 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11522 break;
11523 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11524 break;
11525 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11526 break;
11527 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11528 break;
11529 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11530 break;
11531 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11532 break;
11533 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11534 break;
11535 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11536 break;
11537 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11538 break;
11539 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11540 break;
11541 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11542 break;
11543 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11544 break;
11545 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11546 break;
11547 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11548 break;
11549 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11550 break;
11551 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11552 break;
11553 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11554 break;
11555 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11556 break;
11557 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11558 break;
11559 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11560 break;
11561 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11562 break;
11563 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11564 break;
11565 case 8900: hashes_buf[0].salt->salt_iter = 1;
11566 break;
11567 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11568 break;
11569 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11570 break;
11571 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11572 break;
11573 case 9300: hashes_buf[0].salt->salt_iter = 1;
11574 break;
11575 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11576 break;
11577 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11578 break;
11579 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11580 break;
11581 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11582 break;
11583 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11584 break;
11585 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11586 break;
11587 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11588 break;
11589 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11590 break;
11591 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11592 break;
11593 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11594 break;
11595 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11596 break;
11597 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11598 break;
11599 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11600 break;
11601 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11602 break;
11603 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11604 break;
11605 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11606 break;
11607 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11608 break;
11609 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11610 break;
11611 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11612 break;
11613 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11614 break;
11615 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11616 break;
11617 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11618 break;
11619 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11620 break;
11621 }
11622
11623 hashes_cnt = 1;
11624 }
11625
11626 if (show == 1 || left == 1)
11627 {
11628 for (uint i = 0; i < pot_cnt; i++)
11629 {
11630 pot_t *pot_ptr = &pot[i];
11631
11632 hash_t *hashes_buf = &pot_ptr->hash;
11633
11634 local_free (hashes_buf->digest);
11635
11636 if (isSalted)
11637 {
11638 local_free (hashes_buf->salt);
11639 }
11640 }
11641
11642 local_free (pot);
11643
11644 if (data.quiet == 0) log_info_nn ("");
11645
11646 return (0);
11647 }
11648
11649 if (keyspace == 0)
11650 {
11651 if (hashes_cnt == 0)
11652 {
11653 log_error ("ERROR: No hashes loaded");
11654
11655 return (-1);
11656 }
11657 }
11658
11659 /**
11660 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11661 */
11662
11663 if (data.outfile != NULL)
11664 {
11665 if (data.hashfile != NULL)
11666 {
11667 #ifdef _POSIX
11668 struct stat tmpstat_outfile;
11669 struct stat tmpstat_hashfile;
11670 #endif
11671
11672 #ifdef _WIN
11673 struct stat64 tmpstat_outfile;
11674 struct stat64 tmpstat_hashfile;
11675 #endif
11676
11677 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11678
11679 if (tmp_outfile_fp)
11680 {
11681 #ifdef _POSIX
11682 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11683 #endif
11684
11685 #ifdef _WIN
11686 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11687 #endif
11688
11689 fclose (tmp_outfile_fp);
11690 }
11691
11692 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11693
11694 if (tmp_hashfile_fp)
11695 {
11696 #ifdef _POSIX
11697 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11698 #endif
11699
11700 #ifdef _WIN
11701 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11702 #endif
11703
11704 fclose (tmp_hashfile_fp);
11705 }
11706
11707 if (tmp_outfile_fp && tmp_outfile_fp)
11708 {
11709 tmpstat_outfile.st_mode = 0;
11710 tmpstat_outfile.st_nlink = 0;
11711 tmpstat_outfile.st_uid = 0;
11712 tmpstat_outfile.st_gid = 0;
11713 tmpstat_outfile.st_rdev = 0;
11714 tmpstat_outfile.st_atime = 0;
11715
11716 tmpstat_hashfile.st_mode = 0;
11717 tmpstat_hashfile.st_nlink = 0;
11718 tmpstat_hashfile.st_uid = 0;
11719 tmpstat_hashfile.st_gid = 0;
11720 tmpstat_hashfile.st_rdev = 0;
11721 tmpstat_hashfile.st_atime = 0;
11722
11723 #ifdef _POSIX
11724 tmpstat_outfile.st_blksize = 0;
11725 tmpstat_outfile.st_blocks = 0;
11726
11727 tmpstat_hashfile.st_blksize = 0;
11728 tmpstat_hashfile.st_blocks = 0;
11729 #endif
11730
11731 #ifdef _POSIX
11732 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11733 {
11734 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11735
11736 return (-1);
11737 }
11738 #endif
11739
11740 #ifdef _WIN
11741 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11742 {
11743 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11744
11745 return (-1);
11746 }
11747 #endif
11748 }
11749 }
11750 }
11751
11752 /**
11753 * Remove duplicates
11754 */
11755
11756 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11757
11758 if (isSalted)
11759 {
11760 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11761 }
11762 else
11763 {
11764 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11765 }
11766
11767 uint hashes_cnt_orig = hashes_cnt;
11768
11769 hashes_cnt = 1;
11770
11771 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11772 {
11773 if (isSalted)
11774 {
11775 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11776 {
11777 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11778 }
11779 }
11780 else
11781 {
11782 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11783 }
11784
11785 if (hashes_pos > hashes_cnt)
11786 {
11787 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11788 }
11789
11790 hashes_cnt++;
11791 }
11792
11793 /**
11794 * Potfile removes
11795 */
11796
11797 uint potfile_remove_cracks = 0;
11798
11799 if (potfile_disable == 0)
11800 {
11801 hash_t hash_buf;
11802
11803 hash_buf.digest = mymalloc (dgst_size);
11804 hash_buf.salt = NULL;
11805 hash_buf.esalt = NULL;
11806 hash_buf.hash_info = NULL;
11807 hash_buf.cracked = 0;
11808
11809 if (isSalted)
11810 {
11811 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11812 }
11813
11814 if (esalt_size)
11815 {
11816 hash_buf.esalt = mymalloc (esalt_size);
11817 }
11818
11819 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11820
11821 // no solution for these special hash types (for instane because they use hashfile in output etc)
11822 if ((hash_mode != 5200) &&
11823 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11824 (hash_mode != 9000))
11825 {
11826 FILE *fp = fopen (potfile, "rb");
11827
11828 if (fp != NULL)
11829 {
11830 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11831
11832 // to be safe work with a copy (because of line_len loop, i etc)
11833 // moved up here because it's easier to handle continue case
11834 // it's just 64kb
11835
11836 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11837
11838 while (!feof (fp))
11839 {
11840 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11841
11842 if (ptr == NULL) break;
11843
11844 int line_len = strlen (line_buf);
11845
11846 if (line_len == 0) continue;
11847
11848 int iter = MAX_CUT_TRIES;
11849
11850 for (int i = line_len - 1; i && iter; i--, line_len--)
11851 {
11852 if (line_buf[i] != ':') continue;
11853
11854 if (isSalted)
11855 {
11856 memset (hash_buf.salt, 0, sizeof (salt_t));
11857 }
11858
11859 hash_t *found = NULL;
11860
11861 if (hash_mode == 6800)
11862 {
11863 if (i < 64) // 64 = 16 * uint in salt_buf[]
11864 {
11865 // manipulate salt_buf
11866 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11867
11868 hash_buf.salt->salt_len = i;
11869
11870 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11871 }
11872 }
11873 else if (hash_mode == 2500)
11874 {
11875 if (i < 64) // 64 = 16 * uint in salt_buf[]
11876 {
11877 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11878 // manipulate salt_buf
11879
11880 memcpy (line_buf_cpy, line_buf, i);
11881
11882 char *mac2_pos = strrchr (line_buf_cpy, ':');
11883
11884 if (mac2_pos == NULL) continue;
11885
11886 mac2_pos[0] = 0;
11887 mac2_pos++;
11888
11889 if (strlen (mac2_pos) != 12) continue;
11890
11891 char *mac1_pos = strrchr (line_buf_cpy, ':');
11892
11893 if (mac1_pos == NULL) continue;
11894
11895 mac1_pos[0] = 0;
11896 mac1_pos++;
11897
11898 if (strlen (mac1_pos) != 12) continue;
11899
11900 uint essid_length = mac1_pos - line_buf_cpy - 1;
11901
11902 // here we need the ESSID
11903 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11904
11905 hash_buf.salt->salt_len = essid_length;
11906
11907 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11908
11909 if (found)
11910 {
11911 wpa_t *wpa = (wpa_t *) found->esalt;
11912
11913 // compare hex string(s) vs binary MAC address(es)
11914
11915 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11916 {
11917 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11918 {
11919 found = NULL;
11920
11921 break;
11922 }
11923 }
11924
11925 // early skip ;)
11926 if (!found) continue;
11927
11928 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11929 {
11930 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11931 {
11932 found = NULL;
11933
11934 break;
11935 }
11936 }
11937 }
11938 }
11939 }
11940 else
11941 {
11942 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11943
11944 if (parser_status == PARSER_OK)
11945 {
11946 if (isSalted)
11947 {
11948 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11949 }
11950 else
11951 {
11952 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11953 }
11954 }
11955 }
11956
11957 if (found == NULL) continue;
11958
11959 if (!found->cracked) potfile_remove_cracks++;
11960
11961 found->cracked = 1;
11962
11963 if (found) break;
11964
11965 iter--;
11966 }
11967 }
11968
11969 myfree (line_buf_cpy);
11970
11971 myfree (line_buf);
11972
11973 fclose (fp);
11974 }
11975 }
11976
11977 if (esalt_size)
11978 {
11979 local_free (hash_buf.esalt);
11980 }
11981
11982 if (isSalted)
11983 {
11984 local_free (hash_buf.salt);
11985 }
11986
11987 local_free (hash_buf.digest);
11988 }
11989
11990 /**
11991 * Now generate all the buffers required for later
11992 */
11993
11994 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11995
11996 salt_t *salts_buf_new = NULL;
11997 void *esalts_buf_new = NULL;
11998
11999 if (isSalted)
12000 {
12001 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12002
12003 if (esalt_size)
12004 {
12005 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12006 }
12007 }
12008 else
12009 {
12010 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12011 }
12012
12013 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12014
12015 uint digests_cnt = hashes_cnt;
12016 uint digests_done = 0;
12017
12018 size_t size_digests = digests_cnt * dgst_size;
12019 size_t size_shown = digests_cnt * sizeof (uint);
12020
12021 uint *digests_shown = (uint *) mymalloc (size_shown);
12022 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12023
12024 uint salts_cnt = 0;
12025 uint salts_done = 0;
12026
12027 hashinfo_t **hash_info = NULL;
12028
12029 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12030 {
12031 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12032
12033 if (username && (remove || show))
12034 {
12035 uint user_pos;
12036
12037 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12038 {
12039 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12040
12041 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12042 }
12043 }
12044 }
12045
12046 uint *salts_shown = (uint *) mymalloc (size_shown);
12047
12048 salt_t *salt_buf;
12049
12050 {
12051 // copied from inner loop
12052
12053 salt_buf = &salts_buf_new[salts_cnt];
12054
12055 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12056
12057 if (esalt_size)
12058 {
12059 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12060 }
12061
12062 salt_buf->digests_cnt = 0;
12063 salt_buf->digests_done = 0;
12064 salt_buf->digests_offset = 0;
12065
12066 salts_cnt++;
12067 }
12068
12069 if (hashes_buf[0].cracked == 1)
12070 {
12071 digests_shown[0] = 1;
12072
12073 digests_done++;
12074
12075 salt_buf->digests_done++;
12076 }
12077
12078 salt_buf->digests_cnt++;
12079
12080 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12081
12082 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12083 {
12084 hash_info[0] = hashes_buf[0].hash_info;
12085 }
12086
12087 // copy from inner loop
12088
12089 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12090 {
12091 if (isSalted)
12092 {
12093 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12094 {
12095 salt_buf = &salts_buf_new[salts_cnt];
12096
12097 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12098
12099 if (esalt_size)
12100 {
12101 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12102 }
12103
12104 salt_buf->digests_cnt = 0;
12105 salt_buf->digests_done = 0;
12106 salt_buf->digests_offset = hashes_pos;
12107
12108 salts_cnt++;
12109 }
12110 }
12111
12112 if (hashes_buf[hashes_pos].cracked == 1)
12113 {
12114 digests_shown[hashes_pos] = 1;
12115
12116 digests_done++;
12117
12118 salt_buf->digests_done++;
12119 }
12120
12121 salt_buf->digests_cnt++;
12122
12123 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12124
12125 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12126 {
12127 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12128 }
12129 }
12130
12131 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12132 {
12133 salt_t *salt_buf = &salts_buf_new[salt_pos];
12134
12135 if (salt_buf->digests_done == salt_buf->digests_cnt)
12136 {
12137 salts_shown[salt_pos] = 1;
12138
12139 salts_done++;
12140 }
12141
12142 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12143 }
12144
12145 local_free (digests_buf);
12146 local_free (salts_buf);
12147 local_free (esalts_buf);
12148
12149 digests_buf = digests_buf_new;
12150 salts_buf = salts_buf_new;
12151 esalts_buf = esalts_buf_new;
12152
12153 local_free (hashes_buf);
12154
12155 /**
12156 * special modification not set from parser
12157 */
12158
12159 switch (hash_mode)
12160 {
12161 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12162 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12163 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12164 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12165 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12166 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12167 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12168 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12169 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12170 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12171 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12172 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12173 }
12174
12175 if (truecrypt_keyfiles)
12176 {
12177 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12178
12179 char *keyfiles = strdup (truecrypt_keyfiles);
12180
12181 char *keyfile = strtok (keyfiles, ",");
12182
12183 do
12184 {
12185 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12186
12187 } while ((keyfile = strtok (NULL, ",")) != NULL);
12188
12189 free (keyfiles);
12190 }
12191
12192 data.digests_cnt = digests_cnt;
12193 data.digests_done = digests_done;
12194 data.digests_buf = digests_buf;
12195 data.digests_shown = digests_shown;
12196 data.digests_shown_tmp = digests_shown_tmp;
12197
12198 data.salts_cnt = salts_cnt;
12199 data.salts_done = salts_done;
12200 data.salts_buf = salts_buf;
12201 data.salts_shown = salts_shown;
12202
12203 data.esalts_buf = esalts_buf;
12204 data.hash_info = hash_info;
12205
12206 /**
12207 * Automatic Optimizers
12208 */
12209
12210 if (salts_cnt == 1)
12211 opti_type |= OPTI_TYPE_SINGLE_SALT;
12212
12213 if (digests_cnt == 1)
12214 opti_type |= OPTI_TYPE_SINGLE_HASH;
12215
12216 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12217 opti_type |= OPTI_TYPE_NOT_ITERATED;
12218
12219 if (attack_mode == ATTACK_MODE_BF)
12220 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12221
12222 data.opti_type = opti_type;
12223
12224 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12225 {
12226 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12227 {
12228 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12229 {
12230 if (opts_type & OPTS_TYPE_ST_ADD80)
12231 {
12232 opts_type &= ~OPTS_TYPE_ST_ADD80;
12233 opts_type |= OPTS_TYPE_PT_ADD80;
12234 }
12235
12236 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12237 {
12238 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12239 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12240 }
12241
12242 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12243 {
12244 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12245 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12246 }
12247 }
12248 }
12249 }
12250
12251 /**
12252 * Some algorithm, like descrypt, can benefit from JIT compilation
12253 */
12254
12255 int force_jit_compilation = -1;
12256
12257 if (hash_mode == 8900)
12258 {
12259 force_jit_compilation = 8900;
12260 }
12261 else if (hash_mode == 9300)
12262 {
12263 force_jit_compilation = 8900;
12264 }
12265 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12266 {
12267 force_jit_compilation = 1500;
12268 }
12269
12270 /**
12271 * generate bitmap tables
12272 */
12273
12274 const uint bitmap_shift1 = 5;
12275 const uint bitmap_shift2 = 13;
12276
12277 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12278
12279 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12280 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12281 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12282 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12283 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12284 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12285 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12286 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12287
12288 uint bitmap_bits;
12289 uint bitmap_nums;
12290 uint bitmap_mask;
12291 uint bitmap_size;
12292
12293 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12294 {
12295 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12296
12297 bitmap_nums = 1 << bitmap_bits;
12298
12299 bitmap_mask = bitmap_nums - 1;
12300
12301 bitmap_size = bitmap_nums * sizeof (uint);
12302
12303 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12304
12305 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;
12306 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;
12307
12308 break;
12309 }
12310
12311 bitmap_nums = 1 << bitmap_bits;
12312
12313 bitmap_mask = bitmap_nums - 1;
12314
12315 bitmap_size = bitmap_nums * sizeof (uint);
12316
12317 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);
12318 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);
12319
12320 /**
12321 * prepare quick rule
12322 */
12323
12324 data.rule_buf_l = rule_buf_l;
12325 data.rule_buf_r = rule_buf_r;
12326
12327 int rule_len_l = (int) strlen (rule_buf_l);
12328 int rule_len_r = (int) strlen (rule_buf_r);
12329
12330 data.rule_len_l = rule_len_l;
12331 data.rule_len_r = rule_len_r;
12332
12333 /**
12334 * load rules
12335 */
12336
12337 uint *all_kernel_rules_cnt = NULL;
12338
12339 kernel_rule_t **all_kernel_rules_buf = NULL;
12340
12341 if (rp_files_cnt)
12342 {
12343 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12344
12345 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12346 }
12347
12348 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12349
12350 int rule_len = 0;
12351
12352 for (uint i = 0; i < rp_files_cnt; i++)
12353 {
12354 uint kernel_rules_avail = 0;
12355
12356 uint kernel_rules_cnt = 0;
12357
12358 kernel_rule_t *kernel_rules_buf = NULL;
12359
12360 char *rp_file = rp_files[i];
12361
12362 char in[BLOCK_SIZE] = { 0 };
12363 char out[BLOCK_SIZE] = { 0 };
12364
12365 FILE *fp = NULL;
12366
12367 uint rule_line = 0;
12368
12369 if ((fp = fopen (rp_file, "rb")) == NULL)
12370 {
12371 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12372
12373 return (-1);
12374 }
12375
12376 while (!feof (fp))
12377 {
12378 memset (rule_buf, 0, HCBUFSIZ);
12379
12380 rule_len = fgetl (fp, rule_buf);
12381
12382 rule_line++;
12383
12384 if (rule_len == 0) continue;
12385
12386 if (rule_buf[0] == '#') continue;
12387
12388 if (kernel_rules_avail == kernel_rules_cnt)
12389 {
12390 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12391
12392 kernel_rules_avail += INCR_RULES;
12393 }
12394
12395 memset (in, 0, BLOCK_SIZE);
12396 memset (out, 0, BLOCK_SIZE);
12397
12398 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12399
12400 if (result == -1)
12401 {
12402 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12403
12404 continue;
12405 }
12406
12407 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12408 {
12409 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12410
12411 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12412
12413 continue;
12414 }
12415
12416 /* its so slow
12417 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12418 {
12419 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12420
12421 continue;
12422 }
12423 */
12424
12425 kernel_rules_cnt++;
12426 }
12427
12428 fclose (fp);
12429
12430 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12431
12432 all_kernel_rules_buf[i] = kernel_rules_buf;
12433 }
12434
12435 /**
12436 * merge rules or automatic rule generator
12437 */
12438
12439 uint kernel_rules_cnt = 0;
12440
12441 kernel_rule_t *kernel_rules_buf = NULL;
12442
12443 if (attack_mode == ATTACK_MODE_STRAIGHT)
12444 {
12445 if (rp_files_cnt)
12446 {
12447 kernel_rules_cnt = 1;
12448
12449 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12450
12451 repeats[0] = kernel_rules_cnt;
12452
12453 for (uint i = 0; i < rp_files_cnt; i++)
12454 {
12455 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12456
12457 repeats[i + 1] = kernel_rules_cnt;
12458 }
12459
12460 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12461
12462 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12463
12464 for (uint i = 0; i < kernel_rules_cnt; i++)
12465 {
12466 uint out_pos = 0;
12467
12468 kernel_rule_t *out = &kernel_rules_buf[i];
12469
12470 for (uint j = 0; j < rp_files_cnt; j++)
12471 {
12472 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12473 uint in_pos;
12474
12475 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12476
12477 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12478 {
12479 if (out_pos == RULES_MAX - 1)
12480 {
12481 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12482
12483 break;
12484 }
12485
12486 out->cmds[out_pos] = in->cmds[in_pos];
12487 }
12488 }
12489 }
12490
12491 local_free (repeats);
12492 }
12493 else if (rp_gen)
12494 {
12495 uint kernel_rules_avail = 0;
12496
12497 while (kernel_rules_cnt < rp_gen)
12498 {
12499 if (kernel_rules_avail == kernel_rules_cnt)
12500 {
12501 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12502
12503 kernel_rules_avail += INCR_RULES;
12504 }
12505
12506 memset (rule_buf, 0, HCBUFSIZ);
12507
12508 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12509
12510 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12511
12512 kernel_rules_cnt++;
12513 }
12514 }
12515 }
12516
12517 myfree (rule_buf);
12518
12519 /**
12520 * generate NOP rules
12521 */
12522
12523 if (kernel_rules_cnt == 0)
12524 {
12525 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12526
12527 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12528
12529 kernel_rules_cnt++;
12530 }
12531
12532 data.kernel_rules_cnt = kernel_rules_cnt;
12533 data.kernel_rules_buf = kernel_rules_buf;
12534
12535 /**
12536 * OpenCL platforms: detect
12537 */
12538
12539 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12540 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12541
12542 cl_uint platforms_cnt = 0;
12543 cl_uint platform_devices_cnt = 0;
12544
12545 if (keyspace == 0)
12546 {
12547 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12548
12549 if (platforms_cnt == 0)
12550 {
12551 log_error ("ERROR: No OpenCL compatible platform found");
12552
12553 return (-1);
12554 }
12555
12556 if (opencl_platforms_filter != (uint) -1)
12557 {
12558 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12559
12560 if (opencl_platforms_filter > platform_cnt_mask)
12561 {
12562 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12563
12564 return (-1);
12565 }
12566 }
12567 }
12568
12569 /**
12570 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12571 */
12572
12573 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12574 {
12575 cl_platform_id platform = platforms[platform_id];
12576
12577 char platform_vendor[INFOSZ] = { 0 };
12578
12579 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12580
12581 #ifdef HAVE_HWMON
12582 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12583 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12584 {
12585 // make sure that we do not directly control the fan for NVidia
12586
12587 gpu_temp_retain = 0;
12588
12589 data.gpu_temp_retain = gpu_temp_retain;
12590 }
12591 #endif // HAVE_NVML || HAVE_NVAPI
12592 #endif
12593 }
12594
12595 /**
12596 * OpenCL devices: simply push all devices from all platforms into the same device array
12597 */
12598
12599 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12600
12601 data.devices_param = devices_param;
12602
12603 uint devices_cnt = 0;
12604
12605 uint devices_active = 0;
12606
12607 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12608 {
12609 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12610
12611 cl_platform_id platform = platforms[platform_id];
12612
12613 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12614
12615 char platform_vendor[INFOSZ] = { 0 };
12616
12617 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12618
12619 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12620 // this causes trouble with vendor id based macros
12621 // we'll assign generic to those without special optimization available
12622
12623 cl_uint vendor_id = 0;
12624
12625 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12626 {
12627 vendor_id = VENDOR_ID_AMD;
12628 }
12629 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12630 {
12631 vendor_id = VENDOR_ID_GENERIC;
12632 }
12633 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12634 {
12635 vendor_id = VENDOR_ID_GENERIC;
12636 }
12637 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12638 {
12639 vendor_id = VENDOR_ID_GENERIC;
12640 }
12641 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12642 {
12643 vendor_id = VENDOR_ID_GENERIC;
12644 }
12645 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12646 {
12647 vendor_id = VENDOR_ID_NV;
12648 }
12649 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12650 {
12651 vendor_id = VENDOR_ID_GENERIC;
12652 }
12653 else
12654 {
12655 vendor_id = VENDOR_ID_GENERIC;
12656 }
12657
12658 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12659 {
12660 size_t param_value_size = 0;
12661
12662 const uint device_id = devices_cnt;
12663
12664 hc_device_param_t *device_param = &data.devices_param[device_id];
12665
12666 device_param->vendor_id = vendor_id;
12667
12668 device_param->device = platform_devices[platform_devices_id];
12669
12670 device_param->device_id = device_id;
12671
12672 device_param->platform_devices_id = platform_devices_id;
12673
12674 // device_type
12675
12676 cl_device_type device_type;
12677
12678 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12679
12680 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12681
12682 device_param->device_type = device_type;
12683
12684 // device_name
12685
12686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12687
12688 char *device_name = (char *) mymalloc (param_value_size);
12689
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12691
12692 device_param->device_name = device_name;
12693
12694 // tuning db
12695
12696 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12697
12698 // device_version
12699
12700 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12701
12702 char *device_version = (char *) mymalloc (param_value_size);
12703
12704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12705
12706 device_param->device_version = device_version;
12707
12708 // device_opencl_version
12709
12710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12711
12712 char *device_opencl_version = (char *) mymalloc (param_value_size);
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12715
12716 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12717
12718 myfree (device_opencl_version);
12719
12720 // vector_width
12721
12722 cl_uint vector_width;
12723
12724 if (opencl_vector_width_chgd == 0)
12725 {
12726 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12727 {
12728 if (opti_type & OPTI_TYPE_USES_BITS_64)
12729 {
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12731 }
12732 else
12733 {
12734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12735 }
12736 }
12737 else
12738 {
12739 vector_width = (cl_uint) tuningdb_entry->vector_width;
12740 }
12741 }
12742 else
12743 {
12744 vector_width = opencl_vector_width;
12745 }
12746
12747 if (vector_width > 16) vector_width = 16;
12748
12749 device_param->vector_width = vector_width;
12750
12751 // max_compute_units
12752
12753 cl_uint device_processors;
12754
12755 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12756
12757 device_param->device_processors = device_processors;
12758
12759 // device_maxmem_alloc
12760 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12761
12762 cl_ulong device_maxmem_alloc;
12763
12764 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12765
12766 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12767
12768 // device_global_mem
12769
12770 cl_ulong device_global_mem;
12771
12772 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12773
12774 device_param->device_global_mem = device_global_mem;
12775
12776 // max_work_group_size
12777
12778 size_t device_maxworkgroup_size;
12779
12780 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12781
12782 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12783
12784 // max_clock_frequency
12785
12786 cl_uint device_maxclock_frequency;
12787
12788 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12789
12790 device_param->device_maxclock_frequency = device_maxclock_frequency;
12791
12792 // device_endian_little
12793
12794 cl_bool device_endian_little;
12795
12796 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12797
12798 if (device_endian_little == CL_FALSE)
12799 {
12800 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12801
12802 device_param->skipped = 1;
12803 }
12804
12805 // device_available
12806
12807 cl_bool device_available;
12808
12809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12810
12811 if (device_available == CL_FALSE)
12812 {
12813 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12814
12815 device_param->skipped = 1;
12816 }
12817
12818 // device_compiler_available
12819
12820 cl_bool device_compiler_available;
12821
12822 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12823
12824 if (device_compiler_available == CL_FALSE)
12825 {
12826 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12827
12828 device_param->skipped = 1;
12829 }
12830
12831 // device_execution_capabilities
12832
12833 cl_device_exec_capabilities device_execution_capabilities;
12834
12835 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12836
12837 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12838 {
12839 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12840
12841 device_param->skipped = 1;
12842 }
12843
12844 // device_extensions
12845
12846 size_t device_extensions_size;
12847
12848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12849
12850 char *device_extensions = mymalloc (device_extensions_size + 1);
12851
12852 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12853
12854 if (strstr (device_extensions, "base_atomics") == 0)
12855 {
12856 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12857
12858 device_param->skipped = 1;
12859 }
12860
12861 if (strstr (device_extensions, "byte_addressable_store") == 0)
12862 {
12863 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12864
12865 device_param->skipped = 1;
12866 }
12867
12868 myfree (device_extensions);
12869
12870 // device_local_mem_size
12871
12872 cl_ulong device_local_mem_size;
12873
12874 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12875
12876 if (device_local_mem_size < 32768)
12877 {
12878 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12879
12880 device_param->skipped = 1;
12881 }
12882
12883
12884 // skipped
12885
12886 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12887 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12888
12889 // driver_version
12890
12891 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12892
12893 char *driver_version = (char *) mymalloc (param_value_size);
12894
12895 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12896
12897 device_param->driver_version = driver_version;
12898
12899 // device_name_chksum
12900
12901 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12902
12903 #if __x86_64__
12904 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);
12905 #else
12906 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);
12907 #endif
12908
12909 uint device_name_digest[4] = { 0 };
12910
12911 md5_64 ((uint *) device_name_chksum, device_name_digest);
12912
12913 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12914
12915 device_param->device_name_chksum = device_name_chksum;
12916
12917 // device_processor_cores
12918
12919 if (device_type & CL_DEVICE_TYPE_CPU)
12920 {
12921 cl_uint device_processor_cores = 1;
12922
12923 device_param->device_processor_cores = device_processor_cores;
12924 }
12925
12926 if (device_type & CL_DEVICE_TYPE_GPU)
12927 {
12928 if (vendor_id == VENDOR_ID_AMD)
12929 {
12930 cl_uint device_processor_cores = 0;
12931
12932 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12933
12934 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12935
12936 device_param->device_processor_cores = device_processor_cores;
12937 }
12938 else if (vendor_id == VENDOR_ID_NV)
12939 {
12940 cl_uint kernel_exec_timeout = 0;
12941
12942 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12943
12944 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12945
12946 device_param->kernel_exec_timeout = kernel_exec_timeout;
12947
12948 cl_uint device_processor_cores = 0;
12949
12950 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12951
12952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12953
12954 device_param->device_processor_cores = device_processor_cores;
12955
12956 cl_uint sm_minor = 0;
12957 cl_uint sm_major = 0;
12958
12959 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12960 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12961
12962 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12963 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12964
12965 device_param->sm_minor = sm_minor;
12966 device_param->sm_major = sm_major;
12967 }
12968 else
12969 {
12970 cl_uint device_processor_cores = 1;
12971
12972 device_param->device_processor_cores = device_processor_cores;
12973 }
12974 }
12975
12976 // display results
12977
12978 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12979 {
12980 if (device_param->skipped == 0)
12981 {
12982 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12983 device_id + 1,
12984 device_name,
12985 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12986 (unsigned int) (device_global_mem / 1024 / 1024),
12987 (unsigned int) (device_maxclock_frequency),
12988 (unsigned int) device_processors);
12989 }
12990 else
12991 {
12992 log_info ("Device #%u: %s, skipped",
12993 device_id + 1,
12994 device_name);
12995 }
12996 }
12997
12998 // common driver check
12999
13000 if (device_param->skipped == 0)
13001 {
13002 if (device_type & CL_DEVICE_TYPE_GPU)
13003 {
13004 if (vendor_id == VENDOR_ID_AMD)
13005 {
13006 int catalyst_check = (force == 1) ? 0 : 1;
13007
13008 int catalyst_warn = 0;
13009
13010 int catalyst_broken = 0;
13011
13012 if (catalyst_check == 1)
13013 {
13014 catalyst_warn = 1;
13015
13016 // v14.9 and higher
13017 if (atoi (device_param->driver_version) >= 1573)
13018 {
13019 catalyst_warn = 0;
13020 }
13021
13022 catalyst_check = 0;
13023 }
13024
13025 if (catalyst_broken == 1)
13026 {
13027 log_info ("");
13028 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13029 log_info ("It will pass over cracked hashes and does not report them as cracked");
13030 log_info ("You are STRONGLY encouraged not to use it");
13031 log_info ("You can use --force to override this but do not post error reports if you do so");
13032 log_info ("");
13033
13034 return (-1);
13035 }
13036
13037 if (catalyst_warn == 1)
13038 {
13039 log_info ("");
13040 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13041 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13042 log_info ("See hashcat's homepage for official supported catalyst drivers");
13043 #ifdef _WIN
13044 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13045 #endif
13046 log_info ("You can use --force to override this but do not post error reports if you do so");
13047 log_info ("");
13048
13049 return (-1);
13050 }
13051 }
13052 else if (vendor_id == VENDOR_ID_NV)
13053 {
13054 if (device_param->kernel_exec_timeout != 0)
13055 {
13056 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);
13057 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13058 }
13059 }
13060 }
13061
13062 if (device_type & CL_DEVICE_TYPE_CPU)
13063 {
13064 if (vendor_id == VENDOR_ID_AMD)
13065 {
13066 if (force == 0)
13067 {
13068 log_info ("");
13069 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13070 log_info ("You are STRONGLY encouraged not to use it");
13071 log_info ("You can use --force to override this but do not post error reports if you do so");
13072 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13073 log_info ("");
13074
13075 return (-1);
13076 }
13077 }
13078 }
13079
13080 /**
13081 * kernel accel and loops tuning db adjustment
13082 */
13083
13084 device_param->kernel_accel_min = 1;
13085 device_param->kernel_accel_max = 1024;
13086
13087 device_param->kernel_loops_min = 1;
13088 device_param->kernel_loops_max = 1024;
13089
13090 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13091
13092 if (tuningdb_entry)
13093 {
13094 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13095 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13096
13097 if (_kernel_accel)
13098 {
13099 device_param->kernel_accel_min = _kernel_accel;
13100 device_param->kernel_accel_max = _kernel_accel;
13101 }
13102
13103 if (_kernel_loops)
13104 {
13105 if (workload_profile == 1)
13106 {
13107 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13108 }
13109 else if (workload_profile == 2)
13110 {
13111 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13112 }
13113
13114 device_param->kernel_loops_min = _kernel_loops;
13115 device_param->kernel_loops_max = _kernel_loops;
13116 }
13117 }
13118
13119 // commandline parameters overwrite tuningdb entries
13120
13121 if (kernel_accel)
13122 {
13123 device_param->kernel_accel_min = kernel_accel;
13124 device_param->kernel_accel_max = kernel_accel;
13125 }
13126
13127 if (kernel_loops)
13128 {
13129 device_param->kernel_loops_min = kernel_loops;
13130 device_param->kernel_loops_max = kernel_loops;
13131 }
13132
13133 /**
13134 * activate device
13135 */
13136
13137 devices_active++;
13138 }
13139
13140 // next please
13141
13142 devices_cnt++;
13143 }
13144 }
13145
13146 if (keyspace == 0 && devices_active == 0)
13147 {
13148 log_error ("ERROR: No devices found/left");
13149
13150 return (-1);
13151 }
13152
13153 // 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)
13154
13155 if (devices_filter != (uint) -1)
13156 {
13157 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13158
13159 if (devices_filter > devices_cnt_mask)
13160 {
13161 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13162
13163 return (-1);
13164 }
13165 }
13166
13167 data.devices_cnt = devices_cnt;
13168
13169 data.devices_active = devices_active;
13170
13171 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13172 {
13173 log_info ("");
13174 }
13175
13176 /**
13177 * HM devices: init
13178 */
13179
13180 #ifdef HAVE_HWMON
13181 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13182 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13183 #endif
13184
13185 #ifdef HAVE_ADL
13186 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13187 #endif
13188
13189 if (gpu_temp_disable == 0)
13190 {
13191 #if defined(WIN) && defined(HAVE_NVAPI)
13192 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13193
13194 if (nvapi_init (nvapi) == 0)
13195 data.hm_nv = nvapi;
13196
13197 if (data.hm_nv)
13198 {
13199 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13200 {
13201 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13202
13203 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13204
13205 int tmp_out = 0;
13206
13207 for (int i = 0; i < tmp_in; i++)
13208 {
13209 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13210 }
13211
13212 for (int i = 0; i < tmp_out; i++)
13213 {
13214 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13215
13216 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13217
13218 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;
13219 }
13220 }
13221 }
13222 #endif // WIN && HAVE_NVAPI
13223
13224 #if defined(LINUX) && defined(HAVE_NVML)
13225 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13226
13227 if (nvml_init (nvml) == 0)
13228 data.hm_nv = nvml;
13229
13230 if (data.hm_nv)
13231 {
13232 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13233 {
13234 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13235
13236 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13237
13238 int tmp_out = 0;
13239
13240 for (int i = 0; i < tmp_in; i++)
13241 {
13242 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13243 }
13244
13245 for (int i = 0; i < tmp_out; i++)
13246 {
13247 unsigned int speed;
13248
13249 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;
13250 }
13251 }
13252 }
13253 #endif // LINUX && HAVE_NVML
13254
13255 data.hm_amd = NULL;
13256
13257 #ifdef HAVE_ADL
13258 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13259
13260 if (adl_init (adl) == 0)
13261 data.hm_amd = adl;
13262
13263 if (data.hm_amd)
13264 {
13265 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13266 {
13267 // total number of adapters
13268
13269 int hm_adapters_num;
13270
13271 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13272
13273 // adapter info
13274
13275 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13276
13277 if (lpAdapterInfo == NULL) return (-1);
13278
13279 // get a list (of ids of) valid/usable adapters
13280
13281 int num_adl_adapters = 0;
13282
13283 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13284
13285 if (num_adl_adapters > 0)
13286 {
13287 hc_thread_mutex_lock (mux_adl);
13288
13289 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13290
13291 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13292
13293 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13294 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13295
13296 hc_thread_mutex_unlock (mux_adl);
13297 }
13298
13299 myfree (valid_adl_device_list);
13300 myfree (lpAdapterInfo);
13301 }
13302 }
13303 #endif // HAVE_ADL
13304
13305 if (data.hm_amd == NULL && data.hm_nv == NULL)
13306 {
13307 gpu_temp_disable = 1;
13308 }
13309 }
13310
13311 /**
13312 * OpenCL devices: allocate buffer for device specific information
13313 */
13314
13315 #ifdef HAVE_HWMON
13316 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13317
13318 #ifdef HAVE_ADL
13319 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13320
13321 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13322 #endif // ADL
13323 #endif
13324
13325 /**
13326 * enable custom signal handler(s)
13327 */
13328
13329 if (benchmark == 0)
13330 {
13331 hc_signal (sigHandler_default);
13332 }
13333 else
13334 {
13335 hc_signal (sigHandler_benchmark);
13336 }
13337
13338 /**
13339 * User-defined GPU temp handling
13340 */
13341
13342 #ifdef HAVE_HWMON
13343 if (gpu_temp_disable == 1)
13344 {
13345 gpu_temp_abort = 0;
13346 gpu_temp_retain = 0;
13347 }
13348
13349 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13350 {
13351 if (gpu_temp_abort < gpu_temp_retain)
13352 {
13353 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13354
13355 return (-1);
13356 }
13357 }
13358
13359 data.gpu_temp_disable = gpu_temp_disable;
13360 data.gpu_temp_abort = gpu_temp_abort;
13361 data.gpu_temp_retain = gpu_temp_retain;
13362 #endif
13363
13364 /**
13365 * inform the user
13366 */
13367
13368 if (data.quiet == 0)
13369 {
13370 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13371
13372 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);
13373
13374 if (attack_mode == ATTACK_MODE_STRAIGHT)
13375 {
13376 log_info ("Rules: %u", kernel_rules_cnt);
13377 }
13378
13379 if (opti_type)
13380 {
13381 log_info ("Applicable Optimizers:");
13382
13383 for (uint i = 0; i < 32; i++)
13384 {
13385 const uint opti_bit = 1u << i;
13386
13387 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13388 }
13389 }
13390
13391 /**
13392 * Watchdog and Temperature balance
13393 */
13394
13395 #ifdef HAVE_HWMON
13396 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13397 {
13398 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13399 }
13400
13401 if (gpu_temp_abort == 0)
13402 {
13403 log_info ("Watchdog: Temperature abort trigger disabled");
13404 }
13405 else
13406 {
13407 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13408 }
13409
13410 if (gpu_temp_retain == 0)
13411 {
13412 log_info ("Watchdog: Temperature retain trigger disabled");
13413 }
13414 else
13415 {
13416 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13417 }
13418 #endif
13419 }
13420
13421 if (data.quiet == 0) log_info ("");
13422
13423 /**
13424 * HM devices: copy
13425 */
13426
13427 if (gpu_temp_disable == 0)
13428 {
13429 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13430 {
13431 hc_device_param_t *device_param = &data.devices_param[device_id];
13432
13433 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13434
13435 if (device_param->skipped) continue;
13436
13437 const uint platform_devices_id = device_param->platform_devices_id;
13438
13439 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13440 if (device_param->vendor_id == VENDOR_ID_NV)
13441 {
13442 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13443 }
13444 #endif
13445
13446 #ifdef HAVE_ADL
13447 if (device_param->vendor_id == VENDOR_ID_AMD)
13448 {
13449 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13450 }
13451 #endif
13452 }
13453 }
13454
13455 /*
13456 * Temporary fix:
13457 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13458 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13459 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13460 * Driver / ADL bug?
13461 */
13462
13463 #ifdef HAVE_ADL
13464 if (powertune_enable == 1)
13465 {
13466 hc_thread_mutex_lock (mux_adl);
13467
13468 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13469 {
13470 hc_device_param_t *device_param = &data.devices_param[device_id];
13471
13472 if (device_param->skipped) continue;
13473
13474 if (data.hm_device[device_id].od_version == 6)
13475 {
13476 // set powertune value only
13477
13478 int powertune_supported = 0;
13479
13480 int ADL_rc = 0;
13481
13482 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13483 {
13484 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13485
13486 return (-1);
13487 }
13488
13489 if (powertune_supported != 0)
13490 {
13491 // powertune set
13492 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13493
13494 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13495 {
13496 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13497
13498 return (-1);
13499 }
13500
13501 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13502 {
13503 log_error ("ERROR: Failed to set new ADL PowerControl values");
13504
13505 return (-1);
13506 }
13507 }
13508 }
13509 }
13510
13511 hc_thread_mutex_unlock (mux_adl);
13512 }
13513 #endif // HAVE_ADK
13514 #endif // HAVE_HWMON
13515
13516 #ifdef DEBUG
13517 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13518 #endif
13519
13520 uint kernel_power_all = 0;
13521
13522 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13523 {
13524 /**
13525 * host buffer
13526 */
13527
13528 hc_device_param_t *device_param = &data.devices_param[device_id];
13529
13530 if (device_param->skipped) continue;
13531
13532 /**
13533 * device properties
13534 */
13535
13536 const char *device_name_chksum = device_param->device_name_chksum;
13537 const u32 device_processors = device_param->device_processors;
13538 const u32 device_processor_cores = device_param->device_processor_cores;
13539
13540 /**
13541 * create context for each device
13542 */
13543
13544 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13545
13546 /**
13547 * create command-queue
13548 */
13549
13550 // not supported with NV
13551 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13552
13553 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13554
13555 /**
13556 * kernel threads: some algorithms need a fixed kernel-threads count
13557 * because of shared memory usage or bitslice
13558 * there needs to be some upper limit, otherwise there's too much overhead
13559 */
13560
13561 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13562
13563 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13564 {
13565 kernel_threads = KERNEL_THREADS_MAX_CPU;
13566 }
13567
13568 if (hash_mode == 1500) kernel_threads = 64; // DES
13569 if (hash_mode == 3000) kernel_threads = 64; // DES
13570 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13571 if (hash_mode == 7500) kernel_threads = 64; // RC4
13572 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13573 if (hash_mode == 9700) kernel_threads = 64; // RC4
13574 if (hash_mode == 9710) kernel_threads = 64; // RC4
13575 if (hash_mode == 9800) kernel_threads = 64; // RC4
13576 if (hash_mode == 9810) kernel_threads = 64; // RC4
13577 if (hash_mode == 10400) kernel_threads = 64; // RC4
13578 if (hash_mode == 10410) kernel_threads = 64; // RC4
13579 if (hash_mode == 10500) kernel_threads = 64; // RC4
13580 if (hash_mode == 13100) kernel_threads = 64; // RC4
13581
13582 /**
13583 * create input buffers on device : calculate size of fixed memory buffers
13584 */
13585
13586 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13587 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13588
13589 device_param->size_root_css = size_root_css;
13590 device_param->size_markov_css = size_markov_css;
13591
13592 size_t size_results = kernel_threads * sizeof (uint);
13593
13594 device_param->size_results = size_results;
13595
13596 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13597 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13598
13599 size_t size_plains = digests_cnt * sizeof (plain_t);
13600 size_t size_salts = salts_cnt * sizeof (salt_t);
13601 size_t size_esalts = salts_cnt * esalt_size;
13602
13603 device_param->size_plains = size_plains;
13604 device_param->size_digests = size_digests;
13605 device_param->size_shown = size_shown;
13606 device_param->size_salts = size_salts;
13607
13608 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13609 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13610 size_t size_tm = 32 * sizeof (bs_word_t);
13611
13612 // scryptV stuff
13613
13614 size_t size_scryptV = 1;
13615
13616 if ((hash_mode == 8900) || (hash_mode == 9300))
13617 {
13618 uint tmto_start = 0;
13619 uint tmto_stop = 10;
13620
13621 if (scrypt_tmto)
13622 {
13623 tmto_start = scrypt_tmto;
13624 }
13625 else
13626 {
13627 // in case the user did not specify the tmto manually
13628 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13629 // but set the lower end only in case the user has a device with too less memory
13630
13631 if (hash_mode == 8900)
13632 {
13633 if (device_param->vendor_id == VENDOR_ID_AMD)
13634 {
13635 tmto_start = 1;
13636 }
13637 else if (device_param->vendor_id == VENDOR_ID_NV)
13638 {
13639 tmto_start = 2;
13640 }
13641 }
13642 else if (hash_mode == 9300)
13643 {
13644 if (device_param->vendor_id == VENDOR_ID_AMD)
13645 {
13646 tmto_start = 2;
13647 }
13648 else if (device_param->vendor_id == VENDOR_ID_NV)
13649 {
13650 tmto_start = 2;
13651 }
13652 }
13653 }
13654
13655 if (quiet == 0) log_info ("");
13656
13657 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13658 {
13659 // TODO: in theory the following calculation needs to be done per salt, not global
13660 // we assume all hashes have the same scrypt settings
13661
13662 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13663
13664 size_scryptV /= 1 << tmto;
13665
13666 size_scryptV *= device_processors * device_processor_cores;
13667
13668 if (size_scryptV > device_param->device_maxmem_alloc)
13669 {
13670 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13671
13672 continue;
13673 }
13674
13675 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13676 {
13677 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13678 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13679 }
13680
13681 break;
13682 }
13683
13684 if (data.salts_buf[0].scrypt_phy == 0)
13685 {
13686 log_error ("ERROR: can't allocate enough device memory");
13687
13688 return -1;
13689 }
13690
13691 if (quiet == 0) log_info ("");
13692 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13693 }
13694
13695 /**
13696 * some algorithms need a fixed kernel-loops count
13697 */
13698
13699 if (hash_mode == 1500)
13700 {
13701 const u32 kernel_loops_fixed = 1024;
13702
13703 device_param->kernel_loops_min = kernel_loops_fixed;
13704 device_param->kernel_loops_max = kernel_loops_fixed;
13705 }
13706
13707 if (hash_mode == 3000)
13708 {
13709 const u32 kernel_loops_fixed = 1024;
13710
13711 device_param->kernel_loops_min = kernel_loops_fixed;
13712 device_param->kernel_loops_max = kernel_loops_fixed;
13713 }
13714
13715 if (hash_mode == 8900)
13716 {
13717 const u32 kernel_loops_fixed = 1;
13718
13719 device_param->kernel_loops_min = kernel_loops_fixed;
13720 device_param->kernel_loops_max = kernel_loops_fixed;
13721 }
13722
13723 if (hash_mode == 9300)
13724 {
13725 const u32 kernel_loops_fixed = 1;
13726
13727 device_param->kernel_loops_min = kernel_loops_fixed;
13728 device_param->kernel_loops_max = kernel_loops_fixed;
13729 }
13730
13731 if (hash_mode == 12500)
13732 {
13733 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13734
13735 device_param->kernel_loops_min = kernel_loops_fixed;
13736 device_param->kernel_loops_max = kernel_loops_fixed;
13737 }
13738
13739 /**
13740 * some algorithms have a maximum kernel-loops count
13741 */
13742
13743 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13744 {
13745 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13746 {
13747 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13748 }
13749 }
13750
13751 /**
13752 * some algorithms need a special kernel-accel
13753 */
13754
13755 if (hash_mode == 8900)
13756 {
13757 device_param->kernel_accel_min = 1;
13758 device_param->kernel_accel_max = 64;
13759 }
13760
13761 if (hash_mode == 9300)
13762 {
13763 device_param->kernel_accel_min = 1;
13764 device_param->kernel_accel_max = 64;
13765 }
13766
13767 u32 kernel_accel_min = device_param->kernel_accel_min;
13768 u32 kernel_accel_max = device_param->kernel_accel_max;
13769
13770 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13771
13772 size_t size_pws = 4;
13773 size_t size_tmps = 4;
13774 size_t size_hooks = 4;
13775
13776 while (kernel_accel_max >= kernel_accel_min)
13777 {
13778 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13779
13780 // size_pws
13781
13782 size_pws = kernel_power_max * sizeof (pw_t);
13783
13784 // size_tmps
13785
13786 switch (hash_mode)
13787 {
13788 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13789 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13790 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13791 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13792 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13793 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13794 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13795 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13796 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13797 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13798 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13799 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13800 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13801 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13802 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13803 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13804 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13805 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13806 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13807 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13808 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13809 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13810 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13811 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13812 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13813 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13814 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13815 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13816 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13817 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13818 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13819 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13820 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13821 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13822 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13823 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13824 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13825 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13826 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13827 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13828 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13829 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13830 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13831 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13832 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13833 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13834 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13835 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13836 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13837 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13838 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13839 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13840 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13841 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13842 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13843 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13844 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13845 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13846 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13847 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13848 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13849 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13850 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13851 };
13852
13853 // size_hooks
13854
13855 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13856 {
13857 // none yet
13858 }
13859
13860 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13861 // if not, decrease amplifier and try again
13862
13863 int skip = 0;
13864
13865 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13866 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13867 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13868
13869 if (( bitmap_size
13870 + bitmap_size
13871 + bitmap_size
13872 + bitmap_size
13873 + bitmap_size
13874 + bitmap_size
13875 + bitmap_size
13876 + bitmap_size
13877 + size_bfs
13878 + size_combs
13879 + size_digests
13880 + size_esalts
13881 + size_hooks
13882 + size_markov_css
13883 + size_plains
13884 + size_pws
13885 + size_pws // not a bug
13886 + size_results
13887 + size_root_css
13888 + size_rules
13889 + size_rules_c
13890 + size_salts
13891 + size_scryptV
13892 + size_shown
13893 + size_tm
13894 + size_tmps) > device_param->device_global_mem) skip = 1;
13895
13896 if (skip == 1)
13897 {
13898 kernel_accel_max--;
13899
13900 continue;
13901 }
13902
13903 break;
13904 }
13905
13906 /*
13907 if (kernel_accel_max == 0)
13908 {
13909 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13910
13911 return -1;
13912 }
13913 */
13914
13915 device_param->kernel_accel_min = kernel_accel_min;
13916 device_param->kernel_accel_max = kernel_accel_max;
13917
13918 /*
13919 if (kernel_accel_max < kernel_accel)
13920 {
13921 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13922
13923 device_param->kernel_accel = kernel_accel_max;
13924 }
13925 */
13926
13927 device_param->size_bfs = size_bfs;
13928 device_param->size_combs = size_combs;
13929 device_param->size_rules = size_rules;
13930 device_param->size_rules_c = size_rules_c;
13931 device_param->size_pws = size_pws;
13932 device_param->size_tmps = size_tmps;
13933 device_param->size_hooks = size_hooks;
13934
13935 // do not confuse kernel_accel_max with kernel_accel here
13936
13937 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13938
13939 device_param->kernel_threads = kernel_threads;
13940 device_param->kernel_power_user = kernel_power;
13941
13942 kernel_power_all += kernel_power;
13943
13944 /**
13945 * default building options
13946 */
13947
13948 char build_opts[1024] = { 0 };
13949
13950 // we don't have sm_* on vendors not NV but it doesn't matter
13951
13952 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);
13953
13954 /**
13955 * main kernel
13956 */
13957
13958 {
13959 /**
13960 * kernel source filename
13961 */
13962
13963 char source_file[256] = { 0 };
13964
13965 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13966
13967 struct stat sst;
13968
13969 if (stat (source_file, &sst) == -1)
13970 {
13971 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13972
13973 return -1;
13974 }
13975
13976 /**
13977 * kernel cached filename
13978 */
13979
13980 char cached_file[256] = { 0 };
13981
13982 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13983
13984 int cached = 1;
13985
13986 struct stat cst;
13987
13988 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13989 {
13990 cached = 0;
13991 }
13992
13993 /**
13994 * kernel compile or load
13995 */
13996
13997 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13998
13999 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14000
14001 if (force_jit_compilation == -1)
14002 {
14003 if (cached == 0)
14004 {
14005 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14006
14007 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14008
14009 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14010
14011 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14012
14013 #ifdef DEBUG
14014 size_t build_log_size = 0;
14015
14016 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14017
14018 if (build_log_size > 1)
14019 {
14020 char *build_log = (char *) malloc (build_log_size + 1);
14021
14022 memset (build_log, 0, build_log_size + 1);
14023
14024 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14025
14026 puts (build_log);
14027
14028 free (build_log);
14029 }
14030 #endif
14031
14032 if (rc != 0)
14033 {
14034 device_param->skipped = true;
14035 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14036 continue;
14037 }
14038
14039 size_t binary_size;
14040
14041 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14042
14043 u8 *binary = (u8 *) mymalloc (binary_size);
14044
14045 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14046
14047 writeProgramBin (cached_file, binary, binary_size);
14048
14049 local_free (binary);
14050 }
14051 else
14052 {
14053 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14054
14055 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14056
14057 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14058
14059 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14060 }
14061 }
14062 else
14063 {
14064 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14065
14066 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14067
14068 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14069
14070 char build_opts_update[1024] = { 0 };
14071
14072 if (force_jit_compilation == 1500)
14073 {
14074 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14075 }
14076 else if (force_jit_compilation == 8900)
14077 {
14078 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);
14079 }
14080 else
14081 {
14082 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14083 }
14084
14085 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14086
14087 #ifdef DEBUG
14088 size_t build_log_size = 0;
14089
14090 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14091
14092 if (build_log_size > 1)
14093 {
14094 char *build_log = (char *) malloc (build_log_size + 1);
14095
14096 memset (build_log, 0, build_log_size + 1);
14097
14098 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14099
14100 puts (build_log);
14101
14102 free (build_log);
14103 }
14104 #endif
14105
14106 if (rc != 0)
14107 {
14108 device_param->skipped = true;
14109
14110 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14111 }
14112 }
14113
14114 local_free (kernel_lengths);
14115 local_free (kernel_sources[0]);
14116 local_free (kernel_sources);
14117 }
14118
14119 /**
14120 * word generator kernel
14121 */
14122
14123 if (attack_mode != ATTACK_MODE_STRAIGHT)
14124 {
14125 /**
14126 * kernel mp source filename
14127 */
14128
14129 char source_file[256] = { 0 };
14130
14131 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14132
14133 struct stat sst;
14134
14135 if (stat (source_file, &sst) == -1)
14136 {
14137 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14138
14139 return -1;
14140 }
14141
14142 /**
14143 * kernel mp cached filename
14144 */
14145
14146 char cached_file[256] = { 0 };
14147
14148 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14149
14150 int cached = 1;
14151
14152 struct stat cst;
14153
14154 if (stat (cached_file, &cst) == -1)
14155 {
14156 cached = 0;
14157 }
14158
14159 /**
14160 * kernel compile or load
14161 */
14162
14163 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14164
14165 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14166
14167 if (cached == 0)
14168 {
14169 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14170
14171 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14172
14173 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14174
14175 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14176
14177 if (rc != 0)
14178 {
14179 device_param->skipped = true;
14180 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14181 continue;
14182 }
14183
14184 size_t binary_size;
14185
14186 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14187
14188 u8 *binary = (u8 *) mymalloc (binary_size);
14189
14190 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14191
14192 writeProgramBin (cached_file, binary, binary_size);
14193
14194 local_free (binary);
14195 }
14196 else
14197 {
14198 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14199
14200 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14201
14202 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14203
14204 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14205 }
14206
14207 local_free (kernel_lengths);
14208 local_free (kernel_sources[0]);
14209 local_free (kernel_sources);
14210 }
14211
14212 /**
14213 * amplifier kernel
14214 */
14215
14216 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14217 {
14218
14219 }
14220 else
14221 {
14222 /**
14223 * kernel amp source filename
14224 */
14225
14226 char source_file[256] = { 0 };
14227
14228 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14229
14230 struct stat sst;
14231
14232 if (stat (source_file, &sst) == -1)
14233 {
14234 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14235
14236 return -1;
14237 }
14238
14239 /**
14240 * kernel amp cached filename
14241 */
14242
14243 char cached_file[256] = { 0 };
14244
14245 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14246
14247 int cached = 1;
14248
14249 struct stat cst;
14250
14251 if (stat (cached_file, &cst) == -1)
14252 {
14253 cached = 0;
14254 }
14255
14256 /**
14257 * kernel compile or load
14258 */
14259
14260 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14261
14262 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14263
14264 if (cached == 0)
14265 {
14266 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14267
14268 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14269
14270 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14271
14272 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14273
14274 if (rc != 0)
14275 {
14276 device_param->skipped = true;
14277 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14278 continue;
14279 }
14280
14281 size_t binary_size;
14282
14283 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14284
14285 u8 *binary = (u8 *) mymalloc (binary_size);
14286
14287 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14288
14289 writeProgramBin (cached_file, binary, binary_size);
14290
14291 local_free (binary);
14292 }
14293 else
14294 {
14295 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14296
14297 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14298
14299 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14300
14301 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14302 }
14303
14304 local_free (kernel_lengths);
14305 local_free (kernel_sources[0]);
14306 local_free (kernel_sources);
14307 }
14308
14309 // some algorithm collide too fast, make that impossible
14310
14311 if (benchmark == 1)
14312 {
14313 ((uint *) digests_buf)[0] = -1;
14314 ((uint *) digests_buf)[1] = -1;
14315 ((uint *) digests_buf)[2] = -1;
14316 ((uint *) digests_buf)[3] = -1;
14317 }
14318
14319 /**
14320 * global buffers
14321 */
14322
14323 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14324 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14325 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14326 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14327 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14328 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14329 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14330 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14331 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14332 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14333 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14334 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14335 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14336 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14337 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14338 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14339 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14340 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14341
14342 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);
14343 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);
14344 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);
14345 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);
14346 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);
14347 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);
14348 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);
14349 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);
14350 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14351 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14352 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14353
14354 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14355 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14356 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14357 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14358 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14359 run_kernel_bzero (device_param, device_param->d_result, size_results);
14360
14361 /**
14362 * special buffers
14363 */
14364
14365 if (attack_kern == ATTACK_KERN_STRAIGHT)
14366 {
14367 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14368 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14369
14370 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14371
14372 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14373 }
14374 else if (attack_kern == ATTACK_KERN_COMBI)
14375 {
14376 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14377 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14378 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14379 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14380
14381 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14382 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14383 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14384 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14385 }
14386 else if (attack_kern == ATTACK_KERN_BF)
14387 {
14388 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14389 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14390 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14391 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14392 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14393
14394 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14395 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14396 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14397 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14398 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14399 }
14400
14401 if (size_esalts)
14402 {
14403 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14404
14405 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14406 }
14407
14408 /**
14409 * main host data
14410 */
14411
14412 uint *result = (uint *) mymalloc (size_results);
14413
14414 device_param->result = result;
14415
14416 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14417
14418 device_param->pws_buf = pws_buf;
14419
14420 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14421
14422 device_param->combs_buf = combs_buf;
14423
14424 void *hooks_buf = mymalloc (size_hooks);
14425
14426 device_param->hooks_buf = hooks_buf;
14427
14428 /**
14429 * kernel args
14430 */
14431
14432 device_param->kernel_params_buf32[21] = bitmap_mask;
14433 device_param->kernel_params_buf32[22] = bitmap_shift1;
14434 device_param->kernel_params_buf32[23] = bitmap_shift2;
14435 device_param->kernel_params_buf32[24] = 0; // salt_pos
14436 device_param->kernel_params_buf32[25] = 0; // loop_pos
14437 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14438 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14439 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14440 device_param->kernel_params_buf32[29] = 0; // digests_offset
14441 device_param->kernel_params_buf32[30] = 0; // combs_mode
14442 device_param->kernel_params_buf32[31] = 0; // gid_max
14443
14444 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14445 ? &device_param->d_pws_buf
14446 : &device_param->d_pws_amp_buf;
14447 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14448 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14449 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14450 device_param->kernel_params[ 4] = &device_param->d_tmps;
14451 device_param->kernel_params[ 5] = &device_param->d_hooks;
14452 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14453 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14454 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14455 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14456 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14457 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14458 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14459 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14460 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14461 device_param->kernel_params[15] = &device_param->d_digests_buf;
14462 device_param->kernel_params[16] = &device_param->d_digests_shown;
14463 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14464 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14465 device_param->kernel_params[19] = &device_param->d_result;
14466 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14467 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14468 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14469 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14470 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14471 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14472 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14473 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14474 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14475 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14476 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14477 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14478
14479 device_param->kernel_params_mp_buf64[3] = 0;
14480 device_param->kernel_params_mp_buf32[4] = 0;
14481 device_param->kernel_params_mp_buf32[5] = 0;
14482 device_param->kernel_params_mp_buf32[6] = 0;
14483 device_param->kernel_params_mp_buf32[7] = 0;
14484 device_param->kernel_params_mp_buf32[8] = 0;
14485
14486 device_param->kernel_params_mp[0] = NULL;
14487 device_param->kernel_params_mp[1] = NULL;
14488 device_param->kernel_params_mp[2] = NULL;
14489 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14490 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14491 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14492 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14493 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14494 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14495
14496 device_param->kernel_params_mp_l_buf64[3] = 0;
14497 device_param->kernel_params_mp_l_buf32[4] = 0;
14498 device_param->kernel_params_mp_l_buf32[5] = 0;
14499 device_param->kernel_params_mp_l_buf32[6] = 0;
14500 device_param->kernel_params_mp_l_buf32[7] = 0;
14501 device_param->kernel_params_mp_l_buf32[8] = 0;
14502 device_param->kernel_params_mp_l_buf32[9] = 0;
14503
14504 device_param->kernel_params_mp_l[0] = NULL;
14505 device_param->kernel_params_mp_l[1] = NULL;
14506 device_param->kernel_params_mp_l[2] = NULL;
14507 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14508 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14509 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14510 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14511 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14512 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14513 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14514
14515 device_param->kernel_params_mp_r_buf64[3] = 0;
14516 device_param->kernel_params_mp_r_buf32[4] = 0;
14517 device_param->kernel_params_mp_r_buf32[5] = 0;
14518 device_param->kernel_params_mp_r_buf32[6] = 0;
14519 device_param->kernel_params_mp_r_buf32[7] = 0;
14520 device_param->kernel_params_mp_r_buf32[8] = 0;
14521
14522 device_param->kernel_params_mp_r[0] = NULL;
14523 device_param->kernel_params_mp_r[1] = NULL;
14524 device_param->kernel_params_mp_r[2] = NULL;
14525 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14526 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14527 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14528 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14529 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14530 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14531
14532 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14533 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14534
14535 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14536 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14537 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14538 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14539 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14540 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14541 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14542
14543 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14544 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14545
14546 /**
14547 * kernel name
14548 */
14549
14550 char kernel_name[64] = { 0 };
14551
14552 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14553 {
14554 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14555 {
14556 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14557
14558 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14559
14560 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14561
14562 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14563
14564 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14565
14566 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14567 }
14568 else
14569 {
14570 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14571
14572 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14573
14574 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14575
14576 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14577
14578 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14579
14580 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14581 }
14582
14583 if (data.attack_mode == ATTACK_MODE_BF)
14584 {
14585 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14586 {
14587 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14588
14589 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14590 }
14591 }
14592 }
14593 else
14594 {
14595 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14596
14597 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14598
14599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14600
14601 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14602
14603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14604
14605 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14606
14607 if (opts_type & OPTS_TYPE_HOOK12)
14608 {
14609 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14610
14611 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14612 }
14613
14614 if (opts_type & OPTS_TYPE_HOOK23)
14615 {
14616 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14617
14618 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14619 }
14620 }
14621
14622 for (uint i = 0; i <= 20; i++)
14623 {
14624 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14625 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14626 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14627
14628 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14629 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14630 }
14631
14632 for (uint i = 21; i <= 31; i++)
14633 {
14634 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14635 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14636 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14637
14638 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14639 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14640 }
14641
14642 if (attack_mode == ATTACK_MODE_BF)
14643 {
14644 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14645 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14646
14647 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14648 {
14649 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14650 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14651 }
14652 }
14653 else if (attack_mode == ATTACK_MODE_HYBRID1)
14654 {
14655 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14656 }
14657 else if (attack_mode == ATTACK_MODE_HYBRID2)
14658 {
14659 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14660 }
14661
14662 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14663 {
14664 // nothing to do
14665 }
14666 else
14667 {
14668 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14669 }
14670
14671 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14672 {
14673 // nothing to do
14674 }
14675 else
14676 {
14677 for (uint i = 0; i < 5; i++)
14678 {
14679 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14680 }
14681
14682 for (uint i = 5; i < 7; i++)
14683 {
14684 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14685 }
14686 }
14687
14688 /**
14689 * Store initial fanspeed if gpu_temp_retain is enabled
14690 */
14691
14692 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14693 int gpu_temp_retain_set = 0;
14694
14695 if (gpu_temp_disable == 0)
14696 {
14697 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14698 {
14699 hc_thread_mutex_lock (mux_adl);
14700
14701 if (data.hm_device[device_id].fan_supported == 1)
14702 {
14703 if (gpu_temp_retain_chgd == 0)
14704 {
14705 uint cur_temp = 0;
14706 uint default_temp = 0;
14707
14708 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);
14709
14710 if (ADL_rc == ADL_OK)
14711 {
14712 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14713
14714 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14715
14716 // special case with multi gpu setups: always use minimum retain
14717
14718 if (gpu_temp_retain_set == 0)
14719 {
14720 gpu_temp_retain = gpu_temp_retain_target;
14721 gpu_temp_retain_set = 1;
14722 }
14723 else
14724 {
14725 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14726 }
14727
14728 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14729 }
14730 }
14731
14732 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14733
14734 temp_retain_fanspeed_value[device_id] = fan_speed;
14735
14736 if (fan_speed == -1)
14737 {
14738 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14739
14740 temp_retain_fanspeed_value[device_id] = 0;
14741 }
14742 }
14743
14744 hc_thread_mutex_unlock (mux_adl);
14745 }
14746 }
14747
14748 /**
14749 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14750 */
14751
14752 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14753 {
14754 hc_thread_mutex_lock (mux_adl);
14755
14756 if (data.hm_device[device_id].od_version == 6)
14757 {
14758 int ADL_rc;
14759
14760 // check powertune capabilities first, if not available then skip device
14761
14762 int powertune_supported = 0;
14763
14764 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14765 {
14766 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14767
14768 return (-1);
14769 }
14770
14771 if (powertune_supported != 0)
14772 {
14773 // powercontrol settings
14774
14775 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14776
14777 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14778 {
14779 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14780 }
14781
14782 if (ADL_rc != ADL_OK)
14783 {
14784 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14785
14786 return (-1);
14787 }
14788
14789 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14790 {
14791 log_error ("ERROR: Failed to set new ADL PowerControl values");
14792
14793 return (-1);
14794 }
14795
14796 // clocks
14797
14798 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14799
14800 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14801
14802 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)
14803 {
14804 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14805
14806 return (-1);
14807 }
14808
14809 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14810
14811 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14812
14813 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14814 {
14815 log_error ("ERROR: Failed to get ADL device capabilities");
14816
14817 return (-1);
14818 }
14819
14820 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14821 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14822
14823 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14824 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14825
14826 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14827 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14828
14829 // warning if profile has too low max values
14830
14831 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14832 {
14833 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14834 }
14835
14836 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14837 {
14838 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14839 }
14840
14841 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14842
14843 performance_state->iNumberOfPerformanceLevels = 2;
14844
14845 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14846 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14847 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14848 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14849
14850 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)
14851 {
14852 log_info ("ERROR: Failed to set ADL performance state");
14853
14854 return (-1);
14855 }
14856
14857 local_free (performance_state);
14858 }
14859 }
14860
14861 hc_thread_mutex_unlock (mux_adl);
14862 }
14863 #endif // HAVE_HWMON && HAVE_ADL
14864 }
14865
14866 data.kernel_power_all = kernel_power_all;
14867
14868 if (data.quiet == 0) log_info ("");
14869
14870 /**
14871 * In benchmark-mode, inform user which algorithm is checked
14872 */
14873
14874 if (benchmark == 1)
14875 {
14876 quiet = 0;
14877
14878 data.quiet = quiet;
14879
14880 char *hash_type = strhashtype (data.hash_mode); // not a bug
14881
14882 log_info ("Hashtype: %s", hash_type);
14883 log_info ("");
14884 }
14885
14886 /**
14887 * keep track of the progress
14888 */
14889
14890 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14891 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14892 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14893
14894 /**
14895 * open filehandles
14896 */
14897
14898 #if _WIN
14899 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14900 {
14901 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14902
14903 return (-1);
14904 }
14905
14906 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14907 {
14908 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14909
14910 return (-1);
14911 }
14912
14913 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14914 {
14915 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14916
14917 return (-1);
14918 }
14919 #endif
14920
14921 /**
14922 * dictionary pad
14923 */
14924
14925 segment_size *= (1024 * 1024);
14926
14927 data.segment_size = segment_size;
14928
14929 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14930
14931 wl_data->buf = (char *) mymalloc (segment_size);
14932 wl_data->avail = segment_size;
14933 wl_data->incr = segment_size;
14934 wl_data->cnt = 0;
14935 wl_data->pos = 0;
14936
14937 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14938
14939 data.wordlist_mode = wordlist_mode;
14940
14941 cs_t *css_buf = NULL;
14942 uint css_cnt = 0;
14943 uint dictcnt = 0;
14944 uint maskcnt = 1;
14945 char **masks = NULL;
14946 char **dictfiles = NULL;
14947
14948 uint mask_from_file = 0;
14949
14950 if (attack_mode == ATTACK_MODE_STRAIGHT)
14951 {
14952 if (wordlist_mode == WL_MODE_FILE)
14953 {
14954 int wls_left = myargc - (optind + 1);
14955
14956 for (int i = 0; i < wls_left; i++)
14957 {
14958 char *l0_filename = myargv[optind + 1 + i];
14959
14960 struct stat l0_stat;
14961
14962 if (stat (l0_filename, &l0_stat) == -1)
14963 {
14964 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14965
14966 return (-1);
14967 }
14968
14969 uint is_dir = S_ISDIR (l0_stat.st_mode);
14970
14971 if (is_dir == 0)
14972 {
14973 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14974
14975 dictcnt++;
14976
14977 dictfiles[dictcnt - 1] = l0_filename;
14978 }
14979 else
14980 {
14981 // do not allow --keyspace w/ a directory
14982
14983 if (keyspace == 1)
14984 {
14985 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14986
14987 return (-1);
14988 }
14989
14990 char **dictionary_files = NULL;
14991
14992 dictionary_files = scan_directory (l0_filename);
14993
14994 if (dictionary_files != NULL)
14995 {
14996 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14997
14998 for (int d = 0; dictionary_files[d] != NULL; d++)
14999 {
15000 char *l1_filename = dictionary_files[d];
15001
15002 struct stat l1_stat;
15003
15004 if (stat (l1_filename, &l1_stat) == -1)
15005 {
15006 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15007
15008 return (-1);
15009 }
15010
15011 if (S_ISREG (l1_stat.st_mode))
15012 {
15013 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15014
15015 dictcnt++;
15016
15017 dictfiles[dictcnt - 1] = strdup (l1_filename);
15018 }
15019 }
15020 }
15021
15022 local_free (dictionary_files);
15023 }
15024 }
15025
15026 if (dictcnt < 1)
15027 {
15028 log_error ("ERROR: No usable dictionary file found.");
15029
15030 return (-1);
15031 }
15032 }
15033 else if (wordlist_mode == WL_MODE_STDIN)
15034 {
15035 dictcnt = 1;
15036 }
15037 }
15038 else if (attack_mode == ATTACK_MODE_COMBI)
15039 {
15040 // display
15041
15042 char *dictfile1 = myargv[optind + 1 + 0];
15043 char *dictfile2 = myargv[optind + 1 + 1];
15044
15045 // find the bigger dictionary and use as base
15046
15047 FILE *fp1 = NULL;
15048 FILE *fp2 = NULL;
15049
15050 struct stat tmp_stat;
15051
15052 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15053 {
15054 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15055
15056 return (-1);
15057 }
15058
15059 if (stat (dictfile1, &tmp_stat) == -1)
15060 {
15061 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15062
15063 fclose (fp1);
15064
15065 return (-1);
15066 }
15067
15068 if (S_ISDIR (tmp_stat.st_mode))
15069 {
15070 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15071
15072 fclose (fp1);
15073
15074 return (-1);
15075 }
15076
15077 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15078 {
15079 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15080
15081 fclose (fp1);
15082
15083 return (-1);
15084 }
15085
15086 if (stat (dictfile2, &tmp_stat) == -1)
15087 {
15088 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15089
15090 fclose (fp1);
15091 fclose (fp2);
15092
15093 return (-1);
15094 }
15095
15096 if (S_ISDIR (tmp_stat.st_mode))
15097 {
15098 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15099
15100 fclose (fp1);
15101 fclose (fp2);
15102
15103 return (-1);
15104 }
15105
15106 data.combs_cnt = 1;
15107
15108 data.quiet = 1;
15109
15110 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15111
15112 data.quiet = quiet;
15113
15114 if (words1_cnt == 0)
15115 {
15116 log_error ("ERROR: %s: empty file", dictfile1);
15117
15118 fclose (fp1);
15119 fclose (fp2);
15120
15121 return (-1);
15122 }
15123
15124 data.combs_cnt = 1;
15125
15126 data.quiet = 1;
15127
15128 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15129
15130 data.quiet = quiet;
15131
15132 if (words2_cnt == 0)
15133 {
15134 log_error ("ERROR: %s: empty file", dictfile2);
15135
15136 fclose (fp1);
15137 fclose (fp2);
15138
15139 return (-1);
15140 }
15141
15142 fclose (fp1);
15143 fclose (fp2);
15144
15145 data.dictfile = dictfile1;
15146 data.dictfile2 = dictfile2;
15147
15148 if (words1_cnt >= words2_cnt)
15149 {
15150 data.combs_cnt = words2_cnt;
15151 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15152
15153 dictfiles = &data.dictfile;
15154
15155 dictcnt = 1;
15156 }
15157 else
15158 {
15159 data.combs_cnt = words1_cnt;
15160 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15161
15162 dictfiles = &data.dictfile2;
15163
15164 dictcnt = 1;
15165
15166 // we also have to switch wordlist related rules!
15167
15168 char *tmpc = data.rule_buf_l;
15169
15170 data.rule_buf_l = data.rule_buf_r;
15171 data.rule_buf_r = tmpc;
15172
15173 int tmpi = data.rule_len_l;
15174
15175 data.rule_len_l = data.rule_len_r;
15176 data.rule_len_r = tmpi;
15177 }
15178 }
15179 else if (attack_mode == ATTACK_MODE_BF)
15180 {
15181 char *mask = NULL;
15182
15183 maskcnt = 0;
15184
15185 if (benchmark == 0)
15186 {
15187 mask = myargv[optind + 1];
15188
15189 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15190
15191 if ((optind + 2) <= myargc)
15192 {
15193 struct stat file_stat;
15194
15195 if (stat (mask, &file_stat) == -1)
15196 {
15197 maskcnt = 1;
15198
15199 masks[maskcnt - 1] = mystrdup (mask);
15200 }
15201 else
15202 {
15203 int wls_left = myargc - (optind + 1);
15204
15205 uint masks_avail = INCR_MASKS;
15206
15207 for (int i = 0; i < wls_left; i++)
15208 {
15209 if (i != 0)
15210 {
15211 mask = myargv[optind + 1 + i];
15212
15213 if (stat (mask, &file_stat) == -1)
15214 {
15215 log_error ("ERROR: %s: %s", mask, strerror (errno));
15216
15217 return (-1);
15218 }
15219 }
15220
15221 uint is_file = S_ISREG (file_stat.st_mode);
15222
15223 if (is_file == 1)
15224 {
15225 FILE *mask_fp;
15226
15227 if ((mask_fp = fopen (mask, "r")) == NULL)
15228 {
15229 log_error ("ERROR: %s: %s", mask, strerror (errno));
15230
15231 return (-1);
15232 }
15233
15234 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15235
15236 while (!feof (mask_fp))
15237 {
15238 memset (line_buf, 0, HCBUFSIZ);
15239
15240 int line_len = fgetl (mask_fp, line_buf);
15241
15242 if (line_len == 0) continue;
15243
15244 if (line_buf[0] == '#') continue;
15245
15246 if (masks_avail == maskcnt)
15247 {
15248 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15249
15250 masks_avail += INCR_MASKS;
15251 }
15252
15253 masks[maskcnt] = mystrdup (line_buf);
15254
15255 maskcnt++;
15256 }
15257
15258 myfree (line_buf);
15259
15260 fclose (mask_fp);
15261 }
15262 else
15263 {
15264 log_error ("ERROR: %s: unsupported file-type", mask);
15265
15266 return (-1);
15267 }
15268 }
15269
15270 mask_from_file = 1;
15271 }
15272 }
15273 else
15274 {
15275 custom_charset_1 = (char *) "?l?d?u";
15276 custom_charset_2 = (char *) "?l?d";
15277 custom_charset_3 = (char *) "?l?d*!$@_";
15278
15279 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15280 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15281 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15282
15283 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15284
15285 wordlist_mode = WL_MODE_MASK;
15286
15287 data.wordlist_mode = wordlist_mode;
15288
15289 increment = 1;
15290
15291 maskcnt = 1;
15292 }
15293 }
15294 else
15295 {
15296 /**
15297 * generate full masks and charsets
15298 */
15299
15300 masks = (char **) mymalloc (sizeof (char *));
15301
15302 switch (hash_mode)
15303 {
15304 case 1731: pw_min = 5;
15305 pw_max = 5;
15306 mask = mystrdup ("?b?b?b?b?b");
15307 break;
15308 case 12500: pw_min = 5;
15309 pw_max = 5;
15310 mask = mystrdup ("?b?b?b?b?b");
15311 break;
15312 default: pw_min = 7;
15313 pw_max = 7;
15314 mask = mystrdup ("?b?b?b?b?b?b?b");
15315 break;
15316 }
15317
15318 maskcnt = 1;
15319
15320 masks[maskcnt - 1] = mystrdup (mask);
15321
15322 wordlist_mode = WL_MODE_MASK;
15323
15324 data.wordlist_mode = wordlist_mode;
15325
15326 increment = 1;
15327 }
15328
15329 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15330
15331 if (increment)
15332 {
15333 if (increment_min > pw_min) pw_min = increment_min;
15334
15335 if (increment_max < pw_max) pw_max = increment_max;
15336 }
15337 }
15338 else if (attack_mode == ATTACK_MODE_HYBRID1)
15339 {
15340 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15341
15342 // display
15343
15344 char *mask = myargv[myargc - 1];
15345
15346 maskcnt = 0;
15347
15348 masks = (char **) mymalloc (1 * sizeof (char *));
15349
15350 // mod
15351
15352 struct stat file_stat;
15353
15354 if (stat (mask, &file_stat) == -1)
15355 {
15356 maskcnt = 1;
15357
15358 masks[maskcnt - 1] = mystrdup (mask);
15359 }
15360 else
15361 {
15362 uint is_file = S_ISREG (file_stat.st_mode);
15363
15364 if (is_file == 1)
15365 {
15366 FILE *mask_fp;
15367
15368 if ((mask_fp = fopen (mask, "r")) == NULL)
15369 {
15370 log_error ("ERROR: %s: %s", mask, strerror (errno));
15371
15372 return (-1);
15373 }
15374
15375 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15376
15377 uint masks_avail = 1;
15378
15379 while (!feof (mask_fp))
15380 {
15381 memset (line_buf, 0, HCBUFSIZ);
15382
15383 int line_len = fgetl (mask_fp, line_buf);
15384
15385 if (line_len == 0) continue;
15386
15387 if (line_buf[0] == '#') continue;
15388
15389 if (masks_avail == maskcnt)
15390 {
15391 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15392
15393 masks_avail += INCR_MASKS;
15394 }
15395
15396 masks[maskcnt] = mystrdup (line_buf);
15397
15398 maskcnt++;
15399 }
15400
15401 myfree (line_buf);
15402
15403 fclose (mask_fp);
15404
15405 mask_from_file = 1;
15406 }
15407 else
15408 {
15409 maskcnt = 1;
15410
15411 masks[maskcnt - 1] = mystrdup (mask);
15412 }
15413 }
15414
15415 // base
15416
15417 int wls_left = myargc - (optind + 2);
15418
15419 for (int i = 0; i < wls_left; i++)
15420 {
15421 char *filename = myargv[optind + 1 + i];
15422
15423 struct stat file_stat;
15424
15425 if (stat (filename, &file_stat) == -1)
15426 {
15427 log_error ("ERROR: %s: %s", filename, strerror (errno));
15428
15429 return (-1);
15430 }
15431
15432 uint is_dir = S_ISDIR (file_stat.st_mode);
15433
15434 if (is_dir == 0)
15435 {
15436 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15437
15438 dictcnt++;
15439
15440 dictfiles[dictcnt - 1] = filename;
15441 }
15442 else
15443 {
15444 // do not allow --keyspace w/ a directory
15445
15446 if (keyspace == 1)
15447 {
15448 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15449
15450 return (-1);
15451 }
15452
15453 char **dictionary_files = NULL;
15454
15455 dictionary_files = scan_directory (filename);
15456
15457 if (dictionary_files != NULL)
15458 {
15459 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15460
15461 for (int d = 0; dictionary_files[d] != NULL; d++)
15462 {
15463 char *l1_filename = dictionary_files[d];
15464
15465 struct stat l1_stat;
15466
15467 if (stat (l1_filename, &l1_stat) == -1)
15468 {
15469 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15470
15471 return (-1);
15472 }
15473
15474 if (S_ISREG (l1_stat.st_mode))
15475 {
15476 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15477
15478 dictcnt++;
15479
15480 dictfiles[dictcnt - 1] = strdup (l1_filename);
15481 }
15482 }
15483 }
15484
15485 local_free (dictionary_files);
15486 }
15487 }
15488
15489 if (dictcnt < 1)
15490 {
15491 log_error ("ERROR: No usable dictionary file found.");
15492
15493 return (-1);
15494 }
15495
15496 if (increment)
15497 {
15498 maskcnt = 0;
15499
15500 uint mask_min = increment_min; // we can't reject smaller masks here
15501 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15502
15503 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15504 {
15505 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15506
15507 if (cur_mask == NULL) break;
15508
15509 masks[maskcnt] = cur_mask;
15510
15511 maskcnt++;
15512
15513 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15514 }
15515 }
15516 }
15517 else if (attack_mode == ATTACK_MODE_HYBRID2)
15518 {
15519 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15520
15521 // display
15522
15523 char *mask = myargv[optind + 1 + 0];
15524
15525 maskcnt = 0;
15526
15527 masks = (char **) mymalloc (1 * sizeof (char *));
15528
15529 // mod
15530
15531 struct stat file_stat;
15532
15533 if (stat (mask, &file_stat) == -1)
15534 {
15535 maskcnt = 1;
15536
15537 masks[maskcnt - 1] = mystrdup (mask);
15538 }
15539 else
15540 {
15541 uint is_file = S_ISREG (file_stat.st_mode);
15542
15543 if (is_file == 1)
15544 {
15545 FILE *mask_fp;
15546
15547 if ((mask_fp = fopen (mask, "r")) == NULL)
15548 {
15549 log_error ("ERROR: %s: %s", mask, strerror (errno));
15550
15551 return (-1);
15552 }
15553
15554 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15555
15556 uint masks_avail = 1;
15557
15558 while (!feof (mask_fp))
15559 {
15560 memset (line_buf, 0, HCBUFSIZ);
15561
15562 int line_len = fgetl (mask_fp, line_buf);
15563
15564 if (line_len == 0) continue;
15565
15566 if (line_buf[0] == '#') continue;
15567
15568 if (masks_avail == maskcnt)
15569 {
15570 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15571
15572 masks_avail += INCR_MASKS;
15573 }
15574
15575 masks[maskcnt] = mystrdup (line_buf);
15576
15577 maskcnt++;
15578 }
15579
15580 myfree (line_buf);
15581
15582 fclose (mask_fp);
15583
15584 mask_from_file = 1;
15585 }
15586 else
15587 {
15588 maskcnt = 1;
15589
15590 masks[maskcnt - 1] = mystrdup (mask);
15591 }
15592 }
15593
15594 // base
15595
15596 int wls_left = myargc - (optind + 2);
15597
15598 for (int i = 0; i < wls_left; i++)
15599 {
15600 char *filename = myargv[optind + 2 + i];
15601
15602 struct stat file_stat;
15603
15604 if (stat (filename, &file_stat) == -1)
15605 {
15606 log_error ("ERROR: %s: %s", filename, strerror (errno));
15607
15608 return (-1);
15609 }
15610
15611 uint is_dir = S_ISDIR (file_stat.st_mode);
15612
15613 if (is_dir == 0)
15614 {
15615 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15616
15617 dictcnt++;
15618
15619 dictfiles[dictcnt - 1] = filename;
15620 }
15621 else
15622 {
15623 // do not allow --keyspace w/ a directory
15624
15625 if (keyspace == 1)
15626 {
15627 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15628
15629 return (-1);
15630 }
15631
15632 char **dictionary_files = NULL;
15633
15634 dictionary_files = scan_directory (filename);
15635
15636 if (dictionary_files != NULL)
15637 {
15638 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15639
15640 for (int d = 0; dictionary_files[d] != NULL; d++)
15641 {
15642 char *l1_filename = dictionary_files[d];
15643
15644 struct stat l1_stat;
15645
15646 if (stat (l1_filename, &l1_stat) == -1)
15647 {
15648 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15649
15650 return (-1);
15651 }
15652
15653 if (S_ISREG (l1_stat.st_mode))
15654 {
15655 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15656
15657 dictcnt++;
15658
15659 dictfiles[dictcnt - 1] = strdup (l1_filename);
15660 }
15661 }
15662 }
15663
15664 local_free (dictionary_files);
15665 }
15666 }
15667
15668 if (dictcnt < 1)
15669 {
15670 log_error ("ERROR: No usable dictionary file found.");
15671
15672 return (-1);
15673 }
15674
15675 if (increment)
15676 {
15677 maskcnt = 0;
15678
15679 uint mask_min = increment_min; // we can't reject smaller masks here
15680 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15681
15682 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15683 {
15684 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15685
15686 if (cur_mask == NULL) break;
15687
15688 masks[maskcnt] = cur_mask;
15689
15690 maskcnt++;
15691
15692 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15693 }
15694 }
15695 }
15696
15697 data.pw_min = pw_min;
15698 data.pw_max = pw_max;
15699
15700 /**
15701 * weak hash check
15702 */
15703
15704 if (weak_hash_threshold >= salts_cnt)
15705 {
15706 hc_device_param_t *device_param = NULL;
15707
15708 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15709 {
15710 device_param = &data.devices_param[device_id];
15711
15712 if (device_param->skipped) continue;
15713
15714 break;
15715 }
15716
15717 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15718
15719 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15720 {
15721 weak_hash_check (device_param, salt_pos);
15722 }
15723 }
15724
15725 // Display hack, guarantee that there is at least one \r before real start
15726
15727 if (data.quiet == 0) log_info_nn ("");
15728
15729 /**
15730 * status and monitor threads
15731 */
15732
15733 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15734
15735 hc_thread_t i_thread = 0;
15736
15737 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15738 {
15739 hc_thread_create (i_thread, thread_keypress, &benchmark);
15740 }
15741
15742 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15743
15744 uint ni_threads_cnt = 0;
15745
15746 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15747
15748 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15749
15750 ni_threads_cnt++;
15751
15752 /**
15753 * Outfile remove
15754 */
15755
15756 if (keyspace == 0)
15757 {
15758 if (outfile_check_timer != 0)
15759 {
15760 if (data.outfile_check_directory != NULL)
15761 {
15762 if ((hash_mode != 5200) &&
15763 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15764 (hash_mode != 9000))
15765 {
15766 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15767
15768 ni_threads_cnt++;
15769 }
15770 else
15771 {
15772 outfile_check_timer = 0;
15773 }
15774 }
15775 else
15776 {
15777 outfile_check_timer = 0;
15778 }
15779 }
15780 }
15781
15782 /**
15783 * Inform the user if we got some hashes remove because of the pot file remove feature
15784 */
15785
15786 if (data.quiet == 0)
15787 {
15788 if (potfile_remove_cracks > 0)
15789 {
15790 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15791 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15792 }
15793 }
15794
15795 data.outfile_check_timer = outfile_check_timer;
15796
15797 /**
15798 * main loop
15799 */
15800
15801 char **induction_dictionaries = NULL;
15802
15803 int induction_dictionaries_cnt = 0;
15804
15805 hcstat_table_t *root_table_buf = NULL;
15806 hcstat_table_t *markov_table_buf = NULL;
15807
15808 uint initial_restore_done = 0;
15809
15810 data.maskcnt = maskcnt;
15811
15812 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15813 {
15814 if (data.devices_status == STATUS_CRACKED) break;
15815
15816 data.devices_status = STATUS_INIT;
15817
15818 if (maskpos > rd->maskpos)
15819 {
15820 rd->dictpos = 0;
15821 }
15822
15823 rd->maskpos = maskpos;
15824 data.maskpos = maskpos;
15825
15826 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15827 {
15828 char *mask = masks[maskpos];
15829
15830 if (mask_from_file == 1)
15831 {
15832 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15833
15834 char *str_ptr;
15835 uint str_pos;
15836
15837 uint mask_offset = 0;
15838
15839 uint separator_cnt;
15840
15841 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15842 {
15843 str_ptr = strstr (mask + mask_offset, ",");
15844
15845 if (str_ptr == NULL) break;
15846
15847 str_pos = str_ptr - mask;
15848
15849 // escaped separator, i.e. "\,"
15850
15851 if (str_pos > 0)
15852 {
15853 if (mask[str_pos - 1] == '\\')
15854 {
15855 separator_cnt --;
15856
15857 mask_offset = str_pos + 1;
15858
15859 continue;
15860 }
15861 }
15862
15863 // reset the offset
15864
15865 mask_offset = 0;
15866
15867 mask[str_pos] = '\0';
15868
15869 switch (separator_cnt)
15870 {
15871 case 0:
15872 mp_reset_usr (mp_usr, 0);
15873
15874 custom_charset_1 = mask;
15875 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15876 break;
15877
15878 case 1:
15879 mp_reset_usr (mp_usr, 1);
15880
15881 custom_charset_2 = mask;
15882 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15883 break;
15884
15885 case 2:
15886 mp_reset_usr (mp_usr, 2);
15887
15888 custom_charset_3 = mask;
15889 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15890 break;
15891
15892 case 3:
15893 mp_reset_usr (mp_usr, 3);
15894
15895 custom_charset_4 = mask;
15896 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15897 break;
15898 }
15899
15900 mask = mask + str_pos + 1;
15901 }
15902 }
15903
15904 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15905 {
15906 if (maskpos > 0)
15907 {
15908 local_free (css_buf);
15909 local_free (data.root_css_buf);
15910 local_free (data.markov_css_buf);
15911
15912 local_free (masks[maskpos - 1]);
15913 }
15914
15915 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15916
15917 data.mask = mask;
15918 data.css_cnt = css_cnt;
15919 data.css_buf = css_buf;
15920
15921 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15922
15923 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15924
15925 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15926 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15927
15928 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15929
15930 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15931
15932 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15933 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15934
15935 data.root_css_buf = root_css_buf;
15936 data.markov_css_buf = markov_css_buf;
15937
15938 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15939
15940 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15941
15942 local_free (root_table_buf);
15943 local_free (markov_table_buf);
15944
15945 // args
15946
15947 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15948 {
15949 hc_device_param_t *device_param = &data.devices_param[device_id];
15950
15951 if (device_param->skipped) continue;
15952
15953 device_param->kernel_params_mp[0] = &device_param->d_combs;
15954 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15955 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15956
15957 device_param->kernel_params_mp_buf64[3] = 0;
15958 device_param->kernel_params_mp_buf32[4] = css_cnt;
15959 device_param->kernel_params_mp_buf32[5] = 0;
15960 device_param->kernel_params_mp_buf32[6] = 0;
15961 device_param->kernel_params_mp_buf32[7] = 0;
15962
15963 if (attack_mode == ATTACK_MODE_HYBRID1)
15964 {
15965 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15966 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15967 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15968 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15969 }
15970 else if (attack_mode == ATTACK_MODE_HYBRID2)
15971 {
15972 device_param->kernel_params_mp_buf32[5] = 0;
15973 device_param->kernel_params_mp_buf32[6] = 0;
15974 device_param->kernel_params_mp_buf32[7] = 0;
15975 }
15976
15977 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]);
15978 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]);
15979 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]);
15980
15981 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);
15982 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);
15983 }
15984 }
15985 else if (attack_mode == ATTACK_MODE_BF)
15986 {
15987 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15988
15989 if (increment)
15990 {
15991 for (uint i = 0; i < dictcnt; i++)
15992 {
15993 local_free (dictfiles[i]);
15994 }
15995
15996 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15997 {
15998 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15999
16000 if (l1_filename == NULL) break;
16001
16002 dictcnt++;
16003
16004 dictfiles[dictcnt - 1] = l1_filename;
16005 }
16006 }
16007 else
16008 {
16009 dictcnt++;
16010
16011 dictfiles[dictcnt - 1] = mask;
16012 }
16013
16014 if (dictcnt == 0)
16015 {
16016 log_error ("ERROR: Mask is too small");
16017
16018 return (-1);
16019 }
16020 }
16021 }
16022
16023 free (induction_dictionaries);
16024
16025 // induction_dictionaries_cnt = 0; // implied
16026
16027 if (attack_mode != ATTACK_MODE_BF)
16028 {
16029 if (keyspace == 0)
16030 {
16031 induction_dictionaries = scan_directory (induction_directory);
16032
16033 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16034 }
16035 }
16036
16037 if (induction_dictionaries_cnt)
16038 {
16039 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16040 }
16041
16042 /**
16043 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16044 */
16045 if (keyspace == 1)
16046 {
16047 if ((maskcnt > 1) || (dictcnt > 1))
16048 {
16049 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16050
16051 return (-1);
16052 }
16053 }
16054
16055 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16056 {
16057 char *subid = logfile_generate_subid ();
16058
16059 data.subid = subid;
16060
16061 logfile_sub_msg ("START");
16062
16063 data.devices_status = STATUS_INIT;
16064
16065 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16066 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16067 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16068
16069 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16070
16071 data.cpt_pos = 0;
16072
16073 data.cpt_start = time (NULL);
16074
16075 data.cpt_total = 0;
16076
16077 if (data.restore == 0)
16078 {
16079 rd->words_cur = skip;
16080
16081 skip = 0;
16082
16083 data.skip = 0;
16084 }
16085
16086 data.ms_paused = 0;
16087
16088 data.words_cur = rd->words_cur;
16089
16090 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16091 {
16092 hc_device_param_t *device_param = &data.devices_param[device_id];
16093
16094 if (device_param->skipped) continue;
16095
16096 device_param->speed_pos = 0;
16097
16098 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16099 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16100
16101 device_param->exec_pos = 0;
16102
16103 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16104
16105 device_param->kernel_power = device_param->kernel_power_user;
16106
16107 device_param->outerloop_pos = 0;
16108 device_param->outerloop_left = 0;
16109 device_param->innerloop_pos = 0;
16110 device_param->innerloop_left = 0;
16111
16112 // some more resets:
16113
16114 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16115
16116 device_param->pws_cnt = 0;
16117
16118 device_param->words_off = 0;
16119 device_param->words_done = 0;
16120 }
16121
16122 data.kernel_power_div = 0;
16123
16124 // figure out some workload
16125
16126 if (attack_mode == ATTACK_MODE_STRAIGHT)
16127 {
16128 if (data.wordlist_mode == WL_MODE_FILE)
16129 {
16130 char *dictfile = NULL;
16131
16132 if (induction_dictionaries_cnt)
16133 {
16134 dictfile = induction_dictionaries[0];
16135 }
16136 else
16137 {
16138 dictfile = dictfiles[dictpos];
16139 }
16140
16141 data.dictfile = dictfile;
16142
16143 logfile_sub_string (dictfile);
16144
16145 for (uint i = 0; i < rp_files_cnt; i++)
16146 {
16147 logfile_sub_var_string ("rulefile", rp_files[i]);
16148 }
16149
16150 FILE *fd2 = fopen (dictfile, "rb");
16151
16152 if (fd2 == NULL)
16153 {
16154 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16155
16156 return (-1);
16157 }
16158
16159 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16160
16161 fclose (fd2);
16162
16163 if (data.words_cnt == 0)
16164 {
16165 if (data.devices_status == STATUS_CRACKED) break;
16166 if (data.devices_status == STATUS_ABORTED) break;
16167
16168 dictpos++;
16169
16170 continue;
16171 }
16172 }
16173 }
16174 else if (attack_mode == ATTACK_MODE_COMBI)
16175 {
16176 char *dictfile = data.dictfile;
16177 char *dictfile2 = data.dictfile2;
16178
16179 logfile_sub_string (dictfile);
16180 logfile_sub_string (dictfile2);
16181
16182 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16183 {
16184 FILE *fd2 = fopen (dictfile, "rb");
16185
16186 if (fd2 == NULL)
16187 {
16188 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16189
16190 return (-1);
16191 }
16192
16193 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16194
16195 fclose (fd2);
16196 }
16197 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16198 {
16199 FILE *fd2 = fopen (dictfile2, "rb");
16200
16201 if (fd2 == NULL)
16202 {
16203 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16204
16205 return (-1);
16206 }
16207
16208 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16209
16210 fclose (fd2);
16211 }
16212
16213 if (data.words_cnt == 0)
16214 {
16215 if (data.devices_status == STATUS_CRACKED) break;
16216 if (data.devices_status == STATUS_ABORTED) break;
16217
16218 dictpos++;
16219
16220 continue;
16221 }
16222 }
16223 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16224 {
16225 char *dictfile = NULL;
16226
16227 if (induction_dictionaries_cnt)
16228 {
16229 dictfile = induction_dictionaries[0];
16230 }
16231 else
16232 {
16233 dictfile = dictfiles[dictpos];
16234 }
16235
16236 data.dictfile = dictfile;
16237
16238 char *mask = data.mask;
16239
16240 logfile_sub_string (dictfile);
16241 logfile_sub_string (mask);
16242
16243 FILE *fd2 = fopen (dictfile, "rb");
16244
16245 if (fd2 == NULL)
16246 {
16247 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16248
16249 return (-1);
16250 }
16251
16252 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16253
16254 fclose (fd2);
16255
16256 if (data.words_cnt == 0)
16257 {
16258 if (data.devices_status == STATUS_CRACKED) break;
16259 if (data.devices_status == STATUS_ABORTED) break;
16260
16261 dictpos++;
16262
16263 continue;
16264 }
16265 }
16266 else if (attack_mode == ATTACK_MODE_BF)
16267 {
16268 local_free (css_buf);
16269 local_free (data.root_css_buf);
16270 local_free (data.markov_css_buf);
16271
16272 char *mask = dictfiles[dictpos];
16273
16274 logfile_sub_string (mask);
16275
16276 // base
16277
16278 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16279
16280 if (opts_type & OPTS_TYPE_PT_UNICODE)
16281 {
16282 uint css_cnt_unicode = css_cnt * 2;
16283
16284 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16285
16286 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16287 {
16288 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16289
16290 css_buf_unicode[j + 1].cs_buf[0] = 0;
16291 css_buf_unicode[j + 1].cs_len = 1;
16292 }
16293
16294 free (css_buf);
16295
16296 css_buf = css_buf_unicode;
16297 css_cnt = css_cnt_unicode;
16298 }
16299
16300 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16301
16302 uint mask_min = pw_min;
16303 uint mask_max = pw_max;
16304
16305 if (opts_type & OPTS_TYPE_PT_UNICODE)
16306 {
16307 mask_min *= 2;
16308 mask_max *= 2;
16309 }
16310
16311 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16312 {
16313 if (css_cnt < mask_min)
16314 {
16315 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16316 }
16317
16318 if (css_cnt > mask_max)
16319 {
16320 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16321 }
16322
16323 // skip to next mask
16324
16325 dictpos++;
16326
16327 rd->dictpos = dictpos;
16328
16329 logfile_sub_msg ("STOP");
16330
16331 continue;
16332 }
16333
16334 uint save_css_cnt = css_cnt;
16335
16336 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16337 {
16338 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16339 {
16340 uint salt_len = (uint) data.salts_buf[0].salt_len;
16341 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16342
16343 uint css_cnt_salt = css_cnt + salt_len;
16344
16345 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16346
16347 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16348
16349 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16350 {
16351 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16352 css_buf_salt[j].cs_len = 1;
16353 }
16354
16355 free (css_buf);
16356
16357 css_buf = css_buf_salt;
16358 css_cnt = css_cnt_salt;
16359 }
16360 }
16361
16362 data.mask = mask;
16363 data.css_cnt = css_cnt;
16364 data.css_buf = css_buf;
16365
16366 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16367
16368 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16369
16370 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16371
16372 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16373 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16374
16375 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16376
16377 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16378
16379 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16380 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16381
16382 data.root_css_buf = root_css_buf;
16383 data.markov_css_buf = markov_css_buf;
16384
16385 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16386
16387 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16388
16389 local_free (root_table_buf);
16390 local_free (markov_table_buf);
16391
16392 // copy + args
16393
16394 uint css_cnt_l = css_cnt;
16395 uint css_cnt_r;
16396
16397 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16398 {
16399 if (save_css_cnt < 6)
16400 {
16401 css_cnt_r = 1;
16402 }
16403 else if (save_css_cnt == 6)
16404 {
16405 css_cnt_r = 2;
16406 }
16407 else
16408 {
16409 if (opts_type & OPTS_TYPE_PT_UNICODE)
16410 {
16411 if (save_css_cnt == 8 || save_css_cnt == 10)
16412 {
16413 css_cnt_r = 2;
16414 }
16415 else
16416 {
16417 css_cnt_r = 4;
16418 }
16419 }
16420 else
16421 {
16422 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16423 {
16424 css_cnt_r = 3;
16425 }
16426 else
16427 {
16428 css_cnt_r = 4;
16429 }
16430 }
16431 }
16432 }
16433 else
16434 {
16435 css_cnt_r = 1;
16436
16437 /* unfinished code?
16438 int sum = css_buf[css_cnt_r - 1].cs_len;
16439
16440 for (uint i = 1; i < 4 && i < css_cnt; i++)
16441 {
16442 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16443
16444 css_cnt_r++;
16445
16446 sum *= css_buf[css_cnt_r - 1].cs_len;
16447 }
16448 */
16449 }
16450
16451 css_cnt_l -= css_cnt_r;
16452
16453 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16454
16455 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16456 {
16457 hc_device_param_t *device_param = &data.devices_param[device_id];
16458
16459 if (device_param->skipped) continue;
16460
16461 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16462 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16463 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16464
16465 device_param->kernel_params_mp_l_buf64[3] = 0;
16466 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16467 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16468 device_param->kernel_params_mp_l_buf32[6] = 0;
16469 device_param->kernel_params_mp_l_buf32[7] = 0;
16470 device_param->kernel_params_mp_l_buf32[8] = 0;
16471
16472 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16473 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16474 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16475 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16476
16477 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16478 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16479 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16480
16481 device_param->kernel_params_mp_r_buf64[3] = 0;
16482 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16483 device_param->kernel_params_mp_r_buf32[5] = 0;
16484 device_param->kernel_params_mp_r_buf32[6] = 0;
16485 device_param->kernel_params_mp_r_buf32[7] = 0;
16486
16487 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]);
16488 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]);
16489 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]);
16490
16491 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]);
16492 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]);
16493 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]);
16494
16495 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);
16496 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);
16497 }
16498 }
16499
16500 u64 words_base = data.words_cnt;
16501
16502 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16503 {
16504 if (data.kernel_rules_cnt)
16505 {
16506 words_base /= data.kernel_rules_cnt;
16507 }
16508 }
16509 else if (data.attack_kern == ATTACK_KERN_COMBI)
16510 {
16511 if (data.combs_cnt)
16512 {
16513 words_base /= data.combs_cnt;
16514 }
16515 }
16516 else if (data.attack_kern == ATTACK_KERN_BF)
16517 {
16518 if (data.bfs_cnt)
16519 {
16520 words_base /= data.bfs_cnt;
16521 }
16522 }
16523
16524 data.words_base = words_base;
16525
16526 if (keyspace == 1)
16527 {
16528 log_info ("%llu", (unsigned long long int) words_base);
16529
16530 return (0);
16531 }
16532
16533 if (data.words_cur > data.words_base)
16534 {
16535 log_error ("ERROR: restore value greater keyspace");
16536
16537 return (-1);
16538 }
16539
16540 if (data.words_cur)
16541 {
16542 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16543 {
16544 for (uint i = 0; i < data.salts_cnt; i++)
16545 {
16546 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16547 }
16548 }
16549 else if (data.attack_kern == ATTACK_KERN_COMBI)
16550 {
16551 for (uint i = 0; i < data.salts_cnt; i++)
16552 {
16553 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16554 }
16555 }
16556 else if (data.attack_kern == ATTACK_KERN_BF)
16557 {
16558 for (uint i = 0; i < data.salts_cnt; i++)
16559 {
16560 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16561 }
16562 }
16563 }
16564
16565 /*
16566 * Inform user about possible slow speeds
16567 */
16568
16569 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16570 {
16571 if (data.words_base < kernel_power_all)
16572 {
16573 if (quiet == 0)
16574 {
16575 log_info ("");
16576 log_info ("ATTENTION!");
16577 log_info (" The wordlist or mask you are using is too small.");
16578 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
16579 log_info (" The cracking speed will drop.");
16580 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16581 log_info ("");
16582 }
16583 }
16584 }
16585
16586 /*
16587 * Update loopback file
16588 */
16589
16590 if (loopback == 1)
16591 {
16592 time_t now;
16593
16594 time (&now);
16595
16596 uint random_num = get_random_num (0, 9999);
16597
16598 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16599
16600 data.loopback_file = loopback_file;
16601 }
16602
16603 /*
16604 * Update dictionary statistic
16605 */
16606
16607 if (keyspace == 0)
16608 {
16609 dictstat_fp = fopen (dictstat, "wb");
16610
16611 if (dictstat_fp)
16612 {
16613 lock_file (dictstat_fp);
16614
16615 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16616
16617 fclose (dictstat_fp);
16618 }
16619 }
16620
16621 data.devices_status = STATUS_RUNNING;
16622
16623 if (initial_restore_done == 0)
16624 {
16625 if (data.restore_disable == 0) cycle_restore ();
16626
16627 initial_restore_done = 1;
16628 }
16629
16630 hc_timer_set (&data.timer_running);
16631
16632 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16633 {
16634 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16635 {
16636 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16637 if (quiet == 0) fflush (stdout);
16638 }
16639 }
16640 else if (wordlist_mode == WL_MODE_STDIN)
16641 {
16642 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16643 if (data.quiet == 0) log_info ("");
16644 }
16645
16646 time_t runtime_start;
16647
16648 time (&runtime_start);
16649
16650 data.runtime_start = runtime_start;
16651
16652 /**
16653 * create cracker threads
16654 */
16655
16656 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16657
16658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16659 {
16660 hc_device_param_t *device_param = &devices_param[device_id];
16661
16662 if (wordlist_mode == WL_MODE_STDIN)
16663 {
16664 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16665 }
16666 else
16667 {
16668 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16669 }
16670 }
16671
16672 // wait for crack threads to exit
16673
16674 hc_thread_wait (data.devices_cnt, c_threads);
16675
16676 local_free (c_threads);
16677
16678 data.restore = 0;
16679
16680 // finalize task
16681
16682 logfile_sub_var_uint ("status-after-work", data.devices_status);
16683
16684 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16685
16686 if (data.devices_status == STATUS_CRACKED) break;
16687 if (data.devices_status == STATUS_ABORTED) break;
16688
16689 if (data.devices_status == STATUS_BYPASS)
16690 {
16691 data.devices_status = STATUS_RUNNING;
16692 }
16693
16694 if (induction_dictionaries_cnt)
16695 {
16696 unlink (induction_dictionaries[0]);
16697 }
16698
16699 free (induction_dictionaries);
16700
16701 if (attack_mode != ATTACK_MODE_BF)
16702 {
16703 induction_dictionaries = scan_directory (induction_directory);
16704
16705 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16706 }
16707
16708 if (benchmark == 0)
16709 {
16710 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16711 {
16712 if (quiet == 0) clear_prompt ();
16713
16714 if (quiet == 0) log_info ("");
16715
16716 if (status == 1)
16717 {
16718 status_display ();
16719 }
16720 else
16721 {
16722 if (quiet == 0) status_display ();
16723 }
16724
16725 if (quiet == 0) log_info ("");
16726 }
16727 }
16728
16729 if (attack_mode == ATTACK_MODE_BF)
16730 {
16731 dictpos++;
16732
16733 rd->dictpos = dictpos;
16734 }
16735 else
16736 {
16737 if (induction_dictionaries_cnt)
16738 {
16739 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16740 }
16741 else
16742 {
16743 dictpos++;
16744
16745 rd->dictpos = dictpos;
16746 }
16747 }
16748
16749 time_t runtime_stop;
16750
16751 time (&runtime_stop);
16752
16753 data.runtime_stop = runtime_stop;
16754
16755 logfile_sub_uint (runtime_start);
16756 logfile_sub_uint (runtime_stop);
16757
16758 logfile_sub_msg ("STOP");
16759
16760 global_free (subid);
16761 }
16762
16763 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16764
16765 if (data.devices_status == STATUS_CRACKED) break;
16766 if (data.devices_status == STATUS_ABORTED) break;
16767 if (data.devices_status == STATUS_QUIT) break;
16768
16769 if (data.devices_status == STATUS_BYPASS)
16770 {
16771 data.devices_status = STATUS_RUNNING;
16772 }
16773 }
16774
16775 // 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
16776
16777 if (attack_mode == ATTACK_MODE_STRAIGHT)
16778 {
16779 if (data.wordlist_mode == WL_MODE_FILE)
16780 {
16781 if (data.dictfile == NULL)
16782 {
16783 if (dictfiles != NULL)
16784 {
16785 data.dictfile = dictfiles[0];
16786
16787 hc_timer_set (&data.timer_running);
16788 }
16789 }
16790 }
16791 }
16792 // NOTE: combi is okay because it is already set beforehand
16793 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16794 {
16795 if (data.dictfile == NULL)
16796 {
16797 if (dictfiles != NULL)
16798 {
16799 hc_timer_set (&data.timer_running);
16800
16801 data.dictfile = dictfiles[0];
16802 }
16803 }
16804 }
16805 else if (attack_mode == ATTACK_MODE_BF)
16806 {
16807 if (data.mask == NULL)
16808 {
16809 hc_timer_set (&data.timer_running);
16810
16811 data.mask = masks[0];
16812 }
16813 }
16814
16815 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16816 {
16817 data.devices_status = STATUS_EXHAUSTED;
16818 }
16819
16820 // if cracked / aborted remove last induction dictionary
16821
16822 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16823 {
16824 struct stat induct_stat;
16825
16826 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16827 {
16828 unlink (induction_dictionaries[file_pos]);
16829 }
16830 }
16831
16832 // wait for non-interactive threads
16833
16834 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16835 {
16836 hc_thread_wait (1, &ni_threads[thread_idx]);
16837 }
16838
16839 local_free (ni_threads);
16840
16841 // wait for interactive threads
16842
16843 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16844 {
16845 hc_thread_wait (1, &i_thread);
16846 }
16847
16848 // we dont need restore file anymore
16849 if (data.restore_disable == 0)
16850 {
16851 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16852 {
16853 unlink (eff_restore_file);
16854 unlink (new_restore_file);
16855 }
16856 else
16857 {
16858 cycle_restore ();
16859 }
16860 }
16861
16862 // finally save left hashes
16863
16864 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16865 {
16866 save_hash ();
16867 }
16868
16869 /**
16870 * Clean up
16871 */
16872
16873 if (benchmark == 1)
16874 {
16875 status_benchmark ();
16876
16877 log_info ("");
16878 }
16879 else
16880 {
16881 if (quiet == 0) clear_prompt ();
16882
16883 if (quiet == 0) log_info ("");
16884
16885 if (status == 1)
16886 {
16887 status_display ();
16888 }
16889 else
16890 {
16891 if (quiet == 0) status_display ();
16892 }
16893
16894 if (quiet == 0) log_info ("");
16895 }
16896
16897 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16898 {
16899 hc_device_param_t *device_param = &data.devices_param[device_id];
16900
16901 if (device_param->skipped) continue;
16902
16903 local_free (device_param->result);
16904
16905 local_free (device_param->combs_buf);
16906
16907 local_free (device_param->hooks_buf);
16908
16909 local_free (device_param->device_name);
16910
16911 local_free (device_param->device_name_chksum);
16912
16913 local_free (device_param->device_version);
16914
16915 local_free (device_param->driver_version);
16916
16917 if (device_param->pws_buf) myfree (device_param->pws_buf);
16918 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16919 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16920 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16921 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16922 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16923 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16924 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16925 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16926 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16927 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16928 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16929 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16930 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16931 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16932 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16933 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16934 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16935 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16936 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16937 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16938 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16939 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16940 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16941 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16942 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16943 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16944 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16945 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16946
16947 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16948 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16949 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16950 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16951 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16952 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16953 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16954 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16955 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16956 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16957
16958 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16959 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16960 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16961
16962 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16963 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16964 }
16965
16966 // reset default fan speed
16967
16968 #ifdef HAVE_HWMON
16969 if (gpu_temp_disable == 0)
16970 {
16971 #ifdef HAVE_ADL
16972 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16973 {
16974 hc_thread_mutex_lock (mux_adl);
16975
16976 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16977 {
16978 hc_device_param_t *device_param = &data.devices_param[device_id];
16979
16980 if (device_param->skipped) continue;
16981
16982 if (data.hm_device[device_id].fan_supported == 1)
16983 {
16984 int fanspeed = temp_retain_fanspeed_value[device_id];
16985
16986 if (fanspeed == -1) continue;
16987
16988 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16989
16990 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16991 }
16992 }
16993
16994 hc_thread_mutex_unlock (mux_adl);
16995 }
16996 #endif // HAVE_ADL
16997 }
16998
16999 #ifdef HAVE_ADL
17000 // reset power tuning
17001
17002 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17003 {
17004 hc_thread_mutex_lock (mux_adl);
17005
17006 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17007 {
17008 hc_device_param_t *device_param = &data.devices_param[device_id];
17009
17010 if (device_param->skipped) continue;
17011
17012 if (data.hm_device[device_id].od_version == 6)
17013 {
17014 // check powertune capabilities first, if not available then skip device
17015
17016 int powertune_supported = 0;
17017
17018 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17019 {
17020 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17021
17022 return (-1);
17023 }
17024
17025 if (powertune_supported != 0)
17026 {
17027 // powercontrol settings
17028
17029 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)
17030 {
17031 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17032
17033 return (-1);
17034 }
17035
17036 // clocks
17037
17038 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17039
17040 performance_state->iNumberOfPerformanceLevels = 2;
17041
17042 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17043 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17044 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17045 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17046
17047 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)
17048 {
17049 log_info ("ERROR: Failed to restore ADL performance state");
17050
17051 return (-1);
17052 }
17053
17054 local_free (performance_state);
17055 }
17056 }
17057 }
17058
17059 hc_thread_mutex_unlock (mux_adl);
17060 }
17061 #endif // HAVE_ADL
17062
17063 if (gpu_temp_disable == 0)
17064 {
17065 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17066 if (data.hm_nv)
17067 {
17068 #if defined(LINUX) && defined(HAVE_NVML)
17069
17070 hm_NVML_nvmlShutdown (data.hm_nv);
17071
17072 nvml_close (data.hm_nv);
17073
17074 #elif defined(WIN) && (HAVE_NVAPI)
17075
17076 hm_NvAPI_Unload (data.hm_nv);
17077
17078 nvapi_close (data.hm_nv);
17079
17080 #endif
17081
17082 data.hm_nv = NULL;
17083 }
17084 #endif
17085
17086 #ifdef HAVE_ADL
17087 if (data.hm_amd)
17088 {
17089 hm_ADL_Main_Control_Destroy (data.hm_amd);
17090
17091 adl_close (data.hm_amd);
17092 data.hm_amd = NULL;
17093 }
17094 #endif
17095 }
17096 #endif // HAVE_HWMON
17097
17098 // free memory
17099
17100 local_free (masks);
17101
17102 local_free (dictstat_base);
17103
17104 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17105 {
17106 pot_t *pot_ptr = &pot[pot_pos];
17107
17108 hash_t *hash = &pot_ptr->hash;
17109
17110 local_free (hash->digest);
17111
17112 if (isSalted)
17113 {
17114 local_free (hash->salt);
17115 }
17116 }
17117
17118 local_free (pot);
17119
17120 local_free (all_kernel_rules_cnt);
17121 local_free (all_kernel_rules_buf);
17122
17123 local_free (wl_data->buf);
17124 local_free (wl_data);
17125
17126 local_free (bitmap_s1_a);
17127 local_free (bitmap_s1_b);
17128 local_free (bitmap_s1_c);
17129 local_free (bitmap_s1_d);
17130 local_free (bitmap_s2_a);
17131 local_free (bitmap_s2_b);
17132 local_free (bitmap_s2_c);
17133 local_free (bitmap_s2_d);
17134
17135 #ifdef HAVE_HWMON
17136 local_free (temp_retain_fanspeed_value);
17137 #ifdef HAVE_ADL
17138 local_free (od_clock_mem_status);
17139 local_free (od_power_control_status);
17140 #endif // ADL
17141 #endif
17142
17143 global_free (devices_param);
17144
17145 global_free (kernel_rules_buf);
17146
17147 global_free (root_css_buf);
17148 global_free (markov_css_buf);
17149
17150 global_free (digests_buf);
17151 global_free (digests_shown);
17152 global_free (digests_shown_tmp);
17153
17154 global_free (salts_buf);
17155 global_free (salts_shown);
17156
17157 global_free (esalts_buf);
17158
17159 global_free (words_progress_done);
17160 global_free (words_progress_rejected);
17161 global_free (words_progress_restored);
17162
17163 if (pot_fp) fclose (pot_fp);
17164
17165 if (data.devices_status == STATUS_QUIT) break;
17166 }
17167
17168 // destroy others mutex
17169
17170 hc_thread_mutex_delete (mux_dispatcher);
17171 hc_thread_mutex_delete (mux_counter);
17172 hc_thread_mutex_delete (mux_display);
17173 hc_thread_mutex_delete (mux_adl);
17174
17175 // free memory
17176
17177 local_free (eff_restore_file);
17178 local_free (new_restore_file);
17179
17180 local_free (rd);
17181
17182 // tuning db
17183
17184 tuning_db_destroy (tuning_db);
17185
17186 // loopback
17187
17188 local_free (loopback_file);
17189
17190 if (loopback == 1) unlink (loopback_file);
17191
17192 // induction directory
17193
17194 if (induction_dir == NULL)
17195 {
17196 if (attack_mode != ATTACK_MODE_BF)
17197 {
17198 if (rmdir (induction_directory) == -1)
17199 {
17200 if (errno == ENOENT)
17201 {
17202 // good, we can ignore
17203 }
17204 else if (errno == ENOTEMPTY)
17205 {
17206 // good, we can ignore
17207 }
17208 else
17209 {
17210 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17211
17212 return (-1);
17213 }
17214 }
17215
17216 local_free (induction_directory);
17217 }
17218 }
17219
17220 // outfile-check directory
17221
17222 if (outfile_check_dir == NULL)
17223 {
17224 if (rmdir (outfile_check_directory) == -1)
17225 {
17226 if (errno == ENOENT)
17227 {
17228 // good, we can ignore
17229 }
17230 else if (errno == ENOTEMPTY)
17231 {
17232 // good, we can ignore
17233 }
17234 else
17235 {
17236 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17237
17238 return (-1);
17239 }
17240 }
17241
17242 local_free (outfile_check_directory);
17243 }
17244
17245 time_t proc_stop;
17246
17247 time (&proc_stop);
17248
17249 logfile_top_uint (proc_start);
17250 logfile_top_uint (proc_stop);
17251
17252 logfile_top_msg ("STOP");
17253
17254 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17255 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17256
17257 if (data.ocl) ocl_close (data.ocl);
17258
17259 if (data.devices_status == STATUS_ABORTED) return 2;
17260 if (data.devices_status == STATUS_QUIT) return 2;
17261 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17262 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17263 if (data.devices_status == STATUS_CRACKED) return 0;
17264
17265 return -1;
17266 }
Hashcat additions to support pwdhash