projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Removed SHA1 optimization.
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * oclHashcat specific functions
758 */
759
760 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
761 {
762 int exec_pos = (int) device_param->exec_pos - last_num_entries;
763
764 if (exec_pos < 0) exec_pos += EXEC_CACHE;
765
766 double exec_ms_sum = 0;
767
768 int exec_ms_cnt = 0;
769
770 for (int i = 0; i < last_num_entries; i++)
771 {
772 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
773
774 if (exec_ms)
775 {
776 exec_ms_sum += exec_ms;
777
778 exec_ms_cnt++;
779 }
780 }
781
782 if (exec_ms_cnt == 0) return 0;
783
784 return exec_ms_sum / exec_ms_cnt;
785 }
786
787 void status_display_automat ()
788 {
789 FILE *out = stdout;
790
791 fprintf (out, "STATUS\t%u\t", data.devices_status);
792
793 /**
794 * speed new
795 */
796
797 fprintf (out, "SPEED\t");
798
799 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
800 {
801 hc_device_param_t *device_param = &data.devices_param[device_id];
802
803 if (device_param->skipped) continue;
804
805 u64 speed_cnt = 0;
806 float speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 float rec_ms;
811
812 hc_timer_get (device_param->speed_rec[i], rec_ms);
813
814 if (rec_ms > SPEED_MAXAGE) continue;
815
816 speed_cnt += device_param->speed_cnt[i];
817 speed_ms += device_param->speed_ms[i];
818 }
819
820 speed_cnt /= SPEED_CACHE;
821 speed_ms /= SPEED_CACHE;
822
823 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
824 }
825
826 /**
827 * exec time
828 */
829
830 fprintf (out, "EXEC_RUNTIME\t");
831
832 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
833 {
834 hc_device_param_t *device_param = &data.devices_param[device_id];
835
836 if (device_param->skipped) continue;
837
838 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
839
840 fprintf (out, "%f\t", exec_ms_avg);
841 }
842
843 /**
844 * words_cur
845 */
846
847 u64 words_cur = get_lowest_words_done ();
848
849 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
850
851 /**
852 * counter
853 */
854
855 u64 progress_total = data.words_cnt * data.salts_cnt;
856
857 u64 all_done = 0;
858 u64 all_rejected = 0;
859 u64 all_restored = 0;
860
861 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
862 {
863 all_done += data.words_progress_done[salt_pos];
864 all_rejected += data.words_progress_rejected[salt_pos];
865 all_restored += data.words_progress_restored[salt_pos];
866 }
867
868 u64 progress_cur = all_restored + all_done + all_rejected;
869 u64 progress_end = progress_total;
870
871 u64 progress_skip = 0;
872
873 if (data.skip)
874 {
875 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
876
877 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
878 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
879 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
880 }
881
882 if (data.limit)
883 {
884 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
885
886 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
887 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
888 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
889 }
890
891 u64 progress_cur_relative_skip = progress_cur - progress_skip;
892 u64 progress_end_relative_skip = progress_end - progress_skip;
893
894 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
895
896 /**
897 * cracks
898 */
899
900 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
901 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
902
903 /**
904 * temperature
905 */
906
907 #ifdef HAVE_HWMON
908 if (data.gpu_temp_disable == 0)
909 {
910 fprintf (out, "TEMP\t");
911
912 hc_thread_mutex_lock (mux_adl);
913
914 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
915 {
916 hc_device_param_t *device_param = &data.devices_param[device_id];
917
918 if (device_param->skipped) continue;
919
920 int temp = hm_get_temperature_with_device_id (device_id);
921
922 fprintf (out, "%d\t", temp);
923 }
924
925 hc_thread_mutex_unlock (mux_adl);
926 }
927 #endif // HAVE_HWMON
928
929 /**
930 * flush
931 */
932
933 #ifdef _WIN
934 fputc ('\r', out);
935 fputc ('\n', out);
936 #endif
937
938 #ifdef _POSIX
939 fputc ('\n', out);
940 #endif
941
942 fflush (out);
943 }
944
945 void status_display ()
946 {
947 if (data.devices_status == STATUS_INIT) return;
948 if (data.devices_status == STATUS_STARTING) return;
949 if (data.devices_status == STATUS_BYPASS) return;
950
951 if (data.status_automat == 1)
952 {
953 status_display_automat ();
954
955 return;
956 }
957
958 char tmp_buf[1000] = { 0 };
959
960 uint tmp_len = 0;
961
962 log_info ("Session.Name...: %s", data.session);
963
964 char *status_type = strstatus (data.devices_status);
965
966 uint hash_mode = data.hash_mode;
967
968 char *hash_type = strhashtype (hash_mode); // not a bug
969
970 log_info ("Status.........: %s", status_type);
971
972 /**
973 * show rules
974 */
975
976 if (data.rp_files_cnt)
977 {
978 uint i;
979
980 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
981 {
982 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
983 }
984
985 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
986
987 log_info ("Rules.Type.....: %s", tmp_buf);
988
989 tmp_len = 0;
990 }
991
992 if (data.rp_gen)
993 {
994 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
995
996 if (data.rp_gen_seed)
997 {
998 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
999 }
1000 }
1001
1002 /**
1003 * show input
1004 */
1005
1006 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1007 {
1008 if (data.wordlist_mode == WL_MODE_FILE)
1009 {
1010 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1011 }
1012 else if (data.wordlist_mode == WL_MODE_STDIN)
1013 {
1014 log_info ("Input.Mode.....: Pipe");
1015 }
1016 }
1017 else if (data.attack_mode == ATTACK_MODE_COMBI)
1018 {
1019 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1020 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1021 }
1022 else if (data.attack_mode == ATTACK_MODE_BF)
1023 {
1024 char *mask = data.mask;
1025
1026 if (mask != NULL)
1027 {
1028 uint mask_len = data.css_cnt;
1029
1030 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1031
1032 if (mask_len > 0)
1033 {
1034 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1035 {
1036 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1037 {
1038 mask_len -= data.salts_buf[0].salt_len;
1039 }
1040 }
1041
1042 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1045 }
1046
1047 if (data.maskcnt > 1)
1048 {
1049 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1050
1051 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1052 }
1053
1054 log_info ("Input.Mode.....: %s", tmp_buf);
1055 }
1056
1057 tmp_len = 0;
1058 }
1059 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1060 {
1061 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1062 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1063 }
1064 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1065 {
1066 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1067 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1068 }
1069
1070 if (data.digests_cnt == 1)
1071 {
1072 if (data.hash_mode == 2500)
1073 {
1074 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1075
1076 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1077 (char *) data.salts_buf[0].salt_buf,
1078 wpa->orig_mac1[0],
1079 wpa->orig_mac1[1],
1080 wpa->orig_mac1[2],
1081 wpa->orig_mac1[3],
1082 wpa->orig_mac1[4],
1083 wpa->orig_mac1[5],
1084 wpa->orig_mac2[0],
1085 wpa->orig_mac2[1],
1086 wpa->orig_mac2[2],
1087 wpa->orig_mac2[3],
1088 wpa->orig_mac2[4],
1089 wpa->orig_mac2[5]);
1090 }
1091 else if (data.hash_mode == 5200)
1092 {
1093 log_info ("Hash.Target....: File (%s)", data.hashfile);
1094 }
1095 else if (data.hash_mode == 9000)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else
1104 {
1105 char out_buf[HCBUFSIZ] = { 0 };
1106
1107 ascii_digest (out_buf, 0, 0);
1108
1109 // limit length
1110 if (strlen (out_buf) > 40)
1111 {
1112 out_buf[41] = '.';
1113 out_buf[42] = '.';
1114 out_buf[43] = '.';
1115 out_buf[44] = 0;
1116 }
1117
1118 log_info ("Hash.Target....: %s", out_buf);
1119 }
1120 }
1121 else
1122 {
1123 if (data.hash_mode == 3000)
1124 {
1125 char out_buf1[32] = { 0 };
1126 char out_buf2[32] = { 0 };
1127
1128 ascii_digest (out_buf1, 0, 0);
1129 ascii_digest (out_buf2, 0, 1);
1130
1131 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1132 }
1133 else
1134 {
1135 log_info ("Hash.Target....: File (%s)", data.hashfile);
1136 }
1137 }
1138
1139 log_info ("Hash.Type......: %s", hash_type);
1140
1141 /**
1142 * speed new
1143 */
1144
1145 u64 speed_cnt[DEVICES_MAX] = { 0 };
1146 float speed_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 // we need to clear values (set to 0) because in case the device does
1155 // not get new candidates it idles around but speed display would
1156 // show it as working.
1157 // if we instantly set it to 0 after reading it happens that the
1158 // speed can be shown as zero if the users refreshes too fast.
1159 // therefore, we add a timestamp when a stat was recorded and if its
1160 // too old we will not use it
1161
1162 speed_cnt[device_id] = 0;
1163 speed_ms[device_id] = 0;
1164
1165 for (int i = 0; i < SPEED_CACHE; i++)
1166 {
1167 float rec_ms;
1168
1169 hc_timer_get (device_param->speed_rec[i], rec_ms);
1170
1171 if (rec_ms > SPEED_MAXAGE) continue;
1172
1173 speed_cnt[device_id] += device_param->speed_cnt[i];
1174 speed_ms[device_id] += device_param->speed_ms[i];
1175 }
1176
1177 speed_cnt[device_id] /= SPEED_CACHE;
1178 speed_ms[device_id] /= SPEED_CACHE;
1179 }
1180
1181 float hashes_all_ms = 0;
1182
1183 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1184
1185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1186 {
1187 hc_device_param_t *device_param = &data.devices_param[device_id];
1188
1189 if (device_param->skipped) continue;
1190
1191 hashes_dev_ms[device_id] = 0;
1192
1193 if (speed_ms[device_id])
1194 {
1195 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1196
1197 hashes_all_ms += hashes_dev_ms[device_id];
1198 }
1199 }
1200
1201 /**
1202 * exec time
1203 */
1204
1205 double exec_all_ms[DEVICES_MAX] = { 0 };
1206
1207 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1208 {
1209 hc_device_param_t *device_param = &data.devices_param[device_id];
1210
1211 if (device_param->skipped) continue;
1212
1213 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1214
1215 exec_all_ms[device_id] = exec_ms_avg;
1216 }
1217
1218 /**
1219 * timers
1220 */
1221
1222 float ms_running = 0;
1223
1224 hc_timer_get (data.timer_running, ms_running);
1225
1226 float ms_paused = data.ms_paused;
1227
1228 if (data.devices_status == STATUS_PAUSED)
1229 {
1230 float ms_paused_tmp = 0;
1231
1232 hc_timer_get (data.timer_paused, ms_paused_tmp);
1233
1234 ms_paused += ms_paused_tmp;
1235 }
1236
1237 #ifdef WIN
1238
1239 __time64_t sec_run = ms_running / 1000;
1240
1241 #else
1242
1243 time_t sec_run = ms_running / 1000;
1244
1245 #endif
1246
1247 if (sec_run)
1248 {
1249 char display_run[32] = { 0 };
1250
1251 struct tm tm_run;
1252
1253 struct tm *tmp = NULL;
1254
1255 #ifdef WIN
1256
1257 tmp = _gmtime64 (&sec_run);
1258
1259 #else
1260
1261 tmp = gmtime (&sec_run);
1262
1263 #endif
1264
1265 if (tmp != NULL)
1266 {
1267 memset (&tm_run, 0, sizeof (tm_run));
1268
1269 memcpy (&tm_run, tmp, sizeof (tm_run));
1270
1271 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1272
1273 char *start = ctime (&data.proc_start);
1274
1275 size_t start_len = strlen (start);
1276
1277 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1278 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1279
1280 log_info ("Time.Started...: %s (%s)", start, display_run);
1281 }
1282 }
1283 else
1284 {
1285 log_info ("Time.Started...: 0 secs");
1286 }
1287
1288 /**
1289 * counters
1290 */
1291
1292 u64 progress_total = data.words_cnt * data.salts_cnt;
1293
1294 u64 all_done = 0;
1295 u64 all_rejected = 0;
1296 u64 all_restored = 0;
1297
1298 u64 progress_noneed = 0;
1299
1300 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1301 {
1302 all_done += data.words_progress_done[salt_pos];
1303 all_rejected += data.words_progress_rejected[salt_pos];
1304 all_restored += data.words_progress_restored[salt_pos];
1305
1306 // Important for ETA only
1307
1308 if (data.salts_shown[salt_pos] == 1)
1309 {
1310 const u64 all = data.words_progress_done[salt_pos]
1311 + data.words_progress_rejected[salt_pos]
1312 + data.words_progress_restored[salt_pos];
1313
1314 const u64 left = data.words_cnt - all;
1315
1316 progress_noneed += left;
1317 }
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1347 {
1348 if (data.devices_status != STATUS_CRACKED)
1349 {
1350 #ifdef WIN
1351 __time64_t sec_etc = 0;
1352 #else
1353 time_t sec_etc = 0;
1354 #endif
1355
1356 if (hashes_all_ms)
1357 {
1358 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1359
1360 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1361
1362 sec_etc = ms_left / 1000;
1363 }
1364
1365 if (sec_etc == 0)
1366 {
1367 //log_info ("Time.Estimated.: 0 secs");
1368 }
1369 else if ((u64) sec_etc > ETC_MAX)
1370 {
1371 log_info ("Time.Estimated.: > 10 Years");
1372 }
1373 else
1374 {
1375 char display_etc[32] = { 0 };
1376
1377 struct tm tm_etc;
1378
1379 struct tm *tmp = NULL;
1380
1381 #ifdef WIN
1382
1383 tmp = _gmtime64 (&sec_etc);
1384
1385 #else
1386
1387 tmp = gmtime (&sec_etc);
1388
1389 #endif
1390
1391 if (tmp != NULL)
1392 {
1393 memset (&tm_etc, 0, sizeof (tm_etc));
1394
1395 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1396
1397 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1398
1399 time_t now;
1400
1401 time (&now);
1402
1403 now += sec_etc;
1404
1405 char *etc = ctime (&now);
1406
1407 size_t etc_len = strlen (etc);
1408
1409 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1410 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1411
1412 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1413 }
1414 }
1415 }
1416 }
1417
1418 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1419 {
1420 hc_device_param_t *device_param = &data.devices_param[device_id];
1421
1422 if (device_param->skipped) continue;
1423
1424 char display_dev_cur[16] = { 0 };
1425
1426 strncpy (display_dev_cur, "0.00", 4);
1427
1428 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1429
1430 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1431 }
1432
1433 char display_all_cur[16] = { 0 };
1434
1435 strncpy (display_all_cur, "0.00", 4);
1436
1437 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1438
1439 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1440
1441 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1442 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1443
1444 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);
1445
1446 // crack-per-time
1447
1448 if (data.digests_cnt > 100)
1449 {
1450 time_t now = time (NULL);
1451
1452 int cpt_cur_min = 0;
1453 int cpt_cur_hour = 0;
1454 int cpt_cur_day = 0;
1455
1456 for (int i = 0; i < CPT_BUF; i++)
1457 {
1458 const uint cracked = data.cpt_buf[i].cracked;
1459 const time_t timestamp = data.cpt_buf[i].timestamp;
1460
1461 if ((timestamp + 60) > now)
1462 {
1463 cpt_cur_min += cracked;
1464 }
1465
1466 if ((timestamp + 3600) > now)
1467 {
1468 cpt_cur_hour += cracked;
1469 }
1470
1471 if ((timestamp + 86400) > now)
1472 {
1473 cpt_cur_day += cracked;
1474 }
1475 }
1476
1477 float ms_real = ms_running - ms_paused;
1478
1479 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1480 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1481 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1482
1483 if ((data.cpt_start + 86400) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_cur_hour,
1488 cpt_cur_day,
1489 cpt_avg_min,
1490 cpt_avg_hour,
1491 cpt_avg_day);
1492 }
1493 else if ((data.cpt_start + 3600) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_avg_min,
1499 cpt_avg_hour,
1500 cpt_avg_day);
1501 }
1502 else if ((data.cpt_start + 60) < now)
1503 {
1504 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1505 cpt_cur_min,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else
1511 {
1512 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 }
1518
1519 // Restore point
1520
1521 u64 restore_point = get_lowest_words_done ();
1522
1523 u64 restore_total = data.words_base;
1524
1525 float percent_restore = 0;
1526
1527 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1528
1529 if (progress_end_relative_skip)
1530 {
1531 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532 {
1533 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1534 float percent_rejected = 0.0;
1535
1536 if (progress_cur)
1537 {
1538 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1539 }
1540
1541 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);
1542 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1543
1544 if (data.restore_disable == 0)
1545 {
1546 if (percent_finished != 1)
1547 {
1548 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1549 }
1550 }
1551 }
1552 }
1553 else
1554 {
1555 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1556 {
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 }
1564 }
1565 else
1566 {
1567 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1568 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1569
1570 // --restore not allowed if stdin is used -- really? why?
1571
1572 //if (data.restore_disable == 0)
1573 //{
1574 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1575 //}
1576 }
1577 }
1578
1579 #ifdef HAVE_HWMON
1580 if (data.gpu_temp_disable == 0)
1581 {
1582 hc_thread_mutex_lock (mux_adl);
1583
1584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1585 {
1586 hc_device_param_t *device_param = &data.devices_param[device_id];
1587
1588 if (device_param->skipped) continue;
1589
1590 #define HM_STR_BUF_SIZE 255
1591
1592 if (data.hm_device[device_id].fan_supported == 1)
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 if (device_param->vendor_id == VENDOR_ID_AMD)
1602 {
1603 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1604 }
1605 else if (device_param->vendor_id == VENDOR_ID_NV)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609
1610 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1611 }
1612 else
1613 {
1614 char utilization[HM_STR_BUF_SIZE] = { 0 };
1615 char temperature[HM_STR_BUF_SIZE] = { 0 };
1616
1617 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1618 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1621 }
1622 }
1623
1624 hc_thread_mutex_unlock (mux_adl);
1625 }
1626 #endif // HAVE_HWMON
1627 }
1628
1629 static void status_benchmark ()
1630 {
1631 if (data.devices_status == STATUS_INIT) return;
1632 if (data.devices_status == STATUS_STARTING) return;
1633
1634 if (data.words_cnt == 0) return;
1635
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 float speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = 0;
1646 speed_ms[device_id] = 0;
1647
1648 for (int i = 0; i < SPEED_CACHE; i++)
1649 {
1650 speed_cnt[device_id] += device_param->speed_cnt[i];
1651 speed_ms[device_id] += device_param->speed_ms[i];
1652 }
1653
1654 speed_cnt[device_id] /= SPEED_CACHE;
1655 speed_ms[device_id] /= SPEED_CACHE;
1656 }
1657
1658 float hashes_all_ms = 0;
1659
1660 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1661
1662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1663 {
1664 hc_device_param_t *device_param = &data.devices_param[device_id];
1665
1666 if (device_param->skipped) continue;
1667
1668 hashes_dev_ms[device_id] = 0;
1669
1670 if (speed_ms[device_id])
1671 {
1672 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1673
1674 hashes_all_ms += hashes_dev_ms[device_id];
1675 }
1676 }
1677
1678 /**
1679 * exec time
1680 */
1681
1682 double exec_all_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1691
1692 exec_all_ms[device_id] = exec_ms_avg;
1693 }
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 char display_dev_cur[16] = { 0 };
1702
1703 strncpy (display_dev_cur, "0.00", 4);
1704
1705 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1706
1707 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1708 }
1709
1710 char display_all_cur[16] = { 0 };
1711
1712 strncpy (display_all_cur, "0.00", 4);
1713
1714 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1715
1716 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1717 }
1718
1719 /**
1720 * oclHashcat -only- functions
1721 */
1722
1723 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1724 {
1725 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1726 {
1727 if (attack_kern == ATTACK_KERN_STRAIGHT)
1728 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1729 else if (attack_kern == ATTACK_KERN_COMBI)
1730 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1731 else if (attack_kern == ATTACK_KERN_BF)
1732 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1733 }
1734 else
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1736 }
1737
1738 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)
1739 {
1740 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1741 {
1742 if (attack_kern == ATTACK_KERN_STRAIGHT)
1743 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1744 else if (attack_kern == ATTACK_KERN_COMBI)
1745 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1746 else if (attack_kern == ATTACK_KERN_BF)
1747 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1748 }
1749 else
1750 {
1751 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 }
1753 }
1754
1755 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1756 {
1757 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1758 {
1759 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1760 }
1761 else
1762 {
1763 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1764 }
1765 }
1766
1767 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)
1768 {
1769 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1770 {
1771 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1772 }
1773 else
1774 {
1775 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1776 }
1777 }
1778
1779 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1780 {
1781 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1782 }
1783
1784 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1785 {
1786 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1787 }
1788
1789 static uint convert_from_hex (char *line_buf, const uint line_len)
1790 {
1791 if (line_len & 1) return (line_len); // not in hex
1792
1793 if (data.hex_wordlist == 1)
1794 {
1795 uint i;
1796 uint j;
1797
1798 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1799 {
1800 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1801 }
1802
1803 memset (line_buf + i, 0, line_len - i);
1804
1805 return (i);
1806 }
1807 else if (line_len >= 6) // $HEX[] = 6
1808 {
1809 if (line_buf[0] != '$') return (line_len);
1810 if (line_buf[1] != 'H') return (line_len);
1811 if (line_buf[2] != 'E') return (line_len);
1812 if (line_buf[3] != 'X') return (line_len);
1813 if (line_buf[4] != '[') return (line_len);
1814 if (line_buf[line_len - 1] != ']') return (line_len);
1815
1816 uint i;
1817 uint j;
1818
1819 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1820 {
1821 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1822 }
1823
1824 memset (line_buf + i, 0, line_len - i);
1825
1826 return (i);
1827 }
1828
1829 return (line_len);
1830 }
1831
1832 static void clear_prompt ()
1833 {
1834 fputc ('\r', stdout);
1835
1836 for (size_t i = 0; i < strlen (PROMPT); i++)
1837 {
1838 fputc (' ', stdout);
1839 }
1840
1841 fputc ('\r', stdout);
1842
1843 fflush (stdout);
1844 }
1845
1846 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1847 {
1848 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);
1849 }
1850
1851 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1852 {
1853 char *outfile = data.outfile;
1854 uint quiet = data.quiet;
1855 FILE *pot_fp = data.pot_fp;
1856 uint loopback = data.loopback;
1857 uint debug_mode = data.debug_mode;
1858 char *debug_file = data.debug_file;
1859
1860 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1861 int debug_rule_len = 0; // -1 error
1862 uint debug_plain_len = 0;
1863
1864 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1865
1866 // hash
1867
1868 char out_buf[HCBUFSIZ] = { 0 };
1869
1870 ascii_digest (out_buf, salt_pos, digest_pos);
1871
1872 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1873
1874 // plain
1875
1876 plain_t plain;
1877
1878 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);
1879
1880 uint gidvid = plain.gidvid;
1881 uint il_pos = plain.il_pos;
1882
1883 u64 crackpos = device_param->words_off;
1884
1885 uint plain_buf[16] = { 0 };
1886
1887 u8 *plain_ptr = (u8 *) plain_buf;
1888 unsigned int plain_len = 0;
1889
1890 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1891 {
1892 u64 gidd = gidvid;
1893 u64 gidm = 0;
1894
1895 pw_t pw;
1896
1897 gidd_to_pw_t (device_param, gidd, &pw);
1898
1899 for (int i = 0, j = gidm; i < 16; i++, j++)
1900 {
1901 plain_buf[i] = pw.i[j];
1902 }
1903
1904 plain_len = pw.pw_len;
1905
1906 const uint off = device_param->innerloop_pos + il_pos;
1907
1908 if (debug_mode > 0)
1909 {
1910 debug_rule_len = 0;
1911
1912 // save rule
1913 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1914 {
1915 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1916
1917 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1918 }
1919
1920 // save plain
1921 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1924
1925 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1926
1927 debug_plain_len = plain_len;
1928 }
1929 }
1930
1931 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1932
1933 crackpos += gidvid;
1934 crackpos *= data.kernel_rules_cnt;
1935 crackpos += device_param->innerloop_pos + il_pos;
1936
1937 if (plain_len > data.pw_max) plain_len = data.pw_max;
1938 }
1939 else if (data.attack_mode == ATTACK_MODE_COMBI)
1940 {
1941 u64 gidd = gidvid;
1942 u64 gidm = 0;
1943
1944 pw_t pw;
1945
1946 gidd_to_pw_t (device_param, gidd, &pw);
1947
1948 for (int i = 0, j = gidm; i < 16; i++, j++)
1949 {
1950 plain_buf[i] = pw.i[j];
1951 }
1952
1953 plain_len = pw.pw_len;
1954
1955 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1956 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1957
1958 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1959 {
1960 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1961 }
1962 else
1963 {
1964 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1965
1966 memcpy (plain_ptr, comb_buf, comb_len);
1967 }
1968
1969 plain_len += comb_len;
1970
1971 crackpos += gidvid;
1972 crackpos *= data.combs_cnt;
1973 crackpos += device_param->innerloop_pos + il_pos;
1974
1975 if (data.pw_max != PW_DICTMAX1)
1976 {
1977 if (plain_len > data.pw_max) plain_len = data.pw_max;
1978 }
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_BF)
1981 {
1982 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1983 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1984
1985 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1986 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1987
1988 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1989 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1990
1991 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1992 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1993
1994 plain_len = data.css_cnt;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.bfs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2001 {
2002 u64 gidd = gidvid;
2003 u64 gidm = 0;
2004
2005 pw_t pw;
2006
2007 gidd_to_pw_t (device_param, gidd, &pw);
2008
2009 for (int i = 0, j = gidm; i < 16; i++, j++)
2010 {
2011 plain_buf[i] = pw.i[j];
2012 }
2013
2014 plain_len = pw.pw_len;
2015
2016 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2017
2018 uint start = 0;
2019 uint stop = device_param->kernel_params_mp_buf32[4];
2020
2021 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2022
2023 plain_len += start + stop;
2024
2025 crackpos += gidvid;
2026 crackpos *= data.combs_cnt;
2027 crackpos += device_param->innerloop_pos + il_pos;
2028
2029 if (data.pw_max != PW_DICTMAX1)
2030 {
2031 if (plain_len > data.pw_max) plain_len = data.pw_max;
2032 }
2033 }
2034 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2035 {
2036 u64 gidd = gidvid;
2037 u64 gidm = 0;
2038
2039 pw_t pw;
2040
2041 gidd_to_pw_t (device_param, gidd, &pw);
2042
2043 for (int i = 0, j = gidm; i < 16; i++, j++)
2044 {
2045 plain_buf[i] = pw.i[j];
2046 }
2047
2048 plain_len = pw.pw_len;
2049
2050 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2051
2052 uint start = 0;
2053 uint stop = device_param->kernel_params_mp_buf32[4];
2054
2055 memmove (plain_ptr + stop, plain_ptr, plain_len);
2056
2057 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2058
2059 plain_len += start + stop;
2060
2061 crackpos += gidvid;
2062 crackpos *= data.combs_cnt;
2063 crackpos += device_param->innerloop_pos + il_pos;
2064
2065 if (data.pw_max != PW_DICTMAX1)
2066 {
2067 if (plain_len > data.pw_max) plain_len = data.pw_max;
2068 }
2069 }
2070
2071 if (data.attack_mode == ATTACK_MODE_BF)
2072 {
2073 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2074 {
2075 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2076 {
2077 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2078 {
2079 plain_len = plain_len - data.salts_buf[0].salt_len;
2080 }
2081 }
2082
2083 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2084 {
2085 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2086 {
2087 plain_ptr[j] = plain_ptr[i];
2088 }
2089
2090 plain_len = plain_len / 2;
2091 }
2092 }
2093 }
2094
2095 // if enabled, update also the potfile
2096
2097 if (pot_fp)
2098 {
2099 lock_file (pot_fp);
2100
2101 fprintf (pot_fp, "%s:", out_buf);
2102
2103 format_plain (pot_fp, plain_ptr, plain_len, 1);
2104
2105 fputc ('\n', pot_fp);
2106
2107 fflush (pot_fp);
2108
2109 unlock_file (pot_fp);
2110 }
2111
2112 // outfile
2113
2114 FILE *out_fp = NULL;
2115
2116 if (outfile != NULL)
2117 {
2118 if ((out_fp = fopen (outfile, "ab")) == NULL)
2119 {
2120 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2121
2122 out_fp = stdout;
2123 }
2124 lock_file (out_fp);
2125 }
2126 else
2127 {
2128 out_fp = stdout;
2129
2130 if (quiet == 0) clear_prompt ();
2131 }
2132
2133 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2134
2135 if (outfile != NULL)
2136 {
2137 if (out_fp != stdout)
2138 {
2139 fclose (out_fp);
2140 }
2141 }
2142 else
2143 {
2144 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2145 {
2146 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2147 {
2148 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2149 if (quiet == 0) fflush (stdout);
2150 }
2151 }
2152 }
2153
2154 // loopback
2155
2156 if (loopback)
2157 {
2158 char *loopback_file = data.loopback_file;
2159
2160 FILE *fb_fp = NULL;
2161
2162 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2163 {
2164 lock_file (fb_fp);
2165
2166 format_plain (fb_fp, plain_ptr, plain_len, 1);
2167
2168 fputc ('\n', fb_fp);
2169
2170 fclose (fb_fp);
2171 }
2172 }
2173
2174 // (rule) debug mode
2175
2176 // the next check implies that:
2177 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2178 // - debug_mode > 0
2179
2180 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2181 {
2182 if (debug_rule_len < 0) debug_rule_len = 0;
2183
2184 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2185
2186 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2187
2188 if ((quiet == 0) && (debug_file == NULL))
2189 {
2190 fprintf (stdout, "%s", PROMPT);
2191 fflush (stdout);
2192 }
2193 }
2194 }
2195
2196 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2197 {
2198 salt_t *salt_buf = &data.salts_buf[salt_pos];
2199
2200 int found = 0;
2201
2202 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);
2203
2204 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2205
2206 if (found == 1)
2207 {
2208 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2209
2210 log_info_nn ("");
2211
2212 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);
2213
2214 uint cpt_cracked = 0;
2215
2216 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2217 {
2218 uint idx = salt_buf->digests_offset + digest_pos;
2219
2220 if (data.digests_shown_tmp[idx] == 0) continue;
2221
2222 if (data.digests_shown[idx] == 1) continue;
2223
2224 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2225 {
2226 data.digests_shown[idx] = 1;
2227
2228 data.digests_done++;
2229
2230 cpt_cracked++;
2231
2232 salt_buf->digests_done++;
2233
2234 if (salt_buf->digests_done == salt_buf->digests_cnt)
2235 {
2236 data.salts_shown[salt_pos] = 1;
2237
2238 data.salts_done++;
2239 }
2240 }
2241
2242 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2243
2244 check_hash (device_param, salt_pos, digest_pos);
2245 }
2246
2247 if (cpt_cracked > 0)
2248 {
2249 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2250 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2251
2252 data.cpt_pos++;
2253
2254 data.cpt_total += cpt_cracked;
2255
2256 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2257 }
2258
2259 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2260 {
2261 // we need to reset cracked state on the device
2262 // otherwise host thinks again and again the hash was cracked
2263 // and returns invalid password each time
2264
2265 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2266
2267 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);
2268 }
2269
2270 memset (device_param->result, 0, device_param->size_results);
2271
2272 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);
2273 }
2274 }
2275
2276 static void save_hash ()
2277 {
2278 char *hashfile = data.hashfile;
2279
2280 char new_hashfile[256] = { 0 };
2281 char old_hashfile[256] = { 0 };
2282
2283 snprintf (new_hashfile, 255, "%s.new", hashfile);
2284 snprintf (old_hashfile, 255, "%s.old", hashfile);
2285
2286 unlink (new_hashfile);
2287
2288 char separator = data.separator;
2289
2290 FILE *fp = fopen (new_hashfile, "wb");
2291
2292 if (fp == NULL)
2293 {
2294 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2295
2296 exit (-1);
2297 }
2298
2299 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2300 {
2301 if (data.salts_shown[salt_pos] == 1) continue;
2302
2303 salt_t *salt_buf = &data.salts_buf[salt_pos];
2304
2305 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2306 {
2307 uint idx = salt_buf->digests_offset + digest_pos;
2308
2309 if (data.digests_shown[idx] == 1) continue;
2310
2311 if (data.hash_mode != 2500)
2312 {
2313 char out_buf[HCBUFSIZ] = { 0 };
2314
2315 if (data.username == 1)
2316 {
2317 user_t *user = data.hash_info[idx]->user;
2318
2319 uint i;
2320
2321 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2322
2323 fputc (separator, fp);
2324 }
2325
2326 ascii_digest (out_buf, salt_pos, digest_pos);
2327
2328 fputs (out_buf, fp);
2329
2330 log_out (fp, "");
2331 }
2332 else
2333 {
2334 hccap_t hccap;
2335
2336 to_hccap_t (&hccap, salt_pos, digest_pos);
2337
2338 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2339 }
2340 }
2341 }
2342
2343 fflush (fp);
2344
2345 fclose (fp);
2346
2347 unlink (old_hashfile);
2348
2349 if (rename (hashfile, old_hashfile) != 0)
2350 {
2351 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2352
2353 exit (-1);
2354 }
2355
2356 unlink (hashfile);
2357
2358 if (rename (new_hashfile, hashfile) != 0)
2359 {
2360 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2361
2362 exit (-1);
2363 }
2364
2365 unlink (old_hashfile);
2366 }
2367
2368 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2369 {
2370 // function called only in case kernel_power_all > words_left
2371
2372 float kernel_power_div = (float) (total_left) / kernel_power_all;
2373
2374 kernel_power_div += kernel_power_div / 100;
2375
2376 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2377
2378 while (kernel_power_new < total_left)
2379 {
2380 kernel_power_div += kernel_power_div / 100;
2381
2382 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2383 }
2384
2385 if (data.quiet == 0)
2386 {
2387 clear_prompt ();
2388
2389 log_info ("");
2390
2391 log_info ("INFO: approaching final keyspace, workload adjusted");
2392
2393 log_info ("");
2394
2395 fprintf (stdout, "%s", PROMPT);
2396
2397 fflush (stdout);
2398 }
2399
2400 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2401
2402 return kernel_power_div;
2403 }
2404
2405 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2406 {
2407 uint num_elements = num;
2408
2409 device_param->kernel_params_buf32[30] = data.combs_mode;
2410 device_param->kernel_params_buf32[31] = num;
2411
2412 uint kernel_threads = device_param->kernel_threads;
2413
2414 while (num_elements % kernel_threads) num_elements++;
2415
2416 cl_kernel kernel = NULL;
2417
2418 switch (kern_run)
2419 {
2420 case KERN_RUN_1: kernel = device_param->kernel1; break;
2421 case KERN_RUN_12: kernel = device_param->kernel12; break;
2422 case KERN_RUN_2: kernel = device_param->kernel2; break;
2423 case KERN_RUN_23: kernel = device_param->kernel23; break;
2424 case KERN_RUN_3: kernel = device_param->kernel3; break;
2425 }
2426
2427 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2428 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2429 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2430 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2431 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2432 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2433 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2434 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2435 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2436 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2437 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2438
2439 hc_timer_t timer;
2440
2441 hc_timer_set (&timer);
2442
2443 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2444 {
2445 const size_t global_work_size[3] = { num_elements, 32, 1 };
2446 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2447
2448 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2449 }
2450 else
2451 {
2452 size_t workgroup_size = 0;
2453
2454 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2455
2456 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2457
2458 const size_t global_work_size[3] = { num_elements, 1, 1 };
2459 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2460
2461 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2462 }
2463
2464 hc_clFlush (data.ocl, device_param->command_queue);
2465
2466 hc_clFinish (data.ocl, device_param->command_queue);
2467
2468 if (event_update)
2469 {
2470 float exec_time;
2471
2472 hc_timer_get (timer, exec_time);
2473
2474 uint exec_pos = device_param->exec_pos;
2475
2476 device_param->exec_ms[exec_pos] = exec_time;
2477
2478 exec_pos++;
2479
2480 if (exec_pos == EXEC_CACHE)
2481 {
2482 exec_pos = 0;
2483 }
2484
2485 device_param->exec_pos = exec_pos;
2486 }
2487 }
2488
2489 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2490 {
2491 uint num_elements = num;
2492
2493 switch (kern_run)
2494 {
2495 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2496 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2497 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2498 }
2499
2500 // causes problems with special threads like in bcrypt
2501 // const uint kernel_threads = device_param->kernel_threads;
2502
2503 uint kernel_threads = KERNEL_THREADS;
2504
2505 while (num_elements % kernel_threads) num_elements++;
2506
2507 cl_kernel kernel = NULL;
2508
2509 switch (kern_run)
2510 {
2511 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2512 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2513 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2514 }
2515
2516 switch (kern_run)
2517 {
2518 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2519 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2520 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2521 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2522 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2523 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2524 break;
2525 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2526 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2527 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2528 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2529 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2530 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2531 break;
2532 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2533 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2534 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2535 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2536 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2537 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2538 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2539 break;
2540 }
2541
2542 size_t workgroup_size = 0;
2543 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2544 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2545
2546 const size_t global_work_size[3] = { num_elements, 1, 1 };
2547 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2548
2549 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2550
2551 hc_clFlush (data.ocl, device_param->command_queue);
2552
2553 hc_clFinish (data.ocl, device_param->command_queue);
2554 }
2555
2556 static void run_kernel_tm (hc_device_param_t *device_param)
2557 {
2558 const uint num_elements = 1024; // fixed
2559
2560 uint kernel_threads = 32;
2561
2562 cl_kernel kernel = device_param->kernel_tm;
2563
2564 size_t workgroup_size = 0;
2565 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2566 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2567
2568 const size_t global_work_size[3] = { num_elements, 1, 1 };
2569 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2570
2571 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2572
2573 hc_clFlush (data.ocl, device_param->command_queue);
2574
2575 hc_clFinish (data.ocl, device_param->command_queue);
2576 }
2577
2578 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2579 {
2580 uint num_elements = num;
2581
2582 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2583 device_param->kernel_params_amp_buf32[6] = num_elements;
2584
2585 // causes problems with special threads like in bcrypt
2586 // const uint kernel_threads = device_param->kernel_threads;
2587
2588 uint kernel_threads = KERNEL_THREADS;
2589
2590 while (num_elements % kernel_threads) num_elements++;
2591
2592 cl_kernel kernel = device_param->kernel_amp;
2593
2594 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2595 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2596
2597 size_t workgroup_size = 0;
2598 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2599 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2600
2601 const size_t global_work_size[3] = { num_elements, 1, 1 };
2602 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2603
2604 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2605
2606 hc_clFlush (data.ocl, device_param->command_queue);
2607
2608 hc_clFinish (data.ocl, device_param->command_queue);
2609 }
2610
2611 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2612 {
2613 int rc = -1;
2614
2615 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2616 {
2617 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2618
2619 const cl_uchar zero = 0;
2620
2621 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2622 }
2623
2624 if (rc != 0)
2625 {
2626 // NOTE: clEnqueueFillBuffer () always fails with -59
2627 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2628 // How's that possible, OpenCL 1.2 support is advertised??
2629 // We need to workaround...
2630
2631 #define FILLSZ 0x100000
2632
2633 char *tmp = (char *) mymalloc (FILLSZ);
2634
2635 for (uint i = 0; i < size; i += FILLSZ)
2636 {
2637 const int left = size - i;
2638
2639 const int fillsz = MIN (FILLSZ, left);
2640
2641 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2642 }
2643
2644 myfree (tmp);
2645 }
2646 }
2647
2648 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)
2649 {
2650 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2651 {
2652 if (attack_mode == ATTACK_MODE_BF)
2653 {
2654 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2655 {
2656 const uint size_tm = 32 * sizeof (bs_word_t);
2657
2658 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2659
2660 run_kernel_tm (device_param);
2661
2662 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);
2663 }
2664 }
2665
2666 if (highest_pw_len < 16)
2667 {
2668 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2669 }
2670 else if (highest_pw_len < 32)
2671 {
2672 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2673 }
2674 else
2675 {
2676 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2677 }
2678 }
2679 else
2680 {
2681 run_kernel_amp (device_param, pws_cnt);
2682
2683 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2684
2685 if (opts_type & OPTS_TYPE_HOOK12)
2686 {
2687 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2688 }
2689
2690 uint iter = salt_buf->salt_iter;
2691
2692 uint loop_step = device_param->kernel_loops;
2693
2694 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2695 {
2696 uint loop_left = iter - loop_pos;
2697
2698 loop_left = MIN (loop_left, loop_step);
2699
2700 device_param->kernel_params_buf32[25] = loop_pos;
2701 device_param->kernel_params_buf32[26] = loop_left;
2702
2703 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2704
2705 if (data.devices_status == STATUS_CRACKED) break;
2706 if (data.devices_status == STATUS_ABORTED) break;
2707 if (data.devices_status == STATUS_QUIT) break;
2708 }
2709
2710 if (opts_type & OPTS_TYPE_HOOK23)
2711 {
2712 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2713
2714 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);
2715
2716 // do something with data
2717
2718 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);
2719 }
2720
2721 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2722 }
2723 }
2724
2725 static int run_rule_engine (const int rule_len, const char *rule_buf)
2726 {
2727 if (rule_len == 0)
2728 {
2729 return 0;
2730 }
2731 else if (rule_len == 1)
2732 {
2733 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2734 }
2735
2736 return 1;
2737 }
2738
2739 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2740 {
2741 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2742 {
2743 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);
2744 }
2745 else if (data.attack_kern == ATTACK_KERN_COMBI)
2746 {
2747 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2748 {
2749 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2750 {
2751 for (u32 i = 0; i < pws_cnt; i++)
2752 {
2753 const u32 pw_len = device_param->pws_buf[i].pw_len;
2754
2755 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2756
2757 ptr[pw_len] = 0x01;
2758 }
2759 }
2760 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2761 {
2762 for (u32 i = 0; i < pws_cnt; i++)
2763 {
2764 const u32 pw_len = device_param->pws_buf[i].pw_len;
2765
2766 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2767
2768 ptr[pw_len] = 0x80;
2769 }
2770 }
2771 }
2772
2773 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);
2774 }
2775 else if (data.attack_kern == ATTACK_KERN_BF)
2776 {
2777 const u64 off = device_param->words_off;
2778
2779 device_param->kernel_params_mp_l_buf64[3] = off;
2780
2781 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2782 }
2783 }
2784
2785 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2786 {
2787 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2788
2789 device_param->kernel_params_buf32[26] = kernel_loops;
2790 device_param->kernel_params_buf32[27] = kernel_loops;
2791
2792 // init some fake words
2793
2794 for (u32 i = 0; i < kernel_power; i++)
2795 {
2796 device_param->pws_buf[i].i[0] = i;
2797 device_param->pws_buf[i].i[1] = 0x01234567;
2798 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2799 }
2800
2801 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);
2802
2803 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2804 {
2805 run_kernel_amp (device_param, kernel_power);
2806 }
2807
2808 // caching run
2809
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2817 }
2818
2819 // now user repeats
2820
2821 for (int i = 0; i < repeat; i++)
2822 {
2823 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2824 {
2825 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2826 }
2827 else
2828 {
2829 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2830 }
2831 }
2832
2833 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2834
2835 // reset fake words
2836
2837 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2838
2839 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);
2840 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);
2841
2842 return exec_ms_prev;
2843 }
2844
2845 static void autotune (hc_device_param_t *device_param)
2846 {
2847 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2848
2849 const u32 kernel_accel_min = device_param->kernel_accel_min;
2850 const u32 kernel_accel_max = device_param->kernel_accel_max;
2851
2852 const u32 kernel_loops_min = device_param->kernel_loops_min;
2853 const u32 kernel_loops_max = device_param->kernel_loops_max;
2854
2855 u32 kernel_accel = kernel_accel_min;
2856 u32 kernel_loops = kernel_loops_min;
2857
2858 // steps
2859
2860 #define STEPS_CNT 10
2861
2862 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2863 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2864
2865 u32 steps_accel[STEPS_ACCEL_CNT];
2866 u32 steps_loops[STEPS_LOOPS_CNT];
2867
2868 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2869 {
2870 steps_accel[i] = 1 << i;
2871 }
2872
2873 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2874 {
2875 steps_loops[i] = 1 << i;
2876 }
2877
2878 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2879 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2880
2881 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2882 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2883
2884 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2885 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2886
2887 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2888
2889 u32 kernel_loops_tmp;
2890
2891 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2892 {
2893 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2894
2895 if (exec_ms < target_ms) break;
2896 }
2897
2898 // kernel-accel
2899
2900 if (kernel_accel_min < kernel_accel_max)
2901 {
2902 double e_best = 0;
2903
2904 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2905 {
2906 const u32 kernel_accel_try = steps_accel[i];
2907
2908 if (kernel_accel_try < kernel_accel_min) continue;
2909 if (kernel_accel_try > kernel_accel_max) break;
2910
2911 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2912
2913 if (exec_ms > target_ms) break;
2914
2915 const double e = kernel_accel_try / exec_ms;
2916
2917 if (e > e_best)
2918 {
2919 kernel_accel = kernel_accel_try;
2920
2921 e_best = e;
2922 }
2923 }
2924 }
2925
2926 // kernel-loops final
2927
2928 if (kernel_loops_min < kernel_loops_max)
2929 {
2930 double e_best = 0;
2931
2932 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2933 {
2934 const u32 kernel_loops_try = steps_loops[i];
2935
2936 if (kernel_loops_try < kernel_loops_min) continue;
2937 if (kernel_loops_try > kernel_loops_max) break;
2938
2939 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2940
2941 if (exec_ms > target_ms) break;
2942
2943 const double e = kernel_loops_try / exec_ms;
2944
2945 if (e > e_best)
2946 {
2947 kernel_loops = kernel_loops_try;
2948
2949 e_best = e;
2950 }
2951 }
2952 }
2953
2954 // final balance
2955
2956 u32 kernel_accel_best = kernel_accel;
2957 u32 kernel_loops_best = kernel_loops;
2958
2959 u32 exec_best = -1;
2960
2961 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2962 {
2963 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2964
2965 exec_best = exec_ms;
2966 }
2967
2968 // reset
2969
2970 if (kernel_accel_min < kernel_accel_max)
2971 {
2972 u32 kernel_accel_try = kernel_accel;
2973 u32 kernel_loops_try = kernel_loops;
2974
2975 for (int i = 0; i < 2; i++)
2976 {
2977 kernel_accel_try >>= 1;
2978 kernel_loops_try <<= 1;
2979
2980 if (kernel_accel_try < kernel_accel_min) break;
2981 if (kernel_loops_try > kernel_loops_max) break;
2982
2983 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2984
2985 if (exec_ms < exec_best)
2986 {
2987 kernel_accel_best = kernel_accel_try;
2988 kernel_loops_best = kernel_loops_try;
2989
2990 exec_best = exec_ms;
2991 }
2992 }
2993 }
2994
2995 // reset
2996
2997 if (kernel_loops_min < kernel_loops_max)
2998 {
2999 u32 kernel_accel_try = kernel_accel;
3000 u32 kernel_loops_try = kernel_loops;
3001
3002 for (int i = 0; i < 2; i++)
3003 {
3004 kernel_accel_try <<= 1;
3005 kernel_loops_try >>= 1;
3006
3007 if (kernel_accel_try > kernel_accel_max) break;
3008 if (kernel_loops_try < kernel_loops_min) break;
3009
3010 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3011
3012 if (exec_ms < exec_best)
3013 {
3014 kernel_accel_best = kernel_accel_try;
3015 kernel_loops_best = kernel_loops_try;
3016
3017 exec_best = exec_ms;
3018 }
3019 }
3020 }
3021
3022 // reset timer
3023
3024 device_param->exec_pos = 0;
3025
3026 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3027
3028 // store
3029
3030 kernel_accel = kernel_accel_best;
3031 kernel_loops = kernel_loops_best;
3032
3033 device_param->kernel_accel = kernel_accel;
3034 device_param->kernel_loops = kernel_loops;
3035
3036 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3037
3038 device_param->kernel_power = kernel_power;
3039
3040 #ifdef DEBUG
3041
3042 if (data.quiet == 0)
3043 {
3044 clear_prompt ();
3045
3046 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3047 "Device #%u: autotuned kernel-loops to %u\n",
3048 device_param->device_id + 1,
3049 kernel_accel,
3050 device_param->device_id + 1,
3051 kernel_loops);
3052
3053 fprintf (stdout, "%s", PROMPT);
3054 fflush (stdout);
3055 }
3056
3057 #endif
3058 }
3059
3060 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3061 {
3062 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3063
3064 // init speed timer
3065
3066 uint speed_pos = device_param->speed_pos;
3067
3068 #ifdef _POSIX
3069 if (device_param->timer_speed.tv_sec == 0)
3070 {
3071 hc_timer_set (&device_param->timer_speed);
3072 }
3073 #endif
3074
3075 #ifdef _WIN
3076 if (device_param->timer_speed.QuadPart == 0)
3077 {
3078 hc_timer_set (&device_param->timer_speed);
3079 }
3080 #endif
3081
3082 // find higest password length, this is for optimization stuff
3083
3084 uint highest_pw_len = 0;
3085
3086 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3087 {
3088 }
3089 else if (data.attack_kern == ATTACK_KERN_COMBI)
3090 {
3091 }
3092 else if (data.attack_kern == ATTACK_KERN_BF)
3093 {
3094 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3095 + device_param->kernel_params_mp_l_buf32[5];
3096 }
3097
3098 // iteration type
3099
3100 uint innerloop_step = 0;
3101 uint innerloop_cnt = 0;
3102
3103 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3104 else innerloop_step = 1;
3105
3106 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3107 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3109
3110 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3111
3112 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3113 {
3114 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3115
3116 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3117
3118 if (data.devices_status == STATUS_CRACKED) break;
3119 if (data.devices_status == STATUS_ABORTED) break;
3120 if (data.devices_status == STATUS_QUIT) break;
3121 if (data.devices_status == STATUS_BYPASS) break;
3122
3123 salt_t *salt_buf = &data.salts_buf[salt_pos];
3124
3125 device_param->kernel_params_buf32[24] = salt_pos;
3126 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3127 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3128
3129 FILE *combs_fp = device_param->combs_fp;
3130
3131 if (data.attack_mode == ATTACK_MODE_COMBI)
3132 {
3133 rewind (combs_fp);
3134 }
3135
3136 // innerloops
3137
3138 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3139 {
3140 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3141
3142 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3143
3144 if (data.devices_status == STATUS_CRACKED) break;
3145 if (data.devices_status == STATUS_ABORTED) break;
3146 if (data.devices_status == STATUS_QUIT) break;
3147 if (data.devices_status == STATUS_BYPASS) break;
3148
3149 uint innerloop_left = innerloop_cnt - innerloop_pos;
3150
3151 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3152
3153 device_param->innerloop_pos = innerloop_pos;
3154 device_param->innerloop_left = innerloop_left;
3155
3156 device_param->kernel_params_buf32[27] = innerloop_left;
3157
3158 // i think we can get rid of this
3159 if (innerloop_left == 0)
3160 {
3161 puts ("bug, how should this happen????\n");
3162
3163 continue;
3164 }
3165
3166 if (data.salts_shown[salt_pos] == 1)
3167 {
3168 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3169
3170 continue;
3171 }
3172
3173 // initialize amplifiers
3174
3175 if (data.attack_mode == ATTACK_MODE_COMBI)
3176 {
3177 uint i = 0;
3178
3179 while (i < innerloop_left)
3180 {
3181 if (feof (combs_fp)) break;
3182
3183 int line_len = fgetl (combs_fp, line_buf);
3184
3185 if (line_len >= PW_MAX1) continue;
3186
3187 line_len = convert_from_hex (line_buf, line_len);
3188
3189 char *line_buf_new = line_buf;
3190
3191 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3192 {
3193 char rule_buf_out[BLOCK_SIZE] = { 0 };
3194
3195 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3196
3197 if (rule_len_out < 0)
3198 {
3199 data.words_progress_rejected[salt_pos] += pws_cnt;
3200
3201 continue;
3202 }
3203
3204 line_len = rule_len_out;
3205
3206 line_buf_new = rule_buf_out;
3207 }
3208
3209 line_len = MIN (line_len, PW_DICTMAX);
3210
3211 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3212
3213 memcpy (ptr, line_buf_new, line_len);
3214
3215 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3216
3217 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3218 {
3219 uppercase (ptr, line_len);
3220 }
3221
3222 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3223 {
3224 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3225 {
3226 ptr[line_len] = 0x80;
3227 }
3228
3229 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3230 {
3231 ptr[line_len] = 0x01;
3232 }
3233 }
3234
3235 device_param->combs_buf[i].pw_len = line_len;
3236
3237 i++;
3238 }
3239
3240 for (uint j = i; j < innerloop_left; j++)
3241 {
3242 device_param->combs_buf[j].i[0] = 0;
3243 device_param->combs_buf[j].i[1] = 0;
3244 device_param->combs_buf[j].i[2] = 0;
3245 device_param->combs_buf[j].i[3] = 0;
3246 device_param->combs_buf[j].i[4] = 0;
3247 device_param->combs_buf[j].i[5] = 0;
3248 device_param->combs_buf[j].i[6] = 0;
3249 device_param->combs_buf[j].i[7] = 0;
3250
3251 device_param->combs_buf[j].pw_len = 0;
3252 }
3253
3254 innerloop_left = i;
3255 }
3256 else if (data.attack_mode == ATTACK_MODE_BF)
3257 {
3258 u64 off = innerloop_pos;
3259
3260 device_param->kernel_params_mp_r_buf64[3] = off;
3261
3262 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3265 {
3266 u64 off = innerloop_pos;
3267
3268 device_param->kernel_params_mp_buf64[3] = off;
3269
3270 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3271 }
3272 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3273 {
3274 u64 off = innerloop_pos;
3275
3276 device_param->kernel_params_mp_buf64[3] = off;
3277
3278 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3279 }
3280
3281 // copy amplifiers
3282
3283 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3284 {
3285 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);
3286 }
3287 else if (data.attack_mode == ATTACK_MODE_COMBI)
3288 {
3289 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);
3290 }
3291 else if (data.attack_mode == ATTACK_MODE_BF)
3292 {
3293 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);
3294 }
3295 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3296 {
3297 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);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3300 {
3301 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);
3302 }
3303
3304 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3305
3306 if (data.benchmark == 1)
3307 {
3308 for (u32 i = 0; i < data.benchmark_repeats; i++)
3309 {
3310 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3311 }
3312 }
3313
3314 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3315
3316 if (data.devices_status == STATUS_CRACKED) break;
3317 if (data.devices_status == STATUS_ABORTED) break;
3318 if (data.devices_status == STATUS_QUIT) break;
3319
3320 /**
3321 * result
3322 */
3323
3324 hc_thread_mutex_lock (mux_display);
3325
3326 check_cracked (device_param, salt_pos);
3327
3328 hc_thread_mutex_unlock (mux_display);
3329
3330 /**
3331 * progress
3332 */
3333
3334 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3335
3336 if (data.benchmark == 1)
3337 {
3338 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3339 }
3340
3341 hc_thread_mutex_lock (mux_counter);
3342
3343 data.words_progress_done[salt_pos] += perf_sum_all;
3344
3345 hc_thread_mutex_unlock (mux_counter);
3346
3347 /**
3348 * speed
3349 */
3350
3351 float speed_ms;
3352
3353 hc_timer_get (device_param->timer_speed, speed_ms);
3354
3355 hc_timer_set (&device_param->timer_speed);
3356
3357 hc_thread_mutex_lock (mux_display);
3358
3359 device_param->speed_cnt[speed_pos] = perf_sum_all;
3360
3361 device_param->speed_ms[speed_pos] = speed_ms;
3362
3363 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3364
3365 hc_thread_mutex_unlock (mux_display);
3366
3367 speed_pos++;
3368
3369 if (speed_pos == SPEED_CACHE)
3370 {
3371 speed_pos = 0;
3372 }
3373
3374 /**
3375 * benchmark
3376 */
3377
3378 if (data.benchmark == 1) break;
3379 }
3380 }
3381
3382 device_param->speed_pos = speed_pos;
3383
3384 myfree (line_buf);
3385 }
3386
3387 static void load_segment (wl_data_t *wl_data, FILE *fd)
3388 {
3389 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3390
3391 wl_data->pos = 0;
3392
3393 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3394
3395 wl_data->buf[wl_data->cnt] = 0;
3396
3397 if (wl_data->cnt == 0) return;
3398
3399 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3400
3401 while (!feof (fd))
3402 {
3403 if (wl_data->cnt == wl_data->avail)
3404 {
3405 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3406
3407 wl_data->avail += wl_data->incr;
3408 }
3409
3410 const int c = fgetc (fd);
3411
3412 if (c == EOF) break;
3413
3414 wl_data->buf[wl_data->cnt] = (char) c;
3415
3416 wl_data->cnt++;
3417
3418 if (c == '\n') break;
3419 }
3420
3421 // ensure stream ends with a newline
3422
3423 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3424 {
3425 wl_data->cnt++;
3426
3427 wl_data->buf[wl_data->cnt - 1] = '\n';
3428 }
3429
3430 return;
3431 }
3432
3433 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3434 {
3435 char *ptr = buf;
3436
3437 for (u32 i = 0; i < sz; i++, ptr++)
3438 {
3439 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3440
3441 if (i == 7)
3442 {
3443 *off = i;
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 if (*ptr != '\n') continue;
3450
3451 *off = i + 1;
3452
3453 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3454
3455 *len = i;
3456
3457 return;
3458 }
3459
3460 *off = sz;
3461 *len = sz;
3462 }
3463
3464 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3465 {
3466 char *ptr = buf;
3467
3468 for (u32 i = 0; i < sz; i++, ptr++)
3469 {
3470 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3471
3472 if (*ptr != '\n') continue;
3473
3474 *off = i + 1;
3475
3476 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3477
3478 *len = i;
3479
3480 return;
3481 }
3482
3483 *off = sz;
3484 *len = sz;
3485 }
3486
3487 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3488 {
3489 char *ptr = buf;
3490
3491 for (u32 i = 0; i < sz; i++, ptr++)
3492 {
3493 if (*ptr != '\n') continue;
3494
3495 *off = i + 1;
3496
3497 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3498
3499 *len = i;
3500
3501 return;
3502 }
3503
3504 *off = sz;
3505 *len = sz;
3506 }
3507
3508 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3509 {
3510 while (wl_data->pos < wl_data->cnt)
3511 {
3512 uint off;
3513 uint len;
3514
3515 char *ptr = wl_data->buf + wl_data->pos;
3516
3517 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3518
3519 wl_data->pos += off;
3520
3521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3522 {
3523 char rule_buf_out[BLOCK_SIZE] = { 0 };
3524
3525 int rule_len_out = -1;
3526
3527 if (len < BLOCK_SIZE)
3528 {
3529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3530 }
3531
3532 if (rule_len_out < 0)
3533 {
3534 continue;
3535 }
3536
3537 if (rule_len_out > PW_MAX)
3538 {
3539 continue;
3540 }
3541 }
3542 else
3543 {
3544 if (len > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549
3550 *out_buf = ptr;
3551 *out_len = len;
3552
3553 return;
3554 }
3555
3556 if (feof (fd))
3557 {
3558 fprintf (stderr, "BUG feof()!!\n");
3559
3560 return;
3561 }
3562
3563 load_segment (wl_data, fd);
3564
3565 get_next_word (wl_data, fd, out_buf, out_len);
3566 }
3567
3568 #ifdef _POSIX
3569 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3570 #endif
3571
3572 #ifdef _WIN
3573 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3574 #endif
3575 {
3576 hc_signal (NULL);
3577
3578 dictstat_t d;
3579
3580 d.cnt = 0;
3581
3582 #ifdef _POSIX
3583 fstat (fileno (fd), &d.stat);
3584 #endif
3585
3586 #ifdef _WIN
3587 _fstat64 (fileno (fd), &d.stat);
3588 #endif
3589
3590 d.stat.st_mode = 0;
3591 d.stat.st_nlink = 0;
3592 d.stat.st_uid = 0;
3593 d.stat.st_gid = 0;
3594 d.stat.st_rdev = 0;
3595 d.stat.st_atime = 0;
3596
3597 #ifdef _POSIX
3598 d.stat.st_blksize = 0;
3599 d.stat.st_blocks = 0;
3600 #endif
3601
3602 if (d.stat.st_size == 0) return 0;
3603
3604 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3605
3606 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3607 {
3608 if (d_cache)
3609 {
3610 u64 cnt = d_cache->cnt;
3611
3612 u64 keyspace = cnt;
3613
3614 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3615 {
3616 keyspace *= data.kernel_rules_cnt;
3617 }
3618 else if (data.attack_kern == ATTACK_KERN_COMBI)
3619 {
3620 keyspace *= data.combs_cnt;
3621 }
3622
3623 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);
3624 if (data.quiet == 0) log_info ("");
3625
3626 hc_signal (sigHandler_default);
3627
3628 return (keyspace);
3629 }
3630 }
3631
3632 time_t now = 0;
3633 time_t prev = 0;
3634
3635 u64 comp = 0;
3636 u64 cnt = 0;
3637 u64 cnt2 = 0;
3638
3639 while (!feof (fd))
3640 {
3641 load_segment (wl_data, fd);
3642
3643 comp += wl_data->cnt;
3644
3645 u32 i = 0;
3646
3647 while (i < wl_data->cnt)
3648 {
3649 u32 len;
3650 u32 off;
3651
3652 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3653
3654 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3655 {
3656 char rule_buf_out[BLOCK_SIZE] = { 0 };
3657
3658 int rule_len_out = -1;
3659
3660 if (len < BLOCK_SIZE)
3661 {
3662 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3663 }
3664
3665 if (rule_len_out < 0)
3666 {
3667 len = PW_MAX1;
3668 }
3669 else
3670 {
3671 len = rule_len_out;
3672 }
3673 }
3674
3675 if (len < PW_MAX1)
3676 {
3677 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3678 {
3679 cnt += data.kernel_rules_cnt;
3680 }
3681 else if (data.attack_kern == ATTACK_KERN_COMBI)
3682 {
3683 cnt += data.combs_cnt;
3684 }
3685
3686 d.cnt++;
3687 }
3688
3689 i += off;
3690
3691 cnt2++;
3692 }
3693
3694 time (&now);
3695
3696 if ((now - prev) == 0) continue;
3697
3698 float percent = (float) comp / (float) d.stat.st_size;
3699
3700 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);
3701
3702 time (&prev);
3703 }
3704
3705 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);
3706 if (data.quiet == 0) log_info ("");
3707
3708 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3709
3710 hc_signal (sigHandler_default);
3711
3712 return (cnt);
3713 }
3714
3715 static void *thread_monitor (void *p)
3716 {
3717 uint runtime_check = 0;
3718 uint remove_check = 0;
3719 uint status_check = 0;
3720 uint restore_check = 0;
3721
3722 uint restore_left = data.restore_timer;
3723 uint remove_left = data.remove_timer;
3724 uint status_left = data.status_timer;
3725
3726 #ifdef HAVE_HWMON
3727 uint hwmon_check = 0;
3728
3729 // these variables are mainly used for fan control (AMD only)
3730
3731 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 // temperature controller "loopback" values
3734
3735 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3736 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3737
3738 #ifdef HAVE_ADL
3739 int temp_threshold = 1; // degrees celcius
3740
3741 int fan_speed_min = 15; // in percentage
3742 int fan_speed_max = 100;
3743 #endif // HAVE_ADL
3744
3745 time_t last_temp_check_time;
3746 #endif // HAVE_HWMON
3747
3748 uint sleep_time = 1;
3749
3750 if (data.runtime)
3751 {
3752 runtime_check = 1;
3753 }
3754
3755 if (data.restore_timer)
3756 {
3757 restore_check = 1;
3758 }
3759
3760 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3761 {
3762 remove_check = 1;
3763 }
3764
3765 if (data.status == 1)
3766 {
3767 status_check = 1;
3768 }
3769
3770 #ifdef HAVE_HWMON
3771 if (data.gpu_temp_disable == 0)
3772 {
3773 time (&last_temp_check_time);
3774
3775 hwmon_check = 1;
3776 }
3777 #endif
3778
3779 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3780 {
3781 #ifdef HAVE_HWMON
3782 if (hwmon_check == 0)
3783 #endif
3784 return (p);
3785 }
3786
3787 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3788 {
3789 hc_sleep (sleep_time);
3790
3791 if (data.devices_status != STATUS_RUNNING) continue;
3792
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 1)
3795 {
3796 hc_thread_mutex_lock (mux_adl);
3797
3798 time_t temp_check_time;
3799
3800 time (&temp_check_time);
3801
3802 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3803
3804 if (Ta == 0) Ta = 1;
3805
3806 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3807 {
3808 hc_device_param_t *device_param = &data.devices_param[device_id];
3809
3810 if (device_param->skipped) continue;
3811
3812 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3813
3814 const int temperature = hm_get_temperature_with_device_id (device_id);
3815
3816 if (temperature > (int) data.gpu_temp_abort)
3817 {
3818 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3819
3820 if (data.devices_status != STATUS_QUIT) myabort ();
3821
3822 break;
3823 }
3824
3825 #ifdef HAVE_ADL
3826 const int gpu_temp_retain = data.gpu_temp_retain;
3827
3828 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3829 {
3830 if (data.hm_device[device_id].fan_supported == 1)
3831 {
3832 int temp_cur = temperature;
3833
3834 int temp_diff_new = gpu_temp_retain - temp_cur;
3835
3836 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3837
3838 // calculate Ta value (time difference in seconds between the last check and this check)
3839
3840 last_temp_check_time = temp_check_time;
3841
3842 float Kp = 1.8;
3843 float Ki = 0.005;
3844 float Kd = 6;
3845
3846 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3847
3848 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);
3849
3850 if (abs (fan_diff_required) >= temp_threshold)
3851 {
3852 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3853
3854 int fan_speed_level = fan_speed_cur;
3855
3856 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3857
3858 int fan_speed_new = fan_speed_level - fan_diff_required;
3859
3860 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3861 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3862
3863 if (fan_speed_new != fan_speed_cur)
3864 {
3865 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3866 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3867
3868 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3869 {
3870 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3871
3872 fan_speed_chgd[device_id] = 1;
3873 }
3874
3875 temp_diff_old[device_id] = temp_diff_new;
3876 }
3877 }
3878 }
3879 }
3880 #endif // HAVE_ADL
3881 }
3882
3883 hc_thread_mutex_unlock (mux_adl);
3884 }
3885 #endif // HAVE_HWMON
3886
3887 if (restore_check == 1)
3888 {
3889 restore_left--;
3890
3891 if (restore_left == 0)
3892 {
3893 if (data.restore_disable == 0) cycle_restore ();
3894
3895 restore_left = data.restore_timer;
3896 }
3897 }
3898
3899 if ((runtime_check == 1) && (data.runtime_start > 0))
3900 {
3901 time_t runtime_cur;
3902
3903 time (&runtime_cur);
3904
3905 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3906
3907 if (runtime_left <= 0)
3908 {
3909 if (data.benchmark == 0)
3910 {
3911 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3912 }
3913
3914 if (data.devices_status != STATUS_QUIT) myabort ();
3915 }
3916 }
3917
3918 if (remove_check == 1)
3919 {
3920 remove_left--;
3921
3922 if (remove_left == 0)
3923 {
3924 if (data.digests_saved != data.digests_done)
3925 {
3926 data.digests_saved = data.digests_done;
3927
3928 save_hash ();
3929 }
3930
3931 remove_left = data.remove_timer;
3932 }
3933 }
3934
3935 if (status_check == 1)
3936 {
3937 status_left--;
3938
3939 if (status_left == 0)
3940 {
3941 hc_thread_mutex_lock (mux_display);
3942
3943 if (data.quiet == 0) clear_prompt ();
3944
3945 if (data.quiet == 0) log_info ("");
3946
3947 status_display ();
3948
3949 if (data.quiet == 0) log_info ("");
3950
3951 hc_thread_mutex_unlock (mux_display);
3952
3953 status_left = data.status_timer;
3954 }
3955 }
3956 }
3957
3958 #ifdef HAVE_HWMON
3959 myfree (fan_speed_chgd);
3960
3961 myfree (temp_diff_old);
3962 myfree (temp_diff_sum);
3963 #endif
3964
3965 p = NULL;
3966
3967 return (p);
3968 }
3969
3970 static void *thread_outfile_remove (void *p)
3971 {
3972 // some hash-dependent constants
3973 char *outfile_dir = data.outfile_check_directory;
3974 uint dgst_size = data.dgst_size;
3975 uint isSalted = data.isSalted;
3976 uint esalt_size = data.esalt_size;
3977 uint hash_mode = data.hash_mode;
3978
3979 uint outfile_check_timer = data.outfile_check_timer;
3980
3981 char separator = data.separator;
3982
3983 // some hash-dependent functions
3984 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3985 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3986
3987 // buffers
3988 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3989
3990 hash_buf.digest = mymalloc (dgst_size);
3991
3992 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3993
3994 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3995
3996 uint digest_buf[64] = { 0 };
3997
3998 outfile_data_t *out_info = NULL;
3999
4000 char **out_files = NULL;
4001
4002 time_t folder_mtime = 0;
4003
4004 int out_cnt = 0;
4005
4006 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4007
4008 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4009 {
4010 hc_sleep (1);
4011
4012 if (data.devices_status != STATUS_RUNNING) continue;
4013
4014 check_left--;
4015
4016 if (check_left == 0)
4017 {
4018 struct stat outfile_check_stat;
4019
4020 if (stat (outfile_dir, &outfile_check_stat) == 0)
4021 {
4022 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4023
4024 if (is_dir == 1)
4025 {
4026 if (outfile_check_stat.st_mtime > folder_mtime)
4027 {
4028 char **out_files_new = scan_directory (outfile_dir);
4029
4030 int out_cnt_new = count_dictionaries (out_files_new);
4031
4032 outfile_data_t *out_info_new = NULL;
4033
4034 if (out_cnt_new > 0)
4035 {
4036 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4037
4038 for (int i = 0; i < out_cnt_new; i++)
4039 {
4040 out_info_new[i].file_name = out_files_new[i];
4041
4042 // check if there are files that we have seen/checked before (and not changed)
4043
4044 for (int j = 0; j < out_cnt; j++)
4045 {
4046 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4047 {
4048 struct stat outfile_stat;
4049
4050 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4051 {
4052 if (outfile_stat.st_ctime == out_info[j].ctime)
4053 {
4054 out_info_new[i].ctime = out_info[j].ctime;
4055 out_info_new[i].seek = out_info[j].seek;
4056 }
4057 }
4058 }
4059 }
4060 }
4061 }
4062
4063 local_free (out_info);
4064 local_free (out_files);
4065
4066 out_files = out_files_new;
4067 out_cnt = out_cnt_new;
4068 out_info = out_info_new;
4069
4070 folder_mtime = outfile_check_stat.st_mtime;
4071 }
4072
4073 for (int j = 0; j < out_cnt; j++)
4074 {
4075 FILE *fp = fopen (out_info[j].file_name, "rb");
4076
4077 if (fp != NULL)
4078 {
4079 //hc_thread_mutex_lock (mux_display);
4080
4081 #ifdef _POSIX
4082 struct stat outfile_stat;
4083
4084 fstat (fileno (fp), &outfile_stat);
4085 #endif
4086
4087 #ifdef _WIN
4088 struct stat64 outfile_stat;
4089
4090 _fstat64 (fileno (fp), &outfile_stat);
4091 #endif
4092
4093 if (outfile_stat.st_ctime > out_info[j].ctime)
4094 {
4095 out_info[j].ctime = outfile_stat.st_ctime;
4096 out_info[j].seek = 0;
4097 }
4098
4099 fseek (fp, out_info[j].seek, SEEK_SET);
4100
4101 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4102
4103 while (!feof (fp))
4104 {
4105 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4106
4107 if (ptr == NULL) break;
4108
4109 int line_len = strlen (line_buf);
4110
4111 if (line_len <= 0) continue;
4112
4113 int iter = MAX_CUT_TRIES;
4114
4115 for (uint i = line_len - 1; i && iter; i--, line_len--)
4116 {
4117 if (line_buf[i] != separator) continue;
4118
4119 int parser_status = PARSER_OK;
4120
4121 if ((hash_mode != 2500) && (hash_mode != 6800))
4122 {
4123 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4124 }
4125
4126 uint found = 0;
4127
4128 if (parser_status == PARSER_OK)
4129 {
4130 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4131 {
4132 if (data.salts_shown[salt_pos] == 1) continue;
4133
4134 salt_t *salt_buf = &data.salts_buf[salt_pos];
4135
4136 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4137 {
4138 uint idx = salt_buf->digests_offset + digest_pos;
4139
4140 if (data.digests_shown[idx] == 1) continue;
4141
4142 uint cracked = 0;
4143
4144 if (hash_mode == 6800)
4145 {
4146 if (i == salt_buf->salt_len)
4147 {
4148 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4149 }
4150 }
4151 else if (hash_mode == 2500)
4152 {
4153 // BSSID : MAC1 : MAC2 (:plain)
4154 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4155 {
4156 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4157
4158 if (!cracked) continue;
4159
4160 // now compare MAC1 and MAC2 too, since we have this additional info
4161 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4162 char *mac2_pos = mac1_pos + 12 + 1;
4163
4164 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4165 wpa_t *wpa = &wpas[salt_pos];
4166
4167 // compare hex string(s) vs binary MAC address(es)
4168
4169 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4170 {
4171 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4172 {
4173 cracked = 0;
4174
4175 break;
4176 }
4177 }
4178
4179 // early skip ;)
4180 if (!cracked) continue;
4181
4182 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4183 {
4184 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4185 {
4186 cracked = 0;
4187
4188 break;
4189 }
4190 }
4191 }
4192 }
4193 else
4194 {
4195 char *digests_buf_ptr = (char *) data.digests_buf;
4196
4197 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4198
4199 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4200 }
4201
4202 if (cracked == 1)
4203 {
4204 found = 1;
4205
4206 data.digests_shown[idx] = 1;
4207
4208 data.digests_done++;
4209
4210 salt_buf->digests_done++;
4211
4212 if (salt_buf->digests_done == salt_buf->digests_cnt)
4213 {
4214 data.salts_shown[salt_pos] = 1;
4215
4216 data.salts_done++;
4217
4218 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4219 }
4220 }
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225 }
4226
4227 if (found) break;
4228
4229 if (data.devices_status == STATUS_CRACKED) break;
4230
4231 iter--;
4232 }
4233
4234 if (data.devices_status == STATUS_CRACKED) break;
4235 }
4236
4237 myfree (line_buf);
4238
4239 out_info[j].seek = ftell (fp);
4240
4241 //hc_thread_mutex_unlock (mux_display);
4242
4243 fclose (fp);
4244 }
4245 }
4246 }
4247 }
4248
4249 check_left = outfile_check_timer;
4250 }
4251 }
4252
4253 if (esalt_size) local_free (hash_buf.esalt);
4254
4255 if (isSalted) local_free (hash_buf.salt);
4256
4257 local_free (hash_buf.digest);
4258
4259 local_free (out_info);
4260
4261 local_free (out_files);
4262
4263 p = NULL;
4264
4265 return (p);
4266 }
4267
4268 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4269 {
4270 if (device_param->pws_cnt < device_param->kernel_power)
4271 {
4272 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4273
4274 u8 *ptr = (u8 *) pw->i;
4275
4276 memcpy (ptr, pw_buf, pw_len);
4277
4278 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4279
4280 pw->pw_len = pw_len;
4281
4282 device_param->pws_cnt++;
4283 }
4284 else
4285 {
4286 fprintf (stderr, "BUG pw_add()!!\n");
4287
4288 return;
4289 }
4290 }
4291
4292 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4293 {
4294 hc_thread_mutex_lock (mux_dispatcher);
4295
4296 const u64 words_cur = data.words_cur;
4297 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4298
4299 device_param->words_off = words_cur;
4300
4301 const u64 words_left = words_base - words_cur;
4302
4303 if (allow_div)
4304 {
4305 if (data.kernel_power_all > words_left)
4306 {
4307 if (data.kernel_power_div == 0)
4308 {
4309 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4310 }
4311 }
4312
4313 if (data.kernel_power_div)
4314 {
4315 if (device_param->kernel_power == device_param->kernel_power_user)
4316 {
4317 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4318
4319 if (kernel_power_new < device_param->kernel_power)
4320 {
4321 device_param->kernel_power = kernel_power_new;
4322 }
4323 }
4324 }
4325 }
4326
4327 const uint kernel_power = device_param->kernel_power;
4328
4329 uint work = MIN (words_left, kernel_power);
4330
4331 work = MIN (work, max);
4332
4333 data.words_cur += work;
4334
4335 hc_thread_mutex_unlock (mux_dispatcher);
4336
4337 return work;
4338 }
4339
4340 static void *thread_calc_stdin (void *p)
4341 {
4342 hc_device_param_t *device_param = (hc_device_param_t *) p;
4343
4344 if (device_param->skipped) return NULL;
4345
4346 autotune (device_param);
4347
4348 char *buf = (char *) mymalloc (HCBUFSIZ);
4349
4350 const uint attack_kern = data.attack_kern;
4351
4352 const uint kernel_power = device_param->kernel_power;
4353
4354 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4355 {
4356 hc_thread_mutex_lock (mux_dispatcher);
4357
4358 if (feof (stdin) != 0)
4359 {
4360 hc_thread_mutex_unlock (mux_dispatcher);
4361
4362 break;
4363 }
4364
4365 uint words_cur = 0;
4366
4367 while (words_cur < kernel_power)
4368 {
4369 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4370
4371 if (line_buf == NULL) break;
4372
4373 uint line_len = in_superchop (line_buf);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (line_len > PW_MAX)
4397 {
4398 continue;
4399 }
4400
4401 if (attack_kern == ATTACK_KERN_STRAIGHT)
4402 {
4403 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4404 {
4405 hc_thread_mutex_lock (mux_counter);
4406
4407 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4408 {
4409 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4410 }
4411
4412 hc_thread_mutex_unlock (mux_counter);
4413
4414 continue;
4415 }
4416 }
4417 else if (attack_kern == ATTACK_KERN_COMBI)
4418 {
4419 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4420 // since we still need to combine the plains
4421
4422 if (line_len > data.pw_max)
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436
4437 pw_add (device_param, (u8 *) line_buf, line_len);
4438
4439 words_cur++;
4440
4441 if (data.devices_status == STATUS_CRACKED) break;
4442 if (data.devices_status == STATUS_ABORTED) break;
4443 if (data.devices_status == STATUS_QUIT) break;
4444 if (data.devices_status == STATUS_BYPASS) break;
4445 }
4446
4447 hc_thread_mutex_unlock (mux_dispatcher);
4448
4449 if (data.devices_status == STATUS_CRACKED) break;
4450 if (data.devices_status == STATUS_ABORTED) break;
4451 if (data.devices_status == STATUS_QUIT) break;
4452 if (data.devices_status == STATUS_BYPASS) break;
4453
4454 // flush
4455
4456 const uint pws_cnt = device_param->pws_cnt;
4457
4458 if (pws_cnt)
4459 {
4460 run_copy (device_param, pws_cnt);
4461
4462 run_cracker (device_param, pws_cnt);
4463
4464 device_param->pws_cnt = 0;
4465
4466 if (attack_kern == ATTACK_KERN_STRAIGHT)
4467 {
4468 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4469 }
4470 else if (attack_kern == ATTACK_KERN_COMBI)
4471 {
4472 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4473 }
4474 }
4475 }
4476
4477 device_param->kernel_accel = 0;
4478 device_param->kernel_loops = 0;
4479
4480 myfree (buf);
4481
4482 return NULL;
4483 }
4484
4485 static void *thread_calc (void *p)
4486 {
4487 hc_device_param_t *device_param = (hc_device_param_t *) p;
4488
4489 if (device_param->skipped) return NULL;
4490
4491 autotune (device_param);
4492
4493 const uint attack_mode = data.attack_mode;
4494 const uint attack_kern = data.attack_kern;
4495
4496 if (attack_mode == ATTACK_MODE_BF)
4497 {
4498 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4499 {
4500 const uint work = get_work (device_param, -1, true);
4501
4502 if (work == 0) break;
4503
4504 const u64 words_off = device_param->words_off;
4505 const u64 words_fin = words_off + work;
4506
4507 const uint pws_cnt = work;
4508
4509 device_param->pws_cnt = pws_cnt;
4510
4511 if (pws_cnt)
4512 {
4513 run_copy (device_param, pws_cnt);
4514
4515 run_cracker (device_param, pws_cnt);
4516
4517 device_param->pws_cnt = 0;
4518
4519 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4520 }
4521
4522 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4523
4524 if (data.devices_status == STATUS_CRACKED) break;
4525 if (data.devices_status == STATUS_ABORTED) break;
4526 if (data.devices_status == STATUS_QUIT) break;
4527 if (data.devices_status == STATUS_BYPASS) break;
4528
4529 if (data.benchmark == 1) break;
4530
4531 device_param->words_done = words_fin;
4532 }
4533 }
4534 else
4535 {
4536 const uint segment_size = data.segment_size;
4537
4538 char *dictfile = data.dictfile;
4539
4540 if (attack_mode == ATTACK_MODE_COMBI)
4541 {
4542 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4543 {
4544 dictfile = data.dictfile2;
4545 }
4546 }
4547
4548 FILE *fd = fopen (dictfile, "rb");
4549
4550 if (fd == NULL)
4551 {
4552 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4553
4554 return NULL;
4555 }
4556
4557 if (attack_mode == ATTACK_MODE_COMBI)
4558 {
4559 const uint combs_mode = data.combs_mode;
4560
4561 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4562 {
4563 const char *dictfilec = data.dictfile2;
4564
4565 FILE *combs_fp = fopen (dictfilec, "rb");
4566
4567 if (combs_fp == NULL)
4568 {
4569 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4570
4571 fclose (fd);
4572
4573 return NULL;
4574 }
4575
4576 device_param->combs_fp = combs_fp;
4577 }
4578 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4579 {
4580 const char *dictfilec = data.dictfile;
4581
4582 FILE *combs_fp = fopen (dictfilec, "rb");
4583
4584 if (combs_fp == NULL)
4585 {
4586 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4587
4588 fclose (fd);
4589
4590 return NULL;
4591 }
4592
4593 device_param->combs_fp = combs_fp;
4594 }
4595 }
4596
4597 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4598
4599 wl_data->buf = (char *) mymalloc (segment_size);
4600 wl_data->avail = segment_size;
4601 wl_data->incr = segment_size;
4602 wl_data->cnt = 0;
4603 wl_data->pos = 0;
4604
4605 u64 words_cur = 0;
4606
4607 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4608 {
4609 u64 words_off = 0;
4610 u64 words_fin = 0;
4611
4612 bool allow_div = true;
4613
4614 u64 max = -1;
4615
4616 while (max)
4617 {
4618 const uint work = get_work (device_param, max, allow_div);
4619
4620 allow_div = false;
4621
4622 if (work == 0) break;
4623
4624 words_off = device_param->words_off;
4625 words_fin = words_off + work;
4626
4627 char *line_buf;
4628 uint line_len;
4629
4630 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4631
4632 max = 0;
4633
4634 for ( ; words_cur < words_fin; words_cur++)
4635 {
4636 get_next_word (wl_data, fd, &line_buf, &line_len);
4637
4638 line_len = convert_from_hex (line_buf, line_len);
4639
4640 // post-process rule engine
4641
4642 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4643 {
4644 char rule_buf_out[BLOCK_SIZE] = { 0 };
4645
4646 int rule_len_out = -1;
4647
4648 if (line_len < BLOCK_SIZE)
4649 {
4650 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4651 }
4652
4653 if (rule_len_out < 0) continue;
4654
4655 line_buf = rule_buf_out;
4656 line_len = rule_len_out;
4657 }
4658
4659 if (attack_kern == ATTACK_KERN_STRAIGHT)
4660 {
4661 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4662 {
4663 max++;
4664
4665 hc_thread_mutex_lock (mux_counter);
4666
4667 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4668 {
4669 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4670 }
4671
4672 hc_thread_mutex_unlock (mux_counter);
4673
4674 continue;
4675 }
4676 }
4677 else if (attack_kern == ATTACK_KERN_COMBI)
4678 {
4679 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4680 // since we still need to combine the plains
4681
4682 if (line_len > data.pw_max)
4683 {
4684 max++;
4685
4686 hc_thread_mutex_lock (mux_counter);
4687
4688 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4689 {
4690 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4691 }
4692
4693 hc_thread_mutex_unlock (mux_counter);
4694
4695 continue;
4696 }
4697 }
4698
4699 pw_add (device_param, (u8 *) line_buf, line_len);
4700
4701 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4702
4703 if (data.devices_status == STATUS_CRACKED) break;
4704 if (data.devices_status == STATUS_ABORTED) break;
4705 if (data.devices_status == STATUS_QUIT) break;
4706 if (data.devices_status == STATUS_BYPASS) break;
4707 }
4708
4709 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4710
4711 if (data.devices_status == STATUS_CRACKED) break;
4712 if (data.devices_status == STATUS_ABORTED) break;
4713 if (data.devices_status == STATUS_QUIT) break;
4714 if (data.devices_status == STATUS_BYPASS) break;
4715 }
4716
4717 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4718
4719 if (data.devices_status == STATUS_CRACKED) break;
4720 if (data.devices_status == STATUS_ABORTED) break;
4721 if (data.devices_status == STATUS_QUIT) break;
4722 if (data.devices_status == STATUS_BYPASS) break;
4723
4724 //
4725 // flush
4726 //
4727
4728 const uint pws_cnt = device_param->pws_cnt;
4729
4730 if (pws_cnt)
4731 {
4732 run_copy (device_param, pws_cnt);
4733
4734 run_cracker (device_param, pws_cnt);
4735
4736 device_param->pws_cnt = 0;
4737
4738 if (attack_kern == ATTACK_KERN_STRAIGHT)
4739 {
4740 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4741 }
4742 else if (attack_kern == ATTACK_KERN_COMBI)
4743 {
4744 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4745 }
4746 }
4747
4748 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4749
4750 if (data.devices_status == STATUS_CRACKED) break;
4751 if (data.devices_status == STATUS_ABORTED) break;
4752 if (data.devices_status == STATUS_QUIT) break;
4753 if (data.devices_status == STATUS_BYPASS) break;
4754
4755 if (words_fin == 0) break;
4756
4757 device_param->words_done = words_fin;
4758 }
4759
4760 if (attack_mode == ATTACK_MODE_COMBI)
4761 {
4762 fclose (device_param->combs_fp);
4763 }
4764
4765 free (wl_data->buf);
4766 free (wl_data);
4767
4768 fclose (fd);
4769 }
4770
4771 device_param->kernel_accel = 0;
4772 device_param->kernel_loops = 0;
4773
4774 return NULL;
4775 }
4776
4777 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4778 {
4779 if (!device_param)
4780 {
4781 log_error ("ERROR: %s : Invalid argument", __func__);
4782
4783 exit (-1);
4784 }
4785
4786 salt_t *salt_buf = &data.salts_buf[salt_pos];
4787
4788 device_param->kernel_params_buf32[24] = salt_pos;
4789 device_param->kernel_params_buf32[27] = 1;
4790 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4791 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4792 device_param->kernel_params_buf32[30] = 0;
4793 device_param->kernel_params_buf32[31] = 1;
4794
4795 char *dictfile_old = data.dictfile;
4796
4797 const char *weak_hash_check = "weak-hash-check";
4798
4799 data.dictfile = (char *) weak_hash_check;
4800
4801 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4802
4803 data.kernel_rules_buf[0].cmds[0] = 0;
4804
4805 /**
4806 * run the kernel
4807 */
4808
4809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4810 {
4811 run_kernel (KERN_RUN_1, device_param, 1, false);
4812 }
4813 else
4814 {
4815 run_kernel (KERN_RUN_1, device_param, 1, false);
4816
4817 uint loop_step = 16;
4818
4819 const uint iter = salt_buf->salt_iter;
4820
4821 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4822 {
4823 uint loop_left = iter - loop_pos;
4824
4825 loop_left = MIN (loop_left, loop_step);
4826
4827 device_param->kernel_params_buf32[25] = loop_pos;
4828 device_param->kernel_params_buf32[26] = loop_left;
4829
4830 run_kernel (KERN_RUN_2, device_param, 1, false);
4831 }
4832
4833 run_kernel (KERN_RUN_3, device_param, 1, false);
4834 }
4835
4836 /**
4837 * result
4838 */
4839
4840 check_cracked (device_param, salt_pos);
4841
4842 /**
4843 * cleanup
4844 */
4845
4846 device_param->kernel_params_buf32[24] = 0;
4847 device_param->kernel_params_buf32[25] = 0;
4848 device_param->kernel_params_buf32[26] = 0;
4849 device_param->kernel_params_buf32[27] = 0;
4850 device_param->kernel_params_buf32[28] = 0;
4851 device_param->kernel_params_buf32[29] = 0;
4852 device_param->kernel_params_buf32[30] = 0;
4853 device_param->kernel_params_buf32[31] = 0;
4854
4855 data.dictfile = dictfile_old;
4856
4857 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4858 }
4859
4860 // hlfmt hashcat
4861
4862 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4863 {
4864 if (data.username == 0)
4865 {
4866 *hashbuf_pos = line_buf;
4867 *hashbuf_len = line_len;
4868 }
4869 else
4870 {
4871 char *pos = line_buf;
4872 int len = line_len;
4873
4874 for (int i = 0; i < line_len; i++, pos++, len--)
4875 {
4876 if (line_buf[i] == data.separator)
4877 {
4878 pos++;
4879
4880 len--;
4881
4882 break;
4883 }
4884 }
4885
4886 *hashbuf_pos = pos;
4887 *hashbuf_len = len;
4888 }
4889 }
4890
4891 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4892 {
4893 char *pos = NULL;
4894 int len = 0;
4895
4896 int sep_cnt = 0;
4897
4898 for (int i = 0; i < line_len; i++)
4899 {
4900 if (line_buf[i] == data.separator)
4901 {
4902 sep_cnt++;
4903
4904 continue;
4905 }
4906
4907 if (sep_cnt == 0)
4908 {
4909 if (pos == NULL) pos = line_buf + i;
4910
4911 len++;
4912 }
4913 }
4914
4915 *userbuf_pos = pos;
4916 *userbuf_len = len;
4917 }
4918
4919 // hlfmt pwdump
4920
4921 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4922 {
4923 int sep_cnt = 0;
4924
4925 int sep2_len = 0;
4926 int sep3_len = 0;
4927
4928 for (int i = 0; i < line_len; i++)
4929 {
4930 if (line_buf[i] == ':')
4931 {
4932 sep_cnt++;
4933
4934 continue;
4935 }
4936
4937 if (sep_cnt == 2) sep2_len++;
4938 if (sep_cnt == 3) sep3_len++;
4939 }
4940
4941 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4942
4943 return 0;
4944 }
4945
4946 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4947 {
4948 char *pos = NULL;
4949 int len = 0;
4950
4951 int sep_cnt = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (data.hash_mode == 1000)
4963 {
4964 if (sep_cnt == 3)
4965 {
4966 if (pos == NULL) pos = line_buf + i;
4967
4968 len++;
4969 }
4970 }
4971 else if (data.hash_mode == 3000)
4972 {
4973 if (sep_cnt == 2)
4974 {
4975 if (pos == NULL) pos = line_buf + i;
4976
4977 len++;
4978 }
4979 }
4980 }
4981
4982 *hashbuf_pos = pos;
4983 *hashbuf_len = len;
4984 }
4985
4986 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4987 {
4988 char *pos = NULL;
4989 int len = 0;
4990
4991 int sep_cnt = 0;
4992
4993 for (int i = 0; i < line_len; i++)
4994 {
4995 if (line_buf[i] == ':')
4996 {
4997 sep_cnt++;
4998
4999 continue;
5000 }
5001
5002 if (sep_cnt == 0)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009
5010 *userbuf_pos = pos;
5011 *userbuf_len = len;
5012 }
5013
5014 // hlfmt passwd
5015
5016 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5017 {
5018 int sep_cnt = 0;
5019
5020 char sep5_first = 0;
5021 char sep6_first = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5033 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5034 }
5035
5036 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5037
5038 return 0;
5039 }
5040
5041 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5042 {
5043 char *pos = NULL;
5044 int len = 0;
5045
5046 int sep_cnt = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == ':')
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (sep_cnt == 1)
5058 {
5059 if (pos == NULL) pos = line_buf + i;
5060
5061 len++;
5062 }
5063 }
5064
5065 *hashbuf_pos = pos;
5066 *hashbuf_len = len;
5067 }
5068
5069 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5070 {
5071 char *pos = NULL;
5072 int len = 0;
5073
5074 int sep_cnt = 0;
5075
5076 for (int i = 0; i < line_len; i++)
5077 {
5078 if (line_buf[i] == ':')
5079 {
5080 sep_cnt++;
5081
5082 continue;
5083 }
5084
5085 if (sep_cnt == 0)
5086 {
5087 if (pos == NULL) pos = line_buf + i;
5088
5089 len++;
5090 }
5091 }
5092
5093 *userbuf_pos = pos;
5094 *userbuf_len = len;
5095 }
5096
5097 // hlfmt shadow
5098
5099 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5100 {
5101 int sep_cnt = 0;
5102
5103 for (int i = 0; i < line_len; i++)
5104 {
5105 if (line_buf[i] == ':') sep_cnt++;
5106 }
5107
5108 if (sep_cnt == 8) return 1;
5109
5110 return 0;
5111 }
5112
5113 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5114 {
5115 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5116 }
5117
5118 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5119 {
5120 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5121 }
5122
5123 // hlfmt main
5124
5125 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5126 {
5127 switch (hashfile_format)
5128 {
5129 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5132 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5133 }
5134 }
5135
5136 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5137 {
5138 switch (hashfile_format)
5139 {
5140 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5143 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5144 }
5145 }
5146
5147 char *strhlfmt (const uint hashfile_format)
5148 {
5149 switch (hashfile_format)
5150 {
5151 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5152 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5153 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5154 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5155 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5156 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5157 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5158 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5159 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5160 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5161 }
5162
5163 return ((char *) "Unknown");
5164 }
5165
5166 static uint hlfmt_detect (FILE *fp, uint max_check)
5167 {
5168 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5169
5170 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5171 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5172
5173 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5174
5175 uint num_check = 0;
5176
5177 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5178
5179 while (!feof (fp))
5180 {
5181 int line_len = fgetl (fp, line_buf);
5182
5183 if (line_len == 0) continue;
5184
5185 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5186 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5187 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5188
5189 if (num_check == max_check) break;
5190
5191 num_check++;
5192 }
5193
5194 myfree (line_buf);
5195
5196 uint hashlist_format = HLFMT_HASHCAT;
5197
5198 for (int i = 1; i < HLFMTS_CNT; i++)
5199 {
5200 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5201
5202 hashlist_format = i;
5203 }
5204
5205 free (formats_cnt);
5206
5207 return hashlist_format;
5208 }
5209
5210 /**
5211 * some further helper function
5212 */
5213
5214 // wrapper around mymalloc for ADL
5215
5216 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5217 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5218 {
5219 return mymalloc (iSize);
5220 }
5221 #endif
5222
5223 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)
5224 {
5225 u64 collisions = 0;
5226
5227 const uint dgst_pos0 = data.dgst_pos0;
5228 const uint dgst_pos1 = data.dgst_pos1;
5229 const uint dgst_pos2 = data.dgst_pos2;
5230 const uint dgst_pos3 = data.dgst_pos3;
5231
5232 memset (bitmap_a, 0, bitmap_size);
5233 memset (bitmap_b, 0, bitmap_size);
5234 memset (bitmap_c, 0, bitmap_size);
5235 memset (bitmap_d, 0, bitmap_size);
5236
5237 for (uint i = 0; i < digests_cnt; i++)
5238 {
5239 uint *digest_ptr = (uint *) digests_buf_ptr;
5240
5241 digests_buf_ptr += dgst_size;
5242
5243 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5244 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5245 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5246 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5247
5248 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5249 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5250 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5251 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5252
5253 if (bitmap_a[idx0] & val0) collisions++;
5254 if (bitmap_b[idx1] & val1) collisions++;
5255 if (bitmap_c[idx2] & val2) collisions++;
5256 if (bitmap_d[idx3] & val3) collisions++;
5257
5258 bitmap_a[idx0] |= val0;
5259 bitmap_b[idx1] |= val1;
5260 bitmap_c[idx2] |= val2;
5261 bitmap_d[idx3] |= val3;
5262
5263 if (collisions >= collisions_max) return 0x7fffffff;
5264 }
5265
5266 return collisions;
5267 }
5268
5269 /**
5270 * main
5271 */
5272
5273 int main (int argc, char **argv)
5274 {
5275 /**
5276 * To help users a bit
5277 */
5278
5279 char *compute = getenv ("COMPUTE");
5280
5281 if (compute)
5282 {
5283 static char display[100];
5284
5285 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5286
5287 putenv (display);
5288 }
5289 else
5290 {
5291 if (getenv ("DISPLAY") == NULL)
5292 putenv ((char *) "DISPLAY=:0");
5293 }
5294
5295 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5296 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5297
5298 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5299 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5300
5301 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5302 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5303
5304 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5305 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5306
5307 /**
5308 * Real init
5309 */
5310
5311 memset (&data, 0, sizeof (hc_global_data_t));
5312
5313 time_t proc_start;
5314
5315 time (&proc_start);
5316
5317 data.proc_start = proc_start;
5318
5319 int myargc = argc;
5320 char **myargv = argv;
5321
5322 hc_thread_mutex_init (mux_dispatcher);
5323 hc_thread_mutex_init (mux_counter);
5324 hc_thread_mutex_init (mux_display);
5325 hc_thread_mutex_init (mux_adl);
5326
5327 /**
5328 * commandline parameters
5329 */
5330
5331 uint usage = USAGE;
5332 uint version = VERSION;
5333 uint quiet = QUIET;
5334 uint benchmark = BENCHMARK;
5335 uint benchmark_repeats = BENCHMARK_REPEATS;
5336 uint show = SHOW;
5337 uint left = LEFT;
5338 uint username = USERNAME;
5339 uint remove = REMOVE;
5340 uint remove_timer = REMOVE_TIMER;
5341 u64 skip = SKIP;
5342 u64 limit = LIMIT;
5343 uint keyspace = KEYSPACE;
5344 uint potfile_disable = POTFILE_DISABLE;
5345 char *potfile_path = NULL;
5346 uint debug_mode = DEBUG_MODE;
5347 char *debug_file = NULL;
5348 char *induction_dir = NULL;
5349 char *outfile_check_dir = NULL;
5350 uint force = FORCE;
5351 uint runtime = RUNTIME;
5352 uint hash_mode = HASH_MODE;
5353 uint attack_mode = ATTACK_MODE;
5354 uint markov_disable = MARKOV_DISABLE;
5355 uint markov_classic = MARKOV_CLASSIC;
5356 uint markov_threshold = MARKOV_THRESHOLD;
5357 char *markov_hcstat = NULL;
5358 char *outfile = NULL;
5359 uint outfile_format = OUTFILE_FORMAT;
5360 uint outfile_autohex = OUTFILE_AUTOHEX;
5361 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5362 uint restore = RESTORE;
5363 uint restore_timer = RESTORE_TIMER;
5364 uint restore_disable = RESTORE_DISABLE;
5365 uint status = STATUS;
5366 uint status_timer = STATUS_TIMER;
5367 uint status_automat = STATUS_AUTOMAT;
5368 uint loopback = LOOPBACK;
5369 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5370 char *session = NULL;
5371 uint hex_charset = HEX_CHARSET;
5372 uint hex_salt = HEX_SALT;
5373 uint hex_wordlist = HEX_WORDLIST;
5374 uint rp_gen = RP_GEN;
5375 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5376 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5377 uint rp_gen_seed = RP_GEN_SEED;
5378 char *rule_buf_l = (char *) RULE_BUF_L;
5379 char *rule_buf_r = (char *) RULE_BUF_R;
5380 uint increment = INCREMENT;
5381 uint increment_min = INCREMENT_MIN;
5382 uint increment_max = INCREMENT_MAX;
5383 char *cpu_affinity = NULL;
5384 OCL_PTR *ocl = NULL;
5385 char *opencl_devices = NULL;
5386 char *opencl_platforms = NULL;
5387 char *opencl_device_types = NULL;
5388 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5389 char *truecrypt_keyfiles = NULL;
5390 uint workload_profile = WORKLOAD_PROFILE;
5391 uint kernel_accel = KERNEL_ACCEL;
5392 uint kernel_loops = KERNEL_LOOPS;
5393 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5394 #ifdef HAVE_HWMON
5395 uint gpu_temp_abort = GPU_TEMP_ABORT;
5396 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5397 #ifdef HAVE_ADL
5398 uint powertune_enable = POWERTUNE_ENABLE;
5399 #endif
5400 #endif
5401 uint logfile_disable = LOGFILE_DISABLE;
5402 uint segment_size = SEGMENT_SIZE;
5403 uint scrypt_tmto = SCRYPT_TMTO;
5404 char separator = SEPARATOR;
5405 uint bitmap_min = BITMAP_MIN;
5406 uint bitmap_max = BITMAP_MAX;
5407 char *custom_charset_1 = NULL;
5408 char *custom_charset_2 = NULL;
5409 char *custom_charset_3 = NULL;
5410 char *custom_charset_4 = NULL;
5411
5412 #define IDX_HELP 'h'
5413 #define IDX_VERSION 'V'
5414 #define IDX_VERSION_LOWER 'v'
5415 #define IDX_QUIET 0xff02
5416 #define IDX_SHOW 0xff03
5417 #define IDX_LEFT 0xff04
5418 #define IDX_REMOVE 0xff05
5419 #define IDX_REMOVE_TIMER 0xff37
5420 #define IDX_SKIP 's'
5421 #define IDX_LIMIT 'l'
5422 #define IDX_KEYSPACE 0xff35
5423 #define IDX_POTFILE_DISABLE 0xff06
5424 #define IDX_POTFILE_PATH 0xffe0
5425 #define IDX_DEBUG_MODE 0xff43
5426 #define IDX_DEBUG_FILE 0xff44
5427 #define IDX_INDUCTION_DIR 0xff46
5428 #define IDX_OUTFILE_CHECK_DIR 0xff47
5429 #define IDX_USERNAME 0xff07
5430 #define IDX_FORCE 0xff08
5431 #define IDX_RUNTIME 0xff09
5432 #define IDX_BENCHMARK 'b'
5433 #define IDX_BENCHMARK_REPEATS 0xff78
5434 #define IDX_HASH_MODE 'm'
5435 #define IDX_ATTACK_MODE 'a'
5436 #define IDX_RP_FILE 'r'
5437 #define IDX_RP_GEN 'g'
5438 #define IDX_RP_GEN_FUNC_MIN 0xff10
5439 #define IDX_RP_GEN_FUNC_MAX 0xff11
5440 #define IDX_RP_GEN_SEED 0xff34
5441 #define IDX_RULE_BUF_L 'j'
5442 #define IDX_RULE_BUF_R 'k'
5443 #define IDX_INCREMENT 'i'
5444 #define IDX_INCREMENT_MIN 0xff12
5445 #define IDX_INCREMENT_MAX 0xff13
5446 #define IDX_OUTFILE 'o'
5447 #define IDX_OUTFILE_FORMAT 0xff14
5448 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5449 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5450 #define IDX_RESTORE 0xff15
5451 #define IDX_RESTORE_DISABLE 0xff27
5452 #define IDX_STATUS 0xff17
5453 #define IDX_STATUS_TIMER 0xff18
5454 #define IDX_STATUS_AUTOMAT 0xff50
5455 #define IDX_LOOPBACK 0xff38
5456 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5457 #define IDX_SESSION 0xff19
5458 #define IDX_HEX_CHARSET 0xff20
5459 #define IDX_HEX_SALT 0xff21
5460 #define IDX_HEX_WORDLIST 0xff40
5461 #define IDX_MARKOV_DISABLE 0xff22
5462 #define IDX_MARKOV_CLASSIC 0xff23
5463 #define IDX_MARKOV_THRESHOLD 't'
5464 #define IDX_MARKOV_HCSTAT 0xff24
5465 #define IDX_CPU_AFFINITY 0xff25
5466 #define IDX_OPENCL_DEVICES 'd'
5467 #define IDX_OPENCL_PLATFORMS 0xff72
5468 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5469 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5470 #define IDX_WORKLOAD_PROFILE 'w'
5471 #define IDX_KERNEL_ACCEL 'n'
5472 #define IDX_KERNEL_LOOPS 'u'
5473 #define IDX_GPU_TEMP_DISABLE 0xff29
5474 #define IDX_GPU_TEMP_ABORT 0xff30
5475 #define IDX_GPU_TEMP_RETAIN 0xff31
5476 #define IDX_POWERTUNE_ENABLE 0xff41
5477 #define IDX_LOGFILE_DISABLE 0xff51
5478 #define IDX_TRUECRYPT_KEYFILES 0xff52
5479 #define IDX_SCRYPT_TMTO 0xff61
5480 #define IDX_SEGMENT_SIZE 'c'
5481 #define IDX_SEPARATOR 'p'
5482 #define IDX_BITMAP_MIN 0xff70
5483 #define IDX_BITMAP_MAX 0xff71
5484 #define IDX_CUSTOM_CHARSET_1 '1'
5485 #define IDX_CUSTOM_CHARSET_2 '2'
5486 #define IDX_CUSTOM_CHARSET_3 '3'
5487 #define IDX_CUSTOM_CHARSET_4 '4'
5488
5489 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5490
5491 struct option long_options[] =
5492 {
5493 {"help", no_argument, 0, IDX_HELP},
5494 {"version", no_argument, 0, IDX_VERSION},
5495 {"quiet", no_argument, 0, IDX_QUIET},
5496 {"show", no_argument, 0, IDX_SHOW},
5497 {"left", no_argument, 0, IDX_LEFT},
5498 {"username", no_argument, 0, IDX_USERNAME},
5499 {"remove", no_argument, 0, IDX_REMOVE},
5500 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5501 {"skip", required_argument, 0, IDX_SKIP},
5502 {"limit", required_argument, 0, IDX_LIMIT},
5503 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5504 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5505 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5506 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5507 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5508 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5509 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5510 {"force", no_argument, 0, IDX_FORCE},
5511 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5512 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5513 {"restore", no_argument, 0, IDX_RESTORE},
5514 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5515 {"status", no_argument, 0, IDX_STATUS},
5516 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5517 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5518 {"loopback", no_argument, 0, IDX_LOOPBACK},
5519 {"weak-hash-threshold",
5520 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5521 {"session", required_argument, 0, IDX_SESSION},
5522 {"runtime", required_argument, 0, IDX_RUNTIME},
5523 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5524 {"generate-rules-func-min",
5525 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5526 {"generate-rules-func-max",
5527 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5528 {"generate-rules-seed",
5529 required_argument, 0, IDX_RP_GEN_SEED},
5530 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5531 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5532 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5533 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5534 {"rules-file", required_argument, 0, IDX_RP_FILE},
5535 {"outfile", required_argument, 0, IDX_OUTFILE},
5536 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5537 {"outfile-autohex-disable",
5538 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5539 {"outfile-check-timer",
5540 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5541 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5542 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5543 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5544 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5545 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5546 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5547 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5548 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5549 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5550 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5551 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5552 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5553 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5554 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5555 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5556 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5557 #ifdef HAVE_HWMON
5558 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5559 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5560 #ifdef HAVE_ADL
5561 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5562 #endif
5563 #endif // HAVE_HWMON
5564 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5565 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5566 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5567 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5568 // deprecated
5569 {"seperator", required_argument, 0, IDX_SEPARATOR},
5570 {"separator", required_argument, 0, IDX_SEPARATOR},
5571 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5572 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5573 {"increment", no_argument, 0, IDX_INCREMENT},
5574 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5575 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5576 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5577 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5578 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5579 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5580
5581 {0, 0, 0, 0}
5582 };
5583
5584 uint rp_files_cnt = 0;
5585
5586 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5587
5588 int option_index = 0;
5589 int c = -1;
5590
5591 optind = 1;
5592 optopt = 0;
5593
5594 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5595 {
5596 switch (c)
5597 {
5598 case IDX_HELP: usage = 1; break;
5599 case IDX_VERSION:
5600 case IDX_VERSION_LOWER: version = 1; break;
5601 case IDX_RESTORE: restore = 1; break;
5602 case IDX_SESSION: session = optarg; break;
5603 case IDX_SHOW: show = 1; break;
5604 case IDX_LEFT: left = 1; break;
5605 case '?': return (-1);
5606 }
5607 }
5608
5609 if (optopt != 0)
5610 {
5611 log_error ("ERROR: Invalid argument specified");
5612
5613 return (-1);
5614 }
5615
5616 /**
5617 * exit functions
5618 */
5619
5620 if (version)
5621 {
5622 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5623
5624 return (0);
5625 }
5626
5627 if (usage)
5628 {
5629 usage_big_print (PROGNAME);
5630
5631 return (0);
5632 }
5633
5634 /**
5635 * session needs to be set, always!
5636 */
5637
5638 if (session == NULL) session = (char *) PROGNAME;
5639
5640 /**
5641 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5642 */
5643
5644 char *exec_path = get_exec_path ();
5645
5646 #ifdef LINUX
5647
5648 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5649 char *resolved_exec_path = realpath (exec_path, NULL);
5650
5651 char *install_dir = get_install_dir (resolved_exec_path);
5652 char *profile_dir = NULL;
5653 char *session_dir = NULL;
5654 char *shared_dir = NULL;
5655
5656 if (strcmp (install_dir, resolved_install_folder) == 0)
5657 {
5658 struct passwd *pw = getpwuid (getuid ());
5659
5660 const char *homedir = pw->pw_dir;
5661
5662 profile_dir = get_profile_dir (homedir);
5663 session_dir = get_session_dir (profile_dir);
5664 shared_dir = strdup (SHARED_FOLDER);
5665
5666 mkdir (profile_dir, 0700);
5667 mkdir (session_dir, 0700);
5668 }
5669 else
5670 {
5671 profile_dir = install_dir;
5672 session_dir = install_dir;
5673 shared_dir = install_dir;
5674 }
5675
5676 myfree (resolved_install_folder);
5677 myfree (resolved_exec_path);
5678
5679 #else
5680
5681 char *install_dir = get_install_dir (exec_path);
5682 char *profile_dir = install_dir;
5683 char *session_dir = install_dir;
5684 char *shared_dir = install_dir;
5685
5686 #endif
5687
5688 data.install_dir = install_dir;
5689 data.profile_dir = profile_dir;
5690 data.session_dir = session_dir;
5691 data.shared_dir = shared_dir;
5692
5693 myfree (exec_path);
5694
5695 /**
5696 * kernel cache, we need to make sure folder exist
5697 */
5698
5699 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5700
5701 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5702
5703 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5704
5705 mkdir (kernels_folder, 0700);
5706
5707 myfree (kernels_folder);
5708
5709 /**
5710 * session
5711 */
5712
5713 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5714
5715 data.session = session;
5716
5717 char *eff_restore_file = (char *) mymalloc (session_size);
5718 char *new_restore_file = (char *) mymalloc (session_size);
5719
5720 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5721 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5722
5723 data.eff_restore_file = eff_restore_file;
5724 data.new_restore_file = new_restore_file;
5725
5726 if (((show == 1) || (left == 1)) && (restore == 1))
5727 {
5728 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5729 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5730
5731 return (-1);
5732 }
5733
5734 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5735 if ((show == 1) || (left == 1))
5736 {
5737 restore_disable = 1;
5738
5739 restore = 0;
5740 }
5741
5742 data.restore_disable = restore_disable;
5743
5744 restore_data_t *rd = init_restore (argc, argv);
5745
5746 data.rd = rd;
5747
5748 /**
5749 * restore file
5750 */
5751
5752 if (restore == 1)
5753 {
5754 read_restore (eff_restore_file, rd);
5755
5756 if (rd->version_bin < RESTORE_MIN)
5757 {
5758 log_error ("ERROR: Incompatible restore-file version");
5759
5760 return (-1);
5761 }
5762
5763 myargc = rd->argc;
5764 myargv = rd->argv;
5765
5766 #ifdef _POSIX
5767 rd->pid = getpid ();
5768 #elif _WIN
5769 rd->pid = GetCurrentProcessId ();
5770 #endif
5771 }
5772
5773 uint hash_mode_chgd = 0;
5774 uint runtime_chgd = 0;
5775 uint kernel_loops_chgd = 0;
5776 uint kernel_accel_chgd = 0;
5777 uint attack_mode_chgd = 0;
5778 uint outfile_format_chgd = 0;
5779 uint rp_gen_seed_chgd = 0;
5780 uint remove_timer_chgd = 0;
5781 uint increment_min_chgd = 0;
5782 uint increment_max_chgd = 0;
5783 uint workload_profile_chgd = 0;
5784 uint opencl_vector_width_chgd = 0;
5785
5786 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5787 uint gpu_temp_retain_chgd = 0;
5788 uint gpu_temp_abort_chgd = 0;
5789 #endif
5790
5791 optind = 1;
5792 optopt = 0;
5793 option_index = 0;
5794
5795 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5796 {
5797 switch (c)
5798 {
5799 //case IDX_HELP: usage = 1; break;
5800 //case IDX_VERSION: version = 1; break;
5801 //case IDX_RESTORE: restore = 1; break;
5802 case IDX_QUIET: quiet = 1; break;
5803 //case IDX_SHOW: show = 1; break;
5804 case IDX_SHOW: break;
5805 //case IDX_LEFT: left = 1; break;
5806 case IDX_LEFT: break;
5807 case IDX_USERNAME: username = 1; break;
5808 case IDX_REMOVE: remove = 1; break;
5809 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5810 remove_timer_chgd = 1; break;
5811 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5812 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5813 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5814 case IDX_DEBUG_FILE: debug_file = optarg; break;
5815 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5816 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5817 case IDX_FORCE: force = 1; break;
5818 case IDX_SKIP: skip = atoll (optarg); break;
5819 case IDX_LIMIT: limit = atoll (optarg); break;
5820 case IDX_KEYSPACE: keyspace = 1; break;
5821 case IDX_BENCHMARK: benchmark = 1; break;
5822 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5823 case IDX_RESTORE: break;
5824 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5825 case IDX_STATUS: status = 1; break;
5826 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5827 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5828 case IDX_LOOPBACK: loopback = 1; break;
5829 case IDX_WEAK_HASH_THRESHOLD:
5830 weak_hash_threshold = atoi (optarg); break;
5831 //case IDX_SESSION: session = optarg; break;
5832 case IDX_SESSION: break;
5833 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5834 hash_mode_chgd = 1; break;
5835 case IDX_RUNTIME: runtime = atoi (optarg);
5836 runtime_chgd = 1; break;
5837 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5838 attack_mode_chgd = 1; break;
5839 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5840 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5841 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5842 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5843 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5844 rp_gen_seed_chgd = 1; break;
5845 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5846 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5847 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5848 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5849 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5850 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5851 case IDX_OUTFILE: outfile = optarg; break;
5852 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5853 outfile_format_chgd = 1; break;
5854 case IDX_OUTFILE_AUTOHEX_DISABLE:
5855 outfile_autohex = 0; break;
5856 case IDX_OUTFILE_CHECK_TIMER:
5857 outfile_check_timer = atoi (optarg); break;
5858 case IDX_HEX_CHARSET: hex_charset = 1; break;
5859 case IDX_HEX_SALT: hex_salt = 1; break;
5860 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5861 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5862 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5863 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5864 case IDX_OPENCL_DEVICE_TYPES:
5865 opencl_device_types = optarg; break;
5866 case IDX_OPENCL_VECTOR_WIDTH:
5867 opencl_vector_width = atoi (optarg);
5868 opencl_vector_width_chgd = 1; break;
5869 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5870 workload_profile_chgd = 1; break;
5871 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5872 kernel_accel_chgd = 1; break;
5873 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5874 kernel_loops_chgd = 1; break;
5875 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5876 #ifdef HAVE_HWMON
5877 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5878 #ifdef HAVE_ADL
5879 gpu_temp_abort_chgd = 1;
5880 #endif
5881 break;
5882 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_retain_chgd = 1;
5885 #endif
5886 break;
5887 #ifdef HAVE_ADL
5888 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5889 #endif
5890 #endif // HAVE_HWMON
5891 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5892 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5893 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5894 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5895 case IDX_SEPARATOR: separator = optarg[0]; break;
5896 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5897 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5898 case IDX_INCREMENT: increment = 1; break;
5899 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5900 increment_min_chgd = 1; break;
5901 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5902 increment_max_chgd = 1; break;
5903 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5904 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5905 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5906 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5907
5908 default:
5909 log_error ("ERROR: Invalid argument specified");
5910 return (-1);
5911 }
5912 }
5913
5914 if (optopt != 0)
5915 {
5916 log_error ("ERROR: Invalid argument specified");
5917
5918 return (-1);
5919 }
5920
5921 /**
5922 * Inform user things getting started,
5923 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5924 * - we do not need to check algorithm_pos
5925 */
5926
5927 if (quiet == 0)
5928 {
5929 if (benchmark == 1)
5930 {
5931 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5932
5933 log_info ("");
5934 }
5935 else if (restore == 1)
5936 {
5937 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5938
5939 log_info ("");
5940 }
5941 else
5942 {
5943 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5944
5945 log_info ("");
5946 }
5947 }
5948
5949 /**
5950 * sanity check
5951 */
5952
5953 if (attack_mode > 7)
5954 {
5955 log_error ("ERROR: Invalid attack-mode specified");
5956
5957 return (-1);
5958 }
5959
5960 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5961 {
5962 log_error ("ERROR: Invalid runtime specified");
5963
5964 return (-1);
5965 }
5966
5967 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5968 {
5969 log_error ("ERROR: Invalid hash-type specified");
5970
5971 return (-1);
5972 }
5973
5974 // renamed hash modes
5975
5976 if (hash_mode_chgd)
5977 {
5978 int n = -1;
5979
5980 switch (hash_mode)
5981 {
5982 case 123: n = 124;
5983 break;
5984 }
5985
5986 if (n >= 0)
5987 {
5988 log_error ("Old -m specified, use -m %d instead", n);
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (username == 1)
5995 {
5996 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5997 {
5998 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5999
6000 return (-1);
6001 }
6002 }
6003
6004 if (outfile_format > 16)
6005 {
6006 log_error ("ERROR: Invalid outfile-format specified");
6007
6008 return (-1);
6009 }
6010
6011 if (left == 1)
6012 {
6013 if (outfile_format_chgd == 1)
6014 {
6015 if (outfile_format > 1)
6016 {
6017 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6018
6019 return (-1);
6020 }
6021 }
6022 else
6023 {
6024 outfile_format = OUTFILE_FMT_HASH;
6025 }
6026 }
6027
6028 if (show == 1)
6029 {
6030 if (outfile_format_chgd == 1)
6031 {
6032 if ((outfile_format > 7) && (outfile_format < 16))
6033 {
6034 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6035
6036 return (-1);
6037 }
6038 }
6039 }
6040
6041 if (increment_min < INCREMENT_MIN)
6042 {
6043 log_error ("ERROR: Invalid increment-min specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_max > INCREMENT_MAX)
6049 {
6050 log_error ("ERROR: Invalid increment-max specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_min > increment_max)
6056 {
6057 log_error ("ERROR: Invalid increment-min specified");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6063 {
6064 log_error ("ERROR: increment is not allowed in attack-mode 0");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_min_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-min is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_max_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-max is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt && rp_gen)
6084 {
6085 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt || rp_gen)
6091 {
6092 if (attack_mode != ATTACK_MODE_STRAIGHT)
6093 {
6094 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (rp_gen_func_min > rp_gen_func_max)
6101 {
6102 log_error ("ERROR: Invalid rp-gen-func-min specified");
6103
6104 return (-1);
6105 }
6106
6107 if (kernel_accel_chgd == 1)
6108 {
6109 if (kernel_accel < 1)
6110 {
6111 log_error ("ERROR: Invalid kernel-accel specified");
6112
6113 return (-1);
6114 }
6115
6116 if (kernel_accel > 1024)
6117 {
6118 log_error ("ERROR: Invalid kernel-accel specified");
6119
6120 return (-1);
6121 }
6122 }
6123
6124 if (kernel_loops_chgd == 1)
6125 {
6126 if (kernel_loops < 1)
6127 {
6128 log_error ("ERROR: Invalid kernel-loops specified");
6129
6130 return (-1);
6131 }
6132
6133 if (kernel_loops > 1024)
6134 {
6135 log_error ("ERROR: Invalid kernel-loops specified");
6136
6137 return (-1);
6138 }
6139 }
6140
6141 if ((workload_profile < 1) || (workload_profile > 3))
6142 {
6143 log_error ("ERROR: workload-profile %i not available", workload_profile);
6144
6145 return (-1);
6146 }
6147
6148 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6149 {
6150 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6151
6152 return (-1);
6153 }
6154
6155 if (show == 1 || left == 1)
6156 {
6157 attack_mode = ATTACK_MODE_NONE;
6158
6159 if (remove == 1)
6160 {
6161 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6162
6163 return (-1);
6164 }
6165
6166 if (potfile_disable == 1)
6167 {
6168 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6169
6170 return (-1);
6171 }
6172 }
6173
6174 uint attack_kern = ATTACK_KERN_NONE;
6175
6176 switch (attack_mode)
6177 {
6178 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6179 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6180 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6181 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6182 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6183 }
6184
6185 if (benchmark == 0)
6186 {
6187 if (keyspace == 1)
6188 {
6189 int num_additional_params = 1;
6190
6191 if (attack_kern == ATTACK_KERN_COMBI)
6192 {
6193 num_additional_params = 2;
6194 }
6195
6196 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6197
6198 if (keyspace_wordlist_specified == 0) optind--;
6199 }
6200
6201 if (attack_kern == ATTACK_KERN_NONE)
6202 {
6203 if ((optind + 1) != myargc)
6204 {
6205 usage_mini_print (myargv[0]);
6206
6207 return (-1);
6208 }
6209 }
6210 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6211 {
6212 if ((optind + 1) > myargc)
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else if (attack_kern == ATTACK_KERN_COMBI)
6220 {
6221 if ((optind + 3) != myargc)
6222 {
6223 usage_mini_print (myargv[0]);
6224
6225 return (-1);
6226 }
6227 }
6228 else if (attack_kern == ATTACK_KERN_BF)
6229 {
6230 if ((optind + 1) > myargc)
6231 {
6232 usage_mini_print (myargv[0]);
6233
6234 return (-1);
6235 }
6236 }
6237 else
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else
6245 {
6246 if (myargv[optind] != 0)
6247 {
6248 log_error ("ERROR: Invalid argument for benchmark mode specified");
6249
6250 return (-1);
6251 }
6252
6253 if (attack_mode_chgd == 1)
6254 {
6255 if (attack_mode != ATTACK_MODE_BF)
6256 {
6257 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6258
6259 return (-1);
6260 }
6261 }
6262 }
6263
6264 if (skip != 0 && limit != 0)
6265 {
6266 limit += skip;
6267 }
6268
6269 if (keyspace == 1)
6270 {
6271 if (show == 1)
6272 {
6273 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6274
6275 return (-1);
6276 }
6277 else if (left == 1)
6278 {
6279 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6280
6281 return (-1);
6282 }
6283
6284 potfile_disable = 1;
6285
6286 restore_disable = 1;
6287
6288 restore = 0;
6289
6290 weak_hash_threshold = 0;
6291
6292 quiet = 1;
6293 }
6294
6295 if (remove_timer_chgd == 1)
6296 {
6297 if (remove == 0)
6298 {
6299 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6300
6301 return (-1);
6302 }
6303
6304 if (remove_timer < 1)
6305 {
6306 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6307
6308 return (-1);
6309 }
6310 }
6311
6312 if (loopback == 1)
6313 {
6314 if (attack_mode == ATTACK_MODE_BF)
6315 {
6316 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6317
6318 return (-1);
6319 }
6320 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6321 {
6322 if ((rp_files_cnt == 0) && (rp_gen == 0))
6323 {
6324 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6325
6326 return (-1);
6327 }
6328 }
6329 }
6330
6331 if (debug_mode > 0)
6332 {
6333 if (attack_mode != ATTACK_MODE_STRAIGHT)
6334 {
6335 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6336
6337 return (-1);
6338 }
6339
6340 if ((rp_files_cnt == 0) && (rp_gen == 0))
6341 {
6342 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6343
6344 return (-1);
6345 }
6346 }
6347
6348 if (debug_mode > 4)
6349 {
6350 log_error ("ERROR: Invalid debug-mode specified");
6351
6352 return (-1);
6353 }
6354
6355 if (debug_file != NULL)
6356 {
6357 if (debug_mode < 1)
6358 {
6359 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6360
6361 return (-1);
6362 }
6363 }
6364
6365 if (induction_dir != NULL)
6366 {
6367 if (attack_mode == ATTACK_MODE_BF)
6368 {
6369 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6370
6371 return (-1);
6372 }
6373 }
6374
6375 if (attack_mode != ATTACK_MODE_STRAIGHT)
6376 {
6377 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6378 {
6379 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6380
6381 return (-1);
6382 }
6383
6384 weak_hash_threshold = 0;
6385 }
6386
6387 /**
6388 * induction directory
6389 */
6390
6391 char *induction_directory = NULL;
6392
6393 if (attack_mode != ATTACK_MODE_BF)
6394 {
6395 if (induction_dir == NULL)
6396 {
6397 induction_directory = (char *) mymalloc (session_size);
6398
6399 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6400
6401 // create induction folder if it does not already exist
6402
6403 if (keyspace == 0)
6404 {
6405 if (rmdir (induction_directory) == -1)
6406 {
6407 if (errno == ENOENT)
6408 {
6409 // good, we can ignore
6410 }
6411 else if (errno == ENOTEMPTY)
6412 {
6413 char *induction_directory_mv = (char *) mymalloc (session_size);
6414
6415 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6416
6417 if (rename (induction_directory, induction_directory_mv) != 0)
6418 {
6419 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6420
6421 return (-1);
6422 }
6423 }
6424 else
6425 {
6426 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6427
6428 return (-1);
6429 }
6430 }
6431
6432 if (mkdir (induction_directory, 0700) == -1)
6433 {
6434 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6435
6436 return (-1);
6437 }
6438 }
6439 }
6440 else
6441 {
6442 induction_directory = induction_dir;
6443 }
6444 }
6445
6446 data.induction_directory = induction_directory;
6447
6448 /**
6449 * loopback
6450 */
6451
6452 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6453
6454 char *loopback_file = (char *) mymalloc (loopback_size);
6455
6456 /**
6457 * tuning db
6458 */
6459
6460 char tuning_db_file[256] = { 0 };
6461
6462 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6463
6464 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6465
6466 /**
6467 * outfile-check directory
6468 */
6469
6470 char *outfile_check_directory = NULL;
6471
6472 if (outfile_check_dir == NULL)
6473 {
6474 outfile_check_directory = (char *) mymalloc (session_size);
6475
6476 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6477 }
6478 else
6479 {
6480 outfile_check_directory = outfile_check_dir;
6481 }
6482
6483 data.outfile_check_directory = outfile_check_directory;
6484
6485 if (keyspace == 0)
6486 {
6487 struct stat outfile_check_stat;
6488
6489 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6490 {
6491 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6492
6493 if (is_dir == 0)
6494 {
6495 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6496
6497 return (-1);
6498 }
6499 }
6500 else if (outfile_check_dir == NULL)
6501 {
6502 if (mkdir (outfile_check_directory, 0700) == -1)
6503 {
6504 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6505
6506 return (-1);
6507 }
6508 }
6509 }
6510
6511 /**
6512 * special other stuff
6513 */
6514
6515 if (hash_mode == 9710)
6516 {
6517 outfile_format = 5;
6518 outfile_format_chgd = 1;
6519 }
6520
6521 if (hash_mode == 9810)
6522 {
6523 outfile_format = 5;
6524 outfile_format_chgd = 1;
6525 }
6526
6527 if (hash_mode == 10410)
6528 {
6529 outfile_format = 5;
6530 outfile_format_chgd = 1;
6531 }
6532
6533 /**
6534 * store stuff
6535 */
6536
6537 data.hash_mode = hash_mode;
6538 data.restore = restore;
6539 data.restore_timer = restore_timer;
6540 data.restore_disable = restore_disable;
6541 data.status = status;
6542 data.status_timer = status_timer;
6543 data.status_automat = status_automat;
6544 data.loopback = loopback;
6545 data.runtime = runtime;
6546 data.remove = remove;
6547 data.remove_timer = remove_timer;
6548 data.debug_mode = debug_mode;
6549 data.debug_file = debug_file;
6550 data.username = username;
6551 data.quiet = quiet;
6552 data.outfile = outfile;
6553 data.outfile_format = outfile_format;
6554 data.outfile_autohex = outfile_autohex;
6555 data.hex_charset = hex_charset;
6556 data.hex_salt = hex_salt;
6557 data.hex_wordlist = hex_wordlist;
6558 data.separator = separator;
6559 data.rp_files = rp_files;
6560 data.rp_files_cnt = rp_files_cnt;
6561 data.rp_gen = rp_gen;
6562 data.rp_gen_seed = rp_gen_seed;
6563 data.force = force;
6564 data.benchmark = benchmark;
6565 data.benchmark_repeats = benchmark_repeats;
6566 data.skip = skip;
6567 data.limit = limit;
6568 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6569 data.powertune_enable = powertune_enable;
6570 #endif
6571 data.logfile_disable = logfile_disable;
6572 data.truecrypt_keyfiles = truecrypt_keyfiles;
6573 data.scrypt_tmto = scrypt_tmto;
6574 data.workload_profile = workload_profile;
6575
6576 /**
6577 * cpu affinity
6578 */
6579
6580 if (cpu_affinity)
6581 {
6582 set_cpu_affinity (cpu_affinity);
6583 }
6584
6585 if (rp_gen_seed_chgd == 0)
6586 {
6587 srand (proc_start);
6588 }
6589 else
6590 {
6591 srand (rp_gen_seed);
6592 }
6593
6594 /**
6595 * logfile init
6596 */
6597
6598 if (logfile_disable == 0)
6599 {
6600 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6601
6602 char *logfile = (char *) mymalloc (logfile_size);
6603
6604 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6605
6606 data.logfile = logfile;
6607
6608 char *topid = logfile_generate_topid ();
6609
6610 data.topid = topid;
6611 }
6612
6613 // logfile_append() checks for logfile_disable internally to make it easier from here
6614
6615 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6616 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6617 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6618 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6619 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6620 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6621 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6622 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6623 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6624 #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));
6625
6626 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6627 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6628 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6629 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6630 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6631 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6632 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6633 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6634
6635 logfile_top_msg ("START");
6636
6637 logfile_top_uint (attack_mode);
6638 logfile_top_uint (attack_kern);
6639 logfile_top_uint (benchmark);
6640 logfile_top_uint (benchmark_repeats);
6641 logfile_top_uint (bitmap_min);
6642 logfile_top_uint (bitmap_max);
6643 logfile_top_uint (debug_mode);
6644 logfile_top_uint (force);
6645 logfile_top_uint (kernel_accel);
6646 logfile_top_uint (kernel_loops);
6647 logfile_top_uint (gpu_temp_disable);
6648 #ifdef HAVE_HWMON
6649 logfile_top_uint (gpu_temp_abort);
6650 logfile_top_uint (gpu_temp_retain);
6651 #endif
6652 logfile_top_uint (hash_mode);
6653 logfile_top_uint (hex_charset);
6654 logfile_top_uint (hex_salt);
6655 logfile_top_uint (hex_wordlist);
6656 logfile_top_uint (increment);
6657 logfile_top_uint (increment_max);
6658 logfile_top_uint (increment_min);
6659 logfile_top_uint (keyspace);
6660 logfile_top_uint (left);
6661 logfile_top_uint (logfile_disable);
6662 logfile_top_uint (loopback);
6663 logfile_top_uint (markov_classic);
6664 logfile_top_uint (markov_disable);
6665 logfile_top_uint (markov_threshold);
6666 logfile_top_uint (outfile_autohex);
6667 logfile_top_uint (outfile_check_timer);
6668 logfile_top_uint (outfile_format);
6669 logfile_top_uint (potfile_disable);
6670 logfile_top_string (potfile_path);
6671 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6672 logfile_top_uint (powertune_enable);
6673 #endif
6674 logfile_top_uint (scrypt_tmto);
6675 logfile_top_uint (quiet);
6676 logfile_top_uint (remove);
6677 logfile_top_uint (remove_timer);
6678 logfile_top_uint (restore);
6679 logfile_top_uint (restore_disable);
6680 logfile_top_uint (restore_timer);
6681 logfile_top_uint (rp_gen);
6682 logfile_top_uint (rp_gen_func_max);
6683 logfile_top_uint (rp_gen_func_min);
6684 logfile_top_uint (rp_gen_seed);
6685 logfile_top_uint (runtime);
6686 logfile_top_uint (segment_size);
6687 logfile_top_uint (show);
6688 logfile_top_uint (status);
6689 logfile_top_uint (status_automat);
6690 logfile_top_uint (status_timer);
6691 logfile_top_uint (usage);
6692 logfile_top_uint (username);
6693 logfile_top_uint (version);
6694 logfile_top_uint (weak_hash_threshold);
6695 logfile_top_uint (workload_profile);
6696 logfile_top_uint64 (limit);
6697 logfile_top_uint64 (skip);
6698 logfile_top_char (separator);
6699 logfile_top_string (cpu_affinity);
6700 logfile_top_string (custom_charset_1);
6701 logfile_top_string (custom_charset_2);
6702 logfile_top_string (custom_charset_3);
6703 logfile_top_string (custom_charset_4);
6704 logfile_top_string (debug_file);
6705 logfile_top_string (opencl_devices);
6706 logfile_top_string (opencl_platforms);
6707 logfile_top_string (opencl_device_types);
6708 logfile_top_uint (opencl_vector_width);
6709 logfile_top_string (induction_dir);
6710 logfile_top_string (markov_hcstat);
6711 logfile_top_string (outfile);
6712 logfile_top_string (outfile_check_dir);
6713 logfile_top_string (rule_buf_l);
6714 logfile_top_string (rule_buf_r);
6715 logfile_top_string (session);
6716 logfile_top_string (truecrypt_keyfiles);
6717
6718 /**
6719 * Init OpenCL library loader
6720 */
6721
6722 if (keyspace == 0)
6723 {
6724 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6725
6726 ocl_init (ocl);
6727
6728 data.ocl = ocl;
6729 }
6730
6731 /**
6732 * OpenCL platform selection
6733 */
6734
6735 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6736
6737 /**
6738 * OpenCL device selection
6739 */
6740
6741 u32 devices_filter = setup_devices_filter (opencl_devices);
6742
6743 /**
6744 * OpenCL device type selection
6745 */
6746
6747 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6748
6749 /**
6750 * benchmark
6751 */
6752
6753 if (benchmark == 1)
6754 {
6755 /**
6756 * disable useless stuff for benchmark
6757 */
6758
6759 status_timer = 0;
6760 restore_timer = 0;
6761 restore_disable = 1;
6762 potfile_disable = 1;
6763 weak_hash_threshold = 0;
6764 gpu_temp_disable = 1;
6765
6766 data.status_timer = status_timer;
6767 data.restore_timer = restore_timer;
6768 data.restore_disable = restore_disable;
6769
6770 /**
6771 * force attack mode to be bruteforce
6772 */
6773
6774 attack_mode = ATTACK_MODE_BF;
6775 attack_kern = ATTACK_KERN_BF;
6776
6777 if (workload_profile_chgd == 0)
6778 {
6779 workload_profile = 3;
6780
6781 data.workload_profile = workload_profile;
6782 }
6783 }
6784
6785 /**
6786 * config
6787 */
6788
6789 uint hash_type = 0;
6790 uint salt_type = 0;
6791 uint attack_exec = 0;
6792 uint opts_type = 0;
6793 uint kern_type = 0;
6794 uint dgst_size = 0;
6795 uint esalt_size = 0;
6796 uint opti_type = 0;
6797 uint dgst_pos0 = -1;
6798 uint dgst_pos1 = -1;
6799 uint dgst_pos2 = -1;
6800 uint dgst_pos3 = -1;
6801
6802 int (*parse_func) (char *, uint, hash_t *);
6803 int (*sort_by_digest) (const void *, const void *);
6804
6805 uint algorithm_pos = 0;
6806 uint algorithm_max = 1;
6807
6808 uint *algorithms = default_benchmark_algorithms;
6809
6810 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6811
6812 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6813 {
6814 /*
6815 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6816 * the following algos are skipped entirely
6817 */
6818
6819 if (algorithm_pos > 0)
6820 {
6821 local_free (rd);
6822
6823 rd = init_restore (argc, argv);
6824
6825 data.rd = rd;
6826 }
6827
6828 /**
6829 * update hash_mode in case of multihash benchmark
6830 */
6831
6832 if (benchmark == 1)
6833 {
6834 if (hash_mode_chgd == 0)
6835 {
6836 hash_mode = algorithms[algorithm_pos];
6837
6838 data.hash_mode = hash_mode;
6839 }
6840
6841 quiet = 1;
6842
6843 data.quiet = quiet;
6844 }
6845
6846 switch (hash_mode)
6847 {
6848 case 0: hash_type = HASH_TYPE_MD5;
6849 salt_type = SALT_TYPE_NONE;
6850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6851 opts_type = OPTS_TYPE_PT_GENERATE_LE
6852 | OPTS_TYPE_PT_ADD80
6853 | OPTS_TYPE_PT_ADDBITS14;
6854 kern_type = KERN_TYPE_MD5;
6855 dgst_size = DGST_SIZE_4_4;
6856 parse_func = md5_parse_hash;
6857 sort_by_digest = sort_by_digest_4_4;
6858 opti_type = OPTI_TYPE_ZERO_BYTE
6859 | OPTI_TYPE_PRECOMPUTE_INIT
6860 | OPTI_TYPE_PRECOMPUTE_MERKLE
6861 | OPTI_TYPE_MEET_IN_MIDDLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_NOT_SALTED
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 0;
6867 dgst_pos1 = 3;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 10: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_ST_ADD80
6877 | OPTS_TYPE_ST_ADDBITS14;
6878 kern_type = KERN_TYPE_MD5_PWSLT;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5s_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_MEET_IN_MIDDLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_APPENDED_SALT
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 11: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_INTERN;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_ST_ADD80
6901 | OPTS_TYPE_ST_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_PWSLT;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = joomla_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_MEET_IN_MIDDLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_APPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 12: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_INTERN;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_PWSLT;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = postgresql_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_MEET_IN_MIDDLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 20: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_PT_ADD80
6949 | OPTS_TYPE_PT_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_SLTPW;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = md5s_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_EARLY_SKIP
6958 | OPTI_TYPE_NOT_ITERATED
6959 | OPTI_TYPE_PREPENDED_SALT
6960 | OPTI_TYPE_RAW_HASH;
6961 dgst_pos0 = 0;
6962 dgst_pos1 = 3;
6963 dgst_pos2 = 2;
6964 dgst_pos3 = 1;
6965 break;
6966
6967 case 21: hash_type = HASH_TYPE_MD5;
6968 salt_type = SALT_TYPE_INTERN;
6969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6970 opts_type = OPTS_TYPE_PT_GENERATE_LE
6971 | OPTS_TYPE_PT_ADD80
6972 | OPTS_TYPE_PT_ADDBITS14;
6973 kern_type = KERN_TYPE_MD5_SLTPW;
6974 dgst_size = DGST_SIZE_4_4;
6975 parse_func = osc_parse_hash;
6976 sort_by_digest = sort_by_digest_4_4;
6977 opti_type = OPTI_TYPE_ZERO_BYTE
6978 | OPTI_TYPE_PRECOMPUTE_INIT
6979 | OPTI_TYPE_PRECOMPUTE_MERKLE
6980 | OPTI_TYPE_EARLY_SKIP
6981 | OPTI_TYPE_NOT_ITERATED
6982 | OPTI_TYPE_PREPENDED_SALT
6983 | OPTI_TYPE_RAW_HASH;
6984 dgst_pos0 = 0;
6985 dgst_pos1 = 3;
6986 dgst_pos2 = 2;
6987 dgst_pos3 = 1;
6988 break;
6989
6990 case 22: hash_type = HASH_TYPE_MD5;
6991 salt_type = SALT_TYPE_EMBEDDED;
6992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6993 opts_type = OPTS_TYPE_PT_GENERATE_LE
6994 | OPTS_TYPE_PT_ADD80
6995 | OPTS_TYPE_PT_ADDBITS14;
6996 kern_type = KERN_TYPE_MD5_SLTPW;
6997 dgst_size = DGST_SIZE_4_4;
6998 parse_func = netscreen_parse_hash;
6999 sort_by_digest = sort_by_digest_4_4;
7000 opti_type = OPTI_TYPE_ZERO_BYTE
7001 | OPTI_TYPE_PRECOMPUTE_INIT
7002 | OPTI_TYPE_PRECOMPUTE_MERKLE
7003 | OPTI_TYPE_EARLY_SKIP
7004 | OPTI_TYPE_NOT_ITERATED
7005 | OPTI_TYPE_PREPENDED_SALT
7006 | OPTI_TYPE_RAW_HASH;
7007 dgst_pos0 = 0;
7008 dgst_pos1 = 3;
7009 dgst_pos2 = 2;
7010 dgst_pos3 = 1;
7011 break;
7012
7013 case 23: hash_type = HASH_TYPE_MD5;
7014 salt_type = SALT_TYPE_EMBEDDED;
7015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7016 opts_type = OPTS_TYPE_PT_GENERATE_LE
7017 | OPTS_TYPE_PT_ADD80
7018 | OPTS_TYPE_PT_ADDBITS14;
7019 kern_type = KERN_TYPE_MD5_SLTPW;
7020 dgst_size = DGST_SIZE_4_4;
7021 parse_func = skype_parse_hash;
7022 sort_by_digest = sort_by_digest_4_4;
7023 opti_type = OPTI_TYPE_ZERO_BYTE
7024 | OPTI_TYPE_PRECOMPUTE_INIT
7025 | OPTI_TYPE_PRECOMPUTE_MERKLE
7026 | OPTI_TYPE_EARLY_SKIP
7027 | OPTI_TYPE_NOT_ITERATED
7028 | OPTI_TYPE_PREPENDED_SALT
7029 | OPTI_TYPE_RAW_HASH;
7030 dgst_pos0 = 0;
7031 dgst_pos1 = 3;
7032 dgst_pos2 = 2;
7033 dgst_pos3 = 1;
7034 break;
7035
7036 case 30: hash_type = HASH_TYPE_MD5;
7037 salt_type = SALT_TYPE_INTERN;
7038 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7039 opts_type = OPTS_TYPE_PT_GENERATE_LE
7040 | OPTS_TYPE_PT_UNICODE
7041 | OPTS_TYPE_ST_ADD80
7042 | OPTS_TYPE_ST_ADDBITS14;
7043 kern_type = KERN_TYPE_MD5_PWUSLT;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = md5s_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_MEET_IN_MIDDLE
7051 | OPTI_TYPE_EARLY_SKIP
7052 | OPTI_TYPE_NOT_ITERATED
7053 | OPTI_TYPE_APPENDED_SALT
7054 | OPTI_TYPE_RAW_HASH;
7055 dgst_pos0 = 0;
7056 dgst_pos1 = 3;
7057 dgst_pos2 = 2;
7058 dgst_pos3 = 1;
7059 break;
7060
7061 case 40: hash_type = HASH_TYPE_MD5;
7062 salt_type = SALT_TYPE_INTERN;
7063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7064 opts_type = OPTS_TYPE_PT_GENERATE_LE
7065 | OPTS_TYPE_PT_ADD80
7066 | OPTS_TYPE_PT_ADDBITS14
7067 | OPTS_TYPE_PT_UNICODE;
7068 kern_type = KERN_TYPE_MD5_SLTPWU;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = md5s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_PREPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 50: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS14;
7091 kern_type = KERN_TYPE_HMACMD5_PW;
7092 dgst_size = DGST_SIZE_4_4;
7093 parse_func = hmacmd5_parse_hash;
7094 sort_by_digest = sort_by_digest_4_4;
7095 opti_type = OPTI_TYPE_ZERO_BYTE
7096 | OPTI_TYPE_NOT_ITERATED;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 60: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_PT_ADD80
7108 | OPTS_TYPE_PT_ADDBITS14;
7109 kern_type = KERN_TYPE_HMACMD5_SLT;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = hmacmd5_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_NOT_ITERATED;
7115 dgst_pos0 = 0;
7116 dgst_pos1 = 3;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 100: hash_type = HASH_TYPE_SHA1;
7122 salt_type = SALT_TYPE_NONE;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_BE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS15;
7127 kern_type = KERN_TYPE_SHA1;
7128 dgst_size = DGST_SIZE_4_5;
7129 parse_func = sha1_parse_hash;
7130 sort_by_digest = sort_by_digest_4_5;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_PRECOMPUTE_INIT
7133 | OPTI_TYPE_PRECOMPUTE_MERKLE
7134 | OPTI_TYPE_EARLY_SKIP
7135 | OPTI_TYPE_NOT_ITERATED
7136 | OPTI_TYPE_NOT_SALTED
7137 | OPTI_TYPE_RAW_HASH;
7138 dgst_pos0 = 3;
7139 dgst_pos1 = 4;
7140 dgst_pos2 = 2;
7141 dgst_pos3 = 1;
7142 break;
7143
7144 case 101: hash_type = HASH_TYPE_SHA1;
7145 salt_type = SALT_TYPE_NONE;
7146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7147 opts_type = OPTS_TYPE_PT_GENERATE_BE
7148 | OPTS_TYPE_PT_ADD80
7149 | OPTS_TYPE_PT_ADDBITS15;
7150 kern_type = KERN_TYPE_SHA1;
7151 dgst_size = DGST_SIZE_4_5;
7152 parse_func = sha1b64_parse_hash;
7153 sort_by_digest = sort_by_digest_4_5;
7154 opti_type = OPTI_TYPE_ZERO_BYTE
7155 | OPTI_TYPE_PRECOMPUTE_INIT
7156 | OPTI_TYPE_PRECOMPUTE_MERKLE
7157 | OPTI_TYPE_EARLY_SKIP
7158 | OPTI_TYPE_NOT_ITERATED
7159 | OPTI_TYPE_NOT_SALTED
7160 | OPTI_TYPE_RAW_HASH;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 110: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_INTERN;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_ST_ADD80
7172 | OPTS_TYPE_ST_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_PWSLT;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1s_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_PRECOMPUTE_MERKLE
7180 | OPTI_TYPE_EARLY_SKIP
7181 | OPTI_TYPE_NOT_ITERATED
7182 | OPTI_TYPE_APPENDED_SALT
7183 | OPTI_TYPE_RAW_HASH;
7184 dgst_pos0 = 3;
7185 dgst_pos1 = 4;
7186 dgst_pos2 = 2;
7187 dgst_pos3 = 1;
7188 break;
7189
7190 case 111: hash_type = HASH_TYPE_SHA1;
7191 salt_type = SALT_TYPE_EMBEDDED;
7192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7193 opts_type = OPTS_TYPE_PT_GENERATE_BE
7194 | OPTS_TYPE_ST_ADD80
7195 | OPTS_TYPE_ST_ADDBITS15;
7196 kern_type = KERN_TYPE_SHA1_PWSLT;
7197 dgst_size = DGST_SIZE_4_5;
7198 parse_func = sha1b64s_parse_hash;
7199 sort_by_digest = sort_by_digest_4_5;
7200 opti_type = OPTI_TYPE_ZERO_BYTE
7201 | OPTI_TYPE_PRECOMPUTE_INIT
7202 | OPTI_TYPE_PRECOMPUTE_MERKLE
7203 | OPTI_TYPE_EARLY_SKIP
7204 | OPTI_TYPE_NOT_ITERATED
7205 | OPTI_TYPE_APPENDED_SALT
7206 | OPTI_TYPE_RAW_HASH;
7207 dgst_pos0 = 3;
7208 dgst_pos1 = 4;
7209 dgst_pos2 = 2;
7210 dgst_pos3 = 1;
7211 break;
7212
7213 case 112: hash_type = HASH_TYPE_SHA1;
7214 salt_type = SALT_TYPE_INTERN;
7215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7216 opts_type = OPTS_TYPE_PT_GENERATE_BE
7217 | OPTS_TYPE_ST_ADD80
7218 | OPTS_TYPE_ST_ADDBITS15
7219 | OPTS_TYPE_ST_HEX;
7220 kern_type = KERN_TYPE_SHA1_PWSLT;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = oracles_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_APPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 120: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_PT_ADD80
7242 | OPTS_TYPE_PT_ADDBITS15;
7243 kern_type = KERN_TYPE_SHA1_SLTPW;
7244 dgst_size = DGST_SIZE_4_5;
7245 parse_func = sha1s_parse_hash;
7246 sort_by_digest = sort_by_digest_4_5;
7247 opti_type = OPTI_TYPE_ZERO_BYTE
7248 | OPTI_TYPE_PRECOMPUTE_INIT
7249 | OPTI_TYPE_PRECOMPUTE_MERKLE
7250 | OPTI_TYPE_EARLY_SKIP
7251 | OPTI_TYPE_NOT_ITERATED
7252 | OPTI_TYPE_PREPENDED_SALT
7253 | OPTI_TYPE_RAW_HASH;
7254 dgst_pos0 = 3;
7255 dgst_pos1 = 4;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 121: hash_type = HASH_TYPE_SHA1;
7261 salt_type = SALT_TYPE_INTERN;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_BE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS15
7266 | OPTS_TYPE_ST_LOWER;
7267 kern_type = KERN_TYPE_SHA1_SLTPW;
7268 dgst_size = DGST_SIZE_4_5;
7269 parse_func = smf_parse_hash;
7270 sort_by_digest = sort_by_digest_4_5;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 122: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_EMBEDDED;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15
7290 | OPTS_TYPE_ST_HEX;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = osx1_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 124: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15;
7314 kern_type = KERN_TYPE_SHA1_SLTPW;
7315 dgst_size = DGST_SIZE_4_5;
7316 parse_func = djangosha1_parse_hash;
7317 sort_by_digest = sort_by_digest_4_5;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_PRECOMPUTE_INIT
7320 | OPTI_TYPE_PRECOMPUTE_MERKLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_PREPENDED_SALT
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 3;
7326 dgst_pos1 = 4;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 125: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_EMBEDDED;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15
7337 | OPTS_TYPE_ST_HEX;
7338 kern_type = KERN_TYPE_SHA1_SLTPW;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = arubaos_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_PREPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 130: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_INTERN;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_UNICODE
7360 | OPTS_TYPE_ST_ADD80
7361 | OPTS_TYPE_ST_ADDBITS15;
7362 kern_type = KERN_TYPE_SHA1_PWUSLT;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = sha1s_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_APPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 131: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_EMBEDDED;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_UNICODE
7384 | OPTS_TYPE_PT_UPPER
7385 | OPTS_TYPE_ST_ADD80
7386 | OPTS_TYPE_ST_ADDBITS15
7387 | OPTS_TYPE_ST_HEX;
7388 kern_type = KERN_TYPE_SHA1_PWUSLT;
7389 dgst_size = DGST_SIZE_4_5;
7390 parse_func = mssql2000_parse_hash;
7391 sort_by_digest = sort_by_digest_4_5;
7392 opti_type = OPTI_TYPE_ZERO_BYTE
7393 | OPTI_TYPE_PRECOMPUTE_INIT
7394 | OPTI_TYPE_PRECOMPUTE_MERKLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_APPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 132: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_EMBEDDED;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_PT_UNICODE
7410 | OPTS_TYPE_ST_ADD80
7411 | OPTS_TYPE_ST_ADDBITS15
7412 | OPTS_TYPE_ST_HEX;
7413 kern_type = KERN_TYPE_SHA1_PWUSLT;
7414 dgst_size = DGST_SIZE_4_5;
7415 parse_func = mssql2005_parse_hash;
7416 sort_by_digest = sort_by_digest_4_5;
7417 opti_type = OPTI_TYPE_ZERO_BYTE
7418 | OPTI_TYPE_PRECOMPUTE_INIT
7419 | OPTI_TYPE_PRECOMPUTE_MERKLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_APPENDED_SALT
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 3;
7425 dgst_pos1 = 4;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 133: hash_type = HASH_TYPE_SHA1;
7431 salt_type = SALT_TYPE_EMBEDDED;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_BE
7434 | OPTS_TYPE_PT_UNICODE
7435 | OPTS_TYPE_ST_ADD80
7436 | OPTS_TYPE_ST_ADDBITS15;
7437 kern_type = KERN_TYPE_SHA1_PWUSLT;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = peoplesoft_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_APPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 140: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_INTERN;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_ADD80
7459 | OPTS_TYPE_PT_ADDBITS15
7460 | OPTS_TYPE_PT_UNICODE;
7461 kern_type = KERN_TYPE_SHA1_SLTPWU;
7462 dgst_size = DGST_SIZE_4_5;
7463 parse_func = sha1s_parse_hash;
7464 sort_by_digest = sort_by_digest_4_5;
7465 opti_type = OPTI_TYPE_ZERO_BYTE
7466 | OPTI_TYPE_PRECOMPUTE_INIT
7467 | OPTI_TYPE_PRECOMPUTE_MERKLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_PREPENDED_SALT
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 3;
7473 dgst_pos1 = 4;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 141: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_EMBEDDED;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_BE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS15
7484 | OPTS_TYPE_PT_UNICODE
7485 | OPTS_TYPE_ST_BASE64;
7486 kern_type = KERN_TYPE_SHA1_SLTPWU;
7487 dgst_size = DGST_SIZE_4_5;
7488 parse_func = episerver_parse_hash;
7489 sort_by_digest = sort_by_digest_4_5;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_EARLY_SKIP
7494 | OPTI_TYPE_NOT_ITERATED
7495 | OPTI_TYPE_PREPENDED_SALT
7496 | OPTI_TYPE_RAW_HASH;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 4;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 1;
7501 break;
7502
7503 case 150: hash_type = HASH_TYPE_SHA1;
7504 salt_type = SALT_TYPE_INTERN;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_ST_ADD80
7508 | OPTS_TYPE_ST_ADDBITS15;
7509 kern_type = KERN_TYPE_HMACSHA1_PW;
7510 dgst_size = DGST_SIZE_4_5;
7511 parse_func = hmacsha1_parse_hash;
7512 sort_by_digest = sort_by_digest_4_5;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_NOT_ITERATED;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 160: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_INTERN;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15;
7527 kern_type = KERN_TYPE_HMACSHA1_SLT;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = hmacsha1_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_NOT_ITERATED;
7533 dgst_pos0 = 3;
7534 dgst_pos1 = 4;
7535 dgst_pos2 = 2;
7536 dgst_pos3 = 1;
7537 break;
7538
7539 case 190: hash_type = HASH_TYPE_SHA1;
7540 salt_type = SALT_TYPE_NONE;
7541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7542 opts_type = OPTS_TYPE_PT_GENERATE_BE
7543 | OPTS_TYPE_PT_ADD80
7544 | OPTS_TYPE_PT_ADDBITS15;
7545 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7546 dgst_size = DGST_SIZE_4_5;
7547 parse_func = sha1linkedin_parse_hash;
7548 sort_by_digest = sort_by_digest_4_5;
7549 opti_type = OPTI_TYPE_ZERO_BYTE
7550 | OPTI_TYPE_PRECOMPUTE_INIT
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_NOT_SALTED;
7554 dgst_pos0 = 0;
7555 dgst_pos1 = 4;
7556 dgst_pos2 = 3;
7557 dgst_pos3 = 2;
7558 break;
7559
7560 case 200: hash_type = HASH_TYPE_MYSQL;
7561 salt_type = SALT_TYPE_NONE;
7562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7563 opts_type = 0;
7564 kern_type = KERN_TYPE_MYSQL;
7565 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7566 parse_func = mysql323_parse_hash;
7567 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7568 opti_type = OPTI_TYPE_ZERO_BYTE;
7569 dgst_pos0 = 0;
7570 dgst_pos1 = 1;
7571 dgst_pos2 = 2;
7572 dgst_pos3 = 3;
7573 break;
7574
7575 case 300: hash_type = HASH_TYPE_SHA1;
7576 salt_type = SALT_TYPE_NONE;
7577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7578 opts_type = OPTS_TYPE_PT_GENERATE_BE
7579 | OPTS_TYPE_PT_ADD80
7580 | OPTS_TYPE_PT_ADDBITS15;
7581 kern_type = KERN_TYPE_MYSQL41;
7582 dgst_size = DGST_SIZE_4_5;
7583 parse_func = sha1_parse_hash;
7584 sort_by_digest = sort_by_digest_4_5;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_PRECOMPUTE_INIT
7587 | OPTI_TYPE_PRECOMPUTE_MERKLE
7588 | OPTI_TYPE_EARLY_SKIP
7589 | OPTI_TYPE_NOT_ITERATED
7590 | OPTI_TYPE_NOT_SALTED;
7591 dgst_pos0 = 3;
7592 dgst_pos1 = 4;
7593 dgst_pos2 = 2;
7594 dgst_pos3 = 1;
7595 break;
7596
7597 case 400: hash_type = HASH_TYPE_MD5;
7598 salt_type = SALT_TYPE_EMBEDDED;
7599 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7600 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7601 kern_type = KERN_TYPE_PHPASS;
7602 dgst_size = DGST_SIZE_4_4;
7603 parse_func = phpass_parse_hash;
7604 sort_by_digest = sort_by_digest_4_4;
7605 opti_type = OPTI_TYPE_ZERO_BYTE;
7606 dgst_pos0 = 0;
7607 dgst_pos1 = 1;
7608 dgst_pos2 = 2;
7609 dgst_pos3 = 3;
7610 break;
7611
7612 case 500: hash_type = HASH_TYPE_MD5;
7613 salt_type = SALT_TYPE_EMBEDDED;
7614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7616 kern_type = KERN_TYPE_MD5CRYPT;
7617 dgst_size = DGST_SIZE_4_4;
7618 parse_func = md5crypt_parse_hash;
7619 sort_by_digest = sort_by_digest_4_4;
7620 opti_type = OPTI_TYPE_ZERO_BYTE;
7621 dgst_pos0 = 0;
7622 dgst_pos1 = 1;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 3;
7625 break;
7626
7627 case 501: hash_type = HASH_TYPE_MD5;
7628 salt_type = SALT_TYPE_EMBEDDED;
7629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_LE
7631 | OPTS_TYPE_HASH_COPY;
7632 kern_type = KERN_TYPE_MD5CRYPT;
7633 dgst_size = DGST_SIZE_4_4;
7634 parse_func = juniper_parse_hash;
7635 sort_by_digest = sort_by_digest_4_4;
7636 opti_type = OPTI_TYPE_ZERO_BYTE;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 1;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 3;
7641 break;
7642
7643 case 900: hash_type = HASH_TYPE_MD4;
7644 salt_type = SALT_TYPE_NONE;
7645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_LE
7647 | OPTS_TYPE_PT_ADD80
7648 | OPTS_TYPE_PT_ADDBITS14;
7649 kern_type = KERN_TYPE_MD4;
7650 dgst_size = DGST_SIZE_4_4;
7651 parse_func = md4_parse_hash;
7652 sort_by_digest = sort_by_digest_4_4;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_MEET_IN_MIDDLE
7657 | OPTI_TYPE_EARLY_SKIP
7658 | OPTI_TYPE_NOT_ITERATED
7659 | OPTI_TYPE_NOT_SALTED
7660 | OPTI_TYPE_RAW_HASH;
7661 dgst_pos0 = 0;
7662 dgst_pos1 = 3;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 1;
7665 break;
7666
7667 case 1000: hash_type = HASH_TYPE_MD4;
7668 salt_type = SALT_TYPE_NONE;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_LE
7671 | OPTS_TYPE_PT_ADD80
7672 | OPTS_TYPE_PT_ADDBITS14
7673 | OPTS_TYPE_PT_UNICODE;
7674 kern_type = KERN_TYPE_MD4_PWU;
7675 dgst_size = DGST_SIZE_4_4;
7676 parse_func = md4_parse_hash;
7677 sort_by_digest = sort_by_digest_4_4;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_MEET_IN_MIDDLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_NOT_SALTED
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 0;
7687 dgst_pos1 = 3;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 1;
7690 break;
7691
7692 case 1100: hash_type = HASH_TYPE_MD4;
7693 salt_type = SALT_TYPE_INTERN;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_LE
7696 | OPTS_TYPE_PT_ADD80
7697 | OPTS_TYPE_PT_ADDBITS14
7698 | OPTS_TYPE_PT_UNICODE
7699 | OPTS_TYPE_ST_ADD80
7700 | OPTS_TYPE_ST_UNICODE
7701 | OPTS_TYPE_ST_LOWER;
7702 kern_type = KERN_TYPE_MD44_PWUSLT;
7703 dgst_size = DGST_SIZE_4_4;
7704 parse_func = dcc_parse_hash;
7705 sort_by_digest = sort_by_digest_4_4;
7706 opti_type = OPTI_TYPE_ZERO_BYTE
7707 | OPTI_TYPE_PRECOMPUTE_INIT
7708 | OPTI_TYPE_PRECOMPUTE_MERKLE
7709 | OPTI_TYPE_EARLY_SKIP
7710 | OPTI_TYPE_NOT_ITERATED;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 3;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 1400: hash_type = HASH_TYPE_SHA256;
7718 salt_type = SALT_TYPE_NONE;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_ADD80
7722 | OPTS_TYPE_PT_ADDBITS15;
7723 kern_type = KERN_TYPE_SHA256;
7724 dgst_size = DGST_SIZE_4_8;
7725 parse_func = sha256_parse_hash;
7726 sort_by_digest = sort_by_digest_4_8;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED
7732 | OPTI_TYPE_NOT_SALTED
7733 | OPTI_TYPE_RAW_HASH;
7734 dgst_pos0 = 3;
7735 dgst_pos1 = 7;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 6;
7738 break;
7739
7740 case 1410: hash_type = HASH_TYPE_SHA256;
7741 salt_type = SALT_TYPE_INTERN;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_BE
7744 | OPTS_TYPE_ST_ADD80
7745 | OPTS_TYPE_ST_ADDBITS15;
7746 kern_type = KERN_TYPE_SHA256_PWSLT;
7747 dgst_size = DGST_SIZE_4_8;
7748 parse_func = sha256s_parse_hash;
7749 sort_by_digest = sort_by_digest_4_8;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_PRECOMPUTE_INIT
7752 | OPTI_TYPE_PRECOMPUTE_MERKLE
7753 | OPTI_TYPE_EARLY_SKIP
7754 | OPTI_TYPE_NOT_ITERATED
7755 | OPTI_TYPE_APPENDED_SALT
7756 | OPTI_TYPE_RAW_HASH;
7757 dgst_pos0 = 3;
7758 dgst_pos1 = 7;
7759 dgst_pos2 = 2;
7760 dgst_pos3 = 6;
7761 break;
7762
7763 case 1420: hash_type = HASH_TYPE_SHA256;
7764 salt_type = SALT_TYPE_INTERN;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = OPTS_TYPE_PT_GENERATE_BE
7767 | OPTS_TYPE_PT_ADD80
7768 | OPTS_TYPE_PT_ADDBITS15;
7769 kern_type = KERN_TYPE_SHA256_SLTPW;
7770 dgst_size = DGST_SIZE_4_8;
7771 parse_func = sha256s_parse_hash;
7772 sort_by_digest = sort_by_digest_4_8;
7773 opti_type = OPTI_TYPE_ZERO_BYTE
7774 | OPTI_TYPE_PRECOMPUTE_INIT
7775 | OPTI_TYPE_PRECOMPUTE_MERKLE
7776 | OPTI_TYPE_EARLY_SKIP
7777 | OPTI_TYPE_NOT_ITERATED
7778 | OPTI_TYPE_PREPENDED_SALT
7779 | OPTI_TYPE_RAW_HASH;
7780 dgst_pos0 = 3;
7781 dgst_pos1 = 7;
7782 dgst_pos2 = 2;
7783 dgst_pos3 = 6;
7784 break;
7785
7786 case 1421: hash_type = HASH_TYPE_SHA256;
7787 salt_type = SALT_TYPE_EMBEDDED;
7788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7789 opts_type = OPTS_TYPE_PT_GENERATE_BE
7790 | OPTS_TYPE_PT_ADD80
7791 | OPTS_TYPE_PT_ADDBITS15;
7792 kern_type = KERN_TYPE_SHA256_SLTPW;
7793 dgst_size = DGST_SIZE_4_8;
7794 parse_func = hmailserver_parse_hash;
7795 sort_by_digest = sort_by_digest_4_8;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP
7800 | OPTI_TYPE_NOT_ITERATED
7801 | OPTI_TYPE_PREPENDED_SALT
7802 | OPTI_TYPE_RAW_HASH;
7803 dgst_pos0 = 3;
7804 dgst_pos1 = 7;
7805 dgst_pos2 = 2;
7806 dgst_pos3 = 6;
7807 break;
7808
7809 case 1430: hash_type = HASH_TYPE_SHA256;
7810 salt_type = SALT_TYPE_INTERN;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_BE
7813 | OPTS_TYPE_PT_UNICODE
7814 | OPTS_TYPE_ST_ADD80
7815 | OPTS_TYPE_ST_ADDBITS15;
7816 kern_type = KERN_TYPE_SHA256_PWUSLT;
7817 dgst_size = DGST_SIZE_4_8;
7818 parse_func = sha256s_parse_hash;
7819 sort_by_digest = sort_by_digest_4_8;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_APPENDED_SALT
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 3;
7828 dgst_pos1 = 7;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 6;
7831 break;
7832
7833 case 1440: hash_type = HASH_TYPE_SHA256;
7834 salt_type = SALT_TYPE_INTERN;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_PT_ADD80
7838 | OPTS_TYPE_PT_ADDBITS15
7839 | OPTS_TYPE_PT_UNICODE;
7840 kern_type = KERN_TYPE_SHA256_SLTPWU;
7841 dgst_size = DGST_SIZE_4_8;
7842 parse_func = sha256s_parse_hash;
7843 sort_by_digest = sort_by_digest_4_8;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_EARLY_SKIP
7848 | OPTI_TYPE_NOT_ITERATED
7849 | OPTI_TYPE_PREPENDED_SALT
7850 | OPTI_TYPE_RAW_HASH;
7851 dgst_pos0 = 3;
7852 dgst_pos1 = 7;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 6;
7855 break;
7856
7857 case 1441: hash_type = HASH_TYPE_SHA256;
7858 salt_type = SALT_TYPE_EMBEDDED;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_BE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS15
7863 | OPTS_TYPE_PT_UNICODE
7864 | OPTS_TYPE_ST_BASE64;
7865 kern_type = KERN_TYPE_SHA256_SLTPWU;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = episerver4_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_EARLY_SKIP
7873 | OPTI_TYPE_NOT_ITERATED
7874 | OPTI_TYPE_PREPENDED_SALT
7875 | OPTI_TYPE_RAW_HASH;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 7;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 6;
7880 break;
7881
7882 case 1450: hash_type = HASH_TYPE_SHA256;
7883 salt_type = SALT_TYPE_INTERN;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_ST_ADD80;
7887 kern_type = KERN_TYPE_HMACSHA256_PW;
7888 dgst_size = DGST_SIZE_4_8;
7889 parse_func = hmacsha256_parse_hash;
7890 sort_by_digest = sort_by_digest_4_8;
7891 opti_type = OPTI_TYPE_ZERO_BYTE
7892 | OPTI_TYPE_NOT_ITERATED;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1460: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_HMACSHA256_SLT;
7906 dgst_size = DGST_SIZE_4_8;
7907 parse_func = hmacsha256_parse_hash;
7908 sort_by_digest = sort_by_digest_4_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_NOT_ITERATED;
7911 dgst_pos0 = 3;
7912 dgst_pos1 = 7;
7913 dgst_pos2 = 2;
7914 dgst_pos3 = 6;
7915 break;
7916
7917 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7918 salt_type = SALT_TYPE_EMBEDDED;
7919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7920 opts_type = OPTS_TYPE_PT_GENERATE_LE
7921 | OPTS_TYPE_PT_BITSLICE;
7922 kern_type = KERN_TYPE_DESCRYPT;
7923 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7924 parse_func = descrypt_parse_hash;
7925 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7926 opti_type = OPTI_TYPE_ZERO_BYTE
7927 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7928 dgst_pos0 = 0;
7929 dgst_pos1 = 1;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 3;
7932 break;
7933
7934 case 1600: hash_type = HASH_TYPE_MD5;
7935 salt_type = SALT_TYPE_EMBEDDED;
7936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7938 kern_type = KERN_TYPE_APR1CRYPT;
7939 dgst_size = DGST_SIZE_4_4;
7940 parse_func = md5apr1_parse_hash;
7941 sort_by_digest = sort_by_digest_4_4;
7942 opti_type = OPTI_TYPE_ZERO_BYTE;
7943 dgst_pos0 = 0;
7944 dgst_pos1 = 1;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 3;
7947 break;
7948
7949 case 1700: hash_type = HASH_TYPE_SHA512;
7950 salt_type = SALT_TYPE_NONE;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_ADD80
7954 | OPTS_TYPE_PT_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA512;
7956 dgst_size = DGST_SIZE_8_8;
7957 parse_func = sha512_parse_hash;
7958 sort_by_digest = sort_by_digest_8_8;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_NOT_SALTED
7965 | OPTI_TYPE_USES_BITS_64
7966 | OPTI_TYPE_RAW_HASH;
7967 dgst_pos0 = 14;
7968 dgst_pos1 = 15;
7969 dgst_pos2 = 6;
7970 dgst_pos3 = 7;
7971 break;
7972
7973 case 1710: hash_type = HASH_TYPE_SHA512;
7974 salt_type = SALT_TYPE_INTERN;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_ST_ADD80
7978 | OPTS_TYPE_ST_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA512_PWSLT;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = sha512s_parse_hash;
7982 sort_by_digest = sort_by_digest_8_8;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_APPENDED_SALT
7989 | OPTI_TYPE_USES_BITS_64
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 14;
7992 dgst_pos1 = 15;
7993 dgst_pos2 = 6;
7994 dgst_pos3 = 7;
7995 break;
7996
7997 case 1711: hash_type = HASH_TYPE_SHA512;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_ST_ADD80
8002 | OPTS_TYPE_ST_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA512_PWSLT;
8004 dgst_size = DGST_SIZE_8_8;
8005 parse_func = sha512b64s_parse_hash;
8006 sort_by_digest = sort_by_digest_8_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_APPENDED_SALT
8013 | OPTI_TYPE_USES_BITS_64
8014 | OPTI_TYPE_RAW_HASH;
8015 dgst_pos0 = 14;
8016 dgst_pos1 = 15;
8017 dgst_pos2 = 6;
8018 dgst_pos3 = 7;
8019 break;
8020
8021 case 1720: hash_type = HASH_TYPE_SHA512;
8022 salt_type = SALT_TYPE_INTERN;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_PT_ADD80
8026 | OPTS_TYPE_PT_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA512_SLTPW;
8028 dgst_size = DGST_SIZE_8_8;
8029 parse_func = sha512s_parse_hash;
8030 sort_by_digest = sort_by_digest_8_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_PREPENDED_SALT
8037 | OPTI_TYPE_USES_BITS_64
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 14;
8040 dgst_pos1 = 15;
8041 dgst_pos2 = 6;
8042 dgst_pos3 = 7;
8043 break;
8044
8045 case 1722: hash_type = HASH_TYPE_SHA512;
8046 salt_type = SALT_TYPE_EMBEDDED;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_PT_ADD80
8050 | OPTS_TYPE_PT_ADDBITS15
8051 | OPTS_TYPE_ST_HEX;
8052 kern_type = KERN_TYPE_SHA512_SLTPW;
8053 dgst_size = DGST_SIZE_8_8;
8054 parse_func = osx512_parse_hash;
8055 sort_by_digest = sort_by_digest_8_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_PRECOMPUTE_MERKLE
8059 | OPTI_TYPE_EARLY_SKIP
8060 | OPTI_TYPE_NOT_ITERATED
8061 | OPTI_TYPE_PREPENDED_SALT
8062 | OPTI_TYPE_USES_BITS_64
8063 | OPTI_TYPE_RAW_HASH;
8064 dgst_pos0 = 14;
8065 dgst_pos1 = 15;
8066 dgst_pos2 = 6;
8067 dgst_pos3 = 7;
8068 break;
8069
8070 case 1730: hash_type = HASH_TYPE_SHA512;
8071 salt_type = SALT_TYPE_INTERN;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_BE
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_ADD80
8076 | OPTS_TYPE_ST_ADDBITS15;
8077 kern_type = KERN_TYPE_SHA512_PWSLTU;
8078 dgst_size = DGST_SIZE_8_8;
8079 parse_func = sha512s_parse_hash;
8080 sort_by_digest = sort_by_digest_8_8;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP
8085 | OPTI_TYPE_NOT_ITERATED
8086 | OPTI_TYPE_APPENDED_SALT
8087 | OPTI_TYPE_USES_BITS_64
8088 | OPTI_TYPE_RAW_HASH;
8089 dgst_pos0 = 14;
8090 dgst_pos1 = 15;
8091 dgst_pos2 = 6;
8092 dgst_pos3 = 7;
8093 break;
8094
8095 case 1731: hash_type = HASH_TYPE_SHA512;
8096 salt_type = SALT_TYPE_EMBEDDED;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_BE
8099 | OPTS_TYPE_PT_UNICODE
8100 | OPTS_TYPE_ST_ADD80
8101 | OPTS_TYPE_ST_ADDBITS15
8102 | OPTS_TYPE_ST_HEX;
8103 kern_type = KERN_TYPE_SHA512_PWSLTU;
8104 dgst_size = DGST_SIZE_8_8;
8105 parse_func = mssql2012_parse_hash;
8106 sort_by_digest = sort_by_digest_8_8;
8107 opti_type = OPTI_TYPE_ZERO_BYTE
8108 | OPTI_TYPE_PRECOMPUTE_INIT
8109 | OPTI_TYPE_PRECOMPUTE_MERKLE
8110 | OPTI_TYPE_EARLY_SKIP
8111 | OPTI_TYPE_NOT_ITERATED
8112 | OPTI_TYPE_APPENDED_SALT
8113 | OPTI_TYPE_USES_BITS_64
8114 | OPTI_TYPE_RAW_HASH;
8115 dgst_pos0 = 14;
8116 dgst_pos1 = 15;
8117 dgst_pos2 = 6;
8118 dgst_pos3 = 7;
8119 break;
8120
8121 case 1740: hash_type = HASH_TYPE_SHA512;
8122 salt_type = SALT_TYPE_INTERN;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_BE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS15
8127 | OPTS_TYPE_PT_UNICODE;
8128 kern_type = KERN_TYPE_SHA512_SLTPWU;
8129 dgst_size = DGST_SIZE_8_8;
8130 parse_func = sha512s_parse_hash;
8131 sort_by_digest = sort_by_digest_8_8;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_PREPENDED_SALT
8138 | OPTI_TYPE_USES_BITS_64
8139 | OPTI_TYPE_RAW_HASH;
8140 dgst_pos0 = 14;
8141 dgst_pos1 = 15;
8142 dgst_pos2 = 6;
8143 dgst_pos3 = 7;
8144 break;
8145
8146 case 1750: hash_type = HASH_TYPE_SHA512;
8147 salt_type = SALT_TYPE_INTERN;
8148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149 opts_type = OPTS_TYPE_PT_GENERATE_BE
8150 | OPTS_TYPE_ST_ADD80;
8151 kern_type = KERN_TYPE_HMACSHA512_PW;
8152 dgst_size = DGST_SIZE_8_8;
8153 parse_func = hmacsha512_parse_hash;
8154 sort_by_digest = sort_by_digest_8_8;
8155 opti_type = OPTI_TYPE_ZERO_BYTE
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_NOT_ITERATED;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1760: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_PT_ADD80
8169 | OPTS_TYPE_PT_ADDBITS15;
8170 kern_type = KERN_TYPE_HMACSHA512_SLT;
8171 dgst_size = DGST_SIZE_8_8;
8172 parse_func = hmacsha512_parse_hash;
8173 sort_by_digest = sort_by_digest_8_8;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_NOT_ITERATED;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1800: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8187 kern_type = KERN_TYPE_SHA512CRYPT;
8188 dgst_size = DGST_SIZE_8_8;
8189 parse_func = sha512crypt_parse_hash;
8190 sort_by_digest = sort_by_digest_8_8;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_USES_BITS_64;
8193 dgst_pos0 = 0;
8194 dgst_pos1 = 1;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 3;
8197 break;
8198
8199 case 2100: hash_type = HASH_TYPE_DCC2;
8200 salt_type = SALT_TYPE_EMBEDDED;
8201 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_ST_LOWER
8204 | OPTS_TYPE_ST_UNICODE;
8205 kern_type = KERN_TYPE_DCC2;
8206 dgst_size = DGST_SIZE_4_4;
8207 parse_func = dcc2_parse_hash;
8208 sort_by_digest = sort_by_digest_4_4;
8209 opti_type = OPTI_TYPE_ZERO_BYTE;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 1;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 3;
8214 break;
8215
8216 case 2400: hash_type = HASH_TYPE_MD5;
8217 salt_type = SALT_TYPE_NONE;
8218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8220 kern_type = KERN_TYPE_MD5PIX;
8221 dgst_size = DGST_SIZE_4_4;
8222 parse_func = md5pix_parse_hash;
8223 sort_by_digest = sort_by_digest_4_4;
8224 opti_type = OPTI_TYPE_ZERO_BYTE
8225 | OPTI_TYPE_PRECOMPUTE_INIT
8226 | OPTI_TYPE_PRECOMPUTE_MERKLE
8227 | OPTI_TYPE_EARLY_SKIP
8228 | OPTI_TYPE_NOT_ITERATED
8229 | OPTI_TYPE_NOT_SALTED;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 3;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 1;
8234 break;
8235
8236 case 2410: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_INTERN;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8240 kern_type = KERN_TYPE_MD5ASA;
8241 dgst_size = DGST_SIZE_4_4;
8242 parse_func = md5asa_parse_hash;
8243 sort_by_digest = sort_by_digest_4_4;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 3;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 1;
8253 break;
8254
8255 case 2500: hash_type = HASH_TYPE_WPA;
8256 salt_type = SALT_TYPE_EMBEDDED;
8257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8259 kern_type = KERN_TYPE_WPA;
8260 dgst_size = DGST_SIZE_4_4;
8261 parse_func = wpa_parse_hash;
8262 sort_by_digest = sort_by_digest_4_4;
8263 opti_type = OPTI_TYPE_ZERO_BYTE;
8264 dgst_pos0 = 0;
8265 dgst_pos1 = 1;
8266 dgst_pos2 = 2;
8267 dgst_pos3 = 3;
8268 break;
8269
8270 case 2600: hash_type = HASH_TYPE_MD5;
8271 salt_type = SALT_TYPE_VIRTUAL;
8272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8273 opts_type = OPTS_TYPE_PT_GENERATE_LE
8274 | OPTS_TYPE_PT_ADD80
8275 | OPTS_TYPE_PT_ADDBITS14
8276 | OPTS_TYPE_ST_ADD80;
8277 kern_type = KERN_TYPE_MD55_PWSLT1;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = md5md5_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP;
8285 dgst_pos0 = 0;
8286 dgst_pos1 = 3;
8287 dgst_pos2 = 2;
8288 dgst_pos3 = 1;
8289 break;
8290
8291 case 2611: hash_type = HASH_TYPE_MD5;
8292 salt_type = SALT_TYPE_INTERN;
8293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8294 opts_type = OPTS_TYPE_PT_GENERATE_LE
8295 | OPTS_TYPE_PT_ADD80
8296 | OPTS_TYPE_PT_ADDBITS14
8297 | OPTS_TYPE_ST_ADD80;
8298 kern_type = KERN_TYPE_MD55_PWSLT1;
8299 dgst_size = DGST_SIZE_4_4;
8300 parse_func = vb3_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_PRECOMPUTE_MERKLE
8305 | OPTI_TYPE_EARLY_SKIP;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 3;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 1;
8310 break;
8311
8312 case 2612: hash_type = HASH_TYPE_MD5;
8313 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
8320 kern_type = KERN_TYPE_MD55_PWSLT1;
8321 dgst_size = DGST_SIZE_4_4;
8322 parse_func = phps_parse_hash;
8323 sort_by_digest = sort_by_digest_4_4;
8324 opti_type = OPTI_TYPE_ZERO_BYTE
8325 | OPTI_TYPE_PRECOMPUTE_INIT
8326 | OPTI_TYPE_PRECOMPUTE_MERKLE
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 2711: hash_type = HASH_TYPE_MD5;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS14
8340 | OPTS_TYPE_ST_ADD80;
8341 kern_type = KERN_TYPE_MD55_PWSLT2;
8342 dgst_size = DGST_SIZE_4_4;
8343 parse_func = vb30_parse_hash;
8344 sort_by_digest = sort_by_digest_4_4;
8345 opti_type = OPTI_TYPE_ZERO_BYTE
8346 | OPTI_TYPE_PRECOMPUTE_INIT
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 2811: hash_type = HASH_TYPE_MD5;
8355 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_MD55_SLTPW;
8361 dgst_size = DGST_SIZE_4_4;
8362 parse_func = ipb2_parse_hash;
8363 sort_by_digest = sort_by_digest_4_4;
8364 opti_type = OPTI_TYPE_ZERO_BYTE
8365 | OPTI_TYPE_PRECOMPUTE_INIT
8366 | OPTI_TYPE_EARLY_SKIP;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 3;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 1;
8371 break;
8372
8373 case 3000: hash_type = HASH_TYPE_LM;
8374 salt_type = SALT_TYPE_NONE;
8375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8376 opts_type = OPTS_TYPE_PT_GENERATE_LE
8377 | OPTS_TYPE_PT_UPPER
8378 | OPTS_TYPE_PT_BITSLICE;
8379 kern_type = KERN_TYPE_LM;
8380 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8381 parse_func = lm_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8385 dgst_pos0 = 0;
8386 dgst_pos1 = 1;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 3;
8389 break;
8390
8391 case 3100: hash_type = HASH_TYPE_ORACLEH;
8392 salt_type = SALT_TYPE_INTERN;
8393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE
8395 | OPTS_TYPE_PT_UPPER
8396 | OPTS_TYPE_ST_UPPER;
8397 kern_type = KERN_TYPE_ORACLEH;
8398 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8399 parse_func = oracleh_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8401 opti_type = OPTI_TYPE_ZERO_BYTE;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 3200: hash_type = HASH_TYPE_BCRYPT;
8409 salt_type = SALT_TYPE_EMBEDDED;
8410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE
8412 | OPTS_TYPE_ST_GENERATE_LE;
8413 kern_type = KERN_TYPE_BCRYPT;
8414 dgst_size = DGST_SIZE_4_6;
8415 parse_func = bcrypt_parse_hash;
8416 sort_by_digest = sort_by_digest_4_6;
8417 opti_type = OPTI_TYPE_ZERO_BYTE;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 1;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 3;
8422 break;
8423
8424 case 3710: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_INTERN;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS14;
8430 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5s_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 3711: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_EMBEDDED;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS14;
8450 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = mediawiki_b_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 3800: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_INTERN;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_ST_ADDBITS14;
8469 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8470 dgst_size = DGST_SIZE_4_4;
8471 parse_func = md5s_parse_hash;
8472 sort_by_digest = sort_by_digest_4_4;
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_INIT
8475 | OPTI_TYPE_PRECOMPUTE_MERKLE
8476 | OPTI_TYPE_EARLY_SKIP
8477 | OPTI_TYPE_NOT_ITERATED
8478 | OPTI_TYPE_RAW_HASH;
8479 dgst_pos0 = 0;
8480 dgst_pos1 = 3;
8481 dgst_pos2 = 2;
8482 dgst_pos3 = 1;
8483 break;
8484
8485 case 4300: hash_type = HASH_TYPE_MD5;
8486 salt_type = SALT_TYPE_VIRTUAL;
8487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8488 opts_type = OPTS_TYPE_PT_GENERATE_LE
8489 | OPTS_TYPE_PT_ADD80
8490 | OPTS_TYPE_PT_ADDBITS14
8491 | OPTS_TYPE_ST_ADD80;
8492 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5md5_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
8507 case 4400: hash_type = HASH_TYPE_MD5;
8508 salt_type = SALT_TYPE_NONE;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_BE
8511 | OPTS_TYPE_PT_ADD80
8512 | OPTS_TYPE_PT_ADDBITS15;
8513 kern_type = KERN_TYPE_MD5_SHA1;
8514 dgst_size = DGST_SIZE_4_4;
8515 parse_func = md5_parse_hash;
8516 sort_by_digest = sort_by_digest_4_4;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP
8521 | OPTI_TYPE_NOT_ITERATED
8522 | OPTI_TYPE_NOT_SALTED
8523 | OPTI_TYPE_RAW_HASH;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 3;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 4500: hash_type = HASH_TYPE_SHA1;
8531 salt_type = SALT_TYPE_NONE;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_BE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS15;
8536 kern_type = KERN_TYPE_SHA11;
8537 dgst_size = DGST_SIZE_4_5;
8538 parse_func = sha1_parse_hash;
8539 sort_by_digest = sort_by_digest_4_5;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_SALTED;
8545 dgst_pos0 = 3;
8546 dgst_pos1 = 4;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 1;
8549 break;
8550
8551 case 4700: hash_type = HASH_TYPE_SHA1;
8552 salt_type = SALT_TYPE_NONE;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE
8555 | OPTS_TYPE_PT_ADD80
8556 | OPTS_TYPE_PT_ADDBITS14;
8557 kern_type = KERN_TYPE_SHA1_MD5;
8558 dgst_size = DGST_SIZE_4_5;
8559 parse_func = sha1_parse_hash;
8560 sort_by_digest = sort_by_digest_4_5;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_PRECOMPUTE_INIT
8563 | OPTI_TYPE_PRECOMPUTE_MERKLE
8564 | OPTI_TYPE_EARLY_SKIP
8565 | OPTI_TYPE_NOT_ITERATED
8566 | OPTI_TYPE_NOT_SALTED
8567 | OPTI_TYPE_RAW_HASH;
8568 dgst_pos0 = 3;
8569 dgst_pos1 = 4;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 4800: hash_type = HASH_TYPE_MD5;
8575 salt_type = SALT_TYPE_EMBEDDED;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADDBITS14;
8579 kern_type = KERN_TYPE_MD5_CHAP;
8580 dgst_size = DGST_SIZE_4_4;
8581 parse_func = chap_parse_hash;
8582 sort_by_digest = sort_by_digest_4_4;
8583 opti_type = OPTI_TYPE_ZERO_BYTE
8584 | OPTI_TYPE_PRECOMPUTE_INIT
8585 | OPTI_TYPE_PRECOMPUTE_MERKLE
8586 | OPTI_TYPE_MEET_IN_MIDDLE
8587 | OPTI_TYPE_EARLY_SKIP
8588 | OPTI_TYPE_NOT_ITERATED
8589 | OPTI_TYPE_RAW_HASH;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 3;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 1;
8594 break;
8595
8596 case 4900: hash_type = HASH_TYPE_SHA1;
8597 salt_type = SALT_TYPE_INTERN;
8598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8600 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8601 dgst_size = DGST_SIZE_4_5;
8602 parse_func = sha1s_parse_hash;
8603 sort_by_digest = sort_by_digest_4_5;
8604 opti_type = OPTI_TYPE_ZERO_BYTE
8605 | OPTI_TYPE_PRECOMPUTE_INIT
8606 | OPTI_TYPE_PRECOMPUTE_MERKLE
8607 | OPTI_TYPE_EARLY_SKIP;
8608 dgst_pos0 = 3;
8609 dgst_pos1 = 4;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 1;
8612 break;
8613
8614 case 5000: hash_type = HASH_TYPE_KECCAK;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE
8618 | OPTS_TYPE_PT_ADD01;
8619 kern_type = KERN_TYPE_KECCAK;
8620 dgst_size = DGST_SIZE_8_25;
8621 parse_func = keccak_parse_hash;
8622 sort_by_digest = sort_by_digest_8_25;
8623 opti_type = OPTI_TYPE_ZERO_BYTE
8624 | OPTI_TYPE_USES_BITS_64
8625 | OPTI_TYPE_RAW_HASH;
8626 dgst_pos0 = 2;
8627 dgst_pos1 = 3;
8628 dgst_pos2 = 4;
8629 dgst_pos3 = 5;
8630 break;
8631
8632 case 5100: hash_type = HASH_TYPE_MD5H;
8633 salt_type = SALT_TYPE_NONE;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_PT_ADD80
8637 | OPTS_TYPE_PT_ADDBITS14;
8638 kern_type = KERN_TYPE_MD5H;
8639 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8640 parse_func = md5half_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_RAW_HASH;
8644 dgst_pos0 = 0;
8645 dgst_pos1 = 1;
8646 dgst_pos2 = 2;
8647 dgst_pos3 = 3;
8648 break;
8649
8650 case 5200: hash_type = HASH_TYPE_SHA256;
8651 salt_type = SALT_TYPE_EMBEDDED;
8652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8654 kern_type = KERN_TYPE_PSAFE3;
8655 dgst_size = DGST_SIZE_4_8;
8656 parse_func = psafe3_parse_hash;
8657 sort_by_digest = sort_by_digest_4_8;
8658 opti_type = OPTI_TYPE_ZERO_BYTE;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 5300: hash_type = HASH_TYPE_MD5;
8666 salt_type = SALT_TYPE_EMBEDDED;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE
8669 | OPTS_TYPE_ST_ADD80;
8670 kern_type = KERN_TYPE_IKEPSK_MD5;
8671 dgst_size = DGST_SIZE_4_4;
8672 parse_func = ikepsk_md5_parse_hash;
8673 sort_by_digest = sort_by_digest_4_4;
8674 opti_type = OPTI_TYPE_ZERO_BYTE;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 3;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 1;
8679 break;
8680
8681 case 5400: hash_type = HASH_TYPE_SHA1;
8682 salt_type = SALT_TYPE_EMBEDDED;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_BE
8685 | OPTS_TYPE_ST_ADD80;
8686 kern_type = KERN_TYPE_IKEPSK_SHA1;
8687 dgst_size = DGST_SIZE_4_5;
8688 parse_func = ikepsk_sha1_parse_hash;
8689 sort_by_digest = sort_by_digest_4_5;
8690 opti_type = OPTI_TYPE_ZERO_BYTE;
8691 dgst_pos0 = 3;
8692 dgst_pos1 = 4;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 1;
8695 break;
8696
8697 case 5500: hash_type = HASH_TYPE_NETNTLM;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS14
8703 | OPTS_TYPE_PT_UNICODE
8704 | OPTS_TYPE_ST_HEX;
8705 kern_type = KERN_TYPE_NETNTLMv1;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = netntlmv1_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8711 dgst_pos0 = 0;
8712 dgst_pos1 = 1;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 3;
8715 break;
8716
8717 case 5600: hash_type = HASH_TYPE_MD5;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE
8721 | OPTS_TYPE_PT_ADD80
8722 | OPTS_TYPE_PT_ADDBITS14
8723 | OPTS_TYPE_PT_UNICODE;
8724 kern_type = KERN_TYPE_NETNTLMv2;
8725 dgst_size = DGST_SIZE_4_4;
8726 parse_func = netntlmv2_parse_hash;
8727 sort_by_digest = sort_by_digest_4_4;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 0;
8730 dgst_pos1 = 3;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 1;
8733 break;
8734
8735 case 5700: hash_type = HASH_TYPE_SHA256;
8736 salt_type = SALT_TYPE_NONE;
8737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_BE
8739 | OPTS_TYPE_PT_ADD80
8740 | OPTS_TYPE_PT_ADDBITS15;
8741 kern_type = KERN_TYPE_SHA256;
8742 dgst_size = DGST_SIZE_4_8;
8743 parse_func = cisco4_parse_hash;
8744 sort_by_digest = sort_by_digest_4_8;
8745 opti_type = OPTI_TYPE_ZERO_BYTE
8746 | OPTI_TYPE_PRECOMPUTE_INIT
8747 | OPTI_TYPE_PRECOMPUTE_MERKLE
8748 | OPTI_TYPE_EARLY_SKIP
8749 | OPTI_TYPE_NOT_ITERATED
8750 | OPTI_TYPE_NOT_SALTED
8751 | OPTI_TYPE_RAW_HASH;
8752 dgst_pos0 = 3;
8753 dgst_pos1 = 7;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 6;
8756 break;
8757
8758 case 5800: hash_type = HASH_TYPE_SHA1;
8759 salt_type = SALT_TYPE_INTERN;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8762 | OPTS_TYPE_ST_ADD80;
8763 kern_type = KERN_TYPE_ANDROIDPIN;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = androidpin_parse_hash;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8775 salt_type = SALT_TYPE_NONE;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD80;
8779 kern_type = KERN_TYPE_RIPEMD160;
8780 dgst_size = DGST_SIZE_4_5;
8781 parse_func = ripemd160_parse_hash;
8782 sort_by_digest = sort_by_digest_4_5;
8783 opti_type = OPTI_TYPE_ZERO_BYTE;
8784 dgst_pos0 = 0;
8785 dgst_pos1 = 1;
8786 dgst_pos2 = 2;
8787 dgst_pos3 = 3;
8788 break;
8789
8790 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8791 salt_type = SALT_TYPE_NONE;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_BE
8794 | OPTS_TYPE_PT_ADD80;
8795 kern_type = KERN_TYPE_WHIRLPOOL;
8796 dgst_size = DGST_SIZE_4_16;
8797 parse_func = whirlpool_parse_hash;
8798 sort_by_digest = sort_by_digest_4_16;
8799 opti_type = OPTI_TYPE_ZERO_BYTE;
8800 dgst_pos0 = 0;
8801 dgst_pos1 = 1;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 3;
8804 break;
8805
8806 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8810 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8811 dgst_size = DGST_SIZE_4_5;
8812 parse_func = truecrypt_parse_hash_2k;
8813 sort_by_digest = sort_by_digest_4_5;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8825 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8826 dgst_size = DGST_SIZE_4_5;
8827 parse_func = truecrypt_parse_hash_2k;
8828 sort_by_digest = sort_by_digest_4_5;
8829 opti_type = OPTI_TYPE_ZERO_BYTE;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8840 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8841 dgst_size = DGST_SIZE_4_5;
8842 parse_func = truecrypt_parse_hash_2k;
8843 sort_by_digest = sort_by_digest_4_5;
8844 opti_type = OPTI_TYPE_ZERO_BYTE;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 1;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 3;
8849 break;
8850
8851 case 6221: hash_type = HASH_TYPE_SHA512;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8855 kern_type = KERN_TYPE_TCSHA512_XTS512;
8856 dgst_size = DGST_SIZE_8_8;
8857 parse_func = truecrypt_parse_hash_1k;
8858 sort_by_digest = sort_by_digest_8_8;
8859 opti_type = OPTI_TYPE_ZERO_BYTE
8860 | OPTI_TYPE_USES_BITS_64;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 6222: hash_type = HASH_TYPE_SHA512;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8871 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8872 dgst_size = DGST_SIZE_8_8;
8873 parse_func = truecrypt_parse_hash_1k;
8874 sort_by_digest = sort_by_digest_8_8;
8875 opti_type = OPTI_TYPE_ZERO_BYTE
8876 | OPTI_TYPE_USES_BITS_64;
8877 dgst_pos0 = 0;
8878 dgst_pos1 = 1;
8879 dgst_pos2 = 2;
8880 dgst_pos3 = 3;
8881 break;
8882
8883 case 6223: hash_type = HASH_TYPE_SHA512;
8884 salt_type = SALT_TYPE_EMBEDDED;
8885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8886 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8887 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8888 dgst_size = DGST_SIZE_8_8;
8889 parse_func = truecrypt_parse_hash_1k;
8890 sort_by_digest = sort_by_digest_8_8;
8891 opti_type = OPTI_TYPE_ZERO_BYTE
8892 | OPTI_TYPE_USES_BITS_64;
8893 dgst_pos0 = 0;
8894 dgst_pos1 = 1;
8895 dgst_pos2 = 2;
8896 dgst_pos3 = 3;
8897 break;
8898
8899 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8900 salt_type = SALT_TYPE_EMBEDDED;
8901 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8902 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8903 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8904 dgst_size = DGST_SIZE_4_8;
8905 parse_func = truecrypt_parse_hash_1k;
8906 sort_by_digest = sort_by_digest_4_8;
8907 opti_type = OPTI_TYPE_ZERO_BYTE;
8908 dgst_pos0 = 0;
8909 dgst_pos1 = 1;
8910 dgst_pos2 = 2;
8911 dgst_pos3 = 3;
8912 break;
8913
8914 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8915 salt_type = SALT_TYPE_EMBEDDED;
8916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8918 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8919 dgst_size = DGST_SIZE_4_8;
8920 parse_func = truecrypt_parse_hash_1k;
8921 sort_by_digest = sort_by_digest_4_8;
8922 opti_type = OPTI_TYPE_ZERO_BYTE;
8923 dgst_pos0 = 0;
8924 dgst_pos1 = 1;
8925 dgst_pos2 = 2;
8926 dgst_pos3 = 3;
8927 break;
8928
8929 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8930 salt_type = SALT_TYPE_EMBEDDED;
8931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8933 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8934 dgst_size = DGST_SIZE_4_8;
8935 parse_func = truecrypt_parse_hash_1k;
8936 sort_by_digest = sort_by_digest_4_8;
8937 opti_type = OPTI_TYPE_ZERO_BYTE;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8948 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8949 dgst_size = DGST_SIZE_4_5;
8950 parse_func = truecrypt_parse_hash_1k;
8951 sort_by_digest = sort_by_digest_4_5;
8952 opti_type = OPTI_TYPE_ZERO_BYTE;
8953 dgst_pos0 = 0;
8954 dgst_pos1 = 1;
8955 dgst_pos2 = 2;
8956 dgst_pos3 = 3;
8957 break;
8958
8959 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8960 salt_type = SALT_TYPE_EMBEDDED;
8961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8963 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8964 dgst_size = DGST_SIZE_4_5;
8965 parse_func = truecrypt_parse_hash_1k;
8966 sort_by_digest = sort_by_digest_4_5;
8967 opti_type = OPTI_TYPE_ZERO_BYTE;
8968 dgst_pos0 = 0;
8969 dgst_pos1 = 1;
8970 dgst_pos2 = 2;
8971 dgst_pos3 = 3;
8972 break;
8973
8974 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8975 salt_type = SALT_TYPE_EMBEDDED;
8976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8978 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8979 dgst_size = DGST_SIZE_4_5;
8980 parse_func = truecrypt_parse_hash_1k;
8981 sort_by_digest = sort_by_digest_4_5;
8982 opti_type = OPTI_TYPE_ZERO_BYTE;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 6300: hash_type = HASH_TYPE_MD5;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_MD5AIX;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = md5aix_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_ZERO_BYTE;
8998 dgst_pos0 = 0;
8999 dgst_pos1 = 1;
9000 dgst_pos2 = 2;
9001 dgst_pos3 = 3;
9002 break;
9003
9004 case 6400: hash_type = HASH_TYPE_SHA256;
9005 salt_type = SALT_TYPE_EMBEDDED;
9006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9007 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9008 kern_type = KERN_TYPE_SHA256AIX;
9009 dgst_size = DGST_SIZE_4_8;
9010 parse_func = sha256aix_parse_hash;
9011 sort_by_digest = sort_by_digest_4_8;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6500: hash_type = HASH_TYPE_SHA512;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9023 kern_type = KERN_TYPE_SHA512AIX;
9024 dgst_size = DGST_SIZE_8_8;
9025 parse_func = sha512aix_parse_hash;
9026 sort_by_digest = sort_by_digest_8_8;
9027 opti_type = OPTI_TYPE_ZERO_BYTE
9028 | OPTI_TYPE_USES_BITS_64;
9029 dgst_pos0 = 0;
9030 dgst_pos1 = 1;
9031 dgst_pos2 = 2;
9032 dgst_pos3 = 3;
9033 break;
9034
9035 case 6600: hash_type = HASH_TYPE_AES;
9036 salt_type = SALT_TYPE_EMBEDDED;
9037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9038 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9039 kern_type = KERN_TYPE_AGILEKEY;
9040 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9041 parse_func = agilekey_parse_hash;
9042 sort_by_digest = sort_by_digest_4_5;
9043 opti_type = OPTI_TYPE_ZERO_BYTE;
9044 dgst_pos0 = 0;
9045 dgst_pos1 = 1;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 3;
9048 break;
9049
9050 case 6700: hash_type = HASH_TYPE_SHA1;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9054 kern_type = KERN_TYPE_SHA1AIX;
9055 dgst_size = DGST_SIZE_4_5;
9056 parse_func = sha1aix_parse_hash;
9057 sort_by_digest = sort_by_digest_4_5;
9058 opti_type = OPTI_TYPE_ZERO_BYTE;
9059 dgst_pos0 = 0;
9060 dgst_pos1 = 1;
9061 dgst_pos2 = 2;
9062 dgst_pos3 = 3;
9063 break;
9064
9065 case 6800: hash_type = HASH_TYPE_AES;
9066 salt_type = SALT_TYPE_EMBEDDED;
9067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9069 kern_type = KERN_TYPE_LASTPASS;
9070 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9071 parse_func = lastpass_parse_hash;
9072 sort_by_digest = sort_by_digest_4_8;
9073 opti_type = OPTI_TYPE_ZERO_BYTE;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6900: hash_type = HASH_TYPE_GOST;
9081 salt_type = SALT_TYPE_NONE;
9082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9084 kern_type = KERN_TYPE_GOST;
9085 dgst_size = DGST_SIZE_4_8;
9086 parse_func = gost_parse_hash;
9087 sort_by_digest = sort_by_digest_4_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 7100: hash_type = HASH_TYPE_SHA512;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9099 kern_type = KERN_TYPE_PBKDF2_SHA512;
9100 dgst_size = DGST_SIZE_8_16;
9101 parse_func = sha512osx_parse_hash;
9102 sort_by_digest = sort_by_digest_8_16;
9103 opti_type = OPTI_TYPE_ZERO_BYTE
9104 | OPTI_TYPE_USES_BITS_64;
9105 dgst_pos0 = 0;
9106 dgst_pos1 = 1;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 3;
9109 break;
9110
9111 case 7200: hash_type = HASH_TYPE_SHA512;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9115 kern_type = KERN_TYPE_PBKDF2_SHA512;
9116 dgst_size = DGST_SIZE_8_16;
9117 parse_func = sha512grub_parse_hash;
9118 sort_by_digest = sort_by_digest_8_16;
9119 opti_type = OPTI_TYPE_ZERO_BYTE
9120 | OPTI_TYPE_USES_BITS_64;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 7300: hash_type = HASH_TYPE_SHA1;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_BE
9131 | OPTS_TYPE_ST_ADD80
9132 | OPTS_TYPE_ST_ADDBITS15;
9133 kern_type = KERN_TYPE_RAKP;
9134 dgst_size = DGST_SIZE_4_5;
9135 parse_func = rakp_parse_hash;
9136 sort_by_digest = sort_by_digest_4_5;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_NOT_ITERATED;
9139 dgst_pos0 = 3;
9140 dgst_pos1 = 4;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 1;
9143 break;
9144
9145 case 7400: hash_type = HASH_TYPE_SHA256;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9149 kern_type = KERN_TYPE_SHA256CRYPT;
9150 dgst_size = DGST_SIZE_4_8;
9151 parse_func = sha256crypt_parse_hash;
9152 sort_by_digest = sort_by_digest_4_8;
9153 opti_type = OPTI_TYPE_ZERO_BYTE;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 1;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 3;
9158 break;
9159
9160 case 7500: hash_type = HASH_TYPE_KRB5PA;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9164 kern_type = KERN_TYPE_KRB5PA;
9165 dgst_size = DGST_SIZE_4_4;
9166 parse_func = krb5pa_parse_hash;
9167 sort_by_digest = sort_by_digest_4_4;
9168 opti_type = OPTI_TYPE_ZERO_BYTE
9169 | OPTI_TYPE_NOT_ITERATED;
9170 dgst_pos0 = 0;
9171 dgst_pos1 = 1;
9172 dgst_pos2 = 2;
9173 dgst_pos3 = 3;
9174 break;
9175
9176 case 7600: hash_type = HASH_TYPE_SHA1;
9177 salt_type = SALT_TYPE_INTERN;
9178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9179 opts_type = OPTS_TYPE_PT_GENERATE_BE
9180 | OPTS_TYPE_PT_ADD80
9181 | OPTS_TYPE_PT_ADDBITS15;
9182 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9183 dgst_size = DGST_SIZE_4_5;
9184 parse_func = redmine_parse_hash;
9185 sort_by_digest = sort_by_digest_4_5;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_EARLY_SKIP
9189 | OPTI_TYPE_NOT_ITERATED
9190 | OPTI_TYPE_PREPENDED_SALT;
9191 dgst_pos0 = 3;
9192 dgst_pos1 = 4;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 1;
9195 break;
9196
9197 case 7700: hash_type = HASH_TYPE_SAPB;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE
9201 | OPTS_TYPE_PT_UPPER
9202 | OPTS_TYPE_ST_UPPER;
9203 kern_type = KERN_TYPE_SAPB;
9204 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9205 parse_func = sapb_parse_hash;
9206 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9207 opti_type = OPTI_TYPE_ZERO_BYTE
9208 | OPTI_TYPE_PRECOMPUTE_INIT
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 7800: hash_type = HASH_TYPE_SAPG;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_ST_ADD80
9221 | OPTS_TYPE_ST_UPPER;
9222 kern_type = KERN_TYPE_SAPG;
9223 dgst_size = DGST_SIZE_4_5;
9224 parse_func = sapg_parse_hash;
9225 sort_by_digest = sort_by_digest_4_5;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 3;
9230 dgst_pos1 = 4;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 1;
9233 break;
9234
9235 case 7900: hash_type = HASH_TYPE_SHA512;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9239 kern_type = KERN_TYPE_DRUPAL7;
9240 dgst_size = DGST_SIZE_8_8;
9241 parse_func = drupal7_parse_hash;
9242 sort_by_digest = sort_by_digest_8_8;
9243 opti_type = OPTI_TYPE_ZERO_BYTE
9244 | OPTI_TYPE_USES_BITS_64;
9245 dgst_pos0 = 0;
9246 dgst_pos1 = 1;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 3;
9249 break;
9250
9251 case 8000: hash_type = HASH_TYPE_SHA256;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_BE
9255 | OPTS_TYPE_PT_UNICODE
9256 | OPTS_TYPE_ST_ADD80
9257 | OPTS_TYPE_ST_HEX;
9258 kern_type = KERN_TYPE_SYBASEASE;
9259 dgst_size = DGST_SIZE_4_8;
9260 parse_func = sybasease_parse_hash;
9261 sort_by_digest = sort_by_digest_4_8;
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_PRECOMPUTE_INIT
9264 | OPTI_TYPE_EARLY_SKIP
9265 | OPTI_TYPE_NOT_ITERATED
9266 | OPTI_TYPE_RAW_HASH;
9267 dgst_pos0 = 3;
9268 dgst_pos1 = 7;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 6;
9271 break;
9272
9273 case 8100: hash_type = HASH_TYPE_SHA1;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9277 kern_type = KERN_TYPE_NETSCALER;
9278 dgst_size = DGST_SIZE_4_5;
9279 parse_func = netscaler_parse_hash;
9280 sort_by_digest = sort_by_digest_4_5;
9281 opti_type = OPTI_TYPE_ZERO_BYTE
9282 | OPTI_TYPE_PRECOMPUTE_INIT
9283 | OPTI_TYPE_PRECOMPUTE_MERKLE
9284 | OPTI_TYPE_EARLY_SKIP
9285 | OPTI_TYPE_NOT_ITERATED
9286 | OPTI_TYPE_PREPENDED_SALT
9287 | OPTI_TYPE_RAW_HASH;
9288 dgst_pos0 = 3;
9289 dgst_pos1 = 4;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 1;
9292 break;
9293
9294 case 8200: hash_type = HASH_TYPE_SHA256;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9298 kern_type = KERN_TYPE_CLOUDKEY;
9299 dgst_size = DGST_SIZE_4_8;
9300 parse_func = cloudkey_parse_hash;
9301 sort_by_digest = sort_by_digest_4_8;
9302 opti_type = OPTI_TYPE_ZERO_BYTE;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 8300: hash_type = HASH_TYPE_SHA1;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_BE
9313 | OPTS_TYPE_ST_HEX
9314 | OPTS_TYPE_ST_ADD80;
9315 kern_type = KERN_TYPE_NSEC3;
9316 dgst_size = DGST_SIZE_4_5;
9317 parse_func = nsec3_parse_hash;
9318 sort_by_digest = sort_by_digest_4_5;
9319 opti_type = OPTI_TYPE_ZERO_BYTE;
9320 dgst_pos0 = 3;
9321 dgst_pos1 = 4;
9322 dgst_pos2 = 2;
9323 dgst_pos3 = 1;
9324 break;
9325
9326 case 8400: hash_type = HASH_TYPE_SHA1;
9327 salt_type = SALT_TYPE_INTERN;
9328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9329 opts_type = OPTS_TYPE_PT_GENERATE_BE
9330 | OPTS_TYPE_PT_ADD80
9331 | OPTS_TYPE_PT_ADDBITS15;
9332 kern_type = KERN_TYPE_WBB3;
9333 dgst_size = DGST_SIZE_4_5;
9334 parse_func = wbb3_parse_hash;
9335 sort_by_digest = sort_by_digest_4_5;
9336 opti_type = OPTI_TYPE_ZERO_BYTE
9337 | OPTI_TYPE_PRECOMPUTE_INIT
9338 | OPTI_TYPE_NOT_ITERATED;
9339 dgst_pos0 = 3;
9340 dgst_pos1 = 4;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 1;
9343 break;
9344
9345 case 8500: hash_type = HASH_TYPE_DESRACF;
9346 salt_type = SALT_TYPE_EMBEDDED;
9347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_LE
9349 | OPTS_TYPE_ST_UPPER;
9350 kern_type = KERN_TYPE_RACF;
9351 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9352 parse_func = racf_parse_hash;
9353 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9354 opti_type = OPTI_TYPE_ZERO_BYTE
9355 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9356 dgst_pos0 = 0;
9357 dgst_pos1 = 1;
9358 dgst_pos2 = 2;
9359 dgst_pos3 = 3;
9360 break;
9361
9362 case 8600: hash_type = HASH_TYPE_LOTUS5;
9363 salt_type = SALT_TYPE_NONE;
9364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9366 kern_type = KERN_TYPE_LOTUS5;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = lotus5_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_EARLY_SKIP
9371 | OPTI_TYPE_NOT_ITERATED
9372 | OPTI_TYPE_NOT_SALTED
9373 | OPTI_TYPE_RAW_HASH;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 8700: hash_type = HASH_TYPE_LOTUS6;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9384 kern_type = KERN_TYPE_LOTUS6;
9385 dgst_size = DGST_SIZE_4_4;
9386 parse_func = lotus6_parse_hash;
9387 sort_by_digest = sort_by_digest_4_4;
9388 opti_type = OPTI_TYPE_EARLY_SKIP
9389 | OPTI_TYPE_NOT_ITERATED
9390 | OPTI_TYPE_RAW_HASH;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_ANDROIDFDE;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = androidfde_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 8900: hash_type = HASH_TYPE_SCRYPT;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_SCRYPT;
9417 dgst_size = DGST_SIZE_4_8;
9418 parse_func = scrypt_parse_hash;
9419 sort_by_digest = sort_by_digest_4_8;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 9000: hash_type = HASH_TYPE_SHA1;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_ST_GENERATE_LE;
9432 kern_type = KERN_TYPE_PSAFE2;
9433 dgst_size = DGST_SIZE_4_5;
9434 parse_func = psafe2_parse_hash;
9435 sort_by_digest = sort_by_digest_4_5;
9436 opti_type = OPTI_TYPE_ZERO_BYTE;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 9100: hash_type = HASH_TYPE_LOTUS8;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9447 kern_type = KERN_TYPE_LOTUS8;
9448 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9449 parse_func = lotus8_parse_hash;
9450 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9451 opti_type = OPTI_TYPE_ZERO_BYTE;
9452 dgst_pos0 = 0;
9453 dgst_pos1 = 1;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 3;
9456 break;
9457
9458 case 9200: hash_type = HASH_TYPE_SHA256;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9462 kern_type = KERN_TYPE_PBKDF2_SHA256;
9463 dgst_size = DGST_SIZE_4_32;
9464 parse_func = cisco8_parse_hash;
9465 sort_by_digest = sort_by_digest_4_32;
9466 opti_type = OPTI_TYPE_ZERO_BYTE;
9467 dgst_pos0 = 0;
9468 dgst_pos1 = 1;
9469 dgst_pos2 = 2;
9470 dgst_pos3 = 3;
9471 break;
9472
9473 case 9300: hash_type = HASH_TYPE_SCRYPT;
9474 salt_type = SALT_TYPE_EMBEDDED;
9475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9477 kern_type = KERN_TYPE_SCRYPT;
9478 dgst_size = DGST_SIZE_4_8;
9479 parse_func = cisco9_parse_hash;
9480 sort_by_digest = sort_by_digest_4_8;
9481 opti_type = OPTI_TYPE_ZERO_BYTE;
9482 dgst_pos0 = 0;
9483 dgst_pos1 = 1;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 3;
9486 break;
9487
9488 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9492 kern_type = KERN_TYPE_OFFICE2007;
9493 dgst_size = DGST_SIZE_4_4;
9494 parse_func = office2007_parse_hash;
9495 sort_by_digest = sort_by_digest_4_4;
9496 opti_type = OPTI_TYPE_ZERO_BYTE;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9507 kern_type = KERN_TYPE_OFFICE2010;
9508 dgst_size = DGST_SIZE_4_4;
9509 parse_func = office2010_parse_hash;
9510 sort_by_digest = sort_by_digest_4_4;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_OFFICE2013;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = office2013_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE
9537 | OPTS_TYPE_PT_ADD80
9538 | OPTS_TYPE_PT_UNICODE;
9539 kern_type = KERN_TYPE_OLDOFFICE01;
9540 dgst_size = DGST_SIZE_4_4;
9541 parse_func = oldoffice01_parse_hash;
9542 sort_by_digest = sort_by_digest_4_4;
9543 opti_type = OPTI_TYPE_ZERO_BYTE
9544 | OPTI_TYPE_PRECOMPUTE_INIT
9545 | OPTI_TYPE_NOT_ITERATED;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9553 salt_type = SALT_TYPE_EMBEDDED;
9554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE
9556 | OPTS_TYPE_PT_ADD80;
9557 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = oldoffice01cm1_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE
9562 | OPTI_TYPE_PRECOMPUTE_INIT
9563 | OPTI_TYPE_NOT_ITERATED;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE
9574 | OPTS_TYPE_PT_ADD80
9575 | OPTS_TYPE_PT_UNICODE
9576 | OPTS_TYPE_PT_NEVERCRACK;
9577 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9578 dgst_size = DGST_SIZE_4_4;
9579 parse_func = oldoffice01cm2_parse_hash;
9580 sort_by_digest = sort_by_digest_4_4;
9581 opti_type = OPTI_TYPE_ZERO_BYTE
9582 | OPTI_TYPE_PRECOMPUTE_INIT
9583 | OPTI_TYPE_NOT_ITERATED;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_BE
9594 | OPTS_TYPE_PT_ADD80
9595 | OPTS_TYPE_PT_UNICODE;
9596 kern_type = KERN_TYPE_OLDOFFICE34;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = oldoffice34_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE
9601 | OPTI_TYPE_PRECOMPUTE_INIT
9602 | OPTI_TYPE_NOT_ITERATED;
9603 dgst_pos0 = 0;
9604 dgst_pos1 = 1;
9605 dgst_pos2 = 2;
9606 dgst_pos3 = 3;
9607 break;
9608
9609 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9610 salt_type = SALT_TYPE_EMBEDDED;
9611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9613 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice34cm1_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_BE
9630 | OPTS_TYPE_PT_ADD80
9631 | OPTS_TYPE_PT_UNICODE
9632 | OPTS_TYPE_PT_NEVERCRACK;
9633 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice34cm2_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9900: hash_type = HASH_TYPE_MD5;
9647 salt_type = SALT_TYPE_NONE;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9650 kern_type = KERN_TYPE_RADMIN2;
9651 dgst_size = DGST_SIZE_4_4;
9652 parse_func = radmin2_parse_hash;
9653 sort_by_digest = sort_by_digest_4_4;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_PRECOMPUTE_INIT
9656 | OPTI_TYPE_EARLY_SKIP
9657 | OPTI_TYPE_NOT_ITERATED
9658 | OPTI_TYPE_NOT_SALTED;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 3;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 1;
9663 break;
9664
9665 case 10000: hash_type = HASH_TYPE_SHA256;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9669 kern_type = KERN_TYPE_PBKDF2_SHA256;
9670 dgst_size = DGST_SIZE_4_32;
9671 parse_func = djangopbkdf2_parse_hash;
9672 sort_by_digest = sort_by_digest_4_32;
9673 opti_type = OPTI_TYPE_ZERO_BYTE;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 10100: hash_type = HASH_TYPE_SIPHASH;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9684 kern_type = KERN_TYPE_SIPHASH;
9685 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9686 parse_func = siphash_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_NOT_ITERATED
9690 | OPTI_TYPE_RAW_HASH;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 10200: hash_type = HASH_TYPE_MD5;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE
9701 | OPTS_TYPE_ST_ADD80
9702 | OPTS_TYPE_ST_ADDBITS14;
9703 kern_type = KERN_TYPE_HMACMD5_PW;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = crammd5_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 3;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 1;
9713 break;
9714
9715 case 10300: hash_type = HASH_TYPE_SHA1;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9719 kern_type = KERN_TYPE_SAPH_SHA1;
9720 dgst_size = DGST_SIZE_4_5;
9721 parse_func = saph_sha1_parse_hash;
9722 sort_by_digest = sort_by_digest_4_5;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 10400: hash_type = HASH_TYPE_PDFU16;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9734 kern_type = KERN_TYPE_PDF11;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = pdf11_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 10410: hash_type = HASH_TYPE_PDFU16;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9750 kern_type = KERN_TYPE_PDF11CM1;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = pdf11cm1_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_NOT_ITERATED;
9756 dgst_pos0 = 0;
9757 dgst_pos1 = 1;
9758 dgst_pos2 = 2;
9759 dgst_pos3 = 3;
9760 break;
9761
9762 case 10420: hash_type = HASH_TYPE_PDFU16;
9763 salt_type = SALT_TYPE_EMBEDDED;
9764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9766 kern_type = KERN_TYPE_PDF11CM2;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = pdf11cm2_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_NOT_ITERATED;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 10500: hash_type = HASH_TYPE_PDFU16;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9782 kern_type = KERN_TYPE_PDF14;
9783 dgst_size = DGST_SIZE_4_4;
9784 parse_func = pdf14_parse_hash;
9785 sort_by_digest = sort_by_digest_4_4;
9786 opti_type = OPTI_TYPE_ZERO_BYTE
9787 | OPTI_TYPE_NOT_ITERATED;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 10600: hash_type = HASH_TYPE_SHA256;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_BE
9798 | OPTS_TYPE_ST_ADD80
9799 | OPTS_TYPE_ST_ADDBITS15
9800 | OPTS_TYPE_HASH_COPY;
9801 kern_type = KERN_TYPE_SHA256_PWSLT;
9802 dgst_size = DGST_SIZE_4_8;
9803 parse_func = pdf17l3_parse_hash;
9804 sort_by_digest = sort_by_digest_4_8;
9805 opti_type = OPTI_TYPE_ZERO_BYTE
9806 | OPTI_TYPE_PRECOMPUTE_INIT
9807 | OPTI_TYPE_PRECOMPUTE_MERKLE
9808 | OPTI_TYPE_EARLY_SKIP
9809 | OPTI_TYPE_NOT_ITERATED
9810 | OPTI_TYPE_APPENDED_SALT
9811 | OPTI_TYPE_RAW_HASH;
9812 dgst_pos0 = 3;
9813 dgst_pos1 = 7;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 6;
9816 break;
9817
9818 case 10700: hash_type = HASH_TYPE_PDFU32;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_LE
9822 | OPTS_TYPE_HASH_COPY;
9823 kern_type = KERN_TYPE_PDF17L8;
9824 dgst_size = DGST_SIZE_4_8;
9825 parse_func = pdf17l8_parse_hash;
9826 sort_by_digest = sort_by_digest_4_8;
9827 opti_type = OPTI_TYPE_ZERO_BYTE
9828 | OPTI_TYPE_NOT_ITERATED;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 10800: hash_type = HASH_TYPE_SHA384;
9836 salt_type = SALT_TYPE_NONE;
9837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_BE
9839 | OPTS_TYPE_PT_ADD80
9840 | OPTS_TYPE_PT_ADDBITS15;
9841 kern_type = KERN_TYPE_SHA384;
9842 dgst_size = DGST_SIZE_8_8;
9843 parse_func = sha384_parse_hash;
9844 sort_by_digest = sort_by_digest_8_8;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_PRECOMPUTE_INIT
9847 | OPTI_TYPE_PRECOMPUTE_MERKLE
9848 | OPTI_TYPE_EARLY_SKIP
9849 | OPTI_TYPE_NOT_ITERATED
9850 | OPTI_TYPE_NOT_SALTED
9851 | OPTI_TYPE_USES_BITS_64
9852 | OPTI_TYPE_RAW_HASH;
9853 dgst_pos0 = 6;
9854 dgst_pos1 = 7;
9855 dgst_pos2 = 4;
9856 dgst_pos3 = 5;
9857 break;
9858
9859 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE
9863 | OPTS_TYPE_ST_BASE64
9864 | OPTS_TYPE_HASH_COPY;
9865 kern_type = KERN_TYPE_PBKDF2_SHA256;
9866 dgst_size = DGST_SIZE_4_32;
9867 parse_func = pbkdf2_sha256_parse_hash;
9868 sort_by_digest = sort_by_digest_4_32;
9869 opti_type = OPTI_TYPE_ZERO_BYTE;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 1;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 3;
9874 break;
9875
9876 case 11000: hash_type = HASH_TYPE_MD5;
9877 salt_type = SALT_TYPE_INTERN;
9878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE
9880 | OPTS_TYPE_PT_ADD80;
9881 kern_type = KERN_TYPE_PRESTASHOP;
9882 dgst_size = DGST_SIZE_4_4;
9883 parse_func = prestashop_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_PRECOMPUTE_INIT
9887 | OPTI_TYPE_NOT_ITERATED
9888 | OPTI_TYPE_PREPENDED_SALT;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 3;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 1;
9893 break;
9894
9895 case 11100: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_ST_ADD80;
9900 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = postgresql_auth_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_PRECOMPUTE_INIT
9906 | OPTI_TYPE_PRECOMPUTE_MERKLE
9907 | OPTI_TYPE_EARLY_SKIP;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 3;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 1;
9912 break;
9913
9914 case 11200: hash_type = HASH_TYPE_SHA1;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_BE
9918 | OPTS_TYPE_PT_ADD80
9919 | OPTS_TYPE_ST_HEX;
9920 kern_type = KERN_TYPE_MYSQL_AUTH;
9921 dgst_size = DGST_SIZE_4_5;
9922 parse_func = mysql_auth_parse_hash;
9923 sort_by_digest = sort_by_digest_4_5;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_EARLY_SKIP;
9926 dgst_pos0 = 3;
9927 dgst_pos1 = 4;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_HEX
9937 | OPTS_TYPE_ST_ADD80;
9938 kern_type = KERN_TYPE_BITCOIN_WALLET;
9939 dgst_size = DGST_SIZE_4_4;
9940 parse_func = bitcoin_wallet_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4;
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 11400: hash_type = HASH_TYPE_MD5;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_PT_ADD80
9954 | OPTS_TYPE_HASH_COPY;
9955 kern_type = KERN_TYPE_SIP_AUTH;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = sip_auth_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 3;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 1;
9964 break;
9965
9966 case 11500: hash_type = HASH_TYPE_CRC32;
9967 salt_type = SALT_TYPE_INTERN;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_ST_GENERATE_LE
9971 | OPTS_TYPE_ST_HEX;
9972 kern_type = KERN_TYPE_CRC32;
9973 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9974 parse_func = crc32_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9976 opti_type = OPTI_TYPE_ZERO_BYTE;
9977 dgst_pos0 = 0;
9978 dgst_pos1 = 1;
9979 dgst_pos2 = 2;
9980 dgst_pos3 = 3;
9981 break;
9982
9983 case 11600: hash_type = HASH_TYPE_AES;
9984 salt_type = SALT_TYPE_EMBEDDED;
9985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9986 opts_type = OPTS_TYPE_PT_GENERATE_LE
9987 | OPTS_TYPE_PT_NEVERCRACK;
9988 kern_type = KERN_TYPE_SEVEN_ZIP;
9989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9990 parse_func = seven_zip_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10000 salt_type = SALT_TYPE_NONE;
10001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE
10003 | OPTS_TYPE_PT_ADD01;
10004 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10005 dgst_size = DGST_SIZE_4_8;
10006 parse_func = gost2012sbog_256_parse_hash;
10007 sort_by_digest = sort_by_digest_4_8;
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10016 salt_type = SALT_TYPE_NONE;
10017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_ADD01;
10020 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10021 dgst_size = DGST_SIZE_4_16;
10022 parse_func = gost2012sbog_512_parse_hash;
10023 sort_by_digest = sort_by_digest_4_16;
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_ST_BASE64
10036 | OPTS_TYPE_HASH_COPY;
10037 kern_type = KERN_TYPE_PBKDF2_MD5;
10038 dgst_size = DGST_SIZE_4_32;
10039 parse_func = pbkdf2_md5_parse_hash;
10040 sort_by_digest = sort_by_digest_4_32;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE
10052 | OPTS_TYPE_ST_BASE64
10053 | OPTS_TYPE_HASH_COPY;
10054 kern_type = KERN_TYPE_PBKDF2_SHA1;
10055 dgst_size = DGST_SIZE_4_32;
10056 parse_func = pbkdf2_sha1_parse_hash;
10057 sort_by_digest = sort_by_digest_4_32;
10058 opti_type = OPTI_TYPE_ZERO_BYTE;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA512;
10072 dgst_size = DGST_SIZE_8_16;
10073 parse_func = pbkdf2_sha512_parse_hash;
10074 sort_by_digest = sort_by_digest_8_16;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_USES_BITS_64;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_ECRYPTFS;
10088 dgst_size = DGST_SIZE_8_8;
10089 parse_func = ecryptfs_parse_hash;
10090 sort_by_digest = sort_by_digest_8_8;
10091 opti_type = OPTI_TYPE_ZERO_BYTE
10092 | OPTI_TYPE_USES_BITS_64;
10093 dgst_pos0 = 0;
10094 dgst_pos1 = 1;
10095 dgst_pos2 = 2;
10096 dgst_pos3 = 3;
10097 break;
10098
10099 case 12300: hash_type = HASH_TYPE_ORACLET;
10100 salt_type = SALT_TYPE_EMBEDDED;
10101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10102 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10103 kern_type = KERN_TYPE_ORACLET;
10104 dgst_size = DGST_SIZE_8_16;
10105 parse_func = oraclet_parse_hash;
10106 sort_by_digest = sort_by_digest_8_16;
10107 opti_type = OPTI_TYPE_ZERO_BYTE
10108 | OPTI_TYPE_USES_BITS_64;
10109 dgst_pos0 = 0;
10110 dgst_pos1 = 1;
10111 dgst_pos2 = 2;
10112 dgst_pos3 = 3;
10113 break;
10114
10115 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10116 salt_type = SALT_TYPE_EMBEDDED;
10117 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10118 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10119 kern_type = KERN_TYPE_BSDICRYPT;
10120 dgst_size = DGST_SIZE_4_4;
10121 parse_func = bsdicrypt_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10125 dgst_pos0 = 0;
10126 dgst_pos1 = 1;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 3;
10129 break;
10130
10131 case 12500: hash_type = HASH_TYPE_RAR3HP;
10132 salt_type = SALT_TYPE_EMBEDDED;
10133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10135 kern_type = KERN_TYPE_RAR3;
10136 dgst_size = DGST_SIZE_4_4;
10137 parse_func = rar3hp_parse_hash;
10138 sort_by_digest = sort_by_digest_4_4;
10139 opti_type = OPTI_TYPE_ZERO_BYTE;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 12600: hash_type = HASH_TYPE_SHA256;
10147 salt_type = SALT_TYPE_INTERN;
10148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_BE
10150 | OPTS_TYPE_PT_ADD80;
10151 kern_type = KERN_TYPE_CF10;
10152 dgst_size = DGST_SIZE_4_8;
10153 parse_func = cf10_parse_hash;
10154 sort_by_digest = sort_by_digest_4_8;
10155 opti_type = OPTI_TYPE_ZERO_BYTE
10156 | OPTI_TYPE_PRECOMPUTE_INIT
10157 | OPTI_TYPE_EARLY_SKIP
10158 | OPTI_TYPE_NOT_ITERATED;
10159 dgst_pos0 = 3;
10160 dgst_pos1 = 7;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 6;
10163 break;
10164
10165 case 12700: hash_type = HASH_TYPE_AES;
10166 salt_type = SALT_TYPE_EMBEDDED;
10167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_LE
10169 | OPTS_TYPE_HASH_COPY;
10170 kern_type = KERN_TYPE_MYWALLET;
10171 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10172 parse_func = mywallet_parse_hash;
10173 sort_by_digest = sort_by_digest_4_5;
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10185 kern_type = KERN_TYPE_MS_DRSR;
10186 dgst_size = DGST_SIZE_4_8;
10187 parse_func = ms_drsr_parse_hash;
10188 sort_by_digest = sort_by_digest_4_8;
10189 opti_type = OPTI_TYPE_ZERO_BYTE;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10200 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10201 dgst_size = DGST_SIZE_4_8;
10202 parse_func = androidfde_samsung_parse_hash;
10203 sort_by_digest = sort_by_digest_4_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE;
10205 dgst_pos0 = 0;
10206 dgst_pos1 = 1;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 3;
10209 break;
10210
10211 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10215 kern_type = KERN_TYPE_RAR5;
10216 dgst_size = DGST_SIZE_4_4;
10217 parse_func = rar5_parse_hash;
10218 sort_by_digest = sort_by_digest_4_4;
10219 opti_type = OPTI_TYPE_ZERO_BYTE;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10230 kern_type = KERN_TYPE_KRB5TGS;
10231 dgst_size = DGST_SIZE_4_4;
10232 parse_func = krb5tgs_parse_hash;
10233 sort_by_digest = sort_by_digest_4_4;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_NOT_ITERATED;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 13200: hash_type = HASH_TYPE_AES;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_AXCRYPT;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = axcrypt_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 13300: hash_type = HASH_TYPE_SHA1;
10258 salt_type = SALT_TYPE_NONE;
10259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_BE
10261 | OPTS_TYPE_PT_ADD80
10262 | OPTS_TYPE_PT_ADDBITS15;
10263 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10264 dgst_size = DGST_SIZE_4_5;
10265 parse_func = sha1axcrypt_parse_hash;
10266 sort_by_digest = sort_by_digest_4_5;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_PRECOMPUTE_INIT
10269 | OPTI_TYPE_EARLY_SKIP
10270 | OPTI_TYPE_NOT_ITERATED
10271 | OPTI_TYPE_NOT_SALTED;
10272 dgst_pos0 = 0;
10273 dgst_pos1 = 4;
10274 dgst_pos2 = 3;
10275 dgst_pos3 = 2;
10276 break;
10277
10278 case 13400: hash_type = HASH_TYPE_AES;
10279 salt_type = SALT_TYPE_EMBEDDED;
10280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10282 kern_type = KERN_TYPE_KEEPASS;
10283 dgst_size = DGST_SIZE_4_4;
10284 parse_func = keepass_parse_hash;
10285 sort_by_digest = sort_by_digest_4_4;
10286 opti_type = OPTI_TYPE_ZERO_BYTE;
10287 dgst_pos0 = 0;
10288 dgst_pos1 = 1;
10289 dgst_pos2 = 2;
10290 dgst_pos3 = 3;
10291 break;
10292
10293 case 13500: hash_type = HASH_TYPE_SHA1;
10294 salt_type = SALT_TYPE_EMBEDDED;
10295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10296 opts_type = OPTS_TYPE_PT_GENERATE_BE
10297 | OPTS_TYPE_PT_UNICODE
10298 | OPTS_TYPE_PT_ADD80;
10299 kern_type = KERN_TYPE_SHA1_SLTPWU;
10300 dgst_size = DGST_SIZE_4_5;
10301 parse_func = pstoken_parse_hash;
10302 sort_by_digest = sort_by_digest_4_5;
10303 opti_type = OPTI_TYPE_ZERO_BYTE
10304 | OPTI_TYPE_PRECOMPUTE_INIT
10305 | OPTI_TYPE_EARLY_SKIP
10306 | OPTI_TYPE_NOT_ITERATED
10307 | OPTI_TYPE_PREPENDED_SALT
10308 | OPTI_TYPE_RAW_HASH;
10309 dgst_pos0 = 3;
10310 dgst_pos1 = 4;
10311 dgst_pos2 = 2;
10312 dgst_pos3 = 1;
10313 break;
10314
10315 default: usage_mini_print (PROGNAME); return (-1);
10316 }
10317
10318 /**
10319 * parser
10320 */
10321
10322 data.parse_func = parse_func;
10323
10324 /**
10325 * misc stuff
10326 */
10327
10328 if (hex_salt)
10329 {
10330 if (salt_type == SALT_TYPE_INTERN)
10331 {
10332 opts_type |= OPTS_TYPE_ST_HEX;
10333 }
10334 else
10335 {
10336 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10337
10338 return (-1);
10339 }
10340 }
10341
10342 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10343 | (salt_type == SALT_TYPE_EXTERN)
10344 | (salt_type == SALT_TYPE_EMBEDDED)
10345 | (salt_type == SALT_TYPE_VIRTUAL));
10346
10347 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10348
10349 data.hash_type = hash_type;
10350 data.attack_mode = attack_mode;
10351 data.attack_kern = attack_kern;
10352 data.attack_exec = attack_exec;
10353 data.kern_type = kern_type;
10354 data.opts_type = opts_type;
10355 data.dgst_size = dgst_size;
10356 data.salt_type = salt_type;
10357 data.isSalted = isSalted;
10358 data.sort_by_digest = sort_by_digest;
10359 data.dgst_pos0 = dgst_pos0;
10360 data.dgst_pos1 = dgst_pos1;
10361 data.dgst_pos2 = dgst_pos2;
10362 data.dgst_pos3 = dgst_pos3;
10363
10364 esalt_size = 0;
10365
10366 switch (hash_mode)
10367 {
10368 case 2500: esalt_size = sizeof (wpa_t); break;
10369 case 5300: esalt_size = sizeof (ikepsk_t); break;
10370 case 5400: esalt_size = sizeof (ikepsk_t); break;
10371 case 5500: esalt_size = sizeof (netntlm_t); break;
10372 case 5600: esalt_size = sizeof (netntlm_t); break;
10373 case 6211: esalt_size = sizeof (tc_t); break;
10374 case 6212: esalt_size = sizeof (tc_t); break;
10375 case 6213: esalt_size = sizeof (tc_t); break;
10376 case 6221: esalt_size = sizeof (tc_t); break;
10377 case 6222: esalt_size = sizeof (tc_t); break;
10378 case 6223: esalt_size = sizeof (tc_t); break;
10379 case 6231: esalt_size = sizeof (tc_t); break;
10380 case 6232: esalt_size = sizeof (tc_t); break;
10381 case 6233: esalt_size = sizeof (tc_t); break;
10382 case 6241: esalt_size = sizeof (tc_t); break;
10383 case 6242: esalt_size = sizeof (tc_t); break;
10384 case 6243: esalt_size = sizeof (tc_t); break;
10385 case 6600: esalt_size = sizeof (agilekey_t); break;
10386 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10387 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10388 case 7300: esalt_size = sizeof (rakp_t); break;
10389 case 7500: esalt_size = sizeof (krb5pa_t); break;
10390 case 8200: esalt_size = sizeof (cloudkey_t); break;
10391 case 8800: esalt_size = sizeof (androidfde_t); break;
10392 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10393 case 9400: esalt_size = sizeof (office2007_t); break;
10394 case 9500: esalt_size = sizeof (office2010_t); break;
10395 case 9600: esalt_size = sizeof (office2013_t); break;
10396 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10397 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10398 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10399 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10400 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10401 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10402 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10403 case 10200: esalt_size = sizeof (cram_md5_t); break;
10404 case 10400: esalt_size = sizeof (pdf_t); break;
10405 case 10410: esalt_size = sizeof (pdf_t); break;
10406 case 10420: esalt_size = sizeof (pdf_t); break;
10407 case 10500: esalt_size = sizeof (pdf_t); break;
10408 case 10600: esalt_size = sizeof (pdf_t); break;
10409 case 10700: esalt_size = sizeof (pdf_t); break;
10410 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10411 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10412 case 11400: esalt_size = sizeof (sip_t); break;
10413 case 11600: esalt_size = sizeof (seven_zip_t); break;
10414 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10415 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10416 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10417 case 13000: esalt_size = sizeof (rar5_t); break;
10418 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10419 case 13400: esalt_size = sizeof (keepass_t); break;
10420 case 13500: esalt_size = sizeof (pstoken_t); break;
10421 }
10422
10423 data.esalt_size = esalt_size;
10424
10425 /**
10426 * choose dictionary parser
10427 */
10428
10429 if (hash_type == HASH_TYPE_LM)
10430 {
10431 get_next_word_func = get_next_word_lm;
10432 }
10433 else if (opts_type & OPTS_TYPE_PT_UPPER)
10434 {
10435 get_next_word_func = get_next_word_uc;
10436 }
10437 else
10438 {
10439 get_next_word_func = get_next_word_std;
10440 }
10441
10442 /**
10443 * dictstat
10444 */
10445
10446 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10447
10448 #ifdef _POSIX
10449 size_t dictstat_nmemb = 0;
10450 #endif
10451
10452 #ifdef _WIN
10453 uint dictstat_nmemb = 0;
10454 #endif
10455
10456 char dictstat[256] = { 0 };
10457
10458 FILE *dictstat_fp = NULL;
10459
10460 if (keyspace == 0)
10461 {
10462 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10463
10464 dictstat_fp = fopen (dictstat, "rb");
10465
10466 if (dictstat_fp)
10467 {
10468 #ifdef _POSIX
10469 struct stat tmpstat;
10470
10471 fstat (fileno (dictstat_fp), &tmpstat);
10472 #endif
10473
10474 #ifdef _WIN
10475 struct stat64 tmpstat;
10476
10477 _fstat64 (fileno (dictstat_fp), &tmpstat);
10478 #endif
10479
10480 if (tmpstat.st_mtime < COMPTIME)
10481 {
10482 /* with v0.15 the format changed so we have to ensure user is using a good version
10483 since there is no version-header in the dictstat file */
10484
10485 fclose (dictstat_fp);
10486
10487 unlink (dictstat);
10488 }
10489 else
10490 {
10491 while (!feof (dictstat_fp))
10492 {
10493 dictstat_t d;
10494
10495 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10496
10497 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10498
10499 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10500 {
10501 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10502
10503 return -1;
10504 }
10505 }
10506
10507 fclose (dictstat_fp);
10508 }
10509 }
10510 }
10511
10512 /**
10513 * potfile
10514 */
10515
10516 char potfile[256] = { 0 };
10517
10518 if (potfile_path == NULL)
10519 {
10520 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10521 }
10522 else
10523 {
10524 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10525 }
10526
10527 data.pot_fp = NULL;
10528
10529 FILE *out_fp = NULL;
10530 FILE *pot_fp = NULL;
10531
10532 if (show == 1 || left == 1)
10533 {
10534 pot_fp = fopen (potfile, "rb");
10535
10536 if (pot_fp == NULL)
10537 {
10538 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10539
10540 return (-1);
10541 }
10542
10543 if (outfile != NULL)
10544 {
10545 if ((out_fp = fopen (outfile, "ab")) == NULL)
10546 {
10547 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10548
10549 fclose (pot_fp);
10550
10551 return (-1);
10552 }
10553 }
10554 else
10555 {
10556 out_fp = stdout;
10557 }
10558 }
10559 else
10560 {
10561 if (potfile_disable == 0)
10562 {
10563 pot_fp = fopen (potfile, "ab");
10564
10565 if (pot_fp == NULL)
10566 {
10567 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10568
10569 return (-1);
10570 }
10571
10572 data.pot_fp = pot_fp;
10573 }
10574 }
10575
10576 pot_t *pot = NULL;
10577
10578 uint pot_cnt = 0;
10579 uint pot_avail = 0;
10580
10581 if (show == 1 || left == 1)
10582 {
10583 SUPPRESS_OUTPUT = 1;
10584
10585 pot_avail = count_lines (pot_fp);
10586
10587 rewind (pot_fp);
10588
10589 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10590
10591 uint pot_hashes_avail = 0;
10592
10593 uint line_num = 0;
10594
10595 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10596
10597 while (!feof (pot_fp))
10598 {
10599 line_num++;
10600
10601 int line_len = fgetl (pot_fp, line_buf);
10602
10603 if (line_len == 0) continue;
10604
10605 char *plain_buf = line_buf + line_len;
10606
10607 pot_t *pot_ptr = &pot[pot_cnt];
10608
10609 hash_t *hashes_buf = &pot_ptr->hash;
10610
10611 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10612 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10613
10614 if (pot_cnt == pot_hashes_avail)
10615 {
10616 uint pos = 0;
10617
10618 for (pos = 0; pos < INCR_POT; pos++)
10619 {
10620 if ((pot_cnt + pos) >= pot_avail) break;
10621
10622 pot_t *tmp_pot = &pot[pot_cnt + pos];
10623
10624 hash_t *tmp_hash = &tmp_pot->hash;
10625
10626 tmp_hash->digest = mymalloc (dgst_size);
10627
10628 if (isSalted)
10629 {
10630 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10631 }
10632
10633 if (esalt_size)
10634 {
10635 tmp_hash->esalt = mymalloc (esalt_size);
10636 }
10637
10638 pot_hashes_avail++;
10639 }
10640 }
10641
10642 int plain_len = 0;
10643
10644 int parser_status;
10645
10646 int iter = MAX_CUT_TRIES;
10647
10648 do
10649 {
10650 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10651 {
10652 if (line_buf[i] == ':')
10653 {
10654 line_len--;
10655
10656 break;
10657 }
10658 }
10659
10660 if (data.hash_mode != 2500)
10661 {
10662 parser_status = parse_func (line_buf, line_len, hashes_buf);
10663 }
10664 else
10665 {
10666 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10667
10668 if (line_len > max_salt_size)
10669 {
10670 parser_status = PARSER_GLOBAL_LENGTH;
10671 }
10672 else
10673 {
10674 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10675
10676 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10677
10678 hashes_buf->salt->salt_len = line_len;
10679
10680 parser_status = PARSER_OK;
10681 }
10682 }
10683
10684 // if NOT parsed without error, we add the ":" to the plain
10685
10686 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10687 {
10688 plain_len++;
10689 plain_buf--;
10690 }
10691
10692 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10693
10694 if (parser_status < PARSER_GLOBAL_ZERO)
10695 {
10696 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10697
10698 continue;
10699 }
10700
10701 if (plain_len >= 255) continue;
10702
10703 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10704
10705 pot_ptr->plain_len = plain_len;
10706
10707 pot_cnt++;
10708 }
10709
10710 myfree (line_buf);
10711
10712 fclose (pot_fp);
10713
10714 SUPPRESS_OUTPUT = 0;
10715
10716 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10717 }
10718
10719 /**
10720 * word len
10721 */
10722
10723 uint pw_min = PW_MIN;
10724 uint pw_max = PW_MAX;
10725
10726 switch (hash_mode)
10727 {
10728 case 125: if (pw_max > 32) pw_max = 32;
10729 break;
10730 case 400: if (pw_max > 40) pw_max = 40;
10731 break;
10732 case 500: if (pw_max > 16) pw_max = 16;
10733 break;
10734 case 1500: if (pw_max > 8) pw_max = 8;
10735 break;
10736 case 1600: if (pw_max > 16) pw_max = 16;
10737 break;
10738 case 1800: if (pw_max > 16) pw_max = 16;
10739 break;
10740 case 2100: if (pw_max > 16) pw_max = 16;
10741 break;
10742 case 2500: if (pw_min < 8) pw_min = 8;
10743 break;
10744 case 3000: if (pw_max > 7) pw_max = 7;
10745 break;
10746 case 5200: if (pw_max > 24) pw_max = 24;
10747 break;
10748 case 5800: if (pw_max > 16) pw_max = 16;
10749 break;
10750 case 6300: if (pw_max > 16) pw_max = 16;
10751 break;
10752 case 7400: if (pw_max > 16) pw_max = 16;
10753 break;
10754 case 7900: if (pw_max > 48) pw_max = 48;
10755 break;
10756 case 8500: if (pw_max > 8) pw_max = 8;
10757 break;
10758 case 8600: if (pw_max > 16) pw_max = 16;
10759 break;
10760 case 9710: pw_min = 5;
10761 pw_max = 5;
10762 break;
10763 case 9810: pw_min = 5;
10764 pw_max = 5;
10765 break;
10766 case 10410: pw_min = 5;
10767 pw_max = 5;
10768 break;
10769 case 10300: if (pw_max < 3) pw_min = 3;
10770 if (pw_max > 40) pw_max = 40;
10771 break;
10772 case 10500: if (pw_max < 3) pw_min = 3;
10773 if (pw_max > 40) pw_max = 40;
10774 break;
10775 case 10700: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 11300: if (pw_max > 40) pw_max = 40;
10778 break;
10779 case 12500: if (pw_max > 20) pw_max = 20;
10780 break;
10781 case 12800: if (pw_max > 24) pw_max = 24;
10782 break;
10783 }
10784
10785 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10786 {
10787 switch (attack_kern)
10788 {
10789 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10790 break;
10791 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10792 break;
10793 }
10794 }
10795
10796 /**
10797 * charsets : keep them together for more easy maintainnce
10798 */
10799
10800 cs_t mp_sys[6] = { { { 0 }, 0 } };
10801 cs_t mp_usr[4] = { { { 0 }, 0 } };
10802
10803 mp_setup_sys (mp_sys);
10804
10805 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10806 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10807 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10808 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10809
10810 /**
10811 * load hashes, part I: find input mode, count hashes
10812 */
10813
10814 uint hashlist_mode = 0;
10815 uint hashlist_format = HLFMT_HASHCAT;
10816
10817 uint hashes_avail = 0;
10818
10819 if (benchmark == 0)
10820 {
10821 struct stat f;
10822
10823 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10824
10825 if ((hash_mode == 2500) ||
10826 (hash_mode == 5200) ||
10827 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10828 (hash_mode == 9000))
10829 {
10830 hashlist_mode = HL_MODE_ARG;
10831
10832 char *hashfile = myargv[optind];
10833
10834 data.hashfile = hashfile;
10835
10836 logfile_top_var_string ("target", hashfile);
10837 }
10838
10839 if (hashlist_mode == HL_MODE_ARG)
10840 {
10841 if (hash_mode == 2500)
10842 {
10843 struct stat st;
10844
10845 if (stat (data.hashfile, &st) == -1)
10846 {
10847 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10848
10849 return (-1);
10850 }
10851
10852 hashes_avail = st.st_size / sizeof (hccap_t);
10853 }
10854 else
10855 {
10856 hashes_avail = 1;
10857 }
10858 }
10859 else if (hashlist_mode == HL_MODE_FILE)
10860 {
10861 char *hashfile = myargv[optind];
10862
10863 data.hashfile = hashfile;
10864
10865 logfile_top_var_string ("target", hashfile);
10866
10867 FILE *fp = NULL;
10868
10869 if ((fp = fopen (hashfile, "rb")) == NULL)
10870 {
10871 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10872
10873 return (-1);
10874 }
10875
10876 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10877
10878 hashes_avail = count_lines (fp);
10879
10880 rewind (fp);
10881
10882 if (hashes_avail == 0)
10883 {
10884 log_error ("ERROR: hashfile is empty or corrupt");
10885
10886 fclose (fp);
10887
10888 return (-1);
10889 }
10890
10891 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10892
10893 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10894 {
10895 log_error ("ERROR: remove not supported in native hashfile-format mode");
10896
10897 fclose (fp);
10898
10899 return (-1);
10900 }
10901
10902 fclose (fp);
10903 }
10904 }
10905 else
10906 {
10907 hashlist_mode = HL_MODE_ARG;
10908
10909 hashes_avail = 1;
10910 }
10911
10912 if (hash_mode == 3000) hashes_avail *= 2;
10913
10914 data.hashlist_mode = hashlist_mode;
10915 data.hashlist_format = hashlist_format;
10916
10917 logfile_top_uint (hashlist_mode);
10918 logfile_top_uint (hashlist_format);
10919
10920 /**
10921 * load hashes, part II: allocate required memory, set pointers
10922 */
10923
10924 hash_t *hashes_buf = NULL;
10925 void *digests_buf = NULL;
10926 salt_t *salts_buf = NULL;
10927 void *esalts_buf = NULL;
10928
10929 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10930
10931 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10932
10933 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10934 {
10935 u32 hash_pos;
10936
10937 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10938 {
10939 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10940
10941 hashes_buf[hash_pos].hash_info = hash_info;
10942
10943 if (username && (remove || show || left))
10944 {
10945 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10946 }
10947
10948 if (benchmark)
10949 {
10950 hash_info->orighash = (char *) mymalloc (256);
10951 }
10952 }
10953 }
10954
10955 if (isSalted)
10956 {
10957 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10958
10959 if (esalt_size)
10960 {
10961 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10962 }
10963 }
10964 else
10965 {
10966 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10967 }
10968
10969 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10970 {
10971 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10972
10973 if (isSalted)
10974 {
10975 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10976
10977 if (esalt_size)
10978 {
10979 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10980 }
10981 }
10982 else
10983 {
10984 hashes_buf[hash_pos].salt = &salts_buf[0];
10985 }
10986 }
10987
10988 /**
10989 * load hashes, part III: parse hashes or generate them if benchmark
10990 */
10991
10992 uint hashes_cnt = 0;
10993
10994 if (benchmark == 0)
10995 {
10996 if (keyspace == 1)
10997 {
10998 // useless to read hash file for keyspace, cheat a little bit w/ optind
10999 }
11000 else if (hashes_avail == 0)
11001 {
11002 }
11003 else if (hashlist_mode == HL_MODE_ARG)
11004 {
11005 char *input_buf = myargv[optind];
11006
11007 uint input_len = strlen (input_buf);
11008
11009 logfile_top_var_string ("target", input_buf);
11010
11011 char *hash_buf = NULL;
11012 int hash_len = 0;
11013
11014 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11015
11016 bool hash_fmt_error = 0;
11017
11018 if (hash_len < 1) hash_fmt_error = 1;
11019 if (hash_buf == NULL) hash_fmt_error = 1;
11020
11021 if (hash_fmt_error)
11022 {
11023 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11024 }
11025 else
11026 {
11027 if (opts_type & OPTS_TYPE_HASH_COPY)
11028 {
11029 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11030
11031 hash_info_tmp->orighash = mystrdup (hash_buf);
11032 }
11033
11034 if (isSalted)
11035 {
11036 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11037 }
11038
11039 int parser_status = PARSER_OK;
11040
11041 if (hash_mode == 2500)
11042 {
11043 if (hash_len == 0)
11044 {
11045 log_error ("ERROR: hccap file not specified");
11046
11047 return (-1);
11048 }
11049
11050 hashlist_mode = HL_MODE_FILE;
11051
11052 data.hashlist_mode = hashlist_mode;
11053
11054 FILE *fp = fopen (hash_buf, "rb");
11055
11056 if (fp == NULL)
11057 {
11058 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11059
11060 return (-1);
11061 }
11062
11063 if (hashes_avail < 1)
11064 {
11065 log_error ("ERROR: hccap file is empty or corrupt");
11066
11067 fclose (fp);
11068
11069 return (-1);
11070 }
11071
11072 uint hccap_size = sizeof (hccap_t);
11073
11074 char *in = (char *) mymalloc (hccap_size);
11075
11076 while (!feof (fp))
11077 {
11078 int n = fread (in, hccap_size, 1, fp);
11079
11080 if (n != 1)
11081 {
11082 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11083
11084 break;
11085 }
11086
11087 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11088
11089 if (parser_status != PARSER_OK)
11090 {
11091 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11092
11093 continue;
11094 }
11095
11096 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11097
11098 if ((show == 1) || (left == 1))
11099 {
11100 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11101
11102 char *salt_ptr = (char *) tmp_salt->salt_buf;
11103
11104 int cur_pos = tmp_salt->salt_len;
11105 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11106
11107 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11108
11109 // do the appending task
11110
11111 snprintf (salt_ptr + cur_pos,
11112 rem_len,
11113 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11114 wpa->orig_mac1[0],
11115 wpa->orig_mac1[1],
11116 wpa->orig_mac1[2],
11117 wpa->orig_mac1[3],
11118 wpa->orig_mac1[4],
11119 wpa->orig_mac1[5],
11120 wpa->orig_mac2[0],
11121 wpa->orig_mac2[1],
11122 wpa->orig_mac2[2],
11123 wpa->orig_mac2[3],
11124 wpa->orig_mac2[4],
11125 wpa->orig_mac2[5]);
11126
11127 // memset () the remaining part of the salt
11128
11129 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11130 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11131
11132 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11133
11134 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11135 }
11136
11137 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);
11138 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);
11139
11140 hashes_cnt++;
11141 }
11142
11143 fclose (fp);
11144
11145 myfree (in);
11146 }
11147 else if (hash_mode == 3000)
11148 {
11149 if (hash_len == 32)
11150 {
11151 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11152
11153 hash_t *lm_hash_left = NULL;
11154
11155 if (parser_status == PARSER_OK)
11156 {
11157 lm_hash_left = &hashes_buf[hashes_cnt];
11158
11159 hashes_cnt++;
11160 }
11161 else
11162 {
11163 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11164 }
11165
11166 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11167
11168 hash_t *lm_hash_right = NULL;
11169
11170 if (parser_status == PARSER_OK)
11171 {
11172 lm_hash_right = &hashes_buf[hashes_cnt];
11173
11174 hashes_cnt++;
11175 }
11176 else
11177 {
11178 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11179 }
11180
11181 // show / left
11182
11183 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11184 {
11185 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);
11186 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);
11187 }
11188 }
11189 else
11190 {
11191 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11192
11193 if (parser_status == PARSER_OK)
11194 {
11195 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11196 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11197 }
11198
11199 if (parser_status == PARSER_OK)
11200 {
11201 hashes_cnt++;
11202 }
11203 else
11204 {
11205 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11206 }
11207 }
11208 }
11209 else
11210 {
11211 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11212
11213 if (parser_status == PARSER_OK)
11214 {
11215 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11216 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11217 }
11218
11219 if (parser_status == PARSER_OK)
11220 {
11221 hashes_cnt++;
11222 }
11223 else
11224 {
11225 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11226 }
11227 }
11228 }
11229 }
11230 else if (hashlist_mode == HL_MODE_FILE)
11231 {
11232 char *hashfile = data.hashfile;
11233
11234 FILE *fp;
11235
11236 if ((fp = fopen (hashfile, "rb")) == NULL)
11237 {
11238 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11239
11240 return (-1);
11241 }
11242
11243 uint line_num = 0;
11244
11245 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11246
11247 while (!feof (fp))
11248 {
11249 line_num++;
11250
11251 int line_len = fgetl (fp, line_buf);
11252
11253 if (line_len == 0) continue;
11254
11255 char *hash_buf = NULL;
11256 int hash_len = 0;
11257
11258 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11259
11260 bool hash_fmt_error = 0;
11261
11262 if (hash_len < 1) hash_fmt_error = 1;
11263 if (hash_buf == NULL) hash_fmt_error = 1;
11264
11265 if (hash_fmt_error)
11266 {
11267 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11268
11269 continue;
11270 }
11271
11272 if (username)
11273 {
11274 char *user_buf = NULL;
11275 int user_len = 0;
11276
11277 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11278
11279 if (remove || show)
11280 {
11281 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11282
11283 *user = (user_t *) mymalloc (sizeof (user_t));
11284
11285 user_t *user_ptr = *user;
11286
11287 if (user_buf != NULL)
11288 {
11289 user_ptr->user_name = mystrdup (user_buf);
11290 }
11291 else
11292 {
11293 user_ptr->user_name = mystrdup ("");
11294 }
11295
11296 user_ptr->user_len = user_len;
11297 }
11298 }
11299
11300 if (opts_type & OPTS_TYPE_HASH_COPY)
11301 {
11302 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11303
11304 hash_info_tmp->orighash = mystrdup (hash_buf);
11305 }
11306
11307 if (isSalted)
11308 {
11309 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11310 }
11311
11312 if (hash_mode == 3000)
11313 {
11314 if (hash_len == 32)
11315 {
11316 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11317
11318 if (parser_status < PARSER_GLOBAL_ZERO)
11319 {
11320 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11321
11322 continue;
11323 }
11324
11325 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11326
11327 hashes_cnt++;
11328
11329 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11330
11331 if (parser_status < PARSER_GLOBAL_ZERO)
11332 {
11333 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11334
11335 continue;
11336 }
11337
11338 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11339
11340 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);
11341
11342 hashes_cnt++;
11343
11344 // show / left
11345
11346 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);
11347 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);
11348 }
11349 else
11350 {
11351 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11352
11353 if (parser_status < PARSER_GLOBAL_ZERO)
11354 {
11355 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11356
11357 continue;
11358 }
11359
11360 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);
11361
11362 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11363 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11364
11365 hashes_cnt++;
11366 }
11367 }
11368 else
11369 {
11370 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11371
11372 if (parser_status < PARSER_GLOBAL_ZERO)
11373 {
11374 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11375
11376 continue;
11377 }
11378
11379 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);
11380
11381 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11382 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11383
11384 hashes_cnt++;
11385 }
11386 }
11387
11388 myfree (line_buf);
11389
11390 fclose (fp);
11391
11392 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11393
11394 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11395 }
11396 }
11397 else
11398 {
11399 if (isSalted)
11400 {
11401 hashes_buf[0].salt->salt_len = 8;
11402
11403 // special salt handling
11404
11405 switch (hash_mode)
11406 {
11407 case 1500: hashes_buf[0].salt->salt_len = 2;
11408 break;
11409 case 1731: hashes_buf[0].salt->salt_len = 4;
11410 break;
11411 case 2410: hashes_buf[0].salt->salt_len = 4;
11412 break;
11413 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11414 break;
11415 case 3100: hashes_buf[0].salt->salt_len = 1;
11416 break;
11417 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11418 break;
11419 case 5800: hashes_buf[0].salt->salt_len = 16;
11420 break;
11421 case 6800: hashes_buf[0].salt->salt_len = 32;
11422 break;
11423 case 8400: hashes_buf[0].salt->salt_len = 40;
11424 break;
11425 case 8800: hashes_buf[0].salt->salt_len = 16;
11426 break;
11427 case 8900: hashes_buf[0].salt->salt_len = 16;
11428 hashes_buf[0].salt->scrypt_N = 1024;
11429 hashes_buf[0].salt->scrypt_r = 1;
11430 hashes_buf[0].salt->scrypt_p = 1;
11431 break;
11432 case 9100: hashes_buf[0].salt->salt_len = 16;
11433 break;
11434 case 9300: hashes_buf[0].salt->salt_len = 14;
11435 hashes_buf[0].salt->scrypt_N = 16384;
11436 hashes_buf[0].salt->scrypt_r = 1;
11437 hashes_buf[0].salt->scrypt_p = 1;
11438 break;
11439 case 9400: hashes_buf[0].salt->salt_len = 16;
11440 break;
11441 case 9500: hashes_buf[0].salt->salt_len = 16;
11442 break;
11443 case 9600: hashes_buf[0].salt->salt_len = 16;
11444 break;
11445 case 9700: hashes_buf[0].salt->salt_len = 16;
11446 break;
11447 case 9710: hashes_buf[0].salt->salt_len = 16;
11448 break;
11449 case 9720: hashes_buf[0].salt->salt_len = 16;
11450 break;
11451 case 9800: hashes_buf[0].salt->salt_len = 16;
11452 break;
11453 case 9810: hashes_buf[0].salt->salt_len = 16;
11454 break;
11455 case 9820: hashes_buf[0].salt->salt_len = 16;
11456 break;
11457 case 10300: hashes_buf[0].salt->salt_len = 12;
11458 break;
11459 case 11500: hashes_buf[0].salt->salt_len = 4;
11460 break;
11461 case 11600: hashes_buf[0].salt->salt_len = 4;
11462 break;
11463 case 12400: hashes_buf[0].salt->salt_len = 4;
11464 break;
11465 case 12500: hashes_buf[0].salt->salt_len = 8;
11466 break;
11467 case 12600: hashes_buf[0].salt->salt_len = 64;
11468 break;
11469 }
11470
11471 // special esalt handling
11472
11473 switch (hash_mode)
11474 {
11475 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11476 break;
11477 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11478 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11479 break;
11480 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11481 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11482 break;
11483 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11484 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11485 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11486 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11487 break;
11488 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11489 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11490 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11491 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11492 break;
11493 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11494 break;
11495 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11496 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11497 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11498 break;
11499 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11500 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11501 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11502 break;
11503 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11504 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11505 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11506 break;
11507 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11508 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11509 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11510 break;
11511 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11512 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11513 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11514 break;
11515 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11516 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11517 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11518 break;
11519 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11520 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11521 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11522 break;
11523 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11524 break;
11525 }
11526 }
11527
11528 // set hashfile
11529
11530 switch (hash_mode)
11531 {
11532 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11533 break;
11534 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11535 break;
11536 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11537 break;
11538 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11539 break;
11540 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11541 break;
11542 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11543 break;
11544 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11545 break;
11546 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11547 break;
11548 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11549 break;
11550 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11551 break;
11552 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11553 break;
11554 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11555 break;
11556 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11557 break;
11558 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11559 break;
11560 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11561 break;
11562 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11563 break;
11564 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11565 break;
11566 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11567 break;
11568 }
11569
11570 // set default iterations
11571
11572 switch (hash_mode)
11573 {
11574 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11575 break;
11576 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11577 break;
11578 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11579 break;
11580 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11581 break;
11582 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11583 break;
11584 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11585 break;
11586 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11587 break;
11588 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11589 break;
11590 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11591 break;
11592 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11593 break;
11594 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11595 break;
11596 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11597 break;
11598 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11599 break;
11600 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11601 break;
11602 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11603 break;
11604 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11605 break;
11606 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11607 break;
11608 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11609 break;
11610 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11611 break;
11612 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11613 break;
11614 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11615 break;
11616 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11617 break;
11618 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11619 break;
11620 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11621 break;
11622 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11623 break;
11624 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11625 break;
11626 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11627 break;
11628 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11629 break;
11630 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11631 break;
11632 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11633 break;
11634 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11635 break;
11636 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11637 break;
11638 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11639 break;
11640 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11641 break;
11642 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11643 break;
11644 case 8900: hashes_buf[0].salt->salt_iter = 1;
11645 break;
11646 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11647 break;
11648 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11649 break;
11650 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11651 break;
11652 case 9300: hashes_buf[0].salt->salt_iter = 1;
11653 break;
11654 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11655 break;
11656 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11657 break;
11658 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11659 break;
11660 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11661 break;
11662 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11663 break;
11664 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11665 break;
11666 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11667 break;
11668 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11669 break;
11670 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11671 break;
11672 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11673 break;
11674 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11675 break;
11676 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11677 break;
11678 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11679 break;
11680 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11681 break;
11682 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11683 break;
11684 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11685 break;
11686 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11687 break;
11688 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11689 break;
11690 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11691 break;
11692 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11693 break;
11694 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11695 break;
11696 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11697 break;
11698 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11699 break;
11700 }
11701
11702 hashes_cnt = 1;
11703 }
11704
11705 if (show == 1 || left == 1)
11706 {
11707 for (uint i = 0; i < pot_cnt; i++)
11708 {
11709 pot_t *pot_ptr = &pot[i];
11710
11711 hash_t *hashes_buf = &pot_ptr->hash;
11712
11713 local_free (hashes_buf->digest);
11714
11715 if (isSalted)
11716 {
11717 local_free (hashes_buf->salt);
11718 }
11719 }
11720
11721 local_free (pot);
11722
11723 if (data.quiet == 0) log_info_nn ("");
11724
11725 return (0);
11726 }
11727
11728 if (keyspace == 0)
11729 {
11730 if (hashes_cnt == 0)
11731 {
11732 log_error ("ERROR: No hashes loaded");
11733
11734 return (-1);
11735 }
11736 }
11737
11738 /**
11739 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11740 */
11741
11742 if (data.outfile != NULL)
11743 {
11744 if (data.hashfile != NULL)
11745 {
11746 #ifdef _POSIX
11747 struct stat tmpstat_outfile;
11748 struct stat tmpstat_hashfile;
11749 #endif
11750
11751 #ifdef _WIN
11752 struct stat64 tmpstat_outfile;
11753 struct stat64 tmpstat_hashfile;
11754 #endif
11755
11756 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11757
11758 if (tmp_outfile_fp)
11759 {
11760 #ifdef _POSIX
11761 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11762 #endif
11763
11764 #ifdef _WIN
11765 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11766 #endif
11767
11768 fclose (tmp_outfile_fp);
11769 }
11770
11771 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11772
11773 if (tmp_hashfile_fp)
11774 {
11775 #ifdef _POSIX
11776 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11777 #endif
11778
11779 #ifdef _WIN
11780 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11781 #endif
11782
11783 fclose (tmp_hashfile_fp);
11784 }
11785
11786 if (tmp_outfile_fp && tmp_outfile_fp)
11787 {
11788 tmpstat_outfile.st_mode = 0;
11789 tmpstat_outfile.st_nlink = 0;
11790 tmpstat_outfile.st_uid = 0;
11791 tmpstat_outfile.st_gid = 0;
11792 tmpstat_outfile.st_rdev = 0;
11793 tmpstat_outfile.st_atime = 0;
11794
11795 tmpstat_hashfile.st_mode = 0;
11796 tmpstat_hashfile.st_nlink = 0;
11797 tmpstat_hashfile.st_uid = 0;
11798 tmpstat_hashfile.st_gid = 0;
11799 tmpstat_hashfile.st_rdev = 0;
11800 tmpstat_hashfile.st_atime = 0;
11801
11802 #ifdef _POSIX
11803 tmpstat_outfile.st_blksize = 0;
11804 tmpstat_outfile.st_blocks = 0;
11805
11806 tmpstat_hashfile.st_blksize = 0;
11807 tmpstat_hashfile.st_blocks = 0;
11808 #endif
11809
11810 #ifdef _POSIX
11811 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11812 {
11813 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11814
11815 return (-1);
11816 }
11817 #endif
11818
11819 #ifdef _WIN
11820 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11821 {
11822 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11823
11824 return (-1);
11825 }
11826 #endif
11827 }
11828 }
11829 }
11830
11831 /**
11832 * Remove duplicates
11833 */
11834
11835 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11836
11837 if (isSalted)
11838 {
11839 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11840 }
11841 else
11842 {
11843 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11844 }
11845
11846 uint hashes_cnt_orig = hashes_cnt;
11847
11848 hashes_cnt = 1;
11849
11850 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11851 {
11852 if (isSalted)
11853 {
11854 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11855 {
11856 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11857 }
11858 }
11859 else
11860 {
11861 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11862 }
11863
11864 if (hashes_pos > hashes_cnt)
11865 {
11866 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11867 }
11868
11869 hashes_cnt++;
11870 }
11871
11872 /**
11873 * Potfile removes
11874 */
11875
11876 uint potfile_remove_cracks = 0;
11877
11878 if (potfile_disable == 0)
11879 {
11880 hash_t hash_buf;
11881
11882 hash_buf.digest = mymalloc (dgst_size);
11883 hash_buf.salt = NULL;
11884 hash_buf.esalt = NULL;
11885 hash_buf.hash_info = NULL;
11886 hash_buf.cracked = 0;
11887
11888 if (isSalted)
11889 {
11890 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11891 }
11892
11893 if (esalt_size)
11894 {
11895 hash_buf.esalt = mymalloc (esalt_size);
11896 }
11897
11898 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11899
11900 // no solution for these special hash types (for instane because they use hashfile in output etc)
11901 if ((hash_mode != 5200) &&
11902 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11903 (hash_mode != 9000))
11904 {
11905 FILE *fp = fopen (potfile, "rb");
11906
11907 if (fp != NULL)
11908 {
11909 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11910
11911 // to be safe work with a copy (because of line_len loop, i etc)
11912 // moved up here because it's easier to handle continue case
11913 // it's just 64kb
11914
11915 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11916
11917 while (!feof (fp))
11918 {
11919 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11920
11921 if (ptr == NULL) break;
11922
11923 int line_len = strlen (line_buf);
11924
11925 if (line_len == 0) continue;
11926
11927 int iter = MAX_CUT_TRIES;
11928
11929 for (int i = line_len - 1; i && iter; i--, line_len--)
11930 {
11931 if (line_buf[i] != ':') continue;
11932
11933 if (isSalted)
11934 {
11935 memset (hash_buf.salt, 0, sizeof (salt_t));
11936 }
11937
11938 hash_t *found = NULL;
11939
11940 if (hash_mode == 6800)
11941 {
11942 if (i < 64) // 64 = 16 * uint in salt_buf[]
11943 {
11944 // manipulate salt_buf
11945 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11946
11947 hash_buf.salt->salt_len = i;
11948
11949 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11950 }
11951 }
11952 else if (hash_mode == 2500)
11953 {
11954 if (i < 64) // 64 = 16 * uint in salt_buf[]
11955 {
11956 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11957 // manipulate salt_buf
11958
11959 memcpy (line_buf_cpy, line_buf, i);
11960
11961 char *mac2_pos = strrchr (line_buf_cpy, ':');
11962
11963 if (mac2_pos == NULL) continue;
11964
11965 mac2_pos[0] = 0;
11966 mac2_pos++;
11967
11968 if (strlen (mac2_pos) != 12) continue;
11969
11970 char *mac1_pos = strrchr (line_buf_cpy, ':');
11971
11972 if (mac1_pos == NULL) continue;
11973
11974 mac1_pos[0] = 0;
11975 mac1_pos++;
11976
11977 if (strlen (mac1_pos) != 12) continue;
11978
11979 uint essid_length = mac1_pos - line_buf_cpy - 1;
11980
11981 // here we need the ESSID
11982 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11983
11984 hash_buf.salt->salt_len = essid_length;
11985
11986 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11987
11988 if (found)
11989 {
11990 wpa_t *wpa = (wpa_t *) found->esalt;
11991
11992 // compare hex string(s) vs binary MAC address(es)
11993
11994 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11995 {
11996 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11997 {
11998 found = NULL;
11999
12000 break;
12001 }
12002 }
12003
12004 // early skip ;)
12005 if (!found) continue;
12006
12007 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12008 {
12009 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12010 {
12011 found = NULL;
12012
12013 break;
12014 }
12015 }
12016 }
12017 }
12018 }
12019 else
12020 {
12021 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12022
12023 if (parser_status == PARSER_OK)
12024 {
12025 if (isSalted)
12026 {
12027 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12028 }
12029 else
12030 {
12031 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12032 }
12033 }
12034 }
12035
12036 if (found == NULL) continue;
12037
12038 if (!found->cracked) potfile_remove_cracks++;
12039
12040 found->cracked = 1;
12041
12042 if (found) break;
12043
12044 iter--;
12045 }
12046 }
12047
12048 myfree (line_buf_cpy);
12049
12050 myfree (line_buf);
12051
12052 fclose (fp);
12053 }
12054 }
12055
12056 if (esalt_size)
12057 {
12058 local_free (hash_buf.esalt);
12059 }
12060
12061 if (isSalted)
12062 {
12063 local_free (hash_buf.salt);
12064 }
12065
12066 local_free (hash_buf.digest);
12067 }
12068
12069 /**
12070 * Now generate all the buffers required for later
12071 */
12072
12073 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12074
12075 salt_t *salts_buf_new = NULL;
12076 void *esalts_buf_new = NULL;
12077
12078 if (isSalted)
12079 {
12080 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12081
12082 if (esalt_size)
12083 {
12084 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12085 }
12086 }
12087 else
12088 {
12089 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12090 }
12091
12092 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12093
12094 uint digests_cnt = hashes_cnt;
12095 uint digests_done = 0;
12096
12097 uint size_digests = digests_cnt * dgst_size;
12098 uint size_shown = digests_cnt * sizeof (uint);
12099
12100 uint *digests_shown = (uint *) mymalloc (size_shown);
12101 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12102
12103 uint salts_cnt = 0;
12104 uint salts_done = 0;
12105
12106 hashinfo_t **hash_info = NULL;
12107
12108 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12109 {
12110 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12111
12112 if (username && (remove || show))
12113 {
12114 uint user_pos;
12115
12116 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12117 {
12118 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12119
12120 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12121 }
12122 }
12123 }
12124
12125 uint *salts_shown = (uint *) mymalloc (size_shown);
12126
12127 salt_t *salt_buf;
12128
12129 {
12130 // copied from inner loop
12131
12132 salt_buf = &salts_buf_new[salts_cnt];
12133
12134 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12135
12136 if (esalt_size)
12137 {
12138 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12139 }
12140
12141 salt_buf->digests_cnt = 0;
12142 salt_buf->digests_done = 0;
12143 salt_buf->digests_offset = 0;
12144
12145 salts_cnt++;
12146 }
12147
12148 if (hashes_buf[0].cracked == 1)
12149 {
12150 digests_shown[0] = 1;
12151
12152 digests_done++;
12153
12154 salt_buf->digests_done++;
12155 }
12156
12157 salt_buf->digests_cnt++;
12158
12159 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12160
12161 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12162 {
12163 hash_info[0] = hashes_buf[0].hash_info;
12164 }
12165
12166 // copy from inner loop
12167
12168 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12169 {
12170 if (isSalted)
12171 {
12172 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12173 {
12174 salt_buf = &salts_buf_new[salts_cnt];
12175
12176 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12177
12178 if (esalt_size)
12179 {
12180 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12181 }
12182
12183 salt_buf->digests_cnt = 0;
12184 salt_buf->digests_done = 0;
12185 salt_buf->digests_offset = hashes_pos;
12186
12187 salts_cnt++;
12188 }
12189 }
12190
12191 if (hashes_buf[hashes_pos].cracked == 1)
12192 {
12193 digests_shown[hashes_pos] = 1;
12194
12195 digests_done++;
12196
12197 salt_buf->digests_done++;
12198 }
12199
12200 salt_buf->digests_cnt++;
12201
12202 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12203
12204 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12205 {
12206 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12207 }
12208 }
12209
12210 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12211 {
12212 salt_t *salt_buf = &salts_buf_new[salt_pos];
12213
12214 if (salt_buf->digests_done == salt_buf->digests_cnt)
12215 {
12216 salts_shown[salt_pos] = 1;
12217
12218 salts_done++;
12219 }
12220
12221 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12222 }
12223
12224 local_free (digests_buf);
12225 local_free (salts_buf);
12226 local_free (esalts_buf);
12227
12228 digests_buf = digests_buf_new;
12229 salts_buf = salts_buf_new;
12230 esalts_buf = esalts_buf_new;
12231
12232 local_free (hashes_buf);
12233
12234 /**
12235 * special modification not set from parser
12236 */
12237
12238 switch (hash_mode)
12239 {
12240 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12241 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12242 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12243 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12244 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12245 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12246 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12247 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12248 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12249 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12250 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12251 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12252 }
12253
12254 if (truecrypt_keyfiles)
12255 {
12256 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12257
12258 char *keyfiles = strdup (truecrypt_keyfiles);
12259
12260 char *keyfile = strtok (keyfiles, ",");
12261
12262 do
12263 {
12264 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12265
12266 } while ((keyfile = strtok (NULL, ",")) != NULL);
12267
12268 free (keyfiles);
12269 }
12270
12271 data.digests_cnt = digests_cnt;
12272 data.digests_done = digests_done;
12273 data.digests_buf = digests_buf;
12274 data.digests_shown = digests_shown;
12275 data.digests_shown_tmp = digests_shown_tmp;
12276
12277 data.salts_cnt = salts_cnt;
12278 data.salts_done = salts_done;
12279 data.salts_buf = salts_buf;
12280 data.salts_shown = salts_shown;
12281
12282 data.esalts_buf = esalts_buf;
12283 data.hash_info = hash_info;
12284
12285 /**
12286 * Automatic Optimizers
12287 */
12288
12289 if (salts_cnt == 1)
12290 opti_type |= OPTI_TYPE_SINGLE_SALT;
12291
12292 if (digests_cnt == 1)
12293 opti_type |= OPTI_TYPE_SINGLE_HASH;
12294
12295 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12296 opti_type |= OPTI_TYPE_NOT_ITERATED;
12297
12298 if (attack_mode == ATTACK_MODE_BF)
12299 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12300
12301 data.opti_type = opti_type;
12302
12303 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12304 {
12305 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12306 {
12307 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12308 {
12309 if (opts_type & OPTS_TYPE_ST_ADD80)
12310 {
12311 opts_type &= ~OPTS_TYPE_ST_ADD80;
12312 opts_type |= OPTS_TYPE_PT_ADD80;
12313 }
12314
12315 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12316 {
12317 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12318 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12319 }
12320
12321 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12322 {
12323 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12324 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12325 }
12326 }
12327 }
12328 }
12329
12330 /**
12331 * Some algorithm, like descrypt, can benefit from JIT compilation
12332 */
12333
12334 int force_jit_compilation = -1;
12335
12336 if (hash_mode == 8900)
12337 {
12338 force_jit_compilation = 8900;
12339 }
12340 else if (hash_mode == 9300)
12341 {
12342 force_jit_compilation = 8900;
12343 }
12344 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12345 {
12346 force_jit_compilation = 1500;
12347 }
12348
12349 /**
12350 * generate bitmap tables
12351 */
12352
12353 const uint bitmap_shift1 = 5;
12354 const uint bitmap_shift2 = 13;
12355
12356 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12357
12358 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12359 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12360 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12361 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12362 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12363 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12364 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12365 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12366
12367 uint bitmap_bits;
12368 uint bitmap_nums;
12369 uint bitmap_mask;
12370 uint bitmap_size;
12371
12372 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12373 {
12374 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12375
12376 bitmap_nums = 1 << bitmap_bits;
12377
12378 bitmap_mask = bitmap_nums - 1;
12379
12380 bitmap_size = bitmap_nums * sizeof (uint);
12381
12382 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12383
12384 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;
12385 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;
12386
12387 break;
12388 }
12389
12390 bitmap_nums = 1 << bitmap_bits;
12391
12392 bitmap_mask = bitmap_nums - 1;
12393
12394 bitmap_size = bitmap_nums * sizeof (uint);
12395
12396 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);
12397 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);
12398
12399 /**
12400 * prepare quick rule
12401 */
12402
12403 data.rule_buf_l = rule_buf_l;
12404 data.rule_buf_r = rule_buf_r;
12405
12406 int rule_len_l = (int) strlen (rule_buf_l);
12407 int rule_len_r = (int) strlen (rule_buf_r);
12408
12409 data.rule_len_l = rule_len_l;
12410 data.rule_len_r = rule_len_r;
12411
12412 /**
12413 * load rules
12414 */
12415
12416 uint *all_kernel_rules_cnt = NULL;
12417
12418 kernel_rule_t **all_kernel_rules_buf = NULL;
12419
12420 if (rp_files_cnt)
12421 {
12422 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12423
12424 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12425 }
12426
12427 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12428
12429 int rule_len = 0;
12430
12431 for (uint i = 0; i < rp_files_cnt; i++)
12432 {
12433 uint kernel_rules_avail = 0;
12434
12435 uint kernel_rules_cnt = 0;
12436
12437 kernel_rule_t *kernel_rules_buf = NULL;
12438
12439 char *rp_file = rp_files[i];
12440
12441 char in[BLOCK_SIZE] = { 0 };
12442 char out[BLOCK_SIZE] = { 0 };
12443
12444 FILE *fp = NULL;
12445
12446 uint rule_line = 0;
12447
12448 if ((fp = fopen (rp_file, "rb")) == NULL)
12449 {
12450 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12451
12452 return (-1);
12453 }
12454
12455 while (!feof (fp))
12456 {
12457 memset (rule_buf, 0, HCBUFSIZ);
12458
12459 rule_len = fgetl (fp, rule_buf);
12460
12461 rule_line++;
12462
12463 if (rule_len == 0) continue;
12464
12465 if (rule_buf[0] == '#') continue;
12466
12467 if (kernel_rules_avail == kernel_rules_cnt)
12468 {
12469 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12470
12471 kernel_rules_avail += INCR_RULES;
12472 }
12473
12474 memset (in, 0, BLOCK_SIZE);
12475 memset (out, 0, BLOCK_SIZE);
12476
12477 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12478
12479 if (result == -1)
12480 {
12481 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12482
12483 continue;
12484 }
12485
12486 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12487 {
12488 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12489
12490 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12491
12492 continue;
12493 }
12494
12495 /* its so slow
12496 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12497 {
12498 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12499
12500 continue;
12501 }
12502 */
12503
12504 kernel_rules_cnt++;
12505 }
12506
12507 fclose (fp);
12508
12509 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12510
12511 all_kernel_rules_buf[i] = kernel_rules_buf;
12512 }
12513
12514 /**
12515 * merge rules or automatic rule generator
12516 */
12517
12518 uint kernel_rules_cnt = 0;
12519
12520 kernel_rule_t *kernel_rules_buf = NULL;
12521
12522 if (attack_mode == ATTACK_MODE_STRAIGHT)
12523 {
12524 if (rp_files_cnt)
12525 {
12526 kernel_rules_cnt = 1;
12527
12528 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12529
12530 repeats[0] = kernel_rules_cnt;
12531
12532 for (uint i = 0; i < rp_files_cnt; i++)
12533 {
12534 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12535
12536 repeats[i + 1] = kernel_rules_cnt;
12537 }
12538
12539 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12540
12541 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12542
12543 for (uint i = 0; i < kernel_rules_cnt; i++)
12544 {
12545 uint out_pos = 0;
12546
12547 kernel_rule_t *out = &kernel_rules_buf[i];
12548
12549 for (uint j = 0; j < rp_files_cnt; j++)
12550 {
12551 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12552 uint in_pos;
12553
12554 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12555
12556 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12557 {
12558 if (out_pos == RULES_MAX - 1)
12559 {
12560 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12561
12562 break;
12563 }
12564
12565 out->cmds[out_pos] = in->cmds[in_pos];
12566 }
12567 }
12568 }
12569
12570 local_free (repeats);
12571 }
12572 else if (rp_gen)
12573 {
12574 uint kernel_rules_avail = 0;
12575
12576 while (kernel_rules_cnt < rp_gen)
12577 {
12578 if (kernel_rules_avail == kernel_rules_cnt)
12579 {
12580 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12581
12582 kernel_rules_avail += INCR_RULES;
12583 }
12584
12585 memset (rule_buf, 0, HCBUFSIZ);
12586
12587 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12588
12589 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12590
12591 kernel_rules_cnt++;
12592 }
12593 }
12594 }
12595
12596 myfree (rule_buf);
12597
12598 /**
12599 * generate NOP rules
12600 */
12601
12602 if (kernel_rules_cnt == 0)
12603 {
12604 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12605
12606 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12607
12608 kernel_rules_cnt++;
12609 }
12610
12611 data.kernel_rules_cnt = kernel_rules_cnt;
12612 data.kernel_rules_buf = kernel_rules_buf;
12613
12614 /**
12615 * OpenCL platforms: detect
12616 */
12617
12618 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12619 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12620
12621 cl_uint platforms_cnt = 0;
12622 cl_uint platform_devices_cnt = 0;
12623
12624 if (keyspace == 0)
12625 {
12626 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12627
12628 if (platforms_cnt == 0)
12629 {
12630 log_error ("ERROR: No OpenCL compatible platform found");
12631
12632 return (-1);
12633 }
12634
12635 if (opencl_platforms_filter != (uint) -1)
12636 {
12637 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12638
12639 if (opencl_platforms_filter > platform_cnt_mask)
12640 {
12641 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12642
12643 return (-1);
12644 }
12645 }
12646 }
12647
12648 /**
12649 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12650 */
12651
12652 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12653 {
12654 cl_platform_id platform = platforms[platform_id];
12655
12656 char platform_vendor[INFOSZ] = { 0 };
12657
12658 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12659
12660 #ifdef HAVE_HWMON
12661 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12662 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12663 {
12664 // make sure that we do not directly control the fan for NVidia
12665
12666 gpu_temp_retain = 0;
12667
12668 data.gpu_temp_retain = gpu_temp_retain;
12669 }
12670 #endif // HAVE_NVML || HAVE_NVAPI
12671 #endif
12672 }
12673
12674 /**
12675 * OpenCL devices: simply push all devices from all platforms into the same device array
12676 */
12677
12678 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12679
12680 data.devices_param = devices_param;
12681
12682 uint devices_cnt = 0;
12683
12684 uint devices_active = 0;
12685
12686 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12687 {
12688 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12689
12690 cl_platform_id platform = platforms[platform_id];
12691
12692 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12693
12694 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12695 {
12696 size_t param_value_size = 0;
12697
12698 const uint device_id = devices_cnt;
12699
12700 hc_device_param_t *device_param = &data.devices_param[device_id];
12701
12702 device_param->device = platform_devices[platform_devices_id];
12703
12704 device_param->device_id = device_id;
12705
12706 device_param->platform_devices_id = platform_devices_id;
12707
12708 // device_type
12709
12710 cl_device_type device_type;
12711
12712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12713
12714 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12715
12716 device_param->device_type = device_type;
12717
12718 // vendor_id
12719
12720 cl_uint vendor_id = 0;
12721
12722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12723
12724 device_param->vendor_id = vendor_id;
12725
12726 // device_name
12727
12728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12729
12730 char *device_name = (char *) mymalloc (param_value_size);
12731
12732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12733
12734 device_param->device_name = device_name;
12735
12736 // tuning db
12737
12738 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12739
12740 // device_version
12741
12742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12743
12744 char *device_version = (char *) mymalloc (param_value_size);
12745
12746 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12747
12748 device_param->device_version = device_version;
12749
12750 // device_opencl_version
12751
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12753
12754 char *device_opencl_version = (char *) mymalloc (param_value_size);
12755
12756 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12757
12758 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12759
12760 myfree (device_opencl_version);
12761
12762 if (strstr (device_version, "pocl"))
12763 {
12764 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12765 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12766
12767 cl_uint vendor_id = VENDOR_ID_GENERIC;
12768
12769 device_param->vendor_id = vendor_id;
12770 }
12771
12772 // vector_width
12773
12774 cl_uint vector_width;
12775
12776 if (opencl_vector_width_chgd == 0)
12777 {
12778 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12779 {
12780 if (opti_type & OPTI_TYPE_USES_BITS_64)
12781 {
12782 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12783 }
12784 else
12785 {
12786 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12787 }
12788 }
12789 else
12790 {
12791 vector_width = (cl_uint) tuningdb_entry->vector_width;
12792 }
12793 }
12794 else
12795 {
12796 vector_width = opencl_vector_width;
12797 }
12798
12799 if (vector_width > 16) vector_width = 16;
12800
12801 device_param->vector_width = vector_width;
12802
12803 // max_compute_units
12804
12805 cl_uint device_processors;
12806
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12808
12809 device_param->device_processors = device_processors;
12810
12811 // max_mem_alloc_size
12812
12813 cl_ulong device_maxmem_alloc;
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12816
12817 device_param->device_maxmem_alloc = device_maxmem_alloc;
12818
12819 // max_mem_alloc_size
12820
12821 cl_ulong device_global_mem;
12822
12823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12824
12825 device_param->device_global_mem = device_global_mem;
12826
12827 // max_clock_frequency
12828
12829 cl_uint device_maxclock_frequency;
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12832
12833 device_param->device_maxclock_frequency = device_maxclock_frequency;
12834
12835 // skipped
12836
12837 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12838 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12839
12840 device_param->skipped = (skipped1 || skipped2);
12841
12842 // driver_version
12843 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12844
12845 char *driver_version = (char *) mymalloc (param_value_size);
12846
12847 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12848
12849 device_param->driver_version = driver_version;
12850
12851 // device_name_chksum
12852
12853 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12854
12855 #if __x86_64__
12856 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);
12857 #else
12858 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);
12859 #endif
12860
12861 uint device_name_digest[4] = { 0 };
12862
12863 md5_64 ((uint *) device_name_chksum, device_name_digest);
12864
12865 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12866
12867 device_param->device_name_chksum = device_name_chksum;
12868
12869 // device_processor_cores
12870
12871 if (device_type & CL_DEVICE_TYPE_CPU)
12872 {
12873 cl_uint device_processor_cores = 1;
12874
12875 device_param->device_processor_cores = device_processor_cores;
12876 }
12877
12878 if (device_type & CL_DEVICE_TYPE_GPU)
12879 {
12880 if (vendor_id == VENDOR_ID_AMD)
12881 {
12882 cl_uint device_processor_cores = 0;
12883
12884 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12885
12886 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12887
12888 device_param->device_processor_cores = device_processor_cores;
12889 }
12890 else if (vendor_id == VENDOR_ID_NV)
12891 {
12892 cl_uint kernel_exec_timeout = 0;
12893
12894 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12895
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12897
12898 device_param->kernel_exec_timeout = kernel_exec_timeout;
12899
12900 cl_uint device_processor_cores = 0;
12901
12902 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12903
12904 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12905
12906 device_param->device_processor_cores = device_processor_cores;
12907
12908 cl_uint sm_minor = 0;
12909 cl_uint sm_major = 0;
12910
12911 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12912 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12913
12914 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12915 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12916
12917 device_param->sm_minor = sm_minor;
12918 device_param->sm_major = sm_major;
12919 }
12920 else
12921 {
12922 cl_uint device_processor_cores = 1;
12923
12924 device_param->device_processor_cores = device_processor_cores;
12925 }
12926 }
12927
12928 // display results
12929
12930 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12931 {
12932 if (device_param->skipped == 0)
12933 {
12934 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12935 device_id + 1,
12936 device_name,
12937 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12938 (unsigned int) (device_global_mem / 1024 / 1024),
12939 (unsigned int) (device_maxclock_frequency),
12940 (unsigned int) device_processors);
12941 }
12942 else
12943 {
12944 log_info ("Device #%u: %s, skipped",
12945 device_id + 1,
12946 device_name);
12947 }
12948 }
12949
12950 // common driver check
12951
12952 if (device_param->skipped == 0)
12953 {
12954 if (strstr (device_version, "pocl"))
12955 {
12956 if (force == 0)
12957 {
12958 log_info ("");
12959 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12960 log_info ("You are STRONGLY encouraged not to use it");
12961 log_info ("You can use --force to override this but do not post error reports if you do so");
12962 log_info ("");
12963
12964 return (-1);
12965 }
12966 }
12967
12968 if (device_type & CL_DEVICE_TYPE_GPU)
12969 {
12970 if (vendor_id == VENDOR_ID_NV)
12971 {
12972 if (device_param->kernel_exec_timeout != 0)
12973 {
12974 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);
12975 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12976 }
12977 }
12978 else if (vendor_id == VENDOR_ID_AMD)
12979 {
12980 int catalyst_check = (force == 1) ? 0 : 1;
12981
12982 int catalyst_warn = 0;
12983
12984 int catalyst_broken = 0;
12985
12986 if (catalyst_check == 1)
12987 {
12988 catalyst_warn = 1;
12989
12990 // v14.9 and higher
12991 if (atoi (device_param->driver_version) >= 1573)
12992 {
12993 catalyst_warn = 0;
12994 }
12995
12996 catalyst_check = 0;
12997 }
12998
12999 if (catalyst_broken == 1)
13000 {
13001 log_info ("");
13002 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13003 log_info ("It will pass over cracked hashes and does not report them as cracked");
13004 log_info ("You are STRONGLY encouraged not to use it");
13005 log_info ("You can use --force to override this but do not post error reports if you do so");
13006 log_info ("");
13007
13008 return (-1);
13009 }
13010
13011 if (catalyst_warn == 1)
13012 {
13013 log_info ("");
13014 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13015 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13016 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13017 #ifdef _WIN
13018 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13019 #endif
13020 log_info ("You can use --force to override this but do not post error reports if you do so");
13021 log_info ("");
13022
13023 return (-1);
13024 }
13025 }
13026 }
13027
13028 /**
13029 * kernel accel and loops tuning db adjustment
13030 */
13031
13032 device_param->kernel_accel_min = 1;
13033 device_param->kernel_accel_max = 1024;
13034
13035 device_param->kernel_loops_min = 1;
13036 device_param->kernel_loops_max = 1024;
13037
13038 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13039
13040 if (tuningdb_entry)
13041 {
13042 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13043 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13044
13045 if (_kernel_accel)
13046 {
13047 device_param->kernel_accel_min = _kernel_accel;
13048 device_param->kernel_accel_max = _kernel_accel;
13049 }
13050
13051 if (_kernel_loops)
13052 {
13053 if (workload_profile == 1)
13054 {
13055 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13056 }
13057 else if (workload_profile == 2)
13058 {
13059 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13060 }
13061
13062 device_param->kernel_loops_min = _kernel_loops;
13063 device_param->kernel_loops_max = _kernel_loops;
13064 }
13065 }
13066
13067 // commandline parameters overwrite tuningdb entries
13068
13069 if (kernel_accel)
13070 {
13071 device_param->kernel_accel_min = kernel_accel;
13072 device_param->kernel_accel_max = kernel_accel;
13073 }
13074
13075 if (kernel_loops)
13076 {
13077 device_param->kernel_loops_min = kernel_loops;
13078 device_param->kernel_loops_max = kernel_loops;
13079 }
13080
13081 /**
13082 * activate device
13083 */
13084
13085 devices_active++;
13086 }
13087
13088 // next please
13089
13090 devices_cnt++;
13091 }
13092 }
13093
13094 if (keyspace == 0 && devices_active == 0)
13095 {
13096 log_error ("ERROR: No devices found/left");
13097
13098 return (-1);
13099 }
13100
13101 // 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)
13102
13103 if (devices_filter != (uint) -1)
13104 {
13105 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13106
13107 if (devices_filter > devices_cnt_mask)
13108 {
13109 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13110
13111 return (-1);
13112 }
13113 }
13114
13115 data.devices_cnt = devices_cnt;
13116
13117 data.devices_active = devices_active;
13118
13119 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13120 {
13121 log_info ("");
13122 }
13123
13124 /**
13125 * HM devices: init
13126 */
13127
13128 #ifdef HAVE_HWMON
13129 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13130 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13131 #endif
13132
13133 #ifdef HAVE_ADL
13134 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13135 #endif
13136
13137 if (gpu_temp_disable == 0)
13138 {
13139 #if defined(WIN) && defined(HAVE_NVAPI)
13140 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13141
13142 if (nvapi_init (nvapi) == 0)
13143 data.hm_nv = nvapi;
13144
13145 if (data.hm_nv)
13146 {
13147 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13148 {
13149 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13150
13151 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13152
13153 int tmp_out = 0;
13154
13155 for (int i = 0; i < tmp_in; i++)
13156 {
13157 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13158 }
13159
13160 for (int i = 0; i < tmp_out; i++)
13161 {
13162 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13163
13164 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13165
13166 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;
13167 }
13168 }
13169 }
13170 #endif // WIN && HAVE_NVAPI
13171
13172 #if defined(LINUX) && defined(HAVE_NVML)
13173 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13174
13175 if (nvml_init (nvml) == 0)
13176 data.hm_nv = nvml;
13177
13178 if (data.hm_nv)
13179 {
13180 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13181 {
13182 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13183
13184 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13185
13186 int tmp_out = 0;
13187
13188 for (int i = 0; i < tmp_in; i++)
13189 {
13190 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13191 }
13192
13193 for (int i = 0; i < tmp_out; i++)
13194 {
13195 unsigned int speed;
13196
13197 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;
13198 }
13199 }
13200 }
13201 #endif // LINUX && HAVE_NVML
13202
13203 data.hm_amd = NULL;
13204
13205 #ifdef HAVE_ADL
13206 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13207
13208 if (adl_init (adl) == 0)
13209 data.hm_amd = adl;
13210
13211 if (data.hm_amd)
13212 {
13213 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13214 {
13215 // total number of adapters
13216
13217 int hm_adapters_num;
13218
13219 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13220
13221 // adapter info
13222
13223 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13224
13225 if (lpAdapterInfo == NULL) return (-1);
13226
13227 // get a list (of ids of) valid/usable adapters
13228
13229 int num_adl_adapters = 0;
13230
13231 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13232
13233 if (num_adl_adapters > 0)
13234 {
13235 hc_thread_mutex_lock (mux_adl);
13236
13237 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13238
13239 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13240
13241 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13242 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13243
13244 hc_thread_mutex_unlock (mux_adl);
13245 }
13246
13247 myfree (valid_adl_device_list);
13248 myfree (lpAdapterInfo);
13249 }
13250 }
13251 #endif // HAVE_ADL
13252
13253 if (data.hm_amd == NULL && data.hm_nv == NULL)
13254 {
13255 gpu_temp_disable = 1;
13256 }
13257 }
13258
13259 /**
13260 * OpenCL devices: allocate buffer for device specific information
13261 */
13262
13263 #ifdef HAVE_HWMON
13264 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13265
13266 #ifdef HAVE_ADL
13267 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13268
13269 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13270 #endif // ADL
13271 #endif
13272
13273 /**
13274 * enable custom signal handler(s)
13275 */
13276
13277 if (benchmark == 0)
13278 {
13279 hc_signal (sigHandler_default);
13280 }
13281 else
13282 {
13283 hc_signal (sigHandler_benchmark);
13284 }
13285
13286 /**
13287 * User-defined GPU temp handling
13288 */
13289
13290 #ifdef HAVE_HWMON
13291 if (gpu_temp_disable == 1)
13292 {
13293 gpu_temp_abort = 0;
13294 gpu_temp_retain = 0;
13295 }
13296
13297 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13298 {
13299 if (gpu_temp_abort < gpu_temp_retain)
13300 {
13301 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13302
13303 return (-1);
13304 }
13305 }
13306
13307 data.gpu_temp_disable = gpu_temp_disable;
13308 data.gpu_temp_abort = gpu_temp_abort;
13309 data.gpu_temp_retain = gpu_temp_retain;
13310 #endif
13311
13312 /**
13313 * inform the user
13314 */
13315
13316 if (data.quiet == 0)
13317 {
13318 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13319
13320 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);
13321
13322 if (attack_mode == ATTACK_MODE_STRAIGHT)
13323 {
13324 log_info ("Rules: %u", kernel_rules_cnt);
13325 }
13326
13327 if (opti_type)
13328 {
13329 log_info ("Applicable Optimizers:");
13330
13331 for (uint i = 0; i < 32; i++)
13332 {
13333 const uint opti_bit = 1u << i;
13334
13335 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13336 }
13337 }
13338
13339 /**
13340 * Watchdog and Temperature balance
13341 */
13342
13343 #ifdef HAVE_HWMON
13344 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13345 {
13346 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13347 }
13348
13349 if (gpu_temp_abort == 0)
13350 {
13351 log_info ("Watchdog: Temperature abort trigger disabled");
13352 }
13353 else
13354 {
13355 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13356 }
13357
13358 if (gpu_temp_retain == 0)
13359 {
13360 log_info ("Watchdog: Temperature retain trigger disabled");
13361 }
13362 else
13363 {
13364 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13365 }
13366 #endif
13367 }
13368
13369 if (data.quiet == 0) log_info ("");
13370
13371 /**
13372 * HM devices: copy
13373 */
13374
13375 if (gpu_temp_disable == 0)
13376 {
13377 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13378 {
13379 hc_device_param_t *device_param = &data.devices_param[device_id];
13380
13381 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13382
13383 if (device_param->skipped) continue;
13384
13385 const uint platform_devices_id = device_param->platform_devices_id;
13386
13387 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13388 if (device_param->vendor_id == VENDOR_ID_NV)
13389 {
13390 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13391 }
13392 #endif
13393
13394 #ifdef HAVE_ADL
13395 if (device_param->vendor_id == VENDOR_ID_AMD)
13396 {
13397 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13398 }
13399 #endif
13400 }
13401 }
13402
13403 /*
13404 * Temporary fix:
13405 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13406 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13407 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13408 * Driver / ADL bug?
13409 */
13410
13411 #ifdef HAVE_ADL
13412 if (powertune_enable == 1)
13413 {
13414 hc_thread_mutex_lock (mux_adl);
13415
13416 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13417 {
13418 hc_device_param_t *device_param = &data.devices_param[device_id];
13419
13420 if (device_param->skipped) continue;
13421
13422 if (data.hm_device[device_id].od_version == 6)
13423 {
13424 // set powertune value only
13425
13426 int powertune_supported = 0;
13427
13428 int ADL_rc = 0;
13429
13430 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13431 {
13432 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13433
13434 return (-1);
13435 }
13436
13437 if (powertune_supported != 0)
13438 {
13439 // powertune set
13440 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13441
13442 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13443 {
13444 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13445
13446 return (-1);
13447 }
13448
13449 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13450 {
13451 log_error ("ERROR: Failed to set new ADL PowerControl values");
13452
13453 return (-1);
13454 }
13455 }
13456 }
13457 }
13458
13459 hc_thread_mutex_unlock (mux_adl);
13460 }
13461 #endif // HAVE_ADK
13462 #endif // HAVE_HWMON
13463
13464 #ifdef DEBUG
13465 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13466 #endif
13467
13468 uint kernel_power_all = 0;
13469
13470 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13471 {
13472 /**
13473 * host buffer
13474 */
13475
13476 hc_device_param_t *device_param = &data.devices_param[device_id];
13477
13478 if (device_param->skipped) continue;
13479
13480 /**
13481 * device properties
13482 */
13483
13484 const char *device_name_chksum = device_param->device_name_chksum;
13485 const u32 device_processors = device_param->device_processors;
13486 const u32 device_processor_cores = device_param->device_processor_cores;
13487
13488 /**
13489 * create context for each device
13490 */
13491
13492 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13493
13494 /**
13495 * create command-queue
13496 */
13497
13498 // not supported with NV
13499 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13500
13501 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13502
13503 /**
13504 * create input buffers on device : calculate size of fixed memory buffers
13505 */
13506
13507 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13508 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13509
13510 device_param->size_root_css = size_root_css;
13511 device_param->size_markov_css = size_markov_css;
13512
13513 uint size_results = KERNEL_THREADS * sizeof (uint);
13514
13515 device_param->size_results = size_results;
13516
13517 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13518 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13519
13520 uint size_plains = digests_cnt * sizeof (plain_t);
13521 uint size_salts = salts_cnt * sizeof (salt_t);
13522 uint size_esalts = salts_cnt * esalt_size;
13523
13524 device_param->size_plains = size_plains;
13525 device_param->size_digests = size_digests;
13526 device_param->size_shown = size_shown;
13527 device_param->size_salts = size_salts;
13528
13529 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13530 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13531 uint size_tm = 32 * sizeof (bs_word_t);
13532
13533 // scryptV stuff
13534
13535 u64 size_scryptV = 1;
13536
13537 if ((hash_mode == 8900) || (hash_mode == 9300))
13538 {
13539 uint tmto_start = 0;
13540 uint tmto_stop = 10;
13541
13542 if (scrypt_tmto)
13543 {
13544 tmto_start = scrypt_tmto;
13545 }
13546 else
13547 {
13548 // in case the user did not specify the tmto manually
13549 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13550 // but set the lower end only in case the user has a device with too less memory
13551
13552 if (hash_mode == 8900)
13553 {
13554 if (device_param->vendor_id == VENDOR_ID_AMD)
13555 {
13556 tmto_start = 1;
13557 }
13558 else if (device_param->vendor_id == VENDOR_ID_NV)
13559 {
13560 tmto_start = 3;
13561 }
13562 }
13563 else if (hash_mode == 9300)
13564 {
13565 if (device_param->vendor_id == VENDOR_ID_AMD)
13566 {
13567 tmto_start = 3;
13568 }
13569 else if (device_param->vendor_id == VENDOR_ID_NV)
13570 {
13571 tmto_start = 5;
13572 }
13573 }
13574 }
13575
13576 if (quiet == 0) log_info ("");
13577
13578 uint shader_per_mp = 1;
13579
13580 if (device_param->vendor_id == VENDOR_ID_AMD)
13581 {
13582 shader_per_mp = 8;
13583 }
13584 else if (device_param->vendor_id == VENDOR_ID_NV)
13585 {
13586 shader_per_mp = 32;
13587 }
13588
13589 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13590 {
13591 // TODO: in theory the following calculation needs to be done per salt, not global
13592 // we assume all hashes have the same scrypt settings
13593
13594 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13595
13596 size_scryptV /= 1 << tmto;
13597
13598 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13599
13600 if (size_scryptV > device_param->device_maxmem_alloc)
13601 {
13602 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13603
13604 continue;
13605 }
13606
13607 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13608 {
13609 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13610 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13611 }
13612
13613 break;
13614 }
13615
13616 if (data.salts_buf[0].scrypt_phy == 0)
13617 {
13618 log_error ("ERROR: can't allocate enough device memory");
13619
13620 return -1;
13621 }
13622
13623 if (quiet == 0) log_info ("");
13624 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13625 }
13626
13627 /**
13628 * create input buffers on device : calculate size of dynamic size memory buffers
13629 */
13630
13631 uint kernel_threads = KERNEL_THREADS;
13632
13633 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13634
13635 if (hash_mode == 3200) kernel_threads = 8;
13636 if (hash_mode == 9000) kernel_threads = 8;
13637
13638 /**
13639 * some algorithms need a fixed kernel-loops count
13640 */
13641
13642 if (hash_mode == 1500)
13643 {
13644 const u32 kernel_loops_fixed = 1024;
13645
13646 device_param->kernel_loops_min = kernel_loops_fixed;
13647 device_param->kernel_loops_max = kernel_loops_fixed;
13648 }
13649
13650 if (hash_mode == 3000)
13651 {
13652 const u32 kernel_loops_fixed = 1024;
13653
13654 device_param->kernel_loops_min = kernel_loops_fixed;
13655 device_param->kernel_loops_max = kernel_loops_fixed;
13656 }
13657
13658 if (hash_mode == 8900)
13659 {
13660 const u32 kernel_loops_fixed = 1;
13661
13662 device_param->kernel_loops_min = kernel_loops_fixed;
13663 device_param->kernel_loops_max = kernel_loops_fixed;
13664 }
13665
13666 if (hash_mode == 9300)
13667 {
13668 const u32 kernel_loops_fixed = 1;
13669
13670 device_param->kernel_loops_min = kernel_loops_fixed;
13671 device_param->kernel_loops_max = kernel_loops_fixed;
13672 }
13673
13674 if (hash_mode == 12500)
13675 {
13676 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13677
13678 device_param->kernel_loops_min = kernel_loops_fixed;
13679 device_param->kernel_loops_max = kernel_loops_fixed;
13680 }
13681
13682 /**
13683 * some algorithms have a maximum kernel-loops count
13684 */
13685
13686 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13687 {
13688 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13689 {
13690 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13691 }
13692 }
13693
13694 /**
13695 * some algorithms need a special kernel-accel
13696 */
13697
13698 if (hash_mode == 8900)
13699 {
13700 device_param->kernel_accel_min = 1;
13701 device_param->kernel_accel_max = 64;
13702 }
13703
13704 if (hash_mode == 9300)
13705 {
13706 device_param->kernel_accel_min = 1;
13707 device_param->kernel_accel_max = 64;
13708 }
13709
13710 u32 kernel_accel_min = device_param->kernel_accel_min;
13711 u32 kernel_accel_max = device_param->kernel_accel_max;
13712
13713 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13714
13715 uint size_pws = 4;
13716 uint size_tmps = 4;
13717 uint size_hooks = 4;
13718
13719 while (kernel_accel_max >= kernel_accel_min)
13720 {
13721 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13722
13723 // size_pws
13724
13725 size_pws = kernel_power_max * sizeof (pw_t);
13726
13727 // size_tmps
13728
13729 switch (hash_mode)
13730 {
13731 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13732 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13733 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13734 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13735 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13736 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13737 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13738 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13739 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13740 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13741 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13742 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13743 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13745 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13746 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13747 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13748 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13749 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13751 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13752 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13753 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13754 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13755 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13756 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13757 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13758 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13759 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13760 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13761 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13762 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13763 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13764 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13765 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13766 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13767 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13768 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13769 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13770 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13771 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13772 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13773 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13774 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13775 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13776 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13777 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13778 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13779 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13780 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13781 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13782 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13783 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13784 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13785 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13786 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13787 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13788 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13789 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13790 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13791 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13792 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13793 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13794 };
13795
13796 // size_hooks
13797
13798 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13799 {
13800 // none yet
13801 }
13802
13803 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13804 // if not, decrease amplifier and try again
13805
13806 int skip = 0;
13807
13808 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13809 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13810 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13811
13812 if (( bitmap_size
13813 + bitmap_size
13814 + bitmap_size
13815 + bitmap_size
13816 + bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + bitmap_size
13820 + size_bfs
13821 + size_combs
13822 + size_digests
13823 + size_esalts
13824 + size_hooks
13825 + size_markov_css
13826 + size_plains
13827 + size_pws
13828 + size_results
13829 + size_root_css
13830 + size_rules
13831 + size_rules_c
13832 + size_salts
13833 + size_scryptV
13834 + size_shown
13835 + size_tm
13836 + size_tmps) > device_param->device_global_mem) skip = 1;
13837
13838 if (skip == 1)
13839 {
13840 kernel_accel_max--;
13841
13842 continue;
13843 }
13844
13845 break;
13846 }
13847
13848 /*
13849 if (kernel_accel_max == 0)
13850 {
13851 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13852
13853 return -1;
13854 }
13855 */
13856
13857 device_param->kernel_accel_min = kernel_accel_min;
13858 device_param->kernel_accel_max = kernel_accel_max;
13859
13860 /*
13861 if (kernel_accel_max < kernel_accel)
13862 {
13863 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13864
13865 device_param->kernel_accel = kernel_accel_max;
13866 }
13867 */
13868
13869 device_param->size_bfs = size_bfs;
13870 device_param->size_combs = size_combs;
13871 device_param->size_rules = size_rules;
13872 device_param->size_rules_c = size_rules_c;
13873 device_param->size_pws = size_pws;
13874 device_param->size_tmps = size_tmps;
13875 device_param->size_hooks = size_hooks;
13876
13877 // do not confuse kernel_accel_max with kernel_accel here
13878
13879 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13880
13881 device_param->kernel_threads = kernel_threads;
13882 device_param->kernel_power_user = kernel_power;
13883
13884 kernel_power_all += kernel_power;
13885
13886 /**
13887 * default building options
13888 */
13889
13890 char build_opts[1024] = { 0 };
13891
13892 // we don't have sm_* on vendors not NV but it doesn't matter
13893
13894 snprintf (build_opts, sizeof (build_opts) - 1, "-I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13895
13896 /**
13897 * main kernel
13898 */
13899
13900 {
13901 /**
13902 * kernel source filename
13903 */
13904
13905 char source_file[256] = { 0 };
13906
13907 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13908
13909 struct stat sst;
13910
13911 if (stat (source_file, &sst) == -1)
13912 {
13913 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13914
13915 return -1;
13916 }
13917
13918 /**
13919 * kernel cached filename
13920 */
13921
13922 char cached_file[256] = { 0 };
13923
13924 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13925
13926 int cached = 1;
13927
13928 struct stat cst;
13929
13930 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13931 {
13932 cached = 0;
13933 }
13934
13935 /**
13936 * kernel compile or load
13937 */
13938
13939 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13940
13941 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13942
13943 if (force_jit_compilation == -1)
13944 {
13945 if (cached == 0)
13946 {
13947 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13948
13949 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13950
13951 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13952
13953 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13954
13955 #ifdef DEBUG
13956 size_t build_log_size = 0;
13957
13958 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13959
13960 if (build_log_size > 1)
13961 {
13962 char *build_log = (char *) malloc (build_log_size + 1);
13963
13964 memset (build_log, 0, build_log_size + 1);
13965
13966 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13967
13968 puts (build_log);
13969
13970 free (build_log);
13971 }
13972 #endif
13973
13974 if (rc != 0)
13975 {
13976 device_param->skipped = true;
13977 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13978 continue;
13979 }
13980
13981 size_t binary_size;
13982
13983 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13984
13985 u8 *binary = (u8 *) mymalloc (binary_size);
13986
13987 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13988
13989 writeProgramBin (cached_file, binary, binary_size);
13990
13991 local_free (binary);
13992 }
13993 else
13994 {
13995 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13996
13997 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13998
13999 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14000
14001 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14002 }
14003 }
14004 else
14005 {
14006 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14007
14008 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14009
14010 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14011
14012 char build_opts_update[1024] = { 0 };
14013
14014 if (force_jit_compilation == 1500)
14015 {
14016 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14017 }
14018 else if (force_jit_compilation == 8900)
14019 {
14020 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);
14021 }
14022 else
14023 {
14024 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14025 }
14026
14027 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14028
14029 #ifdef DEBUG
14030 size_t build_log_size = 0;
14031
14032 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14033
14034 if (build_log_size > 1)
14035 {
14036 char *build_log = (char *) malloc (build_log_size + 1);
14037
14038 memset (build_log, 0, build_log_size + 1);
14039
14040 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14041
14042 puts (build_log);
14043
14044 free (build_log);
14045 }
14046 #endif
14047
14048 if (rc != 0)
14049 {
14050 device_param->skipped = true;
14051
14052 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14053 }
14054 }
14055
14056 local_free (kernel_lengths);
14057 local_free (kernel_sources[0]);
14058 local_free (kernel_sources);
14059 }
14060
14061 /**
14062 * word generator kernel
14063 */
14064
14065 if (attack_mode != ATTACK_MODE_STRAIGHT)
14066 {
14067 /**
14068 * kernel mp source filename
14069 */
14070
14071 char source_file[256] = { 0 };
14072
14073 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14074
14075 struct stat sst;
14076
14077 if (stat (source_file, &sst) == -1)
14078 {
14079 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14080
14081 return -1;
14082 }
14083
14084 /**
14085 * kernel mp cached filename
14086 */
14087
14088 char cached_file[256] = { 0 };
14089
14090 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14091
14092 int cached = 1;
14093
14094 struct stat cst;
14095
14096 if (stat (cached_file, &cst) == -1)
14097 {
14098 cached = 0;
14099 }
14100
14101 /**
14102 * kernel compile or load
14103 */
14104
14105 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14106
14107 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14108
14109 if (cached == 0)
14110 {
14111 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14112
14113 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14114
14115 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14116
14117 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14118
14119 if (rc != 0)
14120 {
14121 device_param->skipped = true;
14122 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14123 continue;
14124 }
14125
14126 size_t binary_size;
14127
14128 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14129
14130 u8 *binary = (u8 *) mymalloc (binary_size);
14131
14132 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14133
14134 writeProgramBin (cached_file, binary, binary_size);
14135
14136 local_free (binary);
14137 }
14138 else
14139 {
14140 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14141
14142 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14143
14144 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14145
14146 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14147 }
14148
14149 local_free (kernel_lengths);
14150 local_free (kernel_sources[0]);
14151 local_free (kernel_sources);
14152 }
14153
14154 /**
14155 * amplifier kernel
14156 */
14157
14158 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14159 {
14160
14161 }
14162 else
14163 {
14164 /**
14165 * kernel amp source filename
14166 */
14167
14168 char source_file[256] = { 0 };
14169
14170 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14171
14172 struct stat sst;
14173
14174 if (stat (source_file, &sst) == -1)
14175 {
14176 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14177
14178 return -1;
14179 }
14180
14181 /**
14182 * kernel amp cached filename
14183 */
14184
14185 char cached_file[256] = { 0 };
14186
14187 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14188
14189 int cached = 1;
14190
14191 struct stat cst;
14192
14193 if (stat (cached_file, &cst) == -1)
14194 {
14195 cached = 0;
14196 }
14197
14198 /**
14199 * kernel compile or load
14200 */
14201
14202 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14203
14204 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14205
14206 if (cached == 0)
14207 {
14208 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14209
14210 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14211
14212 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14213
14214 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14215
14216 if (rc != 0)
14217 {
14218 device_param->skipped = true;
14219 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14220 continue;
14221 }
14222
14223 size_t binary_size;
14224
14225 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14226
14227 u8 *binary = (u8 *) mymalloc (binary_size);
14228
14229 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14230
14231 writeProgramBin (cached_file, binary, binary_size);
14232
14233 local_free (binary);
14234 }
14235 else
14236 {
14237 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14238
14239 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14240
14241 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14242
14243 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14244 }
14245
14246 local_free (kernel_lengths);
14247 local_free (kernel_sources[0]);
14248 local_free (kernel_sources);
14249 }
14250
14251 // some algorithm collide too fast, make that impossible
14252
14253 if (benchmark == 1)
14254 {
14255 ((uint *) digests_buf)[0] = -1;
14256 ((uint *) digests_buf)[1] = -1;
14257 ((uint *) digests_buf)[2] = -1;
14258 ((uint *) digests_buf)[3] = -1;
14259 }
14260
14261 /**
14262 * global buffers
14263 */
14264
14265 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14266 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14267 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14268 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14269 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14270 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14271 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14272 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14273 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14274 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14275 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14276 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14277 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14278 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14279 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14280 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14281 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14282 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14283
14284 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);
14285 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);
14286 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);
14287 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);
14288 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);
14289 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);
14290 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);
14291 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);
14292 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14294 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14295
14296 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14297 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14298 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14299 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14300 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14301 run_kernel_bzero (device_param, device_param->d_result, size_results);
14302
14303 /**
14304 * special buffers
14305 */
14306
14307 if (attack_kern == ATTACK_KERN_STRAIGHT)
14308 {
14309 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14310 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14311
14312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14313
14314 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14315 }
14316 else if (attack_kern == ATTACK_KERN_COMBI)
14317 {
14318 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14319 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14320 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14321 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14322
14323 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14324 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14325 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14326 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14327 }
14328 else if (attack_kern == ATTACK_KERN_BF)
14329 {
14330 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14331 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14332 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14333 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14334 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14335
14336 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14337 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14338 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14339 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14340 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14341 }
14342
14343 if (size_esalts)
14344 {
14345 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14346
14347 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14348 }
14349
14350 /**
14351 * main host data
14352 */
14353
14354 uint *result = (uint *) mymalloc (size_results);
14355
14356 device_param->result = result;
14357
14358 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14359
14360 device_param->pws_buf = pws_buf;
14361
14362 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14363
14364 device_param->combs_buf = combs_buf;
14365
14366 void *hooks_buf = mymalloc (size_hooks);
14367
14368 device_param->hooks_buf = hooks_buf;
14369
14370 /**
14371 * kernel args
14372 */
14373
14374 device_param->kernel_params_buf32[21] = bitmap_mask;
14375 device_param->kernel_params_buf32[22] = bitmap_shift1;
14376 device_param->kernel_params_buf32[23] = bitmap_shift2;
14377 device_param->kernel_params_buf32[24] = 0; // salt_pos
14378 device_param->kernel_params_buf32[25] = 0; // loop_pos
14379 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14380 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14381 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14382 device_param->kernel_params_buf32[29] = 0; // digests_offset
14383 device_param->kernel_params_buf32[30] = 0; // combs_mode
14384 device_param->kernel_params_buf32[31] = 0; // gid_max
14385
14386 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14387 ? &device_param->d_pws_buf
14388 : &device_param->d_pws_amp_buf;
14389 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14390 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14391 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14392 device_param->kernel_params[ 4] = &device_param->d_tmps;
14393 device_param->kernel_params[ 5] = &device_param->d_hooks;
14394 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14395 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14396 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14397 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14398 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14399 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14400 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14401 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14402 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14403 device_param->kernel_params[15] = &device_param->d_digests_buf;
14404 device_param->kernel_params[16] = &device_param->d_digests_shown;
14405 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14406 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14407 device_param->kernel_params[19] = &device_param->d_result;
14408 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14409 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14410 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14411 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14412 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14413 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14414 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14415 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14416 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14417 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14418 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14419 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14420
14421 device_param->kernel_params_mp_buf64[3] = 0;
14422 device_param->kernel_params_mp_buf32[4] = 0;
14423 device_param->kernel_params_mp_buf32[5] = 0;
14424 device_param->kernel_params_mp_buf32[6] = 0;
14425 device_param->kernel_params_mp_buf32[7] = 0;
14426 device_param->kernel_params_mp_buf32[8] = 0;
14427
14428 device_param->kernel_params_mp[0] = NULL;
14429 device_param->kernel_params_mp[1] = NULL;
14430 device_param->kernel_params_mp[2] = NULL;
14431 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14432 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14433 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14434 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14435 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14436 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14437
14438 device_param->kernel_params_mp_l_buf64[3] = 0;
14439 device_param->kernel_params_mp_l_buf32[4] = 0;
14440 device_param->kernel_params_mp_l_buf32[5] = 0;
14441 device_param->kernel_params_mp_l_buf32[6] = 0;
14442 device_param->kernel_params_mp_l_buf32[7] = 0;
14443 device_param->kernel_params_mp_l_buf32[8] = 0;
14444 device_param->kernel_params_mp_l_buf32[9] = 0;
14445
14446 device_param->kernel_params_mp_l[0] = NULL;
14447 device_param->kernel_params_mp_l[1] = NULL;
14448 device_param->kernel_params_mp_l[2] = NULL;
14449 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14450 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14451 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14452 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14453 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14454 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14455 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14456
14457 device_param->kernel_params_mp_r_buf64[3] = 0;
14458 device_param->kernel_params_mp_r_buf32[4] = 0;
14459 device_param->kernel_params_mp_r_buf32[5] = 0;
14460 device_param->kernel_params_mp_r_buf32[6] = 0;
14461 device_param->kernel_params_mp_r_buf32[7] = 0;
14462 device_param->kernel_params_mp_r_buf32[8] = 0;
14463
14464 device_param->kernel_params_mp_r[0] = NULL;
14465 device_param->kernel_params_mp_r[1] = NULL;
14466 device_param->kernel_params_mp_r[2] = NULL;
14467 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14468 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14469 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14470 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14471 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14472 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14473
14474 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14475 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14476
14477 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14478 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14479 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14480 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14481 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14482 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14483 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14484
14485 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14486 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14487
14488 /**
14489 * kernel name
14490 */
14491
14492 char kernel_name[64] = { 0 };
14493
14494 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14495 {
14496 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14497 {
14498 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14499
14500 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14501
14502 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14503
14504 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14505
14506 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14507
14508 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14509 }
14510 else
14511 {
14512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14513
14514 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14515
14516 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14517
14518 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14519
14520 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14521
14522 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14523 }
14524
14525 if (data.attack_mode == ATTACK_MODE_BF)
14526 {
14527 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14528 {
14529 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14530
14531 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14532 }
14533 }
14534 }
14535 else
14536 {
14537 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14538
14539 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14540
14541 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14542
14543 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14544
14545 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14546
14547 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14548
14549 if (opts_type & OPTS_TYPE_HOOK12)
14550 {
14551 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14552
14553 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14554 }
14555
14556 if (opts_type & OPTS_TYPE_HOOK23)
14557 {
14558 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14559
14560 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14561 }
14562 }
14563
14564 for (uint i = 0; i <= 20; i++)
14565 {
14566 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14567 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14568 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14569
14570 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14571 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14572 }
14573
14574 for (uint i = 21; i <= 31; i++)
14575 {
14576 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14577 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14578 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14579
14580 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14581 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14582 }
14583
14584 if (attack_mode == ATTACK_MODE_BF)
14585 {
14586 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14587 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14588
14589 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14590 {
14591 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14592 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14593 }
14594 }
14595 else if (attack_mode == ATTACK_MODE_HYBRID1)
14596 {
14597 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14598 }
14599 else if (attack_mode == ATTACK_MODE_HYBRID2)
14600 {
14601 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14602 }
14603
14604 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14605 {
14606 // nothing to do
14607 }
14608 else
14609 {
14610 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14611 }
14612
14613 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14614 {
14615 // nothing to do
14616 }
14617 else
14618 {
14619 for (uint i = 0; i < 5; i++)
14620 {
14621 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14622 }
14623
14624 for (uint i = 5; i < 7; i++)
14625 {
14626 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14627 }
14628 }
14629
14630 /**
14631 * Store initial fanspeed if gpu_temp_retain is enabled
14632 */
14633
14634 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14635 int gpu_temp_retain_set = 0;
14636
14637 if (gpu_temp_disable == 0)
14638 {
14639 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14640 {
14641 hc_thread_mutex_lock (mux_adl);
14642
14643 if (data.hm_device[device_id].fan_supported == 1)
14644 {
14645 if (gpu_temp_retain_chgd == 0)
14646 {
14647 uint cur_temp = 0;
14648 uint default_temp = 0;
14649
14650 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);
14651
14652 if (ADL_rc == ADL_OK)
14653 {
14654 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14655
14656 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14657
14658 // special case with multi gpu setups: always use minimum retain
14659
14660 if (gpu_temp_retain_set == 0)
14661 {
14662 gpu_temp_retain = gpu_temp_retain_target;
14663 gpu_temp_retain_set = 1;
14664 }
14665 else
14666 {
14667 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14668 }
14669
14670 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14671 }
14672 }
14673
14674 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14675
14676 temp_retain_fanspeed_value[device_id] = fan_speed;
14677
14678 if (fan_speed == -1)
14679 {
14680 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14681
14682 temp_retain_fanspeed_value[device_id] = 0;
14683 }
14684 }
14685
14686 hc_thread_mutex_unlock (mux_adl);
14687 }
14688 }
14689
14690 /**
14691 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14692 */
14693
14694 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14695 {
14696 hc_thread_mutex_lock (mux_adl);
14697
14698 if (data.hm_device[device_id].od_version == 6)
14699 {
14700 int ADL_rc;
14701
14702 // check powertune capabilities first, if not available then skip device
14703
14704 int powertune_supported = 0;
14705
14706 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14707 {
14708 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14709
14710 return (-1);
14711 }
14712
14713 if (powertune_supported != 0)
14714 {
14715 // powercontrol settings
14716
14717 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14718
14719 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14720 {
14721 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14722 }
14723
14724 if (ADL_rc != ADL_OK)
14725 {
14726 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14727
14728 return (-1);
14729 }
14730
14731 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14732 {
14733 log_error ("ERROR: Failed to set new ADL PowerControl values");
14734
14735 return (-1);
14736 }
14737
14738 // clocks
14739
14740 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14741
14742 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14743
14744 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)
14745 {
14746 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14747
14748 return (-1);
14749 }
14750
14751 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14752
14753 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14754
14755 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14756 {
14757 log_error ("ERROR: Failed to get ADL device capabilities");
14758
14759 return (-1);
14760 }
14761
14762 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14763 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14764
14765 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14766 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14767
14768 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14769 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14770
14771 // warning if profile has too low max values
14772
14773 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14774 {
14775 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14776 }
14777
14778 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14779 {
14780 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14781 }
14782
14783 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14784
14785 performance_state->iNumberOfPerformanceLevels = 2;
14786
14787 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14788 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14789 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14790 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14791
14792 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)
14793 {
14794 log_info ("ERROR: Failed to set ADL performance state");
14795
14796 return (-1);
14797 }
14798
14799 local_free (performance_state);
14800 }
14801 }
14802
14803 hc_thread_mutex_unlock (mux_adl);
14804 }
14805 #endif // HAVE_HWMON && HAVE_ADL
14806 }
14807
14808 data.kernel_power_all = kernel_power_all;
14809
14810 if (data.quiet == 0) log_info ("");
14811
14812 /**
14813 * Inform user which algorithm is checked and at which workload setting
14814 */
14815
14816 if (benchmark == 1)
14817 {
14818 quiet = 0;
14819
14820 data.quiet = quiet;
14821
14822 char *hash_type = strhashtype (data.hash_mode); // not a bug
14823
14824 log_info ("Hashtype: %s", hash_type);
14825 log_info ("");
14826 }
14827
14828 /**
14829 * keep track of the progress
14830 */
14831
14832 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14833 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14834 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14835
14836 /**
14837 * open filehandles
14838 */
14839
14840 #if _WIN
14841 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14842 {
14843 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14844
14845 return (-1);
14846 }
14847
14848 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14849 {
14850 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14851
14852 return (-1);
14853 }
14854
14855 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14856 {
14857 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14858
14859 return (-1);
14860 }
14861 #endif
14862
14863 /**
14864 * dictionary pad
14865 */
14866
14867 segment_size *= (1024 * 1024);
14868
14869 data.segment_size = segment_size;
14870
14871 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14872
14873 wl_data->buf = (char *) mymalloc (segment_size);
14874 wl_data->avail = segment_size;
14875 wl_data->incr = segment_size;
14876 wl_data->cnt = 0;
14877 wl_data->pos = 0;
14878
14879 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14880
14881 data.wordlist_mode = wordlist_mode;
14882
14883 cs_t *css_buf = NULL;
14884 uint css_cnt = 0;
14885 uint dictcnt = 0;
14886 uint maskcnt = 1;
14887 char **masks = NULL;
14888 char **dictfiles = NULL;
14889
14890 uint mask_from_file = 0;
14891
14892 if (attack_mode == ATTACK_MODE_STRAIGHT)
14893 {
14894 if (wordlist_mode == WL_MODE_FILE)
14895 {
14896 int wls_left = myargc - (optind + 1);
14897
14898 for (int i = 0; i < wls_left; i++)
14899 {
14900 char *l0_filename = myargv[optind + 1 + i];
14901
14902 struct stat l0_stat;
14903
14904 if (stat (l0_filename, &l0_stat) == -1)
14905 {
14906 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14907
14908 return (-1);
14909 }
14910
14911 uint is_dir = S_ISDIR (l0_stat.st_mode);
14912
14913 if (is_dir == 0)
14914 {
14915 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14916
14917 dictcnt++;
14918
14919 dictfiles[dictcnt - 1] = l0_filename;
14920 }
14921 else
14922 {
14923 // do not allow --keyspace w/ a directory
14924
14925 if (keyspace == 1)
14926 {
14927 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14928
14929 return (-1);
14930 }
14931
14932 char **dictionary_files = NULL;
14933
14934 dictionary_files = scan_directory (l0_filename);
14935
14936 if (dictionary_files != NULL)
14937 {
14938 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14939
14940 for (int d = 0; dictionary_files[d] != NULL; d++)
14941 {
14942 char *l1_filename = dictionary_files[d];
14943
14944 struct stat l1_stat;
14945
14946 if (stat (l1_filename, &l1_stat) == -1)
14947 {
14948 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14949
14950 return (-1);
14951 }
14952
14953 if (S_ISREG (l1_stat.st_mode))
14954 {
14955 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14956
14957 dictcnt++;
14958
14959 dictfiles[dictcnt - 1] = strdup (l1_filename);
14960 }
14961 }
14962 }
14963
14964 local_free (dictionary_files);
14965 }
14966 }
14967
14968 if (dictcnt < 1)
14969 {
14970 log_error ("ERROR: No usable dictionary file found.");
14971
14972 return (-1);
14973 }
14974 }
14975 else if (wordlist_mode == WL_MODE_STDIN)
14976 {
14977 dictcnt = 1;
14978 }
14979 }
14980 else if (attack_mode == ATTACK_MODE_COMBI)
14981 {
14982 // display
14983
14984 char *dictfile1 = myargv[optind + 1 + 0];
14985 char *dictfile2 = myargv[optind + 1 + 1];
14986
14987 // find the bigger dictionary and use as base
14988
14989 FILE *fp1 = NULL;
14990 FILE *fp2 = NULL;
14991
14992 struct stat tmp_stat;
14993
14994 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14995 {
14996 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14997
14998 return (-1);
14999 }
15000
15001 if (stat (dictfile1, &tmp_stat) == -1)
15002 {
15003 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15004
15005 fclose (fp1);
15006
15007 return (-1);
15008 }
15009
15010 if (S_ISDIR (tmp_stat.st_mode))
15011 {
15012 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15013
15014 fclose (fp1);
15015
15016 return (-1);
15017 }
15018
15019 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15020 {
15021 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15022
15023 fclose (fp1);
15024
15025 return (-1);
15026 }
15027
15028 if (stat (dictfile2, &tmp_stat) == -1)
15029 {
15030 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15031
15032 fclose (fp1);
15033 fclose (fp2);
15034
15035 return (-1);
15036 }
15037
15038 if (S_ISDIR (tmp_stat.st_mode))
15039 {
15040 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15041
15042 fclose (fp1);
15043 fclose (fp2);
15044
15045 return (-1);
15046 }
15047
15048 data.combs_cnt = 1;
15049
15050 data.quiet = 1;
15051
15052 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15053
15054 data.quiet = quiet;
15055
15056 if (words1_cnt == 0)
15057 {
15058 log_error ("ERROR: %s: empty file", dictfile1);
15059
15060 fclose (fp1);
15061 fclose (fp2);
15062
15063 return (-1);
15064 }
15065
15066 data.combs_cnt = 1;
15067
15068 data.quiet = 1;
15069
15070 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15071
15072 data.quiet = quiet;
15073
15074 if (words2_cnt == 0)
15075 {
15076 log_error ("ERROR: %s: empty file", dictfile2);
15077
15078 fclose (fp1);
15079 fclose (fp2);
15080
15081 return (-1);
15082 }
15083
15084 fclose (fp1);
15085 fclose (fp2);
15086
15087 data.dictfile = dictfile1;
15088 data.dictfile2 = dictfile2;
15089
15090 if (words1_cnt >= words2_cnt)
15091 {
15092 data.combs_cnt = words2_cnt;
15093 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15094
15095 dictfiles = &data.dictfile;
15096
15097 dictcnt = 1;
15098 }
15099 else
15100 {
15101 data.combs_cnt = words1_cnt;
15102 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15103
15104 dictfiles = &data.dictfile2;
15105
15106 dictcnt = 1;
15107
15108 // we also have to switch wordlist related rules!
15109
15110 char *tmpc = data.rule_buf_l;
15111
15112 data.rule_buf_l = data.rule_buf_r;
15113 data.rule_buf_r = tmpc;
15114
15115 int tmpi = data.rule_len_l;
15116
15117 data.rule_len_l = data.rule_len_r;
15118 data.rule_len_r = tmpi;
15119 }
15120 }
15121 else if (attack_mode == ATTACK_MODE_BF)
15122 {
15123 char *mask = NULL;
15124
15125 maskcnt = 0;
15126
15127 if (benchmark == 0)
15128 {
15129 mask = myargv[optind + 1];
15130
15131 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15132
15133 if ((optind + 2) <= myargc)
15134 {
15135 struct stat file_stat;
15136
15137 if (stat (mask, &file_stat) == -1)
15138 {
15139 maskcnt = 1;
15140
15141 masks[maskcnt - 1] = mystrdup (mask);
15142 }
15143 else
15144 {
15145 int wls_left = myargc - (optind + 1);
15146
15147 uint masks_avail = INCR_MASKS;
15148
15149 for (int i = 0; i < wls_left; i++)
15150 {
15151 if (i != 0)
15152 {
15153 mask = myargv[optind + 1 + i];
15154
15155 if (stat (mask, &file_stat) == -1)
15156 {
15157 log_error ("ERROR: %s: %s", mask, strerror (errno));
15158
15159 return (-1);
15160 }
15161 }
15162
15163 uint is_file = S_ISREG (file_stat.st_mode);
15164
15165 if (is_file == 1)
15166 {
15167 FILE *mask_fp;
15168
15169 if ((mask_fp = fopen (mask, "r")) == NULL)
15170 {
15171 log_error ("ERROR: %s: %s", mask, strerror (errno));
15172
15173 return (-1);
15174 }
15175
15176 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15177
15178 while (!feof (mask_fp))
15179 {
15180 memset (line_buf, 0, HCBUFSIZ);
15181
15182 int line_len = fgetl (mask_fp, line_buf);
15183
15184 if (line_len == 0) continue;
15185
15186 if (line_buf[0] == '#') continue;
15187
15188 if (masks_avail == maskcnt)
15189 {
15190 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15191
15192 masks_avail += INCR_MASKS;
15193 }
15194
15195 masks[maskcnt] = mystrdup (line_buf);
15196
15197 maskcnt++;
15198 }
15199
15200 myfree (line_buf);
15201
15202 fclose (mask_fp);
15203 }
15204 else
15205 {
15206 log_error ("ERROR: %s: unsupported file-type", mask);
15207
15208 return (-1);
15209 }
15210 }
15211
15212 mask_from_file = 1;
15213 }
15214 }
15215 else
15216 {
15217 custom_charset_1 = (char *) "?l?d?u";
15218 custom_charset_2 = (char *) "?l?d";
15219 custom_charset_3 = (char *) "?l?d*!$@_";
15220
15221 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15222 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15223 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15224
15225 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15226
15227 wordlist_mode = WL_MODE_MASK;
15228
15229 data.wordlist_mode = wordlist_mode;
15230
15231 increment = 1;
15232
15233 maskcnt = 1;
15234 }
15235 }
15236 else
15237 {
15238 /**
15239 * generate full masks and charsets
15240 */
15241
15242 masks = (char **) mymalloc (sizeof (char *));
15243
15244 switch (hash_mode)
15245 {
15246 case 1731: pw_min = 5;
15247 pw_max = 5;
15248 mask = mystrdup ("?b?b?b?b?b");
15249 break;
15250 case 12500: pw_min = 5;
15251 pw_max = 5;
15252 mask = mystrdup ("?b?b?b?b?b");
15253 break;
15254 default: pw_min = 7;
15255 pw_max = 7;
15256 mask = mystrdup ("?b?b?b?b?b?b?b");
15257 break;
15258 }
15259
15260 maskcnt = 1;
15261
15262 masks[maskcnt - 1] = mystrdup (mask);
15263
15264 wordlist_mode = WL_MODE_MASK;
15265
15266 data.wordlist_mode = wordlist_mode;
15267
15268 increment = 1;
15269 }
15270
15271 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15272
15273 if (increment)
15274 {
15275 if (increment_min > pw_min) pw_min = increment_min;
15276
15277 if (increment_max < pw_max) pw_max = increment_max;
15278 }
15279 }
15280 else if (attack_mode == ATTACK_MODE_HYBRID1)
15281 {
15282 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15283
15284 // display
15285
15286 char *mask = myargv[myargc - 1];
15287
15288 maskcnt = 0;
15289
15290 masks = (char **) mymalloc (1 * sizeof (char *));
15291
15292 // mod
15293
15294 struct stat file_stat;
15295
15296 if (stat (mask, &file_stat) == -1)
15297 {
15298 maskcnt = 1;
15299
15300 masks[maskcnt - 1] = mystrdup (mask);
15301 }
15302 else
15303 {
15304 uint is_file = S_ISREG (file_stat.st_mode);
15305
15306 if (is_file == 1)
15307 {
15308 FILE *mask_fp;
15309
15310 if ((mask_fp = fopen (mask, "r")) == NULL)
15311 {
15312 log_error ("ERROR: %s: %s", mask, strerror (errno));
15313
15314 return (-1);
15315 }
15316
15317 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15318
15319 uint masks_avail = 1;
15320
15321 while (!feof (mask_fp))
15322 {
15323 memset (line_buf, 0, HCBUFSIZ);
15324
15325 int line_len = fgetl (mask_fp, line_buf);
15326
15327 if (line_len == 0) continue;
15328
15329 if (line_buf[0] == '#') continue;
15330
15331 if (masks_avail == maskcnt)
15332 {
15333 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15334
15335 masks_avail += INCR_MASKS;
15336 }
15337
15338 masks[maskcnt] = mystrdup (line_buf);
15339
15340 maskcnt++;
15341 }
15342
15343 myfree (line_buf);
15344
15345 fclose (mask_fp);
15346
15347 mask_from_file = 1;
15348 }
15349 else
15350 {
15351 maskcnt = 1;
15352
15353 masks[maskcnt - 1] = mystrdup (mask);
15354 }
15355 }
15356
15357 // base
15358
15359 int wls_left = myargc - (optind + 2);
15360
15361 for (int i = 0; i < wls_left; i++)
15362 {
15363 char *filename = myargv[optind + 1 + i];
15364
15365 struct stat file_stat;
15366
15367 if (stat (filename, &file_stat) == -1)
15368 {
15369 log_error ("ERROR: %s: %s", filename, strerror (errno));
15370
15371 return (-1);
15372 }
15373
15374 uint is_dir = S_ISDIR (file_stat.st_mode);
15375
15376 if (is_dir == 0)
15377 {
15378 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15379
15380 dictcnt++;
15381
15382 dictfiles[dictcnt - 1] = filename;
15383 }
15384 else
15385 {
15386 // do not allow --keyspace w/ a directory
15387
15388 if (keyspace == 1)
15389 {
15390 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15391
15392 return (-1);
15393 }
15394
15395 char **dictionary_files = NULL;
15396
15397 dictionary_files = scan_directory (filename);
15398
15399 if (dictionary_files != NULL)
15400 {
15401 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15402
15403 for (int d = 0; dictionary_files[d] != NULL; d++)
15404 {
15405 char *l1_filename = dictionary_files[d];
15406
15407 struct stat l1_stat;
15408
15409 if (stat (l1_filename, &l1_stat) == -1)
15410 {
15411 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15412
15413 return (-1);
15414 }
15415
15416 if (S_ISREG (l1_stat.st_mode))
15417 {
15418 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15419
15420 dictcnt++;
15421
15422 dictfiles[dictcnt - 1] = strdup (l1_filename);
15423 }
15424 }
15425 }
15426
15427 local_free (dictionary_files);
15428 }
15429 }
15430
15431 if (dictcnt < 1)
15432 {
15433 log_error ("ERROR: No usable dictionary file found.");
15434
15435 return (-1);
15436 }
15437
15438 if (increment)
15439 {
15440 maskcnt = 0;
15441
15442 uint mask_min = increment_min; // we can't reject smaller masks here
15443 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15444
15445 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15446 {
15447 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15448
15449 if (cur_mask == NULL) break;
15450
15451 masks[maskcnt] = cur_mask;
15452
15453 maskcnt++;
15454
15455 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15456 }
15457 }
15458 }
15459 else if (attack_mode == ATTACK_MODE_HYBRID2)
15460 {
15461 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15462
15463 // display
15464
15465 char *mask = myargv[optind + 1 + 0];
15466
15467 maskcnt = 0;
15468
15469 masks = (char **) mymalloc (1 * sizeof (char *));
15470
15471 // mod
15472
15473 struct stat file_stat;
15474
15475 if (stat (mask, &file_stat) == -1)
15476 {
15477 maskcnt = 1;
15478
15479 masks[maskcnt - 1] = mystrdup (mask);
15480 }
15481 else
15482 {
15483 uint is_file = S_ISREG (file_stat.st_mode);
15484
15485 if (is_file == 1)
15486 {
15487 FILE *mask_fp;
15488
15489 if ((mask_fp = fopen (mask, "r")) == NULL)
15490 {
15491 log_error ("ERROR: %s: %s", mask, strerror (errno));
15492
15493 return (-1);
15494 }
15495
15496 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15497
15498 uint masks_avail = 1;
15499
15500 while (!feof (mask_fp))
15501 {
15502 memset (line_buf, 0, HCBUFSIZ);
15503
15504 int line_len = fgetl (mask_fp, line_buf);
15505
15506 if (line_len == 0) continue;
15507
15508 if (line_buf[0] == '#') continue;
15509
15510 if (masks_avail == maskcnt)
15511 {
15512 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15513
15514 masks_avail += INCR_MASKS;
15515 }
15516
15517 masks[maskcnt] = mystrdup (line_buf);
15518
15519 maskcnt++;
15520 }
15521
15522 myfree (line_buf);
15523
15524 fclose (mask_fp);
15525
15526 mask_from_file = 1;
15527 }
15528 else
15529 {
15530 maskcnt = 1;
15531
15532 masks[maskcnt - 1] = mystrdup (mask);
15533 }
15534 }
15535
15536 // base
15537
15538 int wls_left = myargc - (optind + 2);
15539
15540 for (int i = 0; i < wls_left; i++)
15541 {
15542 char *filename = myargv[optind + 2 + i];
15543
15544 struct stat file_stat;
15545
15546 if (stat (filename, &file_stat) == -1)
15547 {
15548 log_error ("ERROR: %s: %s", filename, strerror (errno));
15549
15550 return (-1);
15551 }
15552
15553 uint is_dir = S_ISDIR (file_stat.st_mode);
15554
15555 if (is_dir == 0)
15556 {
15557 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15558
15559 dictcnt++;
15560
15561 dictfiles[dictcnt - 1] = filename;
15562 }
15563 else
15564 {
15565 // do not allow --keyspace w/ a directory
15566
15567 if (keyspace == 1)
15568 {
15569 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15570
15571 return (-1);
15572 }
15573
15574 char **dictionary_files = NULL;
15575
15576 dictionary_files = scan_directory (filename);
15577
15578 if (dictionary_files != NULL)
15579 {
15580 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15581
15582 for (int d = 0; dictionary_files[d] != NULL; d++)
15583 {
15584 char *l1_filename = dictionary_files[d];
15585
15586 struct stat l1_stat;
15587
15588 if (stat (l1_filename, &l1_stat) == -1)
15589 {
15590 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15591
15592 return (-1);
15593 }
15594
15595 if (S_ISREG (l1_stat.st_mode))
15596 {
15597 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15598
15599 dictcnt++;
15600
15601 dictfiles[dictcnt - 1] = strdup (l1_filename);
15602 }
15603 }
15604 }
15605
15606 local_free (dictionary_files);
15607 }
15608 }
15609
15610 if (dictcnt < 1)
15611 {
15612 log_error ("ERROR: No usable dictionary file found.");
15613
15614 return (-1);
15615 }
15616
15617 if (increment)
15618 {
15619 maskcnt = 0;
15620
15621 uint mask_min = increment_min; // we can't reject smaller masks here
15622 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15623
15624 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15625 {
15626 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15627
15628 if (cur_mask == NULL) break;
15629
15630 masks[maskcnt] = cur_mask;
15631
15632 maskcnt++;
15633
15634 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15635 }
15636 }
15637 }
15638
15639 data.pw_min = pw_min;
15640 data.pw_max = pw_max;
15641
15642 /**
15643 * weak hash check
15644 */
15645
15646 if (weak_hash_threshold >= salts_cnt)
15647 {
15648 hc_device_param_t *device_param = NULL;
15649
15650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15651 {
15652 device_param = &data.devices_param[device_id];
15653
15654 if (device_param->skipped) continue;
15655
15656 break;
15657 }
15658
15659 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15660
15661 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15662 {
15663 weak_hash_check (device_param, salt_pos);
15664 }
15665 }
15666
15667 // Display hack, guarantee that there is at least one \r before real start
15668
15669 if (data.quiet == 0) log_info_nn ("");
15670
15671 /**
15672 * status and monitor threads
15673 */
15674
15675 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15676
15677 hc_thread_t i_thread = 0;
15678
15679 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15680 {
15681 hc_thread_create (i_thread, thread_keypress, &benchmark);
15682 }
15683
15684 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15685
15686 uint ni_threads_cnt = 0;
15687
15688 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15689
15690 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15691
15692 ni_threads_cnt++;
15693
15694 /**
15695 * Outfile remove
15696 */
15697
15698 if (keyspace == 0)
15699 {
15700 if (outfile_check_timer != 0)
15701 {
15702 if (data.outfile_check_directory != NULL)
15703 {
15704 if ((hash_mode != 5200) &&
15705 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15706 (hash_mode != 9000))
15707 {
15708 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15709
15710 ni_threads_cnt++;
15711 }
15712 else
15713 {
15714 outfile_check_timer = 0;
15715 }
15716 }
15717 else
15718 {
15719 outfile_check_timer = 0;
15720 }
15721 }
15722 }
15723
15724 /**
15725 * Inform the user if we got some hashes remove because of the pot file remove feature
15726 */
15727
15728 if (data.quiet == 0)
15729 {
15730 if (potfile_remove_cracks > 0)
15731 {
15732 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15733 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15734 }
15735 }
15736
15737 data.outfile_check_timer = outfile_check_timer;
15738
15739 /**
15740 * main loop
15741 */
15742
15743 char **induction_dictionaries = NULL;
15744
15745 int induction_dictionaries_cnt = 0;
15746
15747 hcstat_table_t *root_table_buf = NULL;
15748 hcstat_table_t *markov_table_buf = NULL;
15749
15750 uint initial_restore_done = 0;
15751
15752 data.maskcnt = maskcnt;
15753
15754 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15755 {
15756 if (data.devices_status == STATUS_CRACKED) break;
15757
15758 data.devices_status = STATUS_INIT;
15759
15760 if (maskpos > rd->maskpos)
15761 {
15762 rd->dictpos = 0;
15763 }
15764
15765 rd->maskpos = maskpos;
15766 data.maskpos = maskpos;
15767
15768 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15769 {
15770 char *mask = masks[maskpos];
15771
15772 if (mask_from_file == 1)
15773 {
15774 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15775
15776 char *str_ptr;
15777 uint str_pos;
15778
15779 uint mask_offset = 0;
15780
15781 uint separator_cnt;
15782
15783 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15784 {
15785 str_ptr = strstr (mask + mask_offset, ",");
15786
15787 if (str_ptr == NULL) break;
15788
15789 str_pos = str_ptr - mask;
15790
15791 // escaped separator, i.e. "\,"
15792
15793 if (str_pos > 0)
15794 {
15795 if (mask[str_pos - 1] == '\\')
15796 {
15797 separator_cnt --;
15798
15799 mask_offset = str_pos + 1;
15800
15801 continue;
15802 }
15803 }
15804
15805 // reset the offset
15806
15807 mask_offset = 0;
15808
15809 mask[str_pos] = '\0';
15810
15811 switch (separator_cnt)
15812 {
15813 case 0:
15814 mp_reset_usr (mp_usr, 0);
15815
15816 custom_charset_1 = mask;
15817 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15818 break;
15819
15820 case 1:
15821 mp_reset_usr (mp_usr, 1);
15822
15823 custom_charset_2 = mask;
15824 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15825 break;
15826
15827 case 2:
15828 mp_reset_usr (mp_usr, 2);
15829
15830 custom_charset_3 = mask;
15831 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15832 break;
15833
15834 case 3:
15835 mp_reset_usr (mp_usr, 3);
15836
15837 custom_charset_4 = mask;
15838 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15839 break;
15840 }
15841
15842 mask = mask + str_pos + 1;
15843 }
15844 }
15845
15846 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15847 {
15848 if (maskpos > 0)
15849 {
15850 local_free (css_buf);
15851 local_free (data.root_css_buf);
15852 local_free (data.markov_css_buf);
15853
15854 local_free (masks[maskpos - 1]);
15855 }
15856
15857 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15858
15859 data.mask = mask;
15860 data.css_cnt = css_cnt;
15861 data.css_buf = css_buf;
15862
15863 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15864
15865 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15866
15867 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15868 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15869
15870 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15871
15872 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15873
15874 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15875 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15876
15877 data.root_css_buf = root_css_buf;
15878 data.markov_css_buf = markov_css_buf;
15879
15880 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15881
15882 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15883
15884 local_free (root_table_buf);
15885 local_free (markov_table_buf);
15886
15887 // args
15888
15889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15890 {
15891 hc_device_param_t *device_param = &data.devices_param[device_id];
15892
15893 if (device_param->skipped) continue;
15894
15895 device_param->kernel_params_mp[0] = &device_param->d_combs;
15896 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15897 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15898
15899 device_param->kernel_params_mp_buf64[3] = 0;
15900 device_param->kernel_params_mp_buf32[4] = css_cnt;
15901 device_param->kernel_params_mp_buf32[5] = 0;
15902 device_param->kernel_params_mp_buf32[6] = 0;
15903 device_param->kernel_params_mp_buf32[7] = 0;
15904
15905 if (attack_mode == ATTACK_MODE_HYBRID1)
15906 {
15907 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15908 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15909 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15910 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15911 }
15912 else if (attack_mode == ATTACK_MODE_HYBRID2)
15913 {
15914 device_param->kernel_params_mp_buf32[5] = 0;
15915 device_param->kernel_params_mp_buf32[6] = 0;
15916 device_param->kernel_params_mp_buf32[7] = 0;
15917 }
15918
15919 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]);
15920 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]);
15921 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]);
15922
15923 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);
15924 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);
15925 }
15926 }
15927 else if (attack_mode == ATTACK_MODE_BF)
15928 {
15929 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15930
15931 if (increment)
15932 {
15933 for (uint i = 0; i < dictcnt; i++)
15934 {
15935 local_free (dictfiles[i]);
15936 }
15937
15938 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15939 {
15940 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15941
15942 if (l1_filename == NULL) break;
15943
15944 dictcnt++;
15945
15946 dictfiles[dictcnt - 1] = l1_filename;
15947 }
15948 }
15949 else
15950 {
15951 dictcnt++;
15952
15953 dictfiles[dictcnt - 1] = mask;
15954 }
15955
15956 if (dictcnt == 0)
15957 {
15958 log_error ("ERROR: Mask is too small");
15959
15960 return (-1);
15961 }
15962 }
15963 }
15964
15965 free (induction_dictionaries);
15966
15967 // induction_dictionaries_cnt = 0; // implied
15968
15969 if (attack_mode != ATTACK_MODE_BF)
15970 {
15971 if (keyspace == 0)
15972 {
15973 induction_dictionaries = scan_directory (induction_directory);
15974
15975 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15976 }
15977 }
15978
15979 if (induction_dictionaries_cnt)
15980 {
15981 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15982 }
15983
15984 /**
15985 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15986 */
15987 if (keyspace == 1)
15988 {
15989 if ((maskcnt > 1) || (dictcnt > 1))
15990 {
15991 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15992
15993 return (-1);
15994 }
15995 }
15996
15997 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15998 {
15999 char *subid = logfile_generate_subid ();
16000
16001 data.subid = subid;
16002
16003 logfile_sub_msg ("START");
16004
16005 data.devices_status = STATUS_INIT;
16006
16007 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16008 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16009 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16010
16011 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16012
16013 data.cpt_pos = 0;
16014
16015 data.cpt_start = time (NULL);
16016
16017 data.cpt_total = 0;
16018
16019 if (data.restore == 0)
16020 {
16021 rd->words_cur = skip;
16022
16023 skip = 0;
16024
16025 data.skip = 0;
16026 }
16027
16028 data.ms_paused = 0;
16029
16030 data.words_cur = rd->words_cur;
16031
16032 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16033 {
16034 hc_device_param_t *device_param = &data.devices_param[device_id];
16035
16036 if (device_param->skipped) continue;
16037
16038 device_param->speed_pos = 0;
16039
16040 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16041 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16042 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16043
16044 device_param->exec_pos = 0;
16045
16046 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16047
16048 device_param->kernel_power = device_param->kernel_power_user;
16049
16050 device_param->outerloop_pos = 0;
16051 device_param->outerloop_left = 0;
16052 device_param->innerloop_pos = 0;
16053 device_param->innerloop_left = 0;
16054
16055 // some more resets:
16056
16057 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16058
16059 device_param->pws_cnt = 0;
16060
16061 device_param->words_off = 0;
16062 device_param->words_done = 0;
16063 }
16064
16065 data.kernel_power_div = 0;
16066
16067 // figure out some workload
16068
16069 if (attack_mode == ATTACK_MODE_STRAIGHT)
16070 {
16071 if (data.wordlist_mode == WL_MODE_FILE)
16072 {
16073 char *dictfile = NULL;
16074
16075 if (induction_dictionaries_cnt)
16076 {
16077 dictfile = induction_dictionaries[0];
16078 }
16079 else
16080 {
16081 dictfile = dictfiles[dictpos];
16082 }
16083
16084 data.dictfile = dictfile;
16085
16086 logfile_sub_string (dictfile);
16087
16088 for (uint i = 0; i < rp_files_cnt; i++)
16089 {
16090 logfile_sub_var_string ("rulefile", rp_files[i]);
16091 }
16092
16093 FILE *fd2 = fopen (dictfile, "rb");
16094
16095 if (fd2 == NULL)
16096 {
16097 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16098
16099 return (-1);
16100 }
16101
16102 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16103
16104 fclose (fd2);
16105
16106 if (data.words_cnt == 0)
16107 {
16108 if (data.devices_status == STATUS_CRACKED) break;
16109 if (data.devices_status == STATUS_ABORTED) break;
16110
16111 dictpos++;
16112
16113 continue;
16114 }
16115 }
16116 }
16117 else if (attack_mode == ATTACK_MODE_COMBI)
16118 {
16119 char *dictfile = data.dictfile;
16120 char *dictfile2 = data.dictfile2;
16121
16122 logfile_sub_string (dictfile);
16123 logfile_sub_string (dictfile2);
16124
16125 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16126 {
16127 FILE *fd2 = fopen (dictfile, "rb");
16128
16129 if (fd2 == NULL)
16130 {
16131 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16132
16133 return (-1);
16134 }
16135
16136 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16137
16138 fclose (fd2);
16139 }
16140 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16141 {
16142 FILE *fd2 = fopen (dictfile2, "rb");
16143
16144 if (fd2 == NULL)
16145 {
16146 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16147
16148 return (-1);
16149 }
16150
16151 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16152
16153 fclose (fd2);
16154 }
16155
16156 if (data.words_cnt == 0)
16157 {
16158 if (data.devices_status == STATUS_CRACKED) break;
16159 if (data.devices_status == STATUS_ABORTED) break;
16160
16161 dictpos++;
16162
16163 continue;
16164 }
16165 }
16166 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16167 {
16168 char *dictfile = NULL;
16169
16170 if (induction_dictionaries_cnt)
16171 {
16172 dictfile = induction_dictionaries[0];
16173 }
16174 else
16175 {
16176 dictfile = dictfiles[dictpos];
16177 }
16178
16179 data.dictfile = dictfile;
16180
16181 char *mask = data.mask;
16182
16183 logfile_sub_string (dictfile);
16184 logfile_sub_string (mask);
16185
16186 FILE *fd2 = fopen (dictfile, "rb");
16187
16188 if (fd2 == NULL)
16189 {
16190 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16191
16192 return (-1);
16193 }
16194
16195 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16196
16197 fclose (fd2);
16198
16199 if (data.words_cnt == 0)
16200 {
16201 if (data.devices_status == STATUS_CRACKED) break;
16202 if (data.devices_status == STATUS_ABORTED) break;
16203
16204 dictpos++;
16205
16206 continue;
16207 }
16208 }
16209 else if (attack_mode == ATTACK_MODE_BF)
16210 {
16211 local_free (css_buf);
16212 local_free (data.root_css_buf);
16213 local_free (data.markov_css_buf);
16214
16215 char *mask = dictfiles[dictpos];
16216
16217 logfile_sub_string (mask);
16218
16219 // base
16220
16221 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16222
16223 if (opts_type & OPTS_TYPE_PT_UNICODE)
16224 {
16225 uint css_cnt_unicode = css_cnt * 2;
16226
16227 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16228
16229 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16230 {
16231 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16232
16233 css_buf_unicode[j + 1].cs_buf[0] = 0;
16234 css_buf_unicode[j + 1].cs_len = 1;
16235 }
16236
16237 free (css_buf);
16238
16239 css_buf = css_buf_unicode;
16240 css_cnt = css_cnt_unicode;
16241 }
16242
16243 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16244
16245 uint mask_min = pw_min;
16246 uint mask_max = pw_max;
16247
16248 if (opts_type & OPTS_TYPE_PT_UNICODE)
16249 {
16250 mask_min *= 2;
16251 mask_max *= 2;
16252 }
16253
16254 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16255 {
16256 if (css_cnt < mask_min)
16257 {
16258 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16259 }
16260
16261 if (css_cnt > mask_max)
16262 {
16263 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16264 }
16265
16266 // skip to next mask
16267
16268 dictpos++;
16269
16270 rd->dictpos = dictpos;
16271
16272 logfile_sub_msg ("STOP");
16273
16274 continue;
16275 }
16276
16277 uint save_css_cnt = css_cnt;
16278
16279 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16280 {
16281 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16282 {
16283 uint salt_len = (uint) data.salts_buf[0].salt_len;
16284 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16285
16286 uint css_cnt_salt = css_cnt + salt_len;
16287
16288 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16289
16290 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16291
16292 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16293 {
16294 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16295 css_buf_salt[j].cs_len = 1;
16296 }
16297
16298 free (css_buf);
16299
16300 css_buf = css_buf_salt;
16301 css_cnt = css_cnt_salt;
16302 }
16303 }
16304
16305 data.mask = mask;
16306 data.css_cnt = css_cnt;
16307 data.css_buf = css_buf;
16308
16309 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16310
16311 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16312
16313 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16314
16315 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16316 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16317
16318 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16319
16320 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16321
16322 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16323 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16324
16325 data.root_css_buf = root_css_buf;
16326 data.markov_css_buf = markov_css_buf;
16327
16328 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16329
16330 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16331
16332 local_free (root_table_buf);
16333 local_free (markov_table_buf);
16334
16335 // copy + args
16336
16337 uint css_cnt_l = css_cnt;
16338 uint css_cnt_r;
16339
16340 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16341 {
16342 if (save_css_cnt < 6)
16343 {
16344 css_cnt_r = 1;
16345 }
16346 else if (save_css_cnt == 6)
16347 {
16348 css_cnt_r = 2;
16349 }
16350 else
16351 {
16352 if (opts_type & OPTS_TYPE_PT_UNICODE)
16353 {
16354 if (save_css_cnt == 8 || save_css_cnt == 10)
16355 {
16356 css_cnt_r = 2;
16357 }
16358 else
16359 {
16360 css_cnt_r = 4;
16361 }
16362 }
16363 else
16364 {
16365 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16366 {
16367 css_cnt_r = 3;
16368 }
16369 else
16370 {
16371 css_cnt_r = 4;
16372 }
16373 }
16374 }
16375 }
16376 else
16377 {
16378 css_cnt_r = 1;
16379
16380 /* unfinished code?
16381 int sum = css_buf[css_cnt_r - 1].cs_len;
16382
16383 for (uint i = 1; i < 4 && i < css_cnt; i++)
16384 {
16385 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16386
16387 css_cnt_r++;
16388
16389 sum *= css_buf[css_cnt_r - 1].cs_len;
16390 }
16391 */
16392 }
16393
16394 css_cnt_l -= css_cnt_r;
16395
16396 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16397
16398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16399 {
16400 hc_device_param_t *device_param = &data.devices_param[device_id];
16401
16402 if (device_param->skipped) continue;
16403
16404 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16405 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16406 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16407
16408 device_param->kernel_params_mp_l_buf64[3] = 0;
16409 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16410 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16411 device_param->kernel_params_mp_l_buf32[6] = 0;
16412 device_param->kernel_params_mp_l_buf32[7] = 0;
16413 device_param->kernel_params_mp_l_buf32[8] = 0;
16414
16415 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16416 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16417 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16418 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16419
16420 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16421 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16422 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16423
16424 device_param->kernel_params_mp_r_buf64[3] = 0;
16425 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16426 device_param->kernel_params_mp_r_buf32[5] = 0;
16427 device_param->kernel_params_mp_r_buf32[6] = 0;
16428 device_param->kernel_params_mp_r_buf32[7] = 0;
16429
16430 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]);
16431 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]);
16432 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]);
16433
16434 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]);
16435 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]);
16436 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]);
16437
16438 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);
16439 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);
16440 }
16441 }
16442
16443 u64 words_base = data.words_cnt;
16444
16445 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16446 {
16447 if (data.kernel_rules_cnt)
16448 {
16449 words_base /= data.kernel_rules_cnt;
16450 }
16451 }
16452 else if (data.attack_kern == ATTACK_KERN_COMBI)
16453 {
16454 if (data.combs_cnt)
16455 {
16456 words_base /= data.combs_cnt;
16457 }
16458 }
16459 else if (data.attack_kern == ATTACK_KERN_BF)
16460 {
16461 if (data.bfs_cnt)
16462 {
16463 words_base /= data.bfs_cnt;
16464 }
16465 }
16466
16467 data.words_base = words_base;
16468
16469 if (keyspace == 1)
16470 {
16471 log_info ("%llu", (unsigned long long int) words_base);
16472
16473 return (0);
16474 }
16475
16476 if (data.words_cur > data.words_base)
16477 {
16478 log_error ("ERROR: restore value greater keyspace");
16479
16480 return (-1);
16481 }
16482
16483 if (data.words_cur)
16484 {
16485 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16486 {
16487 for (uint i = 0; i < data.salts_cnt; i++)
16488 {
16489 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16490 }
16491 }
16492 else if (data.attack_kern == ATTACK_KERN_COMBI)
16493 {
16494 for (uint i = 0; i < data.salts_cnt; i++)
16495 {
16496 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16497 }
16498 }
16499 else if (data.attack_kern == ATTACK_KERN_BF)
16500 {
16501 for (uint i = 0; i < data.salts_cnt; i++)
16502 {
16503 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16504 }
16505 }
16506 }
16507
16508 /*
16509 * Inform user about possible slow speeds
16510 */
16511
16512 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16513 {
16514 if (data.words_base < kernel_power_all)
16515 {
16516 if (quiet == 0)
16517 {
16518 log_info ("");
16519 log_info ("ATTENTION!");
16520 log_info (" The wordlist or mask you are using is too small.");
16521 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16522 log_info (" The cracking speed will drop.");
16523 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16524 log_info ("");
16525 }
16526 }
16527 }
16528
16529 /*
16530 * Update loopback file
16531 */
16532
16533 if (loopback == 1)
16534 {
16535 time_t now;
16536
16537 time (&now);
16538
16539 uint random_num = get_random_num (0, 9999);
16540
16541 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16542
16543 data.loopback_file = loopback_file;
16544 }
16545
16546 /*
16547 * Update dictionary statistic
16548 */
16549
16550 if (keyspace == 0)
16551 {
16552 dictstat_fp = fopen (dictstat, "wb");
16553
16554 if (dictstat_fp)
16555 {
16556 lock_file (dictstat_fp);
16557
16558 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16559
16560 fclose (dictstat_fp);
16561 }
16562 }
16563
16564 data.devices_status = STATUS_RUNNING;
16565
16566 if (initial_restore_done == 0)
16567 {
16568 if (data.restore_disable == 0) cycle_restore ();
16569
16570 initial_restore_done = 1;
16571 }
16572
16573 hc_timer_set (&data.timer_running);
16574
16575 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16576 {
16577 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16578 {
16579 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16580 if (quiet == 0) fflush (stdout);
16581 }
16582 }
16583 else if (wordlist_mode == WL_MODE_STDIN)
16584 {
16585 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16586 if (data.quiet == 0) log_info ("");
16587 }
16588
16589 time_t runtime_start;
16590
16591 time (&runtime_start);
16592
16593 data.runtime_start = runtime_start;
16594
16595 /**
16596 * create cracker threads
16597 */
16598
16599 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16600
16601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16602 {
16603 hc_device_param_t *device_param = &devices_param[device_id];
16604
16605 if (wordlist_mode == WL_MODE_STDIN)
16606 {
16607 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16608 }
16609 else
16610 {
16611 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16612 }
16613 }
16614
16615 // wait for crack threads to exit
16616
16617 hc_thread_wait (data.devices_cnt, c_threads);
16618
16619 local_free (c_threads);
16620
16621 data.restore = 0;
16622
16623 // finalize task
16624
16625 logfile_sub_var_uint ("status-after-work", data.devices_status);
16626
16627 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16628
16629 if (data.devices_status == STATUS_CRACKED) break;
16630 if (data.devices_status == STATUS_ABORTED) break;
16631
16632 if (data.devices_status == STATUS_BYPASS)
16633 {
16634 data.devices_status = STATUS_RUNNING;
16635 }
16636
16637 if (induction_dictionaries_cnt)
16638 {
16639 unlink (induction_dictionaries[0]);
16640 }
16641
16642 free (induction_dictionaries);
16643
16644 if (attack_mode != ATTACK_MODE_BF)
16645 {
16646 induction_dictionaries = scan_directory (induction_directory);
16647
16648 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16649 }
16650
16651 if (benchmark == 0)
16652 {
16653 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16654 {
16655 if (quiet == 0) clear_prompt ();
16656
16657 if (quiet == 0) log_info ("");
16658
16659 if (status == 1)
16660 {
16661 status_display ();
16662 }
16663 else
16664 {
16665 if (quiet == 0) status_display ();
16666 }
16667
16668 if (quiet == 0) log_info ("");
16669 }
16670 }
16671
16672 if (attack_mode == ATTACK_MODE_BF)
16673 {
16674 dictpos++;
16675
16676 rd->dictpos = dictpos;
16677 }
16678 else
16679 {
16680 if (induction_dictionaries_cnt)
16681 {
16682 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16683 }
16684 else
16685 {
16686 dictpos++;
16687
16688 rd->dictpos = dictpos;
16689 }
16690 }
16691
16692 time_t runtime_stop;
16693
16694 time (&runtime_stop);
16695
16696 data.runtime_stop = runtime_stop;
16697
16698 logfile_sub_uint (runtime_start);
16699 logfile_sub_uint (runtime_stop);
16700
16701 logfile_sub_msg ("STOP");
16702
16703 global_free (subid);
16704 }
16705
16706 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16707
16708 if (data.devices_status == STATUS_CRACKED) break;
16709 if (data.devices_status == STATUS_ABORTED) break;
16710 if (data.devices_status == STATUS_QUIT) break;
16711
16712 if (data.devices_status == STATUS_BYPASS)
16713 {
16714 data.devices_status = STATUS_RUNNING;
16715 }
16716 }
16717
16718 // 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
16719
16720 if (attack_mode == ATTACK_MODE_STRAIGHT)
16721 {
16722 if (data.wordlist_mode == WL_MODE_FILE)
16723 {
16724 if (data.dictfile == NULL)
16725 {
16726 if (dictfiles != NULL)
16727 {
16728 data.dictfile = dictfiles[0];
16729
16730 hc_timer_set (&data.timer_running);
16731 }
16732 }
16733 }
16734 }
16735 // NOTE: combi is okay because it is already set beforehand
16736 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16737 {
16738 if (data.dictfile == NULL)
16739 {
16740 if (dictfiles != NULL)
16741 {
16742 hc_timer_set (&data.timer_running);
16743
16744 data.dictfile = dictfiles[0];
16745 }
16746 }
16747 }
16748 else if (attack_mode == ATTACK_MODE_BF)
16749 {
16750 if (data.mask == NULL)
16751 {
16752 hc_timer_set (&data.timer_running);
16753
16754 data.mask = masks[0];
16755 }
16756 }
16757
16758 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16759 {
16760 data.devices_status = STATUS_EXHAUSTED;
16761 }
16762
16763 // if cracked / aborted remove last induction dictionary
16764
16765 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16766 {
16767 struct stat induct_stat;
16768
16769 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16770 {
16771 unlink (induction_dictionaries[file_pos]);
16772 }
16773 }
16774
16775 // wait for non-interactive threads
16776
16777 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16778 {
16779 hc_thread_wait (1, &ni_threads[thread_idx]);
16780 }
16781
16782 local_free (ni_threads);
16783
16784 // wait for interactive threads
16785
16786 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16787 {
16788 hc_thread_wait (1, &i_thread);
16789 }
16790
16791 // we dont need restore file anymore
16792 if (data.restore_disable == 0)
16793 {
16794 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16795 {
16796 unlink (eff_restore_file);
16797 unlink (new_restore_file);
16798 }
16799 else
16800 {
16801 cycle_restore ();
16802 }
16803 }
16804
16805 // finally save left hashes
16806
16807 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16808 {
16809 save_hash ();
16810 }
16811
16812 /**
16813 * Clean up
16814 */
16815
16816 if (benchmark == 1)
16817 {
16818 status_benchmark ();
16819
16820 log_info ("");
16821 }
16822 else
16823 {
16824 if (quiet == 0) clear_prompt ();
16825
16826 if (quiet == 0) log_info ("");
16827
16828 if (status == 1)
16829 {
16830 status_display ();
16831 }
16832 else
16833 {
16834 if (quiet == 0) status_display ();
16835 }
16836
16837 if (quiet == 0) log_info ("");
16838 }
16839
16840 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16841 {
16842 hc_device_param_t *device_param = &data.devices_param[device_id];
16843
16844 if (device_param->skipped) continue;
16845
16846 local_free (device_param->result);
16847
16848 local_free (device_param->combs_buf);
16849
16850 local_free (device_param->hooks_buf);
16851
16852 local_free (device_param->device_name);
16853
16854 local_free (device_param->device_name_chksum);
16855
16856 local_free (device_param->device_version);
16857
16858 local_free (device_param->driver_version);
16859
16860 if (device_param->pws_buf) myfree (device_param->pws_buf);
16861 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16862 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16863 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16864 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16865 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16866 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16867 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16868 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16869 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16870 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16871 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16872 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16873 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16874 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16875 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16876 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16877 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16878 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16879 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16880 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16881 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16882 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16883 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16884 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16885 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16886 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16887 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16888 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16889
16890 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16891 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16892 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16893 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16894 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16895 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16896 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16897 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16898 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16899 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16900
16901 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16902 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16903 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16904
16905 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16906 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16907 }
16908
16909 // reset default fan speed
16910
16911 #ifdef HAVE_HWMON
16912 if (gpu_temp_disable == 0)
16913 {
16914 #ifdef HAVE_ADL
16915 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16916 {
16917 hc_thread_mutex_lock (mux_adl);
16918
16919 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16920 {
16921 hc_device_param_t *device_param = &data.devices_param[device_id];
16922
16923 if (device_param->skipped) continue;
16924
16925 if (data.hm_device[device_id].fan_supported == 1)
16926 {
16927 int fanspeed = temp_retain_fanspeed_value[device_id];
16928
16929 if (fanspeed == -1) continue;
16930
16931 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16932
16933 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16934 }
16935 }
16936
16937 hc_thread_mutex_unlock (mux_adl);
16938 }
16939 #endif // HAVE_ADL
16940 }
16941
16942 #ifdef HAVE_ADL
16943 // reset power tuning
16944
16945 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16946 {
16947 hc_thread_mutex_lock (mux_adl);
16948
16949 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16950 {
16951 hc_device_param_t *device_param = &data.devices_param[device_id];
16952
16953 if (device_param->skipped) continue;
16954
16955 if (data.hm_device[device_id].od_version == 6)
16956 {
16957 // check powertune capabilities first, if not available then skip device
16958
16959 int powertune_supported = 0;
16960
16961 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16962 {
16963 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16964
16965 return (-1);
16966 }
16967
16968 if (powertune_supported != 0)
16969 {
16970 // powercontrol settings
16971
16972 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)
16973 {
16974 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16975
16976 return (-1);
16977 }
16978
16979 // clocks
16980
16981 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16982
16983 performance_state->iNumberOfPerformanceLevels = 2;
16984
16985 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16986 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16987 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16988 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16989
16990 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)
16991 {
16992 log_info ("ERROR: Failed to restore ADL performance state");
16993
16994 return (-1);
16995 }
16996
16997 local_free (performance_state);
16998 }
16999 }
17000 }
17001
17002 hc_thread_mutex_unlock (mux_adl);
17003 }
17004 #endif // HAVE_ADL
17005
17006 if (gpu_temp_disable == 0)
17007 {
17008 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17009 if (data.hm_nv)
17010 {
17011 #if defined(LINUX) && defined(HAVE_NVML)
17012
17013 hm_NVML_nvmlShutdown (data.hm_nv);
17014
17015 nvml_close (data.hm_nv);
17016
17017 #elif defined(WIN) && (HAVE_NVAPI)
17018
17019 hm_NvAPI_Unload (data.hm_nv);
17020
17021 nvapi_close (data.hm_nv);
17022
17023 #endif
17024
17025 data.hm_nv = NULL;
17026 }
17027 #endif
17028
17029 #ifdef HAVE_ADL
17030 if (data.hm_amd)
17031 {
17032 hm_ADL_Main_Control_Destroy (data.hm_amd);
17033
17034 adl_close (data.hm_amd);
17035 data.hm_amd = NULL;
17036 }
17037 #endif
17038 }
17039 #endif // HAVE_HWMON
17040
17041 // free memory
17042
17043 local_free (masks);
17044
17045 local_free (dictstat_base);
17046
17047 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17048 {
17049 pot_t *pot_ptr = &pot[pot_pos];
17050
17051 hash_t *hash = &pot_ptr->hash;
17052
17053 local_free (hash->digest);
17054
17055 if (isSalted)
17056 {
17057 local_free (hash->salt);
17058 }
17059 }
17060
17061 local_free (pot);
17062
17063 local_free (all_kernel_rules_cnt);
17064 local_free (all_kernel_rules_buf);
17065
17066 local_free (wl_data->buf);
17067 local_free (wl_data);
17068
17069 local_free (bitmap_s1_a);
17070 local_free (bitmap_s1_b);
17071 local_free (bitmap_s1_c);
17072 local_free (bitmap_s1_d);
17073 local_free (bitmap_s2_a);
17074 local_free (bitmap_s2_b);
17075 local_free (bitmap_s2_c);
17076 local_free (bitmap_s2_d);
17077
17078 #ifdef HAVE_HWMON
17079 local_free (temp_retain_fanspeed_value);
17080 #ifdef HAVE_ADL
17081 local_free (od_clock_mem_status);
17082 local_free (od_power_control_status);
17083 #endif // ADL
17084 #endif
17085
17086 global_free (devices_param);
17087
17088 global_free (kernel_rules_buf);
17089
17090 global_free (root_css_buf);
17091 global_free (markov_css_buf);
17092
17093 global_free (digests_buf);
17094 global_free (digests_shown);
17095 global_free (digests_shown_tmp);
17096
17097 global_free (salts_buf);
17098 global_free (salts_shown);
17099
17100 global_free (esalts_buf);
17101
17102 global_free (words_progress_done);
17103 global_free (words_progress_rejected);
17104 global_free (words_progress_restored);
17105
17106 if (pot_fp) fclose (pot_fp);
17107
17108 if (data.devices_status == STATUS_QUIT) break;
17109 }
17110
17111 // destroy others mutex
17112
17113 hc_thread_mutex_delete (mux_dispatcher);
17114 hc_thread_mutex_delete (mux_counter);
17115 hc_thread_mutex_delete (mux_display);
17116 hc_thread_mutex_delete (mux_adl);
17117
17118 // free memory
17119
17120 local_free (eff_restore_file);
17121 local_free (new_restore_file);
17122
17123 local_free (rd);
17124
17125 // tuning db
17126
17127 tuning_db_destroy (tuning_db);
17128
17129 // loopback
17130
17131 local_free (loopback_file);
17132
17133 if (loopback == 1) unlink (loopback_file);
17134
17135 // induction directory
17136
17137 if (induction_dir == NULL)
17138 {
17139 if (attack_mode != ATTACK_MODE_BF)
17140 {
17141 if (rmdir (induction_directory) == -1)
17142 {
17143 if (errno == ENOENT)
17144 {
17145 // good, we can ignore
17146 }
17147 else if (errno == ENOTEMPTY)
17148 {
17149 // good, we can ignore
17150 }
17151 else
17152 {
17153 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17154
17155 return (-1);
17156 }
17157 }
17158
17159 local_free (induction_directory);
17160 }
17161 }
17162
17163 // outfile-check directory
17164
17165 if (outfile_check_dir == NULL)
17166 {
17167 if (rmdir (outfile_check_directory) == -1)
17168 {
17169 if (errno == ENOENT)
17170 {
17171 // good, we can ignore
17172 }
17173 else if (errno == ENOTEMPTY)
17174 {
17175 // good, we can ignore
17176 }
17177 else
17178 {
17179 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17180
17181 return (-1);
17182 }
17183 }
17184
17185 local_free (outfile_check_directory);
17186 }
17187
17188 time_t proc_stop;
17189
17190 time (&proc_stop);
17191
17192 logfile_top_uint (proc_start);
17193 logfile_top_uint (proc_stop);
17194
17195 logfile_top_msg ("STOP");
17196
17197 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17198 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17199
17200 if (data.ocl) ocl_close (data.ocl);
17201
17202 if (data.devices_status == STATUS_ABORTED) return 2;
17203 if (data.devices_status == STATUS_QUIT) return 2;
17204 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17205 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17206 if (data.devices_status == STATUS_CRACKED) return 0;
17207
17208 return -1;
17209 }
Hashcat additions to support pwdhash