projects / hashcat.git / blob
? search:


e8f10f068ad7cde48963bad86aa5380f265d42f6
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 100
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define POWERTUNE_ENABLE 0
88 #define LOGFILE_DISABLE 0
89 #define SCRYPT_TMTO 0
90 #define OPENCL_VECTOR_WIDTH 0
91
92 #define WL_MODE_STDIN 1
93 #define WL_MODE_FILE 2
94 #define WL_MODE_MASK 3
95
96 #define HL_MODE_FILE 4
97 #define HL_MODE_ARG 5
98
99 #define HLFMTS_CNT 11
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110
111 #define HLFMT_TEXT_HASHCAT "native hashcat"
112 #define HLFMT_TEXT_PWDUMP "pwdump"
113 #define HLFMT_TEXT_PASSWD "passwd"
114 #define HLFMT_TEXT_SHADOW "shadow"
115 #define HLFMT_TEXT_DCC "DCC"
116 #define HLFMT_TEXT_DCC2 "DCC 2"
117 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
118 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
119 #define HLFMT_TEXT_NSLDAP "nsldap"
120 #define HLFMT_TEXT_NSLDAPS "nsldaps"
121
122 #define ATTACK_MODE_STRAIGHT 0
123 #define ATTACK_MODE_COMBI 1
124 #define ATTACK_MODE_TOGGLE 2
125 #define ATTACK_MODE_BF 3
126 #define ATTACK_MODE_PERM 4
127 #define ATTACK_MODE_TABLE 5
128 #define ATTACK_MODE_HYBRID1 6
129 #define ATTACK_MODE_HYBRID2 7
130 #define ATTACK_MODE_NONE 100
131
132 #define ATTACK_KERN_STRAIGHT 0
133 #define ATTACK_KERN_COMBI 1
134 #define ATTACK_KERN_BF 3
135 #define ATTACK_KERN_NONE 100
136
137 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
138 #define ATTACK_EXEC_INSIDE_KERNEL 11
139
140 #define COMBINATOR_MODE_BASE_LEFT 10001
141 #define COMBINATOR_MODE_BASE_RIGHT 10002
142
143 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
144 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
145
146 #define MAX_CUT_TRIES 4
147
148 #define MAX_DICTSTAT 10000
149
150 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
151
152 #define global_free(attr) \
153 { \
154 myfree ((void *) data.attr); \
155 \
156 data.attr = NULL; \
157 }
158
159 #define local_free(attr) \
160 { \
161 myfree ((void *) attr); \
162 \
163 attr = NULL; \
164 }
165
166 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
167 {
168 900,
169 0,
170 5100,
171 100,
172 1400,
173 10800,
174 1700,
175 5000,
176 10100,
177 6000,
178 6100,
179 6900,
180 11700,
181 11800,
182 400,
183 8900,
184 11900,
185 12000,
186 10900,
187 12100,
188 23,
189 2500,
190 5300,
191 5400,
192 5500,
193 5600,
194 7300,
195 7500,
196 13100,
197 8300,
198 11100,
199 11200,
200 11400,
201 121,
202 2611,
203 2711,
204 2811,
205 8400,
206 11,
207 2612,
208 7900,
209 21,
210 11000,
211 124,
212 10000,
213 3711,
214 7600,
215 12,
216 131,
217 132,
218 1731,
219 200,
220 300,
221 3100,
222 112,
223 12300,
224 8000,
225 141,
226 1441,
227 1600,
228 12600,
229 1421,
230 101,
231 111,
232 1711,
233 3000,
234 1000,
235 1100,
236 2100,
237 12800,
238 1500,
239 12400,
240 500,
241 3200,
242 7400,
243 1800,
244 122,
245 1722,
246 7100,
247 6300,
248 6700,
249 6400,
250 6500,
251 2400,
252 2410,
253 5700,
254 9200,
255 9300,
256 22,
257 501,
258 5800,
259 8100,
260 8500,
261 7200,
262 9900,
263 7700,
264 7800,
265 10300,
266 8600,
267 8700,
268 9100,
269 133,
270 13500,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400,
303 125
304 };
305
306 /**
307 * types
308 */
309
310 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
311
312 /**
313 * globals
314 */
315
316 static unsigned int full01 = 0x01010101;
317 static unsigned int full80 = 0x80808080;
318
319 int SUPPRESS_OUTPUT = 0;
320
321 hc_thread_mutex_t mux_adl;
322 hc_thread_mutex_t mux_counter;
323 hc_thread_mutex_t mux_dispatcher;
324 hc_thread_mutex_t mux_display;
325
326 hc_global_data_t data;
327
328 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
329
330 const char *USAGE_MINI[] =
331 {
332 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
333 "",
334 "Try --help for more help.",
335 NULL
336 };
337
338 const char *USAGE_BIG[] =
339 {
340 "%s, advanced password recovery",
341 "",
342 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
343 "",
344 "=======",
345 "Options",
346 "=======",
347 "",
348 "* General:",
349 "",
350 " -m, --hash-type=NUM Hash-type, see references below",
351 " -a, --attack-mode=NUM Attack-mode, see references below",
352 " -V, --version Print version",
353 " -h, --help Print help",
354 " --quiet Suppress output",
355 "",
356 "* Misc:",
357 "",
358 " --hex-charset Assume charset is given in hex",
359 " --hex-salt Assume salt is given in hex",
360 " --hex-wordlist Assume words in wordlist is given in hex",
361 " --force Ignore warnings",
362 " --status Enable automatic update of the status-screen",
363 " --status-timer=NUM Seconds between status-screen update",
364 " --status-automat Display the status view in a machine readable format",
365 " --loopback Add new plains to induct directory",
366 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
367 "",
368 "* Markov:",
369 "",
370 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
371 " --markov-disable Disables markov-chains, emulates classic brute-force",
372 " --markov-classic Enables classic markov-chains, no per-position enhancement",
373 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
374 "",
375 "* Session:",
376 "",
377 " --runtime=NUM Abort session after NUM seconds of runtime",
378 " --session=STR Define specific session name",
379 " --restore Restore session from --session",
380 " --restore-disable Do not write restore file",
381 "",
382 "* Files:",
383 "",
384 " -o, --outfile=FILE Define outfile for recovered hash",
385 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
386 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
387 " --outfile-check-timer=NUM Seconds between outfile checks",
388 " -p, --separator=CHAR Separator char for hashlists and outfile",
389 " --show Show cracked passwords only",
390 " --left Show un-cracked passwords only",
391 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
392 " --remove Enable remove of hash once it is cracked",
393 " --remove-timer=NUM Update input hash file each NUM seconds",
394 " --potfile-disable Do not write potfile",
395 " --potfile-path Specific path to potfile",
396 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
397 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
398 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
399 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
400 " --logfile-disable Disable the logfile",
401 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
402 "",
403 "* Resources:",
404 "",
405 " -b, --benchmark Run benchmark",
406 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
407 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
408 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
409 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
410 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
411 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
412 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
413 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
414 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
415 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
416 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
417 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
418 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
421 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
422 #ifdef HAVE_ADL
423 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
424 #endif
425 #endif
426 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
427 "",
428 "* Distributed:",
429 "",
430 " -s, --skip=NUM Skip number of words",
431 " -l, --limit=NUM Limit number of words",
432 " --keyspace Show keyspace base:mod values and quit",
433 "",
434 "* Rules:",
435 "",
436 " -j, --rule-left=RULE Single rule applied to each word from left dict",
437 " -k, --rule-right=RULE Single rule applied to each word from right dict",
438 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
439 " -g, --generate-rules=NUM Generate NUM random rules",
440 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
441 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
442 " --generate-rules-seed=NUM Force RNG seed to NUM",
443 "",
444 "* Custom charsets:",
445 "",
446 " -1, --custom-charset1=CS User-defined charsets",
447 " -2, --custom-charset2=CS Example:",
448 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
449 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
450 "",
451 "* Increment:",
452 "",
453 " -i, --increment Enable increment mode",
454 " --increment-min=NUM Start incrementing at NUM",
455 " --increment-max=NUM Stop incrementing at NUM",
456 "",
457 "==========",
458 "References",
459 "==========",
460 "",
461 "* Workload Profile:",
462 "",
463 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
464 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
465 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
466 "",
467 "* OpenCL device-types:",
468 "",
469 " 1 = CPU devices",
470 " 2 = GPU devices",
471 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
472 "",
473 "* Outfile Formats:",
474 "",
475 " 1 = hash[:salt]",
476 " 2 = plain",
477 " 3 = hash[:salt]:plain",
478 " 4 = hex_plain",
479 " 5 = hash[:salt]:hex_plain",
480 " 6 = plain:hex_plain",
481 " 7 = hash[:salt]:plain:hex_plain",
482 " 8 = crackpos",
483 " 9 = hash[:salt]:crackpos",
484 " 10 = plain:crackpos",
485 " 11 = hash[:salt]:plain:crackpos",
486 " 12 = hex_plain:crackpos",
487 " 13 = hash[:salt]:hex_plain:crackpos",
488 " 14 = plain:hex_plain:crackpos",
489 " 15 = hash[:salt]:plain:hex_plain:crackpos",
490 "",
491 "* Debug mode output formats (for hybrid mode only, by using rules):",
492 "",
493 " 1 = save finding rule",
494 " 2 = save original word",
495 " 3 = save original word and finding rule",
496 " 4 = save original word, finding rule and modified plain",
497 "",
498 "* Built-in charsets:",
499 "",
500 " ?l = abcdefghijklmnopqrstuvwxyz",
501 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
502 " ?d = 0123456789",
503 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
504 " ?a = ?l?u?d?s",
505 " ?b = 0x00 - 0xff",
506 "",
507 "* Attack modes:",
508 "",
509 " 0 = Straight",
510 " 1 = Combination",
511 " 3 = Brute-force",
512 " 6 = Hybrid dict + mask",
513 " 7 = Hybrid mask + dict",
514 "",
515 "* Hash types:",
516 "",
517 "[[ Roll-your-own: Raw Hashes ]]",
518 "",
519 " 900 = MD4",
520 " 0 = MD5",
521 " 5100 = Half MD5",
522 " 100 = SHA1",
523 " 10800 = SHA-384",
524 " 1400 = SHA-256",
525 " 1700 = SHA-512",
526 " 5000 = SHA-3(Keccak)",
527 " 10100 = SipHash",
528 " 6000 = RipeMD160",
529 " 6100 = Whirlpool",
530 " 6900 = GOST R 34.11-94",
531 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
532 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
533 "",
534 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
535 "",
536 " 10 = md5($pass.$salt)",
537 " 20 = md5($salt.$pass)",
538 " 30 = md5(unicode($pass).$salt)",
539 " 40 = md5($salt.unicode($pass))",
540 " 3800 = md5($salt.$pass.$salt)",
541 " 3710 = md5($salt.md5($pass))",
542 " 2600 = md5(md5($pass)",
543 " 4300 = md5(strtoupper(md5($pass)))",
544 " 4400 = md5(sha1($pass))",
545 " 110 = sha1($pass.$salt)",
546 " 120 = sha1($salt.$pass)",
547 " 130 = sha1(unicode($pass).$salt)",
548 " 140 = sha1($salt.unicode($pass))",
549 " 4500 = sha1(sha1($pass)",
550 " 4700 = sha1(md5($pass))",
551 " 4900 = sha1($salt.$pass.$salt)",
552 " 1410 = sha256($pass.$salt)",
553 " 1420 = sha256($salt.$pass)",
554 " 1430 = sha256(unicode($pass).$salt)",
555 " 1440 = sha256($salt.unicode($pass))",
556 " 1710 = sha512($pass.$salt)",
557 " 1720 = sha512($salt.$pass)",
558 " 1730 = sha512(unicode($pass).$salt)",
559 " 1740 = sha512($salt.unicode($pass))",
560 "",
561 "[[ Roll-your-own: Authenticated Hashes ]]",
562 "",
563 " 50 = HMAC-MD5 (key = $pass)",
564 " 60 = HMAC-MD5 (key = $salt)",
565 " 150 = HMAC-SHA1 (key = $pass)",
566 " 160 = HMAC-SHA1 (key = $salt)",
567 " 1450 = HMAC-SHA256 (key = $pass)",
568 " 1460 = HMAC-SHA256 (key = $salt)",
569 " 1750 = HMAC-SHA512 (key = $pass)",
570 " 1760 = HMAC-SHA512 (key = $salt)",
571 "",
572 "[[ Generic KDF ]]",
573 "",
574 " 400 = phpass",
575 " 8900 = scrypt",
576 " 11900 = PBKDF2-HMAC-MD5",
577 " 12000 = PBKDF2-HMAC-SHA1",
578 " 10900 = PBKDF2-HMAC-SHA256",
579 " 12100 = PBKDF2-HMAC-SHA512",
580 "",
581 "[[ Network protocols, Challenge-Response ]]",
582 "",
583 " 23 = Skype",
584 " 2500 = WPA/WPA2",
585 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
586 " 5300 = IKE-PSK MD5",
587 " 5400 = IKE-PSK SHA1",
588 " 5500 = NetNTLMv1",
589 " 5500 = NetNTLMv1 + ESS",
590 " 5600 = NetNTLMv2",
591 " 7300 = IPMI2 RAKP HMAC-SHA1",
592 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
593 " 8300 = DNSSEC (NSEC3)",
594 " 10200 = Cram MD5",
595 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
596 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
597 " 11400 = SIP digest authentication (MD5)",
598 " 13100 = Kerberos 5 TGS-REP etype 23",
599 "",
600 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
601 "",
602 " 121 = SMF (Simple Machines Forum)",
603 " 400 = phpBB3",
604 " 2611 = vBulletin < v3.8.5",
605 " 2711 = vBulletin > v3.8.5",
606 " 2811 = MyBB",
607 " 2811 = IPB (Invison Power Board)",
608 " 8400 = WBB3 (Woltlab Burning Board)",
609 " 11 = Joomla < 2.5.18",
610 " 400 = Joomla > 2.5.18",
611 " 400 = Wordpress",
612 " 2612 = PHPS",
613 " 7900 = Drupal7",
614 " 21 = osCommerce",
615 " 21 = xt:Commerce",
616 " 11000 = PrestaShop",
617 " 124 = Django (SHA-1)",
618 " 10000 = Django (PBKDF2-SHA256)",
619 " 3711 = Mediawiki B type",
620 " 7600 = Redmine",
621 "",
622 "[[ Database Server ]]",
623 "",
624 " 12 = PostgreSQL",
625 " 131 = MSSQL(2000)",
626 " 132 = MSSQL(2005)",
627 " 1731 = MSSQL(2012)",
628 " 1731 = MSSQL(2014)",
629 " 200 = MySQL323",
630 " 300 = MySQL4.1/MySQL5",
631 " 3100 = Oracle H: Type (Oracle 7+)",
632 " 112 = Oracle S: Type (Oracle 11+)",
633 " 12300 = Oracle T: Type (Oracle 12+)",
634 " 8000 = Sybase ASE",
635 "",
636 "[[ HTTP, SMTP, LDAP Server ]]",
637 "",
638 " 141 = EPiServer 6.x < v4",
639 " 1441 = EPiServer 6.x > v4",
640 " 1600 = Apache $apr1$",
641 " 12600 = ColdFusion 10+",
642 " 1421 = hMailServer",
643 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
644 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
645 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
646 "",
647 "[[ Checksums ]]",
648 "",
649 " 11500 = CRC32",
650 "",
651 "[[ Operating-Systems ]]",
652 "",
653 " 3000 = LM",
654 " 1000 = NTLM",
655 " 1100 = Domain Cached Credentials (DCC), MS Cache",
656 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
657 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
658 " 1500 = descrypt, DES(Unix), Traditional DES",
659 " 12400 = BSDiCrypt, Extended DES",
660 " 500 = md5crypt $1$, MD5(Unix)",
661 " 3200 = bcrypt $2*$, Blowfish(Unix)",
662 " 7400 = sha256crypt $5$, SHA256(Unix)",
663 " 1800 = sha512crypt $6$, SHA512(Unix)",
664 " 122 = OSX v10.4",
665 " 122 = OSX v10.5",
666 " 122 = OSX v10.6",
667 " 1722 = OSX v10.7",
668 " 7100 = OSX v10.8",
669 " 7100 = OSX v10.9",
670 " 7100 = OSX v10.10",
671 " 6300 = AIX {smd5}",
672 " 6700 = AIX {ssha1}",
673 " 6400 = AIX {ssha256}",
674 " 6500 = AIX {ssha512}",
675 " 2400 = Cisco-PIX",
676 " 2410 = Cisco-ASA",
677 " 500 = Cisco-IOS $1$",
678 " 5700 = Cisco-IOS $4$",
679 " 9200 = Cisco-IOS $8$",
680 " 9300 = Cisco-IOS $9$",
681 " 22 = Juniper Netscreen/SSG (ScreenOS)",
682 " 501 = Juniper IVE",
683 " 5800 = Android PIN",
684 " 8100 = Citrix Netscaler",
685 " 8500 = RACF",
686 " 7200 = GRUB 2",
687 " 9900 = Radmin2",
688 " 125 = ArubaOS",
689 "",
690 "[[ Enterprise Application Software (EAS) ]]",
691 "",
692 " 7700 = SAP CODVN B (BCODE)",
693 " 7800 = SAP CODVN F/G (PASSCODE)",
694 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
695 " 8600 = Lotus Notes/Domino 5",
696 " 8700 = Lotus Notes/Domino 6",
697 " 9100 = Lotus Notes/Domino 8",
698 " 133 = PeopleSoft",
699 " 13500 = PeopleSoft Token",
700 "",
701 "[[ Archives ]]",
702 "",
703 " 11600 = 7-Zip",
704 " 12500 = RAR3-hp",
705 " 13000 = RAR5",
706 " 13200 = AxCrypt",
707 " 13300 = AxCrypt in memory SHA1",
708 "",
709 "[[ Full-Disk encryptions (FDE) ]]",
710 "",
711 " 62XY = TrueCrypt 5.0+",
712 " X = 1 = PBKDF2-HMAC-RipeMD160",
713 " X = 2 = PBKDF2-HMAC-SHA512",
714 " X = 3 = PBKDF2-HMAC-Whirlpool",
715 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
716 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
717 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
718 " Y = 3 = XTS 1536 bit (Ciphers: All)",
719 " 8800 = Android FDE < v4.3",
720 " 12900 = Android FDE (Samsung DEK)",
721 " 12200 = eCryptfs",
722 "",
723 "[[ Documents ]]",
724 "",
725 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
726 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
727 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
728 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
729 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
730 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
731 " 9400 = MS Office 2007",
732 " 9500 = MS Office 2010",
733 " 9600 = MS Office 2013",
734 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
735 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
736 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
737 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
738 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
739 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
740 "",
741 "[[ Password Managers ]]",
742 "",
743 " 9000 = Password Safe v2",
744 " 5200 = Password Safe v3",
745 " 6800 = Lastpass",
746 " 6600 = 1Password, agilekeychain",
747 " 8200 = 1Password, cloudkeychain",
748 " 11300 = Bitcoin/Litecoin wallet.dat",
749 " 12700 = Blockchain, My Wallet",
750 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
751 "",
752 NULL
753 };
754
755 /**
756 * oclHashcat specific functions
757 */
758
759 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
760 {
761 int exec_pos = (int) device_param->exec_pos - last_num_entries;
762
763 if (exec_pos < 0) exec_pos += EXEC_CACHE;
764
765 double exec_ms_sum = 0;
766
767 int exec_ms_cnt = 0;
768
769 for (int i = 0; i < last_num_entries; i++)
770 {
771 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
772
773 if (exec_ms)
774 {
775 exec_ms_sum += exec_ms;
776
777 exec_ms_cnt++;
778 }
779 }
780
781 if (exec_ms_cnt == 0) return 0;
782
783 return exec_ms_sum / exec_ms_cnt;
784 }
785
786 void status_display_automat ()
787 {
788 FILE *out = stdout;
789
790 fprintf (out, "STATUS\t%u\t", data.devices_status);
791
792 /**
793 * speed new
794 */
795
796 fprintf (out, "SPEED\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 u64 speed_cnt = 0;
805 double speed_ms = 0;
806
807 for (int i = 0; i < SPEED_CACHE; i++)
808 {
809 speed_cnt += device_param->speed_cnt[i];
810 speed_ms += device_param->speed_ms[i];
811 }
812
813 speed_cnt /= SPEED_CACHE;
814 speed_ms /= SPEED_CACHE;
815
816 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
817 }
818
819 /**
820 * exec time
821 */
822
823 fprintf (out, "EXEC_RUNTIME\t");
824
825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
826 {
827 hc_device_param_t *device_param = &data.devices_param[device_id];
828
829 if (device_param->skipped) continue;
830
831 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
832
833 fprintf (out, "%f\t", exec_ms_avg);
834 }
835
836 /**
837 * words_cur
838 */
839
840 u64 words_cur = get_lowest_words_done ();
841
842 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
843
844 /**
845 * counter
846 */
847
848 u64 progress_total = data.words_cnt * data.salts_cnt;
849
850 u64 all_done = 0;
851 u64 all_rejected = 0;
852 u64 all_restored = 0;
853
854 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
855 {
856 all_done += data.words_progress_done[salt_pos];
857 all_rejected += data.words_progress_rejected[salt_pos];
858 all_restored += data.words_progress_restored[salt_pos];
859 }
860
861 u64 progress_cur = all_restored + all_done + all_rejected;
862 u64 progress_end = progress_total;
863
864 u64 progress_skip = 0;
865
866 if (data.skip)
867 {
868 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
873 }
874
875 if (data.limit)
876 {
877 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
878
879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
880 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
881 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
882 }
883
884 u64 progress_cur_relative_skip = progress_cur - progress_skip;
885 u64 progress_end_relative_skip = progress_end - progress_skip;
886
887 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
888
889 /**
890 * cracks
891 */
892
893 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
894 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
895
896 /**
897 * temperature
898 */
899
900 #ifdef HAVE_HWMON
901 if (data.gpu_temp_disable == 0)
902 {
903 fprintf (out, "TEMP\t");
904
905 hc_thread_mutex_lock (mux_adl);
906
907 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
908 {
909 hc_device_param_t *device_param = &data.devices_param[device_id];
910
911 if (device_param->skipped) continue;
912
913 int temp = hm_get_temperature_with_device_id (device_id);
914
915 fprintf (out, "%d\t", temp);
916 }
917
918 hc_thread_mutex_unlock (mux_adl);
919 }
920 #endif // HAVE_HWMON
921
922 /**
923 * flush
924 */
925
926 #ifdef _WIN
927 fputc ('\r', out);
928 fputc ('\n', out);
929 #endif
930
931 #ifdef _POSIX
932 fputc ('\n', out);
933 #endif
934
935 fflush (out);
936 }
937
938 void status_display ()
939 {
940 if (data.devices_status == STATUS_INIT) return;
941 if (data.devices_status == STATUS_STARTING) return;
942 if (data.devices_status == STATUS_BYPASS) return;
943
944 if (data.status_automat == 1)
945 {
946 status_display_automat ();
947
948 return;
949 }
950
951 char tmp_buf[1000] = { 0 };
952
953 uint tmp_len = 0;
954
955 log_info ("Session.Name...: %s", data.session);
956
957 char *status_type = strstatus (data.devices_status);
958
959 uint hash_mode = data.hash_mode;
960
961 char *hash_type = strhashtype (hash_mode); // not a bug
962
963 log_info ("Status.........: %s", status_type);
964
965 /**
966 * show rules
967 */
968
969 if (data.rp_files_cnt)
970 {
971 uint i;
972
973 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
974 {
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
976 }
977
978 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
979
980 log_info ("Rules.Type.....: %s", tmp_buf);
981
982 tmp_len = 0;
983 }
984
985 if (data.rp_gen)
986 {
987 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
988
989 if (data.rp_gen_seed)
990 {
991 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
992 }
993 }
994
995 /**
996 * show input
997 */
998
999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1000 {
1001 if (data.wordlist_mode == WL_MODE_FILE)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1004 }
1005 else if (data.wordlist_mode == WL_MODE_STDIN)
1006 {
1007 log_info ("Input.Mode.....: Pipe");
1008 }
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_COMBI)
1011 {
1012 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1013 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_BF)
1016 {
1017 char *mask = data.mask;
1018
1019 if (mask != NULL)
1020 {
1021 uint mask_len = data.css_cnt;
1022
1023 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1024
1025 if (mask_len > 0)
1026 {
1027 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1028 {
1029 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1030 {
1031 mask_len -= data.salts_buf[0].salt_len;
1032 }
1033 }
1034
1035 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1038 }
1039
1040 if (data.maskcnt > 1)
1041 {
1042 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1045 }
1046
1047 log_info ("Input.Mode.....: %s", tmp_buf);
1048 }
1049
1050 tmp_len = 0;
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1053 {
1054 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1055 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1058 {
1059 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1061 }
1062
1063 if (data.digests_cnt == 1)
1064 {
1065 if (data.hash_mode == 2500)
1066 {
1067 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1068
1069 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1070 (char *) data.salts_buf[0].salt_buf,
1071 wpa->orig_mac1[0],
1072 wpa->orig_mac1[1],
1073 wpa->orig_mac1[2],
1074 wpa->orig_mac1[3],
1075 wpa->orig_mac1[4],
1076 wpa->orig_mac1[5],
1077 wpa->orig_mac2[0],
1078 wpa->orig_mac2[1],
1079 wpa->orig_mac2[2],
1080 wpa->orig_mac2[3],
1081 wpa->orig_mac2[4],
1082 wpa->orig_mac2[5]);
1083 }
1084 else if (data.hash_mode == 5200)
1085 {
1086 log_info ("Hash.Target....: File (%s)", data.hashfile);
1087 }
1088 else if (data.hash_mode == 9000)
1089 {
1090 log_info ("Hash.Target....: File (%s)", data.hashfile);
1091 }
1092 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 else
1097 {
1098 char out_buf[HCBUFSIZ] = { 0 };
1099
1100 ascii_digest (out_buf, 0, 0);
1101
1102 // limit length
1103 if (strlen (out_buf) > 40)
1104 {
1105 out_buf[41] = '.';
1106 out_buf[42] = '.';
1107 out_buf[43] = '.';
1108 out_buf[44] = 0;
1109 }
1110
1111 log_info ("Hash.Target....: %s", out_buf);
1112 }
1113 }
1114 else
1115 {
1116 if (data.hash_mode == 3000)
1117 {
1118 char out_buf1[32] = { 0 };
1119 char out_buf2[32] = { 0 };
1120
1121 ascii_digest (out_buf1, 0, 0);
1122 ascii_digest (out_buf2, 0, 1);
1123
1124 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1125 }
1126 else
1127 {
1128 log_info ("Hash.Target....: File (%s)", data.hashfile);
1129 }
1130 }
1131
1132 log_info ("Hash.Type......: %s", hash_type);
1133
1134 /**
1135 * speed new
1136 */
1137
1138 u64 speed_cnt[DEVICES_MAX] = { 0 };
1139 double speed_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 speed_cnt[device_id] = 0;
1148 speed_ms[device_id] = 0;
1149
1150 for (int i = 0; i < SPEED_CACHE; i++)
1151 {
1152 speed_cnt[device_id] += device_param->speed_cnt[i];
1153 speed_ms[device_id] += device_param->speed_ms[i];
1154 }
1155
1156 speed_cnt[device_id] /= SPEED_CACHE;
1157 speed_ms[device_id] /= SPEED_CACHE;
1158 }
1159
1160 float hashes_all_ms = 0;
1161
1162 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1163
1164 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1165 {
1166 hc_device_param_t *device_param = &data.devices_param[device_id];
1167
1168 if (device_param->skipped) continue;
1169
1170 hashes_dev_ms[device_id] = 0;
1171
1172 if (speed_ms[device_id])
1173 {
1174 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1175
1176 hashes_all_ms += hashes_dev_ms[device_id];
1177 }
1178 }
1179
1180 /**
1181 * exec time
1182 */
1183
1184 double exec_all_ms[DEVICES_MAX] = { 0 };
1185
1186 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1187 {
1188 hc_device_param_t *device_param = &data.devices_param[device_id];
1189
1190 if (device_param->skipped) continue;
1191
1192 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1193
1194 exec_all_ms[device_id] = exec_ms_avg;
1195 }
1196
1197 /**
1198 * timers
1199 */
1200
1201 double ms_running = 0;
1202
1203 hc_timer_get (data.timer_running, ms_running);
1204
1205 double ms_paused = data.ms_paused;
1206
1207 if (data.devices_status == STATUS_PAUSED)
1208 {
1209 double ms_paused_tmp = 0;
1210
1211 hc_timer_get (data.timer_paused, ms_paused_tmp);
1212
1213 ms_paused += ms_paused_tmp;
1214 }
1215
1216 #ifdef WIN
1217
1218 __time64_t sec_run = ms_running / 1000;
1219
1220 #else
1221
1222 time_t sec_run = ms_running / 1000;
1223
1224 #endif
1225
1226 if (sec_run)
1227 {
1228 char display_run[32] = { 0 };
1229
1230 struct tm tm_run;
1231
1232 struct tm *tmp = NULL;
1233
1234 #ifdef WIN
1235
1236 tmp = _gmtime64 (&sec_run);
1237
1238 #else
1239
1240 tmp = gmtime (&sec_run);
1241
1242 #endif
1243
1244 if (tmp != NULL)
1245 {
1246 memset (&tm_run, 0, sizeof (tm_run));
1247
1248 memcpy (&tm_run, tmp, sizeof (tm_run));
1249
1250 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1251
1252 char *start = ctime (&data.proc_start);
1253
1254 size_t start_len = strlen (start);
1255
1256 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1257 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1258
1259 log_info ("Time.Started...: %s (%s)", start, display_run);
1260 }
1261 }
1262 else
1263 {
1264 log_info ("Time.Started...: 0 secs");
1265 }
1266
1267 /**
1268 * counters
1269 */
1270
1271 u64 progress_total = data.words_cnt * data.salts_cnt;
1272
1273 u64 all_done = 0;
1274 u64 all_rejected = 0;
1275 u64 all_restored = 0;
1276
1277 u64 progress_noneed = 0;
1278
1279 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1280 {
1281 all_done += data.words_progress_done[salt_pos];
1282 all_rejected += data.words_progress_rejected[salt_pos];
1283 all_restored += data.words_progress_restored[salt_pos];
1284
1285 // Important for ETA only
1286
1287 if (data.salts_shown[salt_pos] == 1)
1288 {
1289 const u64 all = data.words_progress_done[salt_pos]
1290 + data.words_progress_rejected[salt_pos]
1291 + data.words_progress_restored[salt_pos];
1292
1293 const u64 left = data.words_cnt - all;
1294
1295 progress_noneed += left;
1296 }
1297 }
1298
1299 u64 progress_cur = all_restored + all_done + all_rejected;
1300 u64 progress_end = progress_total;
1301
1302 u64 progress_skip = 0;
1303
1304 if (data.skip)
1305 {
1306 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1307
1308 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1311 }
1312
1313 if (data.limit)
1314 {
1315 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1316
1317 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1318 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1320 }
1321
1322 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1323 u64 progress_end_relative_skip = progress_end - progress_skip;
1324
1325 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1326 {
1327 if (data.devices_status != STATUS_CRACKED)
1328 {
1329 #ifdef WIN
1330 __time64_t sec_etc = 0;
1331 #else
1332 time_t sec_etc = 0;
1333 #endif
1334
1335 if (hashes_all_ms)
1336 {
1337 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1338
1339 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1340
1341 sec_etc = ms_left / 1000;
1342 }
1343
1344 if (sec_etc == 0)
1345 {
1346 //log_info ("Time.Estimated.: 0 secs");
1347 }
1348 else if ((u64) sec_etc > ETC_MAX)
1349 {
1350 log_info ("Time.Estimated.: > 10 Years");
1351 }
1352 else
1353 {
1354 char display_etc[32] = { 0 };
1355
1356 struct tm tm_etc;
1357
1358 struct tm *tmp = NULL;
1359
1360 #ifdef WIN
1361
1362 tmp = _gmtime64 (&sec_etc);
1363
1364 #else
1365
1366 tmp = gmtime (&sec_etc);
1367
1368 #endif
1369
1370 if (tmp != NULL)
1371 {
1372 memset (&tm_etc, 0, sizeof (tm_etc));
1373
1374 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1375
1376 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1377
1378 time_t now;
1379
1380 time (&now);
1381
1382 now += sec_etc;
1383
1384 char *etc = ctime (&now);
1385
1386 size_t etc_len = strlen (etc);
1387
1388 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1389 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1390
1391 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1392 }
1393 }
1394 }
1395 }
1396
1397 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1398 {
1399 hc_device_param_t *device_param = &data.devices_param[device_id];
1400
1401 if (device_param->skipped) continue;
1402
1403 char display_dev_cur[16] = { 0 };
1404
1405 strncpy (display_dev_cur, "0.00", 4);
1406
1407 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1408
1409 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1410 }
1411
1412 char display_all_cur[16] = { 0 };
1413
1414 strncpy (display_all_cur, "0.00", 4);
1415
1416 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1417
1418 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1419
1420 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1421 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1422
1423 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);
1424
1425 // crack-per-time
1426
1427 if (data.digests_cnt > 100)
1428 {
1429 time_t now = time (NULL);
1430
1431 int cpt_cur_min = 0;
1432 int cpt_cur_hour = 0;
1433 int cpt_cur_day = 0;
1434
1435 for (int i = 0; i < CPT_BUF; i++)
1436 {
1437 const uint cracked = data.cpt_buf[i].cracked;
1438 const time_t timestamp = data.cpt_buf[i].timestamp;
1439
1440 if ((timestamp + 60) > now)
1441 {
1442 cpt_cur_min += cracked;
1443 }
1444
1445 if ((timestamp + 3600) > now)
1446 {
1447 cpt_cur_hour += cracked;
1448 }
1449
1450 if ((timestamp + 86400) > now)
1451 {
1452 cpt_cur_day += cracked;
1453 }
1454 }
1455
1456 double ms_real = ms_running - ms_paused;
1457
1458 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1459 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1460 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1461
1462 if ((data.cpt_start + 86400) < now)
1463 {
1464 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1465 cpt_cur_min,
1466 cpt_cur_hour,
1467 cpt_cur_day,
1468 cpt_avg_min,
1469 cpt_avg_hour,
1470 cpt_avg_day);
1471 }
1472 else if ((data.cpt_start + 3600) < now)
1473 {
1474 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1475 cpt_cur_min,
1476 cpt_cur_hour,
1477 cpt_avg_min,
1478 cpt_avg_hour,
1479 cpt_avg_day);
1480 }
1481 else if ((data.cpt_start + 60) < now)
1482 {
1483 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1484 cpt_cur_min,
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 else
1490 {
1491 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1492 cpt_avg_min,
1493 cpt_avg_hour,
1494 cpt_avg_day);
1495 }
1496 }
1497
1498 // Restore point
1499
1500 u64 restore_point = get_lowest_words_done ();
1501
1502 u64 restore_total = data.words_base;
1503
1504 float percent_restore = 0;
1505
1506 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1507
1508 if (progress_end_relative_skip)
1509 {
1510 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1511 {
1512 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1513 float percent_rejected = 0.0;
1514
1515 if (progress_cur)
1516 {
1517 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1518 }
1519
1520 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);
1521 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1522
1523 if (data.restore_disable == 0)
1524 {
1525 if (percent_finished != 1)
1526 {
1527 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1528 }
1529 }
1530 }
1531 }
1532 else
1533 {
1534 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1535 {
1536 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1537 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538
1539 if (data.restore_disable == 0)
1540 {
1541 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1542 }
1543 }
1544 else
1545 {
1546 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1547 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1548
1549 // --restore not allowed if stdin is used -- really? why?
1550
1551 //if (data.restore_disable == 0)
1552 //{
1553 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1554 //}
1555 }
1556 }
1557
1558 #ifdef HAVE_HWMON
1559 if (data.gpu_temp_disable == 0)
1560 {
1561 hc_thread_mutex_lock (mux_adl);
1562
1563 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1564 {
1565 hc_device_param_t *device_param = &data.devices_param[device_id];
1566
1567 if (device_param->skipped) continue;
1568
1569 #define HM_STR_BUF_SIZE 255
1570
1571 if (data.hm_device[device_id].fan_supported == 1)
1572 {
1573 char utilization[HM_STR_BUF_SIZE] = { 0 };
1574 char temperature[HM_STR_BUF_SIZE] = { 0 };
1575 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1576
1577 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1578 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1579
1580 if (device_param->vendor_id == VENDOR_ID_AMD)
1581 {
1582 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1583 }
1584 else if (device_param->vendor_id == VENDOR_ID_NV)
1585 {
1586 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1587 }
1588
1589 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1590 }
1591 else
1592 {
1593 char utilization[HM_STR_BUF_SIZE] = { 0 };
1594 char temperature[HM_STR_BUF_SIZE] = { 0 };
1595
1596 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1597 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1598
1599 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1600 }
1601 }
1602
1603 hc_thread_mutex_unlock (mux_adl);
1604 }
1605 #endif // HAVE_HWMON
1606 }
1607
1608 static void status_benchmark ()
1609 {
1610 if (data.devices_status == STATUS_INIT) return;
1611 if (data.devices_status == STATUS_STARTING) return;
1612
1613 if (data.words_cnt == 0) return;
1614
1615 u64 speed_cnt[DEVICES_MAX] = { 0 };
1616 double speed_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 speed_cnt[device_id] = device_param->speed_cnt[0];
1625 speed_ms[device_id] = device_param->speed_ms[0];
1626 }
1627
1628 float hashes_all_ms = 0;
1629
1630 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 hashes_dev_ms[device_id] = 0;
1639
1640 if (speed_ms[device_id])
1641 {
1642 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1643
1644 hashes_all_ms += hashes_dev_ms[device_id];
1645 }
1646 }
1647
1648 /**
1649 * exec time
1650 */
1651
1652 double exec_all_ms[DEVICES_MAX] = { 0 };
1653
1654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1655 {
1656 hc_device_param_t *device_param = &data.devices_param[device_id];
1657
1658 if (device_param->skipped) continue;
1659
1660 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1661
1662 exec_all_ms[device_id] = exec_ms_avg;
1663 }
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 char display_dev_cur[16] = { 0 };
1672
1673 strncpy (display_dev_cur, "0.00", 4);
1674
1675 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1676
1677 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1678 }
1679
1680 char display_all_cur[16] = { 0 };
1681
1682 strncpy (display_all_cur, "0.00", 4);
1683
1684 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1685
1686 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1687 }
1688
1689 /**
1690 * oclHashcat -only- functions
1691 */
1692
1693 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1694 {
1695 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1696 {
1697 if (attack_kern == ATTACK_KERN_STRAIGHT)
1698 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1699 else if (attack_kern == ATTACK_KERN_COMBI)
1700 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1701 else if (attack_kern == ATTACK_KERN_BF)
1702 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1703 }
1704 else
1705 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1706 }
1707
1708 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)
1709 {
1710 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1711 {
1712 if (attack_kern == ATTACK_KERN_STRAIGHT)
1713 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1714 else if (attack_kern == ATTACK_KERN_COMBI)
1715 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1716 else if (attack_kern == ATTACK_KERN_BF)
1717 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1718 }
1719 else
1720 {
1721 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1722 }
1723 }
1724
1725 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1726 {
1727 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1728 {
1729 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1730 }
1731 else
1732 {
1733 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1734 }
1735 }
1736
1737 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)
1738 {
1739 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1740 {
1741 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1742 }
1743 else
1744 {
1745 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1746 }
1747 }
1748
1749 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1750 {
1751 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1752 }
1753
1754 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1755 {
1756 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1757 }
1758
1759 static uint convert_from_hex (char *line_buf, const uint line_len)
1760 {
1761 if (line_len & 1) return (line_len); // not in hex
1762
1763 if (data.hex_wordlist == 1)
1764 {
1765 uint i;
1766 uint j;
1767
1768 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1769 {
1770 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1771 }
1772
1773 memset (line_buf + i, 0, line_len - i);
1774
1775 return (i);
1776 }
1777 else if (line_len >= 6) // $HEX[] = 6
1778 {
1779 if (line_buf[0] != '$') return (line_len);
1780 if (line_buf[1] != 'H') return (line_len);
1781 if (line_buf[2] != 'E') return (line_len);
1782 if (line_buf[3] != 'X') return (line_len);
1783 if (line_buf[4] != '[') return (line_len);
1784 if (line_buf[line_len - 1] != ']') return (line_len);
1785
1786 uint i;
1787 uint j;
1788
1789 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1790 {
1791 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1792 }
1793
1794 memset (line_buf + i, 0, line_len - i);
1795
1796 return (i);
1797 }
1798
1799 return (line_len);
1800 }
1801
1802 static void clear_prompt ()
1803 {
1804 fputc ('\r', stdout);
1805
1806 for (size_t i = 0; i < strlen (PROMPT); i++)
1807 {
1808 fputc (' ', stdout);
1809 }
1810
1811 fputc ('\r', stdout);
1812
1813 fflush (stdout);
1814 }
1815
1816 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1817 {
1818 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);
1819 }
1820
1821 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1822 {
1823 char *outfile = data.outfile;
1824 uint quiet = data.quiet;
1825 FILE *pot_fp = data.pot_fp;
1826 uint loopback = data.loopback;
1827 uint debug_mode = data.debug_mode;
1828 char *debug_file = data.debug_file;
1829
1830 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1831 int debug_rule_len = 0; // -1 error
1832 uint debug_plain_len = 0;
1833
1834 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1835
1836 // hash
1837
1838 char out_buf[HCBUFSIZ] = { 0 };
1839
1840 ascii_digest (out_buf, salt_pos, digest_pos);
1841
1842 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1843
1844 // plain
1845
1846 plain_t plain;
1847
1848 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);
1849
1850 uint gidvid = plain.gidvid;
1851 uint il_pos = plain.il_pos;
1852
1853 u64 crackpos = device_param->words_off;
1854
1855 uint plain_buf[16] = { 0 };
1856
1857 u8 *plain_ptr = (u8 *) plain_buf;
1858 unsigned int plain_len = 0;
1859
1860 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1861 {
1862 u64 gidd = gidvid;
1863 u64 gidm = 0;
1864
1865 pw_t pw;
1866
1867 gidd_to_pw_t (device_param, gidd, &pw);
1868
1869 for (int i = 0, j = gidm; i < 16; i++, j++)
1870 {
1871 plain_buf[i] = pw.i[j];
1872 }
1873
1874 plain_len = pw.pw_len;
1875
1876 const uint off = device_param->innerloop_pos + il_pos;
1877
1878 if (debug_mode > 0)
1879 {
1880 debug_rule_len = 0;
1881
1882 // save rule
1883 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1884 {
1885 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1886
1887 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1888 }
1889
1890 // save plain
1891 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1892 {
1893 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1894
1895 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1896
1897 debug_plain_len = plain_len;
1898 }
1899 }
1900
1901 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1902
1903 crackpos += gidvid;
1904 crackpos *= data.kernel_rules_cnt;
1905 crackpos += device_param->innerloop_pos + il_pos;
1906
1907 if (plain_len > data.pw_max) plain_len = data.pw_max;
1908 }
1909 else if (data.attack_mode == ATTACK_MODE_COMBI)
1910 {
1911 u64 gidd = gidvid;
1912 u64 gidm = 0;
1913
1914 pw_t pw;
1915
1916 gidd_to_pw_t (device_param, gidd, &pw);
1917
1918 for (int i = 0, j = gidm; i < 16; i++, j++)
1919 {
1920 plain_buf[i] = pw.i[j];
1921 }
1922
1923 plain_len = pw.pw_len;
1924
1925 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1926 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1927
1928 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1929 {
1930 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1931 }
1932 else
1933 {
1934 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1935
1936 memcpy (plain_ptr, comb_buf, comb_len);
1937 }
1938
1939 plain_len += comb_len;
1940
1941 crackpos += gidvid;
1942 crackpos *= data.combs_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (data.pw_max != PW_DICTMAX1)
1946 {
1947 if (plain_len > data.pw_max) plain_len = data.pw_max;
1948 }
1949 }
1950 else if (data.attack_mode == ATTACK_MODE_BF)
1951 {
1952 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1953 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1954
1955 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1956 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1957
1958 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1959 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1960
1961 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1962 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1963
1964 plain_len = data.css_cnt;
1965
1966 crackpos += gidvid;
1967 crackpos *= data.bfs_cnt;
1968 crackpos += device_param->innerloop_pos + il_pos;
1969 }
1970 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1971 {
1972 u64 gidd = gidvid;
1973 u64 gidm = 0;
1974
1975 pw_t pw;
1976
1977 gidd_to_pw_t (device_param, gidd, &pw);
1978
1979 for (int i = 0, j = gidm; i < 16; i++, j++)
1980 {
1981 plain_buf[i] = pw.i[j];
1982 }
1983
1984 plain_len = pw.pw_len;
1985
1986 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1987
1988 uint start = 0;
1989 uint stop = device_param->kernel_params_mp_buf32[4];
1990
1991 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1992
1993 plain_len += start + stop;
1994
1995 crackpos += gidvid;
1996 crackpos *= data.combs_cnt;
1997 crackpos += device_param->innerloop_pos + il_pos;
1998
1999 if (data.pw_max != PW_DICTMAX1)
2000 {
2001 if (plain_len > data.pw_max) plain_len = data.pw_max;
2002 }
2003 }
2004 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2005 {
2006 u64 gidd = gidvid;
2007 u64 gidm = 0;
2008
2009 pw_t pw;
2010
2011 gidd_to_pw_t (device_param, gidd, &pw);
2012
2013 for (int i = 0, j = gidm; i < 16; i++, j++)
2014 {
2015 plain_buf[i] = pw.i[j];
2016 }
2017
2018 plain_len = pw.pw_len;
2019
2020 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2021
2022 uint start = 0;
2023 uint stop = device_param->kernel_params_mp_buf32[4];
2024
2025 memmove (plain_ptr + stop, plain_ptr, plain_len);
2026
2027 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2028
2029 plain_len += start + stop;
2030
2031 crackpos += gidvid;
2032 crackpos *= data.combs_cnt;
2033 crackpos += device_param->innerloop_pos + il_pos;
2034
2035 if (data.pw_max != PW_DICTMAX1)
2036 {
2037 if (plain_len > data.pw_max) plain_len = data.pw_max;
2038 }
2039 }
2040
2041 if (data.attack_mode == ATTACK_MODE_BF)
2042 {
2043 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2044 {
2045 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2046 {
2047 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2048 {
2049 plain_len = plain_len - data.salts_buf[0].salt_len;
2050 }
2051 }
2052
2053 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2054 {
2055 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2056 {
2057 plain_ptr[j] = plain_ptr[i];
2058 }
2059
2060 plain_len = plain_len / 2;
2061 }
2062 }
2063 }
2064
2065 // if enabled, update also the potfile
2066
2067 if (pot_fp)
2068 {
2069 lock_file (pot_fp);
2070
2071 fprintf (pot_fp, "%s:", out_buf);
2072
2073 format_plain (pot_fp, plain_ptr, plain_len, 1);
2074
2075 fputc ('\n', pot_fp);
2076
2077 fflush (pot_fp);
2078
2079 unlock_file (pot_fp);
2080 }
2081
2082 // outfile
2083
2084 FILE *out_fp = NULL;
2085
2086 if (outfile != NULL)
2087 {
2088 if ((out_fp = fopen (outfile, "ab")) == NULL)
2089 {
2090 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2091
2092 out_fp = stdout;
2093 }
2094 lock_file (out_fp);
2095 }
2096 else
2097 {
2098 out_fp = stdout;
2099
2100 if (quiet == 0) clear_prompt ();
2101 }
2102
2103 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2104
2105 if (outfile != NULL)
2106 {
2107 if (out_fp != stdout)
2108 {
2109 fclose (out_fp);
2110 }
2111 }
2112 else
2113 {
2114 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2115 {
2116 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2117 {
2118 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2119 if (quiet == 0) fflush (stdout);
2120 }
2121 }
2122 }
2123
2124 // loopback
2125
2126 if (loopback)
2127 {
2128 char *loopback_file = data.loopback_file;
2129
2130 FILE *fb_fp = NULL;
2131
2132 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2133 {
2134 lock_file (fb_fp);
2135
2136 format_plain (fb_fp, plain_ptr, plain_len, 1);
2137
2138 fputc ('\n', fb_fp);
2139
2140 fclose (fb_fp);
2141 }
2142 }
2143
2144 // (rule) debug mode
2145
2146 // the next check implies that:
2147 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2148 // - debug_mode > 0
2149
2150 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2151 {
2152 if (debug_rule_len < 0) debug_rule_len = 0;
2153
2154 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2155
2156 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2157
2158 if ((quiet == 0) && (debug_file == NULL))
2159 {
2160 fprintf (stdout, "%s", PROMPT);
2161 fflush (stdout);
2162 }
2163 }
2164 }
2165
2166 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2167 {
2168 salt_t *salt_buf = &data.salts_buf[salt_pos];
2169
2170 int found = 0;
2171
2172 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);
2173
2174 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2175
2176 if (found == 1)
2177 {
2178 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2179
2180 log_info_nn ("");
2181
2182 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);
2183
2184 uint cpt_cracked = 0;
2185
2186 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2187 {
2188 uint idx = salt_buf->digests_offset + digest_pos;
2189
2190 if (data.digests_shown_tmp[idx] == 0) continue;
2191
2192 if (data.digests_shown[idx] == 1) continue;
2193
2194 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2195 {
2196 data.digests_shown[idx] = 1;
2197
2198 data.digests_done++;
2199
2200 cpt_cracked++;
2201
2202 salt_buf->digests_done++;
2203
2204 if (salt_buf->digests_done == salt_buf->digests_cnt)
2205 {
2206 data.salts_shown[salt_pos] = 1;
2207
2208 data.salts_done++;
2209 }
2210 }
2211
2212 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2213
2214 check_hash (device_param, salt_pos, digest_pos);
2215 }
2216
2217 if (cpt_cracked > 0)
2218 {
2219 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2220 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2221
2222 data.cpt_pos++;
2223
2224 data.cpt_total += cpt_cracked;
2225
2226 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2227 }
2228
2229 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2230 {
2231 // we need to reset cracked state on the device
2232 // otherwise host thinks again and again the hash was cracked
2233 // and returns invalid password each time
2234
2235 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2236
2237 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);
2238 }
2239
2240 memset (device_param->result, 0, device_param->size_results);
2241
2242 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);
2243 }
2244 }
2245
2246 static void save_hash ()
2247 {
2248 char *hashfile = data.hashfile;
2249
2250 char new_hashfile[256] = { 0 };
2251 char old_hashfile[256] = { 0 };
2252
2253 snprintf (new_hashfile, 255, "%s.new", hashfile);
2254 snprintf (old_hashfile, 255, "%s.old", hashfile);
2255
2256 unlink (new_hashfile);
2257
2258 char separator = data.separator;
2259
2260 FILE *fp = fopen (new_hashfile, "wb");
2261
2262 if (fp == NULL)
2263 {
2264 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2265
2266 exit (-1);
2267 }
2268
2269 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2270 {
2271 if (data.salts_shown[salt_pos] == 1) continue;
2272
2273 salt_t *salt_buf = &data.salts_buf[salt_pos];
2274
2275 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2276 {
2277 uint idx = salt_buf->digests_offset + digest_pos;
2278
2279 if (data.digests_shown[idx] == 1) continue;
2280
2281 if (data.hash_mode != 2500)
2282 {
2283 char out_buf[HCBUFSIZ] = { 0 };
2284
2285 if (data.username == 1)
2286 {
2287 user_t *user = data.hash_info[idx]->user;
2288
2289 uint i;
2290
2291 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2292
2293 fputc (separator, fp);
2294 }
2295
2296 ascii_digest (out_buf, salt_pos, digest_pos);
2297
2298 fputs (out_buf, fp);
2299
2300 log_out (fp, "");
2301 }
2302 else
2303 {
2304 hccap_t hccap;
2305
2306 to_hccap_t (&hccap, salt_pos, digest_pos);
2307
2308 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2309 }
2310 }
2311 }
2312
2313 fflush (fp);
2314
2315 fclose (fp);
2316
2317 unlink (old_hashfile);
2318
2319 if (rename (hashfile, old_hashfile) != 0)
2320 {
2321 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2322
2323 exit (-1);
2324 }
2325
2326 unlink (hashfile);
2327
2328 if (rename (new_hashfile, hashfile) != 0)
2329 {
2330 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2331
2332 exit (-1);
2333 }
2334
2335 unlink (old_hashfile);
2336 }
2337
2338 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2339 {
2340 // function called only in case kernel_power_all > words_left
2341
2342 float kernel_power_div = (float) (total_left) / kernel_power_all;
2343
2344 kernel_power_div += kernel_power_div / 100;
2345
2346 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2347
2348 while (kernel_power_new < total_left)
2349 {
2350 kernel_power_div += kernel_power_div / 100;
2351
2352 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2353 }
2354
2355 if (data.quiet == 0)
2356 {
2357 clear_prompt ();
2358
2359 log_info ("");
2360
2361 log_info ("INFO: approaching final keyspace, workload adjusted");
2362
2363 log_info ("");
2364
2365 fprintf (stdout, "%s", PROMPT);
2366
2367 fflush (stdout);
2368 }
2369
2370 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2371
2372 return kernel_power_div;
2373 }
2374
2375 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2376 {
2377 uint num_elements = num;
2378
2379 device_param->kernel_params_buf32[30] = data.combs_mode;
2380 device_param->kernel_params_buf32[31] = num;
2381
2382 uint kernel_threads = device_param->kernel_threads;
2383
2384 while (num_elements % kernel_threads) num_elements++;
2385
2386 cl_kernel kernel = NULL;
2387
2388 switch (kern_run)
2389 {
2390 case KERN_RUN_1: kernel = device_param->kernel1; break;
2391 case KERN_RUN_12: kernel = device_param->kernel12; break;
2392 case KERN_RUN_2: kernel = device_param->kernel2; break;
2393 case KERN_RUN_23: kernel = device_param->kernel23; break;
2394 case KERN_RUN_3: kernel = device_param->kernel3; break;
2395 }
2396
2397 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2398 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2399 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2400 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2401 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2402 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2403 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2404 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2405 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2406 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2407 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2408
2409 hc_timer_t timer;
2410
2411 hc_timer_set (&timer);
2412
2413 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2414 {
2415 const size_t global_work_size[3] = { num_elements, 32, 1 };
2416 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2417
2418 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2419 }
2420 else
2421 {
2422 size_t workgroup_size = 0;
2423
2424 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2425
2426 if (kern_run == KERN_RUN_2)
2427 {
2428 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2429 {
2430 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2431 }
2432 }
2433
2434 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2435
2436 while (num_elements % kernel_threads) num_elements++;
2437
2438 const size_t global_work_size[3] = { num_elements, 1, 1 };
2439 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2440
2441 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2442 }
2443
2444 hc_clFlush (data.ocl, device_param->command_queue);
2445
2446 hc_clFinish (data.ocl, device_param->command_queue);
2447
2448 if (event_update)
2449 {
2450 double exec_time;
2451
2452 hc_timer_get (timer, exec_time);
2453
2454 uint exec_pos = device_param->exec_pos;
2455
2456 device_param->exec_ms[exec_pos] = exec_time;
2457
2458 exec_pos++;
2459
2460 if (exec_pos == EXEC_CACHE)
2461 {
2462 exec_pos = 0;
2463 }
2464
2465 device_param->exec_pos = exec_pos;
2466 }
2467 }
2468
2469 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2470 {
2471 uint num_elements = num;
2472
2473 switch (kern_run)
2474 {
2475 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2476 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2477 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2478 }
2479
2480 // causes problems with special threads like in bcrypt
2481 // const uint kernel_threads = device_param->kernel_threads;
2482
2483 uint kernel_threads = device_param->kernel_threads;
2484
2485 while (num_elements % kernel_threads) num_elements++;
2486
2487 cl_kernel kernel = NULL;
2488
2489 switch (kern_run)
2490 {
2491 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2492 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2493 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2494 }
2495
2496 switch (kern_run)
2497 {
2498 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2499 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2500 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2501 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2502 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2503 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2504 break;
2505 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2506 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2507 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2508 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2509 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2510 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2511 break;
2512 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2513 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2514 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2515 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2516 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2517 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2518 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2519 break;
2520 }
2521
2522 size_t workgroup_size = 0;
2523
2524 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2525
2526 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2527
2528 const size_t global_work_size[3] = { num_elements, 1, 1 };
2529 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2530
2531 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2532
2533 hc_clFlush (data.ocl, device_param->command_queue);
2534
2535 hc_clFinish (data.ocl, device_param->command_queue);
2536 }
2537
2538 static void run_kernel_tm (hc_device_param_t *device_param)
2539 {
2540 const uint num_elements = 1024; // fixed
2541
2542 uint kernel_threads = 32;
2543
2544 cl_kernel kernel = device_param->kernel_tm;
2545
2546 size_t workgroup_size = 0;
2547
2548 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2549
2550 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2551
2552 const size_t global_work_size[3] = { num_elements, 1, 1 };
2553 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2554
2555 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2556
2557 hc_clFlush (data.ocl, device_param->command_queue);
2558
2559 hc_clFinish (data.ocl, device_param->command_queue);
2560 }
2561
2562 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2563 {
2564 uint num_elements = num;
2565
2566 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2567 device_param->kernel_params_amp_buf32[6] = num_elements;
2568
2569 // causes problems with special threads like in bcrypt
2570 // const uint kernel_threads = device_param->kernel_threads;
2571
2572 uint kernel_threads = device_param->kernel_threads;
2573
2574 while (num_elements % kernel_threads) num_elements++;
2575
2576 cl_kernel kernel = device_param->kernel_amp;
2577
2578 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2579 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2580
2581 size_t workgroup_size = 0;
2582
2583 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2584
2585 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2586
2587 const size_t global_work_size[3] = { num_elements, 1, 1 };
2588 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2589
2590 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2591
2592 hc_clFlush (data.ocl, device_param->command_queue);
2593
2594 hc_clFinish (data.ocl, device_param->command_queue);
2595 }
2596
2597 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2598 {
2599 int rc = -1;
2600
2601 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2602 {
2603 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2604
2605 const cl_uchar zero = 0;
2606
2607 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2608 }
2609
2610 if (rc != 0)
2611 {
2612 // NOTE: clEnqueueFillBuffer () always fails with -59
2613 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2614 // How's that possible, OpenCL 1.2 support is advertised??
2615 // We need to workaround...
2616
2617 #define FILLSZ 0x100000
2618
2619 char *tmp = (char *) mymalloc (FILLSZ);
2620
2621 for (size_t i = 0; i < size; i += FILLSZ)
2622 {
2623 const size_t left = size - i;
2624
2625 const size_t fillsz = MIN (FILLSZ, left);
2626
2627 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2628 }
2629
2630 myfree (tmp);
2631 }
2632 }
2633
2634 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)
2635 {
2636 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2637 {
2638 if (attack_mode == ATTACK_MODE_BF)
2639 {
2640 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2641 {
2642 const uint size_tm = 32 * sizeof (bs_word_t);
2643
2644 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2645
2646 run_kernel_tm (device_param);
2647
2648 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);
2649 }
2650 }
2651
2652 if (highest_pw_len < 16)
2653 {
2654 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2655 }
2656 else if (highest_pw_len < 32)
2657 {
2658 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2659 }
2660 else
2661 {
2662 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2663 }
2664 }
2665 else
2666 {
2667 run_kernel_amp (device_param, pws_cnt);
2668
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2670
2671 if (opts_type & OPTS_TYPE_HOOK12)
2672 {
2673 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2674 }
2675
2676 uint iter = salt_buf->salt_iter;
2677
2678 uint loop_step = device_param->kernel_loops;
2679
2680 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2681 {
2682 uint loop_left = iter - loop_pos;
2683
2684 loop_left = MIN (loop_left, loop_step);
2685
2686 device_param->kernel_params_buf32[25] = loop_pos;
2687 device_param->kernel_params_buf32[26] = loop_left;
2688
2689 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2690
2691 if (data.devices_status == STATUS_CRACKED) break;
2692 if (data.devices_status == STATUS_ABORTED) break;
2693 if (data.devices_status == STATUS_QUIT) break;
2694
2695 /**
2696 * speed
2697 */
2698
2699 const float iter_part = (float) (loop_pos + loop_left) / iter;
2700
2701 const u64 perf_sum_all = pws_cnt * iter_part;
2702
2703 double speed_ms;
2704
2705 hc_timer_get (device_param->timer_speed, speed_ms);
2706
2707 const u32 speed_pos = device_param->speed_pos;
2708
2709 device_param->speed_cnt[speed_pos] = perf_sum_all;
2710
2711 device_param->speed_ms[speed_pos] = speed_ms;
2712 }
2713
2714 if (opts_type & OPTS_TYPE_HOOK23)
2715 {
2716 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2717
2718 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);
2719
2720 // do something with data
2721
2722 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);
2723 }
2724
2725 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2726 }
2727 }
2728
2729 static int run_rule_engine (const int rule_len, const char *rule_buf)
2730 {
2731 if (rule_len == 0)
2732 {
2733 return 0;
2734 }
2735 else if (rule_len == 1)
2736 {
2737 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2738 }
2739
2740 return 1;
2741 }
2742
2743 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2744 {
2745 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2746 {
2747 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);
2748 }
2749 else if (data.attack_kern == ATTACK_KERN_COMBI)
2750 {
2751 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2752 {
2753 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2754 {
2755 for (u32 i = 0; i < pws_cnt; i++)
2756 {
2757 const u32 pw_len = device_param->pws_buf[i].pw_len;
2758
2759 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2760
2761 ptr[pw_len] = 0x01;
2762 }
2763 }
2764 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2765 {
2766 for (u32 i = 0; i < pws_cnt; i++)
2767 {
2768 const u32 pw_len = device_param->pws_buf[i].pw_len;
2769
2770 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2771
2772 ptr[pw_len] = 0x80;
2773 }
2774 }
2775 }
2776
2777 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);
2778 }
2779 else if (data.attack_kern == ATTACK_KERN_BF)
2780 {
2781 const u64 off = device_param->words_off;
2782
2783 device_param->kernel_params_mp_l_buf64[3] = off;
2784
2785 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2786 }
2787 }
2788
2789 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2790 {
2791 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2792
2793 device_param->kernel_params_buf32[26] = kernel_loops;
2794 device_param->kernel_params_buf32[27] = kernel_loops;
2795
2796 // init some fake words
2797
2798 for (u32 i = 0; i < kernel_power; i++)
2799 {
2800 device_param->pws_buf[i].i[0] = i;
2801 device_param->pws_buf[i].i[1] = 0x01234567;
2802 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2803 }
2804
2805 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2806
2807 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2808 {
2809 run_kernel_amp (device_param, kernel_power);
2810 }
2811
2812 // caching run
2813
2814 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2815 {
2816 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2817 }
2818 else
2819 {
2820 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2821 }
2822
2823 // now user repeats
2824
2825 for (int i = 0; i < repeat; i++)
2826 {
2827 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2828 {
2829 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2830 }
2831 else
2832 {
2833 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2834 }
2835 }
2836
2837 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2838
2839 // reset fake words
2840
2841 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2842
2843 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2844 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2845
2846 return exec_ms_prev;
2847 }
2848
2849 static void autotune (hc_device_param_t *device_param)
2850 {
2851 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2852
2853 const u32 kernel_accel_min = device_param->kernel_accel_min;
2854 const u32 kernel_accel_max = device_param->kernel_accel_max;
2855
2856 const u32 kernel_loops_min = device_param->kernel_loops_min;
2857 const u32 kernel_loops_max = device_param->kernel_loops_max;
2858
2859 u32 kernel_accel = kernel_accel_min;
2860 u32 kernel_loops = kernel_loops_min;
2861
2862 // steps
2863
2864 #define STEPS_CNT 10
2865
2866 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2867 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2868
2869 u32 steps_accel[STEPS_ACCEL_CNT];
2870 u32 steps_loops[STEPS_LOOPS_CNT];
2871
2872 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2873 {
2874 steps_accel[i] = 1 << i;
2875 }
2876
2877 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2878 {
2879 steps_loops[i] = 1 << i;
2880 }
2881
2882 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2883 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2884
2885 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2886 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2887
2888 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2889 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2890
2891 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2892
2893 u32 kernel_loops_tmp;
2894
2895 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2896 {
2897 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2898
2899 if (exec_ms < target_ms) break;
2900 }
2901
2902 // kernel-accel
2903
2904 if (kernel_accel_min < kernel_accel_max)
2905 {
2906 double e_best = 0;
2907
2908 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2909 {
2910 const u32 kernel_accel_try = steps_accel[i];
2911
2912 if (kernel_accel_try < kernel_accel_min) continue;
2913 if (kernel_accel_try > kernel_accel_max) break;
2914
2915 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2916
2917 if (exec_ms > target_ms) break;
2918
2919 const double e = kernel_accel_try / exec_ms;
2920
2921 if (e > e_best)
2922 {
2923 kernel_accel = kernel_accel_try;
2924
2925 e_best = e;
2926 }
2927 }
2928 }
2929
2930 // kernel-loops final
2931
2932 if (kernel_loops_min < kernel_loops_max)
2933 {
2934 double e_best = 0;
2935
2936 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2937 {
2938 const u32 kernel_loops_try = steps_loops[i];
2939
2940 if (kernel_loops_try < kernel_loops_min) continue;
2941 if (kernel_loops_try > kernel_loops_max) break;
2942
2943 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2944
2945 if (exec_ms > target_ms) break;
2946
2947 const double e = kernel_loops_try / exec_ms;
2948
2949 if (e > e_best)
2950 {
2951 kernel_loops = kernel_loops_try;
2952
2953 e_best = e;
2954 }
2955 }
2956 }
2957
2958 // final balance
2959
2960 u32 kernel_accel_best = kernel_accel;
2961 u32 kernel_loops_best = kernel_loops;
2962
2963 u32 exec_best = -1;
2964
2965 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2966 {
2967 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2968
2969 exec_best = exec_ms;
2970 }
2971
2972 // reset
2973
2974 if (kernel_accel_min < kernel_accel_max)
2975 {
2976 u32 kernel_accel_try = kernel_accel;
2977 u32 kernel_loops_try = kernel_loops;
2978
2979 for (int i = 0; i < 2; i++)
2980 {
2981 kernel_accel_try >>= 1;
2982 kernel_loops_try <<= 1;
2983
2984 if (kernel_accel_try < kernel_accel_min) break;
2985 if (kernel_loops_try > kernel_loops_max) break;
2986
2987 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2988
2989 if (exec_ms < exec_best)
2990 {
2991 kernel_accel_best = kernel_accel_try;
2992 kernel_loops_best = kernel_loops_try;
2993
2994 exec_best = exec_ms;
2995 }
2996 }
2997 }
2998
2999 // reset
3000
3001 if (kernel_loops_min < kernel_loops_max)
3002 {
3003 u32 kernel_accel_try = kernel_accel;
3004 u32 kernel_loops_try = kernel_loops;
3005
3006 for (int i = 0; i < 2; i++)
3007 {
3008 kernel_accel_try <<= 1;
3009 kernel_loops_try >>= 1;
3010
3011 if (kernel_accel_try > kernel_accel_max) break;
3012 if (kernel_loops_try < kernel_loops_min) break;
3013
3014 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3015
3016 if (exec_ms < exec_best)
3017 {
3018 kernel_accel_best = kernel_accel_try;
3019 kernel_loops_best = kernel_loops_try;
3020
3021 exec_best = exec_ms;
3022 }
3023 }
3024 }
3025
3026 // because of the balance we may have some free space left!
3027 // at this point, allow a small variance to overdrive the limit
3028
3029 const int exec_left = (target_ms * 1.2) / exec_best;
3030
3031 const int accel_left = kernel_accel_max / kernel_accel_best;
3032
3033 const int exec_accel_min = MIN (exec_left, accel_left);
3034
3035 if (exec_accel_min)
3036 {
3037 kernel_accel_best *= exec_accel_min;
3038 }
3039
3040 // reset timer
3041
3042 device_param->exec_pos = 0;
3043
3044 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3045
3046 // store
3047
3048 kernel_accel = kernel_accel_best;
3049 kernel_loops = kernel_loops_best;
3050
3051 device_param->kernel_accel = kernel_accel;
3052 device_param->kernel_loops = kernel_loops;
3053
3054 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3055
3056 device_param->kernel_power = kernel_power;
3057
3058 #ifdef DEBUG
3059
3060 if (data.quiet == 0)
3061 {
3062 clear_prompt ();
3063
3064 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3065 "Device #%u: autotuned kernel-loops to %u\n",
3066 device_param->device_id + 1,
3067 kernel_accel,
3068 device_param->device_id + 1,
3069 kernel_loops);
3070
3071 fprintf (stdout, "%s", PROMPT);
3072 fflush (stdout);
3073 }
3074
3075 #endif
3076 }
3077
3078 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3079 {
3080 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3081
3082 // init speed timer
3083
3084 uint speed_pos = device_param->speed_pos;
3085
3086 #ifdef _POSIX
3087 if (device_param->timer_speed.tv_sec == 0)
3088 {
3089 hc_timer_set (&device_param->timer_speed);
3090 }
3091 #endif
3092
3093 #ifdef _WIN
3094 if (device_param->timer_speed.QuadPart == 0)
3095 {
3096 hc_timer_set (&device_param->timer_speed);
3097 }
3098 #endif
3099
3100 // find higest password length, this is for optimization stuff
3101
3102 uint highest_pw_len = 0;
3103
3104 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3105 {
3106 }
3107 else if (data.attack_kern == ATTACK_KERN_COMBI)
3108 {
3109 }
3110 else if (data.attack_kern == ATTACK_KERN_BF)
3111 {
3112 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3113 + device_param->kernel_params_mp_l_buf32[5];
3114 }
3115
3116 // iteration type
3117
3118 uint innerloop_step = 0;
3119 uint innerloop_cnt = 0;
3120
3121 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3122 else innerloop_step = 1;
3123
3124 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3125 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3126 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3127
3128 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3129
3130 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3131 {
3132 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3133
3134 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3135
3136 if (data.devices_status == STATUS_CRACKED) break;
3137 if (data.devices_status == STATUS_ABORTED) break;
3138 if (data.devices_status == STATUS_QUIT) break;
3139 if (data.devices_status == STATUS_BYPASS) break;
3140
3141 salt_t *salt_buf = &data.salts_buf[salt_pos];
3142
3143 device_param->kernel_params_buf32[24] = salt_pos;
3144 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3145 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3146
3147 FILE *combs_fp = device_param->combs_fp;
3148
3149 if (data.attack_mode == ATTACK_MODE_COMBI)
3150 {
3151 rewind (combs_fp);
3152 }
3153
3154 // innerloops
3155
3156 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3157 {
3158 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3159
3160 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3161
3162 if (data.devices_status == STATUS_CRACKED) break;
3163 if (data.devices_status == STATUS_ABORTED) break;
3164 if (data.devices_status == STATUS_QUIT) break;
3165 if (data.devices_status == STATUS_BYPASS) break;
3166
3167 uint innerloop_left = innerloop_cnt - innerloop_pos;
3168
3169 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3170
3171 device_param->innerloop_pos = innerloop_pos;
3172 device_param->innerloop_left = innerloop_left;
3173
3174 device_param->kernel_params_buf32[27] = innerloop_left;
3175
3176 // i think we can get rid of this
3177 if (innerloop_left == 0)
3178 {
3179 puts ("bug, how should this happen????\n");
3180
3181 continue;
3182 }
3183
3184 if (data.salts_shown[salt_pos] == 1)
3185 {
3186 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3187
3188 continue;
3189 }
3190
3191 // initialize amplifiers
3192
3193 if (data.attack_mode == ATTACK_MODE_COMBI)
3194 {
3195 uint i = 0;
3196
3197 while (i < innerloop_left)
3198 {
3199 if (feof (combs_fp)) break;
3200
3201 int line_len = fgetl (combs_fp, line_buf);
3202
3203 if (line_len >= PW_MAX1) continue;
3204
3205 line_len = convert_from_hex (line_buf, line_len);
3206
3207 char *line_buf_new = line_buf;
3208
3209 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3210 {
3211 char rule_buf_out[BLOCK_SIZE] = { 0 };
3212
3213 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3214
3215 if (rule_len_out < 0)
3216 {
3217 data.words_progress_rejected[salt_pos] += pws_cnt;
3218
3219 continue;
3220 }
3221
3222 line_len = rule_len_out;
3223
3224 line_buf_new = rule_buf_out;
3225 }
3226
3227 line_len = MIN (line_len, PW_DICTMAX);
3228
3229 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3230
3231 memcpy (ptr, line_buf_new, line_len);
3232
3233 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3234
3235 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3236 {
3237 uppercase (ptr, line_len);
3238 }
3239
3240 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3241 {
3242 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3243 {
3244 ptr[line_len] = 0x80;
3245 }
3246
3247 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3248 {
3249 ptr[line_len] = 0x01;
3250 }
3251 }
3252
3253 device_param->combs_buf[i].pw_len = line_len;
3254
3255 i++;
3256 }
3257
3258 for (uint j = i; j < innerloop_left; j++)
3259 {
3260 device_param->combs_buf[j].i[0] = 0;
3261 device_param->combs_buf[j].i[1] = 0;
3262 device_param->combs_buf[j].i[2] = 0;
3263 device_param->combs_buf[j].i[3] = 0;
3264 device_param->combs_buf[j].i[4] = 0;
3265 device_param->combs_buf[j].i[5] = 0;
3266 device_param->combs_buf[j].i[6] = 0;
3267 device_param->combs_buf[j].i[7] = 0;
3268
3269 device_param->combs_buf[j].pw_len = 0;
3270 }
3271
3272 innerloop_left = i;
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_BF)
3275 {
3276 u64 off = innerloop_pos;
3277
3278 device_param->kernel_params_mp_r_buf64[3] = off;
3279
3280 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3283 {
3284 u64 off = innerloop_pos;
3285
3286 device_param->kernel_params_mp_buf64[3] = off;
3287
3288 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3289 }
3290 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3291 {
3292 u64 off = innerloop_pos;
3293
3294 device_param->kernel_params_mp_buf64[3] = off;
3295
3296 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3297 }
3298
3299 // copy amplifiers
3300
3301 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3302 {
3303 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);
3304 }
3305 else if (data.attack_mode == ATTACK_MODE_COMBI)
3306 {
3307 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);
3308 }
3309 else if (data.attack_mode == ATTACK_MODE_BF)
3310 {
3311 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);
3312 }
3313 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3314 {
3315 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);
3316 }
3317 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3318 {
3319 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);
3320 }
3321
3322 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3323
3324 if (data.benchmark == 1)
3325 {
3326 double exec_ms_avg_prev = get_avg_exec_time (device_param, EXEC_CACHE);
3327
3328 // a few caching rounds
3329
3330 for (u32 i = 0; i < 2; i++)
3331 {
3332 hc_timer_set (&device_param->timer_speed);
3333
3334 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3335
3336 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3337
3338 exec_ms_avg_prev = exec_ms_avg;
3339 }
3340
3341 // benchmark_repeats became a maximum possible repeats
3342
3343 for (u32 i = 2; i < data.benchmark_repeats; i++)
3344 {
3345 hc_timer_set (&device_param->timer_speed);
3346
3347 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3348
3349 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
3350
3351 if ((exec_ms_avg_prev / exec_ms_avg) < 1.001) break;
3352
3353 exec_ms_avg_prev = exec_ms_avg;
3354 }
3355 }
3356
3357 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3358
3359 if (data.devices_status == STATUS_CRACKED) break;
3360 if (data.devices_status == STATUS_ABORTED) break;
3361 if (data.devices_status == STATUS_QUIT) break;
3362
3363 /**
3364 * result
3365 */
3366
3367 hc_thread_mutex_lock (mux_display);
3368
3369 check_cracked (device_param, salt_pos);
3370
3371 hc_thread_mutex_unlock (mux_display);
3372
3373 /**
3374 * progress
3375 */
3376
3377 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3378
3379 hc_thread_mutex_lock (mux_counter);
3380
3381 data.words_progress_done[salt_pos] += perf_sum_all;
3382
3383 hc_thread_mutex_unlock (mux_counter);
3384
3385 /**
3386 * speed
3387 */
3388
3389 double speed_ms;
3390
3391 hc_timer_get (device_param->timer_speed, speed_ms);
3392
3393 hc_timer_set (&device_param->timer_speed);
3394
3395 hc_thread_mutex_lock (mux_display);
3396
3397 // current speed
3398
3399 device_param->speed_cnt[speed_pos] = perf_sum_all;
3400
3401 device_param->speed_ms[speed_pos] = speed_ms;
3402
3403 hc_thread_mutex_unlock (mux_display);
3404
3405 speed_pos++;
3406
3407 if (speed_pos == SPEED_CACHE)
3408 {
3409 speed_pos = 0;
3410 }
3411
3412 /**
3413 * benchmark
3414 */
3415
3416 if (data.benchmark == 1) break;
3417 }
3418 }
3419
3420 device_param->speed_pos = speed_pos;
3421
3422 myfree (line_buf);
3423 }
3424
3425 static void load_segment (wl_data_t *wl_data, FILE *fd)
3426 {
3427 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3428
3429 wl_data->pos = 0;
3430
3431 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3432
3433 wl_data->buf[wl_data->cnt] = 0;
3434
3435 if (wl_data->cnt == 0) return;
3436
3437 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3438
3439 while (!feof (fd))
3440 {
3441 if (wl_data->cnt == wl_data->avail)
3442 {
3443 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3444
3445 wl_data->avail += wl_data->incr;
3446 }
3447
3448 const int c = fgetc (fd);
3449
3450 if (c == EOF) break;
3451
3452 wl_data->buf[wl_data->cnt] = (char) c;
3453
3454 wl_data->cnt++;
3455
3456 if (c == '\n') break;
3457 }
3458
3459 // ensure stream ends with a newline
3460
3461 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3462 {
3463 wl_data->cnt++;
3464
3465 wl_data->buf[wl_data->cnt - 1] = '\n';
3466 }
3467
3468 return;
3469 }
3470
3471 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3472 {
3473 char *ptr = buf;
3474
3475 for (u32 i = 0; i < sz; i++, ptr++)
3476 {
3477 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3478
3479 if (i == 7)
3480 {
3481 *off = i;
3482 *len = i;
3483
3484 return;
3485 }
3486
3487 if (*ptr != '\n') continue;
3488
3489 *off = i + 1;
3490
3491 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3492
3493 *len = i;
3494
3495 return;
3496 }
3497
3498 *off = sz;
3499 *len = sz;
3500 }
3501
3502 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3503 {
3504 char *ptr = buf;
3505
3506 for (u32 i = 0; i < sz; i++, ptr++)
3507 {
3508 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3509
3510 if (*ptr != '\n') continue;
3511
3512 *off = i + 1;
3513
3514 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3515
3516 *len = i;
3517
3518 return;
3519 }
3520
3521 *off = sz;
3522 *len = sz;
3523 }
3524
3525 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3526 {
3527 char *ptr = buf;
3528
3529 for (u32 i = 0; i < sz; i++, ptr++)
3530 {
3531 if (*ptr != '\n') continue;
3532
3533 *off = i + 1;
3534
3535 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3536
3537 *len = i;
3538
3539 return;
3540 }
3541
3542 *off = sz;
3543 *len = sz;
3544 }
3545
3546 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3547 {
3548 while (wl_data->pos < wl_data->cnt)
3549 {
3550 uint off;
3551 uint len;
3552
3553 char *ptr = wl_data->buf + wl_data->pos;
3554
3555 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3556
3557 wl_data->pos += off;
3558
3559 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3560 {
3561 char rule_buf_out[BLOCK_SIZE] = { 0 };
3562
3563 int rule_len_out = -1;
3564
3565 if (len < BLOCK_SIZE)
3566 {
3567 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3568 }
3569
3570 if (rule_len_out < 0)
3571 {
3572 continue;
3573 }
3574
3575 if (rule_len_out > PW_MAX)
3576 {
3577 continue;
3578 }
3579 }
3580 else
3581 {
3582 if (len > PW_MAX)
3583 {
3584 continue;
3585 }
3586 }
3587
3588 *out_buf = ptr;
3589 *out_len = len;
3590
3591 return;
3592 }
3593
3594 if (feof (fd))
3595 {
3596 fprintf (stderr, "BUG feof()!!\n");
3597
3598 return;
3599 }
3600
3601 load_segment (wl_data, fd);
3602
3603 get_next_word (wl_data, fd, out_buf, out_len);
3604 }
3605
3606 #ifdef _POSIX
3607 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3608 #endif
3609
3610 #ifdef _WIN
3611 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3612 #endif
3613 {
3614 hc_signal (NULL);
3615
3616 dictstat_t d;
3617
3618 d.cnt = 0;
3619
3620 #ifdef _POSIX
3621 fstat (fileno (fd), &d.stat);
3622 #endif
3623
3624 #ifdef _WIN
3625 _fstat64 (fileno (fd), &d.stat);
3626 #endif
3627
3628 d.stat.st_mode = 0;
3629 d.stat.st_nlink = 0;
3630 d.stat.st_uid = 0;
3631 d.stat.st_gid = 0;
3632 d.stat.st_rdev = 0;
3633 d.stat.st_atime = 0;
3634
3635 #ifdef _POSIX
3636 d.stat.st_blksize = 0;
3637 d.stat.st_blocks = 0;
3638 #endif
3639
3640 if (d.stat.st_size == 0) return 0;
3641
3642 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3643
3644 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3645 {
3646 if (d_cache)
3647 {
3648 u64 cnt = d_cache->cnt;
3649
3650 u64 keyspace = cnt;
3651
3652 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3653 {
3654 keyspace *= data.kernel_rules_cnt;
3655 }
3656 else if (data.attack_kern == ATTACK_KERN_COMBI)
3657 {
3658 keyspace *= data.combs_cnt;
3659 }
3660
3661 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);
3662 if (data.quiet == 0) log_info ("");
3663
3664 hc_signal (sigHandler_default);
3665
3666 return (keyspace);
3667 }
3668 }
3669
3670 time_t now = 0;
3671 time_t prev = 0;
3672
3673 u64 comp = 0;
3674 u64 cnt = 0;
3675 u64 cnt2 = 0;
3676
3677 while (!feof (fd))
3678 {
3679 load_segment (wl_data, fd);
3680
3681 comp += wl_data->cnt;
3682
3683 u32 i = 0;
3684
3685 while (i < wl_data->cnt)
3686 {
3687 u32 len;
3688 u32 off;
3689
3690 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3691
3692 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3693 {
3694 char rule_buf_out[BLOCK_SIZE] = { 0 };
3695
3696 int rule_len_out = -1;
3697
3698 if (len < BLOCK_SIZE)
3699 {
3700 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3701 }
3702
3703 if (rule_len_out < 0)
3704 {
3705 len = PW_MAX1;
3706 }
3707 else
3708 {
3709 len = rule_len_out;
3710 }
3711 }
3712
3713 if (len < PW_MAX1)
3714 {
3715 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3716 {
3717 cnt += data.kernel_rules_cnt;
3718 }
3719 else if (data.attack_kern == ATTACK_KERN_COMBI)
3720 {
3721 cnt += data.combs_cnt;
3722 }
3723
3724 d.cnt++;
3725 }
3726
3727 i += off;
3728
3729 cnt2++;
3730 }
3731
3732 time (&now);
3733
3734 if ((now - prev) == 0) continue;
3735
3736 float percent = (float) comp / (float) d.stat.st_size;
3737
3738 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);
3739
3740 time (&prev);
3741 }
3742
3743 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);
3744 if (data.quiet == 0) log_info ("");
3745
3746 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3747
3748 hc_signal (sigHandler_default);
3749
3750 return (cnt);
3751 }
3752
3753 static void *thread_monitor (void *p)
3754 {
3755 uint runtime_check = 0;
3756 uint remove_check = 0;
3757 uint status_check = 0;
3758 uint restore_check = 0;
3759
3760 uint restore_left = data.restore_timer;
3761 uint remove_left = data.remove_timer;
3762 uint status_left = data.status_timer;
3763
3764 #ifdef HAVE_HWMON
3765 uint hwmon_check = 0;
3766
3767 // these variables are mainly used for fan control (AMD only)
3768
3769 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3770
3771 // temperature controller "loopback" values
3772
3773 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3774 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3775
3776 #ifdef HAVE_ADL
3777 int temp_threshold = 1; // degrees celcius
3778
3779 int fan_speed_min = 15; // in percentage
3780 int fan_speed_max = 100;
3781 #endif // HAVE_ADL
3782
3783 time_t last_temp_check_time;
3784 #endif // HAVE_HWMON
3785
3786 uint sleep_time = 1;
3787
3788 if (data.runtime)
3789 {
3790 runtime_check = 1;
3791 }
3792
3793 if (data.restore_timer)
3794 {
3795 restore_check = 1;
3796 }
3797
3798 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3799 {
3800 remove_check = 1;
3801 }
3802
3803 if (data.status == 1)
3804 {
3805 status_check = 1;
3806 }
3807
3808 #ifdef HAVE_HWMON
3809 if (data.gpu_temp_disable == 0)
3810 {
3811 time (&last_temp_check_time);
3812
3813 hwmon_check = 1;
3814 }
3815 #endif
3816
3817 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3818 {
3819 #ifdef HAVE_HWMON
3820 if (hwmon_check == 0)
3821 #endif
3822 return (p);
3823 }
3824
3825 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3826 {
3827 hc_sleep (sleep_time);
3828
3829 if (data.devices_status != STATUS_RUNNING) continue;
3830
3831 #ifdef HAVE_HWMON
3832 if (hwmon_check == 1)
3833 {
3834 hc_thread_mutex_lock (mux_adl);
3835
3836 time_t temp_check_time;
3837
3838 time (&temp_check_time);
3839
3840 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3841
3842 if (Ta == 0) Ta = 1;
3843
3844 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3845 {
3846 hc_device_param_t *device_param = &data.devices_param[device_id];
3847
3848 if (device_param->skipped) continue;
3849
3850 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3851
3852 const int temperature = hm_get_temperature_with_device_id (device_id);
3853
3854 if (temperature > (int) data.gpu_temp_abort)
3855 {
3856 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3857
3858 if (data.devices_status != STATUS_QUIT) myabort ();
3859
3860 break;
3861 }
3862
3863 #ifdef HAVE_ADL
3864 const int gpu_temp_retain = data.gpu_temp_retain;
3865
3866 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3867 {
3868 if (data.hm_device[device_id].fan_supported == 1)
3869 {
3870 int temp_cur = temperature;
3871
3872 int temp_diff_new = gpu_temp_retain - temp_cur;
3873
3874 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3875
3876 // calculate Ta value (time difference in seconds between the last check and this check)
3877
3878 last_temp_check_time = temp_check_time;
3879
3880 float Kp = 1.8;
3881 float Ki = 0.005;
3882 float Kd = 6;
3883
3884 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3885
3886 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);
3887
3888 if (abs (fan_diff_required) >= temp_threshold)
3889 {
3890 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3891
3892 int fan_speed_level = fan_speed_cur;
3893
3894 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3895
3896 int fan_speed_new = fan_speed_level - fan_diff_required;
3897
3898 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3899 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3900
3901 if (fan_speed_new != fan_speed_cur)
3902 {
3903 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3904 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3905
3906 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3907 {
3908 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3909
3910 fan_speed_chgd[device_id] = 1;
3911 }
3912
3913 temp_diff_old[device_id] = temp_diff_new;
3914 }
3915 }
3916 }
3917 }
3918 #endif // HAVE_ADL
3919 }
3920
3921 hc_thread_mutex_unlock (mux_adl);
3922 }
3923 #endif // HAVE_HWMON
3924
3925 if (restore_check == 1)
3926 {
3927 restore_left--;
3928
3929 if (restore_left == 0)
3930 {
3931 if (data.restore_disable == 0) cycle_restore ();
3932
3933 restore_left = data.restore_timer;
3934 }
3935 }
3936
3937 if ((runtime_check == 1) && (data.runtime_start > 0))
3938 {
3939 time_t runtime_cur;
3940
3941 time (&runtime_cur);
3942
3943 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3944
3945 if (runtime_left <= 0)
3946 {
3947 if (data.benchmark == 0)
3948 {
3949 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3950 }
3951
3952 if (data.devices_status != STATUS_QUIT) myabort ();
3953 }
3954 }
3955
3956 if (remove_check == 1)
3957 {
3958 remove_left--;
3959
3960 if (remove_left == 0)
3961 {
3962 if (data.digests_saved != data.digests_done)
3963 {
3964 data.digests_saved = data.digests_done;
3965
3966 save_hash ();
3967 }
3968
3969 remove_left = data.remove_timer;
3970 }
3971 }
3972
3973 if (status_check == 1)
3974 {
3975 status_left--;
3976
3977 if (status_left == 0)
3978 {
3979 hc_thread_mutex_lock (mux_display);
3980
3981 if (data.quiet == 0) clear_prompt ();
3982
3983 if (data.quiet == 0) log_info ("");
3984
3985 status_display ();
3986
3987 if (data.quiet == 0) log_info ("");
3988
3989 hc_thread_mutex_unlock (mux_display);
3990
3991 status_left = data.status_timer;
3992 }
3993 }
3994 }
3995
3996 #ifdef HAVE_HWMON
3997 myfree (fan_speed_chgd);
3998
3999 myfree (temp_diff_old);
4000 myfree (temp_diff_sum);
4001 #endif
4002
4003 p = NULL;
4004
4005 return (p);
4006 }
4007
4008 static void *thread_outfile_remove (void *p)
4009 {
4010 // some hash-dependent constants
4011 char *outfile_dir = data.outfile_check_directory;
4012 uint dgst_size = data.dgst_size;
4013 uint isSalted = data.isSalted;
4014 uint esalt_size = data.esalt_size;
4015 uint hash_mode = data.hash_mode;
4016
4017 uint outfile_check_timer = data.outfile_check_timer;
4018
4019 char separator = data.separator;
4020
4021 // some hash-dependent functions
4022 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4023 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4024
4025 // buffers
4026 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4027
4028 hash_buf.digest = mymalloc (dgst_size);
4029
4030 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4031
4032 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4033
4034 uint digest_buf[64] = { 0 };
4035
4036 outfile_data_t *out_info = NULL;
4037
4038 char **out_files = NULL;
4039
4040 time_t folder_mtime = 0;
4041
4042 int out_cnt = 0;
4043
4044 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4045
4046 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4047 {
4048 hc_sleep (1);
4049
4050 if (data.devices_status != STATUS_RUNNING) continue;
4051
4052 check_left--;
4053
4054 if (check_left == 0)
4055 {
4056 struct stat outfile_check_stat;
4057
4058 if (stat (outfile_dir, &outfile_check_stat) == 0)
4059 {
4060 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4061
4062 if (is_dir == 1)
4063 {
4064 if (outfile_check_stat.st_mtime > folder_mtime)
4065 {
4066 char **out_files_new = scan_directory (outfile_dir);
4067
4068 int out_cnt_new = count_dictionaries (out_files_new);
4069
4070 outfile_data_t *out_info_new = NULL;
4071
4072 if (out_cnt_new > 0)
4073 {
4074 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4075
4076 for (int i = 0; i < out_cnt_new; i++)
4077 {
4078 out_info_new[i].file_name = out_files_new[i];
4079
4080 // check if there are files that we have seen/checked before (and not changed)
4081
4082 for (int j = 0; j < out_cnt; j++)
4083 {
4084 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4085 {
4086 struct stat outfile_stat;
4087
4088 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4089 {
4090 if (outfile_stat.st_ctime == out_info[j].ctime)
4091 {
4092 out_info_new[i].ctime = out_info[j].ctime;
4093 out_info_new[i].seek = out_info[j].seek;
4094 }
4095 }
4096 }
4097 }
4098 }
4099 }
4100
4101 local_free (out_info);
4102 local_free (out_files);
4103
4104 out_files = out_files_new;
4105 out_cnt = out_cnt_new;
4106 out_info = out_info_new;
4107
4108 folder_mtime = outfile_check_stat.st_mtime;
4109 }
4110
4111 for (int j = 0; j < out_cnt; j++)
4112 {
4113 FILE *fp = fopen (out_info[j].file_name, "rb");
4114
4115 if (fp != NULL)
4116 {
4117 //hc_thread_mutex_lock (mux_display);
4118
4119 #ifdef _POSIX
4120 struct stat outfile_stat;
4121
4122 fstat (fileno (fp), &outfile_stat);
4123 #endif
4124
4125 #ifdef _WIN
4126 struct stat64 outfile_stat;
4127
4128 _fstat64 (fileno (fp), &outfile_stat);
4129 #endif
4130
4131 if (outfile_stat.st_ctime > out_info[j].ctime)
4132 {
4133 out_info[j].ctime = outfile_stat.st_ctime;
4134 out_info[j].seek = 0;
4135 }
4136
4137 fseek (fp, out_info[j].seek, SEEK_SET);
4138
4139 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4140
4141 while (!feof (fp))
4142 {
4143 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4144
4145 if (ptr == NULL) break;
4146
4147 int line_len = strlen (line_buf);
4148
4149 if (line_len <= 0) continue;
4150
4151 int iter = MAX_CUT_TRIES;
4152
4153 for (uint i = line_len - 1; i && iter; i--, line_len--)
4154 {
4155 if (line_buf[i] != separator) continue;
4156
4157 int parser_status = PARSER_OK;
4158
4159 if ((hash_mode != 2500) && (hash_mode != 6800))
4160 {
4161 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4162 }
4163
4164 uint found = 0;
4165
4166 if (parser_status == PARSER_OK)
4167 {
4168 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4169 {
4170 if (data.salts_shown[salt_pos] == 1) continue;
4171
4172 salt_t *salt_buf = &data.salts_buf[salt_pos];
4173
4174 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4175 {
4176 uint idx = salt_buf->digests_offset + digest_pos;
4177
4178 if (data.digests_shown[idx] == 1) continue;
4179
4180 uint cracked = 0;
4181
4182 if (hash_mode == 6800)
4183 {
4184 if (i == salt_buf->salt_len)
4185 {
4186 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4187 }
4188 }
4189 else if (hash_mode == 2500)
4190 {
4191 // BSSID : MAC1 : MAC2 (:plain)
4192 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4193 {
4194 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4195
4196 if (!cracked) continue;
4197
4198 // now compare MAC1 and MAC2 too, since we have this additional info
4199 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4200 char *mac2_pos = mac1_pos + 12 + 1;
4201
4202 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4203 wpa_t *wpa = &wpas[salt_pos];
4204
4205 // compare hex string(s) vs binary MAC address(es)
4206
4207 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4208 {
4209 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4210 {
4211 cracked = 0;
4212
4213 break;
4214 }
4215 }
4216
4217 // early skip ;)
4218 if (!cracked) continue;
4219
4220 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4221 {
4222 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4223 {
4224 cracked = 0;
4225
4226 break;
4227 }
4228 }
4229 }
4230 }
4231 else
4232 {
4233 char *digests_buf_ptr = (char *) data.digests_buf;
4234
4235 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4236
4237 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4238 }
4239
4240 if (cracked == 1)
4241 {
4242 found = 1;
4243
4244 data.digests_shown[idx] = 1;
4245
4246 data.digests_done++;
4247
4248 salt_buf->digests_done++;
4249
4250 if (salt_buf->digests_done == salt_buf->digests_cnt)
4251 {
4252 data.salts_shown[salt_pos] = 1;
4253
4254 data.salts_done++;
4255
4256 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4257 }
4258 }
4259 }
4260
4261 if (data.devices_status == STATUS_CRACKED) break;
4262 }
4263 }
4264
4265 if (found) break;
4266
4267 if (data.devices_status == STATUS_CRACKED) break;
4268
4269 iter--;
4270 }
4271
4272 if (data.devices_status == STATUS_CRACKED) break;
4273 }
4274
4275 myfree (line_buf);
4276
4277 out_info[j].seek = ftell (fp);
4278
4279 //hc_thread_mutex_unlock (mux_display);
4280
4281 fclose (fp);
4282 }
4283 }
4284 }
4285 }
4286
4287 check_left = outfile_check_timer;
4288 }
4289 }
4290
4291 if (esalt_size) local_free (hash_buf.esalt);
4292
4293 if (isSalted) local_free (hash_buf.salt);
4294
4295 local_free (hash_buf.digest);
4296
4297 local_free (out_info);
4298
4299 local_free (out_files);
4300
4301 p = NULL;
4302
4303 return (p);
4304 }
4305
4306 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4307 {
4308 if (device_param->pws_cnt < device_param->kernel_power)
4309 {
4310 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4311
4312 u8 *ptr = (u8 *) pw->i;
4313
4314 memcpy (ptr, pw_buf, pw_len);
4315
4316 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4317
4318 pw->pw_len = pw_len;
4319
4320 device_param->pws_cnt++;
4321 }
4322 else
4323 {
4324 fprintf (stderr, "BUG pw_add()!!\n");
4325
4326 return;
4327 }
4328 }
4329
4330 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4331 {
4332 hc_thread_mutex_lock (mux_dispatcher);
4333
4334 const u64 words_cur = data.words_cur;
4335 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4336
4337 device_param->words_off = words_cur;
4338
4339 const u64 words_left = words_base - words_cur;
4340
4341 if (allow_div)
4342 {
4343 if (data.kernel_power_all > words_left)
4344 {
4345 if (data.kernel_power_div == 0)
4346 {
4347 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4348 }
4349 }
4350
4351 if (data.kernel_power_div)
4352 {
4353 if (device_param->kernel_power == device_param->kernel_power_user)
4354 {
4355 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4356
4357 if (kernel_power_new < device_param->kernel_power)
4358 {
4359 device_param->kernel_power = kernel_power_new;
4360 }
4361 }
4362 }
4363 }
4364
4365 const uint kernel_power = device_param->kernel_power;
4366
4367 uint work = MIN (words_left, kernel_power);
4368
4369 work = MIN (work, max);
4370
4371 data.words_cur += work;
4372
4373 hc_thread_mutex_unlock (mux_dispatcher);
4374
4375 return work;
4376 }
4377
4378 static void *thread_calc_stdin (void *p)
4379 {
4380 hc_device_param_t *device_param = (hc_device_param_t *) p;
4381
4382 if (device_param->skipped) return NULL;
4383
4384 autotune (device_param);
4385
4386 char *buf = (char *) mymalloc (HCBUFSIZ);
4387
4388 const uint attack_kern = data.attack_kern;
4389
4390 const uint kernel_power = device_param->kernel_power;
4391
4392 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4393 {
4394 hc_thread_mutex_lock (mux_dispatcher);
4395
4396 if (feof (stdin) != 0)
4397 {
4398 hc_thread_mutex_unlock (mux_dispatcher);
4399
4400 break;
4401 }
4402
4403 uint words_cur = 0;
4404
4405 while (words_cur < kernel_power)
4406 {
4407 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4408
4409 if (line_buf == NULL) break;
4410
4411 uint line_len = in_superchop (line_buf);
4412
4413 line_len = convert_from_hex (line_buf, line_len);
4414
4415 // post-process rule engine
4416
4417 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4418 {
4419 char rule_buf_out[BLOCK_SIZE] = { 0 };
4420
4421 int rule_len_out = -1;
4422
4423 if (line_len < BLOCK_SIZE)
4424 {
4425 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4426 }
4427
4428 if (rule_len_out < 0) continue;
4429
4430 line_buf = rule_buf_out;
4431 line_len = rule_len_out;
4432 }
4433
4434 if (line_len > PW_MAX)
4435 {
4436 continue;
4437 }
4438
4439 if (attack_kern == ATTACK_KERN_STRAIGHT)
4440 {
4441 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4442 {
4443 hc_thread_mutex_lock (mux_counter);
4444
4445 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4446 {
4447 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4448 }
4449
4450 hc_thread_mutex_unlock (mux_counter);
4451
4452 continue;
4453 }
4454 }
4455 else if (attack_kern == ATTACK_KERN_COMBI)
4456 {
4457 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4458 // since we still need to combine the plains
4459
4460 if (line_len > data.pw_max)
4461 {
4462 hc_thread_mutex_lock (mux_counter);
4463
4464 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4465 {
4466 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4467 }
4468
4469 hc_thread_mutex_unlock (mux_counter);
4470
4471 continue;
4472 }
4473 }
4474
4475 pw_add (device_param, (u8 *) line_buf, line_len);
4476
4477 words_cur++;
4478
4479 if (data.devices_status == STATUS_CRACKED) break;
4480 if (data.devices_status == STATUS_ABORTED) break;
4481 if (data.devices_status == STATUS_QUIT) break;
4482 if (data.devices_status == STATUS_BYPASS) break;
4483 }
4484
4485 hc_thread_mutex_unlock (mux_dispatcher);
4486
4487 if (data.devices_status == STATUS_CRACKED) break;
4488 if (data.devices_status == STATUS_ABORTED) break;
4489 if (data.devices_status == STATUS_QUIT) break;
4490 if (data.devices_status == STATUS_BYPASS) break;
4491
4492 // flush
4493
4494 const uint pws_cnt = device_param->pws_cnt;
4495
4496 if (pws_cnt)
4497 {
4498 run_copy (device_param, pws_cnt);
4499
4500 run_cracker (device_param, pws_cnt);
4501
4502 device_param->pws_cnt = 0;
4503
4504 if (attack_kern == ATTACK_KERN_STRAIGHT)
4505 {
4506 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4507 }
4508 else if (attack_kern == ATTACK_KERN_COMBI)
4509 {
4510 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4511 }
4512 }
4513 }
4514
4515 device_param->kernel_accel = 0;
4516 device_param->kernel_loops = 0;
4517
4518 myfree (buf);
4519
4520 return NULL;
4521 }
4522
4523 static void *thread_calc (void *p)
4524 {
4525 hc_device_param_t *device_param = (hc_device_param_t *) p;
4526
4527 if (device_param->skipped) return NULL;
4528
4529 autotune (device_param);
4530
4531 const uint attack_mode = data.attack_mode;
4532 const uint attack_kern = data.attack_kern;
4533
4534 if (attack_mode == ATTACK_MODE_BF)
4535 {
4536 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4537 {
4538 const uint work = get_work (device_param, -1, true);
4539
4540 if (work == 0) break;
4541
4542 const u64 words_off = device_param->words_off;
4543 const u64 words_fin = words_off + work;
4544
4545 const uint pws_cnt = work;
4546
4547 device_param->pws_cnt = pws_cnt;
4548
4549 if (pws_cnt)
4550 {
4551 run_copy (device_param, pws_cnt);
4552
4553 run_cracker (device_param, pws_cnt);
4554
4555 device_param->pws_cnt = 0;
4556
4557 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4558 }
4559
4560 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4561
4562 if (data.devices_status == STATUS_CRACKED) break;
4563 if (data.devices_status == STATUS_ABORTED) break;
4564 if (data.devices_status == STATUS_QUIT) break;
4565 if (data.devices_status == STATUS_BYPASS) break;
4566
4567 if (data.benchmark == 1) break;
4568
4569 device_param->words_done = words_fin;
4570 }
4571 }
4572 else
4573 {
4574 const uint segment_size = data.segment_size;
4575
4576 char *dictfile = data.dictfile;
4577
4578 if (attack_mode == ATTACK_MODE_COMBI)
4579 {
4580 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4581 {
4582 dictfile = data.dictfile2;
4583 }
4584 }
4585
4586 FILE *fd = fopen (dictfile, "rb");
4587
4588 if (fd == NULL)
4589 {
4590 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4591
4592 return NULL;
4593 }
4594
4595 if (attack_mode == ATTACK_MODE_COMBI)
4596 {
4597 const uint combs_mode = data.combs_mode;
4598
4599 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4600 {
4601 const char *dictfilec = data.dictfile2;
4602
4603 FILE *combs_fp = fopen (dictfilec, "rb");
4604
4605 if (combs_fp == NULL)
4606 {
4607 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4608
4609 fclose (fd);
4610
4611 return NULL;
4612 }
4613
4614 device_param->combs_fp = combs_fp;
4615 }
4616 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4617 {
4618 const char *dictfilec = data.dictfile;
4619
4620 FILE *combs_fp = fopen (dictfilec, "rb");
4621
4622 if (combs_fp == NULL)
4623 {
4624 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4625
4626 fclose (fd);
4627
4628 return NULL;
4629 }
4630
4631 device_param->combs_fp = combs_fp;
4632 }
4633 }
4634
4635 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4636
4637 wl_data->buf = (char *) mymalloc (segment_size);
4638 wl_data->avail = segment_size;
4639 wl_data->incr = segment_size;
4640 wl_data->cnt = 0;
4641 wl_data->pos = 0;
4642
4643 u64 words_cur = 0;
4644
4645 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4646 {
4647 u64 words_off = 0;
4648 u64 words_fin = 0;
4649
4650 bool allow_div = true;
4651
4652 u64 max = -1;
4653
4654 while (max)
4655 {
4656 const uint work = get_work (device_param, max, allow_div);
4657
4658 allow_div = false;
4659
4660 if (work == 0) break;
4661
4662 words_off = device_param->words_off;
4663 words_fin = words_off + work;
4664
4665 char *line_buf;
4666 uint line_len;
4667
4668 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4669
4670 max = 0;
4671
4672 for ( ; words_cur < words_fin; words_cur++)
4673 {
4674 get_next_word (wl_data, fd, &line_buf, &line_len);
4675
4676 line_len = convert_from_hex (line_buf, line_len);
4677
4678 // post-process rule engine
4679
4680 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4681 {
4682 char rule_buf_out[BLOCK_SIZE] = { 0 };
4683
4684 int rule_len_out = -1;
4685
4686 if (line_len < BLOCK_SIZE)
4687 {
4688 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4689 }
4690
4691 if (rule_len_out < 0) continue;
4692
4693 line_buf = rule_buf_out;
4694 line_len = rule_len_out;
4695 }
4696
4697 if (attack_kern == ATTACK_KERN_STRAIGHT)
4698 {
4699 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4700 {
4701 max++;
4702
4703 hc_thread_mutex_lock (mux_counter);
4704
4705 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4706 {
4707 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4708 }
4709
4710 hc_thread_mutex_unlock (mux_counter);
4711
4712 continue;
4713 }
4714 }
4715 else if (attack_kern == ATTACK_KERN_COMBI)
4716 {
4717 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4718 // since we still need to combine the plains
4719
4720 if (line_len > data.pw_max)
4721 {
4722 max++;
4723
4724 hc_thread_mutex_lock (mux_counter);
4725
4726 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4727 {
4728 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4729 }
4730
4731 hc_thread_mutex_unlock (mux_counter);
4732
4733 continue;
4734 }
4735 }
4736
4737 pw_add (device_param, (u8 *) line_buf, line_len);
4738
4739 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4740
4741 if (data.devices_status == STATUS_CRACKED) break;
4742 if (data.devices_status == STATUS_ABORTED) break;
4743 if (data.devices_status == STATUS_QUIT) break;
4744 if (data.devices_status == STATUS_BYPASS) break;
4745 }
4746
4747 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4748
4749 if (data.devices_status == STATUS_CRACKED) break;
4750 if (data.devices_status == STATUS_ABORTED) break;
4751 if (data.devices_status == STATUS_QUIT) break;
4752 if (data.devices_status == STATUS_BYPASS) break;
4753 }
4754
4755 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4756
4757 if (data.devices_status == STATUS_CRACKED) break;
4758 if (data.devices_status == STATUS_ABORTED) break;
4759 if (data.devices_status == STATUS_QUIT) break;
4760 if (data.devices_status == STATUS_BYPASS) break;
4761
4762 //
4763 // flush
4764 //
4765
4766 const uint pws_cnt = device_param->pws_cnt;
4767
4768 if (pws_cnt)
4769 {
4770 run_copy (device_param, pws_cnt);
4771
4772 run_cracker (device_param, pws_cnt);
4773
4774 device_param->pws_cnt = 0;
4775
4776 if (attack_kern == ATTACK_KERN_STRAIGHT)
4777 {
4778 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4779 }
4780 else if (attack_kern == ATTACK_KERN_COMBI)
4781 {
4782 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4783 }
4784 }
4785
4786 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4787
4788 if (data.devices_status == STATUS_CRACKED) break;
4789 if (data.devices_status == STATUS_ABORTED) break;
4790 if (data.devices_status == STATUS_QUIT) break;
4791 if (data.devices_status == STATUS_BYPASS) break;
4792
4793 if (words_fin == 0) break;
4794
4795 device_param->words_done = words_fin;
4796 }
4797
4798 if (attack_mode == ATTACK_MODE_COMBI)
4799 {
4800 fclose (device_param->combs_fp);
4801 }
4802
4803 free (wl_data->buf);
4804 free (wl_data);
4805
4806 fclose (fd);
4807 }
4808
4809 device_param->kernel_accel = 0;
4810 device_param->kernel_loops = 0;
4811
4812 return NULL;
4813 }
4814
4815 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4816 {
4817 if (!device_param)
4818 {
4819 log_error ("ERROR: %s : Invalid argument", __func__);
4820
4821 exit (-1);
4822 }
4823
4824 salt_t *salt_buf = &data.salts_buf[salt_pos];
4825
4826 device_param->kernel_params_buf32[24] = salt_pos;
4827 device_param->kernel_params_buf32[27] = 1;
4828 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4829 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4830 device_param->kernel_params_buf32[30] = 0;
4831 device_param->kernel_params_buf32[31] = 1;
4832
4833 char *dictfile_old = data.dictfile;
4834
4835 const char *weak_hash_check = "weak-hash-check";
4836
4837 data.dictfile = (char *) weak_hash_check;
4838
4839 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4840
4841 data.kernel_rules_buf[0].cmds[0] = 0;
4842
4843 /**
4844 * run the kernel
4845 */
4846
4847 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4848 {
4849 run_kernel (KERN_RUN_1, device_param, 1, false);
4850 }
4851 else
4852 {
4853 run_kernel (KERN_RUN_1, device_param, 1, false);
4854
4855 uint loop_step = 16;
4856
4857 const uint iter = salt_buf->salt_iter;
4858
4859 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4860 {
4861 uint loop_left = iter - loop_pos;
4862
4863 loop_left = MIN (loop_left, loop_step);
4864
4865 device_param->kernel_params_buf32[25] = loop_pos;
4866 device_param->kernel_params_buf32[26] = loop_left;
4867
4868 run_kernel (KERN_RUN_2, device_param, 1, false);
4869 }
4870
4871 run_kernel (KERN_RUN_3, device_param, 1, false);
4872 }
4873
4874 /**
4875 * result
4876 */
4877
4878 check_cracked (device_param, salt_pos);
4879
4880 /**
4881 * cleanup
4882 */
4883
4884 device_param->kernel_params_buf32[24] = 0;
4885 device_param->kernel_params_buf32[25] = 0;
4886 device_param->kernel_params_buf32[26] = 0;
4887 device_param->kernel_params_buf32[27] = 0;
4888 device_param->kernel_params_buf32[28] = 0;
4889 device_param->kernel_params_buf32[29] = 0;
4890 device_param->kernel_params_buf32[30] = 0;
4891 device_param->kernel_params_buf32[31] = 0;
4892
4893 data.dictfile = dictfile_old;
4894
4895 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4896 }
4897
4898 // hlfmt hashcat
4899
4900 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4901 {
4902 if (data.username == 0)
4903 {
4904 *hashbuf_pos = line_buf;
4905 *hashbuf_len = line_len;
4906 }
4907 else
4908 {
4909 char *pos = line_buf;
4910 int len = line_len;
4911
4912 for (int i = 0; i < line_len; i++, pos++, len--)
4913 {
4914 if (line_buf[i] == data.separator)
4915 {
4916 pos++;
4917
4918 len--;
4919
4920 break;
4921 }
4922 }
4923
4924 *hashbuf_pos = pos;
4925 *hashbuf_len = len;
4926 }
4927 }
4928
4929 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4930 {
4931 char *pos = NULL;
4932 int len = 0;
4933
4934 int sep_cnt = 0;
4935
4936 for (int i = 0; i < line_len; i++)
4937 {
4938 if (line_buf[i] == data.separator)
4939 {
4940 sep_cnt++;
4941
4942 continue;
4943 }
4944
4945 if (sep_cnt == 0)
4946 {
4947 if (pos == NULL) pos = line_buf + i;
4948
4949 len++;
4950 }
4951 }
4952
4953 *userbuf_pos = pos;
4954 *userbuf_len = len;
4955 }
4956
4957 // hlfmt pwdump
4958
4959 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4960 {
4961 int sep_cnt = 0;
4962
4963 int sep2_len = 0;
4964 int sep3_len = 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 == 2) sep2_len++;
4976 if (sep_cnt == 3) sep3_len++;
4977 }
4978
4979 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4980
4981 return 0;
4982 }
4983
4984 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4985 {
4986 char *pos = NULL;
4987 int len = 0;
4988
4989 int sep_cnt = 0;
4990
4991 for (int i = 0; i < line_len; i++)
4992 {
4993 if (line_buf[i] == ':')
4994 {
4995 sep_cnt++;
4996
4997 continue;
4998 }
4999
5000 if (data.hash_mode == 1000)
5001 {
5002 if (sep_cnt == 3)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009 else if (data.hash_mode == 3000)
5010 {
5011 if (sep_cnt == 2)
5012 {
5013 if (pos == NULL) pos = line_buf + i;
5014
5015 len++;
5016 }
5017 }
5018 }
5019
5020 *hashbuf_pos = pos;
5021 *hashbuf_len = len;
5022 }
5023
5024 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5025 {
5026 char *pos = NULL;
5027 int len = 0;
5028
5029 int sep_cnt = 0;
5030
5031 for (int i = 0; i < line_len; i++)
5032 {
5033 if (line_buf[i] == ':')
5034 {
5035 sep_cnt++;
5036
5037 continue;
5038 }
5039
5040 if (sep_cnt == 0)
5041 {
5042 if (pos == NULL) pos = line_buf + i;
5043
5044 len++;
5045 }
5046 }
5047
5048 *userbuf_pos = pos;
5049 *userbuf_len = len;
5050 }
5051
5052 // hlfmt passwd
5053
5054 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5055 {
5056 int sep_cnt = 0;
5057
5058 char sep5_first = 0;
5059 char sep6_first = 0;
5060
5061 for (int i = 0; i < line_len; i++)
5062 {
5063 if (line_buf[i] == ':')
5064 {
5065 sep_cnt++;
5066
5067 continue;
5068 }
5069
5070 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5071 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5072 }
5073
5074 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5075
5076 return 0;
5077 }
5078
5079 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5080 {
5081 char *pos = NULL;
5082 int len = 0;
5083
5084 int sep_cnt = 0;
5085
5086 for (int i = 0; i < line_len; i++)
5087 {
5088 if (line_buf[i] == ':')
5089 {
5090 sep_cnt++;
5091
5092 continue;
5093 }
5094
5095 if (sep_cnt == 1)
5096 {
5097 if (pos == NULL) pos = line_buf + i;
5098
5099 len++;
5100 }
5101 }
5102
5103 *hashbuf_pos = pos;
5104 *hashbuf_len = len;
5105 }
5106
5107 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5108 {
5109 char *pos = NULL;
5110 int len = 0;
5111
5112 int sep_cnt = 0;
5113
5114 for (int i = 0; i < line_len; i++)
5115 {
5116 if (line_buf[i] == ':')
5117 {
5118 sep_cnt++;
5119
5120 continue;
5121 }
5122
5123 if (sep_cnt == 0)
5124 {
5125 if (pos == NULL) pos = line_buf + i;
5126
5127 len++;
5128 }
5129 }
5130
5131 *userbuf_pos = pos;
5132 *userbuf_len = len;
5133 }
5134
5135 // hlfmt shadow
5136
5137 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5138 {
5139 int sep_cnt = 0;
5140
5141 for (int i = 0; i < line_len; i++)
5142 {
5143 if (line_buf[i] == ':') sep_cnt++;
5144 }
5145
5146 if (sep_cnt == 8) return 1;
5147
5148 return 0;
5149 }
5150
5151 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5152 {
5153 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5154 }
5155
5156 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5157 {
5158 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5159 }
5160
5161 // hlfmt main
5162
5163 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5164 {
5165 switch (hashfile_format)
5166 {
5167 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5168 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5169 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5170 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5171 }
5172 }
5173
5174 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5175 {
5176 switch (hashfile_format)
5177 {
5178 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5179 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5180 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5181 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5182 }
5183 }
5184
5185 char *strhlfmt (const uint hashfile_format)
5186 {
5187 switch (hashfile_format)
5188 {
5189 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5190 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5191 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5192 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5193 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5194 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5195 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5196 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5197 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5198 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5199 }
5200
5201 return ((char *) "Unknown");
5202 }
5203
5204 static uint hlfmt_detect (FILE *fp, uint max_check)
5205 {
5206 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5207
5208 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5209 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5210
5211 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5212
5213 uint num_check = 0;
5214
5215 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5216
5217 while (!feof (fp))
5218 {
5219 int line_len = fgetl (fp, line_buf);
5220
5221 if (line_len == 0) continue;
5222
5223 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5224 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5225 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5226
5227 if (num_check == max_check) break;
5228
5229 num_check++;
5230 }
5231
5232 myfree (line_buf);
5233
5234 uint hashlist_format = HLFMT_HASHCAT;
5235
5236 for (int i = 1; i < HLFMTS_CNT; i++)
5237 {
5238 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5239
5240 hashlist_format = i;
5241 }
5242
5243 free (formats_cnt);
5244
5245 return hashlist_format;
5246 }
5247
5248 /**
5249 * some further helper function
5250 */
5251
5252 // wrapper around mymalloc for ADL
5253
5254 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5255 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5256 {
5257 return mymalloc (iSize);
5258 }
5259 #endif
5260
5261 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)
5262 {
5263 u64 collisions = 0;
5264
5265 const uint dgst_pos0 = data.dgst_pos0;
5266 const uint dgst_pos1 = data.dgst_pos1;
5267 const uint dgst_pos2 = data.dgst_pos2;
5268 const uint dgst_pos3 = data.dgst_pos3;
5269
5270 memset (bitmap_a, 0, bitmap_size);
5271 memset (bitmap_b, 0, bitmap_size);
5272 memset (bitmap_c, 0, bitmap_size);
5273 memset (bitmap_d, 0, bitmap_size);
5274
5275 for (uint i = 0; i < digests_cnt; i++)
5276 {
5277 uint *digest_ptr = (uint *) digests_buf_ptr;
5278
5279 digests_buf_ptr += dgst_size;
5280
5281 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5282 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5283 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5284 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5285
5286 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5287 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5288 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5289 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5290
5291 if (bitmap_a[idx0] & val0) collisions++;
5292 if (bitmap_b[idx1] & val1) collisions++;
5293 if (bitmap_c[idx2] & val2) collisions++;
5294 if (bitmap_d[idx3] & val3) collisions++;
5295
5296 bitmap_a[idx0] |= val0;
5297 bitmap_b[idx1] |= val1;
5298 bitmap_c[idx2] |= val2;
5299 bitmap_d[idx3] |= val3;
5300
5301 if (collisions >= collisions_max) return 0x7fffffff;
5302 }
5303
5304 return collisions;
5305 }
5306
5307 /**
5308 * main
5309 */
5310
5311 int main (int argc, char **argv)
5312 {
5313 /**
5314 * To help users a bit
5315 */
5316
5317 char *compute = getenv ("COMPUTE");
5318
5319 if (compute)
5320 {
5321 static char display[100];
5322
5323 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5324
5325 putenv (display);
5326 }
5327 else
5328 {
5329 if (getenv ("DISPLAY") == NULL)
5330 putenv ((char *) "DISPLAY=:0");
5331 }
5332
5333 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5334 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5335
5336 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5337 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5338
5339 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5340 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5341
5342 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5343 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5344
5345 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5346 putenv ((char *) "POCL_KERNEL_CACHE=0");
5347
5348 /**
5349 * Real init
5350 */
5351
5352 memset (&data, 0, sizeof (hc_global_data_t));
5353
5354 time_t proc_start;
5355
5356 time (&proc_start);
5357
5358 data.proc_start = proc_start;
5359
5360 int myargc = argc;
5361 char **myargv = argv;
5362
5363 hc_thread_mutex_init (mux_dispatcher);
5364 hc_thread_mutex_init (mux_counter);
5365 hc_thread_mutex_init (mux_display);
5366 hc_thread_mutex_init (mux_adl);
5367
5368 /**
5369 * commandline parameters
5370 */
5371
5372 uint usage = USAGE;
5373 uint version = VERSION;
5374 uint quiet = QUIET;
5375 uint benchmark = BENCHMARK;
5376 uint benchmark_repeats = BENCHMARK_REPEATS;
5377 uint show = SHOW;
5378 uint left = LEFT;
5379 uint username = USERNAME;
5380 uint remove = REMOVE;
5381 uint remove_timer = REMOVE_TIMER;
5382 u64 skip = SKIP;
5383 u64 limit = LIMIT;
5384 uint keyspace = KEYSPACE;
5385 uint potfile_disable = POTFILE_DISABLE;
5386 char *potfile_path = NULL;
5387 uint debug_mode = DEBUG_MODE;
5388 char *debug_file = NULL;
5389 char *induction_dir = NULL;
5390 char *outfile_check_dir = NULL;
5391 uint force = FORCE;
5392 uint runtime = RUNTIME;
5393 uint hash_mode = HASH_MODE;
5394 uint attack_mode = ATTACK_MODE;
5395 uint markov_disable = MARKOV_DISABLE;
5396 uint markov_classic = MARKOV_CLASSIC;
5397 uint markov_threshold = MARKOV_THRESHOLD;
5398 char *markov_hcstat = NULL;
5399 char *outfile = NULL;
5400 uint outfile_format = OUTFILE_FORMAT;
5401 uint outfile_autohex = OUTFILE_AUTOHEX;
5402 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5403 uint restore = RESTORE;
5404 uint restore_timer = RESTORE_TIMER;
5405 uint restore_disable = RESTORE_DISABLE;
5406 uint status = STATUS;
5407 uint status_timer = STATUS_TIMER;
5408 uint status_automat = STATUS_AUTOMAT;
5409 uint loopback = LOOPBACK;
5410 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5411 char *session = NULL;
5412 uint hex_charset = HEX_CHARSET;
5413 uint hex_salt = HEX_SALT;
5414 uint hex_wordlist = HEX_WORDLIST;
5415 uint rp_gen = RP_GEN;
5416 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5417 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5418 uint rp_gen_seed = RP_GEN_SEED;
5419 char *rule_buf_l = (char *) RULE_BUF_L;
5420 char *rule_buf_r = (char *) RULE_BUF_R;
5421 uint increment = INCREMENT;
5422 uint increment_min = INCREMENT_MIN;
5423 uint increment_max = INCREMENT_MAX;
5424 char *cpu_affinity = NULL;
5425 OCL_PTR *ocl = NULL;
5426 char *opencl_devices = NULL;
5427 char *opencl_platforms = NULL;
5428 char *opencl_device_types = NULL;
5429 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5430 char *truecrypt_keyfiles = NULL;
5431 uint workload_profile = WORKLOAD_PROFILE;
5432 uint kernel_accel = KERNEL_ACCEL;
5433 uint kernel_loops = KERNEL_LOOPS;
5434 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5435 #ifdef HAVE_HWMON
5436 uint gpu_temp_abort = GPU_TEMP_ABORT;
5437 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5438 #ifdef HAVE_ADL
5439 uint powertune_enable = POWERTUNE_ENABLE;
5440 #endif
5441 #endif
5442 uint logfile_disable = LOGFILE_DISABLE;
5443 uint segment_size = SEGMENT_SIZE;
5444 uint scrypt_tmto = SCRYPT_TMTO;
5445 char separator = SEPARATOR;
5446 uint bitmap_min = BITMAP_MIN;
5447 uint bitmap_max = BITMAP_MAX;
5448 char *custom_charset_1 = NULL;
5449 char *custom_charset_2 = NULL;
5450 char *custom_charset_3 = NULL;
5451 char *custom_charset_4 = NULL;
5452
5453 #define IDX_HELP 'h'
5454 #define IDX_VERSION 'V'
5455 #define IDX_VERSION_LOWER 'v'
5456 #define IDX_QUIET 0xff02
5457 #define IDX_SHOW 0xff03
5458 #define IDX_LEFT 0xff04
5459 #define IDX_REMOVE 0xff05
5460 #define IDX_REMOVE_TIMER 0xff37
5461 #define IDX_SKIP 's'
5462 #define IDX_LIMIT 'l'
5463 #define IDX_KEYSPACE 0xff35
5464 #define IDX_POTFILE_DISABLE 0xff06
5465 #define IDX_POTFILE_PATH 0xffe0
5466 #define IDX_DEBUG_MODE 0xff43
5467 #define IDX_DEBUG_FILE 0xff44
5468 #define IDX_INDUCTION_DIR 0xff46
5469 #define IDX_OUTFILE_CHECK_DIR 0xff47
5470 #define IDX_USERNAME 0xff07
5471 #define IDX_FORCE 0xff08
5472 #define IDX_RUNTIME 0xff09
5473 #define IDX_BENCHMARK 'b'
5474 #define IDX_BENCHMARK_REPEATS 0xff78
5475 #define IDX_HASH_MODE 'm'
5476 #define IDX_ATTACK_MODE 'a'
5477 #define IDX_RP_FILE 'r'
5478 #define IDX_RP_GEN 'g'
5479 #define IDX_RP_GEN_FUNC_MIN 0xff10
5480 #define IDX_RP_GEN_FUNC_MAX 0xff11
5481 #define IDX_RP_GEN_SEED 0xff34
5482 #define IDX_RULE_BUF_L 'j'
5483 #define IDX_RULE_BUF_R 'k'
5484 #define IDX_INCREMENT 'i'
5485 #define IDX_INCREMENT_MIN 0xff12
5486 #define IDX_INCREMENT_MAX 0xff13
5487 #define IDX_OUTFILE 'o'
5488 #define IDX_OUTFILE_FORMAT 0xff14
5489 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5490 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5491 #define IDX_RESTORE 0xff15
5492 #define IDX_RESTORE_DISABLE 0xff27
5493 #define IDX_STATUS 0xff17
5494 #define IDX_STATUS_TIMER 0xff18
5495 #define IDX_STATUS_AUTOMAT 0xff50
5496 #define IDX_LOOPBACK 0xff38
5497 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5498 #define IDX_SESSION 0xff19
5499 #define IDX_HEX_CHARSET 0xff20
5500 #define IDX_HEX_SALT 0xff21
5501 #define IDX_HEX_WORDLIST 0xff40
5502 #define IDX_MARKOV_DISABLE 0xff22
5503 #define IDX_MARKOV_CLASSIC 0xff23
5504 #define IDX_MARKOV_THRESHOLD 't'
5505 #define IDX_MARKOV_HCSTAT 0xff24
5506 #define IDX_CPU_AFFINITY 0xff25
5507 #define IDX_OPENCL_DEVICES 'd'
5508 #define IDX_OPENCL_PLATFORMS 0xff72
5509 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5510 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5511 #define IDX_WORKLOAD_PROFILE 'w'
5512 #define IDX_KERNEL_ACCEL 'n'
5513 #define IDX_KERNEL_LOOPS 'u'
5514 #define IDX_GPU_TEMP_DISABLE 0xff29
5515 #define IDX_GPU_TEMP_ABORT 0xff30
5516 #define IDX_GPU_TEMP_RETAIN 0xff31
5517 #define IDX_POWERTUNE_ENABLE 0xff41
5518 #define IDX_LOGFILE_DISABLE 0xff51
5519 #define IDX_TRUECRYPT_KEYFILES 0xff52
5520 #define IDX_SCRYPT_TMTO 0xff61
5521 #define IDX_SEGMENT_SIZE 'c'
5522 #define IDX_SEPARATOR 'p'
5523 #define IDX_BITMAP_MIN 0xff70
5524 #define IDX_BITMAP_MAX 0xff71
5525 #define IDX_CUSTOM_CHARSET_1 '1'
5526 #define IDX_CUSTOM_CHARSET_2 '2'
5527 #define IDX_CUSTOM_CHARSET_3 '3'
5528 #define IDX_CUSTOM_CHARSET_4 '4'
5529
5530 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5531
5532 struct option long_options[] =
5533 {
5534 {"help", no_argument, 0, IDX_HELP},
5535 {"version", no_argument, 0, IDX_VERSION},
5536 {"quiet", no_argument, 0, IDX_QUIET},
5537 {"show", no_argument, 0, IDX_SHOW},
5538 {"left", no_argument, 0, IDX_LEFT},
5539 {"username", no_argument, 0, IDX_USERNAME},
5540 {"remove", no_argument, 0, IDX_REMOVE},
5541 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5542 {"skip", required_argument, 0, IDX_SKIP},
5543 {"limit", required_argument, 0, IDX_LIMIT},
5544 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5545 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5546 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5547 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5548 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5549 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5550 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5551 {"force", no_argument, 0, IDX_FORCE},
5552 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5553 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5554 {"restore", no_argument, 0, IDX_RESTORE},
5555 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5556 {"status", no_argument, 0, IDX_STATUS},
5557 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5558 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5559 {"loopback", no_argument, 0, IDX_LOOPBACK},
5560 {"weak-hash-threshold",
5561 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5562 {"session", required_argument, 0, IDX_SESSION},
5563 {"runtime", required_argument, 0, IDX_RUNTIME},
5564 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5565 {"generate-rules-func-min",
5566 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5567 {"generate-rules-func-max",
5568 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5569 {"generate-rules-seed",
5570 required_argument, 0, IDX_RP_GEN_SEED},
5571 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5572 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5573 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5574 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5575 {"rules-file", required_argument, 0, IDX_RP_FILE},
5576 {"outfile", required_argument, 0, IDX_OUTFILE},
5577 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5578 {"outfile-autohex-disable",
5579 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5580 {"outfile-check-timer",
5581 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5582 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5583 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5584 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5585 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5586 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5587 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5588 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5589 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5590 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5591 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5592 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5593 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5594 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5595 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5596 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5597 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5598 #ifdef HAVE_HWMON
5599 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5600 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5601 #ifdef HAVE_ADL
5602 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5603 #endif
5604 #endif // HAVE_HWMON
5605 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5606 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5607 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5608 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5609 // deprecated
5610 {"seperator", required_argument, 0, IDX_SEPARATOR},
5611 {"separator", required_argument, 0, IDX_SEPARATOR},
5612 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5613 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5614 {"increment", no_argument, 0, IDX_INCREMENT},
5615 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5616 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5617 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5618 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5619 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5620 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5621
5622 {0, 0, 0, 0}
5623 };
5624
5625 uint rp_files_cnt = 0;
5626
5627 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5628
5629 int option_index = 0;
5630 int c = -1;
5631
5632 optind = 1;
5633 optopt = 0;
5634
5635 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5636 {
5637 switch (c)
5638 {
5639 case IDX_HELP: usage = 1; break;
5640 case IDX_VERSION:
5641 case IDX_VERSION_LOWER: version = 1; break;
5642 case IDX_RESTORE: restore = 1; break;
5643 case IDX_SESSION: session = optarg; break;
5644 case IDX_SHOW: show = 1; break;
5645 case IDX_LEFT: left = 1; break;
5646 case '?': return (-1);
5647 }
5648 }
5649
5650 if (optopt != 0)
5651 {
5652 log_error ("ERROR: Invalid argument specified");
5653
5654 return (-1);
5655 }
5656
5657 /**
5658 * exit functions
5659 */
5660
5661 if (version)
5662 {
5663 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5664
5665 return (0);
5666 }
5667
5668 if (usage)
5669 {
5670 usage_big_print (PROGNAME);
5671
5672 return (0);
5673 }
5674
5675 /**
5676 * session needs to be set, always!
5677 */
5678
5679 if (session == NULL) session = (char *) PROGNAME;
5680
5681 /**
5682 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5683 */
5684
5685 char *exec_path = get_exec_path ();
5686
5687 #ifdef LINUX
5688
5689 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5690 char *resolved_exec_path = realpath (exec_path, NULL);
5691
5692 char *install_dir = get_install_dir (resolved_exec_path);
5693 char *profile_dir = NULL;
5694 char *session_dir = NULL;
5695 char *shared_dir = NULL;
5696
5697 if (strcmp (install_dir, resolved_install_folder) == 0)
5698 {
5699 struct passwd *pw = getpwuid (getuid ());
5700
5701 const char *homedir = pw->pw_dir;
5702
5703 profile_dir = get_profile_dir (homedir);
5704 session_dir = get_session_dir (profile_dir);
5705 shared_dir = strdup (SHARED_FOLDER);
5706
5707 mkdir (profile_dir, 0700);
5708 mkdir (session_dir, 0700);
5709 }
5710 else
5711 {
5712 profile_dir = install_dir;
5713 session_dir = install_dir;
5714 shared_dir = install_dir;
5715 }
5716
5717 myfree (resolved_install_folder);
5718 myfree (resolved_exec_path);
5719
5720 #else
5721
5722 char *install_dir = get_install_dir (exec_path);
5723 char *profile_dir = install_dir;
5724 char *session_dir = install_dir;
5725 char *shared_dir = install_dir;
5726
5727 #endif
5728
5729 data.install_dir = install_dir;
5730 data.profile_dir = profile_dir;
5731 data.session_dir = session_dir;
5732 data.shared_dir = shared_dir;
5733
5734 myfree (exec_path);
5735
5736 /**
5737 * kernel cache, we need to make sure folder exist
5738 */
5739
5740 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5741
5742 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5743
5744 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5745
5746 mkdir (kernels_folder, 0700);
5747
5748 myfree (kernels_folder);
5749
5750 /**
5751 * session
5752 */
5753
5754 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5755
5756 data.session = session;
5757
5758 char *eff_restore_file = (char *) mymalloc (session_size);
5759 char *new_restore_file = (char *) mymalloc (session_size);
5760
5761 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5762 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5763
5764 data.eff_restore_file = eff_restore_file;
5765 data.new_restore_file = new_restore_file;
5766
5767 if (((show == 1) || (left == 1)) && (restore == 1))
5768 {
5769 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5770 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5771
5772 return (-1);
5773 }
5774
5775 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5776 if ((show == 1) || (left == 1))
5777 {
5778 restore_disable = 1;
5779
5780 restore = 0;
5781 }
5782
5783 data.restore_disable = restore_disable;
5784
5785 restore_data_t *rd = init_restore (argc, argv);
5786
5787 data.rd = rd;
5788
5789 /**
5790 * restore file
5791 */
5792
5793 if (restore == 1)
5794 {
5795 read_restore (eff_restore_file, rd);
5796
5797 if (rd->version_bin < RESTORE_MIN)
5798 {
5799 log_error ("ERROR: Incompatible restore-file version");
5800
5801 return (-1);
5802 }
5803
5804 myargc = rd->argc;
5805 myargv = rd->argv;
5806
5807 #ifdef _POSIX
5808 rd->pid = getpid ();
5809 #elif _WIN
5810 rd->pid = GetCurrentProcessId ();
5811 #endif
5812 }
5813
5814 uint hash_mode_chgd = 0;
5815 uint runtime_chgd = 0;
5816 uint kernel_loops_chgd = 0;
5817 uint kernel_accel_chgd = 0;
5818 uint attack_mode_chgd = 0;
5819 uint outfile_format_chgd = 0;
5820 uint rp_gen_seed_chgd = 0;
5821 uint remove_timer_chgd = 0;
5822 uint increment_min_chgd = 0;
5823 uint increment_max_chgd = 0;
5824 uint workload_profile_chgd = 0;
5825 uint opencl_vector_width_chgd = 0;
5826
5827 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5828 uint gpu_temp_retain_chgd = 0;
5829 uint gpu_temp_abort_chgd = 0;
5830 #endif
5831
5832 optind = 1;
5833 optopt = 0;
5834 option_index = 0;
5835
5836 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5837 {
5838 switch (c)
5839 {
5840 //case IDX_HELP: usage = 1; break;
5841 //case IDX_VERSION: version = 1; break;
5842 //case IDX_RESTORE: restore = 1; break;
5843 case IDX_QUIET: quiet = 1; break;
5844 //case IDX_SHOW: show = 1; break;
5845 case IDX_SHOW: break;
5846 //case IDX_LEFT: left = 1; break;
5847 case IDX_LEFT: break;
5848 case IDX_USERNAME: username = 1; break;
5849 case IDX_REMOVE: remove = 1; break;
5850 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5851 remove_timer_chgd = 1; break;
5852 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5853 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5854 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5855 case IDX_DEBUG_FILE: debug_file = optarg; break;
5856 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5857 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5858 case IDX_FORCE: force = 1; break;
5859 case IDX_SKIP: skip = atoll (optarg); break;
5860 case IDX_LIMIT: limit = atoll (optarg); break;
5861 case IDX_KEYSPACE: keyspace = 1; break;
5862 case IDX_BENCHMARK: benchmark = 1; break;
5863 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5864 case IDX_RESTORE: break;
5865 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5866 case IDX_STATUS: status = 1; break;
5867 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5868 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5869 case IDX_LOOPBACK: loopback = 1; break;
5870 case IDX_WEAK_HASH_THRESHOLD:
5871 weak_hash_threshold = atoi (optarg); break;
5872 //case IDX_SESSION: session = optarg; break;
5873 case IDX_SESSION: break;
5874 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5875 hash_mode_chgd = 1; break;
5876 case IDX_RUNTIME: runtime = atoi (optarg);
5877 runtime_chgd = 1; break;
5878 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5879 attack_mode_chgd = 1; break;
5880 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5881 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5882 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5883 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5884 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5885 rp_gen_seed_chgd = 1; break;
5886 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5887 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5888 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5889 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5890 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5891 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5892 case IDX_OUTFILE: outfile = optarg; break;
5893 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5894 outfile_format_chgd = 1; break;
5895 case IDX_OUTFILE_AUTOHEX_DISABLE:
5896 outfile_autohex = 0; break;
5897 case IDX_OUTFILE_CHECK_TIMER:
5898 outfile_check_timer = atoi (optarg); break;
5899 case IDX_HEX_CHARSET: hex_charset = 1; break;
5900 case IDX_HEX_SALT: hex_salt = 1; break;
5901 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5902 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5903 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5904 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5905 case IDX_OPENCL_DEVICE_TYPES:
5906 opencl_device_types = optarg; break;
5907 case IDX_OPENCL_VECTOR_WIDTH:
5908 opencl_vector_width = atoi (optarg);
5909 opencl_vector_width_chgd = 1; break;
5910 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5911 workload_profile_chgd = 1; break;
5912 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5913 kernel_accel_chgd = 1; break;
5914 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5915 kernel_loops_chgd = 1; break;
5916 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5917 #ifdef HAVE_HWMON
5918 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5919 #ifdef HAVE_ADL
5920 gpu_temp_abort_chgd = 1;
5921 #endif
5922 break;
5923 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5924 #ifdef HAVE_ADL
5925 gpu_temp_retain_chgd = 1;
5926 #endif
5927 break;
5928 #ifdef HAVE_ADL
5929 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5930 #endif
5931 #endif // HAVE_HWMON
5932 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5933 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5934 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5935 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5936 case IDX_SEPARATOR: separator = optarg[0]; break;
5937 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5938 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5939 case IDX_INCREMENT: increment = 1; break;
5940 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5941 increment_min_chgd = 1; break;
5942 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5943 increment_max_chgd = 1; break;
5944 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5945 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5946 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5947 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5948
5949 default:
5950 log_error ("ERROR: Invalid argument specified");
5951 return (-1);
5952 }
5953 }
5954
5955 if (optopt != 0)
5956 {
5957 log_error ("ERROR: Invalid argument specified");
5958
5959 return (-1);
5960 }
5961
5962 /**
5963 * Inform user things getting started,
5964 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5965 * - we do not need to check algorithm_pos
5966 */
5967
5968 if (quiet == 0)
5969 {
5970 if (benchmark == 1)
5971 {
5972 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5973
5974 log_info ("");
5975 }
5976 else if (restore == 1)
5977 {
5978 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5979
5980 log_info ("");
5981 }
5982 else
5983 {
5984 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5985
5986 log_info ("");
5987 }
5988 }
5989
5990 /**
5991 * sanity check
5992 */
5993
5994 if (attack_mode > 7)
5995 {
5996 log_error ("ERROR: Invalid attack-mode specified");
5997
5998 return (-1);
5999 }
6000
6001 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6002 {
6003 log_error ("ERROR: Invalid runtime specified");
6004
6005 return (-1);
6006 }
6007
6008 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
6009 {
6010 log_error ("ERROR: Invalid hash-type specified");
6011
6012 return (-1);
6013 }
6014
6015 // renamed hash modes
6016
6017 if (hash_mode_chgd)
6018 {
6019 int n = -1;
6020
6021 switch (hash_mode)
6022 {
6023 case 123: n = 124;
6024 break;
6025 }
6026
6027 if (n >= 0)
6028 {
6029 log_error ("Old -m specified, use -m %d instead", n);
6030
6031 return (-1);
6032 }
6033 }
6034
6035 if (username == 1)
6036 {
6037 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6038 {
6039 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6040
6041 return (-1);
6042 }
6043 }
6044
6045 if (outfile_format > 16)
6046 {
6047 log_error ("ERROR: Invalid outfile-format specified");
6048
6049 return (-1);
6050 }
6051
6052 if (left == 1)
6053 {
6054 if (outfile_format_chgd == 1)
6055 {
6056 if (outfile_format > 1)
6057 {
6058 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6059
6060 return (-1);
6061 }
6062 }
6063 else
6064 {
6065 outfile_format = OUTFILE_FMT_HASH;
6066 }
6067 }
6068
6069 if (show == 1)
6070 {
6071 if (outfile_format_chgd == 1)
6072 {
6073 if ((outfile_format > 7) && (outfile_format < 16))
6074 {
6075 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6076
6077 return (-1);
6078 }
6079 }
6080 }
6081
6082 if (increment_min < INCREMENT_MIN)
6083 {
6084 log_error ("ERROR: Invalid increment-min specified");
6085
6086 return (-1);
6087 }
6088
6089 if (increment_max > INCREMENT_MAX)
6090 {
6091 log_error ("ERROR: Invalid increment-max specified");
6092
6093 return (-1);
6094 }
6095
6096 if (increment_min > increment_max)
6097 {
6098 log_error ("ERROR: Invalid increment-min specified");
6099
6100 return (-1);
6101 }
6102
6103 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6104 {
6105 log_error ("ERROR: increment is not allowed in attack-mode 0");
6106
6107 return (-1);
6108 }
6109
6110 if ((increment == 0) && (increment_min_chgd == 1))
6111 {
6112 log_error ("ERROR: increment-min is only supported together with increment switch");
6113
6114 return (-1);
6115 }
6116
6117 if ((increment == 0) && (increment_max_chgd == 1))
6118 {
6119 log_error ("ERROR: increment-max is only supported together with increment switch");
6120
6121 return (-1);
6122 }
6123
6124 if (rp_files_cnt && rp_gen)
6125 {
6126 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6127
6128 return (-1);
6129 }
6130
6131 if (rp_files_cnt || rp_gen)
6132 {
6133 if (attack_mode != ATTACK_MODE_STRAIGHT)
6134 {
6135 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6136
6137 return (-1);
6138 }
6139 }
6140
6141 if (rp_gen_func_min > rp_gen_func_max)
6142 {
6143 log_error ("ERROR: Invalid rp-gen-func-min specified");
6144
6145 return (-1);
6146 }
6147
6148 if (kernel_accel_chgd == 1)
6149 {
6150 if (kernel_accel < 1)
6151 {
6152 log_error ("ERROR: Invalid kernel-accel specified");
6153
6154 return (-1);
6155 }
6156
6157 if (kernel_accel > 1024)
6158 {
6159 log_error ("ERROR: Invalid kernel-accel specified");
6160
6161 return (-1);
6162 }
6163 }
6164
6165 if (kernel_loops_chgd == 1)
6166 {
6167 if (kernel_loops < 1)
6168 {
6169 log_error ("ERROR: Invalid kernel-loops specified");
6170
6171 return (-1);
6172 }
6173
6174 if (kernel_loops > 1024)
6175 {
6176 log_error ("ERROR: Invalid kernel-loops specified");
6177
6178 return (-1);
6179 }
6180 }
6181
6182 if ((workload_profile < 1) || (workload_profile > 3))
6183 {
6184 log_error ("ERROR: workload-profile %i not available", workload_profile);
6185
6186 return (-1);
6187 }
6188
6189 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6190 {
6191 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6192
6193 return (-1);
6194 }
6195
6196 if (show == 1 || left == 1)
6197 {
6198 attack_mode = ATTACK_MODE_NONE;
6199
6200 if (remove == 1)
6201 {
6202 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6203
6204 return (-1);
6205 }
6206
6207 if (potfile_disable == 1)
6208 {
6209 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6210
6211 return (-1);
6212 }
6213 }
6214
6215 uint attack_kern = ATTACK_KERN_NONE;
6216
6217 switch (attack_mode)
6218 {
6219 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6220 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6221 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6222 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6223 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6224 }
6225
6226 if (benchmark == 0)
6227 {
6228 if (keyspace == 1)
6229 {
6230 int num_additional_params = 1;
6231
6232 if (attack_kern == ATTACK_KERN_COMBI)
6233 {
6234 num_additional_params = 2;
6235 }
6236
6237 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6238
6239 if (keyspace_wordlist_specified == 0) optind--;
6240 }
6241
6242 if (attack_kern == ATTACK_KERN_NONE)
6243 {
6244 if ((optind + 1) != myargc)
6245 {
6246 usage_mini_print (myargv[0]);
6247
6248 return (-1);
6249 }
6250 }
6251 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6252 {
6253 if ((optind + 1) > myargc)
6254 {
6255 usage_mini_print (myargv[0]);
6256
6257 return (-1);
6258 }
6259 }
6260 else if (attack_kern == ATTACK_KERN_COMBI)
6261 {
6262 if ((optind + 3) != myargc)
6263 {
6264 usage_mini_print (myargv[0]);
6265
6266 return (-1);
6267 }
6268 }
6269 else if (attack_kern == ATTACK_KERN_BF)
6270 {
6271 if ((optind + 1) > myargc)
6272 {
6273 usage_mini_print (myargv[0]);
6274
6275 return (-1);
6276 }
6277 }
6278 else
6279 {
6280 usage_mini_print (myargv[0]);
6281
6282 return (-1);
6283 }
6284 }
6285 else
6286 {
6287 if (myargv[optind] != 0)
6288 {
6289 log_error ("ERROR: Invalid argument for benchmark mode specified");
6290
6291 return (-1);
6292 }
6293
6294 if (attack_mode_chgd == 1)
6295 {
6296 if (attack_mode != ATTACK_MODE_BF)
6297 {
6298 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6299
6300 return (-1);
6301 }
6302 }
6303 }
6304
6305 if (skip != 0 && limit != 0)
6306 {
6307 limit += skip;
6308 }
6309
6310 if (keyspace == 1)
6311 {
6312 if (show == 1)
6313 {
6314 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6315
6316 return (-1);
6317 }
6318 else if (left == 1)
6319 {
6320 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6321
6322 return (-1);
6323 }
6324
6325 potfile_disable = 1;
6326
6327 restore_disable = 1;
6328
6329 restore = 0;
6330
6331 weak_hash_threshold = 0;
6332
6333 quiet = 1;
6334 }
6335
6336 if (remove_timer_chgd == 1)
6337 {
6338 if (remove == 0)
6339 {
6340 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6341
6342 return (-1);
6343 }
6344
6345 if (remove_timer < 1)
6346 {
6347 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 if (loopback == 1)
6354 {
6355 if (attack_mode == ATTACK_MODE_STRAIGHT)
6356 {
6357 if ((rp_files_cnt == 0) && (rp_gen == 0))
6358 {
6359 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6360
6361 return (-1);
6362 }
6363 }
6364 else
6365 {
6366 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6367
6368 return (-1);
6369 }
6370 }
6371
6372 if (debug_mode > 0)
6373 {
6374 if (attack_mode != ATTACK_MODE_STRAIGHT)
6375 {
6376 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6377
6378 return (-1);
6379 }
6380
6381 if ((rp_files_cnt == 0) && (rp_gen == 0))
6382 {
6383 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6384
6385 return (-1);
6386 }
6387 }
6388
6389 if (debug_mode > 4)
6390 {
6391 log_error ("ERROR: Invalid debug-mode specified");
6392
6393 return (-1);
6394 }
6395
6396 if (debug_file != NULL)
6397 {
6398 if (debug_mode < 1)
6399 {
6400 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6401
6402 return (-1);
6403 }
6404 }
6405
6406 if (induction_dir != NULL)
6407 {
6408 if (attack_mode == ATTACK_MODE_BF)
6409 {
6410 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6411
6412 return (-1);
6413 }
6414 }
6415
6416 if (attack_mode != ATTACK_MODE_STRAIGHT)
6417 {
6418 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6419 {
6420 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6421
6422 return (-1);
6423 }
6424
6425 weak_hash_threshold = 0;
6426 }
6427
6428 /**
6429 * induction directory
6430 */
6431
6432 char *induction_directory = NULL;
6433
6434 if (attack_mode != ATTACK_MODE_BF)
6435 {
6436 if (induction_dir == NULL)
6437 {
6438 induction_directory = (char *) mymalloc (session_size);
6439
6440 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6441
6442 // create induction folder if it does not already exist
6443
6444 if (keyspace == 0)
6445 {
6446 if (rmdir (induction_directory) == -1)
6447 {
6448 if (errno == ENOENT)
6449 {
6450 // good, we can ignore
6451 }
6452 else if (errno == ENOTEMPTY)
6453 {
6454 char *induction_directory_mv = (char *) mymalloc (session_size);
6455
6456 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6457
6458 if (rename (induction_directory, induction_directory_mv) != 0)
6459 {
6460 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6461
6462 return (-1);
6463 }
6464 }
6465 else
6466 {
6467 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6468
6469 return (-1);
6470 }
6471 }
6472
6473 if (mkdir (induction_directory, 0700) == -1)
6474 {
6475 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6476
6477 return (-1);
6478 }
6479 }
6480 }
6481 else
6482 {
6483 induction_directory = induction_dir;
6484 }
6485 }
6486
6487 data.induction_directory = induction_directory;
6488
6489 /**
6490 * loopback
6491 */
6492
6493 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6494
6495 char *loopback_file = (char *) mymalloc (loopback_size);
6496
6497 /**
6498 * tuning db
6499 */
6500
6501 char tuning_db_file[256] = { 0 };
6502
6503 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6504
6505 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6506
6507 /**
6508 * outfile-check directory
6509 */
6510
6511 char *outfile_check_directory = NULL;
6512
6513 if (outfile_check_dir == NULL)
6514 {
6515 outfile_check_directory = (char *) mymalloc (session_size);
6516
6517 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6518 }
6519 else
6520 {
6521 outfile_check_directory = outfile_check_dir;
6522 }
6523
6524 data.outfile_check_directory = outfile_check_directory;
6525
6526 if (keyspace == 0)
6527 {
6528 struct stat outfile_check_stat;
6529
6530 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6531 {
6532 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6533
6534 if (is_dir == 0)
6535 {
6536 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6537
6538 return (-1);
6539 }
6540 }
6541 else if (outfile_check_dir == NULL)
6542 {
6543 if (mkdir (outfile_check_directory, 0700) == -1)
6544 {
6545 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6546
6547 return (-1);
6548 }
6549 }
6550 }
6551
6552 /**
6553 * special other stuff
6554 */
6555
6556 if (hash_mode == 9710)
6557 {
6558 outfile_format = 5;
6559 outfile_format_chgd = 1;
6560 }
6561
6562 if (hash_mode == 9810)
6563 {
6564 outfile_format = 5;
6565 outfile_format_chgd = 1;
6566 }
6567
6568 if (hash_mode == 10410)
6569 {
6570 outfile_format = 5;
6571 outfile_format_chgd = 1;
6572 }
6573
6574 /**
6575 * store stuff
6576 */
6577
6578 data.hash_mode = hash_mode;
6579 data.restore = restore;
6580 data.restore_timer = restore_timer;
6581 data.restore_disable = restore_disable;
6582 data.status = status;
6583 data.status_timer = status_timer;
6584 data.status_automat = status_automat;
6585 data.loopback = loopback;
6586 data.runtime = runtime;
6587 data.remove = remove;
6588 data.remove_timer = remove_timer;
6589 data.debug_mode = debug_mode;
6590 data.debug_file = debug_file;
6591 data.username = username;
6592 data.quiet = quiet;
6593 data.outfile = outfile;
6594 data.outfile_format = outfile_format;
6595 data.outfile_autohex = outfile_autohex;
6596 data.hex_charset = hex_charset;
6597 data.hex_salt = hex_salt;
6598 data.hex_wordlist = hex_wordlist;
6599 data.separator = separator;
6600 data.rp_files = rp_files;
6601 data.rp_files_cnt = rp_files_cnt;
6602 data.rp_gen = rp_gen;
6603 data.rp_gen_seed = rp_gen_seed;
6604 data.force = force;
6605 data.benchmark = benchmark;
6606 data.benchmark_repeats = benchmark_repeats;
6607 data.skip = skip;
6608 data.limit = limit;
6609 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6610 data.powertune_enable = powertune_enable;
6611 #endif
6612 data.logfile_disable = logfile_disable;
6613 data.truecrypt_keyfiles = truecrypt_keyfiles;
6614 data.scrypt_tmto = scrypt_tmto;
6615 data.workload_profile = workload_profile;
6616
6617 /**
6618 * cpu affinity
6619 */
6620
6621 if (cpu_affinity)
6622 {
6623 set_cpu_affinity (cpu_affinity);
6624 }
6625
6626 if (rp_gen_seed_chgd == 0)
6627 {
6628 srand (proc_start);
6629 }
6630 else
6631 {
6632 srand (rp_gen_seed);
6633 }
6634
6635 /**
6636 * logfile init
6637 */
6638
6639 if (logfile_disable == 0)
6640 {
6641 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6642
6643 char *logfile = (char *) mymalloc (logfile_size);
6644
6645 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6646
6647 data.logfile = logfile;
6648
6649 char *topid = logfile_generate_topid ();
6650
6651 data.topid = topid;
6652 }
6653
6654 // logfile_append() checks for logfile_disable internally to make it easier from here
6655
6656 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6657 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6658 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6659 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6660 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6661 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6662 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6663 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6664 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6665 #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));
6666
6667 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6668 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6669 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6670 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6671 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6672 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6673 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6674 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6675
6676 logfile_top_msg ("START");
6677
6678 logfile_top_uint (attack_mode);
6679 logfile_top_uint (attack_kern);
6680 logfile_top_uint (benchmark);
6681 logfile_top_uint (benchmark_repeats);
6682 logfile_top_uint (bitmap_min);
6683 logfile_top_uint (bitmap_max);
6684 logfile_top_uint (debug_mode);
6685 logfile_top_uint (force);
6686 logfile_top_uint (kernel_accel);
6687 logfile_top_uint (kernel_loops);
6688 logfile_top_uint (gpu_temp_disable);
6689 #ifdef HAVE_HWMON
6690 logfile_top_uint (gpu_temp_abort);
6691 logfile_top_uint (gpu_temp_retain);
6692 #endif
6693 logfile_top_uint (hash_mode);
6694 logfile_top_uint (hex_charset);
6695 logfile_top_uint (hex_salt);
6696 logfile_top_uint (hex_wordlist);
6697 logfile_top_uint (increment);
6698 logfile_top_uint (increment_max);
6699 logfile_top_uint (increment_min);
6700 logfile_top_uint (keyspace);
6701 logfile_top_uint (left);
6702 logfile_top_uint (logfile_disable);
6703 logfile_top_uint (loopback);
6704 logfile_top_uint (markov_classic);
6705 logfile_top_uint (markov_disable);
6706 logfile_top_uint (markov_threshold);
6707 logfile_top_uint (outfile_autohex);
6708 logfile_top_uint (outfile_check_timer);
6709 logfile_top_uint (outfile_format);
6710 logfile_top_uint (potfile_disable);
6711 logfile_top_string (potfile_path);
6712 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6713 logfile_top_uint (powertune_enable);
6714 #endif
6715 logfile_top_uint (scrypt_tmto);
6716 logfile_top_uint (quiet);
6717 logfile_top_uint (remove);
6718 logfile_top_uint (remove_timer);
6719 logfile_top_uint (restore);
6720 logfile_top_uint (restore_disable);
6721 logfile_top_uint (restore_timer);
6722 logfile_top_uint (rp_gen);
6723 logfile_top_uint (rp_gen_func_max);
6724 logfile_top_uint (rp_gen_func_min);
6725 logfile_top_uint (rp_gen_seed);
6726 logfile_top_uint (runtime);
6727 logfile_top_uint (segment_size);
6728 logfile_top_uint (show);
6729 logfile_top_uint (status);
6730 logfile_top_uint (status_automat);
6731 logfile_top_uint (status_timer);
6732 logfile_top_uint (usage);
6733 logfile_top_uint (username);
6734 logfile_top_uint (version);
6735 logfile_top_uint (weak_hash_threshold);
6736 logfile_top_uint (workload_profile);
6737 logfile_top_uint64 (limit);
6738 logfile_top_uint64 (skip);
6739 logfile_top_char (separator);
6740 logfile_top_string (cpu_affinity);
6741 logfile_top_string (custom_charset_1);
6742 logfile_top_string (custom_charset_2);
6743 logfile_top_string (custom_charset_3);
6744 logfile_top_string (custom_charset_4);
6745 logfile_top_string (debug_file);
6746 logfile_top_string (opencl_devices);
6747 logfile_top_string (opencl_platforms);
6748 logfile_top_string (opencl_device_types);
6749 logfile_top_uint (opencl_vector_width);
6750 logfile_top_string (induction_dir);
6751 logfile_top_string (markov_hcstat);
6752 logfile_top_string (outfile);
6753 logfile_top_string (outfile_check_dir);
6754 logfile_top_string (rule_buf_l);
6755 logfile_top_string (rule_buf_r);
6756 logfile_top_string (session);
6757 logfile_top_string (truecrypt_keyfiles);
6758
6759 /**
6760 * Init OpenCL library loader
6761 */
6762
6763 if (keyspace == 0)
6764 {
6765 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6766
6767 ocl_init (ocl);
6768
6769 data.ocl = ocl;
6770 }
6771
6772 /**
6773 * OpenCL platform selection
6774 */
6775
6776 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6777
6778 /**
6779 * OpenCL device selection
6780 */
6781
6782 u32 devices_filter = setup_devices_filter (opencl_devices);
6783
6784 /**
6785 * OpenCL device type selection
6786 */
6787
6788 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6789
6790 /**
6791 * benchmark
6792 */
6793
6794 if (benchmark == 1)
6795 {
6796 /**
6797 * disable useless stuff for benchmark
6798 */
6799
6800 status_timer = 0;
6801 restore_timer = 0;
6802 restore_disable = 1;
6803 potfile_disable = 1;
6804 weak_hash_threshold = 0;
6805 gpu_temp_disable = 1;
6806
6807 data.status_timer = status_timer;
6808 data.restore_timer = restore_timer;
6809 data.restore_disable = restore_disable;
6810
6811 /**
6812 * force attack mode to be bruteforce
6813 */
6814
6815 attack_mode = ATTACK_MODE_BF;
6816 attack_kern = ATTACK_KERN_BF;
6817
6818 if (workload_profile_chgd == 0)
6819 {
6820 workload_profile = 3;
6821
6822 data.workload_profile = workload_profile;
6823 }
6824 }
6825
6826 /**
6827 * config
6828 */
6829
6830 uint hash_type = 0;
6831 uint salt_type = 0;
6832 uint attack_exec = 0;
6833 uint opts_type = 0;
6834 uint kern_type = 0;
6835 uint dgst_size = 0;
6836 uint esalt_size = 0;
6837 uint opti_type = 0;
6838 uint dgst_pos0 = -1;
6839 uint dgst_pos1 = -1;
6840 uint dgst_pos2 = -1;
6841 uint dgst_pos3 = -1;
6842
6843 int (*parse_func) (char *, uint, hash_t *);
6844 int (*sort_by_digest) (const void *, const void *);
6845
6846 uint algorithm_pos = 0;
6847 uint algorithm_max = 1;
6848
6849 uint *algorithms = default_benchmark_algorithms;
6850
6851 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6852
6853 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6854 {
6855 /*
6856 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6857 * the following algos are skipped entirely
6858 */
6859
6860 if (algorithm_pos > 0)
6861 {
6862 local_free (rd);
6863
6864 rd = init_restore (argc, argv);
6865
6866 data.rd = rd;
6867 }
6868
6869 /**
6870 * update hash_mode in case of multihash benchmark
6871 */
6872
6873 if (benchmark == 1)
6874 {
6875 if (hash_mode_chgd == 0)
6876 {
6877 hash_mode = algorithms[algorithm_pos];
6878
6879 data.hash_mode = hash_mode;
6880 }
6881
6882 quiet = 1;
6883
6884 data.quiet = quiet;
6885 }
6886
6887 switch (hash_mode)
6888 {
6889 case 0: hash_type = HASH_TYPE_MD5;
6890 salt_type = SALT_TYPE_NONE;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_LE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS14;
6895 kern_type = KERN_TYPE_MD5;
6896 dgst_size = DGST_SIZE_4_4;
6897 parse_func = md5_parse_hash;
6898 sort_by_digest = sort_by_digest_4_4;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_MEET_IN_MIDDLE
6903 | OPTI_TYPE_EARLY_SKIP
6904 | OPTI_TYPE_NOT_ITERATED
6905 | OPTI_TYPE_NOT_SALTED
6906 | OPTI_TYPE_RAW_HASH;
6907 dgst_pos0 = 0;
6908 dgst_pos1 = 3;
6909 dgst_pos2 = 2;
6910 dgst_pos3 = 1;
6911 break;
6912
6913 case 10: hash_type = HASH_TYPE_MD5;
6914 salt_type = SALT_TYPE_INTERN;
6915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6916 opts_type = OPTS_TYPE_PT_GENERATE_LE
6917 | OPTS_TYPE_ST_ADD80
6918 | OPTS_TYPE_ST_ADDBITS14;
6919 kern_type = KERN_TYPE_MD5_PWSLT;
6920 dgst_size = DGST_SIZE_4_4;
6921 parse_func = md5s_parse_hash;
6922 sort_by_digest = sort_by_digest_4_4;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_MEET_IN_MIDDLE
6927 | OPTI_TYPE_EARLY_SKIP
6928 | OPTI_TYPE_NOT_ITERATED
6929 | OPTI_TYPE_APPENDED_SALT
6930 | OPTI_TYPE_RAW_HASH;
6931 dgst_pos0 = 0;
6932 dgst_pos1 = 3;
6933 dgst_pos2 = 2;
6934 dgst_pos3 = 1;
6935 break;
6936
6937 case 11: hash_type = HASH_TYPE_MD5;
6938 salt_type = SALT_TYPE_INTERN;
6939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6940 opts_type = OPTS_TYPE_PT_GENERATE_LE
6941 | OPTS_TYPE_ST_ADD80
6942 | OPTS_TYPE_ST_ADDBITS14;
6943 kern_type = KERN_TYPE_MD5_PWSLT;
6944 dgst_size = DGST_SIZE_4_4;
6945 parse_func = joomla_parse_hash;
6946 sort_by_digest = sort_by_digest_4_4;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_MEET_IN_MIDDLE
6951 | OPTI_TYPE_EARLY_SKIP
6952 | OPTI_TYPE_NOT_ITERATED
6953 | OPTI_TYPE_APPENDED_SALT
6954 | OPTI_TYPE_RAW_HASH;
6955 dgst_pos0 = 0;
6956 dgst_pos1 = 3;
6957 dgst_pos2 = 2;
6958 dgst_pos3 = 1;
6959 break;
6960
6961 case 12: hash_type = HASH_TYPE_MD5;
6962 salt_type = SALT_TYPE_INTERN;
6963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6964 opts_type = OPTS_TYPE_PT_GENERATE_LE
6965 | OPTS_TYPE_ST_ADD80
6966 | OPTS_TYPE_ST_ADDBITS14;
6967 kern_type = KERN_TYPE_MD5_PWSLT;
6968 dgst_size = DGST_SIZE_4_4;
6969 parse_func = postgresql_parse_hash;
6970 sort_by_digest = sort_by_digest_4_4;
6971 opti_type = OPTI_TYPE_ZERO_BYTE
6972 | OPTI_TYPE_PRECOMPUTE_INIT
6973 | OPTI_TYPE_PRECOMPUTE_MERKLE
6974 | OPTI_TYPE_MEET_IN_MIDDLE
6975 | OPTI_TYPE_EARLY_SKIP
6976 | OPTI_TYPE_NOT_ITERATED
6977 | OPTI_TYPE_APPENDED_SALT
6978 | OPTI_TYPE_RAW_HASH;
6979 dgst_pos0 = 0;
6980 dgst_pos1 = 3;
6981 dgst_pos2 = 2;
6982 dgst_pos3 = 1;
6983 break;
6984
6985 case 20: hash_type = HASH_TYPE_MD5;
6986 salt_type = SALT_TYPE_INTERN;
6987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6988 opts_type = OPTS_TYPE_PT_GENERATE_LE
6989 | OPTS_TYPE_PT_ADD80
6990 | OPTS_TYPE_PT_ADDBITS14;
6991 kern_type = KERN_TYPE_MD5_SLTPW;
6992 dgst_size = DGST_SIZE_4_4;
6993 parse_func = md5s_parse_hash;
6994 sort_by_digest = sort_by_digest_4_4;
6995 opti_type = OPTI_TYPE_ZERO_BYTE
6996 | OPTI_TYPE_PRECOMPUTE_INIT
6997 | OPTI_TYPE_PRECOMPUTE_MERKLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_PREPENDED_SALT
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 0;
7003 dgst_pos1 = 3;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 21: hash_type = HASH_TYPE_MD5;
7009 salt_type = SALT_TYPE_INTERN;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_LE
7012 | OPTS_TYPE_PT_ADD80
7013 | OPTS_TYPE_PT_ADDBITS14;
7014 kern_type = KERN_TYPE_MD5_SLTPW;
7015 dgst_size = DGST_SIZE_4_4;
7016 parse_func = osc_parse_hash;
7017 sort_by_digest = sort_by_digest_4_4;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_PRECOMPUTE_INIT
7020 | OPTI_TYPE_PRECOMPUTE_MERKLE
7021 | OPTI_TYPE_EARLY_SKIP
7022 | OPTI_TYPE_NOT_ITERATED
7023 | OPTI_TYPE_PREPENDED_SALT
7024 | OPTI_TYPE_RAW_HASH;
7025 dgst_pos0 = 0;
7026 dgst_pos1 = 3;
7027 dgst_pos2 = 2;
7028 dgst_pos3 = 1;
7029 break;
7030
7031 case 22: hash_type = HASH_TYPE_MD5;
7032 salt_type = SALT_TYPE_EMBEDDED;
7033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7034 opts_type = OPTS_TYPE_PT_GENERATE_LE
7035 | OPTS_TYPE_PT_ADD80
7036 | OPTS_TYPE_PT_ADDBITS14;
7037 kern_type = KERN_TYPE_MD5_SLTPW;
7038 dgst_size = DGST_SIZE_4_4;
7039 parse_func = netscreen_parse_hash;
7040 sort_by_digest = sort_by_digest_4_4;
7041 opti_type = OPTI_TYPE_ZERO_BYTE
7042 | OPTI_TYPE_PRECOMPUTE_INIT
7043 | OPTI_TYPE_PRECOMPUTE_MERKLE
7044 | OPTI_TYPE_EARLY_SKIP
7045 | OPTI_TYPE_NOT_ITERATED
7046 | OPTI_TYPE_PREPENDED_SALT
7047 | OPTI_TYPE_RAW_HASH;
7048 dgst_pos0 = 0;
7049 dgst_pos1 = 3;
7050 dgst_pos2 = 2;
7051 dgst_pos3 = 1;
7052 break;
7053
7054 case 23: hash_type = HASH_TYPE_MD5;
7055 salt_type = SALT_TYPE_EMBEDDED;
7056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7057 opts_type = OPTS_TYPE_PT_GENERATE_LE
7058 | OPTS_TYPE_PT_ADD80
7059 | OPTS_TYPE_PT_ADDBITS14;
7060 kern_type = KERN_TYPE_MD5_SLTPW;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = skype_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_EARLY_SKIP
7068 | OPTI_TYPE_NOT_ITERATED
7069 | OPTI_TYPE_PREPENDED_SALT
7070 | OPTI_TYPE_RAW_HASH;
7071 dgst_pos0 = 0;
7072 dgst_pos1 = 3;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 30: hash_type = HASH_TYPE_MD5;
7078 salt_type = SALT_TYPE_INTERN;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_LE
7081 | OPTS_TYPE_PT_UNICODE
7082 | OPTS_TYPE_ST_ADD80
7083 | OPTS_TYPE_ST_ADDBITS14;
7084 kern_type = KERN_TYPE_MD5_PWUSLT;
7085 dgst_size = DGST_SIZE_4_4;
7086 parse_func = md5s_parse_hash;
7087 sort_by_digest = sort_by_digest_4_4;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_PRECOMPUTE_INIT
7090 | OPTI_TYPE_PRECOMPUTE_MERKLE
7091 | OPTI_TYPE_MEET_IN_MIDDLE
7092 | OPTI_TYPE_EARLY_SKIP
7093 | OPTI_TYPE_NOT_ITERATED
7094 | OPTI_TYPE_APPENDED_SALT
7095 | OPTI_TYPE_RAW_HASH;
7096 dgst_pos0 = 0;
7097 dgst_pos1 = 3;
7098 dgst_pos2 = 2;
7099 dgst_pos3 = 1;
7100 break;
7101
7102 case 40: hash_type = HASH_TYPE_MD5;
7103 salt_type = SALT_TYPE_INTERN;
7104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7105 opts_type = OPTS_TYPE_PT_GENERATE_LE
7106 | OPTS_TYPE_PT_ADD80
7107 | OPTS_TYPE_PT_ADDBITS14
7108 | OPTS_TYPE_PT_UNICODE;
7109 kern_type = KERN_TYPE_MD5_SLTPWU;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = md5s_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_PRECOMPUTE_INIT
7115 | OPTI_TYPE_PRECOMPUTE_MERKLE
7116 | OPTI_TYPE_EARLY_SKIP
7117 | OPTI_TYPE_NOT_ITERATED
7118 | OPTI_TYPE_PREPENDED_SALT
7119 | OPTI_TYPE_RAW_HASH;
7120 dgst_pos0 = 0;
7121 dgst_pos1 = 3;
7122 dgst_pos2 = 2;
7123 dgst_pos3 = 1;
7124 break;
7125
7126 case 50: hash_type = HASH_TYPE_MD5;
7127 salt_type = SALT_TYPE_INTERN;
7128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7129 opts_type = OPTS_TYPE_PT_GENERATE_LE
7130 | OPTS_TYPE_ST_ADD80
7131 | OPTS_TYPE_ST_ADDBITS14;
7132 kern_type = KERN_TYPE_HMACMD5_PW;
7133 dgst_size = DGST_SIZE_4_4;
7134 parse_func = hmacmd5_parse_hash;
7135 sort_by_digest = sort_by_digest_4_4;
7136 opti_type = OPTI_TYPE_ZERO_BYTE
7137 | OPTI_TYPE_NOT_ITERATED;
7138 dgst_pos0 = 0;
7139 dgst_pos1 = 3;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 60: hash_type = HASH_TYPE_MD5;
7145 salt_type = SALT_TYPE_INTERN;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_LE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS14;
7150 kern_type = KERN_TYPE_HMACMD5_SLT;
7151 dgst_size = DGST_SIZE_4_4;
7152 parse_func = hmacmd5_parse_hash;
7153 sort_by_digest = sort_by_digest_4_4;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_NOT_ITERATED;
7156 dgst_pos0 = 0;
7157 dgst_pos1 = 3;
7158 dgst_pos2 = 2;
7159 dgst_pos3 = 1;
7160 break;
7161
7162 case 100: hash_type = HASH_TYPE_SHA1;
7163 salt_type = SALT_TYPE_NONE;
7164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7165 opts_type = OPTS_TYPE_PT_GENERATE_BE
7166 | OPTS_TYPE_PT_ADD80
7167 | OPTS_TYPE_PT_ADDBITS15;
7168 kern_type = KERN_TYPE_SHA1;
7169 dgst_size = DGST_SIZE_4_5;
7170 parse_func = sha1_parse_hash;
7171 sort_by_digest = sort_by_digest_4_5;
7172 opti_type = OPTI_TYPE_ZERO_BYTE
7173 | OPTI_TYPE_PRECOMPUTE_INIT
7174 | OPTI_TYPE_PRECOMPUTE_MERKLE
7175 | OPTI_TYPE_EARLY_SKIP
7176 | OPTI_TYPE_NOT_ITERATED
7177 | OPTI_TYPE_NOT_SALTED
7178 | OPTI_TYPE_RAW_HASH;
7179 dgst_pos0 = 3;
7180 dgst_pos1 = 4;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 1;
7183 break;
7184
7185 case 101: hash_type = HASH_TYPE_SHA1;
7186 salt_type = SALT_TYPE_NONE;
7187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7188 opts_type = OPTS_TYPE_PT_GENERATE_BE
7189 | OPTS_TYPE_PT_ADD80
7190 | OPTS_TYPE_PT_ADDBITS15;
7191 kern_type = KERN_TYPE_SHA1;
7192 dgst_size = DGST_SIZE_4_5;
7193 parse_func = sha1b64_parse_hash;
7194 sort_by_digest = sort_by_digest_4_5;
7195 opti_type = OPTI_TYPE_ZERO_BYTE
7196 | OPTI_TYPE_PRECOMPUTE_INIT
7197 | OPTI_TYPE_PRECOMPUTE_MERKLE
7198 | OPTI_TYPE_EARLY_SKIP
7199 | OPTI_TYPE_NOT_ITERATED
7200 | OPTI_TYPE_NOT_SALTED
7201 | OPTI_TYPE_RAW_HASH;
7202 dgst_pos0 = 3;
7203 dgst_pos1 = 4;
7204 dgst_pos2 = 2;
7205 dgst_pos3 = 1;
7206 break;
7207
7208 case 110: hash_type = HASH_TYPE_SHA1;
7209 salt_type = SALT_TYPE_INTERN;
7210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7211 opts_type = OPTS_TYPE_PT_GENERATE_BE
7212 | OPTS_TYPE_ST_ADD80
7213 | OPTS_TYPE_ST_ADDBITS15;
7214 kern_type = KERN_TYPE_SHA1_PWSLT;
7215 dgst_size = DGST_SIZE_4_5;
7216 parse_func = sha1s_parse_hash;
7217 sort_by_digest = sort_by_digest_4_5;
7218 opti_type = OPTI_TYPE_ZERO_BYTE
7219 | OPTI_TYPE_PRECOMPUTE_INIT
7220 | OPTI_TYPE_PRECOMPUTE_MERKLE
7221 | OPTI_TYPE_EARLY_SKIP
7222 | OPTI_TYPE_NOT_ITERATED
7223 | OPTI_TYPE_APPENDED_SALT
7224 | OPTI_TYPE_RAW_HASH;
7225 dgst_pos0 = 3;
7226 dgst_pos1 = 4;
7227 dgst_pos2 = 2;
7228 dgst_pos3 = 1;
7229 break;
7230
7231 case 111: hash_type = HASH_TYPE_SHA1;
7232 salt_type = SALT_TYPE_EMBEDDED;
7233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7234 opts_type = OPTS_TYPE_PT_GENERATE_BE
7235 | OPTS_TYPE_ST_ADD80
7236 | OPTS_TYPE_ST_ADDBITS15;
7237 kern_type = KERN_TYPE_SHA1_PWSLT;
7238 dgst_size = DGST_SIZE_4_5;
7239 parse_func = sha1b64s_parse_hash;
7240 sort_by_digest = sort_by_digest_4_5;
7241 opti_type = OPTI_TYPE_ZERO_BYTE
7242 | OPTI_TYPE_PRECOMPUTE_INIT
7243 | OPTI_TYPE_PRECOMPUTE_MERKLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 3;
7249 dgst_pos1 = 4;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 112: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_ST_ADD80
7259 | OPTS_TYPE_ST_ADDBITS15
7260 | OPTS_TYPE_ST_HEX;
7261 kern_type = KERN_TYPE_SHA1_PWSLT;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = oracles_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_APPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 120: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_INTERN;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15;
7284 kern_type = KERN_TYPE_SHA1_SLTPW;
7285 dgst_size = DGST_SIZE_4_5;
7286 parse_func = sha1s_parse_hash;
7287 sort_by_digest = sort_by_digest_4_5;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_PREPENDED_SALT
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 4;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 121: hash_type = HASH_TYPE_SHA1;
7302 salt_type = SALT_TYPE_INTERN;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS15
7307 | OPTS_TYPE_ST_LOWER;
7308 kern_type = KERN_TYPE_SHA1_SLTPW;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = smf_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_PRECOMPUTE_MERKLE
7315 | OPTI_TYPE_EARLY_SKIP
7316 | OPTI_TYPE_NOT_ITERATED
7317 | OPTI_TYPE_PREPENDED_SALT
7318 | OPTI_TYPE_RAW_HASH;
7319 dgst_pos0 = 3;
7320 dgst_pos1 = 4;
7321 dgst_pos2 = 2;
7322 dgst_pos3 = 1;
7323 break;
7324
7325 case 122: hash_type = HASH_TYPE_SHA1;
7326 salt_type = SALT_TYPE_EMBEDDED;
7327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7328 opts_type = OPTS_TYPE_PT_GENERATE_BE
7329 | OPTS_TYPE_PT_ADD80
7330 | OPTS_TYPE_PT_ADDBITS15
7331 | OPTS_TYPE_ST_HEX;
7332 kern_type = KERN_TYPE_SHA1_SLTPW;
7333 dgst_size = DGST_SIZE_4_5;
7334 parse_func = osx1_parse_hash;
7335 sort_by_digest = sort_by_digest_4_5;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_PREPENDED_SALT
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 4;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 1;
7347 break;
7348
7349 case 124: hash_type = HASH_TYPE_SHA1;
7350 salt_type = SALT_TYPE_EMBEDDED;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_PT_ADD80
7354 | OPTS_TYPE_PT_ADDBITS15;
7355 kern_type = KERN_TYPE_SHA1_SLTPW;
7356 dgst_size = DGST_SIZE_4_5;
7357 parse_func = djangosha1_parse_hash;
7358 sort_by_digest = sort_by_digest_4_5;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_PREPENDED_SALT
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 4;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 1;
7370 break;
7371
7372 case 125: hash_type = HASH_TYPE_SHA1;
7373 salt_type = SALT_TYPE_EMBEDDED;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_PT_ADD80
7377 | OPTS_TYPE_PT_ADDBITS15
7378 | OPTS_TYPE_ST_HEX;
7379 kern_type = KERN_TYPE_SHA1_SLTPW;
7380 dgst_size = DGST_SIZE_4_5;
7381 parse_func = arubaos_parse_hash;
7382 sort_by_digest = sort_by_digest_4_5;
7383 opti_type = OPTI_TYPE_ZERO_BYTE
7384 | OPTI_TYPE_PRECOMPUTE_INIT
7385 | OPTI_TYPE_PRECOMPUTE_MERKLE
7386 | OPTI_TYPE_EARLY_SKIP
7387 | OPTI_TYPE_NOT_ITERATED
7388 | OPTI_TYPE_PREPENDED_SALT
7389 | OPTI_TYPE_RAW_HASH;
7390 dgst_pos0 = 3;
7391 dgst_pos1 = 4;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 130: hash_type = HASH_TYPE_SHA1;
7397 salt_type = SALT_TYPE_INTERN;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_UNICODE
7401 | OPTS_TYPE_ST_ADD80
7402 | OPTS_TYPE_ST_ADDBITS15;
7403 kern_type = KERN_TYPE_SHA1_PWUSLT;
7404 dgst_size = DGST_SIZE_4_5;
7405 parse_func = sha1s_parse_hash;
7406 sort_by_digest = sort_by_digest_4_5;
7407 opti_type = OPTI_TYPE_ZERO_BYTE
7408 | OPTI_TYPE_PRECOMPUTE_INIT
7409 | OPTI_TYPE_PRECOMPUTE_MERKLE
7410 | OPTI_TYPE_EARLY_SKIP
7411 | OPTI_TYPE_NOT_ITERATED
7412 | OPTI_TYPE_APPENDED_SALT
7413 | OPTI_TYPE_RAW_HASH;
7414 dgst_pos0 = 3;
7415 dgst_pos1 = 4;
7416 dgst_pos2 = 2;
7417 dgst_pos3 = 1;
7418 break;
7419
7420 case 131: hash_type = HASH_TYPE_SHA1;
7421 salt_type = SALT_TYPE_EMBEDDED;
7422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7423 opts_type = OPTS_TYPE_PT_GENERATE_BE
7424 | OPTS_TYPE_PT_UNICODE
7425 | OPTS_TYPE_PT_UPPER
7426 | OPTS_TYPE_ST_ADD80
7427 | OPTS_TYPE_ST_ADDBITS15
7428 | OPTS_TYPE_ST_HEX;
7429 kern_type = KERN_TYPE_SHA1_PWUSLT;
7430 dgst_size = DGST_SIZE_4_5;
7431 parse_func = mssql2000_parse_hash;
7432 sort_by_digest = sort_by_digest_4_5;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_APPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 3;
7441 dgst_pos1 = 4;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 132: hash_type = HASH_TYPE_SHA1;
7447 salt_type = SALT_TYPE_EMBEDDED;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_BE
7450 | OPTS_TYPE_PT_UNICODE
7451 | OPTS_TYPE_ST_ADD80
7452 | OPTS_TYPE_ST_ADDBITS15
7453 | OPTS_TYPE_ST_HEX;
7454 kern_type = KERN_TYPE_SHA1_PWUSLT;
7455 dgst_size = DGST_SIZE_4_5;
7456 parse_func = mssql2005_parse_hash;
7457 sort_by_digest = sort_by_digest_4_5;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_APPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 133: hash_type = HASH_TYPE_SHA1;
7472 salt_type = SALT_TYPE_EMBEDDED;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_UNICODE
7476 | OPTS_TYPE_ST_ADD80
7477 | OPTS_TYPE_ST_ADDBITS15;
7478 kern_type = KERN_TYPE_SHA1_PWUSLT;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = peoplesoft_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_APPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 140: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_INTERN;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15
7501 | OPTS_TYPE_PT_UNICODE;
7502 kern_type = KERN_TYPE_SHA1_SLTPWU;
7503 dgst_size = DGST_SIZE_4_5;
7504 parse_func = sha1s_parse_hash;
7505 sort_by_digest = sort_by_digest_4_5;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_PREPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 141: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_EMBEDDED;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15
7525 | OPTS_TYPE_PT_UNICODE
7526 | OPTS_TYPE_ST_BASE64;
7527 kern_type = KERN_TYPE_SHA1_SLTPWU;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = episerver_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_PRECOMPUTE_INIT
7533 | OPTI_TYPE_PRECOMPUTE_MERKLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_PREPENDED_SALT
7537 | OPTI_TYPE_RAW_HASH;
7538 dgst_pos0 = 3;
7539 dgst_pos1 = 4;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 1;
7542 break;
7543
7544 case 150: hash_type = HASH_TYPE_SHA1;
7545 salt_type = SALT_TYPE_INTERN;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_BE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS15;
7550 kern_type = KERN_TYPE_HMACSHA1_PW;
7551 dgst_size = DGST_SIZE_4_5;
7552 parse_func = hmacsha1_parse_hash;
7553 sort_by_digest = sort_by_digest_4_5;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_NOT_ITERATED;
7556 dgst_pos0 = 3;
7557 dgst_pos1 = 4;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 1;
7560 break;
7561
7562 case 160: hash_type = HASH_TYPE_SHA1;
7563 salt_type = SALT_TYPE_INTERN;
7564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_BE
7566 | OPTS_TYPE_PT_ADD80
7567 | OPTS_TYPE_PT_ADDBITS15;
7568 kern_type = KERN_TYPE_HMACSHA1_SLT;
7569 dgst_size = DGST_SIZE_4_5;
7570 parse_func = hmacsha1_parse_hash;
7571 sort_by_digest = sort_by_digest_4_5;
7572 opti_type = OPTI_TYPE_ZERO_BYTE
7573 | OPTI_TYPE_NOT_ITERATED;
7574 dgst_pos0 = 3;
7575 dgst_pos1 = 4;
7576 dgst_pos2 = 2;
7577 dgst_pos3 = 1;
7578 break;
7579
7580 case 190: hash_type = HASH_TYPE_SHA1;
7581 salt_type = SALT_TYPE_NONE;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = OPTS_TYPE_PT_GENERATE_BE
7584 | OPTS_TYPE_PT_ADD80
7585 | OPTS_TYPE_PT_ADDBITS15;
7586 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7587 dgst_size = DGST_SIZE_4_5;
7588 parse_func = sha1linkedin_parse_hash;
7589 sort_by_digest = sort_by_digest_4_5;
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_INIT
7592 | OPTI_TYPE_EARLY_SKIP
7593 | OPTI_TYPE_NOT_ITERATED
7594 | OPTI_TYPE_NOT_SALTED;
7595 dgst_pos0 = 0;
7596 dgst_pos1 = 4;
7597 dgst_pos2 = 3;
7598 dgst_pos3 = 2;
7599 break;
7600
7601 case 200: hash_type = HASH_TYPE_MYSQL;
7602 salt_type = SALT_TYPE_NONE;
7603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7604 opts_type = 0;
7605 kern_type = KERN_TYPE_MYSQL;
7606 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7607 parse_func = mysql323_parse_hash;
7608 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7609 opti_type = OPTI_TYPE_ZERO_BYTE;
7610 dgst_pos0 = 0;
7611 dgst_pos1 = 1;
7612 dgst_pos2 = 2;
7613 dgst_pos3 = 3;
7614 break;
7615
7616 case 300: hash_type = HASH_TYPE_SHA1;
7617 salt_type = SALT_TYPE_NONE;
7618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7619 opts_type = OPTS_TYPE_PT_GENERATE_BE
7620 | OPTS_TYPE_PT_ADD80
7621 | OPTS_TYPE_PT_ADDBITS15;
7622 kern_type = KERN_TYPE_MYSQL41;
7623 dgst_size = DGST_SIZE_4_5;
7624 parse_func = sha1_parse_hash;
7625 sort_by_digest = sort_by_digest_4_5;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_EARLY_SKIP
7630 | OPTI_TYPE_NOT_ITERATED
7631 | OPTI_TYPE_NOT_SALTED;
7632 dgst_pos0 = 3;
7633 dgst_pos1 = 4;
7634 dgst_pos2 = 2;
7635 dgst_pos3 = 1;
7636 break;
7637
7638 case 400: hash_type = HASH_TYPE_MD5;
7639 salt_type = SALT_TYPE_EMBEDDED;
7640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7642 kern_type = KERN_TYPE_PHPASS;
7643 dgst_size = DGST_SIZE_4_4;
7644 parse_func = phpass_parse_hash;
7645 sort_by_digest = sort_by_digest_4_4;
7646 opti_type = OPTI_TYPE_ZERO_BYTE
7647 | OPTI_TYPE_SLOW_HASH_SIMD;
7648 dgst_pos0 = 0;
7649 dgst_pos1 = 1;
7650 dgst_pos2 = 2;
7651 dgst_pos3 = 3;
7652 break;
7653
7654 case 500: hash_type = HASH_TYPE_MD5;
7655 salt_type = SALT_TYPE_EMBEDDED;
7656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7658 kern_type = KERN_TYPE_MD5CRYPT;
7659 dgst_size = DGST_SIZE_4_4;
7660 parse_func = md5crypt_parse_hash;
7661 sort_by_digest = sort_by_digest_4_4;
7662 opti_type = OPTI_TYPE_ZERO_BYTE;
7663 dgst_pos0 = 0;
7664 dgst_pos1 = 1;
7665 dgst_pos2 = 2;
7666 dgst_pos3 = 3;
7667 break;
7668
7669 case 501: hash_type = HASH_TYPE_MD5;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_LE
7673 | OPTS_TYPE_HASH_COPY;
7674 kern_type = KERN_TYPE_MD5CRYPT;
7675 dgst_size = DGST_SIZE_4_4;
7676 parse_func = juniper_parse_hash;
7677 sort_by_digest = sort_by_digest_4_4;
7678 opti_type = OPTI_TYPE_ZERO_BYTE;
7679 dgst_pos0 = 0;
7680 dgst_pos1 = 1;
7681 dgst_pos2 = 2;
7682 dgst_pos3 = 3;
7683 break;
7684
7685 case 900: hash_type = HASH_TYPE_MD4;
7686 salt_type = SALT_TYPE_NONE;
7687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7688 opts_type = OPTS_TYPE_PT_GENERATE_LE
7689 | OPTS_TYPE_PT_ADD80
7690 | OPTS_TYPE_PT_ADDBITS14;
7691 kern_type = KERN_TYPE_MD4;
7692 dgst_size = DGST_SIZE_4_4;
7693 parse_func = md4_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_PRECOMPUTE_INIT
7697 | OPTI_TYPE_PRECOMPUTE_MERKLE
7698 | OPTI_TYPE_MEET_IN_MIDDLE
7699 | OPTI_TYPE_EARLY_SKIP
7700 | OPTI_TYPE_NOT_ITERATED
7701 | OPTI_TYPE_NOT_SALTED
7702 | OPTI_TYPE_RAW_HASH;
7703 dgst_pos0 = 0;
7704 dgst_pos1 = 3;
7705 dgst_pos2 = 2;
7706 dgst_pos3 = 1;
7707 break;
7708
7709 case 1000: hash_type = HASH_TYPE_MD4;
7710 salt_type = SALT_TYPE_NONE;
7711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7712 opts_type = OPTS_TYPE_PT_GENERATE_LE
7713 | OPTS_TYPE_PT_ADD80
7714 | OPTS_TYPE_PT_ADDBITS14
7715 | OPTS_TYPE_PT_UNICODE;
7716 kern_type = KERN_TYPE_MD4_PWU;
7717 dgst_size = DGST_SIZE_4_4;
7718 parse_func = md4_parse_hash;
7719 sort_by_digest = sort_by_digest_4_4;
7720 opti_type = OPTI_TYPE_ZERO_BYTE
7721 | OPTI_TYPE_PRECOMPUTE_INIT
7722 | OPTI_TYPE_PRECOMPUTE_MERKLE
7723 | OPTI_TYPE_MEET_IN_MIDDLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_NOT_SALTED
7727 | OPTI_TYPE_RAW_HASH;
7728 dgst_pos0 = 0;
7729 dgst_pos1 = 3;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 1;
7732 break;
7733
7734 case 1100: hash_type = HASH_TYPE_MD4;
7735 salt_type = SALT_TYPE_INTERN;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_LE
7738 | OPTS_TYPE_PT_ADD80
7739 | OPTS_TYPE_PT_ADDBITS14
7740 | OPTS_TYPE_PT_UNICODE
7741 | OPTS_TYPE_ST_ADD80
7742 | OPTS_TYPE_ST_UNICODE
7743 | OPTS_TYPE_ST_LOWER;
7744 kern_type = KERN_TYPE_MD44_PWUSLT;
7745 dgst_size = DGST_SIZE_4_4;
7746 parse_func = dcc_parse_hash;
7747 sort_by_digest = sort_by_digest_4_4;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED;
7753 dgst_pos0 = 0;
7754 dgst_pos1 = 3;
7755 dgst_pos2 = 2;
7756 dgst_pos3 = 1;
7757 break;
7758
7759 case 1400: hash_type = HASH_TYPE_SHA256;
7760 salt_type = SALT_TYPE_NONE;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_PT_ADD80
7764 | OPTS_TYPE_PT_ADDBITS15;
7765 kern_type = KERN_TYPE_SHA256;
7766 dgst_size = DGST_SIZE_4_8;
7767 parse_func = sha256_parse_hash;
7768 sort_by_digest = sort_by_digest_4_8;
7769 opti_type = OPTI_TYPE_ZERO_BYTE
7770 | OPTI_TYPE_PRECOMPUTE_INIT
7771 | OPTI_TYPE_PRECOMPUTE_MERKLE
7772 | OPTI_TYPE_EARLY_SKIP
7773 | OPTI_TYPE_NOT_ITERATED
7774 | OPTI_TYPE_NOT_SALTED
7775 | OPTI_TYPE_RAW_HASH;
7776 dgst_pos0 = 3;
7777 dgst_pos1 = 7;
7778 dgst_pos2 = 2;
7779 dgst_pos3 = 6;
7780 break;
7781
7782 case 1410: hash_type = HASH_TYPE_SHA256;
7783 salt_type = SALT_TYPE_INTERN;
7784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_BE
7786 | OPTS_TYPE_ST_ADD80
7787 | OPTS_TYPE_ST_ADDBITS15;
7788 kern_type = KERN_TYPE_SHA256_PWSLT;
7789 dgst_size = DGST_SIZE_4_8;
7790 parse_func = sha256s_parse_hash;
7791 sort_by_digest = sort_by_digest_4_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_INIT
7794 | OPTI_TYPE_PRECOMPUTE_MERKLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_APPENDED_SALT
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 3;
7800 dgst_pos1 = 7;
7801 dgst_pos2 = 2;
7802 dgst_pos3 = 6;
7803 break;
7804
7805 case 1420: hash_type = HASH_TYPE_SHA256;
7806 salt_type = SALT_TYPE_INTERN;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_BE
7809 | OPTS_TYPE_PT_ADD80
7810 | OPTS_TYPE_PT_ADDBITS15;
7811 kern_type = KERN_TYPE_SHA256_SLTPW;
7812 dgst_size = DGST_SIZE_4_8;
7813 parse_func = sha256s_parse_hash;
7814 sort_by_digest = sort_by_digest_4_8;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_PREPENDED_SALT
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 3;
7823 dgst_pos1 = 7;
7824 dgst_pos2 = 2;
7825 dgst_pos3 = 6;
7826 break;
7827
7828 case 1421: hash_type = HASH_TYPE_SHA256;
7829 salt_type = SALT_TYPE_EMBEDDED;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_PT_ADD80
7833 | OPTS_TYPE_PT_ADDBITS15;
7834 kern_type = KERN_TYPE_SHA256_SLTPW;
7835 dgst_size = DGST_SIZE_4_8;
7836 parse_func = hmailserver_parse_hash;
7837 sort_by_digest = sort_by_digest_4_8;
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_INIT
7840 | OPTI_TYPE_PRECOMPUTE_MERKLE
7841 | OPTI_TYPE_EARLY_SKIP
7842 | OPTI_TYPE_NOT_ITERATED
7843 | OPTI_TYPE_PREPENDED_SALT
7844 | OPTI_TYPE_RAW_HASH;
7845 dgst_pos0 = 3;
7846 dgst_pos1 = 7;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 6;
7849 break;
7850
7851 case 1430: hash_type = HASH_TYPE_SHA256;
7852 salt_type = SALT_TYPE_INTERN;
7853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_BE
7855 | OPTS_TYPE_PT_UNICODE
7856 | OPTS_TYPE_ST_ADD80
7857 | OPTS_TYPE_ST_ADDBITS15;
7858 kern_type = KERN_TYPE_SHA256_PWUSLT;
7859 dgst_size = DGST_SIZE_4_8;
7860 parse_func = sha256s_parse_hash;
7861 sort_by_digest = sort_by_digest_4_8;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_APPENDED_SALT
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 7;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 6;
7873 break;
7874
7875 case 1440: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15
7881 | OPTS_TYPE_PT_UNICODE;
7882 kern_type = KERN_TYPE_SHA256_SLTPWU;
7883 dgst_size = DGST_SIZE_4_8;
7884 parse_func = sha256s_parse_hash;
7885 sort_by_digest = sort_by_digest_4_8;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_INIT
7888 | OPTI_TYPE_PRECOMPUTE_MERKLE
7889 | OPTI_TYPE_EARLY_SKIP
7890 | OPTI_TYPE_NOT_ITERATED
7891 | OPTI_TYPE_PREPENDED_SALT
7892 | OPTI_TYPE_RAW_HASH;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1441: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_EMBEDDED;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_PT_ADD80
7904 | OPTS_TYPE_PT_ADDBITS15
7905 | OPTS_TYPE_PT_UNICODE
7906 | OPTS_TYPE_ST_BASE64;
7907 kern_type = KERN_TYPE_SHA256_SLTPWU;
7908 dgst_size = DGST_SIZE_4_8;
7909 parse_func = episerver4_parse_hash;
7910 sort_by_digest = sort_by_digest_4_8;
7911 opti_type = OPTI_TYPE_ZERO_BYTE
7912 | OPTI_TYPE_PRECOMPUTE_INIT
7913 | OPTI_TYPE_PRECOMPUTE_MERKLE
7914 | OPTI_TYPE_EARLY_SKIP
7915 | OPTI_TYPE_NOT_ITERATED
7916 | OPTI_TYPE_PREPENDED_SALT
7917 | OPTI_TYPE_RAW_HASH;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1450: hash_type = HASH_TYPE_SHA256;
7925 salt_type = SALT_TYPE_INTERN;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_BE
7928 | OPTS_TYPE_ST_ADD80;
7929 kern_type = KERN_TYPE_HMACSHA256_PW;
7930 dgst_size = DGST_SIZE_4_8;
7931 parse_func = hmacsha256_parse_hash;
7932 sort_by_digest = sort_by_digest_4_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_NOT_ITERATED;
7935 dgst_pos0 = 3;
7936 dgst_pos1 = 7;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 6;
7939 break;
7940
7941 case 1460: hash_type = HASH_TYPE_SHA256;
7942 salt_type = SALT_TYPE_INTERN;
7943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_BE
7945 | OPTS_TYPE_PT_ADD80
7946 | OPTS_TYPE_PT_ADDBITS15;
7947 kern_type = KERN_TYPE_HMACSHA256_SLT;
7948 dgst_size = DGST_SIZE_4_8;
7949 parse_func = hmacsha256_parse_hash;
7950 sort_by_digest = sort_by_digest_4_8;
7951 opti_type = OPTI_TYPE_ZERO_BYTE
7952 | OPTI_TYPE_NOT_ITERATED;
7953 dgst_pos0 = 3;
7954 dgst_pos1 = 7;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 6;
7957 break;
7958
7959 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7960 salt_type = SALT_TYPE_EMBEDDED;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE
7963 | OPTS_TYPE_PT_BITSLICE;
7964 kern_type = KERN_TYPE_DESCRYPT;
7965 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7966 parse_func = descrypt_parse_hash;
7967 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7968 opti_type = OPTI_TYPE_ZERO_BYTE
7969 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7970 dgst_pos0 = 0;
7971 dgst_pos1 = 1;
7972 dgst_pos2 = 2;
7973 dgst_pos3 = 3;
7974 break;
7975
7976 case 1600: hash_type = HASH_TYPE_MD5;
7977 salt_type = SALT_TYPE_EMBEDDED;
7978 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7979 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7980 kern_type = KERN_TYPE_APR1CRYPT;
7981 dgst_size = DGST_SIZE_4_4;
7982 parse_func = md5apr1_parse_hash;
7983 sort_by_digest = sort_by_digest_4_4;
7984 opti_type = OPTI_TYPE_ZERO_BYTE;
7985 dgst_pos0 = 0;
7986 dgst_pos1 = 1;
7987 dgst_pos2 = 2;
7988 dgst_pos3 = 3;
7989 break;
7990
7991 case 1700: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_NONE;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_ADD80
7996 | OPTS_TYPE_PT_ADDBITS15;
7997 kern_type = KERN_TYPE_SHA512;
7998 dgst_size = DGST_SIZE_8_8;
7999 parse_func = sha512_parse_hash;
8000 sort_by_digest = sort_by_digest_8_8;
8001 opti_type = OPTI_TYPE_ZERO_BYTE
8002 | OPTI_TYPE_PRECOMPUTE_INIT
8003 | OPTI_TYPE_PRECOMPUTE_MERKLE
8004 | OPTI_TYPE_EARLY_SKIP
8005 | OPTI_TYPE_NOT_ITERATED
8006 | OPTI_TYPE_NOT_SALTED
8007 | OPTI_TYPE_USES_BITS_64
8008 | OPTI_TYPE_RAW_HASH;
8009 dgst_pos0 = 14;
8010 dgst_pos1 = 15;
8011 dgst_pos2 = 6;
8012 dgst_pos3 = 7;
8013 break;
8014
8015 case 1710: hash_type = HASH_TYPE_SHA512;
8016 salt_type = SALT_TYPE_INTERN;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_BE
8019 | OPTS_TYPE_ST_ADD80
8020 | OPTS_TYPE_ST_ADDBITS15;
8021 kern_type = KERN_TYPE_SHA512_PWSLT;
8022 dgst_size = DGST_SIZE_8_8;
8023 parse_func = sha512s_parse_hash;
8024 sort_by_digest = sort_by_digest_8_8;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP
8029 | OPTI_TYPE_NOT_ITERATED
8030 | OPTI_TYPE_APPENDED_SALT
8031 | OPTI_TYPE_USES_BITS_64
8032 | OPTI_TYPE_RAW_HASH;
8033 dgst_pos0 = 14;
8034 dgst_pos1 = 15;
8035 dgst_pos2 = 6;
8036 dgst_pos3 = 7;
8037 break;
8038
8039 case 1711: hash_type = HASH_TYPE_SHA512;
8040 salt_type = SALT_TYPE_EMBEDDED;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = OPTS_TYPE_PT_GENERATE_BE
8043 | OPTS_TYPE_ST_ADD80
8044 | OPTS_TYPE_ST_ADDBITS15;
8045 kern_type = KERN_TYPE_SHA512_PWSLT;
8046 dgst_size = DGST_SIZE_8_8;
8047 parse_func = sha512b64s_parse_hash;
8048 sort_by_digest = sort_by_digest_8_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_PRECOMPUTE_INIT
8051 | OPTI_TYPE_PRECOMPUTE_MERKLE
8052 | OPTI_TYPE_EARLY_SKIP
8053 | OPTI_TYPE_NOT_ITERATED
8054 | OPTI_TYPE_APPENDED_SALT
8055 | OPTI_TYPE_USES_BITS_64
8056 | OPTI_TYPE_RAW_HASH;
8057 dgst_pos0 = 14;
8058 dgst_pos1 = 15;
8059 dgst_pos2 = 6;
8060 dgst_pos3 = 7;
8061 break;
8062
8063 case 1720: hash_type = HASH_TYPE_SHA512;
8064 salt_type = SALT_TYPE_INTERN;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_ADD80
8068 | OPTS_TYPE_PT_ADDBITS15;
8069 kern_type = KERN_TYPE_SHA512_SLTPW;
8070 dgst_size = DGST_SIZE_8_8;
8071 parse_func = sha512s_parse_hash;
8072 sort_by_digest = sort_by_digest_8_8;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_PREPENDED_SALT
8079 | OPTI_TYPE_USES_BITS_64
8080 | OPTI_TYPE_RAW_HASH;
8081 dgst_pos0 = 14;
8082 dgst_pos1 = 15;
8083 dgst_pos2 = 6;
8084 dgst_pos3 = 7;
8085 break;
8086
8087 case 1722: hash_type = HASH_TYPE_SHA512;
8088 salt_type = SALT_TYPE_EMBEDDED;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS15
8093 | OPTS_TYPE_ST_HEX;
8094 kern_type = KERN_TYPE_SHA512_SLTPW;
8095 dgst_size = DGST_SIZE_8_8;
8096 parse_func = osx512_parse_hash;
8097 sort_by_digest = sort_by_digest_8_8;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP
8102 | OPTI_TYPE_NOT_ITERATED
8103 | OPTI_TYPE_PREPENDED_SALT
8104 | OPTI_TYPE_USES_BITS_64
8105 | OPTI_TYPE_RAW_HASH;
8106 dgst_pos0 = 14;
8107 dgst_pos1 = 15;
8108 dgst_pos2 = 6;
8109 dgst_pos3 = 7;
8110 break;
8111
8112 case 1730: hash_type = HASH_TYPE_SHA512;
8113 salt_type = SALT_TYPE_INTERN;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_BE
8116 | OPTS_TYPE_PT_UNICODE
8117 | OPTS_TYPE_ST_ADD80
8118 | OPTS_TYPE_ST_ADDBITS15;
8119 kern_type = KERN_TYPE_SHA512_PWSLTU;
8120 dgst_size = DGST_SIZE_8_8;
8121 parse_func = sha512s_parse_hash;
8122 sort_by_digest = sort_by_digest_8_8;
8123 opti_type = OPTI_TYPE_ZERO_BYTE
8124 | OPTI_TYPE_PRECOMPUTE_INIT
8125 | OPTI_TYPE_PRECOMPUTE_MERKLE
8126 | OPTI_TYPE_EARLY_SKIP
8127 | OPTI_TYPE_NOT_ITERATED
8128 | OPTI_TYPE_APPENDED_SALT
8129 | OPTI_TYPE_USES_BITS_64
8130 | OPTI_TYPE_RAW_HASH;
8131 dgst_pos0 = 14;
8132 dgst_pos1 = 15;
8133 dgst_pos2 = 6;
8134 dgst_pos3 = 7;
8135 break;
8136
8137 case 1731: hash_type = HASH_TYPE_SHA512;
8138 salt_type = SALT_TYPE_EMBEDDED;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_PT_UNICODE
8142 | OPTS_TYPE_ST_ADD80
8143 | OPTS_TYPE_ST_ADDBITS15
8144 | OPTS_TYPE_ST_HEX;
8145 kern_type = KERN_TYPE_SHA512_PWSLTU;
8146 dgst_size = DGST_SIZE_8_8;
8147 parse_func = mssql2012_parse_hash;
8148 sort_by_digest = sort_by_digest_8_8;
8149 opti_type = OPTI_TYPE_ZERO_BYTE
8150 | OPTI_TYPE_PRECOMPUTE_INIT
8151 | OPTI_TYPE_PRECOMPUTE_MERKLE
8152 | OPTI_TYPE_EARLY_SKIP
8153 | OPTI_TYPE_NOT_ITERATED
8154 | OPTI_TYPE_APPENDED_SALT
8155 | OPTI_TYPE_USES_BITS_64
8156 | OPTI_TYPE_RAW_HASH;
8157 dgst_pos0 = 14;
8158 dgst_pos1 = 15;
8159 dgst_pos2 = 6;
8160 dgst_pos3 = 7;
8161 break;
8162
8163 case 1740: hash_type = HASH_TYPE_SHA512;
8164 salt_type = SALT_TYPE_INTERN;
8165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_BE
8167 | OPTS_TYPE_PT_ADD80
8168 | OPTS_TYPE_PT_ADDBITS15
8169 | OPTS_TYPE_PT_UNICODE;
8170 kern_type = KERN_TYPE_SHA512_SLTPWU;
8171 dgst_size = DGST_SIZE_8_8;
8172 parse_func = sha512s_parse_hash;
8173 sort_by_digest = sort_by_digest_8_8;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_PRECOMPUTE_INIT
8176 | OPTI_TYPE_PRECOMPUTE_MERKLE
8177 | OPTI_TYPE_EARLY_SKIP
8178 | OPTI_TYPE_NOT_ITERATED
8179 | OPTI_TYPE_PREPENDED_SALT
8180 | OPTI_TYPE_USES_BITS_64
8181 | OPTI_TYPE_RAW_HASH;
8182 dgst_pos0 = 14;
8183 dgst_pos1 = 15;
8184 dgst_pos2 = 6;
8185 dgst_pos3 = 7;
8186 break;
8187
8188 case 1750: hash_type = HASH_TYPE_SHA512;
8189 salt_type = SALT_TYPE_INTERN;
8190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8191 opts_type = OPTS_TYPE_PT_GENERATE_BE
8192 | OPTS_TYPE_ST_ADD80;
8193 kern_type = KERN_TYPE_HMACSHA512_PW;
8194 dgst_size = DGST_SIZE_8_8;
8195 parse_func = hmacsha512_parse_hash;
8196 sort_by_digest = sort_by_digest_8_8;
8197 opti_type = OPTI_TYPE_ZERO_BYTE
8198 | OPTI_TYPE_USES_BITS_64
8199 | OPTI_TYPE_NOT_ITERATED;
8200 dgst_pos0 = 14;
8201 dgst_pos1 = 15;
8202 dgst_pos2 = 6;
8203 dgst_pos3 = 7;
8204 break;
8205
8206 case 1760: hash_type = HASH_TYPE_SHA512;
8207 salt_type = SALT_TYPE_INTERN;
8208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_PT_ADD80
8211 | OPTS_TYPE_PT_ADDBITS15;
8212 kern_type = KERN_TYPE_HMACSHA512_SLT;
8213 dgst_size = DGST_SIZE_8_8;
8214 parse_func = hmacsha512_parse_hash;
8215 sort_by_digest = sort_by_digest_8_8;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_USES_BITS_64
8218 | OPTI_TYPE_NOT_ITERATED;
8219 dgst_pos0 = 14;
8220 dgst_pos1 = 15;
8221 dgst_pos2 = 6;
8222 dgst_pos3 = 7;
8223 break;
8224
8225 case 1800: hash_type = HASH_TYPE_SHA512;
8226 salt_type = SALT_TYPE_EMBEDDED;
8227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8229 kern_type = KERN_TYPE_SHA512CRYPT;
8230 dgst_size = DGST_SIZE_8_8;
8231 parse_func = sha512crypt_parse_hash;
8232 sort_by_digest = sort_by_digest_8_8;
8233 opti_type = OPTI_TYPE_ZERO_BYTE
8234 | OPTI_TYPE_USES_BITS_64;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 1;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 3;
8239 break;
8240
8241 case 2100: hash_type = HASH_TYPE_DCC2;
8242 salt_type = SALT_TYPE_EMBEDDED;
8243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8245 | OPTS_TYPE_ST_LOWER
8246 | OPTS_TYPE_ST_UNICODE;
8247 kern_type = KERN_TYPE_DCC2;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = dcc2_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 1;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 3;
8256 break;
8257
8258 case 2400: hash_type = HASH_TYPE_MD5;
8259 salt_type = SALT_TYPE_NONE;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8262 kern_type = KERN_TYPE_MD5PIX;
8263 dgst_size = DGST_SIZE_4_4;
8264 parse_func = md5pix_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4;
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_INIT
8268 | OPTI_TYPE_PRECOMPUTE_MERKLE
8269 | OPTI_TYPE_EARLY_SKIP
8270 | OPTI_TYPE_NOT_ITERATED
8271 | OPTI_TYPE_NOT_SALTED;
8272 dgst_pos0 = 0;
8273 dgst_pos1 = 3;
8274 dgst_pos2 = 2;
8275 dgst_pos3 = 1;
8276 break;
8277
8278 case 2410: hash_type = HASH_TYPE_MD5;
8279 salt_type = SALT_TYPE_INTERN;
8280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8282 kern_type = KERN_TYPE_MD5ASA;
8283 dgst_size = DGST_SIZE_4_4;
8284 parse_func = md5asa_parse_hash;
8285 sort_by_digest = sort_by_digest_4_4;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_PRECOMPUTE_MERKLE
8289 | OPTI_TYPE_EARLY_SKIP
8290 | OPTI_TYPE_NOT_ITERATED;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 3;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 2500: hash_type = HASH_TYPE_WPA;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8301 kern_type = KERN_TYPE_WPA;
8302 dgst_size = DGST_SIZE_4_4;
8303 parse_func = wpa_parse_hash;
8304 sort_by_digest = sort_by_digest_4_4;
8305 opti_type = OPTI_TYPE_ZERO_BYTE;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 1;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 3;
8310 break;
8311
8312 case 2600: hash_type = HASH_TYPE_MD5;
8313 salt_type = SALT_TYPE_VIRTUAL;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS14
8318 | OPTS_TYPE_ST_ADD80;
8319 kern_type = KERN_TYPE_MD55_PWSLT1;
8320 dgst_size = DGST_SIZE_4_4;
8321 parse_func = md5md5_parse_hash;
8322 sort_by_digest = sort_by_digest_4_4;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_PRECOMPUTE_MERKLE
8326 | OPTI_TYPE_EARLY_SKIP;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 3;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 1;
8331 break;
8332
8333 case 2611: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_INTERN;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14
8339 | OPTS_TYPE_ST_ADD80;
8340 kern_type = KERN_TYPE_MD55_PWSLT1;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = vb3_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_PRECOMPUTE_MERKLE
8347 | OPTI_TYPE_EARLY_SKIP;
8348 dgst_pos0 = 0;
8349 dgst_pos1 = 3;
8350 dgst_pos2 = 2;
8351 dgst_pos3 = 1;
8352 break;
8353
8354 case 2612: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_EMBEDDED;
8356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8357 opts_type = OPTS_TYPE_PT_GENERATE_LE
8358 | OPTS_TYPE_PT_ADD80
8359 | OPTS_TYPE_PT_ADDBITS14
8360 | OPTS_TYPE_ST_ADD80
8361 | OPTS_TYPE_ST_HEX;
8362 kern_type = KERN_TYPE_MD55_PWSLT1;
8363 dgst_size = DGST_SIZE_4_4;
8364 parse_func = phps_parse_hash;
8365 sort_by_digest = sort_by_digest_4_4;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_PRECOMPUTE_INIT
8368 | OPTI_TYPE_PRECOMPUTE_MERKLE
8369 | OPTI_TYPE_EARLY_SKIP;
8370 dgst_pos0 = 0;
8371 dgst_pos1 = 3;
8372 dgst_pos2 = 2;
8373 dgst_pos3 = 1;
8374 break;
8375
8376 case 2711: hash_type = HASH_TYPE_MD5;
8377 salt_type = SALT_TYPE_INTERN;
8378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8379 opts_type = OPTS_TYPE_PT_GENERATE_LE
8380 | OPTS_TYPE_PT_ADD80
8381 | OPTS_TYPE_PT_ADDBITS14
8382 | OPTS_TYPE_ST_ADD80;
8383 kern_type = KERN_TYPE_MD55_PWSLT2;
8384 dgst_size = DGST_SIZE_4_4;
8385 parse_func = vb30_parse_hash;
8386 sort_by_digest = sort_by_digest_4_4;
8387 opti_type = OPTI_TYPE_ZERO_BYTE
8388 | OPTI_TYPE_PRECOMPUTE_INIT
8389 | OPTI_TYPE_EARLY_SKIP;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 2811: hash_type = HASH_TYPE_MD5;
8397 salt_type = SALT_TYPE_INTERN;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE
8400 | OPTS_TYPE_PT_ADD80
8401 | OPTS_TYPE_PT_ADDBITS14;
8402 kern_type = KERN_TYPE_MD55_SLTPW;
8403 dgst_size = DGST_SIZE_4_4;
8404 parse_func = ipb2_parse_hash;
8405 sort_by_digest = sort_by_digest_4_4;
8406 opti_type = OPTI_TYPE_ZERO_BYTE
8407 | OPTI_TYPE_PRECOMPUTE_INIT
8408 | OPTI_TYPE_EARLY_SKIP;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 3;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 1;
8413 break;
8414
8415 case 3000: hash_type = HASH_TYPE_LM;
8416 salt_type = SALT_TYPE_NONE;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_PT_UPPER
8420 | OPTS_TYPE_PT_BITSLICE;
8421 kern_type = KERN_TYPE_LM;
8422 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8423 parse_func = lm_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8425 opti_type = OPTI_TYPE_ZERO_BYTE
8426 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 1;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 3;
8431 break;
8432
8433 case 3100: hash_type = HASH_TYPE_ORACLEH;
8434 salt_type = SALT_TYPE_INTERN;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_PT_UPPER
8438 | OPTS_TYPE_ST_UPPER;
8439 kern_type = KERN_TYPE_ORACLEH;
8440 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8441 parse_func = oracleh_parse_hash;
8442 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8443 opti_type = OPTI_TYPE_ZERO_BYTE;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 1;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 3;
8448 break;
8449
8450 case 3200: hash_type = HASH_TYPE_BCRYPT;
8451 salt_type = SALT_TYPE_EMBEDDED;
8452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_LE
8454 | OPTS_TYPE_ST_GENERATE_LE;
8455 kern_type = KERN_TYPE_BCRYPT;
8456 dgst_size = DGST_SIZE_4_6;
8457 parse_func = bcrypt_parse_hash;
8458 sort_by_digest = sort_by_digest_4_6;
8459 opti_type = OPTI_TYPE_ZERO_BYTE;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 1;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 3;
8464 break;
8465
8466 case 3710: hash_type = HASH_TYPE_MD5;
8467 salt_type = SALT_TYPE_INTERN;
8468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8469 opts_type = OPTS_TYPE_PT_GENERATE_LE
8470 | OPTS_TYPE_PT_ADD80
8471 | OPTS_TYPE_PT_ADDBITS14;
8472 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8473 dgst_size = DGST_SIZE_4_4;
8474 parse_func = md5s_parse_hash;
8475 sort_by_digest = sort_by_digest_4_4;
8476 opti_type = OPTI_TYPE_ZERO_BYTE
8477 | OPTI_TYPE_PRECOMPUTE_INIT
8478 | OPTI_TYPE_PRECOMPUTE_MERKLE
8479 | OPTI_TYPE_EARLY_SKIP;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 3;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486 case 3711: hash_type = HASH_TYPE_MD5;
8487 salt_type = SALT_TYPE_EMBEDDED;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE
8490 | OPTS_TYPE_PT_ADD80
8491 | OPTS_TYPE_PT_ADDBITS14;
8492 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = mediawiki_b_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP;
8500 dgst_pos0 = 0;
8501 dgst_pos1 = 3;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 1;
8504 break;
8505
8506 case 3800: hash_type = HASH_TYPE_MD5;
8507 salt_type = SALT_TYPE_INTERN;
8508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8509 opts_type = OPTS_TYPE_PT_GENERATE_LE
8510 | OPTS_TYPE_ST_ADDBITS14;
8511 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = md5s_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP
8519 | OPTI_TYPE_NOT_ITERATED
8520 | OPTI_TYPE_RAW_HASH;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 3;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 1;
8525 break;
8526
8527 case 4300: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_VIRTUAL;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS14
8533 | OPTS_TYPE_ST_ADD80;
8534 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8535 dgst_size = DGST_SIZE_4_4;
8536 parse_func = md5md5_parse_hash;
8537 sort_by_digest = sort_by_digest_4_4;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_PRECOMPUTE_MERKLE
8541 | OPTI_TYPE_EARLY_SKIP;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 3;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 1;
8546 break;
8547
8548
8549 case 4400: hash_type = HASH_TYPE_MD5;
8550 salt_type = SALT_TYPE_NONE;
8551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8552 opts_type = OPTS_TYPE_PT_GENERATE_BE
8553 | OPTS_TYPE_PT_ADD80
8554 | OPTS_TYPE_PT_ADDBITS15;
8555 kern_type = KERN_TYPE_MD5_SHA1;
8556 dgst_size = DGST_SIZE_4_4;
8557 parse_func = md5_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4;
8559 opti_type = OPTI_TYPE_ZERO_BYTE
8560 | OPTI_TYPE_PRECOMPUTE_INIT
8561 | OPTI_TYPE_PRECOMPUTE_MERKLE
8562 | OPTI_TYPE_EARLY_SKIP
8563 | OPTI_TYPE_NOT_ITERATED
8564 | OPTI_TYPE_NOT_SALTED
8565 | OPTI_TYPE_RAW_HASH;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 3;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 1;
8570 break;
8571
8572 case 4500: hash_type = HASH_TYPE_SHA1;
8573 salt_type = SALT_TYPE_NONE;
8574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_BE
8576 | OPTS_TYPE_PT_ADD80
8577 | OPTS_TYPE_PT_ADDBITS15;
8578 kern_type = KERN_TYPE_SHA11;
8579 dgst_size = DGST_SIZE_4_5;
8580 parse_func = sha1_parse_hash;
8581 sort_by_digest = sort_by_digest_4_5;
8582 opti_type = OPTI_TYPE_ZERO_BYTE
8583 | OPTI_TYPE_PRECOMPUTE_INIT
8584 | OPTI_TYPE_PRECOMPUTE_MERKLE
8585 | OPTI_TYPE_EARLY_SKIP
8586 | OPTI_TYPE_NOT_SALTED;
8587 dgst_pos0 = 3;
8588 dgst_pos1 = 4;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 1;
8591 break;
8592
8593 case 4700: hash_type = HASH_TYPE_SHA1;
8594 salt_type = SALT_TYPE_NONE;
8595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE
8597 | OPTS_TYPE_PT_ADD80
8598 | OPTS_TYPE_PT_ADDBITS14;
8599 kern_type = KERN_TYPE_SHA1_MD5;
8600 dgst_size = DGST_SIZE_4_5;
8601 parse_func = sha1_parse_hash;
8602 sort_by_digest = sort_by_digest_4_5;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_EARLY_SKIP
8607 | OPTI_TYPE_NOT_ITERATED
8608 | OPTI_TYPE_NOT_SALTED
8609 | OPTI_TYPE_RAW_HASH;
8610 dgst_pos0 = 3;
8611 dgst_pos1 = 4;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 1;
8614 break;
8615
8616 case 4800: hash_type = HASH_TYPE_MD5;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE
8620 | OPTS_TYPE_PT_ADDBITS14;
8621 kern_type = KERN_TYPE_MD5_CHAP;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = chap_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE
8626 | OPTI_TYPE_PRECOMPUTE_INIT
8627 | OPTI_TYPE_PRECOMPUTE_MERKLE
8628 | OPTI_TYPE_MEET_IN_MIDDLE
8629 | OPTI_TYPE_EARLY_SKIP
8630 | OPTI_TYPE_NOT_ITERATED
8631 | OPTI_TYPE_RAW_HASH;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 3;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 4900: hash_type = HASH_TYPE_SHA1;
8639 salt_type = SALT_TYPE_INTERN;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8642 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8643 dgst_size = DGST_SIZE_4_5;
8644 parse_func = sha1s_parse_hash;
8645 sort_by_digest = sort_by_digest_4_5;
8646 opti_type = OPTI_TYPE_ZERO_BYTE
8647 | OPTI_TYPE_PRECOMPUTE_INIT
8648 | OPTI_TYPE_PRECOMPUTE_MERKLE
8649 | OPTI_TYPE_EARLY_SKIP;
8650 dgst_pos0 = 3;
8651 dgst_pos1 = 4;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 1;
8654 break;
8655
8656 case 5000: hash_type = HASH_TYPE_KECCAK;
8657 salt_type = SALT_TYPE_EMBEDDED;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE
8660 | OPTS_TYPE_PT_ADD01;
8661 kern_type = KERN_TYPE_KECCAK;
8662 dgst_size = DGST_SIZE_8_25;
8663 parse_func = keccak_parse_hash;
8664 sort_by_digest = sort_by_digest_8_25;
8665 opti_type = OPTI_TYPE_ZERO_BYTE
8666 | OPTI_TYPE_USES_BITS_64
8667 | OPTI_TYPE_RAW_HASH;
8668 dgst_pos0 = 2;
8669 dgst_pos1 = 3;
8670 dgst_pos2 = 4;
8671 dgst_pos3 = 5;
8672 break;
8673
8674 case 5100: hash_type = HASH_TYPE_MD5H;
8675 salt_type = SALT_TYPE_NONE;
8676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE
8678 | OPTS_TYPE_PT_ADD80
8679 | OPTS_TYPE_PT_ADDBITS14;
8680 kern_type = KERN_TYPE_MD5H;
8681 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8682 parse_func = md5half_parse_hash;
8683 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8684 opti_type = OPTI_TYPE_ZERO_BYTE
8685 | OPTI_TYPE_RAW_HASH;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 5200: hash_type = HASH_TYPE_SHA256;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8696 kern_type = KERN_TYPE_PSAFE3;
8697 dgst_size = DGST_SIZE_4_8;
8698 parse_func = psafe3_parse_hash;
8699 sort_by_digest = sort_by_digest_4_8;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 5300: hash_type = HASH_TYPE_MD5;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE
8711 | OPTS_TYPE_ST_ADD80;
8712 kern_type = KERN_TYPE_IKEPSK_MD5;
8713 dgst_size = DGST_SIZE_4_4;
8714 parse_func = ikepsk_md5_parse_hash;
8715 sort_by_digest = sort_by_digest_4_4;
8716 opti_type = OPTI_TYPE_ZERO_BYTE;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 3;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 1;
8721 break;
8722
8723 case 5400: hash_type = HASH_TYPE_SHA1;
8724 salt_type = SALT_TYPE_EMBEDDED;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_BE
8727 | OPTS_TYPE_ST_ADD80;
8728 kern_type = KERN_TYPE_IKEPSK_SHA1;
8729 dgst_size = DGST_SIZE_4_5;
8730 parse_func = ikepsk_sha1_parse_hash;
8731 sort_by_digest = sort_by_digest_4_5;
8732 opti_type = OPTI_TYPE_ZERO_BYTE;
8733 dgst_pos0 = 3;
8734 dgst_pos1 = 4;
8735 dgst_pos2 = 2;
8736 dgst_pos3 = 1;
8737 break;
8738
8739 case 5500: hash_type = HASH_TYPE_NETNTLM;
8740 salt_type = SALT_TYPE_EMBEDDED;
8741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8742 opts_type = OPTS_TYPE_PT_GENERATE_LE
8743 | OPTS_TYPE_PT_ADD80
8744 | OPTS_TYPE_PT_ADDBITS14
8745 | OPTS_TYPE_PT_UNICODE
8746 | OPTS_TYPE_ST_HEX;
8747 kern_type = KERN_TYPE_NETNTLMv1;
8748 dgst_size = DGST_SIZE_4_4;
8749 parse_func = netntlmv1_parse_hash;
8750 sort_by_digest = sort_by_digest_4_4;
8751 opti_type = OPTI_TYPE_ZERO_BYTE
8752 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 5600: hash_type = HASH_TYPE_MD5;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE
8763 | OPTS_TYPE_PT_ADD80
8764 | OPTS_TYPE_PT_ADDBITS14
8765 | OPTS_TYPE_PT_UNICODE;
8766 kern_type = KERN_TYPE_NETNTLMv2;
8767 dgst_size = DGST_SIZE_4_4;
8768 parse_func = netntlmv2_parse_hash;
8769 sort_by_digest = sort_by_digest_4_4;
8770 opti_type = OPTI_TYPE_ZERO_BYTE;
8771 dgst_pos0 = 0;
8772 dgst_pos1 = 3;
8773 dgst_pos2 = 2;
8774 dgst_pos3 = 1;
8775 break;
8776
8777 case 5700: hash_type = HASH_TYPE_SHA256;
8778 salt_type = SALT_TYPE_NONE;
8779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8780 opts_type = OPTS_TYPE_PT_GENERATE_BE
8781 | OPTS_TYPE_PT_ADD80
8782 | OPTS_TYPE_PT_ADDBITS15;
8783 kern_type = KERN_TYPE_SHA256;
8784 dgst_size = DGST_SIZE_4_8;
8785 parse_func = cisco4_parse_hash;
8786 sort_by_digest = sort_by_digest_4_8;
8787 opti_type = OPTI_TYPE_ZERO_BYTE
8788 | OPTI_TYPE_PRECOMPUTE_INIT
8789 | OPTI_TYPE_PRECOMPUTE_MERKLE
8790 | OPTI_TYPE_EARLY_SKIP
8791 | OPTI_TYPE_NOT_ITERATED
8792 | OPTI_TYPE_NOT_SALTED
8793 | OPTI_TYPE_RAW_HASH;
8794 dgst_pos0 = 3;
8795 dgst_pos1 = 7;
8796 dgst_pos2 = 2;
8797 dgst_pos3 = 6;
8798 break;
8799
8800 case 5800: hash_type = HASH_TYPE_SHA1;
8801 salt_type = SALT_TYPE_INTERN;
8802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8803 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8804 | OPTS_TYPE_ST_ADD80;
8805 kern_type = KERN_TYPE_ANDROIDPIN;
8806 dgst_size = DGST_SIZE_4_5;
8807 parse_func = androidpin_parse_hash;
8808 sort_by_digest = sort_by_digest_4_5;
8809 opti_type = OPTI_TYPE_ZERO_BYTE;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8817 salt_type = SALT_TYPE_NONE;
8818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE
8820 | OPTS_TYPE_PT_ADD80;
8821 kern_type = KERN_TYPE_RIPEMD160;
8822 dgst_size = DGST_SIZE_4_5;
8823 parse_func = ripemd160_parse_hash;
8824 sort_by_digest = sort_by_digest_4_5;
8825 opti_type = OPTI_TYPE_ZERO_BYTE;
8826 dgst_pos0 = 0;
8827 dgst_pos1 = 1;
8828 dgst_pos2 = 2;
8829 dgst_pos3 = 3;
8830 break;
8831
8832 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8833 salt_type = SALT_TYPE_NONE;
8834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_BE
8836 | OPTS_TYPE_PT_ADD80;
8837 kern_type = KERN_TYPE_WHIRLPOOL;
8838 dgst_size = DGST_SIZE_4_16;
8839 parse_func = whirlpool_parse_hash;
8840 sort_by_digest = sort_by_digest_4_16;
8841 opti_type = OPTI_TYPE_ZERO_BYTE;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8849 salt_type = SALT_TYPE_EMBEDDED;
8850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8852 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8853 dgst_size = DGST_SIZE_4_5;
8854 parse_func = truecrypt_parse_hash_2k;
8855 sort_by_digest = sort_by_digest_4_5;
8856 opti_type = OPTI_TYPE_ZERO_BYTE;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8867 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8868 dgst_size = DGST_SIZE_4_5;
8869 parse_func = truecrypt_parse_hash_2k;
8870 sort_by_digest = sort_by_digest_4_5;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8882 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8883 dgst_size = DGST_SIZE_4_5;
8884 parse_func = truecrypt_parse_hash_2k;
8885 sort_by_digest = sort_by_digest_4_5;
8886 opti_type = OPTI_TYPE_ZERO_BYTE;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 1;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 3;
8891 break;
8892
8893 case 6221: hash_type = HASH_TYPE_SHA512;
8894 salt_type = SALT_TYPE_EMBEDDED;
8895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8897 kern_type = KERN_TYPE_TCSHA512_XTS512;
8898 dgst_size = DGST_SIZE_8_8;
8899 parse_func = truecrypt_parse_hash_1k;
8900 sort_by_digest = sort_by_digest_8_8;
8901 opti_type = OPTI_TYPE_ZERO_BYTE
8902 | OPTI_TYPE_USES_BITS_64;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6222: hash_type = HASH_TYPE_SHA512;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8913 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8914 dgst_size = DGST_SIZE_8_8;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_8_8;
8917 opti_type = OPTI_TYPE_ZERO_BYTE
8918 | OPTI_TYPE_USES_BITS_64;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 6223: hash_type = HASH_TYPE_SHA512;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8929 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8930 dgst_size = DGST_SIZE_8_8;
8931 parse_func = truecrypt_parse_hash_1k;
8932 sort_by_digest = sort_by_digest_8_8;
8933 opti_type = OPTI_TYPE_ZERO_BYTE
8934 | OPTI_TYPE_USES_BITS_64;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8945 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8946 dgst_size = DGST_SIZE_4_8;
8947 parse_func = truecrypt_parse_hash_1k;
8948 sort_by_digest = sort_by_digest_4_8;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8961 dgst_size = DGST_SIZE_4_8;
8962 parse_func = truecrypt_parse_hash_1k;
8963 sort_by_digest = sort_by_digest_4_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8976 dgst_size = DGST_SIZE_4_8;
8977 parse_func = truecrypt_parse_hash_1k;
8978 sort_by_digest = sort_by_digest_4_8;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8990 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8991 dgst_size = DGST_SIZE_4_5;
8992 parse_func = truecrypt_parse_hash_1k;
8993 sort_by_digest = sort_by_digest_4_5;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9002 salt_type = SALT_TYPE_EMBEDDED;
9003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9005 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9006 dgst_size = DGST_SIZE_4_5;
9007 parse_func = truecrypt_parse_hash_1k;
9008 sort_by_digest = sort_by_digest_4_5;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9020 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9021 dgst_size = DGST_SIZE_4_5;
9022 parse_func = truecrypt_parse_hash_1k;
9023 sort_by_digest = sort_by_digest_4_5;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 6300: hash_type = HASH_TYPE_MD5;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9035 kern_type = KERN_TYPE_MD5AIX;
9036 dgst_size = DGST_SIZE_4_4;
9037 parse_func = md5aix_parse_hash;
9038 sort_by_digest = sort_by_digest_4_4;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6400: hash_type = HASH_TYPE_SHA256;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_SHA256AIX;
9051 dgst_size = DGST_SIZE_4_8;
9052 parse_func = sha256aix_parse_hash;
9053 sort_by_digest = sort_by_digest_4_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 6500: hash_type = HASH_TYPE_SHA512;
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_SHA512AIX;
9066 dgst_size = DGST_SIZE_8_8;
9067 parse_func = sha512aix_parse_hash;
9068 sort_by_digest = sort_by_digest_8_8;
9069 opti_type = OPTI_TYPE_ZERO_BYTE
9070 | OPTI_TYPE_USES_BITS_64;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 6600: hash_type = HASH_TYPE_AES;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9081 kern_type = KERN_TYPE_AGILEKEY;
9082 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9083 parse_func = agilekey_parse_hash;
9084 sort_by_digest = sort_by_digest_4_5;
9085 opti_type = OPTI_TYPE_ZERO_BYTE;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 6700: hash_type = HASH_TYPE_SHA1;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9096 kern_type = KERN_TYPE_SHA1AIX;
9097 dgst_size = DGST_SIZE_4_5;
9098 parse_func = sha1aix_parse_hash;
9099 sort_by_digest = sort_by_digest_4_5;
9100 opti_type = OPTI_TYPE_ZERO_BYTE;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6800: hash_type = HASH_TYPE_AES;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_LASTPASS;
9112 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9113 parse_func = lastpass_parse_hash;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 6900: hash_type = HASH_TYPE_GOST;
9123 salt_type = SALT_TYPE_NONE;
9124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9126 kern_type = KERN_TYPE_GOST;
9127 dgst_size = DGST_SIZE_4_8;
9128 parse_func = gost_parse_hash;
9129 sort_by_digest = sort_by_digest_4_8;
9130 opti_type = OPTI_TYPE_ZERO_BYTE;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 7100: hash_type = HASH_TYPE_SHA512;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9141 kern_type = KERN_TYPE_PBKDF2_SHA512;
9142 dgst_size = DGST_SIZE_8_16;
9143 parse_func = sha512osx_parse_hash;
9144 sort_by_digest = sort_by_digest_8_16;
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_USES_BITS_64;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 7200: hash_type = HASH_TYPE_SHA512;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9157 kern_type = KERN_TYPE_PBKDF2_SHA512;
9158 dgst_size = DGST_SIZE_8_16;
9159 parse_func = sha512grub_parse_hash;
9160 sort_by_digest = sort_by_digest_8_16;
9161 opti_type = OPTI_TYPE_ZERO_BYTE
9162 | OPTI_TYPE_USES_BITS_64;
9163 dgst_pos0 = 0;
9164 dgst_pos1 = 1;
9165 dgst_pos2 = 2;
9166 dgst_pos3 = 3;
9167 break;
9168
9169 case 7300: hash_type = HASH_TYPE_SHA1;
9170 salt_type = SALT_TYPE_EMBEDDED;
9171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9172 opts_type = OPTS_TYPE_PT_GENERATE_BE
9173 | OPTS_TYPE_ST_ADD80
9174 | OPTS_TYPE_ST_ADDBITS15;
9175 kern_type = KERN_TYPE_RAKP;
9176 dgst_size = DGST_SIZE_4_5;
9177 parse_func = rakp_parse_hash;
9178 sort_by_digest = sort_by_digest_4_5;
9179 opti_type = OPTI_TYPE_ZERO_BYTE
9180 | OPTI_TYPE_NOT_ITERATED;
9181 dgst_pos0 = 3;
9182 dgst_pos1 = 4;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 1;
9185 break;
9186
9187 case 7400: hash_type = HASH_TYPE_SHA256;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9191 kern_type = KERN_TYPE_SHA256CRYPT;
9192 dgst_size = DGST_SIZE_4_8;
9193 parse_func = sha256crypt_parse_hash;
9194 sort_by_digest = sort_by_digest_4_8;
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 7500: hash_type = HASH_TYPE_KRB5PA;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9206 kern_type = KERN_TYPE_KRB5PA;
9207 dgst_size = DGST_SIZE_4_4;
9208 parse_func = krb5pa_parse_hash;
9209 sort_by_digest = sort_by_digest_4_4;
9210 opti_type = OPTI_TYPE_ZERO_BYTE
9211 | OPTI_TYPE_NOT_ITERATED;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 7600: hash_type = HASH_TYPE_SHA1;
9219 salt_type = SALT_TYPE_INTERN;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_BE
9222 | OPTS_TYPE_PT_ADD80
9223 | OPTS_TYPE_PT_ADDBITS15;
9224 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9225 dgst_size = DGST_SIZE_4_5;
9226 parse_func = redmine_parse_hash;
9227 sort_by_digest = sort_by_digest_4_5;
9228 opti_type = OPTI_TYPE_ZERO_BYTE
9229 | OPTI_TYPE_PRECOMPUTE_INIT
9230 | OPTI_TYPE_EARLY_SKIP
9231 | OPTI_TYPE_NOT_ITERATED
9232 | OPTI_TYPE_PREPENDED_SALT;
9233 dgst_pos0 = 3;
9234 dgst_pos1 = 4;
9235 dgst_pos2 = 2;
9236 dgst_pos3 = 1;
9237 break;
9238
9239 case 7700: hash_type = HASH_TYPE_SAPB;
9240 salt_type = SALT_TYPE_EMBEDDED;
9241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9242 opts_type = OPTS_TYPE_PT_GENERATE_LE
9243 | OPTS_TYPE_PT_UPPER
9244 | OPTS_TYPE_ST_UPPER;
9245 kern_type = KERN_TYPE_SAPB;
9246 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9247 parse_func = sapb_parse_hash;
9248 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9249 opti_type = OPTI_TYPE_ZERO_BYTE
9250 | OPTI_TYPE_PRECOMPUTE_INIT
9251 | OPTI_TYPE_NOT_ITERATED;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 7800: hash_type = HASH_TYPE_SAPG;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_BE
9262 | OPTS_TYPE_ST_ADD80
9263 | OPTS_TYPE_ST_UPPER;
9264 kern_type = KERN_TYPE_SAPG;
9265 dgst_size = DGST_SIZE_4_5;
9266 parse_func = sapg_parse_hash;
9267 sort_by_digest = sort_by_digest_4_5;
9268 opti_type = OPTI_TYPE_ZERO_BYTE
9269 | OPTI_TYPE_PRECOMPUTE_INIT
9270 | OPTI_TYPE_NOT_ITERATED;
9271 dgst_pos0 = 3;
9272 dgst_pos1 = 4;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 1;
9275 break;
9276
9277 case 7900: hash_type = HASH_TYPE_SHA512;
9278 salt_type = SALT_TYPE_EMBEDDED;
9279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9281 kern_type = KERN_TYPE_DRUPAL7;
9282 dgst_size = DGST_SIZE_8_8;
9283 parse_func = drupal7_parse_hash;
9284 sort_by_digest = sort_by_digest_8_8;
9285 opti_type = OPTI_TYPE_ZERO_BYTE
9286 | OPTI_TYPE_USES_BITS_64;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 8000: hash_type = HASH_TYPE_SHA256;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_BE
9297 | OPTS_TYPE_PT_UNICODE
9298 | OPTS_TYPE_ST_ADD80
9299 | OPTS_TYPE_ST_HEX;
9300 kern_type = KERN_TYPE_SYBASEASE;
9301 dgst_size = DGST_SIZE_4_8;
9302 parse_func = sybasease_parse_hash;
9303 sort_by_digest = sort_by_digest_4_8;
9304 opti_type = OPTI_TYPE_ZERO_BYTE
9305 | OPTI_TYPE_PRECOMPUTE_INIT
9306 | OPTI_TYPE_EARLY_SKIP
9307 | OPTI_TYPE_NOT_ITERATED
9308 | OPTI_TYPE_RAW_HASH;
9309 dgst_pos0 = 3;
9310 dgst_pos1 = 7;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 6;
9313 break;
9314
9315 case 8100: hash_type = HASH_TYPE_SHA1;
9316 salt_type = SALT_TYPE_EMBEDDED;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9319 kern_type = KERN_TYPE_NETSCALER;
9320 dgst_size = DGST_SIZE_4_5;
9321 parse_func = netscaler_parse_hash;
9322 sort_by_digest = sort_by_digest_4_5;
9323 opti_type = OPTI_TYPE_ZERO_BYTE
9324 | OPTI_TYPE_PRECOMPUTE_INIT
9325 | OPTI_TYPE_PRECOMPUTE_MERKLE
9326 | OPTI_TYPE_EARLY_SKIP
9327 | OPTI_TYPE_NOT_ITERATED
9328 | OPTI_TYPE_PREPENDED_SALT
9329 | OPTI_TYPE_RAW_HASH;
9330 dgst_pos0 = 3;
9331 dgst_pos1 = 4;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 1;
9334 break;
9335
9336 case 8200: hash_type = HASH_TYPE_SHA256;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9340 kern_type = KERN_TYPE_CLOUDKEY;
9341 dgst_size = DGST_SIZE_4_8;
9342 parse_func = cloudkey_parse_hash;
9343 sort_by_digest = sort_by_digest_4_8;
9344 opti_type = OPTI_TYPE_ZERO_BYTE;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 8300: hash_type = HASH_TYPE_SHA1;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_BE
9355 | OPTS_TYPE_ST_HEX
9356 | OPTS_TYPE_ST_ADD80;
9357 kern_type = KERN_TYPE_NSEC3;
9358 dgst_size = DGST_SIZE_4_5;
9359 parse_func = nsec3_parse_hash;
9360 sort_by_digest = sort_by_digest_4_5;
9361 opti_type = OPTI_TYPE_ZERO_BYTE;
9362 dgst_pos0 = 3;
9363 dgst_pos1 = 4;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 1;
9366 break;
9367
9368 case 8400: hash_type = HASH_TYPE_SHA1;
9369 salt_type = SALT_TYPE_INTERN;
9370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_BE
9372 | OPTS_TYPE_PT_ADD80
9373 | OPTS_TYPE_PT_ADDBITS15;
9374 kern_type = KERN_TYPE_WBB3;
9375 dgst_size = DGST_SIZE_4_5;
9376 parse_func = wbb3_parse_hash;
9377 sort_by_digest = sort_by_digest_4_5;
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_PRECOMPUTE_INIT
9380 | OPTI_TYPE_NOT_ITERATED;
9381 dgst_pos0 = 3;
9382 dgst_pos1 = 4;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 1;
9385 break;
9386
9387 case 8500: hash_type = HASH_TYPE_DESRACF;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_ST_UPPER;
9392 kern_type = KERN_TYPE_RACF;
9393 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9394 parse_func = racf_parse_hash;
9395 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9396 opti_type = OPTI_TYPE_ZERO_BYTE
9397 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8600: hash_type = HASH_TYPE_LOTUS5;
9405 salt_type = SALT_TYPE_NONE;
9406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_LOTUS5;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = lotus5_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_EARLY_SKIP
9413 | OPTI_TYPE_NOT_ITERATED
9414 | OPTI_TYPE_NOT_SALTED
9415 | OPTI_TYPE_RAW_HASH;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 8700: hash_type = HASH_TYPE_LOTUS6;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_LOTUS6;
9427 dgst_size = DGST_SIZE_4_4;
9428 parse_func = lotus6_parse_hash;
9429 sort_by_digest = sort_by_digest_4_4;
9430 opti_type = OPTI_TYPE_EARLY_SKIP
9431 | OPTI_TYPE_NOT_ITERATED
9432 | OPTI_TYPE_RAW_HASH;
9433 dgst_pos0 = 0;
9434 dgst_pos1 = 1;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 3;
9437 break;
9438
9439 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9440 salt_type = SALT_TYPE_EMBEDDED;
9441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9443 kern_type = KERN_TYPE_ANDROIDFDE;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = androidfde_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 8900: hash_type = HASH_TYPE_SCRYPT;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_SCRYPT;
9459 dgst_size = DGST_SIZE_4_8;
9460 parse_func = scrypt_parse_hash;
9461 sort_by_digest = sort_by_digest_4_8;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 9000: hash_type = HASH_TYPE_SHA1;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_LE
9473 | OPTS_TYPE_ST_GENERATE_LE;
9474 kern_type = KERN_TYPE_PSAFE2;
9475 dgst_size = DGST_SIZE_4_5;
9476 parse_func = psafe2_parse_hash;
9477 sort_by_digest = sort_by_digest_4_5;
9478 opti_type = OPTI_TYPE_ZERO_BYTE;
9479 dgst_pos0 = 0;
9480 dgst_pos1 = 1;
9481 dgst_pos2 = 2;
9482 dgst_pos3 = 3;
9483 break;
9484
9485 case 9100: hash_type = HASH_TYPE_LOTUS8;
9486 salt_type = SALT_TYPE_EMBEDDED;
9487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9488 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9489 kern_type = KERN_TYPE_LOTUS8;
9490 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9491 parse_func = lotus8_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9493 opti_type = OPTI_TYPE_ZERO_BYTE;
9494 dgst_pos0 = 0;
9495 dgst_pos1 = 1;
9496 dgst_pos2 = 2;
9497 dgst_pos3 = 3;
9498 break;
9499
9500 case 9200: hash_type = HASH_TYPE_SHA256;
9501 salt_type = SALT_TYPE_EMBEDDED;
9502 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9503 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9504 kern_type = KERN_TYPE_PBKDF2_SHA256;
9505 dgst_size = DGST_SIZE_4_32;
9506 parse_func = cisco8_parse_hash;
9507 sort_by_digest = sort_by_digest_4_32;
9508 opti_type = OPTI_TYPE_ZERO_BYTE;
9509 dgst_pos0 = 0;
9510 dgst_pos1 = 1;
9511 dgst_pos2 = 2;
9512 dgst_pos3 = 3;
9513 break;
9514
9515 case 9300: hash_type = HASH_TYPE_SCRYPT;
9516 salt_type = SALT_TYPE_EMBEDDED;
9517 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9518 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9519 kern_type = KERN_TYPE_SCRYPT;
9520 dgst_size = DGST_SIZE_4_8;
9521 parse_func = cisco9_parse_hash;
9522 sort_by_digest = sort_by_digest_4_8;
9523 opti_type = OPTI_TYPE_ZERO_BYTE;
9524 dgst_pos0 = 0;
9525 dgst_pos1 = 1;
9526 dgst_pos2 = 2;
9527 dgst_pos3 = 3;
9528 break;
9529
9530 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9531 salt_type = SALT_TYPE_EMBEDDED;
9532 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9533 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9534 kern_type = KERN_TYPE_OFFICE2007;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = office2007_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE;
9539 dgst_pos0 = 0;
9540 dgst_pos1 = 1;
9541 dgst_pos2 = 2;
9542 dgst_pos3 = 3;
9543 break;
9544
9545 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9546 salt_type = SALT_TYPE_EMBEDDED;
9547 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9548 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9549 kern_type = KERN_TYPE_OFFICE2010;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = office2010_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_OFFICE2013;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = office2013_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_ZERO_BYTE;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE
9579 | OPTS_TYPE_PT_ADD80
9580 | OPTS_TYPE_PT_UNICODE;
9581 kern_type = KERN_TYPE_OLDOFFICE01;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = oldoffice01_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_ZERO_BYTE
9586 | OPTI_TYPE_PRECOMPUTE_INIT
9587 | OPTI_TYPE_NOT_ITERATED;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE
9598 | OPTS_TYPE_PT_ADD80;
9599 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = oldoffice01cm1_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_PRECOMPUTE_INIT
9605 | OPTI_TYPE_NOT_ITERATED;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE
9616 | OPTS_TYPE_PT_ADD80
9617 | OPTS_TYPE_PT_UNICODE
9618 | OPTS_TYPE_PT_NEVERCRACK;
9619 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9620 dgst_size = DGST_SIZE_4_4;
9621 parse_func = oldoffice01cm2_parse_hash;
9622 sort_by_digest = sort_by_digest_4_4;
9623 opti_type = OPTI_TYPE_ZERO_BYTE
9624 | OPTI_TYPE_PRECOMPUTE_INIT
9625 | OPTI_TYPE_NOT_ITERATED;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_BE
9636 | OPTS_TYPE_PT_ADD80
9637 | OPTS_TYPE_PT_UNICODE;
9638 kern_type = KERN_TYPE_OLDOFFICE34;
9639 dgst_size = DGST_SIZE_4_4;
9640 parse_func = oldoffice34_parse_hash;
9641 sort_by_digest = sort_by_digest_4_4;
9642 opti_type = OPTI_TYPE_ZERO_BYTE
9643 | OPTI_TYPE_PRECOMPUTE_INIT
9644 | OPTI_TYPE_NOT_ITERATED;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9656 dgst_size = DGST_SIZE_4_4;
9657 parse_func = oldoffice34cm1_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4;
9659 opti_type = OPTI_TYPE_ZERO_BYTE
9660 | OPTI_TYPE_PRECOMPUTE_INIT
9661 | OPTI_TYPE_NOT_ITERATED;
9662 dgst_pos0 = 0;
9663 dgst_pos1 = 1;
9664 dgst_pos2 = 2;
9665 dgst_pos3 = 3;
9666 break;
9667
9668 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_BE
9672 | OPTS_TYPE_PT_ADD80
9673 | OPTS_TYPE_PT_UNICODE
9674 | OPTS_TYPE_PT_NEVERCRACK;
9675 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9676 dgst_size = DGST_SIZE_4_4;
9677 parse_func = oldoffice34cm2_parse_hash;
9678 sort_by_digest = sort_by_digest_4_4;
9679 opti_type = OPTI_TYPE_ZERO_BYTE
9680 | OPTI_TYPE_PRECOMPUTE_INIT
9681 | OPTI_TYPE_NOT_ITERATED;
9682 dgst_pos0 = 0;
9683 dgst_pos1 = 1;
9684 dgst_pos2 = 2;
9685 dgst_pos3 = 3;
9686 break;
9687
9688 case 9900: hash_type = HASH_TYPE_MD5;
9689 salt_type = SALT_TYPE_NONE;
9690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9691 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9692 kern_type = KERN_TYPE_RADMIN2;
9693 dgst_size = DGST_SIZE_4_4;
9694 parse_func = radmin2_parse_hash;
9695 sort_by_digest = sort_by_digest_4_4;
9696 opti_type = OPTI_TYPE_ZERO_BYTE
9697 | OPTI_TYPE_PRECOMPUTE_INIT
9698 | OPTI_TYPE_EARLY_SKIP
9699 | OPTI_TYPE_NOT_ITERATED
9700 | OPTI_TYPE_NOT_SALTED;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 3;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 1;
9705 break;
9706
9707 case 10000: hash_type = HASH_TYPE_SHA256;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9711 kern_type = KERN_TYPE_PBKDF2_SHA256;
9712 dgst_size = DGST_SIZE_4_32;
9713 parse_func = djangopbkdf2_parse_hash;
9714 sort_by_digest = sort_by_digest_4_32;
9715 opti_type = OPTI_TYPE_ZERO_BYTE;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 10100: hash_type = HASH_TYPE_SIPHASH;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_SIPHASH;
9727 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9728 parse_func = siphash_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED
9732 | OPTI_TYPE_RAW_HASH;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10200: hash_type = HASH_TYPE_MD5;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_ST_ADD80
9744 | OPTS_TYPE_ST_ADDBITS14;
9745 kern_type = KERN_TYPE_HMACMD5_PW;
9746 dgst_size = DGST_SIZE_4_4;
9747 parse_func = crammd5_parse_hash;
9748 sort_by_digest = sort_by_digest_4_4;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 3;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 1;
9755 break;
9756
9757 case 10300: hash_type = HASH_TYPE_SHA1;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9761 kern_type = KERN_TYPE_SAPH_SHA1;
9762 dgst_size = DGST_SIZE_4_5;
9763 parse_func = saph_sha1_parse_hash;
9764 sort_by_digest = sort_by_digest_4_5;
9765 opti_type = OPTI_TYPE_ZERO_BYTE;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 10400: hash_type = HASH_TYPE_PDFU16;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_PDF11;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = pdf11_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_NOT_ITERATED;
9782 dgst_pos0 = 0;
9783 dgst_pos1 = 1;
9784 dgst_pos2 = 2;
9785 dgst_pos3 = 3;
9786 break;
9787
9788 case 10410: hash_type = HASH_TYPE_PDFU16;
9789 salt_type = SALT_TYPE_EMBEDDED;
9790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9792 kern_type = KERN_TYPE_PDF11CM1;
9793 dgst_size = DGST_SIZE_4_4;
9794 parse_func = pdf11cm1_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_NOT_ITERATED;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 1;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 3;
9802 break;
9803
9804 case 10420: hash_type = HASH_TYPE_PDFU16;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9808 kern_type = KERN_TYPE_PDF11CM2;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = pdf11cm2_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 10500: hash_type = HASH_TYPE_PDFU16;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_PDF14;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = pdf14_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_NOT_ITERATED;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 10600: hash_type = HASH_TYPE_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_ST_ADD80
9841 | OPTS_TYPE_ST_ADDBITS15
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_SHA256_PWSLT;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = pdf17l3_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_PRECOMPUTE_MERKLE
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_APPENDED_SALT
9853 | OPTI_TYPE_RAW_HASH;
9854 dgst_pos0 = 3;
9855 dgst_pos1 = 7;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 6;
9858 break;
9859
9860 case 10700: hash_type = HASH_TYPE_PDFU32;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_LE
9864 | OPTS_TYPE_HASH_COPY;
9865 kern_type = KERN_TYPE_PDF17L8;
9866 dgst_size = DGST_SIZE_4_8;
9867 parse_func = pdf17l8_parse_hash;
9868 sort_by_digest = sort_by_digest_4_8;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_NOT_ITERATED;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 10800: hash_type = HASH_TYPE_SHA384;
9878 salt_type = SALT_TYPE_NONE;
9879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_BE
9881 | OPTS_TYPE_PT_ADD80
9882 | OPTS_TYPE_PT_ADDBITS15;
9883 kern_type = KERN_TYPE_SHA384;
9884 dgst_size = DGST_SIZE_8_8;
9885 parse_func = sha384_parse_hash;
9886 sort_by_digest = sort_by_digest_8_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE
9888 | OPTI_TYPE_PRECOMPUTE_INIT
9889 | OPTI_TYPE_PRECOMPUTE_MERKLE
9890 | OPTI_TYPE_EARLY_SKIP
9891 | OPTI_TYPE_NOT_ITERATED
9892 | OPTI_TYPE_NOT_SALTED
9893 | OPTI_TYPE_USES_BITS_64
9894 | OPTI_TYPE_RAW_HASH;
9895 dgst_pos0 = 6;
9896 dgst_pos1 = 7;
9897 dgst_pos2 = 4;
9898 dgst_pos3 = 5;
9899 break;
9900
9901 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9902 salt_type = SALT_TYPE_EMBEDDED;
9903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_ST_BASE64
9906 | OPTS_TYPE_HASH_COPY;
9907 kern_type = KERN_TYPE_PBKDF2_SHA256;
9908 dgst_size = DGST_SIZE_4_32;
9909 parse_func = pbkdf2_sha256_parse_hash;
9910 sort_by_digest = sort_by_digest_4_32;
9911 opti_type = OPTI_TYPE_ZERO_BYTE;
9912 dgst_pos0 = 0;
9913 dgst_pos1 = 1;
9914 dgst_pos2 = 2;
9915 dgst_pos3 = 3;
9916 break;
9917
9918 case 11000: hash_type = HASH_TYPE_MD5;
9919 salt_type = SALT_TYPE_INTERN;
9920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9921 opts_type = OPTS_TYPE_PT_GENERATE_LE
9922 | OPTS_TYPE_PT_ADD80;
9923 kern_type = KERN_TYPE_PRESTASHOP;
9924 dgst_size = DGST_SIZE_4_4;
9925 parse_func = prestashop_parse_hash;
9926 sort_by_digest = sort_by_digest_4_4;
9927 opti_type = OPTI_TYPE_ZERO_BYTE
9928 | OPTI_TYPE_PRECOMPUTE_INIT
9929 | OPTI_TYPE_NOT_ITERATED
9930 | OPTI_TYPE_PREPENDED_SALT;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 3;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 1;
9935 break;
9936
9937 case 11100: hash_type = HASH_TYPE_MD5;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE
9941 | OPTS_TYPE_ST_ADD80;
9942 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9943 dgst_size = DGST_SIZE_4_4;
9944 parse_func = postgresql_auth_parse_hash;
9945 sort_by_digest = sort_by_digest_4_4;
9946 opti_type = OPTI_TYPE_ZERO_BYTE
9947 | OPTI_TYPE_PRECOMPUTE_INIT
9948 | OPTI_TYPE_PRECOMPUTE_MERKLE
9949 | OPTI_TYPE_EARLY_SKIP;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 3;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 1;
9954 break;
9955
9956 case 11200: hash_type = HASH_TYPE_SHA1;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_BE
9960 | OPTS_TYPE_PT_ADD80
9961 | OPTS_TYPE_ST_HEX;
9962 kern_type = KERN_TYPE_MYSQL_AUTH;
9963 dgst_size = DGST_SIZE_4_5;
9964 parse_func = mysql_auth_parse_hash;
9965 sort_by_digest = sort_by_digest_4_5;
9966 opti_type = OPTI_TYPE_ZERO_BYTE
9967 | OPTI_TYPE_EARLY_SKIP;
9968 dgst_pos0 = 3;
9969 dgst_pos1 = 4;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 1;
9972 break;
9973
9974 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE
9978 | OPTS_TYPE_ST_HEX
9979 | OPTS_TYPE_ST_ADD80;
9980 kern_type = KERN_TYPE_BITCOIN_WALLET;
9981 dgst_size = DGST_SIZE_4_4;
9982 parse_func = bitcoin_wallet_parse_hash;
9983 sort_by_digest = sort_by_digest_4_4;
9984 opti_type = OPTI_TYPE_ZERO_BYTE;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 11400: hash_type = HASH_TYPE_MD5;
9992 salt_type = SALT_TYPE_EMBEDDED;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_LE
9995 | OPTS_TYPE_PT_ADD80
9996 | OPTS_TYPE_HASH_COPY;
9997 kern_type = KERN_TYPE_SIP_AUTH;
9998 dgst_size = DGST_SIZE_4_4;
9999 parse_func = sip_auth_parse_hash;
10000 sort_by_digest = sort_by_digest_4_4;
10001 opti_type = OPTI_TYPE_ZERO_BYTE;
10002 dgst_pos0 = 0;
10003 dgst_pos1 = 3;
10004 dgst_pos2 = 2;
10005 dgst_pos3 = 1;
10006 break;
10007
10008 case 11500: hash_type = HASH_TYPE_CRC32;
10009 salt_type = SALT_TYPE_INTERN;
10010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10011 opts_type = OPTS_TYPE_PT_GENERATE_LE
10012 | OPTS_TYPE_ST_GENERATE_LE
10013 | OPTS_TYPE_ST_HEX;
10014 kern_type = KERN_TYPE_CRC32;
10015 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10016 parse_func = crc32_parse_hash;
10017 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10018 opti_type = OPTI_TYPE_ZERO_BYTE;
10019 dgst_pos0 = 0;
10020 dgst_pos1 = 1;
10021 dgst_pos2 = 2;
10022 dgst_pos3 = 3;
10023 break;
10024
10025 case 11600: hash_type = HASH_TYPE_AES;
10026 salt_type = SALT_TYPE_EMBEDDED;
10027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10028 opts_type = OPTS_TYPE_PT_GENERATE_LE
10029 | OPTS_TYPE_PT_NEVERCRACK;
10030 kern_type = KERN_TYPE_SEVEN_ZIP;
10031 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10032 parse_func = seven_zip_parse_hash;
10033 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10034 opti_type = OPTI_TYPE_ZERO_BYTE;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10042 salt_type = SALT_TYPE_NONE;
10043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE
10045 | OPTS_TYPE_PT_ADD01;
10046 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10047 dgst_size = DGST_SIZE_4_8;
10048 parse_func = gost2012sbog_256_parse_hash;
10049 sort_by_digest = sort_by_digest_4_8;
10050 opti_type = OPTI_TYPE_ZERO_BYTE;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10058 salt_type = SALT_TYPE_NONE;
10059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE
10061 | OPTS_TYPE_PT_ADD01;
10062 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10063 dgst_size = DGST_SIZE_4_16;
10064 parse_func = gost2012sbog_512_parse_hash;
10065 sort_by_digest = sort_by_digest_4_16;
10066 opti_type = OPTI_TYPE_ZERO_BYTE;
10067 dgst_pos0 = 0;
10068 dgst_pos1 = 1;
10069 dgst_pos2 = 2;
10070 dgst_pos3 = 3;
10071 break;
10072
10073 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10074 salt_type = SALT_TYPE_EMBEDDED;
10075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10076 opts_type = OPTS_TYPE_PT_GENERATE_LE
10077 | OPTS_TYPE_ST_BASE64
10078 | OPTS_TYPE_HASH_COPY;
10079 kern_type = KERN_TYPE_PBKDF2_MD5;
10080 dgst_size = DGST_SIZE_4_32;
10081 parse_func = pbkdf2_md5_parse_hash;
10082 sort_by_digest = sort_by_digest_4_32;
10083 opti_type = OPTI_TYPE_ZERO_BYTE;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 1;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 3;
10088 break;
10089
10090 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE
10094 | OPTS_TYPE_ST_BASE64
10095 | OPTS_TYPE_HASH_COPY;
10096 kern_type = KERN_TYPE_PBKDF2_SHA1;
10097 dgst_size = DGST_SIZE_4_32;
10098 parse_func = pbkdf2_sha1_parse_hash;
10099 sort_by_digest = sort_by_digest_4_32;
10100 opti_type = OPTI_TYPE_ZERO_BYTE;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 1;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 3;
10105 break;
10106
10107 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_LE
10111 | OPTS_TYPE_ST_BASE64
10112 | OPTS_TYPE_HASH_COPY;
10113 kern_type = KERN_TYPE_PBKDF2_SHA512;
10114 dgst_size = DGST_SIZE_8_16;
10115 parse_func = pbkdf2_sha512_parse_hash;
10116 sort_by_digest = sort_by_digest_8_16;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_USES_BITS_64;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_ECRYPTFS;
10130 dgst_size = DGST_SIZE_8_8;
10131 parse_func = ecryptfs_parse_hash;
10132 sort_by_digest = sort_by_digest_8_8;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_USES_BITS_64;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 12300: hash_type = HASH_TYPE_ORACLET;
10142 salt_type = SALT_TYPE_EMBEDDED;
10143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10145 kern_type = KERN_TYPE_ORACLET;
10146 dgst_size = DGST_SIZE_8_16;
10147 parse_func = oraclet_parse_hash;
10148 sort_by_digest = sort_by_digest_8_16;
10149 opti_type = OPTI_TYPE_ZERO_BYTE
10150 | OPTI_TYPE_USES_BITS_64;
10151 dgst_pos0 = 0;
10152 dgst_pos1 = 1;
10153 dgst_pos2 = 2;
10154 dgst_pos3 = 3;
10155 break;
10156
10157 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10158 salt_type = SALT_TYPE_EMBEDDED;
10159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10161 kern_type = KERN_TYPE_BSDICRYPT;
10162 dgst_size = DGST_SIZE_4_4;
10163 parse_func = bsdicrypt_parse_hash;
10164 sort_by_digest = sort_by_digest_4_4;
10165 opti_type = OPTI_TYPE_ZERO_BYTE
10166 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10167 dgst_pos0 = 0;
10168 dgst_pos1 = 1;
10169 dgst_pos2 = 2;
10170 dgst_pos3 = 3;
10171 break;
10172
10173 case 12500: hash_type = HASH_TYPE_RAR3HP;
10174 salt_type = SALT_TYPE_EMBEDDED;
10175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10177 kern_type = KERN_TYPE_RAR3;
10178 dgst_size = DGST_SIZE_4_4;
10179 parse_func = rar3hp_parse_hash;
10180 sort_by_digest = sort_by_digest_4_4;
10181 opti_type = OPTI_TYPE_ZERO_BYTE;
10182 dgst_pos0 = 0;
10183 dgst_pos1 = 1;
10184 dgst_pos2 = 2;
10185 dgst_pos3 = 3;
10186 break;
10187
10188 case 12600: hash_type = HASH_TYPE_SHA256;
10189 salt_type = SALT_TYPE_INTERN;
10190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10191 opts_type = OPTS_TYPE_PT_GENERATE_BE
10192 | OPTS_TYPE_PT_ADD80;
10193 kern_type = KERN_TYPE_CF10;
10194 dgst_size = DGST_SIZE_4_8;
10195 parse_func = cf10_parse_hash;
10196 sort_by_digest = sort_by_digest_4_8;
10197 opti_type = OPTI_TYPE_ZERO_BYTE
10198 | OPTI_TYPE_PRECOMPUTE_INIT
10199 | OPTI_TYPE_EARLY_SKIP
10200 | OPTI_TYPE_NOT_ITERATED;
10201 dgst_pos0 = 3;
10202 dgst_pos1 = 7;
10203 dgst_pos2 = 2;
10204 dgst_pos3 = 6;
10205 break;
10206
10207 case 12700: hash_type = HASH_TYPE_AES;
10208 salt_type = SALT_TYPE_EMBEDDED;
10209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10210 opts_type = OPTS_TYPE_PT_GENERATE_LE
10211 | OPTS_TYPE_HASH_COPY;
10212 kern_type = KERN_TYPE_MYWALLET;
10213 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10214 parse_func = mywallet_parse_hash;
10215 sort_by_digest = sort_by_digest_4_5;
10216 opti_type = OPTI_TYPE_ZERO_BYTE;
10217 dgst_pos0 = 0;
10218 dgst_pos1 = 1;
10219 dgst_pos2 = 2;
10220 dgst_pos3 = 3;
10221 break;
10222
10223 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10224 salt_type = SALT_TYPE_EMBEDDED;
10225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10227 kern_type = KERN_TYPE_MS_DRSR;
10228 dgst_size = DGST_SIZE_4_8;
10229 parse_func = ms_drsr_parse_hash;
10230 sort_by_digest = sort_by_digest_4_8;
10231 opti_type = OPTI_TYPE_ZERO_BYTE;
10232 dgst_pos0 = 0;
10233 dgst_pos1 = 1;
10234 dgst_pos2 = 2;
10235 dgst_pos3 = 3;
10236 break;
10237
10238 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10239 salt_type = SALT_TYPE_EMBEDDED;
10240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10241 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10242 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10243 dgst_size = DGST_SIZE_4_8;
10244 parse_func = androidfde_samsung_parse_hash;
10245 sort_by_digest = sort_by_digest_4_8;
10246 opti_type = OPTI_TYPE_ZERO_BYTE;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 1;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 3;
10251 break;
10252
10253 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_RAR5;
10258 dgst_size = DGST_SIZE_4_4;
10259 parse_func = rar5_parse_hash;
10260 sort_by_digest = sort_by_digest_4_4;
10261 opti_type = OPTI_TYPE_ZERO_BYTE;
10262 dgst_pos0 = 0;
10263 dgst_pos1 = 1;
10264 dgst_pos2 = 2;
10265 dgst_pos3 = 3;
10266 break;
10267
10268 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10269 salt_type = SALT_TYPE_EMBEDDED;
10270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10272 kern_type = KERN_TYPE_KRB5TGS;
10273 dgst_size = DGST_SIZE_4_4;
10274 parse_func = krb5tgs_parse_hash;
10275 sort_by_digest = sort_by_digest_4_4;
10276 opti_type = OPTI_TYPE_ZERO_BYTE
10277 | OPTI_TYPE_NOT_ITERATED;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 13200: hash_type = HASH_TYPE_AES;
10285 salt_type = SALT_TYPE_EMBEDDED;
10286 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10288 kern_type = KERN_TYPE_AXCRYPT;
10289 dgst_size = DGST_SIZE_4_4;
10290 parse_func = axcrypt_parse_hash;
10291 sort_by_digest = sort_by_digest_4_4;
10292 opti_type = OPTI_TYPE_ZERO_BYTE;
10293 dgst_pos0 = 0;
10294 dgst_pos1 = 1;
10295 dgst_pos2 = 2;
10296 dgst_pos3 = 3;
10297 break;
10298
10299 case 13300: hash_type = HASH_TYPE_SHA1;
10300 salt_type = SALT_TYPE_NONE;
10301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10302 opts_type = OPTS_TYPE_PT_GENERATE_BE
10303 | OPTS_TYPE_PT_ADD80
10304 | OPTS_TYPE_PT_ADDBITS15;
10305 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10306 dgst_size = DGST_SIZE_4_5;
10307 parse_func = sha1axcrypt_parse_hash;
10308 sort_by_digest = sort_by_digest_4_5;
10309 opti_type = OPTI_TYPE_ZERO_BYTE
10310 | OPTI_TYPE_PRECOMPUTE_INIT
10311 | OPTI_TYPE_EARLY_SKIP
10312 | OPTI_TYPE_NOT_ITERATED
10313 | OPTI_TYPE_NOT_SALTED;
10314 dgst_pos0 = 0;
10315 dgst_pos1 = 4;
10316 dgst_pos2 = 3;
10317 dgst_pos3 = 2;
10318 break;
10319
10320 case 13400: hash_type = HASH_TYPE_AES;
10321 salt_type = SALT_TYPE_EMBEDDED;
10322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10324 kern_type = KERN_TYPE_KEEPASS;
10325 dgst_size = DGST_SIZE_4_4;
10326 parse_func = keepass_parse_hash;
10327 sort_by_digest = sort_by_digest_4_4;
10328 opti_type = OPTI_TYPE_ZERO_BYTE;
10329 dgst_pos0 = 0;
10330 dgst_pos1 = 1;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 3;
10333 break;
10334
10335 case 13500: hash_type = HASH_TYPE_SHA1;
10336 salt_type = SALT_TYPE_EMBEDDED;
10337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10338 opts_type = OPTS_TYPE_PT_GENERATE_BE
10339 | OPTS_TYPE_PT_UNICODE
10340 | OPTS_TYPE_PT_ADD80;
10341 kern_type = KERN_TYPE_PSTOKEN;
10342 dgst_size = DGST_SIZE_4_5;
10343 parse_func = pstoken_parse_hash;
10344 sort_by_digest = sort_by_digest_4_5;
10345 opti_type = OPTI_TYPE_ZERO_BYTE
10346 | OPTI_TYPE_PRECOMPUTE_INIT
10347 | OPTI_TYPE_EARLY_SKIP
10348 | OPTI_TYPE_NOT_ITERATED
10349 | OPTI_TYPE_PREPENDED_SALT
10350 | OPTI_TYPE_RAW_HASH;
10351 dgst_pos0 = 3;
10352 dgst_pos1 = 4;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 1;
10355 break;
10356
10357 default: usage_mini_print (PROGNAME); return (-1);
10358 }
10359
10360 /**
10361 * parser
10362 */
10363
10364 data.parse_func = parse_func;
10365
10366 /**
10367 * misc stuff
10368 */
10369
10370 if (hex_salt)
10371 {
10372 if (salt_type == SALT_TYPE_INTERN)
10373 {
10374 opts_type |= OPTS_TYPE_ST_HEX;
10375 }
10376 else
10377 {
10378 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10379
10380 return (-1);
10381 }
10382 }
10383
10384 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10385 | (salt_type == SALT_TYPE_EXTERN)
10386 | (salt_type == SALT_TYPE_EMBEDDED)
10387 | (salt_type == SALT_TYPE_VIRTUAL));
10388
10389 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10390
10391 data.hash_type = hash_type;
10392 data.attack_mode = attack_mode;
10393 data.attack_kern = attack_kern;
10394 data.attack_exec = attack_exec;
10395 data.kern_type = kern_type;
10396 data.opts_type = opts_type;
10397 data.dgst_size = dgst_size;
10398 data.salt_type = salt_type;
10399 data.isSalted = isSalted;
10400 data.sort_by_digest = sort_by_digest;
10401 data.dgst_pos0 = dgst_pos0;
10402 data.dgst_pos1 = dgst_pos1;
10403 data.dgst_pos2 = dgst_pos2;
10404 data.dgst_pos3 = dgst_pos3;
10405
10406 esalt_size = 0;
10407
10408 switch (hash_mode)
10409 {
10410 case 2500: esalt_size = sizeof (wpa_t); break;
10411 case 5300: esalt_size = sizeof (ikepsk_t); break;
10412 case 5400: esalt_size = sizeof (ikepsk_t); break;
10413 case 5500: esalt_size = sizeof (netntlm_t); break;
10414 case 5600: esalt_size = sizeof (netntlm_t); break;
10415 case 6211: esalt_size = sizeof (tc_t); break;
10416 case 6212: esalt_size = sizeof (tc_t); break;
10417 case 6213: esalt_size = sizeof (tc_t); break;
10418 case 6221: esalt_size = sizeof (tc_t); break;
10419 case 6222: esalt_size = sizeof (tc_t); break;
10420 case 6223: esalt_size = sizeof (tc_t); break;
10421 case 6231: esalt_size = sizeof (tc_t); break;
10422 case 6232: esalt_size = sizeof (tc_t); break;
10423 case 6233: esalt_size = sizeof (tc_t); break;
10424 case 6241: esalt_size = sizeof (tc_t); break;
10425 case 6242: esalt_size = sizeof (tc_t); break;
10426 case 6243: esalt_size = sizeof (tc_t); break;
10427 case 6600: esalt_size = sizeof (agilekey_t); break;
10428 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10429 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10430 case 7300: esalt_size = sizeof (rakp_t); break;
10431 case 7500: esalt_size = sizeof (krb5pa_t); break;
10432 case 8200: esalt_size = sizeof (cloudkey_t); break;
10433 case 8800: esalt_size = sizeof (androidfde_t); break;
10434 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10435 case 9400: esalt_size = sizeof (office2007_t); break;
10436 case 9500: esalt_size = sizeof (office2010_t); break;
10437 case 9600: esalt_size = sizeof (office2013_t); break;
10438 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10439 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10440 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10441 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10442 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10443 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10444 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10445 case 10200: esalt_size = sizeof (cram_md5_t); break;
10446 case 10400: esalt_size = sizeof (pdf_t); break;
10447 case 10410: esalt_size = sizeof (pdf_t); break;
10448 case 10420: esalt_size = sizeof (pdf_t); break;
10449 case 10500: esalt_size = sizeof (pdf_t); break;
10450 case 10600: esalt_size = sizeof (pdf_t); break;
10451 case 10700: esalt_size = sizeof (pdf_t); break;
10452 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10453 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10454 case 11400: esalt_size = sizeof (sip_t); break;
10455 case 11600: esalt_size = sizeof (seven_zip_t); break;
10456 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10457 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10458 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10459 case 13000: esalt_size = sizeof (rar5_t); break;
10460 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10461 case 13400: esalt_size = sizeof (keepass_t); break;
10462 case 13500: esalt_size = sizeof (pstoken_t); break;
10463 }
10464
10465 data.esalt_size = esalt_size;
10466
10467 /**
10468 * choose dictionary parser
10469 */
10470
10471 if (hash_type == HASH_TYPE_LM)
10472 {
10473 get_next_word_func = get_next_word_lm;
10474 }
10475 else if (opts_type & OPTS_TYPE_PT_UPPER)
10476 {
10477 get_next_word_func = get_next_word_uc;
10478 }
10479 else
10480 {
10481 get_next_word_func = get_next_word_std;
10482 }
10483
10484 /**
10485 * dictstat
10486 */
10487
10488 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10489
10490 #ifdef _POSIX
10491 size_t dictstat_nmemb = 0;
10492 #endif
10493
10494 #ifdef _WIN
10495 uint dictstat_nmemb = 0;
10496 #endif
10497
10498 char dictstat[256] = { 0 };
10499
10500 FILE *dictstat_fp = NULL;
10501
10502 if (keyspace == 0)
10503 {
10504 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10505
10506 dictstat_fp = fopen (dictstat, "rb");
10507
10508 if (dictstat_fp)
10509 {
10510 #ifdef _POSIX
10511 struct stat tmpstat;
10512
10513 fstat (fileno (dictstat_fp), &tmpstat);
10514 #endif
10515
10516 #ifdef _WIN
10517 struct stat64 tmpstat;
10518
10519 _fstat64 (fileno (dictstat_fp), &tmpstat);
10520 #endif
10521
10522 if (tmpstat.st_mtime < COMPTIME)
10523 {
10524 /* with v0.15 the format changed so we have to ensure user is using a good version
10525 since there is no version-header in the dictstat file */
10526
10527 fclose (dictstat_fp);
10528
10529 unlink (dictstat);
10530 }
10531 else
10532 {
10533 while (!feof (dictstat_fp))
10534 {
10535 dictstat_t d;
10536
10537 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10538
10539 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10540
10541 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10542 {
10543 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10544
10545 return -1;
10546 }
10547 }
10548
10549 fclose (dictstat_fp);
10550 }
10551 }
10552 }
10553
10554 /**
10555 * potfile
10556 */
10557
10558 char potfile[256] = { 0 };
10559
10560 if (potfile_path == NULL)
10561 {
10562 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10563 }
10564 else
10565 {
10566 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10567 }
10568
10569 data.pot_fp = NULL;
10570
10571 FILE *out_fp = NULL;
10572 FILE *pot_fp = NULL;
10573
10574 if (show == 1 || left == 1)
10575 {
10576 pot_fp = fopen (potfile, "rb");
10577
10578 if (pot_fp == NULL)
10579 {
10580 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10581
10582 return (-1);
10583 }
10584
10585 if (outfile != NULL)
10586 {
10587 if ((out_fp = fopen (outfile, "ab")) == NULL)
10588 {
10589 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10590
10591 fclose (pot_fp);
10592
10593 return (-1);
10594 }
10595 }
10596 else
10597 {
10598 out_fp = stdout;
10599 }
10600 }
10601 else
10602 {
10603 if (potfile_disable == 0)
10604 {
10605 pot_fp = fopen (potfile, "ab");
10606
10607 if (pot_fp == NULL)
10608 {
10609 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10610
10611 return (-1);
10612 }
10613
10614 data.pot_fp = pot_fp;
10615 }
10616 }
10617
10618 pot_t *pot = NULL;
10619
10620 uint pot_cnt = 0;
10621 uint pot_avail = 0;
10622
10623 if (show == 1 || left == 1)
10624 {
10625 SUPPRESS_OUTPUT = 1;
10626
10627 pot_avail = count_lines (pot_fp);
10628
10629 rewind (pot_fp);
10630
10631 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10632
10633 uint pot_hashes_avail = 0;
10634
10635 uint line_num = 0;
10636
10637 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10638
10639 while (!feof (pot_fp))
10640 {
10641 line_num++;
10642
10643 int line_len = fgetl (pot_fp, line_buf);
10644
10645 if (line_len == 0) continue;
10646
10647 char *plain_buf = line_buf + line_len;
10648
10649 pot_t *pot_ptr = &pot[pot_cnt];
10650
10651 hash_t *hashes_buf = &pot_ptr->hash;
10652
10653 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10654 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10655
10656 if (pot_cnt == pot_hashes_avail)
10657 {
10658 uint pos = 0;
10659
10660 for (pos = 0; pos < INCR_POT; pos++)
10661 {
10662 if ((pot_cnt + pos) >= pot_avail) break;
10663
10664 pot_t *tmp_pot = &pot[pot_cnt + pos];
10665
10666 hash_t *tmp_hash = &tmp_pot->hash;
10667
10668 tmp_hash->digest = mymalloc (dgst_size);
10669
10670 if (isSalted)
10671 {
10672 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10673 }
10674
10675 if (esalt_size)
10676 {
10677 tmp_hash->esalt = mymalloc (esalt_size);
10678 }
10679
10680 pot_hashes_avail++;
10681 }
10682 }
10683
10684 int plain_len = 0;
10685
10686 int parser_status;
10687
10688 int iter = MAX_CUT_TRIES;
10689
10690 do
10691 {
10692 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10693 {
10694 if (line_buf[i] == ':')
10695 {
10696 line_len--;
10697
10698 break;
10699 }
10700 }
10701
10702 if (data.hash_mode != 2500)
10703 {
10704 parser_status = parse_func (line_buf, line_len, hashes_buf);
10705 }
10706 else
10707 {
10708 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10709
10710 if (line_len > max_salt_size)
10711 {
10712 parser_status = PARSER_GLOBAL_LENGTH;
10713 }
10714 else
10715 {
10716 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10717
10718 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10719
10720 hashes_buf->salt->salt_len = line_len;
10721
10722 parser_status = PARSER_OK;
10723 }
10724 }
10725
10726 // if NOT parsed without error, we add the ":" to the plain
10727
10728 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10729 {
10730 plain_len++;
10731 plain_buf--;
10732 }
10733
10734 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10735
10736 if (parser_status < PARSER_GLOBAL_ZERO)
10737 {
10738 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10739
10740 continue;
10741 }
10742
10743 if (plain_len >= 255) continue;
10744
10745 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10746
10747 pot_ptr->plain_len = plain_len;
10748
10749 pot_cnt++;
10750 }
10751
10752 myfree (line_buf);
10753
10754 fclose (pot_fp);
10755
10756 SUPPRESS_OUTPUT = 0;
10757
10758 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10759 }
10760
10761 /**
10762 * word len
10763 */
10764
10765 uint pw_min = PW_MIN;
10766 uint pw_max = PW_MAX;
10767
10768 switch (hash_mode)
10769 {
10770 case 125: if (pw_max > 32) pw_max = 32;
10771 break;
10772 case 400: if (pw_max > 40) pw_max = 40;
10773 break;
10774 case 500: if (pw_max > 16) pw_max = 16;
10775 break;
10776 case 1500: if (pw_max > 8) pw_max = 8;
10777 break;
10778 case 1600: if (pw_max > 16) pw_max = 16;
10779 break;
10780 case 1800: if (pw_max > 16) pw_max = 16;
10781 break;
10782 case 2100: if (pw_max > 16) pw_max = 16;
10783 break;
10784 case 2500: if (pw_min < 8) pw_min = 8;
10785 break;
10786 case 3000: if (pw_max > 7) pw_max = 7;
10787 break;
10788 case 5200: if (pw_max > 24) pw_max = 24;
10789 break;
10790 case 5800: if (pw_max > 16) pw_max = 16;
10791 break;
10792 case 6300: if (pw_max > 16) pw_max = 16;
10793 break;
10794 case 7400: if (pw_max > 16) pw_max = 16;
10795 break;
10796 case 7900: if (pw_max > 48) pw_max = 48;
10797 break;
10798 case 8500: if (pw_max > 8) pw_max = 8;
10799 break;
10800 case 8600: if (pw_max > 16) pw_max = 16;
10801 break;
10802 case 9710: pw_min = 5;
10803 pw_max = 5;
10804 break;
10805 case 9810: pw_min = 5;
10806 pw_max = 5;
10807 break;
10808 case 10410: pw_min = 5;
10809 pw_max = 5;
10810 break;
10811 case 10300: if (pw_max < 3) pw_min = 3;
10812 if (pw_max > 40) pw_max = 40;
10813 break;
10814 case 10500: if (pw_max < 3) pw_min = 3;
10815 if (pw_max > 40) pw_max = 40;
10816 break;
10817 case 10700: if (pw_max > 16) pw_max = 16;
10818 break;
10819 case 11300: if (pw_max > 40) pw_max = 40;
10820 break;
10821 case 12500: if (pw_max > 20) pw_max = 20;
10822 break;
10823 case 12800: if (pw_max > 24) pw_max = 24;
10824 break;
10825 }
10826
10827 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10828 {
10829 switch (attack_kern)
10830 {
10831 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10832 break;
10833 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10834 break;
10835 }
10836 }
10837
10838 /**
10839 * charsets : keep them together for more easy maintainnce
10840 */
10841
10842 cs_t mp_sys[6] = { { { 0 }, 0 } };
10843 cs_t mp_usr[4] = { { { 0 }, 0 } };
10844
10845 mp_setup_sys (mp_sys);
10846
10847 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10848 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10849 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10850 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10851
10852 /**
10853 * load hashes, part I: find input mode, count hashes
10854 */
10855
10856 uint hashlist_mode = 0;
10857 uint hashlist_format = HLFMT_HASHCAT;
10858
10859 uint hashes_avail = 0;
10860
10861 if (benchmark == 0)
10862 {
10863 struct stat f;
10864
10865 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10866
10867 if ((hash_mode == 2500) ||
10868 (hash_mode == 5200) ||
10869 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10870 (hash_mode == 9000))
10871 {
10872 hashlist_mode = HL_MODE_ARG;
10873
10874 char *hashfile = myargv[optind];
10875
10876 data.hashfile = hashfile;
10877
10878 logfile_top_var_string ("target", hashfile);
10879 }
10880
10881 if (hashlist_mode == HL_MODE_ARG)
10882 {
10883 if (hash_mode == 2500)
10884 {
10885 struct stat st;
10886
10887 if (stat (data.hashfile, &st) == -1)
10888 {
10889 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10890
10891 return (-1);
10892 }
10893
10894 hashes_avail = st.st_size / sizeof (hccap_t);
10895 }
10896 else
10897 {
10898 hashes_avail = 1;
10899 }
10900 }
10901 else if (hashlist_mode == HL_MODE_FILE)
10902 {
10903 char *hashfile = myargv[optind];
10904
10905 data.hashfile = hashfile;
10906
10907 logfile_top_var_string ("target", hashfile);
10908
10909 FILE *fp = NULL;
10910
10911 if ((fp = fopen (hashfile, "rb")) == NULL)
10912 {
10913 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10914
10915 return (-1);
10916 }
10917
10918 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10919
10920 hashes_avail = count_lines (fp);
10921
10922 rewind (fp);
10923
10924 if (hashes_avail == 0)
10925 {
10926 log_error ("ERROR: hashfile is empty or corrupt");
10927
10928 fclose (fp);
10929
10930 return (-1);
10931 }
10932
10933 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10934
10935 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10936 {
10937 log_error ("ERROR: remove not supported in native hashfile-format mode");
10938
10939 fclose (fp);
10940
10941 return (-1);
10942 }
10943
10944 fclose (fp);
10945 }
10946 }
10947 else
10948 {
10949 hashlist_mode = HL_MODE_ARG;
10950
10951 hashes_avail = 1;
10952 }
10953
10954 if (hash_mode == 3000) hashes_avail *= 2;
10955
10956 data.hashlist_mode = hashlist_mode;
10957 data.hashlist_format = hashlist_format;
10958
10959 logfile_top_uint (hashlist_mode);
10960 logfile_top_uint (hashlist_format);
10961
10962 /**
10963 * load hashes, part II: allocate required memory, set pointers
10964 */
10965
10966 hash_t *hashes_buf = NULL;
10967 void *digests_buf = NULL;
10968 salt_t *salts_buf = NULL;
10969 void *esalts_buf = NULL;
10970
10971 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10972
10973 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10974
10975 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10976 {
10977 u32 hash_pos;
10978
10979 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10980 {
10981 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10982
10983 hashes_buf[hash_pos].hash_info = hash_info;
10984
10985 if (username && (remove || show || left))
10986 {
10987 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10988 }
10989
10990 if (benchmark)
10991 {
10992 hash_info->orighash = (char *) mymalloc (256);
10993 }
10994 }
10995 }
10996
10997 if (isSalted)
10998 {
10999 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11000
11001 if (esalt_size)
11002 {
11003 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11004 }
11005 }
11006 else
11007 {
11008 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11009 }
11010
11011 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11012 {
11013 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11014
11015 if (isSalted)
11016 {
11017 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11018
11019 if (esalt_size)
11020 {
11021 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11022 }
11023 }
11024 else
11025 {
11026 hashes_buf[hash_pos].salt = &salts_buf[0];
11027 }
11028 }
11029
11030 /**
11031 * load hashes, part III: parse hashes or generate them if benchmark
11032 */
11033
11034 uint hashes_cnt = 0;
11035
11036 if (benchmark == 0)
11037 {
11038 if (keyspace == 1)
11039 {
11040 // useless to read hash file for keyspace, cheat a little bit w/ optind
11041 }
11042 else if (hashes_avail == 0)
11043 {
11044 }
11045 else if (hashlist_mode == HL_MODE_ARG)
11046 {
11047 char *input_buf = myargv[optind];
11048
11049 uint input_len = strlen (input_buf);
11050
11051 logfile_top_var_string ("target", input_buf);
11052
11053 char *hash_buf = NULL;
11054 int hash_len = 0;
11055
11056 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11057
11058 bool hash_fmt_error = 0;
11059
11060 if (hash_len < 1) hash_fmt_error = 1;
11061 if (hash_buf == NULL) hash_fmt_error = 1;
11062
11063 if (hash_fmt_error)
11064 {
11065 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11066 }
11067 else
11068 {
11069 if (opts_type & OPTS_TYPE_HASH_COPY)
11070 {
11071 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11072
11073 hash_info_tmp->orighash = mystrdup (hash_buf);
11074 }
11075
11076 if (isSalted)
11077 {
11078 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11079 }
11080
11081 int parser_status = PARSER_OK;
11082
11083 if (hash_mode == 2500)
11084 {
11085 if (hash_len == 0)
11086 {
11087 log_error ("ERROR: hccap file not specified");
11088
11089 return (-1);
11090 }
11091
11092 hashlist_mode = HL_MODE_FILE;
11093
11094 data.hashlist_mode = hashlist_mode;
11095
11096 FILE *fp = fopen (hash_buf, "rb");
11097
11098 if (fp == NULL)
11099 {
11100 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11101
11102 return (-1);
11103 }
11104
11105 if (hashes_avail < 1)
11106 {
11107 log_error ("ERROR: hccap file is empty or corrupt");
11108
11109 fclose (fp);
11110
11111 return (-1);
11112 }
11113
11114 uint hccap_size = sizeof (hccap_t);
11115
11116 char *in = (char *) mymalloc (hccap_size);
11117
11118 while (!feof (fp))
11119 {
11120 int n = fread (in, hccap_size, 1, fp);
11121
11122 if (n != 1)
11123 {
11124 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11125
11126 break;
11127 }
11128
11129 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11130
11131 if (parser_status != PARSER_OK)
11132 {
11133 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11134
11135 continue;
11136 }
11137
11138 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11139
11140 if ((show == 1) || (left == 1))
11141 {
11142 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11143
11144 char *salt_ptr = (char *) tmp_salt->salt_buf;
11145
11146 int cur_pos = tmp_salt->salt_len;
11147 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11148
11149 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11150
11151 // do the appending task
11152
11153 snprintf (salt_ptr + cur_pos,
11154 rem_len,
11155 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11156 wpa->orig_mac1[0],
11157 wpa->orig_mac1[1],
11158 wpa->orig_mac1[2],
11159 wpa->orig_mac1[3],
11160 wpa->orig_mac1[4],
11161 wpa->orig_mac1[5],
11162 wpa->orig_mac2[0],
11163 wpa->orig_mac2[1],
11164 wpa->orig_mac2[2],
11165 wpa->orig_mac2[3],
11166 wpa->orig_mac2[4],
11167 wpa->orig_mac2[5]);
11168
11169 // memset () the remaining part of the salt
11170
11171 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11172 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11173
11174 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11175
11176 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11177 }
11178
11179 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);
11180 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);
11181
11182 hashes_cnt++;
11183 }
11184
11185 fclose (fp);
11186
11187 myfree (in);
11188 }
11189 else if (hash_mode == 3000)
11190 {
11191 if (hash_len == 32)
11192 {
11193 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11194
11195 hash_t *lm_hash_left = NULL;
11196
11197 if (parser_status == PARSER_OK)
11198 {
11199 lm_hash_left = &hashes_buf[hashes_cnt];
11200
11201 hashes_cnt++;
11202 }
11203 else
11204 {
11205 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11206 }
11207
11208 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11209
11210 hash_t *lm_hash_right = NULL;
11211
11212 if (parser_status == PARSER_OK)
11213 {
11214 lm_hash_right = &hashes_buf[hashes_cnt];
11215
11216 hashes_cnt++;
11217 }
11218 else
11219 {
11220 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11221 }
11222
11223 // show / left
11224
11225 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11226 {
11227 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);
11228 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);
11229 }
11230 }
11231 else
11232 {
11233 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11234
11235 if (parser_status == PARSER_OK)
11236 {
11237 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11238 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11239 }
11240
11241 if (parser_status == PARSER_OK)
11242 {
11243 hashes_cnt++;
11244 }
11245 else
11246 {
11247 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11248 }
11249 }
11250 }
11251 else
11252 {
11253 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11254
11255 if (parser_status == PARSER_OK)
11256 {
11257 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11258 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11259 }
11260
11261 if (parser_status == PARSER_OK)
11262 {
11263 hashes_cnt++;
11264 }
11265 else
11266 {
11267 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11268 }
11269 }
11270 }
11271 }
11272 else if (hashlist_mode == HL_MODE_FILE)
11273 {
11274 char *hashfile = data.hashfile;
11275
11276 FILE *fp;
11277
11278 if ((fp = fopen (hashfile, "rb")) == NULL)
11279 {
11280 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11281
11282 return (-1);
11283 }
11284
11285 uint line_num = 0;
11286
11287 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11288
11289 while (!feof (fp))
11290 {
11291 line_num++;
11292
11293 int line_len = fgetl (fp, line_buf);
11294
11295 if (line_len == 0) continue;
11296
11297 char *hash_buf = NULL;
11298 int hash_len = 0;
11299
11300 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11301
11302 bool hash_fmt_error = 0;
11303
11304 if (hash_len < 1) hash_fmt_error = 1;
11305 if (hash_buf == NULL) hash_fmt_error = 1;
11306
11307 if (hash_fmt_error)
11308 {
11309 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11310
11311 continue;
11312 }
11313
11314 if (username)
11315 {
11316 char *user_buf = NULL;
11317 int user_len = 0;
11318
11319 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11320
11321 if (remove || show)
11322 {
11323 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11324
11325 *user = (user_t *) mymalloc (sizeof (user_t));
11326
11327 user_t *user_ptr = *user;
11328
11329 if (user_buf != NULL)
11330 {
11331 user_ptr->user_name = mystrdup (user_buf);
11332 }
11333 else
11334 {
11335 user_ptr->user_name = mystrdup ("");
11336 }
11337
11338 user_ptr->user_len = user_len;
11339 }
11340 }
11341
11342 if (opts_type & OPTS_TYPE_HASH_COPY)
11343 {
11344 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11345
11346 hash_info_tmp->orighash = mystrdup (hash_buf);
11347 }
11348
11349 if (isSalted)
11350 {
11351 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11352 }
11353
11354 if (hash_mode == 3000)
11355 {
11356 if (hash_len == 32)
11357 {
11358 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11359
11360 if (parser_status < PARSER_GLOBAL_ZERO)
11361 {
11362 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11363
11364 continue;
11365 }
11366
11367 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11368
11369 hashes_cnt++;
11370
11371 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11372
11373 if (parser_status < PARSER_GLOBAL_ZERO)
11374 {
11375 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11376
11377 continue;
11378 }
11379
11380 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11381
11382 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);
11383
11384 hashes_cnt++;
11385
11386 // show / left
11387
11388 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);
11389 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);
11390 }
11391 else
11392 {
11393 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11394
11395 if (parser_status < PARSER_GLOBAL_ZERO)
11396 {
11397 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11398
11399 continue;
11400 }
11401
11402 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);
11403
11404 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11405 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11406
11407 hashes_cnt++;
11408 }
11409 }
11410 else
11411 {
11412 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11413
11414 if (parser_status < PARSER_GLOBAL_ZERO)
11415 {
11416 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11417
11418 continue;
11419 }
11420
11421 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);
11422
11423 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11424 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11425
11426 hashes_cnt++;
11427 }
11428 }
11429
11430 myfree (line_buf);
11431
11432 fclose (fp);
11433
11434 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11435
11436 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11437 }
11438 }
11439 else
11440 {
11441 if (isSalted)
11442 {
11443 hashes_buf[0].salt->salt_len = 8;
11444
11445 // special salt handling
11446
11447 switch (hash_mode)
11448 {
11449 case 1500: hashes_buf[0].salt->salt_len = 2;
11450 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11451 break;
11452 case 1731: hashes_buf[0].salt->salt_len = 4;
11453 break;
11454 case 2410: hashes_buf[0].salt->salt_len = 4;
11455 break;
11456 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11457 break;
11458 case 3100: hashes_buf[0].salt->salt_len = 1;
11459 break;
11460 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11461 break;
11462 case 5800: hashes_buf[0].salt->salt_len = 16;
11463 break;
11464 case 6800: hashes_buf[0].salt->salt_len = 32;
11465 break;
11466 case 8400: hashes_buf[0].salt->salt_len = 40;
11467 break;
11468 case 8800: hashes_buf[0].salt->salt_len = 16;
11469 break;
11470 case 8900: hashes_buf[0].salt->salt_len = 16;
11471 hashes_buf[0].salt->scrypt_N = 1024;
11472 hashes_buf[0].salt->scrypt_r = 1;
11473 hashes_buf[0].salt->scrypt_p = 1;
11474 break;
11475 case 9100: hashes_buf[0].salt->salt_len = 16;
11476 break;
11477 case 9300: hashes_buf[0].salt->salt_len = 14;
11478 hashes_buf[0].salt->scrypt_N = 16384;
11479 hashes_buf[0].salt->scrypt_r = 1;
11480 hashes_buf[0].salt->scrypt_p = 1;
11481 break;
11482 case 9400: hashes_buf[0].salt->salt_len = 16;
11483 break;
11484 case 9500: hashes_buf[0].salt->salt_len = 16;
11485 break;
11486 case 9600: hashes_buf[0].salt->salt_len = 16;
11487 break;
11488 case 9700: hashes_buf[0].salt->salt_len = 16;
11489 break;
11490 case 9710: hashes_buf[0].salt->salt_len = 16;
11491 break;
11492 case 9720: hashes_buf[0].salt->salt_len = 16;
11493 break;
11494 case 9800: hashes_buf[0].salt->salt_len = 16;
11495 break;
11496 case 9810: hashes_buf[0].salt->salt_len = 16;
11497 break;
11498 case 9820: hashes_buf[0].salt->salt_len = 16;
11499 break;
11500 case 10300: hashes_buf[0].salt->salt_len = 12;
11501 break;
11502 case 11500: hashes_buf[0].salt->salt_len = 4;
11503 break;
11504 case 11600: hashes_buf[0].salt->salt_len = 4;
11505 break;
11506 case 12400: hashes_buf[0].salt->salt_len = 4;
11507 break;
11508 case 12500: hashes_buf[0].salt->salt_len = 8;
11509 break;
11510 case 12600: hashes_buf[0].salt->salt_len = 64;
11511 break;
11512 }
11513
11514 // special esalt handling
11515
11516 switch (hash_mode)
11517 {
11518 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11519 break;
11520 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11521 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11522 break;
11523 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11524 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11525 break;
11526 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11527 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11528 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11529 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11530 break;
11531 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11532 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11533 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11534 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11535 break;
11536 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11537 break;
11538 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11539 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11540 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11541 break;
11542 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11543 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11544 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11545 break;
11546 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11547 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11548 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11549 break;
11550 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11551 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11552 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11553 break;
11554 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11555 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11556 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11557 break;
11558 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11559 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11560 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11561 break;
11562 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11563 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11564 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11565 break;
11566 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11567 break;
11568 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11569 break;
11570 }
11571 }
11572
11573 // set hashfile
11574
11575 switch (hash_mode)
11576 {
11577 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11578 break;
11579 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11580 break;
11581 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11582 break;
11583 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11584 break;
11585 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11586 break;
11587 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11588 break;
11589 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11590 break;
11591 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11592 break;
11593 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11594 break;
11595 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11596 break;
11597 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11598 break;
11599 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11600 break;
11601 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11602 break;
11603 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11604 break;
11605 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11606 break;
11607 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11608 break;
11609 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11610 break;
11611 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11612 break;
11613 }
11614
11615 // set default iterations
11616
11617 switch (hash_mode)
11618 {
11619 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11620 break;
11621 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11622 break;
11623 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11624 break;
11625 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11626 break;
11627 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11628 break;
11629 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11630 break;
11631 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11632 break;
11633 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11634 break;
11635 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11636 break;
11637 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11638 break;
11639 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11640 break;
11641 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11642 break;
11643 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11644 break;
11645 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11646 break;
11647 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11648 break;
11649 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11650 break;
11651 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11652 break;
11653 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11654 break;
11655 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11656 break;
11657 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11658 break;
11659 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11660 break;
11661 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11662 break;
11663 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11664 break;
11665 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11666 break;
11667 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11668 break;
11669 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11670 break;
11671 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11672 break;
11673 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11674 break;
11675 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11676 break;
11677 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11678 break;
11679 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11680 break;
11681 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11682 break;
11683 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11684 break;
11685 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11686 break;
11687 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11688 break;
11689 case 8900: hashes_buf[0].salt->salt_iter = 1;
11690 break;
11691 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11692 break;
11693 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11694 break;
11695 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11696 break;
11697 case 9300: hashes_buf[0].salt->salt_iter = 1;
11698 break;
11699 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11700 break;
11701 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11702 break;
11703 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11704 break;
11705 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11706 break;
11707 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11708 break;
11709 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11710 break;
11711 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11712 break;
11713 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11714 break;
11715 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11716 break;
11717 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11718 break;
11719 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11720 break;
11721 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11722 break;
11723 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11724 break;
11725 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11726 break;
11727 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11728 break;
11729 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11730 break;
11731 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11732 break;
11733 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11734 break;
11735 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11736 break;
11737 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11738 break;
11739 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11740 break;
11741 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11742 break;
11743 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11744 break;
11745 }
11746
11747 hashes_cnt = 1;
11748 }
11749
11750 if (show == 1 || left == 1)
11751 {
11752 for (uint i = 0; i < pot_cnt; i++)
11753 {
11754 pot_t *pot_ptr = &pot[i];
11755
11756 hash_t *hashes_buf = &pot_ptr->hash;
11757
11758 local_free (hashes_buf->digest);
11759
11760 if (isSalted)
11761 {
11762 local_free (hashes_buf->salt);
11763 }
11764 }
11765
11766 local_free (pot);
11767
11768 if (data.quiet == 0) log_info_nn ("");
11769
11770 return (0);
11771 }
11772
11773 if (keyspace == 0)
11774 {
11775 if (hashes_cnt == 0)
11776 {
11777 log_error ("ERROR: No hashes loaded");
11778
11779 return (-1);
11780 }
11781 }
11782
11783 /**
11784 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11785 */
11786
11787 if (data.outfile != NULL)
11788 {
11789 if (data.hashfile != NULL)
11790 {
11791 #ifdef _POSIX
11792 struct stat tmpstat_outfile;
11793 struct stat tmpstat_hashfile;
11794 #endif
11795
11796 #ifdef _WIN
11797 struct stat64 tmpstat_outfile;
11798 struct stat64 tmpstat_hashfile;
11799 #endif
11800
11801 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11802
11803 if (tmp_outfile_fp)
11804 {
11805 #ifdef _POSIX
11806 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11807 #endif
11808
11809 #ifdef _WIN
11810 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11811 #endif
11812
11813 fclose (tmp_outfile_fp);
11814 }
11815
11816 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11817
11818 if (tmp_hashfile_fp)
11819 {
11820 #ifdef _POSIX
11821 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11822 #endif
11823
11824 #ifdef _WIN
11825 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11826 #endif
11827
11828 fclose (tmp_hashfile_fp);
11829 }
11830
11831 if (tmp_outfile_fp && tmp_outfile_fp)
11832 {
11833 tmpstat_outfile.st_mode = 0;
11834 tmpstat_outfile.st_nlink = 0;
11835 tmpstat_outfile.st_uid = 0;
11836 tmpstat_outfile.st_gid = 0;
11837 tmpstat_outfile.st_rdev = 0;
11838 tmpstat_outfile.st_atime = 0;
11839
11840 tmpstat_hashfile.st_mode = 0;
11841 tmpstat_hashfile.st_nlink = 0;
11842 tmpstat_hashfile.st_uid = 0;
11843 tmpstat_hashfile.st_gid = 0;
11844 tmpstat_hashfile.st_rdev = 0;
11845 tmpstat_hashfile.st_atime = 0;
11846
11847 #ifdef _POSIX
11848 tmpstat_outfile.st_blksize = 0;
11849 tmpstat_outfile.st_blocks = 0;
11850
11851 tmpstat_hashfile.st_blksize = 0;
11852 tmpstat_hashfile.st_blocks = 0;
11853 #endif
11854
11855 #ifdef _POSIX
11856 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11857 {
11858 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11859
11860 return (-1);
11861 }
11862 #endif
11863
11864 #ifdef _WIN
11865 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11866 {
11867 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11868
11869 return (-1);
11870 }
11871 #endif
11872 }
11873 }
11874 }
11875
11876 /**
11877 * Remove duplicates
11878 */
11879
11880 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11881
11882 if (isSalted)
11883 {
11884 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11885 }
11886 else
11887 {
11888 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11889 }
11890
11891 uint hashes_cnt_orig = hashes_cnt;
11892
11893 hashes_cnt = 1;
11894
11895 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11896 {
11897 if (isSalted)
11898 {
11899 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11900 {
11901 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11902 }
11903 }
11904 else
11905 {
11906 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11907 }
11908
11909 if (hashes_pos > hashes_cnt)
11910 {
11911 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11912 }
11913
11914 hashes_cnt++;
11915 }
11916
11917 /**
11918 * Potfile removes
11919 */
11920
11921 uint potfile_remove_cracks = 0;
11922
11923 if (potfile_disable == 0)
11924 {
11925 hash_t hash_buf;
11926
11927 hash_buf.digest = mymalloc (dgst_size);
11928 hash_buf.salt = NULL;
11929 hash_buf.esalt = NULL;
11930 hash_buf.hash_info = NULL;
11931 hash_buf.cracked = 0;
11932
11933 if (isSalted)
11934 {
11935 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11936 }
11937
11938 if (esalt_size)
11939 {
11940 hash_buf.esalt = mymalloc (esalt_size);
11941 }
11942
11943 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11944
11945 // no solution for these special hash types (for instane because they use hashfile in output etc)
11946 if ((hash_mode != 5200) &&
11947 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11948 (hash_mode != 9000))
11949 {
11950 FILE *fp = fopen (potfile, "rb");
11951
11952 if (fp != NULL)
11953 {
11954 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11955
11956 // to be safe work with a copy (because of line_len loop, i etc)
11957 // moved up here because it's easier to handle continue case
11958 // it's just 64kb
11959
11960 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11961
11962 while (!feof (fp))
11963 {
11964 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11965
11966 if (ptr == NULL) break;
11967
11968 int line_len = strlen (line_buf);
11969
11970 if (line_len == 0) continue;
11971
11972 int iter = MAX_CUT_TRIES;
11973
11974 for (int i = line_len - 1; i && iter; i--, line_len--)
11975 {
11976 if (line_buf[i] != ':') continue;
11977
11978 if (isSalted)
11979 {
11980 memset (hash_buf.salt, 0, sizeof (salt_t));
11981 }
11982
11983 hash_t *found = NULL;
11984
11985 if (hash_mode == 6800)
11986 {
11987 if (i < 64) // 64 = 16 * uint in salt_buf[]
11988 {
11989 // manipulate salt_buf
11990 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11991
11992 hash_buf.salt->salt_len = i;
11993
11994 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11995 }
11996 }
11997 else if (hash_mode == 2500)
11998 {
11999 if (i < 64) // 64 = 16 * uint in salt_buf[]
12000 {
12001 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12002 // manipulate salt_buf
12003
12004 memcpy (line_buf_cpy, line_buf, i);
12005
12006 char *mac2_pos = strrchr (line_buf_cpy, ':');
12007
12008 if (mac2_pos == NULL) continue;
12009
12010 mac2_pos[0] = 0;
12011 mac2_pos++;
12012
12013 if (strlen (mac2_pos) != 12) continue;
12014
12015 char *mac1_pos = strrchr (line_buf_cpy, ':');
12016
12017 if (mac1_pos == NULL) continue;
12018
12019 mac1_pos[0] = 0;
12020 mac1_pos++;
12021
12022 if (strlen (mac1_pos) != 12) continue;
12023
12024 uint essid_length = mac1_pos - line_buf_cpy - 1;
12025
12026 // here we need the ESSID
12027 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12028
12029 hash_buf.salt->salt_len = essid_length;
12030
12031 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12032
12033 if (found)
12034 {
12035 wpa_t *wpa = (wpa_t *) found->esalt;
12036
12037 // compare hex string(s) vs binary MAC address(es)
12038
12039 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12040 {
12041 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12042 {
12043 found = NULL;
12044
12045 break;
12046 }
12047 }
12048
12049 // early skip ;)
12050 if (!found) continue;
12051
12052 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12053 {
12054 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12055 {
12056 found = NULL;
12057
12058 break;
12059 }
12060 }
12061 }
12062 }
12063 }
12064 else
12065 {
12066 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12067
12068 if (parser_status == PARSER_OK)
12069 {
12070 if (isSalted)
12071 {
12072 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12073 }
12074 else
12075 {
12076 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12077 }
12078 }
12079 }
12080
12081 if (found == NULL) continue;
12082
12083 if (!found->cracked) potfile_remove_cracks++;
12084
12085 found->cracked = 1;
12086
12087 if (found) break;
12088
12089 iter--;
12090 }
12091 }
12092
12093 myfree (line_buf_cpy);
12094
12095 myfree (line_buf);
12096
12097 fclose (fp);
12098 }
12099 }
12100
12101 if (esalt_size)
12102 {
12103 local_free (hash_buf.esalt);
12104 }
12105
12106 if (isSalted)
12107 {
12108 local_free (hash_buf.salt);
12109 }
12110
12111 local_free (hash_buf.digest);
12112 }
12113
12114 /**
12115 * Now generate all the buffers required for later
12116 */
12117
12118 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12119
12120 salt_t *salts_buf_new = NULL;
12121 void *esalts_buf_new = NULL;
12122
12123 if (isSalted)
12124 {
12125 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12126
12127 if (esalt_size)
12128 {
12129 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12130 }
12131 }
12132 else
12133 {
12134 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12135 }
12136
12137 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12138
12139 uint digests_cnt = hashes_cnt;
12140 uint digests_done = 0;
12141
12142 size_t size_digests = digests_cnt * dgst_size;
12143 size_t size_shown = digests_cnt * sizeof (uint);
12144
12145 uint *digests_shown = (uint *) mymalloc (size_shown);
12146 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12147
12148 uint salts_cnt = 0;
12149 uint salts_done = 0;
12150
12151 hashinfo_t **hash_info = NULL;
12152
12153 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12154 {
12155 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12156
12157 if (username && (remove || show))
12158 {
12159 uint user_pos;
12160
12161 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12162 {
12163 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12164
12165 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12166 }
12167 }
12168 }
12169
12170 uint *salts_shown = (uint *) mymalloc (size_shown);
12171
12172 salt_t *salt_buf;
12173
12174 {
12175 // copied from inner loop
12176
12177 salt_buf = &salts_buf_new[salts_cnt];
12178
12179 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12180
12181 if (esalt_size)
12182 {
12183 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12184 }
12185
12186 salt_buf->digests_cnt = 0;
12187 salt_buf->digests_done = 0;
12188 salt_buf->digests_offset = 0;
12189
12190 salts_cnt++;
12191 }
12192
12193 if (hashes_buf[0].cracked == 1)
12194 {
12195 digests_shown[0] = 1;
12196
12197 digests_done++;
12198
12199 salt_buf->digests_done++;
12200 }
12201
12202 salt_buf->digests_cnt++;
12203
12204 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12205
12206 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12207 {
12208 hash_info[0] = hashes_buf[0].hash_info;
12209 }
12210
12211 // copy from inner loop
12212
12213 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12214 {
12215 if (isSalted)
12216 {
12217 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12218 {
12219 salt_buf = &salts_buf_new[salts_cnt];
12220
12221 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12222
12223 if (esalt_size)
12224 {
12225 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12226 }
12227
12228 salt_buf->digests_cnt = 0;
12229 salt_buf->digests_done = 0;
12230 salt_buf->digests_offset = hashes_pos;
12231
12232 salts_cnt++;
12233 }
12234 }
12235
12236 if (hashes_buf[hashes_pos].cracked == 1)
12237 {
12238 digests_shown[hashes_pos] = 1;
12239
12240 digests_done++;
12241
12242 salt_buf->digests_done++;
12243 }
12244
12245 salt_buf->digests_cnt++;
12246
12247 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12248
12249 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12250 {
12251 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12252 }
12253 }
12254
12255 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12256 {
12257 salt_t *salt_buf = &salts_buf_new[salt_pos];
12258
12259 if (salt_buf->digests_done == salt_buf->digests_cnt)
12260 {
12261 salts_shown[salt_pos] = 1;
12262
12263 salts_done++;
12264 }
12265
12266 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12267 }
12268
12269 local_free (digests_buf);
12270 local_free (salts_buf);
12271 local_free (esalts_buf);
12272
12273 digests_buf = digests_buf_new;
12274 salts_buf = salts_buf_new;
12275 esalts_buf = esalts_buf_new;
12276
12277 local_free (hashes_buf);
12278
12279 /**
12280 * special modification not set from parser
12281 */
12282
12283 switch (hash_mode)
12284 {
12285 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12286 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12287 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12288 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12289 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12290 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12291 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12292 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12293 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12294 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12295 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12296 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12297 }
12298
12299 if (truecrypt_keyfiles)
12300 {
12301 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12302
12303 char *keyfiles = strdup (truecrypt_keyfiles);
12304
12305 char *keyfile = strtok (keyfiles, ",");
12306
12307 do
12308 {
12309 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12310
12311 } while ((keyfile = strtok (NULL, ",")) != NULL);
12312
12313 free (keyfiles);
12314 }
12315
12316 data.digests_cnt = digests_cnt;
12317 data.digests_done = digests_done;
12318 data.digests_buf = digests_buf;
12319 data.digests_shown = digests_shown;
12320 data.digests_shown_tmp = digests_shown_tmp;
12321
12322 data.salts_cnt = salts_cnt;
12323 data.salts_done = salts_done;
12324 data.salts_buf = salts_buf;
12325 data.salts_shown = salts_shown;
12326
12327 data.esalts_buf = esalts_buf;
12328 data.hash_info = hash_info;
12329
12330 /**
12331 * Automatic Optimizers
12332 */
12333
12334 if (salts_cnt == 1)
12335 opti_type |= OPTI_TYPE_SINGLE_SALT;
12336
12337 if (digests_cnt == 1)
12338 opti_type |= OPTI_TYPE_SINGLE_HASH;
12339
12340 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12341 opti_type |= OPTI_TYPE_NOT_ITERATED;
12342
12343 if (attack_mode == ATTACK_MODE_BF)
12344 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12345
12346 data.opti_type = opti_type;
12347
12348 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12349 {
12350 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12351 {
12352 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12353 {
12354 if (opts_type & OPTS_TYPE_ST_ADD80)
12355 {
12356 opts_type &= ~OPTS_TYPE_ST_ADD80;
12357 opts_type |= OPTS_TYPE_PT_ADD80;
12358 }
12359
12360 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12361 {
12362 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12363 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12364 }
12365
12366 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12367 {
12368 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12369 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12370 }
12371 }
12372 }
12373 }
12374
12375 /**
12376 * Some algorithm, like descrypt, can benefit from JIT compilation
12377 */
12378
12379 int force_jit_compilation = -1;
12380
12381 if (hash_mode == 8900)
12382 {
12383 force_jit_compilation = 8900;
12384 }
12385 else if (hash_mode == 9300)
12386 {
12387 force_jit_compilation = 8900;
12388 }
12389 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12390 {
12391 force_jit_compilation = 1500;
12392 }
12393
12394 /**
12395 * generate bitmap tables
12396 */
12397
12398 const uint bitmap_shift1 = 5;
12399 const uint bitmap_shift2 = 13;
12400
12401 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12402
12403 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12404 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12405 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12406 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12407 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12408 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12409 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12410 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12411
12412 uint bitmap_bits;
12413 uint bitmap_nums;
12414 uint bitmap_mask;
12415 uint bitmap_size;
12416
12417 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12418 {
12419 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12420
12421 bitmap_nums = 1 << bitmap_bits;
12422
12423 bitmap_mask = bitmap_nums - 1;
12424
12425 bitmap_size = bitmap_nums * sizeof (uint);
12426
12427 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12428
12429 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;
12430 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;
12431
12432 break;
12433 }
12434
12435 bitmap_nums = 1 << bitmap_bits;
12436
12437 bitmap_mask = bitmap_nums - 1;
12438
12439 bitmap_size = bitmap_nums * sizeof (uint);
12440
12441 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);
12442 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);
12443
12444 /**
12445 * prepare quick rule
12446 */
12447
12448 data.rule_buf_l = rule_buf_l;
12449 data.rule_buf_r = rule_buf_r;
12450
12451 int rule_len_l = (int) strlen (rule_buf_l);
12452 int rule_len_r = (int) strlen (rule_buf_r);
12453
12454 data.rule_len_l = rule_len_l;
12455 data.rule_len_r = rule_len_r;
12456
12457 /**
12458 * load rules
12459 */
12460
12461 uint *all_kernel_rules_cnt = NULL;
12462
12463 kernel_rule_t **all_kernel_rules_buf = NULL;
12464
12465 if (rp_files_cnt)
12466 {
12467 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12468
12469 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12470 }
12471
12472 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12473
12474 int rule_len = 0;
12475
12476 for (uint i = 0; i < rp_files_cnt; i++)
12477 {
12478 uint kernel_rules_avail = 0;
12479
12480 uint kernel_rules_cnt = 0;
12481
12482 kernel_rule_t *kernel_rules_buf = NULL;
12483
12484 char *rp_file = rp_files[i];
12485
12486 char in[BLOCK_SIZE] = { 0 };
12487 char out[BLOCK_SIZE] = { 0 };
12488
12489 FILE *fp = NULL;
12490
12491 uint rule_line = 0;
12492
12493 if ((fp = fopen (rp_file, "rb")) == NULL)
12494 {
12495 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12496
12497 return (-1);
12498 }
12499
12500 while (!feof (fp))
12501 {
12502 memset (rule_buf, 0, HCBUFSIZ);
12503
12504 rule_len = fgetl (fp, rule_buf);
12505
12506 rule_line++;
12507
12508 if (rule_len == 0) continue;
12509
12510 if (rule_buf[0] == '#') continue;
12511
12512 if (kernel_rules_avail == kernel_rules_cnt)
12513 {
12514 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12515
12516 kernel_rules_avail += INCR_RULES;
12517 }
12518
12519 memset (in, 0, BLOCK_SIZE);
12520 memset (out, 0, BLOCK_SIZE);
12521
12522 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12523
12524 if (result == -1)
12525 {
12526 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12527
12528 continue;
12529 }
12530
12531 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12532 {
12533 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12534
12535 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12536
12537 continue;
12538 }
12539
12540 /* its so slow
12541 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12542 {
12543 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12544
12545 continue;
12546 }
12547 */
12548
12549 kernel_rules_cnt++;
12550 }
12551
12552 fclose (fp);
12553
12554 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12555
12556 all_kernel_rules_buf[i] = kernel_rules_buf;
12557 }
12558
12559 /**
12560 * merge rules or automatic rule generator
12561 */
12562
12563 uint kernel_rules_cnt = 0;
12564
12565 kernel_rule_t *kernel_rules_buf = NULL;
12566
12567 if (attack_mode == ATTACK_MODE_STRAIGHT)
12568 {
12569 if (rp_files_cnt)
12570 {
12571 kernel_rules_cnt = 1;
12572
12573 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12574
12575 repeats[0] = kernel_rules_cnt;
12576
12577 for (uint i = 0; i < rp_files_cnt; i++)
12578 {
12579 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12580
12581 repeats[i + 1] = kernel_rules_cnt;
12582 }
12583
12584 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12585
12586 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12587
12588 for (uint i = 0; i < kernel_rules_cnt; i++)
12589 {
12590 uint out_pos = 0;
12591
12592 kernel_rule_t *out = &kernel_rules_buf[i];
12593
12594 for (uint j = 0; j < rp_files_cnt; j++)
12595 {
12596 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12597 uint in_pos;
12598
12599 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12600
12601 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12602 {
12603 if (out_pos == RULES_MAX - 1)
12604 {
12605 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12606
12607 break;
12608 }
12609
12610 out->cmds[out_pos] = in->cmds[in_pos];
12611 }
12612 }
12613 }
12614
12615 local_free (repeats);
12616 }
12617 else if (rp_gen)
12618 {
12619 uint kernel_rules_avail = 0;
12620
12621 while (kernel_rules_cnt < rp_gen)
12622 {
12623 if (kernel_rules_avail == kernel_rules_cnt)
12624 {
12625 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12626
12627 kernel_rules_avail += INCR_RULES;
12628 }
12629
12630 memset (rule_buf, 0, HCBUFSIZ);
12631
12632 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12633
12634 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12635
12636 kernel_rules_cnt++;
12637 }
12638 }
12639 }
12640
12641 myfree (rule_buf);
12642
12643 /**
12644 * generate NOP rules
12645 */
12646
12647 if (kernel_rules_cnt == 0)
12648 {
12649 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12650
12651 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12652
12653 kernel_rules_cnt++;
12654 }
12655
12656 data.kernel_rules_cnt = kernel_rules_cnt;
12657 data.kernel_rules_buf = kernel_rules_buf;
12658
12659 /**
12660 * OpenCL platforms: detect
12661 */
12662
12663 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12664 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12665
12666 cl_uint platforms_cnt = 0;
12667 cl_uint platform_devices_cnt = 0;
12668
12669 if (keyspace == 0)
12670 {
12671 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12672
12673 if (platforms_cnt == 0)
12674 {
12675 log_error ("ERROR: No OpenCL compatible platform found");
12676
12677 return (-1);
12678 }
12679
12680 if (opencl_platforms_filter != (uint) -1)
12681 {
12682 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12683
12684 if (opencl_platforms_filter > platform_cnt_mask)
12685 {
12686 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12687
12688 return (-1);
12689 }
12690 }
12691 }
12692
12693 /**
12694 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12695 */
12696
12697 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12698 {
12699 cl_platform_id platform = platforms[platform_id];
12700
12701 char platform_vendor[INFOSZ] = { 0 };
12702
12703 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12704
12705 #ifdef HAVE_HWMON
12706 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12707 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12708 {
12709 // make sure that we do not directly control the fan for NVidia
12710
12711 gpu_temp_retain = 0;
12712
12713 data.gpu_temp_retain = gpu_temp_retain;
12714 }
12715 #endif // HAVE_NVML || HAVE_NVAPI
12716 #endif
12717 }
12718
12719 /**
12720 * OpenCL devices: simply push all devices from all platforms into the same device array
12721 */
12722
12723 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12724
12725 data.devices_param = devices_param;
12726
12727 uint devices_cnt = 0;
12728
12729 uint devices_active = 0;
12730
12731 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12732 {
12733 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12734
12735 cl_platform_id platform = platforms[platform_id];
12736
12737 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12738
12739 char platform_vendor[INFOSZ] = { 0 };
12740
12741 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12742
12743 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12744 // this causes trouble with vendor id based macros
12745 // we'll assign generic to those without special optimization available
12746
12747 cl_uint vendor_id = 0;
12748
12749 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12750 {
12751 vendor_id = VENDOR_ID_AMD;
12752 }
12753 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12754 {
12755 vendor_id = VENDOR_ID_GENERIC;
12756 }
12757 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12758 {
12759 vendor_id = VENDOR_ID_GENERIC;
12760 }
12761 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12762 {
12763 vendor_id = VENDOR_ID_GENERIC;
12764 }
12765 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12766 {
12767 vendor_id = VENDOR_ID_GENERIC;
12768 }
12769 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12770 {
12771 vendor_id = VENDOR_ID_NV;
12772 }
12773 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12774 {
12775 vendor_id = VENDOR_ID_GENERIC;
12776 }
12777 else
12778 {
12779 vendor_id = VENDOR_ID_GENERIC;
12780 }
12781
12782 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12783 {
12784 size_t param_value_size = 0;
12785
12786 const uint device_id = devices_cnt;
12787
12788 hc_device_param_t *device_param = &data.devices_param[device_id];
12789
12790 device_param->vendor_id = vendor_id;
12791
12792 device_param->device = platform_devices[platform_devices_id];
12793
12794 device_param->device_id = device_id;
12795
12796 device_param->platform_devices_id = platform_devices_id;
12797
12798 // device_type
12799
12800 cl_device_type device_type;
12801
12802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12803
12804 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12805
12806 device_param->device_type = device_type;
12807
12808 // device_name
12809
12810 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12811
12812 char *device_name = (char *) mymalloc (param_value_size);
12813
12814 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12815
12816 device_param->device_name = device_name;
12817
12818 // tuning db
12819
12820 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12821
12822 // device_version
12823
12824 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12825
12826 char *device_version = (char *) mymalloc (param_value_size);
12827
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12829
12830 device_param->device_version = device_version;
12831
12832 // device_opencl_version
12833
12834 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12835
12836 char *device_opencl_version = (char *) mymalloc (param_value_size);
12837
12838 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12839
12840 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12841
12842 myfree (device_opencl_version);
12843
12844 // vector_width
12845
12846 cl_uint vector_width;
12847
12848 if (opencl_vector_width_chgd == 0)
12849 {
12850 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12851 {
12852 if (opti_type & OPTI_TYPE_USES_BITS_64)
12853 {
12854 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12855 }
12856 else
12857 {
12858 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12859 }
12860 }
12861 else
12862 {
12863 vector_width = (cl_uint) tuningdb_entry->vector_width;
12864 }
12865 }
12866 else
12867 {
12868 vector_width = opencl_vector_width;
12869 }
12870
12871 if (vector_width > 16) vector_width = 16;
12872
12873 device_param->vector_width = vector_width;
12874
12875 // max_compute_units
12876
12877 cl_uint device_processors;
12878
12879 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12880
12881 device_param->device_processors = device_processors;
12882
12883 // device_maxmem_alloc
12884 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12885
12886 cl_ulong device_maxmem_alloc;
12887
12888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12889
12890 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7ffffff);
12891
12892 // device_global_mem
12893
12894 cl_ulong device_global_mem;
12895
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12897
12898 device_param->device_global_mem = device_global_mem;
12899
12900 // max_work_group_size
12901
12902 size_t device_maxworkgroup_size;
12903
12904 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12905
12906 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12907
12908 // max_clock_frequency
12909
12910 cl_uint device_maxclock_frequency;
12911
12912 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12913
12914 device_param->device_maxclock_frequency = device_maxclock_frequency;
12915
12916 // skipped
12917
12918 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12919 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12920
12921 device_param->skipped = (skipped1 || skipped2);
12922
12923 // driver_version
12924 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12925
12926 char *driver_version = (char *) mymalloc (param_value_size);
12927
12928 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12929
12930 device_param->driver_version = driver_version;
12931
12932 // device_name_chksum
12933
12934 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12935
12936 #if __x86_64__
12937 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);
12938 #else
12939 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);
12940 #endif
12941
12942 uint device_name_digest[4] = { 0 };
12943
12944 md5_64 ((uint *) device_name_chksum, device_name_digest);
12945
12946 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12947
12948 device_param->device_name_chksum = device_name_chksum;
12949
12950 // device_processor_cores
12951
12952 if (device_type & CL_DEVICE_TYPE_CPU)
12953 {
12954 cl_uint device_processor_cores = 1;
12955
12956 device_param->device_processor_cores = device_processor_cores;
12957 }
12958
12959 if (device_type & CL_DEVICE_TYPE_GPU)
12960 {
12961 if (vendor_id == VENDOR_ID_AMD)
12962 {
12963 cl_uint device_processor_cores = 0;
12964
12965 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12966
12967 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12968
12969 device_param->device_processor_cores = device_processor_cores;
12970 }
12971 else if (vendor_id == VENDOR_ID_NV)
12972 {
12973 cl_uint kernel_exec_timeout = 0;
12974
12975 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12976
12977 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12978
12979 device_param->kernel_exec_timeout = kernel_exec_timeout;
12980
12981 cl_uint device_processor_cores = 0;
12982
12983 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12984
12985 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12986
12987 device_param->device_processor_cores = device_processor_cores;
12988
12989 cl_uint sm_minor = 0;
12990 cl_uint sm_major = 0;
12991
12992 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12993 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12994
12995 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12996 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12997
12998 device_param->sm_minor = sm_minor;
12999 device_param->sm_major = sm_major;
13000 }
13001 else
13002 {
13003 cl_uint device_processor_cores = 1;
13004
13005 device_param->device_processor_cores = device_processor_cores;
13006 }
13007 }
13008
13009 // display results
13010
13011 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13012 {
13013 if (device_param->skipped == 0)
13014 {
13015 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13016 device_id + 1,
13017 device_name,
13018 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13019 (unsigned int) (device_global_mem / 1024 / 1024),
13020 (unsigned int) (device_maxclock_frequency),
13021 (unsigned int) device_processors);
13022 }
13023 else
13024 {
13025 log_info ("Device #%u: %s, skipped",
13026 device_id + 1,
13027 device_name);
13028 }
13029 }
13030
13031 // common driver check
13032
13033 if (device_param->skipped == 0)
13034 {
13035 if (device_type & CL_DEVICE_TYPE_GPU)
13036 {
13037 if (vendor_id == VENDOR_ID_AMD)
13038 {
13039 int catalyst_check = (force == 1) ? 0 : 1;
13040
13041 int catalyst_warn = 0;
13042
13043 int catalyst_broken = 0;
13044
13045 if (catalyst_check == 1)
13046 {
13047 catalyst_warn = 1;
13048
13049 // v14.9 and higher
13050 if (atoi (device_param->driver_version) >= 1573)
13051 {
13052 catalyst_warn = 0;
13053 }
13054
13055 catalyst_check = 0;
13056 }
13057
13058 if (catalyst_broken == 1)
13059 {
13060 log_info ("");
13061 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13062 log_info ("It will pass over cracked hashes and does not report them as cracked");
13063 log_info ("You are STRONGLY encouraged not to use it");
13064 log_info ("You can use --force to override this but do not post error reports if you do so");
13065 log_info ("");
13066
13067 return (-1);
13068 }
13069
13070 if (catalyst_warn == 1)
13071 {
13072 log_info ("");
13073 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13074 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13075 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13076 #ifdef _WIN
13077 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13078 #endif
13079 log_info ("You can use --force to override this but do not post error reports if you do so");
13080 log_info ("");
13081
13082 return (-1);
13083 }
13084 }
13085 else if (vendor_id == VENDOR_ID_NV)
13086 {
13087 if (device_param->kernel_exec_timeout != 0)
13088 {
13089 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);
13090 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13091 }
13092 }
13093 else if (vendor_id == VENDOR_ID_POCL)
13094 {
13095 if (force == 0)
13096 {
13097 log_info ("");
13098 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
13099 log_info ("You are STRONGLY encouraged not to use it");
13100 log_info ("You can use --force to override this but do not post error reports if you do so");
13101 log_info ("");
13102
13103 return (-1);
13104 }
13105 }
13106 }
13107
13108 /**
13109 * kernel accel and loops tuning db adjustment
13110 */
13111
13112 device_param->kernel_accel_min = 1;
13113 device_param->kernel_accel_max = 1024;
13114
13115 device_param->kernel_loops_min = 1;
13116 device_param->kernel_loops_max = 1024;
13117
13118 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13119
13120 if (tuningdb_entry)
13121 {
13122 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13123 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13124
13125 if (_kernel_accel)
13126 {
13127 device_param->kernel_accel_min = _kernel_accel;
13128 device_param->kernel_accel_max = _kernel_accel;
13129 }
13130
13131 if (_kernel_loops)
13132 {
13133 if (workload_profile == 1)
13134 {
13135 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13136 }
13137 else if (workload_profile == 2)
13138 {
13139 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13140 }
13141
13142 device_param->kernel_loops_min = _kernel_loops;
13143 device_param->kernel_loops_max = _kernel_loops;
13144 }
13145 }
13146
13147 // commandline parameters overwrite tuningdb entries
13148
13149 if (kernel_accel)
13150 {
13151 device_param->kernel_accel_min = kernel_accel;
13152 device_param->kernel_accel_max = kernel_accel;
13153 }
13154
13155 if (kernel_loops)
13156 {
13157 device_param->kernel_loops_min = kernel_loops;
13158 device_param->kernel_loops_max = kernel_loops;
13159 }
13160
13161 /**
13162 * activate device
13163 */
13164
13165 devices_active++;
13166 }
13167
13168 // next please
13169
13170 devices_cnt++;
13171 }
13172 }
13173
13174 if (keyspace == 0 && devices_active == 0)
13175 {
13176 log_error ("ERROR: No devices found/left");
13177
13178 return (-1);
13179 }
13180
13181 // 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)
13182
13183 if (devices_filter != (uint) -1)
13184 {
13185 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13186
13187 if (devices_filter > devices_cnt_mask)
13188 {
13189 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13190
13191 return (-1);
13192 }
13193 }
13194
13195 data.devices_cnt = devices_cnt;
13196
13197 data.devices_active = devices_active;
13198
13199 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13200 {
13201 log_info ("");
13202 }
13203
13204 /**
13205 * HM devices: init
13206 */
13207
13208 #ifdef HAVE_HWMON
13209 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13210 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13211 #endif
13212
13213 #ifdef HAVE_ADL
13214 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13215 #endif
13216
13217 if (gpu_temp_disable == 0)
13218 {
13219 #if defined(WIN) && defined(HAVE_NVAPI)
13220 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13221
13222 if (nvapi_init (nvapi) == 0)
13223 data.hm_nv = nvapi;
13224
13225 if (data.hm_nv)
13226 {
13227 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13228 {
13229 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13230
13231 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13232
13233 int tmp_out = 0;
13234
13235 for (int i = 0; i < tmp_in; i++)
13236 {
13237 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13238 }
13239
13240 for (int i = 0; i < tmp_out; i++)
13241 {
13242 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13243
13244 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13245
13246 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;
13247 }
13248 }
13249 }
13250 #endif // WIN && HAVE_NVAPI
13251
13252 #if defined(LINUX) && defined(HAVE_NVML)
13253 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13254
13255 if (nvml_init (nvml) == 0)
13256 data.hm_nv = nvml;
13257
13258 if (data.hm_nv)
13259 {
13260 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13261 {
13262 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13263
13264 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13265
13266 int tmp_out = 0;
13267
13268 for (int i = 0; i < tmp_in; i++)
13269 {
13270 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13271 }
13272
13273 for (int i = 0; i < tmp_out; i++)
13274 {
13275 unsigned int speed;
13276
13277 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;
13278 }
13279 }
13280 }
13281 #endif // LINUX && HAVE_NVML
13282
13283 data.hm_amd = NULL;
13284
13285 #ifdef HAVE_ADL
13286 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13287
13288 if (adl_init (adl) == 0)
13289 data.hm_amd = adl;
13290
13291 if (data.hm_amd)
13292 {
13293 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13294 {
13295 // total number of adapters
13296
13297 int hm_adapters_num;
13298
13299 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13300
13301 // adapter info
13302
13303 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13304
13305 if (lpAdapterInfo == NULL) return (-1);
13306
13307 // get a list (of ids of) valid/usable adapters
13308
13309 int num_adl_adapters = 0;
13310
13311 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13312
13313 if (num_adl_adapters > 0)
13314 {
13315 hc_thread_mutex_lock (mux_adl);
13316
13317 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13318
13319 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13320
13321 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13322 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13323
13324 hc_thread_mutex_unlock (mux_adl);
13325 }
13326
13327 myfree (valid_adl_device_list);
13328 myfree (lpAdapterInfo);
13329 }
13330 }
13331 #endif // HAVE_ADL
13332
13333 if (data.hm_amd == NULL && data.hm_nv == NULL)
13334 {
13335 gpu_temp_disable = 1;
13336 }
13337 }
13338
13339 /**
13340 * OpenCL devices: allocate buffer for device specific information
13341 */
13342
13343 #ifdef HAVE_HWMON
13344 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13345
13346 #ifdef HAVE_ADL
13347 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13348
13349 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13350 #endif // ADL
13351 #endif
13352
13353 /**
13354 * enable custom signal handler(s)
13355 */
13356
13357 if (benchmark == 0)
13358 {
13359 hc_signal (sigHandler_default);
13360 }
13361 else
13362 {
13363 hc_signal (sigHandler_benchmark);
13364 }
13365
13366 /**
13367 * User-defined GPU temp handling
13368 */
13369
13370 #ifdef HAVE_HWMON
13371 if (gpu_temp_disable == 1)
13372 {
13373 gpu_temp_abort = 0;
13374 gpu_temp_retain = 0;
13375 }
13376
13377 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13378 {
13379 if (gpu_temp_abort < gpu_temp_retain)
13380 {
13381 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13382
13383 return (-1);
13384 }
13385 }
13386
13387 data.gpu_temp_disable = gpu_temp_disable;
13388 data.gpu_temp_abort = gpu_temp_abort;
13389 data.gpu_temp_retain = gpu_temp_retain;
13390 #endif
13391
13392 /**
13393 * inform the user
13394 */
13395
13396 if (data.quiet == 0)
13397 {
13398 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13399
13400 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);
13401
13402 if (attack_mode == ATTACK_MODE_STRAIGHT)
13403 {
13404 log_info ("Rules: %u", kernel_rules_cnt);
13405 }
13406
13407 if (opti_type)
13408 {
13409 log_info ("Applicable Optimizers:");
13410
13411 for (uint i = 0; i < 32; i++)
13412 {
13413 const uint opti_bit = 1u << i;
13414
13415 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13416 }
13417 }
13418
13419 /**
13420 * Watchdog and Temperature balance
13421 */
13422
13423 #ifdef HAVE_HWMON
13424 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13425 {
13426 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13427 }
13428
13429 if (gpu_temp_abort == 0)
13430 {
13431 log_info ("Watchdog: Temperature abort trigger disabled");
13432 }
13433 else
13434 {
13435 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13436 }
13437
13438 if (gpu_temp_retain == 0)
13439 {
13440 log_info ("Watchdog: Temperature retain trigger disabled");
13441 }
13442 else
13443 {
13444 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13445 }
13446 #endif
13447 }
13448
13449 if (data.quiet == 0) log_info ("");
13450
13451 /**
13452 * HM devices: copy
13453 */
13454
13455 if (gpu_temp_disable == 0)
13456 {
13457 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13458 {
13459 hc_device_param_t *device_param = &data.devices_param[device_id];
13460
13461 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13462
13463 if (device_param->skipped) continue;
13464
13465 const uint platform_devices_id = device_param->platform_devices_id;
13466
13467 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13468 if (device_param->vendor_id == VENDOR_ID_NV)
13469 {
13470 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13471 }
13472 #endif
13473
13474 #ifdef HAVE_ADL
13475 if (device_param->vendor_id == VENDOR_ID_AMD)
13476 {
13477 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13478 }
13479 #endif
13480 }
13481 }
13482
13483 /*
13484 * Temporary fix:
13485 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13486 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13487 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13488 * Driver / ADL bug?
13489 */
13490
13491 #ifdef HAVE_ADL
13492 if (powertune_enable == 1)
13493 {
13494 hc_thread_mutex_lock (mux_adl);
13495
13496 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13497 {
13498 hc_device_param_t *device_param = &data.devices_param[device_id];
13499
13500 if (device_param->skipped) continue;
13501
13502 if (data.hm_device[device_id].od_version == 6)
13503 {
13504 // set powertune value only
13505
13506 int powertune_supported = 0;
13507
13508 int ADL_rc = 0;
13509
13510 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13511 {
13512 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13513
13514 return (-1);
13515 }
13516
13517 if (powertune_supported != 0)
13518 {
13519 // powertune set
13520 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13521
13522 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13523 {
13524 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13525
13526 return (-1);
13527 }
13528
13529 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13530 {
13531 log_error ("ERROR: Failed to set new ADL PowerControl values");
13532
13533 return (-1);
13534 }
13535 }
13536 }
13537 }
13538
13539 hc_thread_mutex_unlock (mux_adl);
13540 }
13541 #endif // HAVE_ADK
13542 #endif // HAVE_HWMON
13543
13544 #ifdef DEBUG
13545 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13546 #endif
13547
13548 uint kernel_power_all = 0;
13549
13550 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13551 {
13552 /**
13553 * host buffer
13554 */
13555
13556 hc_device_param_t *device_param = &data.devices_param[device_id];
13557
13558 if (device_param->skipped) continue;
13559
13560 /**
13561 * device properties
13562 */
13563
13564 const char *device_name_chksum = device_param->device_name_chksum;
13565 const u32 device_processors = device_param->device_processors;
13566 const u32 device_processor_cores = device_param->device_processor_cores;
13567
13568 /**
13569 * create context for each device
13570 */
13571
13572 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13573
13574 /**
13575 * create command-queue
13576 */
13577
13578 // not supported with NV
13579 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13580
13581 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13582
13583 /**
13584 * kernel threads: some algorithms need a fixed kernel-threads count
13585 * because of shared memory usage or bitslice
13586 */
13587
13588 uint kernel_threads = device_param->device_maxworkgroup_size;
13589
13590 if (hash_mode == 1500) kernel_threads = 64; // DES
13591 if (hash_mode == 3000) kernel_threads = 64; // DES
13592 if (hash_mode == 3200) kernel_threads = 8; // blowfish
13593 if (hash_mode == 7500) kernel_threads = 64; // RC4
13594 if (hash_mode == 9000) kernel_threads = 8; // blowfish
13595 if (hash_mode == 9700) kernel_threads = 64; // RC4
13596 if (hash_mode == 9710) kernel_threads = 64; // RC4
13597 if (hash_mode == 9800) kernel_threads = 64; // RC4
13598 if (hash_mode == 9810) kernel_threads = 64; // RC4
13599 if (hash_mode == 10400) kernel_threads = 64; // RC4
13600 if (hash_mode == 10410) kernel_threads = 64; // RC4
13601 if (hash_mode == 10500) kernel_threads = 64; // RC4
13602 if (hash_mode == 13100) kernel_threads = 64; // RC4
13603
13604 /**
13605 * create input buffers on device : calculate size of fixed memory buffers
13606 */
13607
13608 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13609 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13610
13611 device_param->size_root_css = size_root_css;
13612 device_param->size_markov_css = size_markov_css;
13613
13614 size_t size_results = kernel_threads * sizeof (uint);
13615
13616 device_param->size_results = size_results;
13617
13618 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13619 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13620
13621 size_t size_plains = digests_cnt * sizeof (plain_t);
13622 size_t size_salts = salts_cnt * sizeof (salt_t);
13623 size_t size_esalts = salts_cnt * esalt_size;
13624
13625 device_param->size_plains = size_plains;
13626 device_param->size_digests = size_digests;
13627 device_param->size_shown = size_shown;
13628 device_param->size_salts = size_salts;
13629
13630 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13631 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13632 size_t size_tm = 32 * sizeof (bs_word_t);
13633
13634 // scryptV stuff
13635
13636 size_t size_scryptV = 1;
13637
13638 if ((hash_mode == 8900) || (hash_mode == 9300))
13639 {
13640 uint tmto_start = 0;
13641 uint tmto_stop = 10;
13642
13643 if (scrypt_tmto)
13644 {
13645 tmto_start = scrypt_tmto;
13646 }
13647 else
13648 {
13649 // in case the user did not specify the tmto manually
13650 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13651 // but set the lower end only in case the user has a device with too less memory
13652
13653 if (hash_mode == 8900)
13654 {
13655 if (device_param->vendor_id == VENDOR_ID_AMD)
13656 {
13657 tmto_start = 1;
13658 }
13659 else if (device_param->vendor_id == VENDOR_ID_NV)
13660 {
13661 tmto_start = 3;
13662 }
13663 }
13664 else if (hash_mode == 9300)
13665 {
13666 if (device_param->vendor_id == VENDOR_ID_AMD)
13667 {
13668 tmto_start = 3;
13669 }
13670 else if (device_param->vendor_id == VENDOR_ID_NV)
13671 {
13672 tmto_start = 5;
13673 }
13674 }
13675 }
13676
13677 if (quiet == 0) log_info ("");
13678
13679 uint shader_per_mp = 1;
13680
13681 if (device_param->vendor_id == VENDOR_ID_AMD)
13682 {
13683 shader_per_mp = 8;
13684 }
13685 else if (device_param->vendor_id == VENDOR_ID_NV)
13686 {
13687 shader_per_mp = 32;
13688 }
13689
13690 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13691 {
13692 // TODO: in theory the following calculation needs to be done per salt, not global
13693 // we assume all hashes have the same scrypt settings
13694
13695 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13696
13697 size_scryptV /= 1 << tmto;
13698
13699 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13700
13701 if (size_scryptV > device_param->device_maxmem_alloc)
13702 {
13703 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13704
13705 continue;
13706 }
13707
13708 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13709 {
13710 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13711 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13712 }
13713
13714 break;
13715 }
13716
13717 if (data.salts_buf[0].scrypt_phy == 0)
13718 {
13719 log_error ("ERROR: can't allocate enough device memory");
13720
13721 return -1;
13722 }
13723
13724 if (quiet == 0) log_info ("");
13725 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13726 }
13727
13728 /**
13729 * some algorithms need a fixed kernel-loops count
13730 */
13731
13732 if (hash_mode == 1500)
13733 {
13734 const u32 kernel_loops_fixed = 1024;
13735
13736 device_param->kernel_loops_min = kernel_loops_fixed;
13737 device_param->kernel_loops_max = kernel_loops_fixed;
13738 }
13739
13740 if (hash_mode == 3000)
13741 {
13742 const u32 kernel_loops_fixed = 1024;
13743
13744 device_param->kernel_loops_min = kernel_loops_fixed;
13745 device_param->kernel_loops_max = kernel_loops_fixed;
13746 }
13747
13748 if (hash_mode == 8900)
13749 {
13750 const u32 kernel_loops_fixed = 1;
13751
13752 device_param->kernel_loops_min = kernel_loops_fixed;
13753 device_param->kernel_loops_max = kernel_loops_fixed;
13754 }
13755
13756 if (hash_mode == 9300)
13757 {
13758 const u32 kernel_loops_fixed = 1;
13759
13760 device_param->kernel_loops_min = kernel_loops_fixed;
13761 device_param->kernel_loops_max = kernel_loops_fixed;
13762 }
13763
13764 if (hash_mode == 12500)
13765 {
13766 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13767
13768 device_param->kernel_loops_min = kernel_loops_fixed;
13769 device_param->kernel_loops_max = kernel_loops_fixed;
13770 }
13771
13772 /**
13773 * some algorithms have a maximum kernel-loops count
13774 */
13775
13776 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13777 {
13778 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13779 {
13780 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13781 }
13782 }
13783
13784 /**
13785 * some algorithms need a special kernel-accel
13786 */
13787
13788 if (hash_mode == 8900)
13789 {
13790 device_param->kernel_accel_min = 1;
13791 device_param->kernel_accel_max = 64;
13792 }
13793
13794 if (hash_mode == 9300)
13795 {
13796 device_param->kernel_accel_min = 1;
13797 device_param->kernel_accel_max = 64;
13798 }
13799
13800 u32 kernel_accel_min = device_param->kernel_accel_min;
13801 u32 kernel_accel_max = device_param->kernel_accel_max;
13802
13803 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13804
13805 size_t size_pws = 4;
13806 size_t size_tmps = 4;
13807 size_t size_hooks = 4;
13808
13809 while (kernel_accel_max >= kernel_accel_min)
13810 {
13811 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13812
13813 // size_pws
13814
13815 size_pws = kernel_power_max * sizeof (pw_t);
13816
13817 // size_tmps
13818
13819 switch (hash_mode)
13820 {
13821 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13822 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13823 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13824 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13825 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13826 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13827 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13828 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13829 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13830 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13831 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13832 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13833 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13834 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13835 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13836 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13837 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13838 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13839 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13840 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13841 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13842 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13843 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13844 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13845 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13846 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13847 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13848 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13849 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13850 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13851 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13852 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13853 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13854 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13855 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13856 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13857 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13858 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13859 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13860 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13861 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13862 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13863 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13864 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13865 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13866 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13867 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13868 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13869 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13870 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13871 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13872 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13873 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13874 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13875 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13876 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13877 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13878 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13879 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13880 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13881 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13882 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13883 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13884 };
13885
13886 // size_hooks
13887
13888 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13889 {
13890 // none yet
13891 }
13892
13893 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13894 // if not, decrease amplifier and try again
13895
13896 int skip = 0;
13897
13898 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13899 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13900 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13901
13902 if (( bitmap_size
13903 + bitmap_size
13904 + bitmap_size
13905 + bitmap_size
13906 + bitmap_size
13907 + bitmap_size
13908 + bitmap_size
13909 + bitmap_size
13910 + size_bfs
13911 + size_combs
13912 + size_digests
13913 + size_esalts
13914 + size_hooks
13915 + size_markov_css
13916 + size_plains
13917 + size_pws
13918 + size_pws // not a bug
13919 + size_results
13920 + size_root_css
13921 + size_rules
13922 + size_rules_c
13923 + size_salts
13924 + size_scryptV
13925 + size_shown
13926 + size_tm
13927 + size_tmps) > device_param->device_global_mem) skip = 1;
13928
13929 if (skip == 1)
13930 {
13931 kernel_accel_max--;
13932
13933 continue;
13934 }
13935
13936 break;
13937 }
13938
13939 /*
13940 if (kernel_accel_max == 0)
13941 {
13942 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13943
13944 return -1;
13945 }
13946 */
13947
13948 device_param->kernel_accel_min = kernel_accel_min;
13949 device_param->kernel_accel_max = kernel_accel_max;
13950
13951 /*
13952 if (kernel_accel_max < kernel_accel)
13953 {
13954 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13955
13956 device_param->kernel_accel = kernel_accel_max;
13957 }
13958 */
13959
13960 device_param->size_bfs = size_bfs;
13961 device_param->size_combs = size_combs;
13962 device_param->size_rules = size_rules;
13963 device_param->size_rules_c = size_rules_c;
13964 device_param->size_pws = size_pws;
13965 device_param->size_tmps = size_tmps;
13966 device_param->size_hooks = size_hooks;
13967
13968 // do not confuse kernel_accel_max with kernel_accel here
13969
13970 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13971
13972 device_param->kernel_threads = kernel_threads;
13973 device_param->kernel_power_user = kernel_power;
13974
13975 kernel_power_all += kernel_power;
13976
13977 /**
13978 * default building options
13979 */
13980
13981 char build_opts[1024] = { 0 };
13982
13983 // we don't have sm_* on vendors not NV but it doesn't matter
13984
13985 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", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13986
13987 /**
13988 * main kernel
13989 */
13990
13991 {
13992 /**
13993 * kernel source filename
13994 */
13995
13996 char source_file[256] = { 0 };
13997
13998 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13999
14000 struct stat sst;
14001
14002 if (stat (source_file, &sst) == -1)
14003 {
14004 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14005
14006 return -1;
14007 }
14008
14009 /**
14010 * kernel cached filename
14011 */
14012
14013 char cached_file[256] = { 0 };
14014
14015 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14016
14017 int cached = 1;
14018
14019 struct stat cst;
14020
14021 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14022 {
14023 cached = 0;
14024 }
14025
14026 /**
14027 * kernel compile or load
14028 */
14029
14030 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14031
14032 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14033
14034 if (force_jit_compilation == -1)
14035 {
14036 if (cached == 0)
14037 {
14038 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14039
14040 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14041
14042 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14043
14044 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14045
14046 #ifdef DEBUG
14047 size_t build_log_size = 0;
14048
14049 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14050
14051 if (build_log_size > 1)
14052 {
14053 char *build_log = (char *) malloc (build_log_size + 1);
14054
14055 memset (build_log, 0, build_log_size + 1);
14056
14057 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14058
14059 puts (build_log);
14060
14061 free (build_log);
14062 }
14063 #endif
14064
14065 if (rc != 0)
14066 {
14067 device_param->skipped = true;
14068 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14069 continue;
14070 }
14071
14072 size_t binary_size;
14073
14074 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14075
14076 u8 *binary = (u8 *) mymalloc (binary_size);
14077
14078 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14079
14080 writeProgramBin (cached_file, binary, binary_size);
14081
14082 local_free (binary);
14083 }
14084 else
14085 {
14086 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14087
14088 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14089
14090 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14091
14092 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14093 }
14094 }
14095 else
14096 {
14097 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14098
14099 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14100
14101 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14102
14103 char build_opts_update[1024] = { 0 };
14104
14105 if (force_jit_compilation == 1500)
14106 {
14107 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14108 }
14109 else if (force_jit_compilation == 8900)
14110 {
14111 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);
14112 }
14113 else
14114 {
14115 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14116 }
14117
14118 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14119
14120 #ifdef DEBUG
14121 size_t build_log_size = 0;
14122
14123 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14124
14125 if (build_log_size > 1)
14126 {
14127 char *build_log = (char *) malloc (build_log_size + 1);
14128
14129 memset (build_log, 0, build_log_size + 1);
14130
14131 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14132
14133 puts (build_log);
14134
14135 free (build_log);
14136 }
14137 #endif
14138
14139 if (rc != 0)
14140 {
14141 device_param->skipped = true;
14142
14143 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14144 }
14145 }
14146
14147 local_free (kernel_lengths);
14148 local_free (kernel_sources[0]);
14149 local_free (kernel_sources);
14150 }
14151
14152 /**
14153 * word generator kernel
14154 */
14155
14156 if (attack_mode != ATTACK_MODE_STRAIGHT)
14157 {
14158 /**
14159 * kernel mp source filename
14160 */
14161
14162 char source_file[256] = { 0 };
14163
14164 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14165
14166 struct stat sst;
14167
14168 if (stat (source_file, &sst) == -1)
14169 {
14170 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14171
14172 return -1;
14173 }
14174
14175 /**
14176 * kernel mp cached filename
14177 */
14178
14179 char cached_file[256] = { 0 };
14180
14181 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14182
14183 int cached = 1;
14184
14185 struct stat cst;
14186
14187 if (stat (cached_file, &cst) == -1)
14188 {
14189 cached = 0;
14190 }
14191
14192 /**
14193 * kernel compile or load
14194 */
14195
14196 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14197
14198 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14199
14200 if (cached == 0)
14201 {
14202 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14203
14204 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14205
14206 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14207
14208 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14209
14210 if (rc != 0)
14211 {
14212 device_param->skipped = true;
14213 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14214 continue;
14215 }
14216
14217 size_t binary_size;
14218
14219 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14220
14221 u8 *binary = (u8 *) mymalloc (binary_size);
14222
14223 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14224
14225 writeProgramBin (cached_file, binary, binary_size);
14226
14227 local_free (binary);
14228 }
14229 else
14230 {
14231 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14232
14233 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14234
14235 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14236
14237 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14238 }
14239
14240 local_free (kernel_lengths);
14241 local_free (kernel_sources[0]);
14242 local_free (kernel_sources);
14243 }
14244
14245 /**
14246 * amplifier kernel
14247 */
14248
14249 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14250 {
14251
14252 }
14253 else
14254 {
14255 /**
14256 * kernel amp source filename
14257 */
14258
14259 char source_file[256] = { 0 };
14260
14261 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14262
14263 struct stat sst;
14264
14265 if (stat (source_file, &sst) == -1)
14266 {
14267 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14268
14269 return -1;
14270 }
14271
14272 /**
14273 * kernel amp cached filename
14274 */
14275
14276 char cached_file[256] = { 0 };
14277
14278 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14279
14280 int cached = 1;
14281
14282 struct stat cst;
14283
14284 if (stat (cached_file, &cst) == -1)
14285 {
14286 cached = 0;
14287 }
14288
14289 /**
14290 * kernel compile or load
14291 */
14292
14293 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14294
14295 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14296
14297 if (cached == 0)
14298 {
14299 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14300
14301 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14302
14303 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14304
14305 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14306
14307 if (rc != 0)
14308 {
14309 device_param->skipped = true;
14310 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14311 continue;
14312 }
14313
14314 size_t binary_size;
14315
14316 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14317
14318 u8 *binary = (u8 *) mymalloc (binary_size);
14319
14320 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14321
14322 writeProgramBin (cached_file, binary, binary_size);
14323
14324 local_free (binary);
14325 }
14326 else
14327 {
14328 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14329
14330 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14331
14332 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14333
14334 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14335 }
14336
14337 local_free (kernel_lengths);
14338 local_free (kernel_sources[0]);
14339 local_free (kernel_sources);
14340 }
14341
14342 // some algorithm collide too fast, make that impossible
14343
14344 if (benchmark == 1)
14345 {
14346 ((uint *) digests_buf)[0] = -1;
14347 ((uint *) digests_buf)[1] = -1;
14348 ((uint *) digests_buf)[2] = -1;
14349 ((uint *) digests_buf)[3] = -1;
14350 }
14351
14352 /**
14353 * global buffers
14354 */
14355
14356 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14357 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14358 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14359 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14360 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14361 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14362 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14363 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14364 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14365 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14366 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14367 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14368 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14369 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14370 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14371 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14372 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14373 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14374
14375 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);
14376 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);
14377 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);
14378 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);
14379 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);
14380 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);
14381 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);
14382 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);
14383 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14384 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14386
14387 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14388 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14389 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14390 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14391 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14392 run_kernel_bzero (device_param, device_param->d_result, size_results);
14393
14394 /**
14395 * special buffers
14396 */
14397
14398 if (attack_kern == ATTACK_KERN_STRAIGHT)
14399 {
14400 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14401 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14402
14403 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14404
14405 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14406 }
14407 else if (attack_kern == ATTACK_KERN_COMBI)
14408 {
14409 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14410 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14411 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14412 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14413
14414 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14415 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14416 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14417 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14418 }
14419 else if (attack_kern == ATTACK_KERN_BF)
14420 {
14421 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14422 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14423 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14424 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14425 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14426
14427 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14428 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14429 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14430 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14431 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14432 }
14433
14434 if (size_esalts)
14435 {
14436 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14437
14438 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14439 }
14440
14441 /**
14442 * main host data
14443 */
14444
14445 uint *result = (uint *) mymalloc (size_results);
14446
14447 device_param->result = result;
14448
14449 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14450
14451 device_param->pws_buf = pws_buf;
14452
14453 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14454
14455 device_param->combs_buf = combs_buf;
14456
14457 void *hooks_buf = mymalloc (size_hooks);
14458
14459 device_param->hooks_buf = hooks_buf;
14460
14461 /**
14462 * kernel args
14463 */
14464
14465 device_param->kernel_params_buf32[21] = bitmap_mask;
14466 device_param->kernel_params_buf32[22] = bitmap_shift1;
14467 device_param->kernel_params_buf32[23] = bitmap_shift2;
14468 device_param->kernel_params_buf32[24] = 0; // salt_pos
14469 device_param->kernel_params_buf32[25] = 0; // loop_pos
14470 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14471 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14472 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14473 device_param->kernel_params_buf32[29] = 0; // digests_offset
14474 device_param->kernel_params_buf32[30] = 0; // combs_mode
14475 device_param->kernel_params_buf32[31] = 0; // gid_max
14476
14477 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14478 ? &device_param->d_pws_buf
14479 : &device_param->d_pws_amp_buf;
14480 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14481 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14482 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14483 device_param->kernel_params[ 4] = &device_param->d_tmps;
14484 device_param->kernel_params[ 5] = &device_param->d_hooks;
14485 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14486 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14487 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14488 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14489 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14490 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14491 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14492 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14493 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14494 device_param->kernel_params[15] = &device_param->d_digests_buf;
14495 device_param->kernel_params[16] = &device_param->d_digests_shown;
14496 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14497 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14498 device_param->kernel_params[19] = &device_param->d_result;
14499 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14500 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14501 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14502 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14503 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14504 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14505 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14506 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14507 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14508 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14509 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14510 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14511
14512 device_param->kernel_params_mp_buf64[3] = 0;
14513 device_param->kernel_params_mp_buf32[4] = 0;
14514 device_param->kernel_params_mp_buf32[5] = 0;
14515 device_param->kernel_params_mp_buf32[6] = 0;
14516 device_param->kernel_params_mp_buf32[7] = 0;
14517 device_param->kernel_params_mp_buf32[8] = 0;
14518
14519 device_param->kernel_params_mp[0] = NULL;
14520 device_param->kernel_params_mp[1] = NULL;
14521 device_param->kernel_params_mp[2] = NULL;
14522 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14523 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14524 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14525 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14526 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14527 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14528
14529 device_param->kernel_params_mp_l_buf64[3] = 0;
14530 device_param->kernel_params_mp_l_buf32[4] = 0;
14531 device_param->kernel_params_mp_l_buf32[5] = 0;
14532 device_param->kernel_params_mp_l_buf32[6] = 0;
14533 device_param->kernel_params_mp_l_buf32[7] = 0;
14534 device_param->kernel_params_mp_l_buf32[8] = 0;
14535 device_param->kernel_params_mp_l_buf32[9] = 0;
14536
14537 device_param->kernel_params_mp_l[0] = NULL;
14538 device_param->kernel_params_mp_l[1] = NULL;
14539 device_param->kernel_params_mp_l[2] = NULL;
14540 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14541 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14542 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14543 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14544 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14545 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14546 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14547
14548 device_param->kernel_params_mp_r_buf64[3] = 0;
14549 device_param->kernel_params_mp_r_buf32[4] = 0;
14550 device_param->kernel_params_mp_r_buf32[5] = 0;
14551 device_param->kernel_params_mp_r_buf32[6] = 0;
14552 device_param->kernel_params_mp_r_buf32[7] = 0;
14553 device_param->kernel_params_mp_r_buf32[8] = 0;
14554
14555 device_param->kernel_params_mp_r[0] = NULL;
14556 device_param->kernel_params_mp_r[1] = NULL;
14557 device_param->kernel_params_mp_r[2] = NULL;
14558 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14559 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14560 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14561 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14562 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14563 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14564
14565 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14566 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14567
14568 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14569 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14570 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14571 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14572 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14573 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14574 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14575
14576 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14577 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14578
14579 /**
14580 * kernel name
14581 */
14582
14583 char kernel_name[64] = { 0 };
14584
14585 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14586 {
14587 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14588 {
14589 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14590
14591 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14592
14593 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14594
14595 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14596
14597 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14598
14599 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14600 }
14601 else
14602 {
14603 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14604
14605 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14606
14607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14608
14609 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14610
14611 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14612
14613 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14614 }
14615
14616 if (data.attack_mode == ATTACK_MODE_BF)
14617 {
14618 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14619 {
14620 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14621
14622 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14623 }
14624 }
14625 }
14626 else
14627 {
14628 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14629
14630 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14631
14632 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14633
14634 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14635
14636 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14637
14638 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14639
14640 if (opts_type & OPTS_TYPE_HOOK12)
14641 {
14642 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14643
14644 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14645 }
14646
14647 if (opts_type & OPTS_TYPE_HOOK23)
14648 {
14649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14650
14651 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14652 }
14653 }
14654
14655 for (uint i = 0; i <= 20; i++)
14656 {
14657 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14658 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14659 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14660
14661 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14662 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14663 }
14664
14665 for (uint i = 21; i <= 31; i++)
14666 {
14667 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14668 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14669 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14670
14671 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14672 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14673 }
14674
14675 if (attack_mode == ATTACK_MODE_BF)
14676 {
14677 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14678 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14679
14680 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14681 {
14682 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14683 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14684 }
14685 }
14686 else if (attack_mode == ATTACK_MODE_HYBRID1)
14687 {
14688 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14689 }
14690 else if (attack_mode == ATTACK_MODE_HYBRID2)
14691 {
14692 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14693 }
14694
14695 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14696 {
14697 // nothing to do
14698 }
14699 else
14700 {
14701 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14702 }
14703
14704 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14705 {
14706 // nothing to do
14707 }
14708 else
14709 {
14710 for (uint i = 0; i < 5; i++)
14711 {
14712 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14713 }
14714
14715 for (uint i = 5; i < 7; i++)
14716 {
14717 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14718 }
14719 }
14720
14721 /**
14722 * Store initial fanspeed if gpu_temp_retain is enabled
14723 */
14724
14725 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14726 int gpu_temp_retain_set = 0;
14727
14728 if (gpu_temp_disable == 0)
14729 {
14730 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14731 {
14732 hc_thread_mutex_lock (mux_adl);
14733
14734 if (data.hm_device[device_id].fan_supported == 1)
14735 {
14736 if (gpu_temp_retain_chgd == 0)
14737 {
14738 uint cur_temp = 0;
14739 uint default_temp = 0;
14740
14741 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);
14742
14743 if (ADL_rc == ADL_OK)
14744 {
14745 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14746
14747 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14748
14749 // special case with multi gpu setups: always use minimum retain
14750
14751 if (gpu_temp_retain_set == 0)
14752 {
14753 gpu_temp_retain = gpu_temp_retain_target;
14754 gpu_temp_retain_set = 1;
14755 }
14756 else
14757 {
14758 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14759 }
14760
14761 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14762 }
14763 }
14764
14765 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14766
14767 temp_retain_fanspeed_value[device_id] = fan_speed;
14768
14769 if (fan_speed == -1)
14770 {
14771 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14772
14773 temp_retain_fanspeed_value[device_id] = 0;
14774 }
14775 }
14776
14777 hc_thread_mutex_unlock (mux_adl);
14778 }
14779 }
14780
14781 /**
14782 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14783 */
14784
14785 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14786 {
14787 hc_thread_mutex_lock (mux_adl);
14788
14789 if (data.hm_device[device_id].od_version == 6)
14790 {
14791 int ADL_rc;
14792
14793 // check powertune capabilities first, if not available then skip device
14794
14795 int powertune_supported = 0;
14796
14797 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14798 {
14799 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14800
14801 return (-1);
14802 }
14803
14804 if (powertune_supported != 0)
14805 {
14806 // powercontrol settings
14807
14808 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14809
14810 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14811 {
14812 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14813 }
14814
14815 if (ADL_rc != ADL_OK)
14816 {
14817 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14818
14819 return (-1);
14820 }
14821
14822 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14823 {
14824 log_error ("ERROR: Failed to set new ADL PowerControl values");
14825
14826 return (-1);
14827 }
14828
14829 // clocks
14830
14831 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14832
14833 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14834
14835 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)
14836 {
14837 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14838
14839 return (-1);
14840 }
14841
14842 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14843
14844 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14845
14846 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14847 {
14848 log_error ("ERROR: Failed to get ADL device capabilities");
14849
14850 return (-1);
14851 }
14852
14853 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14854 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14855
14856 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14857 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14858
14859 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14860 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14861
14862 // warning if profile has too low max values
14863
14864 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14865 {
14866 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14867 }
14868
14869 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14870 {
14871 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14872 }
14873
14874 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14875
14876 performance_state->iNumberOfPerformanceLevels = 2;
14877
14878 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14879 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14880 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14881 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14882
14883 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)
14884 {
14885 log_info ("ERROR: Failed to set ADL performance state");
14886
14887 return (-1);
14888 }
14889
14890 local_free (performance_state);
14891 }
14892 }
14893
14894 hc_thread_mutex_unlock (mux_adl);
14895 }
14896 #endif // HAVE_HWMON && HAVE_ADL
14897 }
14898
14899 data.kernel_power_all = kernel_power_all;
14900
14901 if (data.quiet == 0) log_info ("");
14902
14903 /**
14904 * In benchmark-mode, inform user which algorithm is checked
14905 */
14906
14907 if (benchmark == 1)
14908 {
14909 quiet = 0;
14910
14911 data.quiet = quiet;
14912
14913 char *hash_type = strhashtype (data.hash_mode); // not a bug
14914
14915 log_info ("Hashtype: %s", hash_type);
14916 log_info ("");
14917 }
14918
14919 /**
14920 * keep track of the progress
14921 */
14922
14923 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14924 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14925 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14926
14927 /**
14928 * open filehandles
14929 */
14930
14931 #if _WIN
14932 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14933 {
14934 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14935
14936 return (-1);
14937 }
14938
14939 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14940 {
14941 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14942
14943 return (-1);
14944 }
14945
14946 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14947 {
14948 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14949
14950 return (-1);
14951 }
14952 #endif
14953
14954 /**
14955 * dictionary pad
14956 */
14957
14958 segment_size *= (1024 * 1024);
14959
14960 data.segment_size = segment_size;
14961
14962 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14963
14964 wl_data->buf = (char *) mymalloc (segment_size);
14965 wl_data->avail = segment_size;
14966 wl_data->incr = segment_size;
14967 wl_data->cnt = 0;
14968 wl_data->pos = 0;
14969
14970 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14971
14972 data.wordlist_mode = wordlist_mode;
14973
14974 cs_t *css_buf = NULL;
14975 uint css_cnt = 0;
14976 uint dictcnt = 0;
14977 uint maskcnt = 1;
14978 char **masks = NULL;
14979 char **dictfiles = NULL;
14980
14981 uint mask_from_file = 0;
14982
14983 if (attack_mode == ATTACK_MODE_STRAIGHT)
14984 {
14985 if (wordlist_mode == WL_MODE_FILE)
14986 {
14987 int wls_left = myargc - (optind + 1);
14988
14989 for (int i = 0; i < wls_left; i++)
14990 {
14991 char *l0_filename = myargv[optind + 1 + i];
14992
14993 struct stat l0_stat;
14994
14995 if (stat (l0_filename, &l0_stat) == -1)
14996 {
14997 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14998
14999 return (-1);
15000 }
15001
15002 uint is_dir = S_ISDIR (l0_stat.st_mode);
15003
15004 if (is_dir == 0)
15005 {
15006 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15007
15008 dictcnt++;
15009
15010 dictfiles[dictcnt - 1] = l0_filename;
15011 }
15012 else
15013 {
15014 // do not allow --keyspace w/ a directory
15015
15016 if (keyspace == 1)
15017 {
15018 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15019
15020 return (-1);
15021 }
15022
15023 char **dictionary_files = NULL;
15024
15025 dictionary_files = scan_directory (l0_filename);
15026
15027 if (dictionary_files != NULL)
15028 {
15029 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15030
15031 for (int d = 0; dictionary_files[d] != NULL; d++)
15032 {
15033 char *l1_filename = dictionary_files[d];
15034
15035 struct stat l1_stat;
15036
15037 if (stat (l1_filename, &l1_stat) == -1)
15038 {
15039 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15040
15041 return (-1);
15042 }
15043
15044 if (S_ISREG (l1_stat.st_mode))
15045 {
15046 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15047
15048 dictcnt++;
15049
15050 dictfiles[dictcnt - 1] = strdup (l1_filename);
15051 }
15052 }
15053 }
15054
15055 local_free (dictionary_files);
15056 }
15057 }
15058
15059 if (dictcnt < 1)
15060 {
15061 log_error ("ERROR: No usable dictionary file found.");
15062
15063 return (-1);
15064 }
15065 }
15066 else if (wordlist_mode == WL_MODE_STDIN)
15067 {
15068 dictcnt = 1;
15069 }
15070 }
15071 else if (attack_mode == ATTACK_MODE_COMBI)
15072 {
15073 // display
15074
15075 char *dictfile1 = myargv[optind + 1 + 0];
15076 char *dictfile2 = myargv[optind + 1 + 1];
15077
15078 // find the bigger dictionary and use as base
15079
15080 FILE *fp1 = NULL;
15081 FILE *fp2 = NULL;
15082
15083 struct stat tmp_stat;
15084
15085 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15086 {
15087 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15088
15089 return (-1);
15090 }
15091
15092 if (stat (dictfile1, &tmp_stat) == -1)
15093 {
15094 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15095
15096 fclose (fp1);
15097
15098 return (-1);
15099 }
15100
15101 if (S_ISDIR (tmp_stat.st_mode))
15102 {
15103 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15104
15105 fclose (fp1);
15106
15107 return (-1);
15108 }
15109
15110 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15111 {
15112 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15113
15114 fclose (fp1);
15115
15116 return (-1);
15117 }
15118
15119 if (stat (dictfile2, &tmp_stat) == -1)
15120 {
15121 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15122
15123 fclose (fp1);
15124 fclose (fp2);
15125
15126 return (-1);
15127 }
15128
15129 if (S_ISDIR (tmp_stat.st_mode))
15130 {
15131 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15132
15133 fclose (fp1);
15134 fclose (fp2);
15135
15136 return (-1);
15137 }
15138
15139 data.combs_cnt = 1;
15140
15141 data.quiet = 1;
15142
15143 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15144
15145 data.quiet = quiet;
15146
15147 if (words1_cnt == 0)
15148 {
15149 log_error ("ERROR: %s: empty file", dictfile1);
15150
15151 fclose (fp1);
15152 fclose (fp2);
15153
15154 return (-1);
15155 }
15156
15157 data.combs_cnt = 1;
15158
15159 data.quiet = 1;
15160
15161 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15162
15163 data.quiet = quiet;
15164
15165 if (words2_cnt == 0)
15166 {
15167 log_error ("ERROR: %s: empty file", dictfile2);
15168
15169 fclose (fp1);
15170 fclose (fp2);
15171
15172 return (-1);
15173 }
15174
15175 fclose (fp1);
15176 fclose (fp2);
15177
15178 data.dictfile = dictfile1;
15179 data.dictfile2 = dictfile2;
15180
15181 if (words1_cnt >= words2_cnt)
15182 {
15183 data.combs_cnt = words2_cnt;
15184 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15185
15186 dictfiles = &data.dictfile;
15187
15188 dictcnt = 1;
15189 }
15190 else
15191 {
15192 data.combs_cnt = words1_cnt;
15193 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15194
15195 dictfiles = &data.dictfile2;
15196
15197 dictcnt = 1;
15198
15199 // we also have to switch wordlist related rules!
15200
15201 char *tmpc = data.rule_buf_l;
15202
15203 data.rule_buf_l = data.rule_buf_r;
15204 data.rule_buf_r = tmpc;
15205
15206 int tmpi = data.rule_len_l;
15207
15208 data.rule_len_l = data.rule_len_r;
15209 data.rule_len_r = tmpi;
15210 }
15211 }
15212 else if (attack_mode == ATTACK_MODE_BF)
15213 {
15214 char *mask = NULL;
15215
15216 maskcnt = 0;
15217
15218 if (benchmark == 0)
15219 {
15220 mask = myargv[optind + 1];
15221
15222 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15223
15224 if ((optind + 2) <= myargc)
15225 {
15226 struct stat file_stat;
15227
15228 if (stat (mask, &file_stat) == -1)
15229 {
15230 maskcnt = 1;
15231
15232 masks[maskcnt - 1] = mystrdup (mask);
15233 }
15234 else
15235 {
15236 int wls_left = myargc - (optind + 1);
15237
15238 uint masks_avail = INCR_MASKS;
15239
15240 for (int i = 0; i < wls_left; i++)
15241 {
15242 if (i != 0)
15243 {
15244 mask = myargv[optind + 1 + i];
15245
15246 if (stat (mask, &file_stat) == -1)
15247 {
15248 log_error ("ERROR: %s: %s", mask, strerror (errno));
15249
15250 return (-1);
15251 }
15252 }
15253
15254 uint is_file = S_ISREG (file_stat.st_mode);
15255
15256 if (is_file == 1)
15257 {
15258 FILE *mask_fp;
15259
15260 if ((mask_fp = fopen (mask, "r")) == NULL)
15261 {
15262 log_error ("ERROR: %s: %s", mask, strerror (errno));
15263
15264 return (-1);
15265 }
15266
15267 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15268
15269 while (!feof (mask_fp))
15270 {
15271 memset (line_buf, 0, HCBUFSIZ);
15272
15273 int line_len = fgetl (mask_fp, line_buf);
15274
15275 if (line_len == 0) continue;
15276
15277 if (line_buf[0] == '#') continue;
15278
15279 if (masks_avail == maskcnt)
15280 {
15281 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15282
15283 masks_avail += INCR_MASKS;
15284 }
15285
15286 masks[maskcnt] = mystrdup (line_buf);
15287
15288 maskcnt++;
15289 }
15290
15291 myfree (line_buf);
15292
15293 fclose (mask_fp);
15294 }
15295 else
15296 {
15297 log_error ("ERROR: %s: unsupported file-type", mask);
15298
15299 return (-1);
15300 }
15301 }
15302
15303 mask_from_file = 1;
15304 }
15305 }
15306 else
15307 {
15308 custom_charset_1 = (char *) "?l?d?u";
15309 custom_charset_2 = (char *) "?l?d";
15310 custom_charset_3 = (char *) "?l?d*!$@_";
15311
15312 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15313 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15314 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15315
15316 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15317
15318 wordlist_mode = WL_MODE_MASK;
15319
15320 data.wordlist_mode = wordlist_mode;
15321
15322 increment = 1;
15323
15324 maskcnt = 1;
15325 }
15326 }
15327 else
15328 {
15329 /**
15330 * generate full masks and charsets
15331 */
15332
15333 masks = (char **) mymalloc (sizeof (char *));
15334
15335 switch (hash_mode)
15336 {
15337 case 1731: pw_min = 5;
15338 pw_max = 5;
15339 mask = mystrdup ("?b?b?b?b?b");
15340 break;
15341 case 12500: pw_min = 5;
15342 pw_max = 5;
15343 mask = mystrdup ("?b?b?b?b?b");
15344 break;
15345 default: pw_min = 7;
15346 pw_max = 7;
15347 mask = mystrdup ("?b?b?b?b?b?b?b");
15348 break;
15349 }
15350
15351 maskcnt = 1;
15352
15353 masks[maskcnt - 1] = mystrdup (mask);
15354
15355 wordlist_mode = WL_MODE_MASK;
15356
15357 data.wordlist_mode = wordlist_mode;
15358
15359 increment = 1;
15360 }
15361
15362 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15363
15364 if (increment)
15365 {
15366 if (increment_min > pw_min) pw_min = increment_min;
15367
15368 if (increment_max < pw_max) pw_max = increment_max;
15369 }
15370 }
15371 else if (attack_mode == ATTACK_MODE_HYBRID1)
15372 {
15373 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15374
15375 // display
15376
15377 char *mask = myargv[myargc - 1];
15378
15379 maskcnt = 0;
15380
15381 masks = (char **) mymalloc (1 * sizeof (char *));
15382
15383 // mod
15384
15385 struct stat file_stat;
15386
15387 if (stat (mask, &file_stat) == -1)
15388 {
15389 maskcnt = 1;
15390
15391 masks[maskcnt - 1] = mystrdup (mask);
15392 }
15393 else
15394 {
15395 uint is_file = S_ISREG (file_stat.st_mode);
15396
15397 if (is_file == 1)
15398 {
15399 FILE *mask_fp;
15400
15401 if ((mask_fp = fopen (mask, "r")) == NULL)
15402 {
15403 log_error ("ERROR: %s: %s", mask, strerror (errno));
15404
15405 return (-1);
15406 }
15407
15408 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15409
15410 uint masks_avail = 1;
15411
15412 while (!feof (mask_fp))
15413 {
15414 memset (line_buf, 0, HCBUFSIZ);
15415
15416 int line_len = fgetl (mask_fp, line_buf);
15417
15418 if (line_len == 0) continue;
15419
15420 if (line_buf[0] == '#') continue;
15421
15422 if (masks_avail == maskcnt)
15423 {
15424 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15425
15426 masks_avail += INCR_MASKS;
15427 }
15428
15429 masks[maskcnt] = mystrdup (line_buf);
15430
15431 maskcnt++;
15432 }
15433
15434 myfree (line_buf);
15435
15436 fclose (mask_fp);
15437
15438 mask_from_file = 1;
15439 }
15440 else
15441 {
15442 maskcnt = 1;
15443
15444 masks[maskcnt - 1] = mystrdup (mask);
15445 }
15446 }
15447
15448 // base
15449
15450 int wls_left = myargc - (optind + 2);
15451
15452 for (int i = 0; i < wls_left; i++)
15453 {
15454 char *filename = myargv[optind + 1 + i];
15455
15456 struct stat file_stat;
15457
15458 if (stat (filename, &file_stat) == -1)
15459 {
15460 log_error ("ERROR: %s: %s", filename, strerror (errno));
15461
15462 return (-1);
15463 }
15464
15465 uint is_dir = S_ISDIR (file_stat.st_mode);
15466
15467 if (is_dir == 0)
15468 {
15469 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15470
15471 dictcnt++;
15472
15473 dictfiles[dictcnt - 1] = filename;
15474 }
15475 else
15476 {
15477 // do not allow --keyspace w/ a directory
15478
15479 if (keyspace == 1)
15480 {
15481 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15482
15483 return (-1);
15484 }
15485
15486 char **dictionary_files = NULL;
15487
15488 dictionary_files = scan_directory (filename);
15489
15490 if (dictionary_files != NULL)
15491 {
15492 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15493
15494 for (int d = 0; dictionary_files[d] != NULL; d++)
15495 {
15496 char *l1_filename = dictionary_files[d];
15497
15498 struct stat l1_stat;
15499
15500 if (stat (l1_filename, &l1_stat) == -1)
15501 {
15502 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15503
15504 return (-1);
15505 }
15506
15507 if (S_ISREG (l1_stat.st_mode))
15508 {
15509 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15510
15511 dictcnt++;
15512
15513 dictfiles[dictcnt - 1] = strdup (l1_filename);
15514 }
15515 }
15516 }
15517
15518 local_free (dictionary_files);
15519 }
15520 }
15521
15522 if (dictcnt < 1)
15523 {
15524 log_error ("ERROR: No usable dictionary file found.");
15525
15526 return (-1);
15527 }
15528
15529 if (increment)
15530 {
15531 maskcnt = 0;
15532
15533 uint mask_min = increment_min; // we can't reject smaller masks here
15534 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15535
15536 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15537 {
15538 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15539
15540 if (cur_mask == NULL) break;
15541
15542 masks[maskcnt] = cur_mask;
15543
15544 maskcnt++;
15545
15546 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15547 }
15548 }
15549 }
15550 else if (attack_mode == ATTACK_MODE_HYBRID2)
15551 {
15552 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15553
15554 // display
15555
15556 char *mask = myargv[optind + 1 + 0];
15557
15558 maskcnt = 0;
15559
15560 masks = (char **) mymalloc (1 * sizeof (char *));
15561
15562 // mod
15563
15564 struct stat file_stat;
15565
15566 if (stat (mask, &file_stat) == -1)
15567 {
15568 maskcnt = 1;
15569
15570 masks[maskcnt - 1] = mystrdup (mask);
15571 }
15572 else
15573 {
15574 uint is_file = S_ISREG (file_stat.st_mode);
15575
15576 if (is_file == 1)
15577 {
15578 FILE *mask_fp;
15579
15580 if ((mask_fp = fopen (mask, "r")) == NULL)
15581 {
15582 log_error ("ERROR: %s: %s", mask, strerror (errno));
15583
15584 return (-1);
15585 }
15586
15587 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15588
15589 uint masks_avail = 1;
15590
15591 while (!feof (mask_fp))
15592 {
15593 memset (line_buf, 0, HCBUFSIZ);
15594
15595 int line_len = fgetl (mask_fp, line_buf);
15596
15597 if (line_len == 0) continue;
15598
15599 if (line_buf[0] == '#') continue;
15600
15601 if (masks_avail == maskcnt)
15602 {
15603 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15604
15605 masks_avail += INCR_MASKS;
15606 }
15607
15608 masks[maskcnt] = mystrdup (line_buf);
15609
15610 maskcnt++;
15611 }
15612
15613 myfree (line_buf);
15614
15615 fclose (mask_fp);
15616
15617 mask_from_file = 1;
15618 }
15619 else
15620 {
15621 maskcnt = 1;
15622
15623 masks[maskcnt - 1] = mystrdup (mask);
15624 }
15625 }
15626
15627 // base
15628
15629 int wls_left = myargc - (optind + 2);
15630
15631 for (int i = 0; i < wls_left; i++)
15632 {
15633 char *filename = myargv[optind + 2 + i];
15634
15635 struct stat file_stat;
15636
15637 if (stat (filename, &file_stat) == -1)
15638 {
15639 log_error ("ERROR: %s: %s", filename, strerror (errno));
15640
15641 return (-1);
15642 }
15643
15644 uint is_dir = S_ISDIR (file_stat.st_mode);
15645
15646 if (is_dir == 0)
15647 {
15648 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15649
15650 dictcnt++;
15651
15652 dictfiles[dictcnt - 1] = filename;
15653 }
15654 else
15655 {
15656 // do not allow --keyspace w/ a directory
15657
15658 if (keyspace == 1)
15659 {
15660 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15661
15662 return (-1);
15663 }
15664
15665 char **dictionary_files = NULL;
15666
15667 dictionary_files = scan_directory (filename);
15668
15669 if (dictionary_files != NULL)
15670 {
15671 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15672
15673 for (int d = 0; dictionary_files[d] != NULL; d++)
15674 {
15675 char *l1_filename = dictionary_files[d];
15676
15677 struct stat l1_stat;
15678
15679 if (stat (l1_filename, &l1_stat) == -1)
15680 {
15681 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15682
15683 return (-1);
15684 }
15685
15686 if (S_ISREG (l1_stat.st_mode))
15687 {
15688 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15689
15690 dictcnt++;
15691
15692 dictfiles[dictcnt - 1] = strdup (l1_filename);
15693 }
15694 }
15695 }
15696
15697 local_free (dictionary_files);
15698 }
15699 }
15700
15701 if (dictcnt < 1)
15702 {
15703 log_error ("ERROR: No usable dictionary file found.");
15704
15705 return (-1);
15706 }
15707
15708 if (increment)
15709 {
15710 maskcnt = 0;
15711
15712 uint mask_min = increment_min; // we can't reject smaller masks here
15713 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15714
15715 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15716 {
15717 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15718
15719 if (cur_mask == NULL) break;
15720
15721 masks[maskcnt] = cur_mask;
15722
15723 maskcnt++;
15724
15725 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15726 }
15727 }
15728 }
15729
15730 data.pw_min = pw_min;
15731 data.pw_max = pw_max;
15732
15733 /**
15734 * weak hash check
15735 */
15736
15737 if (weak_hash_threshold >= salts_cnt)
15738 {
15739 hc_device_param_t *device_param = NULL;
15740
15741 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15742 {
15743 device_param = &data.devices_param[device_id];
15744
15745 if (device_param->skipped) continue;
15746
15747 break;
15748 }
15749
15750 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15751
15752 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15753 {
15754 weak_hash_check (device_param, salt_pos);
15755 }
15756 }
15757
15758 // Display hack, guarantee that there is at least one \r before real start
15759
15760 if (data.quiet == 0) log_info_nn ("");
15761
15762 /**
15763 * status and monitor threads
15764 */
15765
15766 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15767
15768 hc_thread_t i_thread = 0;
15769
15770 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15771 {
15772 hc_thread_create (i_thread, thread_keypress, &benchmark);
15773 }
15774
15775 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15776
15777 uint ni_threads_cnt = 0;
15778
15779 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15780
15781 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15782
15783 ni_threads_cnt++;
15784
15785 /**
15786 * Outfile remove
15787 */
15788
15789 if (keyspace == 0)
15790 {
15791 if (outfile_check_timer != 0)
15792 {
15793 if (data.outfile_check_directory != NULL)
15794 {
15795 if ((hash_mode != 5200) &&
15796 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15797 (hash_mode != 9000))
15798 {
15799 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15800
15801 ni_threads_cnt++;
15802 }
15803 else
15804 {
15805 outfile_check_timer = 0;
15806 }
15807 }
15808 else
15809 {
15810 outfile_check_timer = 0;
15811 }
15812 }
15813 }
15814
15815 /**
15816 * Inform the user if we got some hashes remove because of the pot file remove feature
15817 */
15818
15819 if (data.quiet == 0)
15820 {
15821 if (potfile_remove_cracks > 0)
15822 {
15823 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15824 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15825 }
15826 }
15827
15828 data.outfile_check_timer = outfile_check_timer;
15829
15830 /**
15831 * main loop
15832 */
15833
15834 char **induction_dictionaries = NULL;
15835
15836 int induction_dictionaries_cnt = 0;
15837
15838 hcstat_table_t *root_table_buf = NULL;
15839 hcstat_table_t *markov_table_buf = NULL;
15840
15841 uint initial_restore_done = 0;
15842
15843 data.maskcnt = maskcnt;
15844
15845 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15846 {
15847 if (data.devices_status == STATUS_CRACKED) break;
15848
15849 data.devices_status = STATUS_INIT;
15850
15851 if (maskpos > rd->maskpos)
15852 {
15853 rd->dictpos = 0;
15854 }
15855
15856 rd->maskpos = maskpos;
15857 data.maskpos = maskpos;
15858
15859 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15860 {
15861 char *mask = masks[maskpos];
15862
15863 if (mask_from_file == 1)
15864 {
15865 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15866
15867 char *str_ptr;
15868 uint str_pos;
15869
15870 uint mask_offset = 0;
15871
15872 uint separator_cnt;
15873
15874 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15875 {
15876 str_ptr = strstr (mask + mask_offset, ",");
15877
15878 if (str_ptr == NULL) break;
15879
15880 str_pos = str_ptr - mask;
15881
15882 // escaped separator, i.e. "\,"
15883
15884 if (str_pos > 0)
15885 {
15886 if (mask[str_pos - 1] == '\\')
15887 {
15888 separator_cnt --;
15889
15890 mask_offset = str_pos + 1;
15891
15892 continue;
15893 }
15894 }
15895
15896 // reset the offset
15897
15898 mask_offset = 0;
15899
15900 mask[str_pos] = '\0';
15901
15902 switch (separator_cnt)
15903 {
15904 case 0:
15905 mp_reset_usr (mp_usr, 0);
15906
15907 custom_charset_1 = mask;
15908 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15909 break;
15910
15911 case 1:
15912 mp_reset_usr (mp_usr, 1);
15913
15914 custom_charset_2 = mask;
15915 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15916 break;
15917
15918 case 2:
15919 mp_reset_usr (mp_usr, 2);
15920
15921 custom_charset_3 = mask;
15922 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15923 break;
15924
15925 case 3:
15926 mp_reset_usr (mp_usr, 3);
15927
15928 custom_charset_4 = mask;
15929 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15930 break;
15931 }
15932
15933 mask = mask + str_pos + 1;
15934 }
15935 }
15936
15937 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15938 {
15939 if (maskpos > 0)
15940 {
15941 local_free (css_buf);
15942 local_free (data.root_css_buf);
15943 local_free (data.markov_css_buf);
15944
15945 local_free (masks[maskpos - 1]);
15946 }
15947
15948 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15949
15950 data.mask = mask;
15951 data.css_cnt = css_cnt;
15952 data.css_buf = css_buf;
15953
15954 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15955
15956 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15957
15958 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15959 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15960
15961 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15962
15963 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15964
15965 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15966 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15967
15968 data.root_css_buf = root_css_buf;
15969 data.markov_css_buf = markov_css_buf;
15970
15971 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15972
15973 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15974
15975 local_free (root_table_buf);
15976 local_free (markov_table_buf);
15977
15978 // args
15979
15980 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15981 {
15982 hc_device_param_t *device_param = &data.devices_param[device_id];
15983
15984 if (device_param->skipped) continue;
15985
15986 device_param->kernel_params_mp[0] = &device_param->d_combs;
15987 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15988 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15989
15990 device_param->kernel_params_mp_buf64[3] = 0;
15991 device_param->kernel_params_mp_buf32[4] = css_cnt;
15992 device_param->kernel_params_mp_buf32[5] = 0;
15993 device_param->kernel_params_mp_buf32[6] = 0;
15994 device_param->kernel_params_mp_buf32[7] = 0;
15995
15996 if (attack_mode == ATTACK_MODE_HYBRID1)
15997 {
15998 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15999 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16000 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16001 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16002 }
16003 else if (attack_mode == ATTACK_MODE_HYBRID2)
16004 {
16005 device_param->kernel_params_mp_buf32[5] = 0;
16006 device_param->kernel_params_mp_buf32[6] = 0;
16007 device_param->kernel_params_mp_buf32[7] = 0;
16008 }
16009
16010 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]);
16011 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]);
16012 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]);
16013
16014 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);
16015 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);
16016 }
16017 }
16018 else if (attack_mode == ATTACK_MODE_BF)
16019 {
16020 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16021
16022 if (increment)
16023 {
16024 for (uint i = 0; i < dictcnt; i++)
16025 {
16026 local_free (dictfiles[i]);
16027 }
16028
16029 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16030 {
16031 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16032
16033 if (l1_filename == NULL) break;
16034
16035 dictcnt++;
16036
16037 dictfiles[dictcnt - 1] = l1_filename;
16038 }
16039 }
16040 else
16041 {
16042 dictcnt++;
16043
16044 dictfiles[dictcnt - 1] = mask;
16045 }
16046
16047 if (dictcnt == 0)
16048 {
16049 log_error ("ERROR: Mask is too small");
16050
16051 return (-1);
16052 }
16053 }
16054 }
16055
16056 free (induction_dictionaries);
16057
16058 // induction_dictionaries_cnt = 0; // implied
16059
16060 if (attack_mode != ATTACK_MODE_BF)
16061 {
16062 if (keyspace == 0)
16063 {
16064 induction_dictionaries = scan_directory (induction_directory);
16065
16066 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16067 }
16068 }
16069
16070 if (induction_dictionaries_cnt)
16071 {
16072 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16073 }
16074
16075 /**
16076 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16077 */
16078 if (keyspace == 1)
16079 {
16080 if ((maskcnt > 1) || (dictcnt > 1))
16081 {
16082 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16083
16084 return (-1);
16085 }
16086 }
16087
16088 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16089 {
16090 char *subid = logfile_generate_subid ();
16091
16092 data.subid = subid;
16093
16094 logfile_sub_msg ("START");
16095
16096 data.devices_status = STATUS_INIT;
16097
16098 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16099 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16100 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16101
16102 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16103
16104 data.cpt_pos = 0;
16105
16106 data.cpt_start = time (NULL);
16107
16108 data.cpt_total = 0;
16109
16110 if (data.restore == 0)
16111 {
16112 rd->words_cur = skip;
16113
16114 skip = 0;
16115
16116 data.skip = 0;
16117 }
16118
16119 data.ms_paused = 0;
16120
16121 data.words_cur = rd->words_cur;
16122
16123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16124 {
16125 hc_device_param_t *device_param = &data.devices_param[device_id];
16126
16127 if (device_param->skipped) continue;
16128
16129 device_param->speed_pos = 0;
16130
16131 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16132 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16133
16134 device_param->exec_pos = 0;
16135
16136 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16137
16138 device_param->kernel_power = device_param->kernel_power_user;
16139
16140 device_param->outerloop_pos = 0;
16141 device_param->outerloop_left = 0;
16142 device_param->innerloop_pos = 0;
16143 device_param->innerloop_left = 0;
16144
16145 // some more resets:
16146
16147 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16148
16149 device_param->pws_cnt = 0;
16150
16151 device_param->words_off = 0;
16152 device_param->words_done = 0;
16153 }
16154
16155 data.kernel_power_div = 0;
16156
16157 // figure out some workload
16158
16159 if (attack_mode == ATTACK_MODE_STRAIGHT)
16160 {
16161 if (data.wordlist_mode == WL_MODE_FILE)
16162 {
16163 char *dictfile = NULL;
16164
16165 if (induction_dictionaries_cnt)
16166 {
16167 dictfile = induction_dictionaries[0];
16168 }
16169 else
16170 {
16171 dictfile = dictfiles[dictpos];
16172 }
16173
16174 data.dictfile = dictfile;
16175
16176 logfile_sub_string (dictfile);
16177
16178 for (uint i = 0; i < rp_files_cnt; i++)
16179 {
16180 logfile_sub_var_string ("rulefile", rp_files[i]);
16181 }
16182
16183 FILE *fd2 = fopen (dictfile, "rb");
16184
16185 if (fd2 == NULL)
16186 {
16187 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16188
16189 return (-1);
16190 }
16191
16192 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16193
16194 fclose (fd2);
16195
16196 if (data.words_cnt == 0)
16197 {
16198 if (data.devices_status == STATUS_CRACKED) break;
16199 if (data.devices_status == STATUS_ABORTED) break;
16200
16201 dictpos++;
16202
16203 continue;
16204 }
16205 }
16206 }
16207 else if (attack_mode == ATTACK_MODE_COMBI)
16208 {
16209 char *dictfile = data.dictfile;
16210 char *dictfile2 = data.dictfile2;
16211
16212 logfile_sub_string (dictfile);
16213 logfile_sub_string (dictfile2);
16214
16215 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16216 {
16217 FILE *fd2 = fopen (dictfile, "rb");
16218
16219 if (fd2 == NULL)
16220 {
16221 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16222
16223 return (-1);
16224 }
16225
16226 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16227
16228 fclose (fd2);
16229 }
16230 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16231 {
16232 FILE *fd2 = fopen (dictfile2, "rb");
16233
16234 if (fd2 == NULL)
16235 {
16236 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16237
16238 return (-1);
16239 }
16240
16241 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16242
16243 fclose (fd2);
16244 }
16245
16246 if (data.words_cnt == 0)
16247 {
16248 if (data.devices_status == STATUS_CRACKED) break;
16249 if (data.devices_status == STATUS_ABORTED) break;
16250
16251 dictpos++;
16252
16253 continue;
16254 }
16255 }
16256 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16257 {
16258 char *dictfile = NULL;
16259
16260 if (induction_dictionaries_cnt)
16261 {
16262 dictfile = induction_dictionaries[0];
16263 }
16264 else
16265 {
16266 dictfile = dictfiles[dictpos];
16267 }
16268
16269 data.dictfile = dictfile;
16270
16271 char *mask = data.mask;
16272
16273 logfile_sub_string (dictfile);
16274 logfile_sub_string (mask);
16275
16276 FILE *fd2 = fopen (dictfile, "rb");
16277
16278 if (fd2 == NULL)
16279 {
16280 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16281
16282 return (-1);
16283 }
16284
16285 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16286
16287 fclose (fd2);
16288
16289 if (data.words_cnt == 0)
16290 {
16291 if (data.devices_status == STATUS_CRACKED) break;
16292 if (data.devices_status == STATUS_ABORTED) break;
16293
16294 dictpos++;
16295
16296 continue;
16297 }
16298 }
16299 else if (attack_mode == ATTACK_MODE_BF)
16300 {
16301 local_free (css_buf);
16302 local_free (data.root_css_buf);
16303 local_free (data.markov_css_buf);
16304
16305 char *mask = dictfiles[dictpos];
16306
16307 logfile_sub_string (mask);
16308
16309 // base
16310
16311 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16312
16313 if (opts_type & OPTS_TYPE_PT_UNICODE)
16314 {
16315 uint css_cnt_unicode = css_cnt * 2;
16316
16317 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16318
16319 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16320 {
16321 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16322
16323 css_buf_unicode[j + 1].cs_buf[0] = 0;
16324 css_buf_unicode[j + 1].cs_len = 1;
16325 }
16326
16327 free (css_buf);
16328
16329 css_buf = css_buf_unicode;
16330 css_cnt = css_cnt_unicode;
16331 }
16332
16333 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16334
16335 uint mask_min = pw_min;
16336 uint mask_max = pw_max;
16337
16338 if (opts_type & OPTS_TYPE_PT_UNICODE)
16339 {
16340 mask_min *= 2;
16341 mask_max *= 2;
16342 }
16343
16344 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16345 {
16346 if (css_cnt < mask_min)
16347 {
16348 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16349 }
16350
16351 if (css_cnt > mask_max)
16352 {
16353 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16354 }
16355
16356 // skip to next mask
16357
16358 dictpos++;
16359
16360 rd->dictpos = dictpos;
16361
16362 logfile_sub_msg ("STOP");
16363
16364 continue;
16365 }
16366
16367 uint save_css_cnt = css_cnt;
16368
16369 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16370 {
16371 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16372 {
16373 uint salt_len = (uint) data.salts_buf[0].salt_len;
16374 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16375
16376 uint css_cnt_salt = css_cnt + salt_len;
16377
16378 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16379
16380 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16381
16382 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16383 {
16384 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16385 css_buf_salt[j].cs_len = 1;
16386 }
16387
16388 free (css_buf);
16389
16390 css_buf = css_buf_salt;
16391 css_cnt = css_cnt_salt;
16392 }
16393 }
16394
16395 data.mask = mask;
16396 data.css_cnt = css_cnt;
16397 data.css_buf = css_buf;
16398
16399 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16400
16401 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16402
16403 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16404
16405 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16406 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16407
16408 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16409
16410 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16411
16412 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16413 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16414
16415 data.root_css_buf = root_css_buf;
16416 data.markov_css_buf = markov_css_buf;
16417
16418 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16419
16420 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16421
16422 local_free (root_table_buf);
16423 local_free (markov_table_buf);
16424
16425 // copy + args
16426
16427 uint css_cnt_l = css_cnt;
16428 uint css_cnt_r;
16429
16430 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16431 {
16432 if (save_css_cnt < 6)
16433 {
16434 css_cnt_r = 1;
16435 }
16436 else if (save_css_cnt == 6)
16437 {
16438 css_cnt_r = 2;
16439 }
16440 else
16441 {
16442 if (opts_type & OPTS_TYPE_PT_UNICODE)
16443 {
16444 if (save_css_cnt == 8 || save_css_cnt == 10)
16445 {
16446 css_cnt_r = 2;
16447 }
16448 else
16449 {
16450 css_cnt_r = 4;
16451 }
16452 }
16453 else
16454 {
16455 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16456 {
16457 css_cnt_r = 3;
16458 }
16459 else
16460 {
16461 css_cnt_r = 4;
16462 }
16463 }
16464 }
16465 }
16466 else
16467 {
16468 css_cnt_r = 1;
16469
16470 /* unfinished code?
16471 int sum = css_buf[css_cnt_r - 1].cs_len;
16472
16473 for (uint i = 1; i < 4 && i < css_cnt; i++)
16474 {
16475 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16476
16477 css_cnt_r++;
16478
16479 sum *= css_buf[css_cnt_r - 1].cs_len;
16480 }
16481 */
16482 }
16483
16484 css_cnt_l -= css_cnt_r;
16485
16486 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16487
16488 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16489 {
16490 hc_device_param_t *device_param = &data.devices_param[device_id];
16491
16492 if (device_param->skipped) continue;
16493
16494 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16495 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16496 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16497
16498 device_param->kernel_params_mp_l_buf64[3] = 0;
16499 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16500 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16501 device_param->kernel_params_mp_l_buf32[6] = 0;
16502 device_param->kernel_params_mp_l_buf32[7] = 0;
16503 device_param->kernel_params_mp_l_buf32[8] = 0;
16504
16505 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16506 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16507 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16508 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16509
16510 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16511 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16512 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16513
16514 device_param->kernel_params_mp_r_buf64[3] = 0;
16515 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16516 device_param->kernel_params_mp_r_buf32[5] = 0;
16517 device_param->kernel_params_mp_r_buf32[6] = 0;
16518 device_param->kernel_params_mp_r_buf32[7] = 0;
16519
16520 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]);
16521 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]);
16522 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]);
16523
16524 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]);
16525 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]);
16526 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]);
16527
16528 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);
16529 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);
16530 }
16531 }
16532
16533 u64 words_base = data.words_cnt;
16534
16535 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16536 {
16537 if (data.kernel_rules_cnt)
16538 {
16539 words_base /= data.kernel_rules_cnt;
16540 }
16541 }
16542 else if (data.attack_kern == ATTACK_KERN_COMBI)
16543 {
16544 if (data.combs_cnt)
16545 {
16546 words_base /= data.combs_cnt;
16547 }
16548 }
16549 else if (data.attack_kern == ATTACK_KERN_BF)
16550 {
16551 if (data.bfs_cnt)
16552 {
16553 words_base /= data.bfs_cnt;
16554 }
16555 }
16556
16557 data.words_base = words_base;
16558
16559 if (keyspace == 1)
16560 {
16561 log_info ("%llu", (unsigned long long int) words_base);
16562
16563 return (0);
16564 }
16565
16566 if (data.words_cur > data.words_base)
16567 {
16568 log_error ("ERROR: restore value greater keyspace");
16569
16570 return (-1);
16571 }
16572
16573 if (data.words_cur)
16574 {
16575 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16576 {
16577 for (uint i = 0; i < data.salts_cnt; i++)
16578 {
16579 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16580 }
16581 }
16582 else if (data.attack_kern == ATTACK_KERN_COMBI)
16583 {
16584 for (uint i = 0; i < data.salts_cnt; i++)
16585 {
16586 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16587 }
16588 }
16589 else if (data.attack_kern == ATTACK_KERN_BF)
16590 {
16591 for (uint i = 0; i < data.salts_cnt; i++)
16592 {
16593 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16594 }
16595 }
16596 }
16597
16598 /*
16599 * Inform user about possible slow speeds
16600 */
16601
16602 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16603 {
16604 if (data.words_base < kernel_power_all)
16605 {
16606 if (quiet == 0)
16607 {
16608 log_info ("");
16609 log_info ("ATTENTION!");
16610 log_info (" The wordlist or mask you are using is too small.");
16611 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16612 log_info (" The cracking speed will drop.");
16613 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16614 log_info ("");
16615 }
16616 }
16617 }
16618
16619 /*
16620 * Update loopback file
16621 */
16622
16623 if (loopback == 1)
16624 {
16625 time_t now;
16626
16627 time (&now);
16628
16629 uint random_num = get_random_num (0, 9999);
16630
16631 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16632
16633 data.loopback_file = loopback_file;
16634 }
16635
16636 /*
16637 * Update dictionary statistic
16638 */
16639
16640 if (keyspace == 0)
16641 {
16642 dictstat_fp = fopen (dictstat, "wb");
16643
16644 if (dictstat_fp)
16645 {
16646 lock_file (dictstat_fp);
16647
16648 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16649
16650 fclose (dictstat_fp);
16651 }
16652 }
16653
16654 data.devices_status = STATUS_RUNNING;
16655
16656 if (initial_restore_done == 0)
16657 {
16658 if (data.restore_disable == 0) cycle_restore ();
16659
16660 initial_restore_done = 1;
16661 }
16662
16663 hc_timer_set (&data.timer_running);
16664
16665 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16666 {
16667 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16668 {
16669 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16670 if (quiet == 0) fflush (stdout);
16671 }
16672 }
16673 else if (wordlist_mode == WL_MODE_STDIN)
16674 {
16675 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16676 if (data.quiet == 0) log_info ("");
16677 }
16678
16679 time_t runtime_start;
16680
16681 time (&runtime_start);
16682
16683 data.runtime_start = runtime_start;
16684
16685 /**
16686 * create cracker threads
16687 */
16688
16689 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16690
16691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16692 {
16693 hc_device_param_t *device_param = &devices_param[device_id];
16694
16695 if (wordlist_mode == WL_MODE_STDIN)
16696 {
16697 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16698 }
16699 else
16700 {
16701 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16702 }
16703 }
16704
16705 // wait for crack threads to exit
16706
16707 hc_thread_wait (data.devices_cnt, c_threads);
16708
16709 local_free (c_threads);
16710
16711 data.restore = 0;
16712
16713 // finalize task
16714
16715 logfile_sub_var_uint ("status-after-work", data.devices_status);
16716
16717 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16718
16719 if (data.devices_status == STATUS_CRACKED) break;
16720 if (data.devices_status == STATUS_ABORTED) break;
16721
16722 if (data.devices_status == STATUS_BYPASS)
16723 {
16724 data.devices_status = STATUS_RUNNING;
16725 }
16726
16727 if (induction_dictionaries_cnt)
16728 {
16729 unlink (induction_dictionaries[0]);
16730 }
16731
16732 free (induction_dictionaries);
16733
16734 if (attack_mode != ATTACK_MODE_BF)
16735 {
16736 induction_dictionaries = scan_directory (induction_directory);
16737
16738 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16739 }
16740
16741 if (benchmark == 0)
16742 {
16743 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16744 {
16745 if (quiet == 0) clear_prompt ();
16746
16747 if (quiet == 0) log_info ("");
16748
16749 if (status == 1)
16750 {
16751 status_display ();
16752 }
16753 else
16754 {
16755 if (quiet == 0) status_display ();
16756 }
16757
16758 if (quiet == 0) log_info ("");
16759 }
16760 }
16761
16762 if (attack_mode == ATTACK_MODE_BF)
16763 {
16764 dictpos++;
16765
16766 rd->dictpos = dictpos;
16767 }
16768 else
16769 {
16770 if (induction_dictionaries_cnt)
16771 {
16772 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16773 }
16774 else
16775 {
16776 dictpos++;
16777
16778 rd->dictpos = dictpos;
16779 }
16780 }
16781
16782 time_t runtime_stop;
16783
16784 time (&runtime_stop);
16785
16786 data.runtime_stop = runtime_stop;
16787
16788 logfile_sub_uint (runtime_start);
16789 logfile_sub_uint (runtime_stop);
16790
16791 logfile_sub_msg ("STOP");
16792
16793 global_free (subid);
16794 }
16795
16796 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16797
16798 if (data.devices_status == STATUS_CRACKED) break;
16799 if (data.devices_status == STATUS_ABORTED) break;
16800 if (data.devices_status == STATUS_QUIT) break;
16801
16802 if (data.devices_status == STATUS_BYPASS)
16803 {
16804 data.devices_status = STATUS_RUNNING;
16805 }
16806 }
16807
16808 // 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
16809
16810 if (attack_mode == ATTACK_MODE_STRAIGHT)
16811 {
16812 if (data.wordlist_mode == WL_MODE_FILE)
16813 {
16814 if (data.dictfile == NULL)
16815 {
16816 if (dictfiles != NULL)
16817 {
16818 data.dictfile = dictfiles[0];
16819
16820 hc_timer_set (&data.timer_running);
16821 }
16822 }
16823 }
16824 }
16825 // NOTE: combi is okay because it is already set beforehand
16826 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16827 {
16828 if (data.dictfile == NULL)
16829 {
16830 if (dictfiles != NULL)
16831 {
16832 hc_timer_set (&data.timer_running);
16833
16834 data.dictfile = dictfiles[0];
16835 }
16836 }
16837 }
16838 else if (attack_mode == ATTACK_MODE_BF)
16839 {
16840 if (data.mask == NULL)
16841 {
16842 hc_timer_set (&data.timer_running);
16843
16844 data.mask = masks[0];
16845 }
16846 }
16847
16848 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16849 {
16850 data.devices_status = STATUS_EXHAUSTED;
16851 }
16852
16853 // if cracked / aborted remove last induction dictionary
16854
16855 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16856 {
16857 struct stat induct_stat;
16858
16859 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16860 {
16861 unlink (induction_dictionaries[file_pos]);
16862 }
16863 }
16864
16865 // wait for non-interactive threads
16866
16867 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16868 {
16869 hc_thread_wait (1, &ni_threads[thread_idx]);
16870 }
16871
16872 local_free (ni_threads);
16873
16874 // wait for interactive threads
16875
16876 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16877 {
16878 hc_thread_wait (1, &i_thread);
16879 }
16880
16881 // we dont need restore file anymore
16882 if (data.restore_disable == 0)
16883 {
16884 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16885 {
16886 unlink (eff_restore_file);
16887 unlink (new_restore_file);
16888 }
16889 else
16890 {
16891 cycle_restore ();
16892 }
16893 }
16894
16895 // finally save left hashes
16896
16897 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16898 {
16899 save_hash ();
16900 }
16901
16902 /**
16903 * Clean up
16904 */
16905
16906 if (benchmark == 1)
16907 {
16908 status_benchmark ();
16909
16910 log_info ("");
16911 }
16912 else
16913 {
16914 if (quiet == 0) clear_prompt ();
16915
16916 if (quiet == 0) log_info ("");
16917
16918 if (status == 1)
16919 {
16920 status_display ();
16921 }
16922 else
16923 {
16924 if (quiet == 0) status_display ();
16925 }
16926
16927 if (quiet == 0) log_info ("");
16928 }
16929
16930 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16931 {
16932 hc_device_param_t *device_param = &data.devices_param[device_id];
16933
16934 if (device_param->skipped) continue;
16935
16936 local_free (device_param->result);
16937
16938 local_free (device_param->combs_buf);
16939
16940 local_free (device_param->hooks_buf);
16941
16942 local_free (device_param->device_name);
16943
16944 local_free (device_param->device_name_chksum);
16945
16946 local_free (device_param->device_version);
16947
16948 local_free (device_param->driver_version);
16949
16950 if (device_param->pws_buf) myfree (device_param->pws_buf);
16951 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16952 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16953 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16954 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16955 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16956 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16957 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16958 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16959 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16960 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16961 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16962 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16963 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16964 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16965 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16966 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16967 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16968 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16969 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16970 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16971 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16972 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16973 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16974 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16975 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16976 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16977 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16978 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16979
16980 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16981 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16982 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16983 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16984 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16985 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16986 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16987 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16988 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16989 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16990
16991 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16992 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16993 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16994
16995 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16996 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16997 }
16998
16999 // reset default fan speed
17000
17001 #ifdef HAVE_HWMON
17002 if (gpu_temp_disable == 0)
17003 {
17004 #ifdef HAVE_ADL
17005 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17006 {
17007 hc_thread_mutex_lock (mux_adl);
17008
17009 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17010 {
17011 hc_device_param_t *device_param = &data.devices_param[device_id];
17012
17013 if (device_param->skipped) continue;
17014
17015 if (data.hm_device[device_id].fan_supported == 1)
17016 {
17017 int fanspeed = temp_retain_fanspeed_value[device_id];
17018
17019 if (fanspeed == -1) continue;
17020
17021 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17022
17023 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17024 }
17025 }
17026
17027 hc_thread_mutex_unlock (mux_adl);
17028 }
17029 #endif // HAVE_ADL
17030 }
17031
17032 #ifdef HAVE_ADL
17033 // reset power tuning
17034
17035 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17036 {
17037 hc_thread_mutex_lock (mux_adl);
17038
17039 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17040 {
17041 hc_device_param_t *device_param = &data.devices_param[device_id];
17042
17043 if (device_param->skipped) continue;
17044
17045 if (data.hm_device[device_id].od_version == 6)
17046 {
17047 // check powertune capabilities first, if not available then skip device
17048
17049 int powertune_supported = 0;
17050
17051 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17052 {
17053 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17054
17055 return (-1);
17056 }
17057
17058 if (powertune_supported != 0)
17059 {
17060 // powercontrol settings
17061
17062 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)
17063 {
17064 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17065
17066 return (-1);
17067 }
17068
17069 // clocks
17070
17071 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17072
17073 performance_state->iNumberOfPerformanceLevels = 2;
17074
17075 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17076 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17077 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17078 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17079
17080 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)
17081 {
17082 log_info ("ERROR: Failed to restore ADL performance state");
17083
17084 return (-1);
17085 }
17086
17087 local_free (performance_state);
17088 }
17089 }
17090 }
17091
17092 hc_thread_mutex_unlock (mux_adl);
17093 }
17094 #endif // HAVE_ADL
17095
17096 if (gpu_temp_disable == 0)
17097 {
17098 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17099 if (data.hm_nv)
17100 {
17101 #if defined(LINUX) && defined(HAVE_NVML)
17102
17103 hm_NVML_nvmlShutdown (data.hm_nv);
17104
17105 nvml_close (data.hm_nv);
17106
17107 #elif defined(WIN) && (HAVE_NVAPI)
17108
17109 hm_NvAPI_Unload (data.hm_nv);
17110
17111 nvapi_close (data.hm_nv);
17112
17113 #endif
17114
17115 data.hm_nv = NULL;
17116 }
17117 #endif
17118
17119 #ifdef HAVE_ADL
17120 if (data.hm_amd)
17121 {
17122 hm_ADL_Main_Control_Destroy (data.hm_amd);
17123
17124 adl_close (data.hm_amd);
17125 data.hm_amd = NULL;
17126 }
17127 #endif
17128 }
17129 #endif // HAVE_HWMON
17130
17131 // free memory
17132
17133 local_free (masks);
17134
17135 local_free (dictstat_base);
17136
17137 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17138 {
17139 pot_t *pot_ptr = &pot[pot_pos];
17140
17141 hash_t *hash = &pot_ptr->hash;
17142
17143 local_free (hash->digest);
17144
17145 if (isSalted)
17146 {
17147 local_free (hash->salt);
17148 }
17149 }
17150
17151 local_free (pot);
17152
17153 local_free (all_kernel_rules_cnt);
17154 local_free (all_kernel_rules_buf);
17155
17156 local_free (wl_data->buf);
17157 local_free (wl_data);
17158
17159 local_free (bitmap_s1_a);
17160 local_free (bitmap_s1_b);
17161 local_free (bitmap_s1_c);
17162 local_free (bitmap_s1_d);
17163 local_free (bitmap_s2_a);
17164 local_free (bitmap_s2_b);
17165 local_free (bitmap_s2_c);
17166 local_free (bitmap_s2_d);
17167
17168 #ifdef HAVE_HWMON
17169 local_free (temp_retain_fanspeed_value);
17170 #ifdef HAVE_ADL
17171 local_free (od_clock_mem_status);
17172 local_free (od_power_control_status);
17173 #endif // ADL
17174 #endif
17175
17176 global_free (devices_param);
17177
17178 global_free (kernel_rules_buf);
17179
17180 global_free (root_css_buf);
17181 global_free (markov_css_buf);
17182
17183 global_free (digests_buf);
17184 global_free (digests_shown);
17185 global_free (digests_shown_tmp);
17186
17187 global_free (salts_buf);
17188 global_free (salts_shown);
17189
17190 global_free (esalts_buf);
17191
17192 global_free (words_progress_done);
17193 global_free (words_progress_rejected);
17194 global_free (words_progress_restored);
17195
17196 if (pot_fp) fclose (pot_fp);
17197
17198 if (data.devices_status == STATUS_QUIT) break;
17199 }
17200
17201 // destroy others mutex
17202
17203 hc_thread_mutex_delete (mux_dispatcher);
17204 hc_thread_mutex_delete (mux_counter);
17205 hc_thread_mutex_delete (mux_display);
17206 hc_thread_mutex_delete (mux_adl);
17207
17208 // free memory
17209
17210 local_free (eff_restore_file);
17211 local_free (new_restore_file);
17212
17213 local_free (rd);
17214
17215 // tuning db
17216
17217 tuning_db_destroy (tuning_db);
17218
17219 // loopback
17220
17221 local_free (loopback_file);
17222
17223 if (loopback == 1) unlink (loopback_file);
17224
17225 // induction directory
17226
17227 if (induction_dir == NULL)
17228 {
17229 if (attack_mode != ATTACK_MODE_BF)
17230 {
17231 if (rmdir (induction_directory) == -1)
17232 {
17233 if (errno == ENOENT)
17234 {
17235 // good, we can ignore
17236 }
17237 else if (errno == ENOTEMPTY)
17238 {
17239 // good, we can ignore
17240 }
17241 else
17242 {
17243 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17244
17245 return (-1);
17246 }
17247 }
17248
17249 local_free (induction_directory);
17250 }
17251 }
17252
17253 // outfile-check directory
17254
17255 if (outfile_check_dir == NULL)
17256 {
17257 if (rmdir (outfile_check_directory) == -1)
17258 {
17259 if (errno == ENOENT)
17260 {
17261 // good, we can ignore
17262 }
17263 else if (errno == ENOTEMPTY)
17264 {
17265 // good, we can ignore
17266 }
17267 else
17268 {
17269 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17270
17271 return (-1);
17272 }
17273 }
17274
17275 local_free (outfile_check_directory);
17276 }
17277
17278 time_t proc_stop;
17279
17280 time (&proc_stop);
17281
17282 logfile_top_uint (proc_start);
17283 logfile_top_uint (proc_stop);
17284
17285 logfile_top_msg ("STOP");
17286
17287 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17288 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17289
17290 if (data.ocl) ocl_close (data.ocl);
17291
17292 if (data.devices_status == STATUS_ABORTED) return 2;
17293 if (data.devices_status == STATUS_QUIT) return 2;
17294 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17295 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17296 if (data.devices_status == STATUS_CRACKED) return 0;
17297
17298 return -1;
17299 }
Hashcat additions to support pwdhash