projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Adding parser and basic kernels for -m 134
[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 134,
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 " 134 = 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 > 13400) // 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 134: 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_UNICODE
7459 | OPTS_TYPE_ST_ADD80
7460 | OPTS_TYPE_ST_ADDBITS15;
7461 kern_type = KERN_TYPE_SHA1_SLTPWU;
7462 dgst_size = DGST_SIZE_4_5;
7463 parse_func = pstoken_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 140: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA1_SLTPWU;
7486 dgst_size = DGST_SIZE_4_5;
7487 parse_func = sha1s_parse_hash;
7488 sort_by_digest = sort_by_digest_4_5;
7489 opti_type = OPTI_TYPE_ZERO_BYTE
7490 | OPTI_TYPE_PRECOMPUTE_INIT
7491 | OPTI_TYPE_PRECOMPUTE_MERKLE
7492 | OPTI_TYPE_EARLY_SKIP
7493 | OPTI_TYPE_NOT_ITERATED
7494 | OPTI_TYPE_PREPENDED_SALT
7495 | OPTI_TYPE_RAW_HASH;
7496 dgst_pos0 = 3;
7497 dgst_pos1 = 4;
7498 dgst_pos2 = 2;
7499 dgst_pos3 = 1;
7500 break;
7501
7502 case 141: hash_type = HASH_TYPE_SHA1;
7503 salt_type = SALT_TYPE_EMBEDDED;
7504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7505 opts_type = OPTS_TYPE_PT_GENERATE_BE
7506 | OPTS_TYPE_PT_ADD80
7507 | OPTS_TYPE_PT_ADDBITS15
7508 | OPTS_TYPE_PT_UNICODE
7509 | OPTS_TYPE_ST_BASE64;
7510 kern_type = KERN_TYPE_SHA1_SLTPWU;
7511 dgst_size = DGST_SIZE_4_5;
7512 parse_func = episerver_parse_hash;
7513 sort_by_digest = sort_by_digest_4_5;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_PREPENDED_SALT
7520 | OPTI_TYPE_RAW_HASH;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 4;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 1;
7525 break;
7526
7527 case 150: hash_type = HASH_TYPE_SHA1;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_ST_ADD80
7532 | OPTS_TYPE_ST_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA1_PW;
7534 dgst_size = DGST_SIZE_4_5;
7535 parse_func = hmacsha1_parse_hash;
7536 sort_by_digest = sort_by_digest_4_5;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 160: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_PT_ADD80
7550 | OPTS_TYPE_PT_ADDBITS15;
7551 kern_type = KERN_TYPE_HMACSHA1_SLT;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = hmacsha1_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_NOT_ITERATED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 190: hash_type = HASH_TYPE_SHA1;
7564 salt_type = SALT_TYPE_NONE;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7570 dgst_size = DGST_SIZE_4_5;
7571 parse_func = sha1linkedin_parse_hash;
7572 sort_by_digest = sort_by_digest_4_5;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED
7577 | OPTI_TYPE_NOT_SALTED;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 4;
7580 dgst_pos2 = 3;
7581 dgst_pos3 = 2;
7582 break;
7583
7584 case 200: hash_type = HASH_TYPE_MYSQL;
7585 salt_type = SALT_TYPE_NONE;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = 0;
7588 kern_type = KERN_TYPE_MYSQL;
7589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7590 parse_func = mysql323_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7592 opti_type = OPTI_TYPE_ZERO_BYTE;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 1;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 3;
7597 break;
7598
7599 case 300: hash_type = HASH_TYPE_SHA1;
7600 salt_type = SALT_TYPE_NONE;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_BE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS15;
7605 kern_type = KERN_TYPE_MYSQL41;
7606 dgst_size = DGST_SIZE_4_5;
7607 parse_func = sha1_parse_hash;
7608 sort_by_digest = sort_by_digest_4_5;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_NOT_SALTED;
7615 dgst_pos0 = 3;
7616 dgst_pos1 = 4;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 1;
7619 break;
7620
7621 case 400: hash_type = HASH_TYPE_MD5;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7625 kern_type = KERN_TYPE_PHPASS;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = phpass_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE;
7630 dgst_pos0 = 0;
7631 dgst_pos1 = 1;
7632 dgst_pos2 = 2;
7633 dgst_pos3 = 3;
7634 break;
7635
7636 case 500: hash_type = HASH_TYPE_MD5;
7637 salt_type = SALT_TYPE_EMBEDDED;
7638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7640 kern_type = KERN_TYPE_MD5CRYPT;
7641 dgst_size = DGST_SIZE_4_4;
7642 parse_func = md5crypt_parse_hash;
7643 sort_by_digest = sort_by_digest_4_4;
7644 opti_type = OPTI_TYPE_ZERO_BYTE;
7645 dgst_pos0 = 0;
7646 dgst_pos1 = 1;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 3;
7649 break;
7650
7651 case 501: hash_type = HASH_TYPE_MD5;
7652 salt_type = SALT_TYPE_EMBEDDED;
7653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_LE
7655 | OPTS_TYPE_HASH_COPY;
7656 kern_type = KERN_TYPE_MD5CRYPT;
7657 dgst_size = DGST_SIZE_4_4;
7658 parse_func = juniper_parse_hash;
7659 sort_by_digest = sort_by_digest_4_4;
7660 opti_type = OPTI_TYPE_ZERO_BYTE;
7661 dgst_pos0 = 0;
7662 dgst_pos1 = 1;
7663 dgst_pos2 = 2;
7664 dgst_pos3 = 3;
7665 break;
7666
7667 case 900: 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 kern_type = KERN_TYPE_MD4;
7674 dgst_size = DGST_SIZE_4_4;
7675 parse_func = md4_parse_hash;
7676 sort_by_digest = sort_by_digest_4_4;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_MEET_IN_MIDDLE
7681 | OPTI_TYPE_EARLY_SKIP
7682 | OPTI_TYPE_NOT_ITERATED
7683 | OPTI_TYPE_NOT_SALTED
7684 | OPTI_TYPE_RAW_HASH;
7685 dgst_pos0 = 0;
7686 dgst_pos1 = 3;
7687 dgst_pos2 = 2;
7688 dgst_pos3 = 1;
7689 break;
7690
7691 case 1000: hash_type = HASH_TYPE_MD4;
7692 salt_type = SALT_TYPE_NONE;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_LE
7695 | OPTS_TYPE_PT_ADD80
7696 | OPTS_TYPE_PT_ADDBITS14
7697 | OPTS_TYPE_PT_UNICODE;
7698 kern_type = KERN_TYPE_MD4_PWU;
7699 dgst_size = DGST_SIZE_4_4;
7700 parse_func = md4_parse_hash;
7701 sort_by_digest = sort_by_digest_4_4;
7702 opti_type = OPTI_TYPE_ZERO_BYTE
7703 | OPTI_TYPE_PRECOMPUTE_INIT
7704 | OPTI_TYPE_PRECOMPUTE_MERKLE
7705 | OPTI_TYPE_MEET_IN_MIDDLE
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_NOT_SALTED
7709 | OPTI_TYPE_RAW_HASH;
7710 dgst_pos0 = 0;
7711 dgst_pos1 = 3;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 1;
7714 break;
7715
7716 case 1100: hash_type = HASH_TYPE_MD4;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_LE
7720 | OPTS_TYPE_PT_ADD80
7721 | OPTS_TYPE_PT_ADDBITS14
7722 | OPTS_TYPE_PT_UNICODE
7723 | OPTS_TYPE_ST_ADD80
7724 | OPTS_TYPE_ST_UNICODE
7725 | OPTS_TYPE_ST_LOWER;
7726 kern_type = KERN_TYPE_MD44_PWUSLT;
7727 dgst_size = DGST_SIZE_4_4;
7728 parse_func = dcc_parse_hash;
7729 sort_by_digest = sort_by_digest_4_4;
7730 opti_type = OPTI_TYPE_ZERO_BYTE
7731 | OPTI_TYPE_PRECOMPUTE_INIT
7732 | OPTI_TYPE_PRECOMPUTE_MERKLE
7733 | OPTI_TYPE_EARLY_SKIP
7734 | OPTI_TYPE_NOT_ITERATED;
7735 dgst_pos0 = 0;
7736 dgst_pos1 = 3;
7737 dgst_pos2 = 2;
7738 dgst_pos3 = 1;
7739 break;
7740
7741 case 1400: hash_type = HASH_TYPE_SHA256;
7742 salt_type = SALT_TYPE_NONE;
7743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7744 opts_type = OPTS_TYPE_PT_GENERATE_BE
7745 | OPTS_TYPE_PT_ADD80
7746 | OPTS_TYPE_PT_ADDBITS15;
7747 kern_type = KERN_TYPE_SHA256;
7748 dgst_size = DGST_SIZE_4_8;
7749 parse_func = sha256_parse_hash;
7750 sort_by_digest = sort_by_digest_4_8;
7751 opti_type = OPTI_TYPE_ZERO_BYTE
7752 | OPTI_TYPE_PRECOMPUTE_INIT
7753 | OPTI_TYPE_PRECOMPUTE_MERKLE
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_NOT_SALTED
7757 | OPTI_TYPE_RAW_HASH;
7758 dgst_pos0 = 3;
7759 dgst_pos1 = 7;
7760 dgst_pos2 = 2;
7761 dgst_pos3 = 6;
7762 break;
7763
7764 case 1410: hash_type = HASH_TYPE_SHA256;
7765 salt_type = SALT_TYPE_INTERN;
7766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7767 opts_type = OPTS_TYPE_PT_GENERATE_BE
7768 | OPTS_TYPE_ST_ADD80
7769 | OPTS_TYPE_ST_ADDBITS15;
7770 kern_type = KERN_TYPE_SHA256_PWSLT;
7771 dgst_size = DGST_SIZE_4_8;
7772 parse_func = sha256s_parse_hash;
7773 sort_by_digest = sort_by_digest_4_8;
7774 opti_type = OPTI_TYPE_ZERO_BYTE
7775 | OPTI_TYPE_PRECOMPUTE_INIT
7776 | OPTI_TYPE_PRECOMPUTE_MERKLE
7777 | OPTI_TYPE_EARLY_SKIP
7778 | OPTI_TYPE_NOT_ITERATED
7779 | OPTI_TYPE_APPENDED_SALT
7780 | OPTI_TYPE_RAW_HASH;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 7;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 6;
7785 break;
7786
7787 case 1420: hash_type = HASH_TYPE_SHA256;
7788 salt_type = SALT_TYPE_INTERN;
7789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_BE
7791 | OPTS_TYPE_PT_ADD80
7792 | OPTS_TYPE_PT_ADDBITS15;
7793 kern_type = KERN_TYPE_SHA256_SLTPW;
7794 dgst_size = DGST_SIZE_4_8;
7795 parse_func = sha256s_parse_hash;
7796 sort_by_digest = sort_by_digest_4_8;
7797 opti_type = OPTI_TYPE_ZERO_BYTE
7798 | OPTI_TYPE_PRECOMPUTE_INIT
7799 | OPTI_TYPE_PRECOMPUTE_MERKLE
7800 | OPTI_TYPE_EARLY_SKIP
7801 | OPTI_TYPE_NOT_ITERATED
7802 | OPTI_TYPE_PREPENDED_SALT
7803 | OPTI_TYPE_RAW_HASH;
7804 dgst_pos0 = 3;
7805 dgst_pos1 = 7;
7806 dgst_pos2 = 2;
7807 dgst_pos3 = 6;
7808 break;
7809
7810 case 1421: hash_type = HASH_TYPE_SHA256;
7811 salt_type = SALT_TYPE_EMBEDDED;
7812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7813 opts_type = OPTS_TYPE_PT_GENERATE_BE
7814 | OPTS_TYPE_PT_ADD80
7815 | OPTS_TYPE_PT_ADDBITS15;
7816 kern_type = KERN_TYPE_SHA256_SLTPW;
7817 dgst_size = DGST_SIZE_4_8;
7818 parse_func = hmailserver_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_PREPENDED_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 1430: 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_UNICODE
7838 | OPTS_TYPE_ST_ADD80
7839 | OPTS_TYPE_ST_ADDBITS15;
7840 kern_type = KERN_TYPE_SHA256_PWUSLT;
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_APPENDED_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 1440: hash_type = HASH_TYPE_SHA256;
7858 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA256_SLTPWU;
7865 dgst_size = DGST_SIZE_4_8;
7866 parse_func = sha256s_parse_hash;
7867 sort_by_digest = sort_by_digest_4_8;
7868 opti_type = OPTI_TYPE_ZERO_BYTE
7869 | OPTI_TYPE_PRECOMPUTE_INIT
7870 | OPTI_TYPE_PRECOMPUTE_MERKLE
7871 | OPTI_TYPE_EARLY_SKIP
7872 | OPTI_TYPE_NOT_ITERATED
7873 | OPTI_TYPE_PREPENDED_SALT
7874 | OPTI_TYPE_RAW_HASH;
7875 dgst_pos0 = 3;
7876 dgst_pos1 = 7;
7877 dgst_pos2 = 2;
7878 dgst_pos3 = 6;
7879 break;
7880
7881 case 1441: hash_type = HASH_TYPE_SHA256;
7882 salt_type = SALT_TYPE_EMBEDDED;
7883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7884 opts_type = OPTS_TYPE_PT_GENERATE_BE
7885 | OPTS_TYPE_PT_ADD80
7886 | OPTS_TYPE_PT_ADDBITS15
7887 | OPTS_TYPE_PT_UNICODE
7888 | OPTS_TYPE_ST_BASE64;
7889 kern_type = KERN_TYPE_SHA256_SLTPWU;
7890 dgst_size = DGST_SIZE_4_8;
7891 parse_func = episerver4_parse_hash;
7892 sort_by_digest = sort_by_digest_4_8;
7893 opti_type = OPTI_TYPE_ZERO_BYTE
7894 | OPTI_TYPE_PRECOMPUTE_INIT
7895 | OPTI_TYPE_PRECOMPUTE_MERKLE
7896 | OPTI_TYPE_EARLY_SKIP
7897 | OPTI_TYPE_NOT_ITERATED
7898 | OPTI_TYPE_PREPENDED_SALT
7899 | OPTI_TYPE_RAW_HASH;
7900 dgst_pos0 = 3;
7901 dgst_pos1 = 7;
7902 dgst_pos2 = 2;
7903 dgst_pos3 = 6;
7904 break;
7905
7906 case 1450: hash_type = HASH_TYPE_SHA256;
7907 salt_type = SALT_TYPE_INTERN;
7908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7909 opts_type = OPTS_TYPE_PT_GENERATE_BE
7910 | OPTS_TYPE_ST_ADD80;
7911 kern_type = KERN_TYPE_HMACSHA256_PW;
7912 dgst_size = DGST_SIZE_4_8;
7913 parse_func = hmacsha256_parse_hash;
7914 sort_by_digest = sort_by_digest_4_8;
7915 opti_type = OPTI_TYPE_ZERO_BYTE
7916 | OPTI_TYPE_NOT_ITERATED;
7917 dgst_pos0 = 3;
7918 dgst_pos1 = 7;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 6;
7921 break;
7922
7923 case 1460: hash_type = HASH_TYPE_SHA256;
7924 salt_type = SALT_TYPE_INTERN;
7925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_BE
7927 | OPTS_TYPE_PT_ADD80
7928 | OPTS_TYPE_PT_ADDBITS15;
7929 kern_type = KERN_TYPE_HMACSHA256_SLT;
7930 dgst_size = DGST_SIZE_4_8;
7931 parse_func = hmacsha256_parse_hash;
7932 sort_by_digest = sort_by_digest_4_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_NOT_ITERATED;
7935 dgst_pos0 = 3;
7936 dgst_pos1 = 7;
7937 dgst_pos2 = 2;
7938 dgst_pos3 = 6;
7939 break;
7940
7941 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7942 salt_type = SALT_TYPE_EMBEDDED;
7943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7944 opts_type = OPTS_TYPE_PT_GENERATE_LE
7945 | OPTS_TYPE_PT_BITSLICE;
7946 kern_type = KERN_TYPE_DESCRYPT;
7947 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7948 parse_func = descrypt_parse_hash;
7949 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7950 opti_type = OPTI_TYPE_ZERO_BYTE
7951 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7952 dgst_pos0 = 0;
7953 dgst_pos1 = 1;
7954 dgst_pos2 = 2;
7955 dgst_pos3 = 3;
7956 break;
7957
7958 case 1600: hash_type = HASH_TYPE_MD5;
7959 salt_type = SALT_TYPE_EMBEDDED;
7960 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7961 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7962 kern_type = KERN_TYPE_APR1CRYPT;
7963 dgst_size = DGST_SIZE_4_4;
7964 parse_func = md5apr1_parse_hash;
7965 sort_by_digest = sort_by_digest_4_4;
7966 opti_type = OPTI_TYPE_ZERO_BYTE;
7967 dgst_pos0 = 0;
7968 dgst_pos1 = 1;
7969 dgst_pos2 = 2;
7970 dgst_pos3 = 3;
7971 break;
7972
7973 case 1700: hash_type = HASH_TYPE_SHA512;
7974 salt_type = SALT_TYPE_NONE;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_PT_ADD80
7978 | OPTS_TYPE_PT_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA512;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = sha512_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_NOT_SALTED
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 1710: hash_type = HASH_TYPE_SHA512;
7998 salt_type = SALT_TYPE_INTERN;
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 = sha512s_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 1711: hash_type = HASH_TYPE_SHA512;
8022 salt_type = SALT_TYPE_EMBEDDED;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA512_PWSLT;
8028 dgst_size = DGST_SIZE_8_8;
8029 parse_func = sha512b64s_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_APPENDED_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 1720: hash_type = HASH_TYPE_SHA512;
8046 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_SHA512_SLTPW;
8052 dgst_size = DGST_SIZE_8_8;
8053 parse_func = sha512s_parse_hash;
8054 sort_by_digest = sort_by_digest_8_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_USES_BITS_64
8062 | OPTI_TYPE_RAW_HASH;
8063 dgst_pos0 = 14;
8064 dgst_pos1 = 15;
8065 dgst_pos2 = 6;
8066 dgst_pos3 = 7;
8067 break;
8068
8069 case 1722: hash_type = HASH_TYPE_SHA512;
8070 salt_type = SALT_TYPE_EMBEDDED;
8071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_BE
8073 | OPTS_TYPE_PT_ADD80
8074 | OPTS_TYPE_PT_ADDBITS15
8075 | OPTS_TYPE_ST_HEX;
8076 kern_type = KERN_TYPE_SHA512_SLTPW;
8077 dgst_size = DGST_SIZE_8_8;
8078 parse_func = osx512_parse_hash;
8079 sort_by_digest = sort_by_digest_8_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_USES_BITS_64
8087 | OPTI_TYPE_RAW_HASH;
8088 dgst_pos0 = 14;
8089 dgst_pos1 = 15;
8090 dgst_pos2 = 6;
8091 dgst_pos3 = 7;
8092 break;
8093
8094 case 1730: hash_type = HASH_TYPE_SHA512;
8095 salt_type = SALT_TYPE_INTERN;
8096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8097 opts_type = OPTS_TYPE_PT_GENERATE_BE
8098 | OPTS_TYPE_PT_UNICODE
8099 | OPTS_TYPE_ST_ADD80
8100 | OPTS_TYPE_ST_ADDBITS15;
8101 kern_type = KERN_TYPE_SHA512_PWSLTU;
8102 dgst_size = DGST_SIZE_8_8;
8103 parse_func = sha512s_parse_hash;
8104 sort_by_digest = sort_by_digest_8_8;
8105 opti_type = OPTI_TYPE_ZERO_BYTE
8106 | OPTI_TYPE_PRECOMPUTE_INIT
8107 | OPTI_TYPE_PRECOMPUTE_MERKLE
8108 | OPTI_TYPE_EARLY_SKIP
8109 | OPTI_TYPE_NOT_ITERATED
8110 | OPTI_TYPE_APPENDED_SALT
8111 | OPTI_TYPE_USES_BITS_64
8112 | OPTI_TYPE_RAW_HASH;
8113 dgst_pos0 = 14;
8114 dgst_pos1 = 15;
8115 dgst_pos2 = 6;
8116 dgst_pos3 = 7;
8117 break;
8118
8119 case 1731: hash_type = HASH_TYPE_SHA512;
8120 salt_type = SALT_TYPE_EMBEDDED;
8121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8122 opts_type = OPTS_TYPE_PT_GENERATE_BE
8123 | OPTS_TYPE_PT_UNICODE
8124 | OPTS_TYPE_ST_ADD80
8125 | OPTS_TYPE_ST_ADDBITS15
8126 | OPTS_TYPE_ST_HEX;
8127 kern_type = KERN_TYPE_SHA512_PWSLTU;
8128 dgst_size = DGST_SIZE_8_8;
8129 parse_func = mssql2012_parse_hash;
8130 sort_by_digest = sort_by_digest_8_8;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_PRECOMPUTE_INIT
8133 | OPTI_TYPE_PRECOMPUTE_MERKLE
8134 | OPTI_TYPE_EARLY_SKIP
8135 | OPTI_TYPE_NOT_ITERATED
8136 | OPTI_TYPE_APPENDED_SALT
8137 | OPTI_TYPE_USES_BITS_64
8138 | OPTI_TYPE_RAW_HASH;
8139 dgst_pos0 = 14;
8140 dgst_pos1 = 15;
8141 dgst_pos2 = 6;
8142 dgst_pos3 = 7;
8143 break;
8144
8145 case 1740: hash_type = HASH_TYPE_SHA512;
8146 salt_type = SALT_TYPE_INTERN;
8147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_BE
8149 | OPTS_TYPE_PT_ADD80
8150 | OPTS_TYPE_PT_ADDBITS15
8151 | OPTS_TYPE_PT_UNICODE;
8152 kern_type = KERN_TYPE_SHA512_SLTPWU;
8153 dgst_size = DGST_SIZE_8_8;
8154 parse_func = sha512s_parse_hash;
8155 sort_by_digest = sort_by_digest_8_8;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_PRECOMPUTE_INIT
8158 | OPTI_TYPE_PRECOMPUTE_MERKLE
8159 | OPTI_TYPE_EARLY_SKIP
8160 | OPTI_TYPE_NOT_ITERATED
8161 | OPTI_TYPE_PREPENDED_SALT
8162 | OPTI_TYPE_USES_BITS_64
8163 | OPTI_TYPE_RAW_HASH;
8164 dgst_pos0 = 14;
8165 dgst_pos1 = 15;
8166 dgst_pos2 = 6;
8167 dgst_pos3 = 7;
8168 break;
8169
8170 case 1750: hash_type = HASH_TYPE_SHA512;
8171 salt_type = SALT_TYPE_INTERN;
8172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8173 opts_type = OPTS_TYPE_PT_GENERATE_BE
8174 | OPTS_TYPE_ST_ADD80;
8175 kern_type = KERN_TYPE_HMACSHA512_PW;
8176 dgst_size = DGST_SIZE_8_8;
8177 parse_func = hmacsha512_parse_hash;
8178 sort_by_digest = sort_by_digest_8_8;
8179 opti_type = OPTI_TYPE_ZERO_BYTE
8180 | OPTI_TYPE_USES_BITS_64
8181 | OPTI_TYPE_NOT_ITERATED;
8182 dgst_pos0 = 14;
8183 dgst_pos1 = 15;
8184 dgst_pos2 = 6;
8185 dgst_pos3 = 7;
8186 break;
8187
8188 case 1760: hash_type = HASH_TYPE_SHA512;
8189 salt_type = SALT_TYPE_INTERN;
8190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8191 opts_type = OPTS_TYPE_PT_GENERATE_BE
8192 | OPTS_TYPE_PT_ADD80
8193 | OPTS_TYPE_PT_ADDBITS15;
8194 kern_type = KERN_TYPE_HMACSHA512_SLT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = hmacsha512_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_USES_BITS_64
8200 | OPTI_TYPE_NOT_ITERATED;
8201 dgst_pos0 = 14;
8202 dgst_pos1 = 15;
8203 dgst_pos2 = 6;
8204 dgst_pos3 = 7;
8205 break;
8206
8207 case 1800: hash_type = HASH_TYPE_SHA512;
8208 salt_type = SALT_TYPE_EMBEDDED;
8209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8211 kern_type = KERN_TYPE_SHA512CRYPT;
8212 dgst_size = DGST_SIZE_8_8;
8213 parse_func = sha512crypt_parse_hash;
8214 sort_by_digest = sort_by_digest_8_8;
8215 opti_type = OPTI_TYPE_ZERO_BYTE
8216 | OPTI_TYPE_USES_BITS_64;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 1;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 3;
8221 break;
8222
8223 case 2100: hash_type = HASH_TYPE_DCC2;
8224 salt_type = SALT_TYPE_EMBEDDED;
8225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8227 | OPTS_TYPE_ST_LOWER
8228 | OPTS_TYPE_ST_UNICODE;
8229 kern_type = KERN_TYPE_DCC2;
8230 dgst_size = DGST_SIZE_4_4;
8231 parse_func = dcc2_parse_hash;
8232 sort_by_digest = sort_by_digest_4_4;
8233 opti_type = OPTI_TYPE_ZERO_BYTE;
8234 dgst_pos0 = 0;
8235 dgst_pos1 = 1;
8236 dgst_pos2 = 2;
8237 dgst_pos3 = 3;
8238 break;
8239
8240 case 2400: hash_type = HASH_TYPE_MD5;
8241 salt_type = SALT_TYPE_NONE;
8242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8244 kern_type = KERN_TYPE_MD5PIX;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = md5pix_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_EARLY_SKIP
8252 | OPTI_TYPE_NOT_ITERATED
8253 | OPTI_TYPE_NOT_SALTED;
8254 dgst_pos0 = 0;
8255 dgst_pos1 = 3;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 1;
8258 break;
8259
8260 case 2410: hash_type = HASH_TYPE_MD5;
8261 salt_type = SALT_TYPE_INTERN;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8264 kern_type = KERN_TYPE_MD5ASA;
8265 dgst_size = DGST_SIZE_4_4;
8266 parse_func = md5asa_parse_hash;
8267 sort_by_digest = sort_by_digest_4_4;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_PRECOMPUTE_INIT
8270 | OPTI_TYPE_PRECOMPUTE_MERKLE
8271 | OPTI_TYPE_EARLY_SKIP
8272 | OPTI_TYPE_NOT_ITERATED;
8273 dgst_pos0 = 0;
8274 dgst_pos1 = 3;
8275 dgst_pos2 = 2;
8276 dgst_pos3 = 1;
8277 break;
8278
8279 case 2500: hash_type = HASH_TYPE_WPA;
8280 salt_type = SALT_TYPE_EMBEDDED;
8281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8283 kern_type = KERN_TYPE_WPA;
8284 dgst_size = DGST_SIZE_4_4;
8285 parse_func = wpa_parse_hash;
8286 sort_by_digest = sort_by_digest_4_4;
8287 opti_type = OPTI_TYPE_ZERO_BYTE;
8288 dgst_pos0 = 0;
8289 dgst_pos1 = 1;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 3;
8292 break;
8293
8294 case 2600: hash_type = HASH_TYPE_MD5;
8295 salt_type = SALT_TYPE_VIRTUAL;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_LE
8298 | OPTS_TYPE_PT_ADD80
8299 | OPTS_TYPE_PT_ADDBITS14
8300 | OPTS_TYPE_ST_ADD80;
8301 kern_type = KERN_TYPE_MD55_PWSLT1;
8302 dgst_size = DGST_SIZE_4_4;
8303 parse_func = md5md5_parse_hash;
8304 sort_by_digest = sort_by_digest_4_4;
8305 opti_type = OPTI_TYPE_ZERO_BYTE
8306 | OPTI_TYPE_PRECOMPUTE_INIT
8307 | OPTI_TYPE_PRECOMPUTE_MERKLE
8308 | OPTI_TYPE_EARLY_SKIP;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 3;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 1;
8313 break;
8314
8315 case 2611: hash_type = HASH_TYPE_MD5;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14
8321 | OPTS_TYPE_ST_ADD80;
8322 kern_type = KERN_TYPE_MD55_PWSLT1;
8323 dgst_size = DGST_SIZE_4_4;
8324 parse_func = vb3_parse_hash;
8325 sort_by_digest = sort_by_digest_4_4;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP;
8330 dgst_pos0 = 0;
8331 dgst_pos1 = 3;
8332 dgst_pos2 = 2;
8333 dgst_pos3 = 1;
8334 break;
8335
8336 case 2612: hash_type = HASH_TYPE_MD5;
8337 salt_type = SALT_TYPE_EMBEDDED;
8338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8339 opts_type = OPTS_TYPE_PT_GENERATE_LE
8340 | OPTS_TYPE_PT_ADD80
8341 | OPTS_TYPE_PT_ADDBITS14
8342 | OPTS_TYPE_ST_ADD80
8343 | OPTS_TYPE_ST_HEX;
8344 kern_type = KERN_TYPE_MD55_PWSLT1;
8345 dgst_size = DGST_SIZE_4_4;
8346 parse_func = phps_parse_hash;
8347 sort_by_digest = sort_by_digest_4_4;
8348 opti_type = OPTI_TYPE_ZERO_BYTE
8349 | OPTI_TYPE_PRECOMPUTE_INIT
8350 | OPTI_TYPE_PRECOMPUTE_MERKLE
8351 | OPTI_TYPE_EARLY_SKIP;
8352 dgst_pos0 = 0;
8353 dgst_pos1 = 3;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 1;
8356 break;
8357
8358 case 2711: hash_type = HASH_TYPE_MD5;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_LE
8362 | OPTS_TYPE_PT_ADD80
8363 | OPTS_TYPE_PT_ADDBITS14
8364 | OPTS_TYPE_ST_ADD80;
8365 kern_type = KERN_TYPE_MD55_PWSLT2;
8366 dgst_size = DGST_SIZE_4_4;
8367 parse_func = vb30_parse_hash;
8368 sort_by_digest = sort_by_digest_4_4;
8369 opti_type = OPTI_TYPE_ZERO_BYTE
8370 | OPTI_TYPE_PRECOMPUTE_INIT
8371 | OPTI_TYPE_EARLY_SKIP;
8372 dgst_pos0 = 0;
8373 dgst_pos1 = 3;
8374 dgst_pos2 = 2;
8375 dgst_pos3 = 1;
8376 break;
8377
8378 case 2811: hash_type = HASH_TYPE_MD5;
8379 salt_type = SALT_TYPE_INTERN;
8380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8381 opts_type = OPTS_TYPE_PT_GENERATE_LE
8382 | OPTS_TYPE_PT_ADD80
8383 | OPTS_TYPE_PT_ADDBITS14;
8384 kern_type = KERN_TYPE_MD55_SLTPW;
8385 dgst_size = DGST_SIZE_4_4;
8386 parse_func = ipb2_parse_hash;
8387 sort_by_digest = sort_by_digest_4_4;
8388 opti_type = OPTI_TYPE_ZERO_BYTE
8389 | OPTI_TYPE_PRECOMPUTE_INIT
8390 | OPTI_TYPE_EARLY_SKIP;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 3;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 1;
8395 break;
8396
8397 case 3000: hash_type = HASH_TYPE_LM;
8398 salt_type = SALT_TYPE_NONE;
8399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_PT_UPPER
8402 | OPTS_TYPE_PT_BITSLICE;
8403 kern_type = KERN_TYPE_LM;
8404 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8405 parse_func = lm_parse_hash;
8406 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 3100: hash_type = HASH_TYPE_ORACLEH;
8416 salt_type = SALT_TYPE_INTERN;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_LE
8419 | OPTS_TYPE_PT_UPPER
8420 | OPTS_TYPE_ST_UPPER;
8421 kern_type = KERN_TYPE_ORACLEH;
8422 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8423 parse_func = oracleh_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8425 opti_type = OPTI_TYPE_ZERO_BYTE;
8426 dgst_pos0 = 0;
8427 dgst_pos1 = 1;
8428 dgst_pos2 = 2;
8429 dgst_pos3 = 3;
8430 break;
8431
8432 case 3200: hash_type = HASH_TYPE_BCRYPT;
8433 salt_type = SALT_TYPE_EMBEDDED;
8434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_LE
8436 | OPTS_TYPE_ST_GENERATE_LE;
8437 kern_type = KERN_TYPE_BCRYPT;
8438 dgst_size = DGST_SIZE_4_6;
8439 parse_func = bcrypt_parse_hash;
8440 sort_by_digest = sort_by_digest_4_6;
8441 opti_type = OPTI_TYPE_ZERO_BYTE;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 1;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 3;
8446 break;
8447
8448 case 3710: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE
8452 | OPTS_TYPE_PT_ADD80
8453 | OPTS_TYPE_PT_ADDBITS14;
8454 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8455 dgst_size = DGST_SIZE_4_4;
8456 parse_func = md5s_parse_hash;
8457 sort_by_digest = sort_by_digest_4_4;
8458 opti_type = OPTI_TYPE_ZERO_BYTE
8459 | OPTI_TYPE_PRECOMPUTE_INIT
8460 | OPTI_TYPE_PRECOMPUTE_MERKLE
8461 | OPTI_TYPE_EARLY_SKIP;
8462 dgst_pos0 = 0;
8463 dgst_pos1 = 3;
8464 dgst_pos2 = 2;
8465 dgst_pos3 = 1;
8466 break;
8467
8468 case 3711: hash_type = HASH_TYPE_MD5;
8469 salt_type = SALT_TYPE_EMBEDDED;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_LE
8472 | OPTS_TYPE_PT_ADD80
8473 | OPTS_TYPE_PT_ADDBITS14;
8474 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8475 dgst_size = DGST_SIZE_4_4;
8476 parse_func = mediawiki_b_parse_hash;
8477 sort_by_digest = sort_by_digest_4_4;
8478 opti_type = OPTI_TYPE_ZERO_BYTE
8479 | OPTI_TYPE_PRECOMPUTE_INIT
8480 | OPTI_TYPE_PRECOMPUTE_MERKLE
8481 | OPTI_TYPE_EARLY_SKIP;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 3;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 1;
8486 break;
8487
8488 case 3800: hash_type = HASH_TYPE_MD5;
8489 salt_type = SALT_TYPE_INTERN;
8490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE
8492 | OPTS_TYPE_ST_ADDBITS14;
8493 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = md5s_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_ITERATED
8502 | OPTI_TYPE_RAW_HASH;
8503 dgst_pos0 = 0;
8504 dgst_pos1 = 3;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 1;
8507 break;
8508
8509 case 4300: hash_type = HASH_TYPE_MD5;
8510 salt_type = SALT_TYPE_VIRTUAL;
8511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE
8513 | OPTS_TYPE_PT_ADD80
8514 | OPTS_TYPE_PT_ADDBITS14
8515 | OPTS_TYPE_ST_ADD80;
8516 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8517 dgst_size = DGST_SIZE_4_4;
8518 parse_func = md5md5_parse_hash;
8519 sort_by_digest = sort_by_digest_4_4;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 3;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530
8531 case 4400: hash_type = HASH_TYPE_MD5;
8532 salt_type = SALT_TYPE_NONE;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_BE
8535 | OPTS_TYPE_PT_ADD80
8536 | OPTS_TYPE_PT_ADDBITS15;
8537 kern_type = KERN_TYPE_MD5_SHA1;
8538 dgst_size = DGST_SIZE_4_4;
8539 parse_func = md5_parse_hash;
8540 sort_by_digest = sort_by_digest_4_4;
8541 opti_type = OPTI_TYPE_ZERO_BYTE
8542 | OPTI_TYPE_PRECOMPUTE_INIT
8543 | OPTI_TYPE_PRECOMPUTE_MERKLE
8544 | OPTI_TYPE_EARLY_SKIP
8545 | OPTI_TYPE_NOT_ITERATED
8546 | OPTI_TYPE_NOT_SALTED
8547 | OPTI_TYPE_RAW_HASH;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 3;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 1;
8552 break;
8553
8554 case 4500: hash_type = HASH_TYPE_SHA1;
8555 salt_type = SALT_TYPE_NONE;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_BE
8558 | OPTS_TYPE_PT_ADD80
8559 | OPTS_TYPE_PT_ADDBITS15;
8560 kern_type = KERN_TYPE_SHA11;
8561 dgst_size = DGST_SIZE_4_5;
8562 parse_func = sha1_parse_hash;
8563 sort_by_digest = sort_by_digest_4_5;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_PRECOMPUTE_MERKLE
8567 | OPTI_TYPE_EARLY_SKIP
8568 | OPTI_TYPE_NOT_SALTED;
8569 dgst_pos0 = 3;
8570 dgst_pos1 = 4;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 1;
8573 break;
8574
8575 case 4700: hash_type = HASH_TYPE_SHA1;
8576 salt_type = SALT_TYPE_NONE;
8577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE
8579 | OPTS_TYPE_PT_ADD80
8580 | OPTS_TYPE_PT_ADDBITS14;
8581 kern_type = KERN_TYPE_SHA1_MD5;
8582 dgst_size = DGST_SIZE_4_5;
8583 parse_func = sha1_parse_hash;
8584 sort_by_digest = sort_by_digest_4_5;
8585 opti_type = OPTI_TYPE_ZERO_BYTE
8586 | OPTI_TYPE_PRECOMPUTE_INIT
8587 | OPTI_TYPE_PRECOMPUTE_MERKLE
8588 | OPTI_TYPE_EARLY_SKIP
8589 | OPTI_TYPE_NOT_ITERATED
8590 | OPTI_TYPE_NOT_SALTED
8591 | OPTI_TYPE_RAW_HASH;
8592 dgst_pos0 = 3;
8593 dgst_pos1 = 4;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 1;
8596 break;
8597
8598 case 4800: hash_type = HASH_TYPE_MD5;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_PT_ADDBITS14;
8603 kern_type = KERN_TYPE_MD5_CHAP;
8604 dgst_size = DGST_SIZE_4_4;
8605 parse_func = chap_parse_hash;
8606 sort_by_digest = sort_by_digest_4_4;
8607 opti_type = OPTI_TYPE_ZERO_BYTE
8608 | OPTI_TYPE_PRECOMPUTE_INIT
8609 | OPTI_TYPE_PRECOMPUTE_MERKLE
8610 | OPTI_TYPE_MEET_IN_MIDDLE
8611 | OPTI_TYPE_EARLY_SKIP
8612 | OPTI_TYPE_NOT_ITERATED
8613 | OPTI_TYPE_RAW_HASH;
8614 dgst_pos0 = 0;
8615 dgst_pos1 = 3;
8616 dgst_pos2 = 2;
8617 dgst_pos3 = 1;
8618 break;
8619
8620 case 4900: hash_type = HASH_TYPE_SHA1;
8621 salt_type = SALT_TYPE_INTERN;
8622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8623 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8624 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8625 dgst_size = DGST_SIZE_4_5;
8626 parse_func = sha1s_parse_hash;
8627 sort_by_digest = sort_by_digest_4_5;
8628 opti_type = OPTI_TYPE_ZERO_BYTE
8629 | OPTI_TYPE_PRECOMPUTE_INIT
8630 | OPTI_TYPE_PRECOMPUTE_MERKLE
8631 | OPTI_TYPE_EARLY_SKIP;
8632 dgst_pos0 = 3;
8633 dgst_pos1 = 4;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 5000: hash_type = HASH_TYPE_KECCAK;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE
8642 | OPTS_TYPE_PT_ADD01;
8643 kern_type = KERN_TYPE_KECCAK;
8644 dgst_size = DGST_SIZE_8_25;
8645 parse_func = keccak_parse_hash;
8646 sort_by_digest = sort_by_digest_8_25;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_USES_BITS_64
8649 | OPTI_TYPE_RAW_HASH;
8650 dgst_pos0 = 2;
8651 dgst_pos1 = 3;
8652 dgst_pos2 = 4;
8653 dgst_pos3 = 5;
8654 break;
8655
8656 case 5100: hash_type = HASH_TYPE_MD5H;
8657 salt_type = SALT_TYPE_NONE;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_LE
8660 | OPTS_TYPE_PT_ADD80
8661 | OPTS_TYPE_PT_ADDBITS14;
8662 kern_type = KERN_TYPE_MD5H;
8663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8664 parse_func = md5half_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_RAW_HASH;
8668 dgst_pos0 = 0;
8669 dgst_pos1 = 1;
8670 dgst_pos2 = 2;
8671 dgst_pos3 = 3;
8672 break;
8673
8674 case 5200: hash_type = HASH_TYPE_SHA256;
8675 salt_type = SALT_TYPE_EMBEDDED;
8676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8677 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8678 kern_type = KERN_TYPE_PSAFE3;
8679 dgst_size = DGST_SIZE_4_8;
8680 parse_func = psafe3_parse_hash;
8681 sort_by_digest = sort_by_digest_4_8;
8682 opti_type = OPTI_TYPE_ZERO_BYTE;
8683 dgst_pos0 = 0;
8684 dgst_pos1 = 1;
8685 dgst_pos2 = 2;
8686 dgst_pos3 = 3;
8687 break;
8688
8689 case 5300: hash_type = HASH_TYPE_MD5;
8690 salt_type = SALT_TYPE_EMBEDDED;
8691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8692 opts_type = OPTS_TYPE_PT_GENERATE_LE
8693 | OPTS_TYPE_ST_ADD80;
8694 kern_type = KERN_TYPE_IKEPSK_MD5;
8695 dgst_size = DGST_SIZE_4_4;
8696 parse_func = ikepsk_md5_parse_hash;
8697 sort_by_digest = sort_by_digest_4_4;
8698 opti_type = OPTI_TYPE_ZERO_BYTE;
8699 dgst_pos0 = 0;
8700 dgst_pos1 = 3;
8701 dgst_pos2 = 2;
8702 dgst_pos3 = 1;
8703 break;
8704
8705 case 5400: hash_type = HASH_TYPE_SHA1;
8706 salt_type = SALT_TYPE_EMBEDDED;
8707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8708 opts_type = OPTS_TYPE_PT_GENERATE_BE
8709 | OPTS_TYPE_ST_ADD80;
8710 kern_type = KERN_TYPE_IKEPSK_SHA1;
8711 dgst_size = DGST_SIZE_4_5;
8712 parse_func = ikepsk_sha1_parse_hash;
8713 sort_by_digest = sort_by_digest_4_5;
8714 opti_type = OPTI_TYPE_ZERO_BYTE;
8715 dgst_pos0 = 3;
8716 dgst_pos1 = 4;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 1;
8719 break;
8720
8721 case 5500: hash_type = HASH_TYPE_NETNTLM;
8722 salt_type = SALT_TYPE_EMBEDDED;
8723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_LE
8725 | OPTS_TYPE_PT_ADD80
8726 | OPTS_TYPE_PT_ADDBITS14
8727 | OPTS_TYPE_PT_UNICODE
8728 | OPTS_TYPE_ST_HEX;
8729 kern_type = KERN_TYPE_NETNTLMv1;
8730 dgst_size = DGST_SIZE_4_4;
8731 parse_func = netntlmv1_parse_hash;
8732 sort_by_digest = sort_by_digest_4_4;
8733 opti_type = OPTI_TYPE_ZERO_BYTE
8734 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8735 dgst_pos0 = 0;
8736 dgst_pos1 = 1;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 3;
8739 break;
8740
8741 case 5600: hash_type = HASH_TYPE_MD5;
8742 salt_type = SALT_TYPE_EMBEDDED;
8743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE
8745 | OPTS_TYPE_PT_ADD80
8746 | OPTS_TYPE_PT_ADDBITS14
8747 | OPTS_TYPE_PT_UNICODE;
8748 kern_type = KERN_TYPE_NETNTLMv2;
8749 dgst_size = DGST_SIZE_4_4;
8750 parse_func = netntlmv2_parse_hash;
8751 sort_by_digest = sort_by_digest_4_4;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 3;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 1;
8757 break;
8758
8759 case 5700: hash_type = HASH_TYPE_SHA256;
8760 salt_type = SALT_TYPE_NONE;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_BE
8763 | OPTS_TYPE_PT_ADD80
8764 | OPTS_TYPE_PT_ADDBITS15;
8765 kern_type = KERN_TYPE_SHA256;
8766 dgst_size = DGST_SIZE_4_8;
8767 parse_func = cisco4_parse_hash;
8768 sort_by_digest = sort_by_digest_4_8;
8769 opti_type = OPTI_TYPE_ZERO_BYTE
8770 | OPTI_TYPE_PRECOMPUTE_INIT
8771 | OPTI_TYPE_PRECOMPUTE_MERKLE
8772 | OPTI_TYPE_EARLY_SKIP
8773 | OPTI_TYPE_NOT_ITERATED
8774 | OPTI_TYPE_NOT_SALTED
8775 | OPTI_TYPE_RAW_HASH;
8776 dgst_pos0 = 3;
8777 dgst_pos1 = 7;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 6;
8780 break;
8781
8782 case 5800: hash_type = HASH_TYPE_SHA1;
8783 salt_type = SALT_TYPE_INTERN;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8786 | OPTS_TYPE_ST_ADD80;
8787 kern_type = KERN_TYPE_ANDROIDPIN;
8788 dgst_size = DGST_SIZE_4_5;
8789 parse_func = androidpin_parse_hash;
8790 sort_by_digest = sort_by_digest_4_5;
8791 opti_type = OPTI_TYPE_ZERO_BYTE;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8799 salt_type = SALT_TYPE_NONE;
8800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE
8802 | OPTS_TYPE_PT_ADD80;
8803 kern_type = KERN_TYPE_RIPEMD160;
8804 dgst_size = DGST_SIZE_4_5;
8805 parse_func = ripemd160_parse_hash;
8806 sort_by_digest = sort_by_digest_4_5;
8807 opti_type = OPTI_TYPE_ZERO_BYTE;
8808 dgst_pos0 = 0;
8809 dgst_pos1 = 1;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 3;
8812 break;
8813
8814 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8815 salt_type = SALT_TYPE_NONE;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_BE
8818 | OPTS_TYPE_PT_ADD80;
8819 kern_type = KERN_TYPE_WHIRLPOOL;
8820 dgst_size = DGST_SIZE_4_16;
8821 parse_func = whirlpool_parse_hash;
8822 sort_by_digest = sort_by_digest_4_16;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8834 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8835 dgst_size = DGST_SIZE_4_5;
8836 parse_func = truecrypt_parse_hash_2k;
8837 sort_by_digest = sort_by_digest_4_5;
8838 opti_type = OPTI_TYPE_ZERO_BYTE;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8849 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8850 dgst_size = DGST_SIZE_4_5;
8851 parse_func = truecrypt_parse_hash_2k;
8852 sort_by_digest = sort_by_digest_4_5;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8864 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8865 dgst_size = DGST_SIZE_4_5;
8866 parse_func = truecrypt_parse_hash_2k;
8867 sort_by_digest = sort_by_digest_4_5;
8868 opti_type = OPTI_TYPE_ZERO_BYTE;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 6221: hash_type = HASH_TYPE_SHA512;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8879 kern_type = KERN_TYPE_TCSHA512_XTS512;
8880 dgst_size = DGST_SIZE_8_8;
8881 parse_func = truecrypt_parse_hash_1k;
8882 sort_by_digest = sort_by_digest_8_8;
8883 opti_type = OPTI_TYPE_ZERO_BYTE
8884 | OPTI_TYPE_USES_BITS_64;
8885 dgst_pos0 = 0;
8886 dgst_pos1 = 1;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 3;
8889 break;
8890
8891 case 6222: hash_type = HASH_TYPE_SHA512;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8895 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8896 dgst_size = DGST_SIZE_8_8;
8897 parse_func = truecrypt_parse_hash_1k;
8898 sort_by_digest = sort_by_digest_8_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE
8900 | OPTI_TYPE_USES_BITS_64;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 6223: hash_type = HASH_TYPE_SHA512;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8911 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8912 dgst_size = DGST_SIZE_8_8;
8913 parse_func = truecrypt_parse_hash_1k;
8914 sort_by_digest = sort_by_digest_8_8;
8915 opti_type = OPTI_TYPE_ZERO_BYTE
8916 | OPTI_TYPE_USES_BITS_64;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8927 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8928 dgst_size = DGST_SIZE_4_8;
8929 parse_func = truecrypt_parse_hash_1k;
8930 sort_by_digest = sort_by_digest_4_8;
8931 opti_type = OPTI_TYPE_ZERO_BYTE;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 1;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 3;
8936 break;
8937
8938 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8939 salt_type = SALT_TYPE_EMBEDDED;
8940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8942 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8943 dgst_size = DGST_SIZE_4_8;
8944 parse_func = truecrypt_parse_hash_1k;
8945 sort_by_digest = sort_by_digest_4_8;
8946 opti_type = OPTI_TYPE_ZERO_BYTE;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 1;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 3;
8951 break;
8952
8953 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8954 salt_type = SALT_TYPE_EMBEDDED;
8955 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8956 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8957 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8958 dgst_size = DGST_SIZE_4_8;
8959 parse_func = truecrypt_parse_hash_1k;
8960 sort_by_digest = sort_by_digest_4_8;
8961 opti_type = OPTI_TYPE_ZERO_BYTE;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8969 salt_type = SALT_TYPE_EMBEDDED;
8970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8972 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8973 dgst_size = DGST_SIZE_4_5;
8974 parse_func = truecrypt_parse_hash_1k;
8975 sort_by_digest = sort_by_digest_4_5;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8987 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8988 dgst_size = DGST_SIZE_4_5;
8989 parse_func = truecrypt_parse_hash_1k;
8990 sort_by_digest = sort_by_digest_4_5;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9002 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9003 dgst_size = DGST_SIZE_4_5;
9004 parse_func = truecrypt_parse_hash_1k;
9005 sort_by_digest = sort_by_digest_4_5;
9006 opti_type = OPTI_TYPE_ZERO_BYTE;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 6300: hash_type = HASH_TYPE_MD5;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9017 kern_type = KERN_TYPE_MD5AIX;
9018 dgst_size = DGST_SIZE_4_4;
9019 parse_func = md5aix_parse_hash;
9020 sort_by_digest = sort_by_digest_4_4;
9021 opti_type = OPTI_TYPE_ZERO_BYTE;
9022 dgst_pos0 = 0;
9023 dgst_pos1 = 1;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 3;
9026 break;
9027
9028 case 6400: hash_type = HASH_TYPE_SHA256;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9032 kern_type = KERN_TYPE_SHA256AIX;
9033 dgst_size = DGST_SIZE_4_8;
9034 parse_func = sha256aix_parse_hash;
9035 sort_by_digest = sort_by_digest_4_8;
9036 opti_type = OPTI_TYPE_ZERO_BYTE;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 6500: hash_type = HASH_TYPE_SHA512;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9047 kern_type = KERN_TYPE_SHA512AIX;
9048 dgst_size = DGST_SIZE_8_8;
9049 parse_func = sha512aix_parse_hash;
9050 sort_by_digest = sort_by_digest_8_8;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_USES_BITS_64;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6600: hash_type = HASH_TYPE_AES;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_AGILEKEY;
9064 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9065 parse_func = agilekey_parse_hash;
9066 sort_by_digest = sort_by_digest_4_5;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6700: hash_type = HASH_TYPE_SHA1;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9078 kern_type = KERN_TYPE_SHA1AIX;
9079 dgst_size = DGST_SIZE_4_5;
9080 parse_func = sha1aix_parse_hash;
9081 sort_by_digest = sort_by_digest_4_5;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 6800: hash_type = HASH_TYPE_AES;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9093 kern_type = KERN_TYPE_LASTPASS;
9094 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9095 parse_func = lastpass_parse_hash;
9096 sort_by_digest = sort_by_digest_4_8;
9097 opti_type = OPTI_TYPE_ZERO_BYTE;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 6900: hash_type = HASH_TYPE_GOST;
9105 salt_type = SALT_TYPE_NONE;
9106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9108 kern_type = KERN_TYPE_GOST;
9109 dgst_size = DGST_SIZE_4_8;
9110 parse_func = gost_parse_hash;
9111 sort_by_digest = sort_by_digest_4_8;
9112 opti_type = OPTI_TYPE_ZERO_BYTE;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 7100: hash_type = HASH_TYPE_SHA512;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9123 kern_type = KERN_TYPE_PBKDF2_SHA512;
9124 dgst_size = DGST_SIZE_8_16;
9125 parse_func = sha512osx_parse_hash;
9126 sort_by_digest = sort_by_digest_8_16;
9127 opti_type = OPTI_TYPE_ZERO_BYTE
9128 | OPTI_TYPE_USES_BITS_64;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 1;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 3;
9133 break;
9134
9135 case 7200: hash_type = HASH_TYPE_SHA512;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9139 kern_type = KERN_TYPE_PBKDF2_SHA512;
9140 dgst_size = DGST_SIZE_8_16;
9141 parse_func = sha512grub_parse_hash;
9142 sort_by_digest = sort_by_digest_8_16;
9143 opti_type = OPTI_TYPE_ZERO_BYTE
9144 | OPTI_TYPE_USES_BITS_64;
9145 dgst_pos0 = 0;
9146 dgst_pos1 = 1;
9147 dgst_pos2 = 2;
9148 dgst_pos3 = 3;
9149 break;
9150
9151 case 7300: hash_type = HASH_TYPE_SHA1;
9152 salt_type = SALT_TYPE_EMBEDDED;
9153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9154 opts_type = OPTS_TYPE_PT_GENERATE_BE
9155 | OPTS_TYPE_ST_ADD80
9156 | OPTS_TYPE_ST_ADDBITS15;
9157 kern_type = KERN_TYPE_RAKP;
9158 dgst_size = DGST_SIZE_4_5;
9159 parse_func = rakp_parse_hash;
9160 sort_by_digest = sort_by_digest_4_5;
9161 opti_type = OPTI_TYPE_ZERO_BYTE
9162 | OPTI_TYPE_NOT_ITERATED;
9163 dgst_pos0 = 3;
9164 dgst_pos1 = 4;
9165 dgst_pos2 = 2;
9166 dgst_pos3 = 1;
9167 break;
9168
9169 case 7400: hash_type = HASH_TYPE_SHA256;
9170 salt_type = SALT_TYPE_EMBEDDED;
9171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9172 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9173 kern_type = KERN_TYPE_SHA256CRYPT;
9174 dgst_size = DGST_SIZE_4_8;
9175 parse_func = sha256crypt_parse_hash;
9176 sort_by_digest = sort_by_digest_4_8;
9177 opti_type = OPTI_TYPE_ZERO_BYTE;
9178 dgst_pos0 = 0;
9179 dgst_pos1 = 1;
9180 dgst_pos2 = 2;
9181 dgst_pos3 = 3;
9182 break;
9183
9184 case 7500: hash_type = HASH_TYPE_KRB5PA;
9185 salt_type = SALT_TYPE_EMBEDDED;
9186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9188 kern_type = KERN_TYPE_KRB5PA;
9189 dgst_size = DGST_SIZE_4_4;
9190 parse_func = krb5pa_parse_hash;
9191 sort_by_digest = sort_by_digest_4_4;
9192 opti_type = OPTI_TYPE_ZERO_BYTE
9193 | OPTI_TYPE_NOT_ITERATED;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 7600: hash_type = HASH_TYPE_SHA1;
9201 salt_type = SALT_TYPE_INTERN;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_BE
9204 | OPTS_TYPE_PT_ADD80
9205 | OPTS_TYPE_PT_ADDBITS15;
9206 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9207 dgst_size = DGST_SIZE_4_5;
9208 parse_func = redmine_parse_hash;
9209 sort_by_digest = sort_by_digest_4_5;
9210 opti_type = OPTI_TYPE_ZERO_BYTE
9211 | OPTI_TYPE_PRECOMPUTE_INIT
9212 | OPTI_TYPE_EARLY_SKIP
9213 | OPTI_TYPE_NOT_ITERATED
9214 | OPTI_TYPE_PREPENDED_SALT;
9215 dgst_pos0 = 3;
9216 dgst_pos1 = 4;
9217 dgst_pos2 = 2;
9218 dgst_pos3 = 1;
9219 break;
9220
9221 case 7700: hash_type = HASH_TYPE_SAPB;
9222 salt_type = SALT_TYPE_EMBEDDED;
9223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9224 opts_type = OPTS_TYPE_PT_GENERATE_LE
9225 | OPTS_TYPE_PT_UPPER
9226 | OPTS_TYPE_ST_UPPER;
9227 kern_type = KERN_TYPE_SAPB;
9228 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9229 parse_func = sapb_parse_hash;
9230 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9231 opti_type = OPTI_TYPE_ZERO_BYTE
9232 | OPTI_TYPE_PRECOMPUTE_INIT
9233 | OPTI_TYPE_NOT_ITERATED;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 7800: hash_type = HASH_TYPE_SAPG;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_BE
9244 | OPTS_TYPE_ST_ADD80
9245 | OPTS_TYPE_ST_UPPER;
9246 kern_type = KERN_TYPE_SAPG;
9247 dgst_size = DGST_SIZE_4_5;
9248 parse_func = sapg_parse_hash;
9249 sort_by_digest = sort_by_digest_4_5;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_PRECOMPUTE_INIT
9252 | OPTI_TYPE_NOT_ITERATED;
9253 dgst_pos0 = 3;
9254 dgst_pos1 = 4;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 1;
9257 break;
9258
9259 case 7900: hash_type = HASH_TYPE_SHA512;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9263 kern_type = KERN_TYPE_DRUPAL7;
9264 dgst_size = DGST_SIZE_8_8;
9265 parse_func = drupal7_parse_hash;
9266 sort_by_digest = sort_by_digest_8_8;
9267 opti_type = OPTI_TYPE_ZERO_BYTE
9268 | OPTI_TYPE_USES_BITS_64;
9269 dgst_pos0 = 0;
9270 dgst_pos1 = 1;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 3;
9273 break;
9274
9275 case 8000: hash_type = HASH_TYPE_SHA256;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_BE
9279 | OPTS_TYPE_PT_UNICODE
9280 | OPTS_TYPE_ST_ADD80
9281 | OPTS_TYPE_ST_HEX;
9282 kern_type = KERN_TYPE_SYBASEASE;
9283 dgst_size = DGST_SIZE_4_8;
9284 parse_func = sybasease_parse_hash;
9285 sort_by_digest = sort_by_digest_4_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE
9287 | OPTI_TYPE_PRECOMPUTE_INIT
9288 | OPTI_TYPE_EARLY_SKIP
9289 | OPTI_TYPE_NOT_ITERATED
9290 | OPTI_TYPE_RAW_HASH;
9291 dgst_pos0 = 3;
9292 dgst_pos1 = 7;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 6;
9295 break;
9296
9297 case 8100: hash_type = HASH_TYPE_SHA1;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9301 kern_type = KERN_TYPE_NETSCALER;
9302 dgst_size = DGST_SIZE_4_5;
9303 parse_func = netscaler_parse_hash;
9304 sort_by_digest = sort_by_digest_4_5;
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_PRECOMPUTE_INIT
9307 | OPTI_TYPE_PRECOMPUTE_MERKLE
9308 | OPTI_TYPE_EARLY_SKIP
9309 | OPTI_TYPE_NOT_ITERATED
9310 | OPTI_TYPE_PREPENDED_SALT
9311 | OPTI_TYPE_RAW_HASH;
9312 dgst_pos0 = 3;
9313 dgst_pos1 = 4;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 1;
9316 break;
9317
9318 case 8200: hash_type = HASH_TYPE_SHA256;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9322 kern_type = KERN_TYPE_CLOUDKEY;
9323 dgst_size = DGST_SIZE_4_8;
9324 parse_func = cloudkey_parse_hash;
9325 sort_by_digest = sort_by_digest_4_8;
9326 opti_type = OPTI_TYPE_ZERO_BYTE;
9327 dgst_pos0 = 0;
9328 dgst_pos1 = 1;
9329 dgst_pos2 = 2;
9330 dgst_pos3 = 3;
9331 break;
9332
9333 case 8300: hash_type = HASH_TYPE_SHA1;
9334 salt_type = SALT_TYPE_EMBEDDED;
9335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9336 opts_type = OPTS_TYPE_PT_GENERATE_BE
9337 | OPTS_TYPE_ST_HEX
9338 | OPTS_TYPE_ST_ADD80;
9339 kern_type = KERN_TYPE_NSEC3;
9340 dgst_size = DGST_SIZE_4_5;
9341 parse_func = nsec3_parse_hash;
9342 sort_by_digest = sort_by_digest_4_5;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 3;
9345 dgst_pos1 = 4;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 1;
9348 break;
9349
9350 case 8400: hash_type = HASH_TYPE_SHA1;
9351 salt_type = SALT_TYPE_INTERN;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_BE
9354 | OPTS_TYPE_PT_ADD80
9355 | OPTS_TYPE_PT_ADDBITS15;
9356 kern_type = KERN_TYPE_WBB3;
9357 dgst_size = DGST_SIZE_4_5;
9358 parse_func = wbb3_parse_hash;
9359 sort_by_digest = sort_by_digest_4_5;
9360 opti_type = OPTI_TYPE_ZERO_BYTE
9361 | OPTI_TYPE_PRECOMPUTE_INIT
9362 | OPTI_TYPE_NOT_ITERATED;
9363 dgst_pos0 = 3;
9364 dgst_pos1 = 4;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 1;
9367 break;
9368
9369 case 8500: hash_type = HASH_TYPE_DESRACF;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE
9373 | OPTS_TYPE_ST_UPPER;
9374 kern_type = KERN_TYPE_RACF;
9375 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9376 parse_func = racf_parse_hash;
9377 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 8600: hash_type = HASH_TYPE_LOTUS5;
9387 salt_type = SALT_TYPE_NONE;
9388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9390 kern_type = KERN_TYPE_LOTUS5;
9391 dgst_size = DGST_SIZE_4_4;
9392 parse_func = lotus5_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4;
9394 opti_type = OPTI_TYPE_EARLY_SKIP
9395 | OPTI_TYPE_NOT_ITERATED
9396 | OPTI_TYPE_NOT_SALTED
9397 | OPTI_TYPE_RAW_HASH;
9398 dgst_pos0 = 0;
9399 dgst_pos1 = 1;
9400 dgst_pos2 = 2;
9401 dgst_pos3 = 3;
9402 break;
9403
9404 case 8700: hash_type = HASH_TYPE_LOTUS6;
9405 salt_type = SALT_TYPE_EMBEDDED;
9406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9408 kern_type = KERN_TYPE_LOTUS6;
9409 dgst_size = DGST_SIZE_4_4;
9410 parse_func = lotus6_parse_hash;
9411 sort_by_digest = sort_by_digest_4_4;
9412 opti_type = OPTI_TYPE_EARLY_SKIP
9413 | OPTI_TYPE_NOT_ITERATED
9414 | OPTI_TYPE_RAW_HASH;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9425 kern_type = KERN_TYPE_ANDROIDFDE;
9426 dgst_size = DGST_SIZE_4_4;
9427 parse_func = androidfde_parse_hash;
9428 sort_by_digest = sort_by_digest_4_4;
9429 opti_type = OPTI_TYPE_ZERO_BYTE;
9430 dgst_pos0 = 0;
9431 dgst_pos1 = 1;
9432 dgst_pos2 = 2;
9433 dgst_pos3 = 3;
9434 break;
9435
9436 case 8900: hash_type = HASH_TYPE_SCRYPT;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9440 kern_type = KERN_TYPE_SCRYPT;
9441 dgst_size = DGST_SIZE_4_8;
9442 parse_func = scrypt_parse_hash;
9443 sort_by_digest = sort_by_digest_4_8;
9444 opti_type = OPTI_TYPE_ZERO_BYTE;
9445 dgst_pos0 = 0;
9446 dgst_pos1 = 1;
9447 dgst_pos2 = 2;
9448 dgst_pos3 = 3;
9449 break;
9450
9451 case 9000: hash_type = HASH_TYPE_SHA1;
9452 salt_type = SALT_TYPE_EMBEDDED;
9453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9454 opts_type = OPTS_TYPE_PT_GENERATE_LE
9455 | OPTS_TYPE_ST_GENERATE_LE;
9456 kern_type = KERN_TYPE_PSAFE2;
9457 dgst_size = DGST_SIZE_4_5;
9458 parse_func = psafe2_parse_hash;
9459 sort_by_digest = sort_by_digest_4_5;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9100: hash_type = HASH_TYPE_LOTUS8;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9471 kern_type = KERN_TYPE_LOTUS8;
9472 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9473 parse_func = lotus8_parse_hash;
9474 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9475 opti_type = OPTI_TYPE_ZERO_BYTE;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 9200: hash_type = HASH_TYPE_SHA256;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9486 kern_type = KERN_TYPE_PBKDF2_SHA256;
9487 dgst_size = DGST_SIZE_4_32;
9488 parse_func = cisco8_parse_hash;
9489 sort_by_digest = sort_by_digest_4_32;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 9300: hash_type = HASH_TYPE_SCRYPT;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_SCRYPT;
9502 dgst_size = DGST_SIZE_4_8;
9503 parse_func = cisco9_parse_hash;
9504 sort_by_digest = sort_by_digest_4_8;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_OFFICE2007;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = office2007_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9531 kern_type = KERN_TYPE_OFFICE2010;
9532 dgst_size = DGST_SIZE_4_4;
9533 parse_func = office2010_parse_hash;
9534 sort_by_digest = sort_by_digest_4_4;
9535 opti_type = OPTI_TYPE_ZERO_BYTE;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9546 kern_type = KERN_TYPE_OFFICE2013;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = office2013_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE
9561 | OPTS_TYPE_PT_ADD80
9562 | OPTS_TYPE_PT_UNICODE;
9563 kern_type = KERN_TYPE_OLDOFFICE01;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = oldoffice01_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE
9568 | OPTI_TYPE_PRECOMPUTE_INIT
9569 | OPTI_TYPE_NOT_ITERATED;
9570 dgst_pos0 = 0;
9571 dgst_pos1 = 1;
9572 dgst_pos2 = 2;
9573 dgst_pos3 = 3;
9574 break;
9575
9576 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9577 salt_type = SALT_TYPE_EMBEDDED;
9578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9579 opts_type = OPTS_TYPE_PT_GENERATE_LE
9580 | OPTS_TYPE_PT_ADD80;
9581 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = oldoffice01cm1_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_ZERO_BYTE
9586 | OPTI_TYPE_PRECOMPUTE_INIT
9587 | OPTI_TYPE_NOT_ITERATED;
9588 dgst_pos0 = 0;
9589 dgst_pos1 = 1;
9590 dgst_pos2 = 2;
9591 dgst_pos3 = 3;
9592 break;
9593
9594 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9595 salt_type = SALT_TYPE_EMBEDDED;
9596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9597 opts_type = OPTS_TYPE_PT_GENERATE_LE
9598 | OPTS_TYPE_PT_ADD80
9599 | OPTS_TYPE_PT_UNICODE
9600 | OPTS_TYPE_PT_NEVERCRACK;
9601 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = oldoffice01cm2_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_NOT_ITERATED;
9608 dgst_pos0 = 0;
9609 dgst_pos1 = 1;
9610 dgst_pos2 = 2;
9611 dgst_pos3 = 3;
9612 break;
9613
9614 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9615 salt_type = SALT_TYPE_EMBEDDED;
9616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9617 opts_type = OPTS_TYPE_PT_GENERATE_BE
9618 | OPTS_TYPE_PT_ADD80
9619 | OPTS_TYPE_PT_UNICODE;
9620 kern_type = KERN_TYPE_OLDOFFICE34;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = oldoffice34_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_PRECOMPUTE_INIT
9626 | OPTI_TYPE_NOT_ITERATED;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9637 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9638 dgst_size = DGST_SIZE_4_4;
9639 parse_func = oldoffice34cm1_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4;
9641 opti_type = OPTI_TYPE_ZERO_BYTE
9642 | OPTI_TYPE_PRECOMPUTE_INIT
9643 | OPTI_TYPE_NOT_ITERATED;
9644 dgst_pos0 = 0;
9645 dgst_pos1 = 1;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 3;
9648 break;
9649
9650 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9653 opts_type = OPTS_TYPE_PT_GENERATE_BE
9654 | OPTS_TYPE_PT_ADD80
9655 | OPTS_TYPE_PT_UNICODE
9656 | OPTS_TYPE_PT_NEVERCRACK;
9657 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9658 dgst_size = DGST_SIZE_4_4;
9659 parse_func = oldoffice34cm2_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_PRECOMPUTE_INIT
9663 | OPTI_TYPE_NOT_ITERATED;
9664 dgst_pos0 = 0;
9665 dgst_pos1 = 1;
9666 dgst_pos2 = 2;
9667 dgst_pos3 = 3;
9668 break;
9669
9670 case 9900: hash_type = HASH_TYPE_MD5;
9671 salt_type = SALT_TYPE_NONE;
9672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9673 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9674 kern_type = KERN_TYPE_RADMIN2;
9675 dgst_size = DGST_SIZE_4_4;
9676 parse_func = radmin2_parse_hash;
9677 sort_by_digest = sort_by_digest_4_4;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_PRECOMPUTE_INIT
9680 | OPTI_TYPE_EARLY_SKIP
9681 | OPTI_TYPE_NOT_ITERATED
9682 | OPTI_TYPE_NOT_SALTED;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 3;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 1;
9687 break;
9688
9689 case 10000: hash_type = HASH_TYPE_SHA256;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9693 kern_type = KERN_TYPE_PBKDF2_SHA256;
9694 dgst_size = DGST_SIZE_4_32;
9695 parse_func = djangopbkdf2_parse_hash;
9696 sort_by_digest = sort_by_digest_4_32;
9697 opti_type = OPTI_TYPE_ZERO_BYTE;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 10100: hash_type = HASH_TYPE_SIPHASH;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9708 kern_type = KERN_TYPE_SIPHASH;
9709 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9710 parse_func = siphash_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9712 opti_type = OPTI_TYPE_ZERO_BYTE
9713 | OPTI_TYPE_NOT_ITERATED
9714 | OPTI_TYPE_RAW_HASH;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 1;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 3;
9719 break;
9720
9721 case 10200: hash_type = HASH_TYPE_MD5;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE
9725 | OPTS_TYPE_ST_ADD80
9726 | OPTS_TYPE_ST_ADDBITS14;
9727 kern_type = KERN_TYPE_HMACMD5_PW;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = crammd5_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 3;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 1;
9737 break;
9738
9739 case 10300: hash_type = HASH_TYPE_SHA1;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9743 kern_type = KERN_TYPE_SAPH_SHA1;
9744 dgst_size = DGST_SIZE_4_5;
9745 parse_func = saph_sha1_parse_hash;
9746 sort_by_digest = sort_by_digest_4_5;
9747 opti_type = OPTI_TYPE_ZERO_BYTE;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 10400: hash_type = HASH_TYPE_PDFU16;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_PDF11;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = pdf11_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 10410: hash_type = HASH_TYPE_PDFU16;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9774 kern_type = KERN_TYPE_PDF11CM1;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = pdf11cm1_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 10420: hash_type = HASH_TYPE_PDFU16;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_PDF11CM2;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = pdf11cm2_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_NOT_ITERATED;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 10500: hash_type = HASH_TYPE_PDFU16;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9806 kern_type = KERN_TYPE_PDF14;
9807 dgst_size = DGST_SIZE_4_4;
9808 parse_func = pdf14_parse_hash;
9809 sort_by_digest = sort_by_digest_4_4;
9810 opti_type = OPTI_TYPE_ZERO_BYTE
9811 | OPTI_TYPE_NOT_ITERATED;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 10600: hash_type = HASH_TYPE_SHA256;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_BE
9822 | OPTS_TYPE_ST_ADD80
9823 | OPTS_TYPE_ST_ADDBITS15
9824 | OPTS_TYPE_HASH_COPY;
9825 kern_type = KERN_TYPE_SHA256_PWSLT;
9826 dgst_size = DGST_SIZE_4_8;
9827 parse_func = pdf17l3_parse_hash;
9828 sort_by_digest = sort_by_digest_4_8;
9829 opti_type = OPTI_TYPE_ZERO_BYTE
9830 | OPTI_TYPE_PRECOMPUTE_INIT
9831 | OPTI_TYPE_PRECOMPUTE_MERKLE
9832 | OPTI_TYPE_EARLY_SKIP
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_APPENDED_SALT
9835 | OPTI_TYPE_RAW_HASH;
9836 dgst_pos0 = 3;
9837 dgst_pos1 = 7;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 6;
9840 break;
9841
9842 case 10700: hash_type = HASH_TYPE_PDFU32;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE
9846 | OPTS_TYPE_HASH_COPY;
9847 kern_type = KERN_TYPE_PDF17L8;
9848 dgst_size = DGST_SIZE_4_8;
9849 parse_func = pdf17l8_parse_hash;
9850 sort_by_digest = sort_by_digest_4_8;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_NOT_ITERATED;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 1;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 3;
9857 break;
9858
9859 case 10800: hash_type = HASH_TYPE_SHA384;
9860 salt_type = SALT_TYPE_NONE;
9861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_BE
9863 | OPTS_TYPE_PT_ADD80
9864 | OPTS_TYPE_PT_ADDBITS15;
9865 kern_type = KERN_TYPE_SHA384;
9866 dgst_size = DGST_SIZE_8_8;
9867 parse_func = sha384_parse_hash;
9868 sort_by_digest = sort_by_digest_8_8;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_PRECOMPUTE_INIT
9871 | OPTI_TYPE_PRECOMPUTE_MERKLE
9872 | OPTI_TYPE_EARLY_SKIP
9873 | OPTI_TYPE_NOT_ITERATED
9874 | OPTI_TYPE_NOT_SALTED
9875 | OPTI_TYPE_USES_BITS_64
9876 | OPTI_TYPE_RAW_HASH;
9877 dgst_pos0 = 6;
9878 dgst_pos1 = 7;
9879 dgst_pos2 = 4;
9880 dgst_pos3 = 5;
9881 break;
9882
9883 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE
9887 | OPTS_TYPE_ST_BASE64
9888 | OPTS_TYPE_HASH_COPY;
9889 kern_type = KERN_TYPE_PBKDF2_SHA256;
9890 dgst_size = DGST_SIZE_4_32;
9891 parse_func = pbkdf2_sha256_parse_hash;
9892 sort_by_digest = sort_by_digest_4_32;
9893 opti_type = OPTI_TYPE_ZERO_BYTE;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 11000: hash_type = HASH_TYPE_MD5;
9901 salt_type = SALT_TYPE_INTERN;
9902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE
9904 | OPTS_TYPE_PT_ADD80;
9905 kern_type = KERN_TYPE_PRESTASHOP;
9906 dgst_size = DGST_SIZE_4_4;
9907 parse_func = prestashop_parse_hash;
9908 sort_by_digest = sort_by_digest_4_4;
9909 opti_type = OPTI_TYPE_ZERO_BYTE
9910 | OPTI_TYPE_PRECOMPUTE_INIT
9911 | OPTI_TYPE_NOT_ITERATED
9912 | OPTI_TYPE_PREPENDED_SALT;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 3;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 1;
9917 break;
9918
9919 case 11100: hash_type = HASH_TYPE_MD5;
9920 salt_type = SALT_TYPE_EMBEDDED;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_ST_ADD80;
9924 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9925 dgst_size = DGST_SIZE_4_4;
9926 parse_func = postgresql_auth_parse_hash;
9927 sort_by_digest = sort_by_digest_4_4;
9928 opti_type = OPTI_TYPE_ZERO_BYTE
9929 | OPTI_TYPE_PRECOMPUTE_INIT
9930 | OPTI_TYPE_PRECOMPUTE_MERKLE
9931 | OPTI_TYPE_EARLY_SKIP;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 3;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 11200: hash_type = HASH_TYPE_SHA1;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_BE
9942 | OPTS_TYPE_PT_ADD80
9943 | OPTS_TYPE_ST_HEX;
9944 kern_type = KERN_TYPE_MYSQL_AUTH;
9945 dgst_size = DGST_SIZE_4_5;
9946 parse_func = mysql_auth_parse_hash;
9947 sort_by_digest = sort_by_digest_4_5;
9948 opti_type = OPTI_TYPE_ZERO_BYTE
9949 | OPTI_TYPE_EARLY_SKIP;
9950 dgst_pos0 = 3;
9951 dgst_pos1 = 4;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 1;
9954 break;
9955
9956 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE
9960 | OPTS_TYPE_ST_HEX
9961 | OPTS_TYPE_ST_ADD80;
9962 kern_type = KERN_TYPE_BITCOIN_WALLET;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = bitcoin_wallet_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_ZERO_BYTE;
9967 dgst_pos0 = 0;
9968 dgst_pos1 = 1;
9969 dgst_pos2 = 2;
9970 dgst_pos3 = 3;
9971 break;
9972
9973 case 11400: hash_type = HASH_TYPE_MD5;
9974 salt_type = SALT_TYPE_EMBEDDED;
9975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9976 opts_type = OPTS_TYPE_PT_GENERATE_LE
9977 | OPTS_TYPE_PT_ADD80
9978 | OPTS_TYPE_HASH_COPY;
9979 kern_type = KERN_TYPE_SIP_AUTH;
9980 dgst_size = DGST_SIZE_4_4;
9981 parse_func = sip_auth_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4;
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 3;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 1;
9988 break;
9989
9990 case 11500: hash_type = HASH_TYPE_CRC32;
9991 salt_type = SALT_TYPE_INTERN;
9992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE
9994 | OPTS_TYPE_ST_GENERATE_LE
9995 | OPTS_TYPE_ST_HEX;
9996 kern_type = KERN_TYPE_CRC32;
9997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9998 parse_func = crc32_parse_hash;
9999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10000 opti_type = OPTI_TYPE_ZERO_BYTE;
10001 dgst_pos0 = 0;
10002 dgst_pos1 = 1;
10003 dgst_pos2 = 2;
10004 dgst_pos3 = 3;
10005 break;
10006
10007 case 11600: hash_type = HASH_TYPE_AES;
10008 salt_type = SALT_TYPE_EMBEDDED;
10009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10010 opts_type = OPTS_TYPE_PT_GENERATE_LE
10011 | OPTS_TYPE_PT_NEVERCRACK;
10012 kern_type = KERN_TYPE_SEVEN_ZIP;
10013 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10014 parse_func = seven_zip_parse_hash;
10015 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10016 opti_type = OPTI_TYPE_ZERO_BYTE;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10024 salt_type = SALT_TYPE_NONE;
10025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE
10027 | OPTS_TYPE_PT_ADD01;
10028 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10029 dgst_size = DGST_SIZE_4_8;
10030 parse_func = gost2012sbog_256_parse_hash;
10031 sort_by_digest = sort_by_digest_4_8;
10032 opti_type = OPTI_TYPE_ZERO_BYTE;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10040 salt_type = SALT_TYPE_NONE;
10041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE
10043 | OPTS_TYPE_PT_ADD01;
10044 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10045 dgst_size = DGST_SIZE_4_16;
10046 parse_func = gost2012sbog_512_parse_hash;
10047 sort_by_digest = sort_by_digest_4_16;
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10056 salt_type = SALT_TYPE_EMBEDDED;
10057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE
10059 | OPTS_TYPE_ST_BASE64
10060 | OPTS_TYPE_HASH_COPY;
10061 kern_type = KERN_TYPE_PBKDF2_MD5;
10062 dgst_size = DGST_SIZE_4_32;
10063 parse_func = pbkdf2_md5_parse_hash;
10064 sort_by_digest = sort_by_digest_4_32;
10065 opti_type = OPTI_TYPE_ZERO_BYTE;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE
10076 | OPTS_TYPE_ST_BASE64
10077 | OPTS_TYPE_HASH_COPY;
10078 kern_type = KERN_TYPE_PBKDF2_SHA1;
10079 dgst_size = DGST_SIZE_4_32;
10080 parse_func = pbkdf2_sha1_parse_hash;
10081 sort_by_digest = sort_by_digest_4_32;
10082 opti_type = OPTI_TYPE_ZERO_BYTE;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10090 salt_type = SALT_TYPE_EMBEDDED;
10091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE
10093 | OPTS_TYPE_ST_BASE64
10094 | OPTS_TYPE_HASH_COPY;
10095 kern_type = KERN_TYPE_PBKDF2_SHA512;
10096 dgst_size = DGST_SIZE_8_16;
10097 parse_func = pbkdf2_sha512_parse_hash;
10098 sort_by_digest = sort_by_digest_8_16;
10099 opti_type = OPTI_TYPE_ZERO_BYTE
10100 | OPTI_TYPE_USES_BITS_64;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 1;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 3;
10105 break;
10106
10107 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10111 kern_type = KERN_TYPE_ECRYPTFS;
10112 dgst_size = DGST_SIZE_8_8;
10113 parse_func = ecryptfs_parse_hash;
10114 sort_by_digest = sort_by_digest_8_8;
10115 opti_type = OPTI_TYPE_ZERO_BYTE
10116 | OPTI_TYPE_USES_BITS_64;
10117 dgst_pos0 = 0;
10118 dgst_pos1 = 1;
10119 dgst_pos2 = 2;
10120 dgst_pos3 = 3;
10121 break;
10122
10123 case 12300: hash_type = HASH_TYPE_ORACLET;
10124 salt_type = SALT_TYPE_EMBEDDED;
10125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10126 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10127 kern_type = KERN_TYPE_ORACLET;
10128 dgst_size = DGST_SIZE_8_16;
10129 parse_func = oraclet_parse_hash;
10130 sort_by_digest = sort_by_digest_8_16;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_USES_BITS_64;
10133 dgst_pos0 = 0;
10134 dgst_pos1 = 1;
10135 dgst_pos2 = 2;
10136 dgst_pos3 = 3;
10137 break;
10138
10139 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10140 salt_type = SALT_TYPE_EMBEDDED;
10141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10142 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10143 kern_type = KERN_TYPE_BSDICRYPT;
10144 dgst_size = DGST_SIZE_4_4;
10145 parse_func = bsdicrypt_parse_hash;
10146 sort_by_digest = sort_by_digest_4_4;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10149 dgst_pos0 = 0;
10150 dgst_pos1 = 1;
10151 dgst_pos2 = 2;
10152 dgst_pos3 = 3;
10153 break;
10154
10155 case 12500: hash_type = HASH_TYPE_RAR3HP;
10156 salt_type = SALT_TYPE_EMBEDDED;
10157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10159 kern_type = KERN_TYPE_RAR3;
10160 dgst_size = DGST_SIZE_4_4;
10161 parse_func = rar3hp_parse_hash;
10162 sort_by_digest = sort_by_digest_4_4;
10163 opti_type = OPTI_TYPE_ZERO_BYTE;
10164 dgst_pos0 = 0;
10165 dgst_pos1 = 1;
10166 dgst_pos2 = 2;
10167 dgst_pos3 = 3;
10168 break;
10169
10170 case 12600: hash_type = HASH_TYPE_SHA256;
10171 salt_type = SALT_TYPE_INTERN;
10172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10173 opts_type = OPTS_TYPE_PT_GENERATE_BE
10174 | OPTS_TYPE_PT_ADD80;
10175 kern_type = KERN_TYPE_CF10;
10176 dgst_size = DGST_SIZE_4_8;
10177 parse_func = cf10_parse_hash;
10178 sort_by_digest = sort_by_digest_4_8;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_PRECOMPUTE_INIT
10181 | OPTI_TYPE_EARLY_SKIP
10182 | OPTI_TYPE_NOT_ITERATED;
10183 dgst_pos0 = 3;
10184 dgst_pos1 = 7;
10185 dgst_pos2 = 2;
10186 dgst_pos3 = 6;
10187 break;
10188
10189 case 12700: hash_type = HASH_TYPE_AES;
10190 salt_type = SALT_TYPE_EMBEDDED;
10191 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10192 opts_type = OPTS_TYPE_PT_GENERATE_LE
10193 | OPTS_TYPE_HASH_COPY;
10194 kern_type = KERN_TYPE_MYWALLET;
10195 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10196 parse_func = mywallet_parse_hash;
10197 sort_by_digest = sort_by_digest_4_5;
10198 opti_type = OPTI_TYPE_ZERO_BYTE;
10199 dgst_pos0 = 0;
10200 dgst_pos1 = 1;
10201 dgst_pos2 = 2;
10202 dgst_pos3 = 3;
10203 break;
10204
10205 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10206 salt_type = SALT_TYPE_EMBEDDED;
10207 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10208 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10209 kern_type = KERN_TYPE_MS_DRSR;
10210 dgst_size = DGST_SIZE_4_8;
10211 parse_func = ms_drsr_parse_hash;
10212 sort_by_digest = sort_by_digest_4_8;
10213 opti_type = OPTI_TYPE_ZERO_BYTE;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10221 salt_type = SALT_TYPE_EMBEDDED;
10222 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10224 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10225 dgst_size = DGST_SIZE_4_8;
10226 parse_func = androidfde_samsung_parse_hash;
10227 sort_by_digest = sort_by_digest_4_8;
10228 opti_type = OPTI_TYPE_ZERO_BYTE;
10229 dgst_pos0 = 0;
10230 dgst_pos1 = 1;
10231 dgst_pos2 = 2;
10232 dgst_pos3 = 3;
10233 break;
10234
10235 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10236 salt_type = SALT_TYPE_EMBEDDED;
10237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10238 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10239 kern_type = KERN_TYPE_RAR5;
10240 dgst_size = DGST_SIZE_4_4;
10241 parse_func = rar5_parse_hash;
10242 sort_by_digest = sort_by_digest_4_4;
10243 opti_type = OPTI_TYPE_ZERO_BYTE;
10244 dgst_pos0 = 0;
10245 dgst_pos1 = 1;
10246 dgst_pos2 = 2;
10247 dgst_pos3 = 3;
10248 break;
10249
10250 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10251 salt_type = SALT_TYPE_EMBEDDED;
10252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10253 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10254 kern_type = KERN_TYPE_KRB5TGS;
10255 dgst_size = DGST_SIZE_4_4;
10256 parse_func = krb5tgs_parse_hash;
10257 sort_by_digest = sort_by_digest_4_4;
10258 opti_type = OPTI_TYPE_ZERO_BYTE
10259 | OPTI_TYPE_NOT_ITERATED;
10260 dgst_pos0 = 0;
10261 dgst_pos1 = 1;
10262 dgst_pos2 = 2;
10263 dgst_pos3 = 3;
10264 break;
10265
10266 case 13200: hash_type = HASH_TYPE_AES;
10267 salt_type = SALT_TYPE_EMBEDDED;
10268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10269 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10270 kern_type = KERN_TYPE_AXCRYPT;
10271 dgst_size = DGST_SIZE_4_4;
10272 parse_func = axcrypt_parse_hash;
10273 sort_by_digest = sort_by_digest_4_4;
10274 opti_type = OPTI_TYPE_ZERO_BYTE;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 13300: hash_type = HASH_TYPE_SHA1;
10282 salt_type = SALT_TYPE_NONE;
10283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_BE
10285 | OPTS_TYPE_PT_ADD80
10286 | OPTS_TYPE_PT_ADDBITS15;
10287 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10288 dgst_size = DGST_SIZE_4_5;
10289 parse_func = sha1axcrypt_parse_hash;
10290 sort_by_digest = sort_by_digest_4_5;
10291 opti_type = OPTI_TYPE_ZERO_BYTE
10292 | OPTI_TYPE_PRECOMPUTE_INIT
10293 | OPTI_TYPE_EARLY_SKIP
10294 | OPTI_TYPE_NOT_ITERATED
10295 | OPTI_TYPE_NOT_SALTED;
10296 dgst_pos0 = 0;
10297 dgst_pos1 = 4;
10298 dgst_pos2 = 3;
10299 dgst_pos3 = 2;
10300 break;
10301
10302 case 13400: hash_type = HASH_TYPE_AES;
10303 salt_type = SALT_TYPE_EMBEDDED;
10304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10305 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10306 kern_type = KERN_TYPE_KEEPASS;
10307 dgst_size = DGST_SIZE_4_4;
10308 parse_func = keepass_parse_hash;
10309 sort_by_digest = sort_by_digest_4_4;
10310 opti_type = OPTI_TYPE_ZERO_BYTE;
10311 dgst_pos0 = 0;
10312 dgst_pos1 = 1;
10313 dgst_pos2 = 2;
10314 dgst_pos3 = 3;
10315 break;
10316
10317 default: usage_mini_print (PROGNAME); return (-1);
10318 }
10319
10320 /**
10321 * parser
10322 */
10323
10324 data.parse_func = parse_func;
10325
10326 /**
10327 * misc stuff
10328 */
10329
10330 if (hex_salt)
10331 {
10332 if (salt_type == SALT_TYPE_INTERN)
10333 {
10334 opts_type |= OPTS_TYPE_ST_HEX;
10335 }
10336 else
10337 {
10338 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10339
10340 return (-1);
10341 }
10342 }
10343
10344 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10345 | (salt_type == SALT_TYPE_EXTERN)
10346 | (salt_type == SALT_TYPE_EMBEDDED)
10347 | (salt_type == SALT_TYPE_VIRTUAL));
10348
10349 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10350
10351 data.hash_type = hash_type;
10352 data.attack_mode = attack_mode;
10353 data.attack_kern = attack_kern;
10354 data.attack_exec = attack_exec;
10355 data.kern_type = kern_type;
10356 data.opts_type = opts_type;
10357 data.dgst_size = dgst_size;
10358 data.salt_type = salt_type;
10359 data.isSalted = isSalted;
10360 data.sort_by_digest = sort_by_digest;
10361 data.dgst_pos0 = dgst_pos0;
10362 data.dgst_pos1 = dgst_pos1;
10363 data.dgst_pos2 = dgst_pos2;
10364 data.dgst_pos3 = dgst_pos3;
10365
10366 esalt_size = 0;
10367
10368 switch (hash_mode)
10369 {
10370 case 2500: esalt_size = sizeof (wpa_t); break;
10371 case 5300: esalt_size = sizeof (ikepsk_t); break;
10372 case 5400: esalt_size = sizeof (ikepsk_t); break;
10373 case 5500: esalt_size = sizeof (netntlm_t); break;
10374 case 5600: esalt_size = sizeof (netntlm_t); break;
10375 case 6211: esalt_size = sizeof (tc_t); break;
10376 case 6212: esalt_size = sizeof (tc_t); break;
10377 case 6213: esalt_size = sizeof (tc_t); break;
10378 case 6221: esalt_size = sizeof (tc_t); break;
10379 case 6222: esalt_size = sizeof (tc_t); break;
10380 case 6223: esalt_size = sizeof (tc_t); break;
10381 case 6231: esalt_size = sizeof (tc_t); break;
10382 case 6232: esalt_size = sizeof (tc_t); break;
10383 case 6233: esalt_size = sizeof (tc_t); break;
10384 case 6241: esalt_size = sizeof (tc_t); break;
10385 case 6242: esalt_size = sizeof (tc_t); break;
10386 case 6243: esalt_size = sizeof (tc_t); break;
10387 case 6600: esalt_size = sizeof (agilekey_t); break;
10388 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10389 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10390 case 7300: esalt_size = sizeof (rakp_t); break;
10391 case 7500: esalt_size = sizeof (krb5pa_t); break;
10392 case 8200: esalt_size = sizeof (cloudkey_t); break;
10393 case 8800: esalt_size = sizeof (androidfde_t); break;
10394 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10395 case 9400: esalt_size = sizeof (office2007_t); break;
10396 case 9500: esalt_size = sizeof (office2010_t); break;
10397 case 9600: esalt_size = sizeof (office2013_t); break;
10398 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10399 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10400 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10401 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10402 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10403 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10404 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10405 case 10200: esalt_size = sizeof (cram_md5_t); break;
10406 case 10400: esalt_size = sizeof (pdf_t); break;
10407 case 10410: esalt_size = sizeof (pdf_t); break;
10408 case 10420: esalt_size = sizeof (pdf_t); break;
10409 case 10500: esalt_size = sizeof (pdf_t); break;
10410 case 10600: esalt_size = sizeof (pdf_t); break;
10411 case 10700: esalt_size = sizeof (pdf_t); break;
10412 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10413 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10414 case 11400: esalt_size = sizeof (sip_t); break;
10415 case 11600: esalt_size = sizeof (seven_zip_t); break;
10416 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10417 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10418 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10419 case 13000: esalt_size = sizeof (rar5_t); break;
10420 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10421 case 13400: esalt_size = sizeof (keepass_t); break;
10422 }
10423
10424 data.esalt_size = esalt_size;
10425
10426 /**
10427 * choose dictionary parser
10428 */
10429
10430 if (hash_type == HASH_TYPE_LM)
10431 {
10432 get_next_word_func = get_next_word_lm;
10433 }
10434 else if (opts_type & OPTS_TYPE_PT_UPPER)
10435 {
10436 get_next_word_func = get_next_word_uc;
10437 }
10438 else
10439 {
10440 get_next_word_func = get_next_word_std;
10441 }
10442
10443 /**
10444 * dictstat
10445 */
10446
10447 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10448
10449 #ifdef _POSIX
10450 size_t dictstat_nmemb = 0;
10451 #endif
10452
10453 #ifdef _WIN
10454 uint dictstat_nmemb = 0;
10455 #endif
10456
10457 char dictstat[256] = { 0 };
10458
10459 FILE *dictstat_fp = NULL;
10460
10461 if (keyspace == 0)
10462 {
10463 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10464
10465 dictstat_fp = fopen (dictstat, "rb");
10466
10467 if (dictstat_fp)
10468 {
10469 #ifdef _POSIX
10470 struct stat tmpstat;
10471
10472 fstat (fileno (dictstat_fp), &tmpstat);
10473 #endif
10474
10475 #ifdef _WIN
10476 struct stat64 tmpstat;
10477
10478 _fstat64 (fileno (dictstat_fp), &tmpstat);
10479 #endif
10480
10481 if (tmpstat.st_mtime < COMPTIME)
10482 {
10483 /* with v0.15 the format changed so we have to ensure user is using a good version
10484 since there is no version-header in the dictstat file */
10485
10486 fclose (dictstat_fp);
10487
10488 unlink (dictstat);
10489 }
10490 else
10491 {
10492 while (!feof (dictstat_fp))
10493 {
10494 dictstat_t d;
10495
10496 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10497
10498 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10499
10500 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10501 {
10502 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10503
10504 return -1;
10505 }
10506 }
10507
10508 fclose (dictstat_fp);
10509 }
10510 }
10511 }
10512
10513 /**
10514 * potfile
10515 */
10516
10517 char potfile[256] = { 0 };
10518
10519 if (potfile_path == NULL)
10520 {
10521 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10522 }
10523 else
10524 {
10525 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10526 }
10527
10528 data.pot_fp = NULL;
10529
10530 FILE *out_fp = NULL;
10531 FILE *pot_fp = NULL;
10532
10533 if (show == 1 || left == 1)
10534 {
10535 pot_fp = fopen (potfile, "rb");
10536
10537 if (pot_fp == NULL)
10538 {
10539 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10540
10541 return (-1);
10542 }
10543
10544 if (outfile != NULL)
10545 {
10546 if ((out_fp = fopen (outfile, "ab")) == NULL)
10547 {
10548 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10549
10550 fclose (pot_fp);
10551
10552 return (-1);
10553 }
10554 }
10555 else
10556 {
10557 out_fp = stdout;
10558 }
10559 }
10560 else
10561 {
10562 if (potfile_disable == 0)
10563 {
10564 pot_fp = fopen (potfile, "ab");
10565
10566 if (pot_fp == NULL)
10567 {
10568 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10569
10570 return (-1);
10571 }
10572
10573 data.pot_fp = pot_fp;
10574 }
10575 }
10576
10577 pot_t *pot = NULL;
10578
10579 uint pot_cnt = 0;
10580 uint pot_avail = 0;
10581
10582 if (show == 1 || left == 1)
10583 {
10584 SUPPRESS_OUTPUT = 1;
10585
10586 pot_avail = count_lines (pot_fp);
10587
10588 rewind (pot_fp);
10589
10590 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10591
10592 uint pot_hashes_avail = 0;
10593
10594 uint line_num = 0;
10595
10596 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10597
10598 while (!feof (pot_fp))
10599 {
10600 line_num++;
10601
10602 int line_len = fgetl (pot_fp, line_buf);
10603
10604 if (line_len == 0) continue;
10605
10606 char *plain_buf = line_buf + line_len;
10607
10608 pot_t *pot_ptr = &pot[pot_cnt];
10609
10610 hash_t *hashes_buf = &pot_ptr->hash;
10611
10612 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10613 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10614
10615 if (pot_cnt == pot_hashes_avail)
10616 {
10617 uint pos = 0;
10618
10619 for (pos = 0; pos < INCR_POT; pos++)
10620 {
10621 if ((pot_cnt + pos) >= pot_avail) break;
10622
10623 pot_t *tmp_pot = &pot[pot_cnt + pos];
10624
10625 hash_t *tmp_hash = &tmp_pot->hash;
10626
10627 tmp_hash->digest = mymalloc (dgst_size);
10628
10629 if (isSalted)
10630 {
10631 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10632 }
10633
10634 if (esalt_size)
10635 {
10636 tmp_hash->esalt = mymalloc (esalt_size);
10637 }
10638
10639 pot_hashes_avail++;
10640 }
10641 }
10642
10643 int plain_len = 0;
10644
10645 int parser_status;
10646
10647 int iter = MAX_CUT_TRIES;
10648
10649 do
10650 {
10651 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10652 {
10653 if (line_buf[i] == ':')
10654 {
10655 line_len--;
10656
10657 break;
10658 }
10659 }
10660
10661 if (data.hash_mode != 2500)
10662 {
10663 parser_status = parse_func (line_buf, line_len, hashes_buf);
10664 }
10665 else
10666 {
10667 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10668
10669 if (line_len > max_salt_size)
10670 {
10671 parser_status = PARSER_GLOBAL_LENGTH;
10672 }
10673 else
10674 {
10675 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10676
10677 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10678
10679 hashes_buf->salt->salt_len = line_len;
10680
10681 parser_status = PARSER_OK;
10682 }
10683 }
10684
10685 // if NOT parsed without error, we add the ":" to the plain
10686
10687 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10688 {
10689 plain_len++;
10690 plain_buf--;
10691 }
10692
10693 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10694
10695 if (parser_status < PARSER_GLOBAL_ZERO)
10696 {
10697 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10698
10699 continue;
10700 }
10701
10702 if (plain_len >= 255) continue;
10703
10704 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10705
10706 pot_ptr->plain_len = plain_len;
10707
10708 pot_cnt++;
10709 }
10710
10711 myfree (line_buf);
10712
10713 fclose (pot_fp);
10714
10715 SUPPRESS_OUTPUT = 0;
10716
10717 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10718 }
10719
10720 /**
10721 * word len
10722 */
10723
10724 uint pw_min = PW_MIN;
10725 uint pw_max = PW_MAX;
10726
10727 switch (hash_mode)
10728 {
10729 case 125: if (pw_max > 32) pw_max = 32;
10730 break;
10731 case 400: if (pw_max > 40) pw_max = 40;
10732 break;
10733 case 500: if (pw_max > 16) pw_max = 16;
10734 break;
10735 case 1500: if (pw_max > 8) pw_max = 8;
10736 break;
10737 case 1600: if (pw_max > 16) pw_max = 16;
10738 break;
10739 case 1800: if (pw_max > 16) pw_max = 16;
10740 break;
10741 case 2100: if (pw_max > 16) pw_max = 16;
10742 break;
10743 case 2500: if (pw_min < 8) pw_min = 8;
10744 break;
10745 case 3000: if (pw_max > 7) pw_max = 7;
10746 break;
10747 case 5200: if (pw_max > 24) pw_max = 24;
10748 break;
10749 case 5800: if (pw_max > 16) pw_max = 16;
10750 break;
10751 case 6300: if (pw_max > 16) pw_max = 16;
10752 break;
10753 case 7400: if (pw_max > 16) pw_max = 16;
10754 break;
10755 case 7900: if (pw_max > 48) pw_max = 48;
10756 break;
10757 case 8500: if (pw_max > 8) pw_max = 8;
10758 break;
10759 case 8600: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 9710: pw_min = 5;
10762 pw_max = 5;
10763 break;
10764 case 9810: pw_min = 5;
10765 pw_max = 5;
10766 break;
10767 case 10410: pw_min = 5;
10768 pw_max = 5;
10769 break;
10770 case 10300: if (pw_max < 3) pw_min = 3;
10771 if (pw_max > 40) pw_max = 40;
10772 break;
10773 case 10500: if (pw_max < 3) pw_min = 3;
10774 if (pw_max > 40) pw_max = 40;
10775 break;
10776 case 10700: if (pw_max > 16) pw_max = 16;
10777 break;
10778 case 11300: if (pw_max > 40) pw_max = 40;
10779 break;
10780 case 12500: if (pw_max > 20) pw_max = 20;
10781 break;
10782 case 12800: if (pw_max > 24) pw_max = 24;
10783 break;
10784 }
10785
10786 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10787 {
10788 switch (attack_kern)
10789 {
10790 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10791 break;
10792 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10793 break;
10794 }
10795 }
10796
10797 /**
10798 * charsets : keep them together for more easy maintainnce
10799 */
10800
10801 cs_t mp_sys[6] = { { { 0 }, 0 } };
10802 cs_t mp_usr[4] = { { { 0 }, 0 } };
10803
10804 mp_setup_sys (mp_sys);
10805
10806 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10807 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10808 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10809 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10810
10811 /**
10812 * load hashes, part I: find input mode, count hashes
10813 */
10814
10815 uint hashlist_mode = 0;
10816 uint hashlist_format = HLFMT_HASHCAT;
10817
10818 uint hashes_avail = 0;
10819
10820 if (benchmark == 0)
10821 {
10822 struct stat f;
10823
10824 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10825
10826 if ((hash_mode == 2500) ||
10827 (hash_mode == 5200) ||
10828 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10829 (hash_mode == 9000))
10830 {
10831 hashlist_mode = HL_MODE_ARG;
10832
10833 char *hashfile = myargv[optind];
10834
10835 data.hashfile = hashfile;
10836
10837 logfile_top_var_string ("target", hashfile);
10838 }
10839
10840 if (hashlist_mode == HL_MODE_ARG)
10841 {
10842 if (hash_mode == 2500)
10843 {
10844 struct stat st;
10845
10846 if (stat (data.hashfile, &st) == -1)
10847 {
10848 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10849
10850 return (-1);
10851 }
10852
10853 hashes_avail = st.st_size / sizeof (hccap_t);
10854 }
10855 else
10856 {
10857 hashes_avail = 1;
10858 }
10859 }
10860 else if (hashlist_mode == HL_MODE_FILE)
10861 {
10862 char *hashfile = myargv[optind];
10863
10864 data.hashfile = hashfile;
10865
10866 logfile_top_var_string ("target", hashfile);
10867
10868 FILE *fp = NULL;
10869
10870 if ((fp = fopen (hashfile, "rb")) == NULL)
10871 {
10872 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10873
10874 return (-1);
10875 }
10876
10877 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10878
10879 hashes_avail = count_lines (fp);
10880
10881 rewind (fp);
10882
10883 if (hashes_avail == 0)
10884 {
10885 log_error ("ERROR: hashfile is empty or corrupt");
10886
10887 fclose (fp);
10888
10889 return (-1);
10890 }
10891
10892 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10893
10894 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10895 {
10896 log_error ("ERROR: remove not supported in native hashfile-format mode");
10897
10898 fclose (fp);
10899
10900 return (-1);
10901 }
10902
10903 fclose (fp);
10904 }
10905 }
10906 else
10907 {
10908 hashlist_mode = HL_MODE_ARG;
10909
10910 hashes_avail = 1;
10911 }
10912
10913 if (hash_mode == 3000) hashes_avail *= 2;
10914
10915 data.hashlist_mode = hashlist_mode;
10916 data.hashlist_format = hashlist_format;
10917
10918 logfile_top_uint (hashlist_mode);
10919 logfile_top_uint (hashlist_format);
10920
10921 /**
10922 * load hashes, part II: allocate required memory, set pointers
10923 */
10924
10925 hash_t *hashes_buf = NULL;
10926 void *digests_buf = NULL;
10927 salt_t *salts_buf = NULL;
10928 void *esalts_buf = NULL;
10929
10930 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10931
10932 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10933
10934 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10935 {
10936 u32 hash_pos;
10937
10938 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10939 {
10940 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10941
10942 hashes_buf[hash_pos].hash_info = hash_info;
10943
10944 if (username && (remove || show || left))
10945 {
10946 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10947 }
10948
10949 if (benchmark)
10950 {
10951 hash_info->orighash = (char *) mymalloc (256);
10952 }
10953 }
10954 }
10955
10956 if (isSalted)
10957 {
10958 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10959
10960 if (esalt_size)
10961 {
10962 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10963 }
10964 }
10965 else
10966 {
10967 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10968 }
10969
10970 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10971 {
10972 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10973
10974 if (isSalted)
10975 {
10976 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10977
10978 if (esalt_size)
10979 {
10980 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10981 }
10982 }
10983 else
10984 {
10985 hashes_buf[hash_pos].salt = &salts_buf[0];
10986 }
10987 }
10988
10989 /**
10990 * load hashes, part III: parse hashes or generate them if benchmark
10991 */
10992
10993 uint hashes_cnt = 0;
10994
10995 if (benchmark == 0)
10996 {
10997 if (keyspace == 1)
10998 {
10999 // useless to read hash file for keyspace, cheat a little bit w/ optind
11000 }
11001 else if (hashes_avail == 0)
11002 {
11003 }
11004 else if (hashlist_mode == HL_MODE_ARG)
11005 {
11006 char *input_buf = myargv[optind];
11007
11008 uint input_len = strlen (input_buf);
11009
11010 logfile_top_var_string ("target", input_buf);
11011
11012 char *hash_buf = NULL;
11013 int hash_len = 0;
11014
11015 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11016
11017 bool hash_fmt_error = 0;
11018
11019 if (hash_len < 1) hash_fmt_error = 1;
11020 if (hash_buf == NULL) hash_fmt_error = 1;
11021
11022 if (hash_fmt_error)
11023 {
11024 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11025 }
11026 else
11027 {
11028 if (opts_type & OPTS_TYPE_HASH_COPY)
11029 {
11030 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11031
11032 hash_info_tmp->orighash = mystrdup (hash_buf);
11033 }
11034
11035 if (isSalted)
11036 {
11037 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11038 }
11039
11040 int parser_status = PARSER_OK;
11041
11042 if (hash_mode == 2500)
11043 {
11044 if (hash_len == 0)
11045 {
11046 log_error ("ERROR: hccap file not specified");
11047
11048 return (-1);
11049 }
11050
11051 hashlist_mode = HL_MODE_FILE;
11052
11053 data.hashlist_mode = hashlist_mode;
11054
11055 FILE *fp = fopen (hash_buf, "rb");
11056
11057 if (fp == NULL)
11058 {
11059 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11060
11061 return (-1);
11062 }
11063
11064 if (hashes_avail < 1)
11065 {
11066 log_error ("ERROR: hccap file is empty or corrupt");
11067
11068 fclose (fp);
11069
11070 return (-1);
11071 }
11072
11073 uint hccap_size = sizeof (hccap_t);
11074
11075 char *in = (char *) mymalloc (hccap_size);
11076
11077 while (!feof (fp))
11078 {
11079 int n = fread (in, hccap_size, 1, fp);
11080
11081 if (n != 1)
11082 {
11083 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11084
11085 break;
11086 }
11087
11088 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11089
11090 if (parser_status != PARSER_OK)
11091 {
11092 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11093
11094 continue;
11095 }
11096
11097 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11098
11099 if ((show == 1) || (left == 1))
11100 {
11101 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11102
11103 char *salt_ptr = (char *) tmp_salt->salt_buf;
11104
11105 int cur_pos = tmp_salt->salt_len;
11106 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11107
11108 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11109
11110 // do the appending task
11111
11112 snprintf (salt_ptr + cur_pos,
11113 rem_len,
11114 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11115 wpa->orig_mac1[0],
11116 wpa->orig_mac1[1],
11117 wpa->orig_mac1[2],
11118 wpa->orig_mac1[3],
11119 wpa->orig_mac1[4],
11120 wpa->orig_mac1[5],
11121 wpa->orig_mac2[0],
11122 wpa->orig_mac2[1],
11123 wpa->orig_mac2[2],
11124 wpa->orig_mac2[3],
11125 wpa->orig_mac2[4],
11126 wpa->orig_mac2[5]);
11127
11128 // memset () the remaining part of the salt
11129
11130 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11131 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11132
11133 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11134
11135 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11136 }
11137
11138 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);
11139 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);
11140
11141 hashes_cnt++;
11142 }
11143
11144 fclose (fp);
11145
11146 myfree (in);
11147 }
11148 else if (hash_mode == 3000)
11149 {
11150 if (hash_len == 32)
11151 {
11152 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11153
11154 hash_t *lm_hash_left = NULL;
11155
11156 if (parser_status == PARSER_OK)
11157 {
11158 lm_hash_left = &hashes_buf[hashes_cnt];
11159
11160 hashes_cnt++;
11161 }
11162 else
11163 {
11164 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11165 }
11166
11167 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11168
11169 hash_t *lm_hash_right = NULL;
11170
11171 if (parser_status == PARSER_OK)
11172 {
11173 lm_hash_right = &hashes_buf[hashes_cnt];
11174
11175 hashes_cnt++;
11176 }
11177 else
11178 {
11179 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11180 }
11181
11182 // show / left
11183
11184 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11185 {
11186 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);
11187 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);
11188 }
11189 }
11190 else
11191 {
11192 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11193
11194 if (parser_status == PARSER_OK)
11195 {
11196 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11197 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11198 }
11199
11200 if (parser_status == PARSER_OK)
11201 {
11202 hashes_cnt++;
11203 }
11204 else
11205 {
11206 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11207 }
11208 }
11209 }
11210 else
11211 {
11212 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11213
11214 if (parser_status == PARSER_OK)
11215 {
11216 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11217 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11218 }
11219
11220 if (parser_status == PARSER_OK)
11221 {
11222 hashes_cnt++;
11223 }
11224 else
11225 {
11226 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11227 }
11228 }
11229 }
11230 }
11231 else if (hashlist_mode == HL_MODE_FILE)
11232 {
11233 char *hashfile = data.hashfile;
11234
11235 FILE *fp;
11236
11237 if ((fp = fopen (hashfile, "rb")) == NULL)
11238 {
11239 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11240
11241 return (-1);
11242 }
11243
11244 uint line_num = 0;
11245
11246 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11247
11248 while (!feof (fp))
11249 {
11250 line_num++;
11251
11252 int line_len = fgetl (fp, line_buf);
11253
11254 if (line_len == 0) continue;
11255
11256 char *hash_buf = NULL;
11257 int hash_len = 0;
11258
11259 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11260
11261 bool hash_fmt_error = 0;
11262
11263 if (hash_len < 1) hash_fmt_error = 1;
11264 if (hash_buf == NULL) hash_fmt_error = 1;
11265
11266 if (hash_fmt_error)
11267 {
11268 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11269
11270 continue;
11271 }
11272
11273 if (username)
11274 {
11275 char *user_buf = NULL;
11276 int user_len = 0;
11277
11278 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11279
11280 if (remove || show)
11281 {
11282 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11283
11284 *user = (user_t *) mymalloc (sizeof (user_t));
11285
11286 user_t *user_ptr = *user;
11287
11288 if (user_buf != NULL)
11289 {
11290 user_ptr->user_name = mystrdup (user_buf);
11291 }
11292 else
11293 {
11294 user_ptr->user_name = mystrdup ("");
11295 }
11296
11297 user_ptr->user_len = user_len;
11298 }
11299 }
11300
11301 if (opts_type & OPTS_TYPE_HASH_COPY)
11302 {
11303 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11304
11305 hash_info_tmp->orighash = mystrdup (hash_buf);
11306 }
11307
11308 if (isSalted)
11309 {
11310 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11311 }
11312
11313 if (hash_mode == 3000)
11314 {
11315 if (hash_len == 32)
11316 {
11317 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11318
11319 if (parser_status < PARSER_GLOBAL_ZERO)
11320 {
11321 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11322
11323 continue;
11324 }
11325
11326 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11327
11328 hashes_cnt++;
11329
11330 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11331
11332 if (parser_status < PARSER_GLOBAL_ZERO)
11333 {
11334 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11335
11336 continue;
11337 }
11338
11339 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11340
11341 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);
11342
11343 hashes_cnt++;
11344
11345 // show / left
11346
11347 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);
11348 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);
11349 }
11350 else
11351 {
11352 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11353
11354 if (parser_status < PARSER_GLOBAL_ZERO)
11355 {
11356 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11357
11358 continue;
11359 }
11360
11361 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);
11362
11363 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11364 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11365
11366 hashes_cnt++;
11367 }
11368 }
11369 else
11370 {
11371 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11372
11373 if (parser_status < PARSER_GLOBAL_ZERO)
11374 {
11375 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11376
11377 continue;
11378 }
11379
11380 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);
11381
11382 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11383 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11384
11385 hashes_cnt++;
11386 }
11387 }
11388
11389 myfree (line_buf);
11390
11391 fclose (fp);
11392
11393 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11394
11395 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11396 }
11397 }
11398 else
11399 {
11400 if (isSalted)
11401 {
11402 hashes_buf[0].salt->salt_len = 8;
11403
11404 // special salt handling
11405
11406 switch (hash_mode)
11407 {
11408 case 1500: hashes_buf[0].salt->salt_len = 2;
11409 break;
11410 case 1731: hashes_buf[0].salt->salt_len = 4;
11411 break;
11412 case 2410: hashes_buf[0].salt->salt_len = 4;
11413 break;
11414 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11415 break;
11416 case 3100: hashes_buf[0].salt->salt_len = 1;
11417 break;
11418 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11419 break;
11420 case 5800: hashes_buf[0].salt->salt_len = 16;
11421 break;
11422 case 6800: hashes_buf[0].salt->salt_len = 32;
11423 break;
11424 case 8400: hashes_buf[0].salt->salt_len = 40;
11425 break;
11426 case 8800: hashes_buf[0].salt->salt_len = 16;
11427 break;
11428 case 8900: hashes_buf[0].salt->salt_len = 16;
11429 hashes_buf[0].salt->scrypt_N = 1024;
11430 hashes_buf[0].salt->scrypt_r = 1;
11431 hashes_buf[0].salt->scrypt_p = 1;
11432 break;
11433 case 9100: hashes_buf[0].salt->salt_len = 16;
11434 break;
11435 case 9300: hashes_buf[0].salt->salt_len = 14;
11436 hashes_buf[0].salt->scrypt_N = 16384;
11437 hashes_buf[0].salt->scrypt_r = 1;
11438 hashes_buf[0].salt->scrypt_p = 1;
11439 break;
11440 case 9400: hashes_buf[0].salt->salt_len = 16;
11441 break;
11442 case 9500: hashes_buf[0].salt->salt_len = 16;
11443 break;
11444 case 9600: hashes_buf[0].salt->salt_len = 16;
11445 break;
11446 case 9700: hashes_buf[0].salt->salt_len = 16;
11447 break;
11448 case 9710: hashes_buf[0].salt->salt_len = 16;
11449 break;
11450 case 9720: hashes_buf[0].salt->salt_len = 16;
11451 break;
11452 case 9800: hashes_buf[0].salt->salt_len = 16;
11453 break;
11454 case 9810: hashes_buf[0].salt->salt_len = 16;
11455 break;
11456 case 9820: hashes_buf[0].salt->salt_len = 16;
11457 break;
11458 case 10300: hashes_buf[0].salt->salt_len = 12;
11459 break;
11460 case 11500: hashes_buf[0].salt->salt_len = 4;
11461 break;
11462 case 11600: hashes_buf[0].salt->salt_len = 4;
11463 break;
11464 case 12400: hashes_buf[0].salt->salt_len = 4;
11465 break;
11466 case 12500: hashes_buf[0].salt->salt_len = 8;
11467 break;
11468 case 12600: hashes_buf[0].salt->salt_len = 64;
11469 break;
11470 }
11471
11472 // special esalt handling
11473
11474 switch (hash_mode)
11475 {
11476 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11477 break;
11478 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11479 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11480 break;
11481 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11482 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11483 break;
11484 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11485 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11486 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11487 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11488 break;
11489 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11490 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11491 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11492 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11493 break;
11494 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11495 break;
11496 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11497 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11498 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11499 break;
11500 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11501 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11502 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11503 break;
11504 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11505 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11506 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11507 break;
11508 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11509 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11510 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11511 break;
11512 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11513 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11514 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11515 break;
11516 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11517 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11518 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11519 break;
11520 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11521 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11522 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11523 break;
11524 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11525 break;
11526 }
11527 }
11528
11529 // set hashfile
11530
11531 switch (hash_mode)
11532 {
11533 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11534 break;
11535 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11536 break;
11537 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11538 break;
11539 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11546 break;
11547 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11548 break;
11549 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11550 break;
11551 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11552 break;
11553 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11554 break;
11555 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11556 break;
11557 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11558 break;
11559 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11560 break;
11561 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11562 break;
11563 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11564 break;
11565 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11566 break;
11567 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11568 break;
11569 }
11570
11571 // set default iterations
11572
11573 switch (hash_mode)
11574 {
11575 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11576 break;
11577 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11578 break;
11579 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11580 break;
11581 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11582 break;
11583 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11584 break;
11585 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11586 break;
11587 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11588 break;
11589 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11590 break;
11591 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11592 break;
11593 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11594 break;
11595 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11596 break;
11597 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11598 break;
11599 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11600 break;
11601 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11602 break;
11603 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11604 break;
11605 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11606 break;
11607 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11608 break;
11609 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11610 break;
11611 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11612 break;
11613 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11614 break;
11615 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11616 break;
11617 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11618 break;
11619 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11620 break;
11621 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11622 break;
11623 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11624 break;
11625 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11626 break;
11627 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11628 break;
11629 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11630 break;
11631 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11632 break;
11633 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11634 break;
11635 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11636 break;
11637 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11638 break;
11639 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11640 break;
11641 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11642 break;
11643 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11644 break;
11645 case 8900: hashes_buf[0].salt->salt_iter = 1;
11646 break;
11647 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11648 break;
11649 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11650 break;
11651 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11652 break;
11653 case 9300: hashes_buf[0].salt->salt_iter = 1;
11654 break;
11655 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11656 break;
11657 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11658 break;
11659 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11660 break;
11661 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11662 break;
11663 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11664 break;
11665 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11666 break;
11667 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11668 break;
11669 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11670 break;
11671 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11672 break;
11673 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11674 break;
11675 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11676 break;
11677 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11678 break;
11679 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11680 break;
11681 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11682 break;
11683 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11684 break;
11685 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11686 break;
11687 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11688 break;
11689 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11690 break;
11691 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11692 break;
11693 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11694 break;
11695 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11696 break;
11697 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11698 break;
11699 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11700 break;
11701 }
11702
11703 hashes_cnt = 1;
11704 }
11705
11706 if (show == 1 || left == 1)
11707 {
11708 for (uint i = 0; i < pot_cnt; i++)
11709 {
11710 pot_t *pot_ptr = &pot[i];
11711
11712 hash_t *hashes_buf = &pot_ptr->hash;
11713
11714 local_free (hashes_buf->digest);
11715
11716 if (isSalted)
11717 {
11718 local_free (hashes_buf->salt);
11719 }
11720 }
11721
11722 local_free (pot);
11723
11724 if (data.quiet == 0) log_info_nn ("");
11725
11726 return (0);
11727 }
11728
11729 if (keyspace == 0)
11730 {
11731 if (hashes_cnt == 0)
11732 {
11733 log_error ("ERROR: No hashes loaded");
11734
11735 return (-1);
11736 }
11737 }
11738
11739 /**
11740 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11741 */
11742
11743 if (data.outfile != NULL)
11744 {
11745 if (data.hashfile != NULL)
11746 {
11747 #ifdef _POSIX
11748 struct stat tmpstat_outfile;
11749 struct stat tmpstat_hashfile;
11750 #endif
11751
11752 #ifdef _WIN
11753 struct stat64 tmpstat_outfile;
11754 struct stat64 tmpstat_hashfile;
11755 #endif
11756
11757 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11758
11759 if (tmp_outfile_fp)
11760 {
11761 #ifdef _POSIX
11762 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11763 #endif
11764
11765 #ifdef _WIN
11766 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11767 #endif
11768
11769 fclose (tmp_outfile_fp);
11770 }
11771
11772 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11773
11774 if (tmp_hashfile_fp)
11775 {
11776 #ifdef _POSIX
11777 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11778 #endif
11779
11780 #ifdef _WIN
11781 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11782 #endif
11783
11784 fclose (tmp_hashfile_fp);
11785 }
11786
11787 if (tmp_outfile_fp && tmp_outfile_fp)
11788 {
11789 tmpstat_outfile.st_mode = 0;
11790 tmpstat_outfile.st_nlink = 0;
11791 tmpstat_outfile.st_uid = 0;
11792 tmpstat_outfile.st_gid = 0;
11793 tmpstat_outfile.st_rdev = 0;
11794 tmpstat_outfile.st_atime = 0;
11795
11796 tmpstat_hashfile.st_mode = 0;
11797 tmpstat_hashfile.st_nlink = 0;
11798 tmpstat_hashfile.st_uid = 0;
11799 tmpstat_hashfile.st_gid = 0;
11800 tmpstat_hashfile.st_rdev = 0;
11801 tmpstat_hashfile.st_atime = 0;
11802
11803 #ifdef _POSIX
11804 tmpstat_outfile.st_blksize = 0;
11805 tmpstat_outfile.st_blocks = 0;
11806
11807 tmpstat_hashfile.st_blksize = 0;
11808 tmpstat_hashfile.st_blocks = 0;
11809 #endif
11810
11811 #ifdef _POSIX
11812 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11813 {
11814 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11815
11816 return (-1);
11817 }
11818 #endif
11819
11820 #ifdef _WIN
11821 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11822 {
11823 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11824
11825 return (-1);
11826 }
11827 #endif
11828 }
11829 }
11830 }
11831
11832 /**
11833 * Remove duplicates
11834 */
11835
11836 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11837
11838 if (isSalted)
11839 {
11840 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11841 }
11842 else
11843 {
11844 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11845 }
11846
11847 uint hashes_cnt_orig = hashes_cnt;
11848
11849 hashes_cnt = 1;
11850
11851 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11852 {
11853 if (isSalted)
11854 {
11855 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11856 {
11857 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11858 }
11859 }
11860 else
11861 {
11862 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11863 }
11864
11865 if (hashes_pos > hashes_cnt)
11866 {
11867 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11868 }
11869
11870 hashes_cnt++;
11871 }
11872
11873 /**
11874 * Potfile removes
11875 */
11876
11877 uint potfile_remove_cracks = 0;
11878
11879 if (potfile_disable == 0)
11880 {
11881 hash_t hash_buf;
11882
11883 hash_buf.digest = mymalloc (dgst_size);
11884 hash_buf.salt = NULL;
11885 hash_buf.esalt = NULL;
11886 hash_buf.hash_info = NULL;
11887 hash_buf.cracked = 0;
11888
11889 if (isSalted)
11890 {
11891 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11892 }
11893
11894 if (esalt_size)
11895 {
11896 hash_buf.esalt = mymalloc (esalt_size);
11897 }
11898
11899 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11900
11901 // no solution for these special hash types (for instane because they use hashfile in output etc)
11902 if ((hash_mode != 5200) &&
11903 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11904 (hash_mode != 9000))
11905 {
11906 FILE *fp = fopen (potfile, "rb");
11907
11908 if (fp != NULL)
11909 {
11910 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11911
11912 // to be safe work with a copy (because of line_len loop, i etc)
11913 // moved up here because it's easier to handle continue case
11914 // it's just 64kb
11915
11916 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11917
11918 while (!feof (fp))
11919 {
11920 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11921
11922 if (ptr == NULL) break;
11923
11924 int line_len = strlen (line_buf);
11925
11926 if (line_len == 0) continue;
11927
11928 int iter = MAX_CUT_TRIES;
11929
11930 for (int i = line_len - 1; i && iter; i--, line_len--)
11931 {
11932 if (line_buf[i] != ':') continue;
11933
11934 if (isSalted)
11935 {
11936 memset (hash_buf.salt, 0, sizeof (salt_t));
11937 }
11938
11939 hash_t *found = NULL;
11940
11941 if (hash_mode == 6800)
11942 {
11943 if (i < 64) // 64 = 16 * uint in salt_buf[]
11944 {
11945 // manipulate salt_buf
11946 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11947
11948 hash_buf.salt->salt_len = i;
11949
11950 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11951 }
11952 }
11953 else if (hash_mode == 2500)
11954 {
11955 if (i < 64) // 64 = 16 * uint in salt_buf[]
11956 {
11957 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11958 // manipulate salt_buf
11959
11960 memcpy (line_buf_cpy, line_buf, i);
11961
11962 char *mac2_pos = strrchr (line_buf_cpy, ':');
11963
11964 if (mac2_pos == NULL) continue;
11965
11966 mac2_pos[0] = 0;
11967 mac2_pos++;
11968
11969 if (strlen (mac2_pos) != 12) continue;
11970
11971 char *mac1_pos = strrchr (line_buf_cpy, ':');
11972
11973 if (mac1_pos == NULL) continue;
11974
11975 mac1_pos[0] = 0;
11976 mac1_pos++;
11977
11978 if (strlen (mac1_pos) != 12) continue;
11979
11980 uint essid_length = mac1_pos - line_buf_cpy - 1;
11981
11982 // here we need the ESSID
11983 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11984
11985 hash_buf.salt->salt_len = essid_length;
11986
11987 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11988
11989 if (found)
11990 {
11991 wpa_t *wpa = (wpa_t *) found->esalt;
11992
11993 // compare hex string(s) vs binary MAC address(es)
11994
11995 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11996 {
11997 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11998 {
11999 found = NULL;
12000
12001 break;
12002 }
12003 }
12004
12005 // early skip ;)
12006 if (!found) continue;
12007
12008 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12009 {
12010 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12011 {
12012 found = NULL;
12013
12014 break;
12015 }
12016 }
12017 }
12018 }
12019 }
12020 else
12021 {
12022 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12023
12024 if (parser_status == PARSER_OK)
12025 {
12026 if (isSalted)
12027 {
12028 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12029 }
12030 else
12031 {
12032 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12033 }
12034 }
12035 }
12036
12037 if (found == NULL) continue;
12038
12039 if (!found->cracked) potfile_remove_cracks++;
12040
12041 found->cracked = 1;
12042
12043 if (found) break;
12044
12045 iter--;
12046 }
12047 }
12048
12049 myfree (line_buf_cpy);
12050
12051 myfree (line_buf);
12052
12053 fclose (fp);
12054 }
12055 }
12056
12057 if (esalt_size)
12058 {
12059 local_free (hash_buf.esalt);
12060 }
12061
12062 if (isSalted)
12063 {
12064 local_free (hash_buf.salt);
12065 }
12066
12067 local_free (hash_buf.digest);
12068 }
12069
12070 /**
12071 * Now generate all the buffers required for later
12072 */
12073
12074 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12075
12076 salt_t *salts_buf_new = NULL;
12077 void *esalts_buf_new = NULL;
12078
12079 if (isSalted)
12080 {
12081 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12082
12083 if (esalt_size)
12084 {
12085 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12086 }
12087 }
12088 else
12089 {
12090 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12091 }
12092
12093 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12094
12095 uint digests_cnt = hashes_cnt;
12096 uint digests_done = 0;
12097
12098 uint size_digests = digests_cnt * dgst_size;
12099 uint size_shown = digests_cnt * sizeof (uint);
12100
12101 uint *digests_shown = (uint *) mymalloc (size_shown);
12102 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12103
12104 uint salts_cnt = 0;
12105 uint salts_done = 0;
12106
12107 hashinfo_t **hash_info = NULL;
12108
12109 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12110 {
12111 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12112
12113 if (username && (remove || show))
12114 {
12115 uint user_pos;
12116
12117 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12118 {
12119 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12120
12121 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12122 }
12123 }
12124 }
12125
12126 uint *salts_shown = (uint *) mymalloc (size_shown);
12127
12128 salt_t *salt_buf;
12129
12130 {
12131 // copied from inner loop
12132
12133 salt_buf = &salts_buf_new[salts_cnt];
12134
12135 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12136
12137 if (esalt_size)
12138 {
12139 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12140 }
12141
12142 salt_buf->digests_cnt = 0;
12143 salt_buf->digests_done = 0;
12144 salt_buf->digests_offset = 0;
12145
12146 salts_cnt++;
12147 }
12148
12149 if (hashes_buf[0].cracked == 1)
12150 {
12151 digests_shown[0] = 1;
12152
12153 digests_done++;
12154
12155 salt_buf->digests_done++;
12156 }
12157
12158 salt_buf->digests_cnt++;
12159
12160 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12161
12162 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12163 {
12164 hash_info[0] = hashes_buf[0].hash_info;
12165 }
12166
12167 // copy from inner loop
12168
12169 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12170 {
12171 if (isSalted)
12172 {
12173 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12174 {
12175 salt_buf = &salts_buf_new[salts_cnt];
12176
12177 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12178
12179 if (esalt_size)
12180 {
12181 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12182 }
12183
12184 salt_buf->digests_cnt = 0;
12185 salt_buf->digests_done = 0;
12186 salt_buf->digests_offset = hashes_pos;
12187
12188 salts_cnt++;
12189 }
12190 }
12191
12192 if (hashes_buf[hashes_pos].cracked == 1)
12193 {
12194 digests_shown[hashes_pos] = 1;
12195
12196 digests_done++;
12197
12198 salt_buf->digests_done++;
12199 }
12200
12201 salt_buf->digests_cnt++;
12202
12203 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12204
12205 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12206 {
12207 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12208 }
12209 }
12210
12211 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12212 {
12213 salt_t *salt_buf = &salts_buf_new[salt_pos];
12214
12215 if (salt_buf->digests_done == salt_buf->digests_cnt)
12216 {
12217 salts_shown[salt_pos] = 1;
12218
12219 salts_done++;
12220 }
12221
12222 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12223 }
12224
12225 local_free (digests_buf);
12226 local_free (salts_buf);
12227 local_free (esalts_buf);
12228
12229 digests_buf = digests_buf_new;
12230 salts_buf = salts_buf_new;
12231 esalts_buf = esalts_buf_new;
12232
12233 local_free (hashes_buf);
12234
12235 /**
12236 * special modification not set from parser
12237 */
12238
12239 switch (hash_mode)
12240 {
12241 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12242 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12243 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12244 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12245 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12246 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12247 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12248 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12249 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12250 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12251 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12252 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12253 }
12254
12255 if (truecrypt_keyfiles)
12256 {
12257 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12258
12259 char *keyfiles = strdup (truecrypt_keyfiles);
12260
12261 char *keyfile = strtok (keyfiles, ",");
12262
12263 do
12264 {
12265 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12266
12267 } while ((keyfile = strtok (NULL, ",")) != NULL);
12268
12269 free (keyfiles);
12270 }
12271
12272 data.digests_cnt = digests_cnt;
12273 data.digests_done = digests_done;
12274 data.digests_buf = digests_buf;
12275 data.digests_shown = digests_shown;
12276 data.digests_shown_tmp = digests_shown_tmp;
12277
12278 data.salts_cnt = salts_cnt;
12279 data.salts_done = salts_done;
12280 data.salts_buf = salts_buf;
12281 data.salts_shown = salts_shown;
12282
12283 data.esalts_buf = esalts_buf;
12284 data.hash_info = hash_info;
12285
12286 /**
12287 * Automatic Optimizers
12288 */
12289
12290 if (salts_cnt == 1)
12291 opti_type |= OPTI_TYPE_SINGLE_SALT;
12292
12293 if (digests_cnt == 1)
12294 opti_type |= OPTI_TYPE_SINGLE_HASH;
12295
12296 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12297 opti_type |= OPTI_TYPE_NOT_ITERATED;
12298
12299 if (attack_mode == ATTACK_MODE_BF)
12300 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12301
12302 data.opti_type = opti_type;
12303
12304 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12305 {
12306 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12307 {
12308 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12309 {
12310 if (opts_type & OPTS_TYPE_ST_ADD80)
12311 {
12312 opts_type &= ~OPTS_TYPE_ST_ADD80;
12313 opts_type |= OPTS_TYPE_PT_ADD80;
12314 }
12315
12316 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12317 {
12318 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12319 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12320 }
12321
12322 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12323 {
12324 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12325 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12326 }
12327 }
12328 }
12329 }
12330
12331 /**
12332 * Some algorithm, like descrypt, can benefit from JIT compilation
12333 */
12334
12335 int force_jit_compilation = -1;
12336
12337 if (hash_mode == 8900)
12338 {
12339 force_jit_compilation = 8900;
12340 }
12341 else if (hash_mode == 9300)
12342 {
12343 force_jit_compilation = 8900;
12344 }
12345 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12346 {
12347 force_jit_compilation = 1500;
12348 }
12349
12350 /**
12351 * generate bitmap tables
12352 */
12353
12354 const uint bitmap_shift1 = 5;
12355 const uint bitmap_shift2 = 13;
12356
12357 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12358
12359 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12360 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12361 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12362 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12363 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12364 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12365 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12366 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12367
12368 uint bitmap_bits;
12369 uint bitmap_nums;
12370 uint bitmap_mask;
12371 uint bitmap_size;
12372
12373 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12374 {
12375 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12376
12377 bitmap_nums = 1 << bitmap_bits;
12378
12379 bitmap_mask = bitmap_nums - 1;
12380
12381 bitmap_size = bitmap_nums * sizeof (uint);
12382
12383 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12384
12385 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;
12386 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;
12387
12388 break;
12389 }
12390
12391 bitmap_nums = 1 << bitmap_bits;
12392
12393 bitmap_mask = bitmap_nums - 1;
12394
12395 bitmap_size = bitmap_nums * sizeof (uint);
12396
12397 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);
12398 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);
12399
12400 /**
12401 * prepare quick rule
12402 */
12403
12404 data.rule_buf_l = rule_buf_l;
12405 data.rule_buf_r = rule_buf_r;
12406
12407 int rule_len_l = (int) strlen (rule_buf_l);
12408 int rule_len_r = (int) strlen (rule_buf_r);
12409
12410 data.rule_len_l = rule_len_l;
12411 data.rule_len_r = rule_len_r;
12412
12413 /**
12414 * load rules
12415 */
12416
12417 uint *all_kernel_rules_cnt = NULL;
12418
12419 kernel_rule_t **all_kernel_rules_buf = NULL;
12420
12421 if (rp_files_cnt)
12422 {
12423 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12424
12425 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12426 }
12427
12428 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12429
12430 int rule_len = 0;
12431
12432 for (uint i = 0; i < rp_files_cnt; i++)
12433 {
12434 uint kernel_rules_avail = 0;
12435
12436 uint kernel_rules_cnt = 0;
12437
12438 kernel_rule_t *kernel_rules_buf = NULL;
12439
12440 char *rp_file = rp_files[i];
12441
12442 char in[BLOCK_SIZE] = { 0 };
12443 char out[BLOCK_SIZE] = { 0 };
12444
12445 FILE *fp = NULL;
12446
12447 uint rule_line = 0;
12448
12449 if ((fp = fopen (rp_file, "rb")) == NULL)
12450 {
12451 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12452
12453 return (-1);
12454 }
12455
12456 while (!feof (fp))
12457 {
12458 memset (rule_buf, 0, HCBUFSIZ);
12459
12460 rule_len = fgetl (fp, rule_buf);
12461
12462 rule_line++;
12463
12464 if (rule_len == 0) continue;
12465
12466 if (rule_buf[0] == '#') continue;
12467
12468 if (kernel_rules_avail == kernel_rules_cnt)
12469 {
12470 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12471
12472 kernel_rules_avail += INCR_RULES;
12473 }
12474
12475 memset (in, 0, BLOCK_SIZE);
12476 memset (out, 0, BLOCK_SIZE);
12477
12478 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12479
12480 if (result == -1)
12481 {
12482 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12483
12484 continue;
12485 }
12486
12487 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12488 {
12489 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12490
12491 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12492
12493 continue;
12494 }
12495
12496 /* its so slow
12497 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12498 {
12499 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12500
12501 continue;
12502 }
12503 */
12504
12505 kernel_rules_cnt++;
12506 }
12507
12508 fclose (fp);
12509
12510 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12511
12512 all_kernel_rules_buf[i] = kernel_rules_buf;
12513 }
12514
12515 /**
12516 * merge rules or automatic rule generator
12517 */
12518
12519 uint kernel_rules_cnt = 0;
12520
12521 kernel_rule_t *kernel_rules_buf = NULL;
12522
12523 if (attack_mode == ATTACK_MODE_STRAIGHT)
12524 {
12525 if (rp_files_cnt)
12526 {
12527 kernel_rules_cnt = 1;
12528
12529 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12530
12531 repeats[0] = kernel_rules_cnt;
12532
12533 for (uint i = 0; i < rp_files_cnt; i++)
12534 {
12535 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12536
12537 repeats[i + 1] = kernel_rules_cnt;
12538 }
12539
12540 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12541
12542 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12543
12544 for (uint i = 0; i < kernel_rules_cnt; i++)
12545 {
12546 uint out_pos = 0;
12547
12548 kernel_rule_t *out = &kernel_rules_buf[i];
12549
12550 for (uint j = 0; j < rp_files_cnt; j++)
12551 {
12552 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12553 uint in_pos;
12554
12555 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12556
12557 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12558 {
12559 if (out_pos == RULES_MAX - 1)
12560 {
12561 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12562
12563 break;
12564 }
12565
12566 out->cmds[out_pos] = in->cmds[in_pos];
12567 }
12568 }
12569 }
12570
12571 local_free (repeats);
12572 }
12573 else if (rp_gen)
12574 {
12575 uint kernel_rules_avail = 0;
12576
12577 while (kernel_rules_cnt < rp_gen)
12578 {
12579 if (kernel_rules_avail == kernel_rules_cnt)
12580 {
12581 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12582
12583 kernel_rules_avail += INCR_RULES;
12584 }
12585
12586 memset (rule_buf, 0, HCBUFSIZ);
12587
12588 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12589
12590 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12591
12592 kernel_rules_cnt++;
12593 }
12594 }
12595 }
12596
12597 myfree (rule_buf);
12598
12599 /**
12600 * generate NOP rules
12601 */
12602
12603 if (kernel_rules_cnt == 0)
12604 {
12605 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12606
12607 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12608
12609 kernel_rules_cnt++;
12610 }
12611
12612 data.kernel_rules_cnt = kernel_rules_cnt;
12613 data.kernel_rules_buf = kernel_rules_buf;
12614
12615 /**
12616 * OpenCL platforms: detect
12617 */
12618
12619 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12620 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12621
12622 cl_uint platforms_cnt = 0;
12623 cl_uint platform_devices_cnt = 0;
12624
12625 if (keyspace == 0)
12626 {
12627 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12628
12629 if (platforms_cnt == 0)
12630 {
12631 log_error ("ERROR: No OpenCL compatible platform found");
12632
12633 return (-1);
12634 }
12635
12636 if (opencl_platforms_filter != (uint) -1)
12637 {
12638 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12639
12640 if (opencl_platforms_filter > platform_cnt_mask)
12641 {
12642 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12643
12644 return (-1);
12645 }
12646 }
12647 }
12648
12649 /**
12650 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12651 */
12652
12653 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12654 {
12655 cl_platform_id platform = platforms[platform_id];
12656
12657 char platform_vendor[INFOSZ] = { 0 };
12658
12659 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12660
12661 #ifdef HAVE_HWMON
12662 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12663 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12664 {
12665 // make sure that we do not directly control the fan for NVidia
12666
12667 gpu_temp_retain = 0;
12668
12669 data.gpu_temp_retain = gpu_temp_retain;
12670 }
12671 #endif // HAVE_NVML || HAVE_NVAPI
12672 #endif
12673 }
12674
12675 /**
12676 * OpenCL devices: simply push all devices from all platforms into the same device array
12677 */
12678
12679 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12680
12681 data.devices_param = devices_param;
12682
12683 uint devices_cnt = 0;
12684
12685 uint devices_active = 0;
12686
12687 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12688 {
12689 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12690
12691 cl_platform_id platform = platforms[platform_id];
12692
12693 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12694
12695 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12696 {
12697 size_t param_value_size = 0;
12698
12699 const uint device_id = devices_cnt;
12700
12701 hc_device_param_t *device_param = &data.devices_param[device_id];
12702
12703 device_param->device = platform_devices[platform_devices_id];
12704
12705 device_param->device_id = device_id;
12706
12707 device_param->platform_devices_id = platform_devices_id;
12708
12709 // device_type
12710
12711 cl_device_type device_type;
12712
12713 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12714
12715 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12716
12717 device_param->device_type = device_type;
12718
12719 // vendor_id
12720
12721 cl_uint vendor_id = 0;
12722
12723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12724
12725 device_param->vendor_id = vendor_id;
12726
12727 // device_name
12728
12729 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12730
12731 char *device_name = (char *) mymalloc (param_value_size);
12732
12733 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12734
12735 device_param->device_name = device_name;
12736
12737 // tuning db
12738
12739 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12740
12741 // device_version
12742
12743 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12744
12745 char *device_version = (char *) mymalloc (param_value_size);
12746
12747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12748
12749 device_param->device_version = device_version;
12750
12751 // device_opencl_version
12752
12753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12754
12755 char *device_opencl_version = (char *) mymalloc (param_value_size);
12756
12757 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12758
12759 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12760
12761 myfree (device_opencl_version);
12762
12763 if (strstr (device_version, "pocl"))
12764 {
12765 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12766 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12767
12768 cl_uint vendor_id = VENDOR_ID_GENERIC;
12769
12770 device_param->vendor_id = vendor_id;
12771 }
12772
12773 // vector_width
12774
12775 cl_uint vector_width;
12776
12777 if (opencl_vector_width_chgd == 0)
12778 {
12779 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12780 {
12781 if (opti_type & OPTI_TYPE_USES_BITS_64)
12782 {
12783 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12784 }
12785 else
12786 {
12787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12788 }
12789 }
12790 else
12791 {
12792 vector_width = (cl_uint) tuningdb_entry->vector_width;
12793 }
12794 }
12795 else
12796 {
12797 vector_width = opencl_vector_width;
12798 }
12799
12800 if (vector_width > 16) vector_width = 16;
12801
12802 device_param->vector_width = vector_width;
12803
12804 // max_compute_units
12805
12806 cl_uint device_processors;
12807
12808 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12809
12810 device_param->device_processors = device_processors;
12811
12812 // max_mem_alloc_size
12813
12814 cl_ulong device_maxmem_alloc;
12815
12816 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12817
12818 device_param->device_maxmem_alloc = device_maxmem_alloc;
12819
12820 // max_mem_alloc_size
12821
12822 cl_ulong device_global_mem;
12823
12824 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12825
12826 device_param->device_global_mem = device_global_mem;
12827
12828 // max_clock_frequency
12829
12830 cl_uint device_maxclock_frequency;
12831
12832 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12833
12834 device_param->device_maxclock_frequency = device_maxclock_frequency;
12835
12836 // skipped
12837
12838 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12839 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12840
12841 device_param->skipped = (skipped1 || skipped2);
12842
12843 // driver_version
12844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12845
12846 char *driver_version = (char *) mymalloc (param_value_size);
12847
12848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12849
12850 device_param->driver_version = driver_version;
12851
12852 // device_name_chksum
12853
12854 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12855
12856 #if __x86_64__
12857 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);
12858 #else
12859 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);
12860 #endif
12861
12862 uint device_name_digest[4] = { 0 };
12863
12864 md5_64 ((uint *) device_name_chksum, device_name_digest);
12865
12866 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12867
12868 device_param->device_name_chksum = device_name_chksum;
12869
12870 // device_processor_cores
12871
12872 if (device_type & CL_DEVICE_TYPE_CPU)
12873 {
12874 cl_uint device_processor_cores = 1;
12875
12876 device_param->device_processor_cores = device_processor_cores;
12877 }
12878
12879 if (device_type & CL_DEVICE_TYPE_GPU)
12880 {
12881 if (vendor_id == VENDOR_ID_AMD)
12882 {
12883 cl_uint device_processor_cores = 0;
12884
12885 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12886
12887 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12888
12889 device_param->device_processor_cores = device_processor_cores;
12890 }
12891 else if (vendor_id == VENDOR_ID_NV)
12892 {
12893 cl_uint kernel_exec_timeout = 0;
12894
12895 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12896
12897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12898
12899 device_param->kernel_exec_timeout = kernel_exec_timeout;
12900
12901 cl_uint device_processor_cores = 0;
12902
12903 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12904
12905 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12906
12907 device_param->device_processor_cores = device_processor_cores;
12908
12909 cl_uint sm_minor = 0;
12910 cl_uint sm_major = 0;
12911
12912 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12913 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12914
12915 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12916 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12917
12918 device_param->sm_minor = sm_minor;
12919 device_param->sm_major = sm_major;
12920 }
12921 else
12922 {
12923 cl_uint device_processor_cores = 1;
12924
12925 device_param->device_processor_cores = device_processor_cores;
12926 }
12927 }
12928
12929 // display results
12930
12931 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12932 {
12933 if (device_param->skipped == 0)
12934 {
12935 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12936 device_id + 1,
12937 device_name,
12938 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12939 (unsigned int) (device_global_mem / 1024 / 1024),
12940 (unsigned int) (device_maxclock_frequency),
12941 (unsigned int) device_processors);
12942 }
12943 else
12944 {
12945 log_info ("Device #%u: %s, skipped",
12946 device_id + 1,
12947 device_name);
12948 }
12949 }
12950
12951 // common driver check
12952
12953 if (device_param->skipped == 0)
12954 {
12955 if (strstr (device_version, "pocl"))
12956 {
12957 if (force == 0)
12958 {
12959 log_info ("");
12960 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12961 log_info ("You are STRONGLY encouraged not to use it");
12962 log_info ("You can use --force to override this but do not post error reports if you do so");
12963 log_info ("");
12964
12965 return (-1);
12966 }
12967 }
12968
12969 if (device_type & CL_DEVICE_TYPE_GPU)
12970 {
12971 if (vendor_id == VENDOR_ID_NV)
12972 {
12973 if (device_param->kernel_exec_timeout != 0)
12974 {
12975 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);
12976 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12977 }
12978 }
12979 else if (vendor_id == VENDOR_ID_AMD)
12980 {
12981 int catalyst_check = (force == 1) ? 0 : 1;
12982
12983 int catalyst_warn = 0;
12984
12985 int catalyst_broken = 0;
12986
12987 if (catalyst_check == 1)
12988 {
12989 catalyst_warn = 1;
12990
12991 // v14.9 and higher
12992 if (atoi (device_param->driver_version) >= 1573)
12993 {
12994 catalyst_warn = 0;
12995 }
12996
12997 catalyst_check = 0;
12998 }
12999
13000 if (catalyst_broken == 1)
13001 {
13002 log_info ("");
13003 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13004 log_info ("It will pass over cracked hashes and does not report them as cracked");
13005 log_info ("You are STRONGLY encouraged not to use it");
13006 log_info ("You can use --force to override this but do not post error reports if you do so");
13007 log_info ("");
13008
13009 return (-1);
13010 }
13011
13012 if (catalyst_warn == 1)
13013 {
13014 log_info ("");
13015 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13016 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13017 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13018 #ifdef _WIN
13019 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13020 #endif
13021 log_info ("You can use --force to override this but do not post error reports if you do so");
13022 log_info ("");
13023
13024 return (-1);
13025 }
13026 }
13027 }
13028
13029 /**
13030 * kernel accel and loops tuning db adjustment
13031 */
13032
13033 device_param->kernel_accel_min = 1;
13034 device_param->kernel_accel_max = 1024;
13035
13036 device_param->kernel_loops_min = 1;
13037 device_param->kernel_loops_max = 1024;
13038
13039 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13040
13041 if (tuningdb_entry)
13042 {
13043 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13044 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13045
13046 if (_kernel_accel)
13047 {
13048 device_param->kernel_accel_min = _kernel_accel;
13049 device_param->kernel_accel_max = _kernel_accel;
13050 }
13051
13052 if (_kernel_loops)
13053 {
13054 if (workload_profile == 1)
13055 {
13056 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13057 }
13058 else if (workload_profile == 2)
13059 {
13060 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13061 }
13062
13063 device_param->kernel_loops_min = _kernel_loops;
13064 device_param->kernel_loops_max = _kernel_loops;
13065 }
13066 }
13067
13068 // commandline parameters overwrite tuningdb entries
13069
13070 if (kernel_accel)
13071 {
13072 device_param->kernel_accel_min = kernel_accel;
13073 device_param->kernel_accel_max = kernel_accel;
13074 }
13075
13076 if (kernel_loops)
13077 {
13078 device_param->kernel_loops_min = kernel_loops;
13079 device_param->kernel_loops_max = kernel_loops;
13080 }
13081
13082 /**
13083 * activate device
13084 */
13085
13086 devices_active++;
13087 }
13088
13089 // next please
13090
13091 devices_cnt++;
13092 }
13093 }
13094
13095 if (keyspace == 0 && devices_active == 0)
13096 {
13097 log_error ("ERROR: No devices found/left");
13098
13099 return (-1);
13100 }
13101
13102 // 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)
13103
13104 if (devices_filter != (uint) -1)
13105 {
13106 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13107
13108 if (devices_filter > devices_cnt_mask)
13109 {
13110 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13111
13112 return (-1);
13113 }
13114 }
13115
13116 data.devices_cnt = devices_cnt;
13117
13118 data.devices_active = devices_active;
13119
13120 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13121 {
13122 log_info ("");
13123 }
13124
13125 /**
13126 * HM devices: init
13127 */
13128
13129 #ifdef HAVE_HWMON
13130 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13131 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13132 #endif
13133
13134 #ifdef HAVE_ADL
13135 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13136 #endif
13137
13138 if (gpu_temp_disable == 0)
13139 {
13140 #if defined(WIN) && defined(HAVE_NVAPI)
13141 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13142
13143 if (nvapi_init (nvapi) == 0)
13144 data.hm_nv = nvapi;
13145
13146 if (data.hm_nv)
13147 {
13148 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13149 {
13150 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13151
13152 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13153
13154 int tmp_out = 0;
13155
13156 for (int i = 0; i < tmp_in; i++)
13157 {
13158 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13159 }
13160
13161 for (int i = 0; i < tmp_out; i++)
13162 {
13163 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13164
13165 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13166
13167 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;
13168 }
13169 }
13170 }
13171 #endif // WIN && HAVE_NVAPI
13172
13173 #if defined(LINUX) && defined(HAVE_NVML)
13174 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13175
13176 if (nvml_init (nvml) == 0)
13177 data.hm_nv = nvml;
13178
13179 if (data.hm_nv)
13180 {
13181 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13182 {
13183 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13184
13185 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13186
13187 int tmp_out = 0;
13188
13189 for (int i = 0; i < tmp_in; i++)
13190 {
13191 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13192 }
13193
13194 for (int i = 0; i < tmp_out; i++)
13195 {
13196 unsigned int speed;
13197
13198 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;
13199 }
13200 }
13201 }
13202 #endif // LINUX && HAVE_NVML
13203
13204 data.hm_amd = NULL;
13205
13206 #ifdef HAVE_ADL
13207 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13208
13209 if (adl_init (adl) == 0)
13210 data.hm_amd = adl;
13211
13212 if (data.hm_amd)
13213 {
13214 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13215 {
13216 // total number of adapters
13217
13218 int hm_adapters_num;
13219
13220 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13221
13222 // adapter info
13223
13224 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13225
13226 if (lpAdapterInfo == NULL) return (-1);
13227
13228 // get a list (of ids of) valid/usable adapters
13229
13230 int num_adl_adapters = 0;
13231
13232 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13233
13234 if (num_adl_adapters > 0)
13235 {
13236 hc_thread_mutex_lock (mux_adl);
13237
13238 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13239
13240 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13241
13242 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13243 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13244
13245 hc_thread_mutex_unlock (mux_adl);
13246 }
13247
13248 myfree (valid_adl_device_list);
13249 myfree (lpAdapterInfo);
13250 }
13251 }
13252 #endif // HAVE_ADL
13253
13254 if (data.hm_amd == NULL && data.hm_nv == NULL)
13255 {
13256 gpu_temp_disable = 1;
13257 }
13258 }
13259
13260 /**
13261 * OpenCL devices: allocate buffer for device specific information
13262 */
13263
13264 #ifdef HAVE_HWMON
13265 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13266
13267 #ifdef HAVE_ADL
13268 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13269
13270 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13271 #endif // ADL
13272 #endif
13273
13274 /**
13275 * enable custom signal handler(s)
13276 */
13277
13278 if (benchmark == 0)
13279 {
13280 hc_signal (sigHandler_default);
13281 }
13282 else
13283 {
13284 hc_signal (sigHandler_benchmark);
13285 }
13286
13287 /**
13288 * User-defined GPU temp handling
13289 */
13290
13291 #ifdef HAVE_HWMON
13292 if (gpu_temp_disable == 1)
13293 {
13294 gpu_temp_abort = 0;
13295 gpu_temp_retain = 0;
13296 }
13297
13298 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13299 {
13300 if (gpu_temp_abort < gpu_temp_retain)
13301 {
13302 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13303
13304 return (-1);
13305 }
13306 }
13307
13308 data.gpu_temp_disable = gpu_temp_disable;
13309 data.gpu_temp_abort = gpu_temp_abort;
13310 data.gpu_temp_retain = gpu_temp_retain;
13311 #endif
13312
13313 /**
13314 * inform the user
13315 */
13316
13317 if (data.quiet == 0)
13318 {
13319 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13320
13321 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);
13322
13323 if (attack_mode == ATTACK_MODE_STRAIGHT)
13324 {
13325 log_info ("Rules: %u", kernel_rules_cnt);
13326 }
13327
13328 if (opti_type)
13329 {
13330 log_info ("Applicable Optimizers:");
13331
13332 for (uint i = 0; i < 32; i++)
13333 {
13334 const uint opti_bit = 1u << i;
13335
13336 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13337 }
13338 }
13339
13340 /**
13341 * Watchdog and Temperature balance
13342 */
13343
13344 #ifdef HAVE_HWMON
13345 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13346 {
13347 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13348 }
13349
13350 if (gpu_temp_abort == 0)
13351 {
13352 log_info ("Watchdog: Temperature abort trigger disabled");
13353 }
13354 else
13355 {
13356 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13357 }
13358
13359 if (gpu_temp_retain == 0)
13360 {
13361 log_info ("Watchdog: Temperature retain trigger disabled");
13362 }
13363 else
13364 {
13365 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13366 }
13367 #endif
13368 }
13369
13370 if (data.quiet == 0) log_info ("");
13371
13372 /**
13373 * HM devices: copy
13374 */
13375
13376 if (gpu_temp_disable == 0)
13377 {
13378 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13379 {
13380 hc_device_param_t *device_param = &data.devices_param[device_id];
13381
13382 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13383
13384 if (device_param->skipped) continue;
13385
13386 const uint platform_devices_id = device_param->platform_devices_id;
13387
13388 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13389 if (device_param->vendor_id == VENDOR_ID_NV)
13390 {
13391 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13392 }
13393 #endif
13394
13395 #ifdef HAVE_ADL
13396 if (device_param->vendor_id == VENDOR_ID_AMD)
13397 {
13398 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13399 }
13400 #endif
13401 }
13402 }
13403
13404 /*
13405 * Temporary fix:
13406 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13407 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13408 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13409 * Driver / ADL bug?
13410 */
13411
13412 #ifdef HAVE_ADL
13413 if (powertune_enable == 1)
13414 {
13415 hc_thread_mutex_lock (mux_adl);
13416
13417 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13418 {
13419 hc_device_param_t *device_param = &data.devices_param[device_id];
13420
13421 if (device_param->skipped) continue;
13422
13423 if (data.hm_device[device_id].od_version == 6)
13424 {
13425 // set powertune value only
13426
13427 int powertune_supported = 0;
13428
13429 int ADL_rc = 0;
13430
13431 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13432 {
13433 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13434
13435 return (-1);
13436 }
13437
13438 if (powertune_supported != 0)
13439 {
13440 // powertune set
13441 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13442
13443 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13444 {
13445 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13446
13447 return (-1);
13448 }
13449
13450 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13451 {
13452 log_error ("ERROR: Failed to set new ADL PowerControl values");
13453
13454 return (-1);
13455 }
13456 }
13457 }
13458 }
13459
13460 hc_thread_mutex_unlock (mux_adl);
13461 }
13462 #endif // HAVE_ADK
13463 #endif // HAVE_HWMON
13464
13465 #ifdef DEBUG
13466 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13467 #endif
13468
13469 uint kernel_power_all = 0;
13470
13471 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13472 {
13473 /**
13474 * host buffer
13475 */
13476
13477 hc_device_param_t *device_param = &data.devices_param[device_id];
13478
13479 if (device_param->skipped) continue;
13480
13481 /**
13482 * device properties
13483 */
13484
13485 const char *device_name_chksum = device_param->device_name_chksum;
13486 const u32 device_processors = device_param->device_processors;
13487 const u32 device_processor_cores = device_param->device_processor_cores;
13488
13489 /**
13490 * create context for each device
13491 */
13492
13493 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13494
13495 /**
13496 * create command-queue
13497 */
13498
13499 // not supported with NV
13500 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13501
13502 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13503
13504 /**
13505 * create input buffers on device : calculate size of fixed memory buffers
13506 */
13507
13508 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13509 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13510
13511 device_param->size_root_css = size_root_css;
13512 device_param->size_markov_css = size_markov_css;
13513
13514 uint size_results = KERNEL_THREADS * sizeof (uint);
13515
13516 device_param->size_results = size_results;
13517
13518 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13519 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13520
13521 uint size_plains = digests_cnt * sizeof (plain_t);
13522 uint size_salts = salts_cnt * sizeof (salt_t);
13523 uint size_esalts = salts_cnt * esalt_size;
13524
13525 device_param->size_plains = size_plains;
13526 device_param->size_digests = size_digests;
13527 device_param->size_shown = size_shown;
13528 device_param->size_salts = size_salts;
13529
13530 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13531 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13532 uint size_tm = 32 * sizeof (bs_word_t);
13533
13534 // scryptV stuff
13535
13536 u64 size_scryptV = 1;
13537
13538 if ((hash_mode == 8900) || (hash_mode == 9300))
13539 {
13540 uint tmto_start = 0;
13541 uint tmto_stop = 10;
13542
13543 if (scrypt_tmto)
13544 {
13545 tmto_start = scrypt_tmto;
13546 }
13547 else
13548 {
13549 // in case the user did not specify the tmto manually
13550 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13551 // but set the lower end only in case the user has a device with too less memory
13552
13553 if (hash_mode == 8900)
13554 {
13555 if (device_param->vendor_id == VENDOR_ID_AMD)
13556 {
13557 tmto_start = 1;
13558 }
13559 else if (device_param->vendor_id == VENDOR_ID_NV)
13560 {
13561 tmto_start = 3;
13562 }
13563 }
13564 else if (hash_mode == 9300)
13565 {
13566 if (device_param->vendor_id == VENDOR_ID_AMD)
13567 {
13568 tmto_start = 3;
13569 }
13570 else if (device_param->vendor_id == VENDOR_ID_NV)
13571 {
13572 tmto_start = 5;
13573 }
13574 }
13575 }
13576
13577 if (quiet == 0) log_info ("");
13578
13579 uint shader_per_mp = 1;
13580
13581 if (device_param->vendor_id == VENDOR_ID_AMD)
13582 {
13583 shader_per_mp = 8;
13584 }
13585 else if (device_param->vendor_id == VENDOR_ID_NV)
13586 {
13587 shader_per_mp = 32;
13588 }
13589
13590 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13591 {
13592 // TODO: in theory the following calculation needs to be done per salt, not global
13593 // we assume all hashes have the same scrypt settings
13594
13595 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13596
13597 size_scryptV /= 1 << tmto;
13598
13599 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13600
13601 if (size_scryptV > device_param->device_maxmem_alloc)
13602 {
13603 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13604
13605 continue;
13606 }
13607
13608 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13609 {
13610 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13611 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13612 }
13613
13614 break;
13615 }
13616
13617 if (data.salts_buf[0].scrypt_phy == 0)
13618 {
13619 log_error ("ERROR: can't allocate enough device memory");
13620
13621 return -1;
13622 }
13623
13624 if (quiet == 0) log_info ("");
13625 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13626 }
13627
13628 /**
13629 * create input buffers on device : calculate size of dynamic size memory buffers
13630 */
13631
13632 uint kernel_threads = KERNEL_THREADS;
13633
13634 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13635
13636 if (hash_mode == 3200) kernel_threads = 8;
13637 if (hash_mode == 9000) kernel_threads = 8;
13638
13639 /**
13640 * some algorithms need a fixed kernel-loops count
13641 */
13642
13643 if (hash_mode == 1500)
13644 {
13645 const u32 kernel_loops_fixed = 1024;
13646
13647 device_param->kernel_loops_min = kernel_loops_fixed;
13648 device_param->kernel_loops_max = kernel_loops_fixed;
13649 }
13650
13651 if (hash_mode == 3000)
13652 {
13653 const u32 kernel_loops_fixed = 1024;
13654
13655 device_param->kernel_loops_min = kernel_loops_fixed;
13656 device_param->kernel_loops_max = kernel_loops_fixed;
13657 }
13658
13659 if (hash_mode == 8900)
13660 {
13661 const u32 kernel_loops_fixed = 1;
13662
13663 device_param->kernel_loops_min = kernel_loops_fixed;
13664 device_param->kernel_loops_max = kernel_loops_fixed;
13665 }
13666
13667 if (hash_mode == 9300)
13668 {
13669 const u32 kernel_loops_fixed = 1;
13670
13671 device_param->kernel_loops_min = kernel_loops_fixed;
13672 device_param->kernel_loops_max = kernel_loops_fixed;
13673 }
13674
13675 if (hash_mode == 12500)
13676 {
13677 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13678
13679 device_param->kernel_loops_min = kernel_loops_fixed;
13680 device_param->kernel_loops_max = kernel_loops_fixed;
13681 }
13682
13683 /**
13684 * some algorithms have a maximum kernel-loops count
13685 */
13686
13687 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13688 {
13689 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13690 {
13691 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13692 }
13693 }
13694
13695 /**
13696 * some algorithms need a special kernel-accel
13697 */
13698
13699 if (hash_mode == 8900)
13700 {
13701 device_param->kernel_accel_min = 1;
13702 device_param->kernel_accel_max = 64;
13703 }
13704
13705 if (hash_mode == 9300)
13706 {
13707 device_param->kernel_accel_min = 1;
13708 device_param->kernel_accel_max = 64;
13709 }
13710
13711 u32 kernel_accel_min = device_param->kernel_accel_min;
13712 u32 kernel_accel_max = device_param->kernel_accel_max;
13713
13714 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13715
13716 uint size_pws = 4;
13717 uint size_tmps = 4;
13718 uint size_hooks = 4;
13719
13720 while (kernel_accel_max >= kernel_accel_min)
13721 {
13722 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13723
13724 // size_pws
13725
13726 size_pws = kernel_power_max * sizeof (pw_t);
13727
13728 // size_tmps
13729
13730 switch (hash_mode)
13731 {
13732 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13733 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13734 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13735 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13736 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13737 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13738 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13739 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13740 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13741 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13742 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13743 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13744 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13745 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13746 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13747 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13748 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13749 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13750 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13751 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13752 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13753 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13754 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13755 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13756 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13757 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13758 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13759 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13760 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13761 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13762 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13763 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13764 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13765 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13766 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13767 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13768 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13769 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13770 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13771 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13772 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13773 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13774 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13776 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13777 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13778 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13779 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13780 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13781 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13782 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13783 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13784 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13785 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13786 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13787 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13788 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13789 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13790 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13791 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13792 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13793 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13794 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13795 };
13796
13797 // size_hooks
13798
13799 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13800 {
13801 // none yet
13802 }
13803
13804 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13805 // if not, decrease amplifier and try again
13806
13807 int skip = 0;
13808
13809 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13810 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13811 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13812
13813 if (( bitmap_size
13814 + bitmap_size
13815 + bitmap_size
13816 + bitmap_size
13817 + bitmap_size
13818 + bitmap_size
13819 + bitmap_size
13820 + bitmap_size
13821 + size_bfs
13822 + size_combs
13823 + size_digests
13824 + size_esalts
13825 + size_hooks
13826 + size_markov_css
13827 + size_plains
13828 + size_pws
13829 + size_results
13830 + size_root_css
13831 + size_rules
13832 + size_rules_c
13833 + size_salts
13834 + size_scryptV
13835 + size_shown
13836 + size_tm
13837 + size_tmps) > device_param->device_global_mem) skip = 1;
13838
13839 if (skip == 1)
13840 {
13841 kernel_accel_max--;
13842
13843 continue;
13844 }
13845
13846 break;
13847 }
13848
13849 /*
13850 if (kernel_accel_max == 0)
13851 {
13852 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13853
13854 return -1;
13855 }
13856 */
13857
13858 device_param->kernel_accel_min = kernel_accel_min;
13859 device_param->kernel_accel_max = kernel_accel_max;
13860
13861 /*
13862 if (kernel_accel_max < kernel_accel)
13863 {
13864 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13865
13866 device_param->kernel_accel = kernel_accel_max;
13867 }
13868 */
13869
13870 device_param->size_bfs = size_bfs;
13871 device_param->size_combs = size_combs;
13872 device_param->size_rules = size_rules;
13873 device_param->size_rules_c = size_rules_c;
13874 device_param->size_pws = size_pws;
13875 device_param->size_tmps = size_tmps;
13876 device_param->size_hooks = size_hooks;
13877
13878 // do not confuse kernel_accel_max with kernel_accel here
13879
13880 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13881
13882 device_param->kernel_threads = kernel_threads;
13883 device_param->kernel_power_user = kernel_power;
13884
13885 kernel_power_all += kernel_power;
13886
13887 /**
13888 * default building options
13889 */
13890
13891 char build_opts[1024] = { 0 };
13892
13893 // we don't have sm_* on vendors not NV but it doesn't matter
13894
13895 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);
13896
13897 /**
13898 * main kernel
13899 */
13900
13901 {
13902 /**
13903 * kernel source filename
13904 */
13905
13906 char source_file[256] = { 0 };
13907
13908 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13909
13910 struct stat sst;
13911
13912 if (stat (source_file, &sst) == -1)
13913 {
13914 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13915
13916 return -1;
13917 }
13918
13919 /**
13920 * kernel cached filename
13921 */
13922
13923 char cached_file[256] = { 0 };
13924
13925 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13926
13927 int cached = 1;
13928
13929 struct stat cst;
13930
13931 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13932 {
13933 cached = 0;
13934 }
13935
13936 /**
13937 * kernel compile or load
13938 */
13939
13940 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13941
13942 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13943
13944 if (force_jit_compilation == -1)
13945 {
13946 if (cached == 0)
13947 {
13948 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13949
13950 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13951
13952 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13953
13954 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13955
13956 #ifdef DEBUG
13957 size_t build_log_size = 0;
13958
13959 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13960
13961 if (build_log_size > 1)
13962 {
13963 char *build_log = (char *) malloc (build_log_size + 1);
13964
13965 memset (build_log, 0, build_log_size + 1);
13966
13967 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13968
13969 puts (build_log);
13970
13971 free (build_log);
13972 }
13973 #endif
13974
13975 if (rc != 0)
13976 {
13977 device_param->skipped = true;
13978 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13979 continue;
13980 }
13981
13982 size_t binary_size;
13983
13984 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13985
13986 u8 *binary = (u8 *) mymalloc (binary_size);
13987
13988 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13989
13990 writeProgramBin (cached_file, binary, binary_size);
13991
13992 local_free (binary);
13993 }
13994 else
13995 {
13996 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13997
13998 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13999
14000 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14001
14002 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14003 }
14004 }
14005 else
14006 {
14007 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14008
14009 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14010
14011 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14012
14013 char build_opts_update[1024] = { 0 };
14014
14015 if (force_jit_compilation == 1500)
14016 {
14017 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14018 }
14019 else if (force_jit_compilation == 8900)
14020 {
14021 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);
14022 }
14023 else
14024 {
14025 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14026 }
14027
14028 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14029
14030 #ifdef DEBUG
14031 size_t build_log_size = 0;
14032
14033 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14034
14035 if (build_log_size > 1)
14036 {
14037 char *build_log = (char *) malloc (build_log_size + 1);
14038
14039 memset (build_log, 0, build_log_size + 1);
14040
14041 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14042
14043 puts (build_log);
14044
14045 free (build_log);
14046 }
14047 #endif
14048
14049 if (rc != 0)
14050 {
14051 device_param->skipped = true;
14052
14053 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14054 }
14055 }
14056
14057 local_free (kernel_lengths);
14058 local_free (kernel_sources[0]);
14059 local_free (kernel_sources);
14060 }
14061
14062 /**
14063 * word generator kernel
14064 */
14065
14066 if (attack_mode != ATTACK_MODE_STRAIGHT)
14067 {
14068 /**
14069 * kernel mp source filename
14070 */
14071
14072 char source_file[256] = { 0 };
14073
14074 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14075
14076 struct stat sst;
14077
14078 if (stat (source_file, &sst) == -1)
14079 {
14080 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14081
14082 return -1;
14083 }
14084
14085 /**
14086 * kernel mp cached filename
14087 */
14088
14089 char cached_file[256] = { 0 };
14090
14091 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14092
14093 int cached = 1;
14094
14095 struct stat cst;
14096
14097 if (stat (cached_file, &cst) == -1)
14098 {
14099 cached = 0;
14100 }
14101
14102 /**
14103 * kernel compile or load
14104 */
14105
14106 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14107
14108 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14109
14110 if (cached == 0)
14111 {
14112 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14113
14114 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14115
14116 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14117
14118 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14119
14120 if (rc != 0)
14121 {
14122 device_param->skipped = true;
14123 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14124 continue;
14125 }
14126
14127 size_t binary_size;
14128
14129 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14130
14131 u8 *binary = (u8 *) mymalloc (binary_size);
14132
14133 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14134
14135 writeProgramBin (cached_file, binary, binary_size);
14136
14137 local_free (binary);
14138 }
14139 else
14140 {
14141 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14142
14143 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14144
14145 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14146
14147 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14148 }
14149
14150 local_free (kernel_lengths);
14151 local_free (kernel_sources[0]);
14152 local_free (kernel_sources);
14153 }
14154
14155 /**
14156 * amplifier kernel
14157 */
14158
14159 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14160 {
14161
14162 }
14163 else
14164 {
14165 /**
14166 * kernel amp source filename
14167 */
14168
14169 char source_file[256] = { 0 };
14170
14171 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14172
14173 struct stat sst;
14174
14175 if (stat (source_file, &sst) == -1)
14176 {
14177 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14178
14179 return -1;
14180 }
14181
14182 /**
14183 * kernel amp cached filename
14184 */
14185
14186 char cached_file[256] = { 0 };
14187
14188 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14189
14190 int cached = 1;
14191
14192 struct stat cst;
14193
14194 if (stat (cached_file, &cst) == -1)
14195 {
14196 cached = 0;
14197 }
14198
14199 /**
14200 * kernel compile or load
14201 */
14202
14203 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14204
14205 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14206
14207 if (cached == 0)
14208 {
14209 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14210
14211 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14212
14213 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14214
14215 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14216
14217 if (rc != 0)
14218 {
14219 device_param->skipped = true;
14220 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14221 continue;
14222 }
14223
14224 size_t binary_size;
14225
14226 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14227
14228 u8 *binary = (u8 *) mymalloc (binary_size);
14229
14230 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14231
14232 writeProgramBin (cached_file, binary, binary_size);
14233
14234 local_free (binary);
14235 }
14236 else
14237 {
14238 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14239
14240 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14241
14242 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14243
14244 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14245 }
14246
14247 local_free (kernel_lengths);
14248 local_free (kernel_sources[0]);
14249 local_free (kernel_sources);
14250 }
14251
14252 // some algorithm collide too fast, make that impossible
14253
14254 if (benchmark == 1)
14255 {
14256 ((uint *) digests_buf)[0] = -1;
14257 ((uint *) digests_buf)[1] = -1;
14258 ((uint *) digests_buf)[2] = -1;
14259 ((uint *) digests_buf)[3] = -1;
14260 }
14261
14262 /**
14263 * global buffers
14264 */
14265
14266 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14267 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14268 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14269 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14270 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14271 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14272 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14273 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14274 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14275 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14276 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14277 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14278 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14279 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14280 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14281 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14282 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14283 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14284
14285 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);
14286 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);
14287 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);
14288 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);
14289 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);
14290 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);
14291 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);
14292 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);
14293 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14294 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14295 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14296
14297 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14298 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14299 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14300 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14301 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14302 run_kernel_bzero (device_param, device_param->d_result, size_results);
14303
14304 /**
14305 * special buffers
14306 */
14307
14308 if (attack_kern == ATTACK_KERN_STRAIGHT)
14309 {
14310 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14311 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14312
14313 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14314
14315 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14316 }
14317 else if (attack_kern == ATTACK_KERN_COMBI)
14318 {
14319 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14320 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14321 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14322 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14323
14324 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14325 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14326 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14327 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14328 }
14329 else if (attack_kern == ATTACK_KERN_BF)
14330 {
14331 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14332 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14333 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14334 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14335 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14336
14337 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14338 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14339 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14340 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14341 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14342 }
14343
14344 if (size_esalts)
14345 {
14346 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14347
14348 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14349 }
14350
14351 /**
14352 * main host data
14353 */
14354
14355 uint *result = (uint *) mymalloc (size_results);
14356
14357 device_param->result = result;
14358
14359 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14360
14361 device_param->pws_buf = pws_buf;
14362
14363 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14364
14365 device_param->combs_buf = combs_buf;
14366
14367 void *hooks_buf = mymalloc (size_hooks);
14368
14369 device_param->hooks_buf = hooks_buf;
14370
14371 /**
14372 * kernel args
14373 */
14374
14375 device_param->kernel_params_buf32[21] = bitmap_mask;
14376 device_param->kernel_params_buf32[22] = bitmap_shift1;
14377 device_param->kernel_params_buf32[23] = bitmap_shift2;
14378 device_param->kernel_params_buf32[24] = 0; // salt_pos
14379 device_param->kernel_params_buf32[25] = 0; // loop_pos
14380 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14381 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14382 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14383 device_param->kernel_params_buf32[29] = 0; // digests_offset
14384 device_param->kernel_params_buf32[30] = 0; // combs_mode
14385 device_param->kernel_params_buf32[31] = 0; // gid_max
14386
14387 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14388 ? &device_param->d_pws_buf
14389 : &device_param->d_pws_amp_buf;
14390 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14391 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14392 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14393 device_param->kernel_params[ 4] = &device_param->d_tmps;
14394 device_param->kernel_params[ 5] = &device_param->d_hooks;
14395 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14396 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14397 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14398 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14399 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14400 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14401 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14402 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14403 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14404 device_param->kernel_params[15] = &device_param->d_digests_buf;
14405 device_param->kernel_params[16] = &device_param->d_digests_shown;
14406 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14407 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14408 device_param->kernel_params[19] = &device_param->d_result;
14409 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14410 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14411 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14412 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14413 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14414 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14415 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14416 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14417 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14418 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14419 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14420 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14421
14422 device_param->kernel_params_mp_buf64[3] = 0;
14423 device_param->kernel_params_mp_buf32[4] = 0;
14424 device_param->kernel_params_mp_buf32[5] = 0;
14425 device_param->kernel_params_mp_buf32[6] = 0;
14426 device_param->kernel_params_mp_buf32[7] = 0;
14427 device_param->kernel_params_mp_buf32[8] = 0;
14428
14429 device_param->kernel_params_mp[0] = NULL;
14430 device_param->kernel_params_mp[1] = NULL;
14431 device_param->kernel_params_mp[2] = NULL;
14432 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14433 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14434 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14435 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14436 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14437 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14438
14439 device_param->kernel_params_mp_l_buf64[3] = 0;
14440 device_param->kernel_params_mp_l_buf32[4] = 0;
14441 device_param->kernel_params_mp_l_buf32[5] = 0;
14442 device_param->kernel_params_mp_l_buf32[6] = 0;
14443 device_param->kernel_params_mp_l_buf32[7] = 0;
14444 device_param->kernel_params_mp_l_buf32[8] = 0;
14445 device_param->kernel_params_mp_l_buf32[9] = 0;
14446
14447 device_param->kernel_params_mp_l[0] = NULL;
14448 device_param->kernel_params_mp_l[1] = NULL;
14449 device_param->kernel_params_mp_l[2] = NULL;
14450 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14451 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14452 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14453 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14454 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14455 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14456 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14457
14458 device_param->kernel_params_mp_r_buf64[3] = 0;
14459 device_param->kernel_params_mp_r_buf32[4] = 0;
14460 device_param->kernel_params_mp_r_buf32[5] = 0;
14461 device_param->kernel_params_mp_r_buf32[6] = 0;
14462 device_param->kernel_params_mp_r_buf32[7] = 0;
14463 device_param->kernel_params_mp_r_buf32[8] = 0;
14464
14465 device_param->kernel_params_mp_r[0] = NULL;
14466 device_param->kernel_params_mp_r[1] = NULL;
14467 device_param->kernel_params_mp_r[2] = NULL;
14468 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14469 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14470 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14471 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14472 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14473 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14474
14475 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14476 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14477
14478 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14479 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14480 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14481 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14482 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14483 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14484 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14485
14486 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14487 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14488
14489 /**
14490 * kernel name
14491 */
14492
14493 char kernel_name[64] = { 0 };
14494
14495 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14496 {
14497 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14498 {
14499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14500
14501 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14502
14503 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14504
14505 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14506
14507 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14508
14509 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14510 }
14511 else
14512 {
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14514
14515 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516
14517 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14518
14519 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14520
14521 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14522
14523 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14524 }
14525
14526 if (data.attack_mode == ATTACK_MODE_BF)
14527 {
14528 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14529 {
14530 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14531
14532 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14533 }
14534 }
14535 }
14536 else
14537 {
14538 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14539
14540 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14541
14542 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14543
14544 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14545
14546 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14547
14548 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14549
14550 if (opts_type & OPTS_TYPE_HOOK12)
14551 {
14552 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14553
14554 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14555 }
14556
14557 if (opts_type & OPTS_TYPE_HOOK23)
14558 {
14559 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14560
14561 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14562 }
14563 }
14564
14565 for (uint i = 0; i <= 20; i++)
14566 {
14567 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14568 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14569 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14570
14571 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14572 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14573 }
14574
14575 for (uint i = 21; i <= 31; i++)
14576 {
14577 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14578 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14579 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14580
14581 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14582 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14583 }
14584
14585 if (attack_mode == ATTACK_MODE_BF)
14586 {
14587 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14588 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14589
14590 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14591 {
14592 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14593 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14594 }
14595 }
14596 else if (attack_mode == ATTACK_MODE_HYBRID1)
14597 {
14598 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14599 }
14600 else if (attack_mode == ATTACK_MODE_HYBRID2)
14601 {
14602 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14603 }
14604
14605 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14606 {
14607 // nothing to do
14608 }
14609 else
14610 {
14611 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14612 }
14613
14614 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14615 {
14616 // nothing to do
14617 }
14618 else
14619 {
14620 for (uint i = 0; i < 5; i++)
14621 {
14622 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14623 }
14624
14625 for (uint i = 5; i < 7; i++)
14626 {
14627 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14628 }
14629 }
14630
14631 /**
14632 * Store initial fanspeed if gpu_temp_retain is enabled
14633 */
14634
14635 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14636 int gpu_temp_retain_set = 0;
14637
14638 if (gpu_temp_disable == 0)
14639 {
14640 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14641 {
14642 hc_thread_mutex_lock (mux_adl);
14643
14644 if (data.hm_device[device_id].fan_supported == 1)
14645 {
14646 if (gpu_temp_retain_chgd == 0)
14647 {
14648 uint cur_temp = 0;
14649 uint default_temp = 0;
14650
14651 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);
14652
14653 if (ADL_rc == ADL_OK)
14654 {
14655 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14656
14657 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14658
14659 // special case with multi gpu setups: always use minimum retain
14660
14661 if (gpu_temp_retain_set == 0)
14662 {
14663 gpu_temp_retain = gpu_temp_retain_target;
14664 gpu_temp_retain_set = 1;
14665 }
14666 else
14667 {
14668 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14669 }
14670
14671 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14672 }
14673 }
14674
14675 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14676
14677 temp_retain_fanspeed_value[device_id] = fan_speed;
14678
14679 if (fan_speed == -1)
14680 {
14681 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14682
14683 temp_retain_fanspeed_value[device_id] = 0;
14684 }
14685 }
14686
14687 hc_thread_mutex_unlock (mux_adl);
14688 }
14689 }
14690
14691 /**
14692 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14693 */
14694
14695 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14696 {
14697 hc_thread_mutex_lock (mux_adl);
14698
14699 if (data.hm_device[device_id].od_version == 6)
14700 {
14701 int ADL_rc;
14702
14703 // check powertune capabilities first, if not available then skip device
14704
14705 int powertune_supported = 0;
14706
14707 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14708 {
14709 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14710
14711 return (-1);
14712 }
14713
14714 if (powertune_supported != 0)
14715 {
14716 // powercontrol settings
14717
14718 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14719
14720 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14721 {
14722 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14723 }
14724
14725 if (ADL_rc != ADL_OK)
14726 {
14727 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14728
14729 return (-1);
14730 }
14731
14732 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14733 {
14734 log_error ("ERROR: Failed to set new ADL PowerControl values");
14735
14736 return (-1);
14737 }
14738
14739 // clocks
14740
14741 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14742
14743 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14744
14745 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)
14746 {
14747 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14748
14749 return (-1);
14750 }
14751
14752 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14753
14754 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14755
14756 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14757 {
14758 log_error ("ERROR: Failed to get ADL device capabilities");
14759
14760 return (-1);
14761 }
14762
14763 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14764 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14765
14766 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14767 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14768
14769 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14770 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14771
14772 // warning if profile has too low max values
14773
14774 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14775 {
14776 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14777 }
14778
14779 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14780 {
14781 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14782 }
14783
14784 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14785
14786 performance_state->iNumberOfPerformanceLevels = 2;
14787
14788 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14789 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14790 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14791 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14792
14793 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)
14794 {
14795 log_info ("ERROR: Failed to set ADL performance state");
14796
14797 return (-1);
14798 }
14799
14800 local_free (performance_state);
14801 }
14802 }
14803
14804 hc_thread_mutex_unlock (mux_adl);
14805 }
14806 #endif // HAVE_HWMON && HAVE_ADL
14807 }
14808
14809 data.kernel_power_all = kernel_power_all;
14810
14811 if (data.quiet == 0) log_info ("");
14812
14813 /**
14814 * Inform user which algorithm is checked and at which workload setting
14815 */
14816
14817 if (benchmark == 1)
14818 {
14819 quiet = 0;
14820
14821 data.quiet = quiet;
14822
14823 char *hash_type = strhashtype (data.hash_mode); // not a bug
14824
14825 log_info ("Hashtype: %s", hash_type);
14826 log_info ("");
14827 }
14828
14829 /**
14830 * keep track of the progress
14831 */
14832
14833 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14834 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14835 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14836
14837 /**
14838 * open filehandles
14839 */
14840
14841 #if _WIN
14842 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14843 {
14844 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14845
14846 return (-1);
14847 }
14848
14849 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14850 {
14851 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14852
14853 return (-1);
14854 }
14855
14856 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14857 {
14858 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14859
14860 return (-1);
14861 }
14862 #endif
14863
14864 /**
14865 * dictionary pad
14866 */
14867
14868 segment_size *= (1024 * 1024);
14869
14870 data.segment_size = segment_size;
14871
14872 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14873
14874 wl_data->buf = (char *) mymalloc (segment_size);
14875 wl_data->avail = segment_size;
14876 wl_data->incr = segment_size;
14877 wl_data->cnt = 0;
14878 wl_data->pos = 0;
14879
14880 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14881
14882 data.wordlist_mode = wordlist_mode;
14883
14884 cs_t *css_buf = NULL;
14885 uint css_cnt = 0;
14886 uint dictcnt = 0;
14887 uint maskcnt = 1;
14888 char **masks = NULL;
14889 char **dictfiles = NULL;
14890
14891 uint mask_from_file = 0;
14892
14893 if (attack_mode == ATTACK_MODE_STRAIGHT)
14894 {
14895 if (wordlist_mode == WL_MODE_FILE)
14896 {
14897 int wls_left = myargc - (optind + 1);
14898
14899 for (int i = 0; i < wls_left; i++)
14900 {
14901 char *l0_filename = myargv[optind + 1 + i];
14902
14903 struct stat l0_stat;
14904
14905 if (stat (l0_filename, &l0_stat) == -1)
14906 {
14907 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14908
14909 return (-1);
14910 }
14911
14912 uint is_dir = S_ISDIR (l0_stat.st_mode);
14913
14914 if (is_dir == 0)
14915 {
14916 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14917
14918 dictcnt++;
14919
14920 dictfiles[dictcnt - 1] = l0_filename;
14921 }
14922 else
14923 {
14924 // do not allow --keyspace w/ a directory
14925
14926 if (keyspace == 1)
14927 {
14928 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14929
14930 return (-1);
14931 }
14932
14933 char **dictionary_files = NULL;
14934
14935 dictionary_files = scan_directory (l0_filename);
14936
14937 if (dictionary_files != NULL)
14938 {
14939 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14940
14941 for (int d = 0; dictionary_files[d] != NULL; d++)
14942 {
14943 char *l1_filename = dictionary_files[d];
14944
14945 struct stat l1_stat;
14946
14947 if (stat (l1_filename, &l1_stat) == -1)
14948 {
14949 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14950
14951 return (-1);
14952 }
14953
14954 if (S_ISREG (l1_stat.st_mode))
14955 {
14956 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14957
14958 dictcnt++;
14959
14960 dictfiles[dictcnt - 1] = strdup (l1_filename);
14961 }
14962 }
14963 }
14964
14965 local_free (dictionary_files);
14966 }
14967 }
14968
14969 if (dictcnt < 1)
14970 {
14971 log_error ("ERROR: No usable dictionary file found.");
14972
14973 return (-1);
14974 }
14975 }
14976 else if (wordlist_mode == WL_MODE_STDIN)
14977 {
14978 dictcnt = 1;
14979 }
14980 }
14981 else if (attack_mode == ATTACK_MODE_COMBI)
14982 {
14983 // display
14984
14985 char *dictfile1 = myargv[optind + 1 + 0];
14986 char *dictfile2 = myargv[optind + 1 + 1];
14987
14988 // find the bigger dictionary and use as base
14989
14990 FILE *fp1 = NULL;
14991 FILE *fp2 = NULL;
14992
14993 struct stat tmp_stat;
14994
14995 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14996 {
14997 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14998
14999 return (-1);
15000 }
15001
15002 if (stat (dictfile1, &tmp_stat) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15005
15006 fclose (fp1);
15007
15008 return (-1);
15009 }
15010
15011 if (S_ISDIR (tmp_stat.st_mode))
15012 {
15013 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15014
15015 fclose (fp1);
15016
15017 return (-1);
15018 }
15019
15020 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15021 {
15022 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15023
15024 fclose (fp1);
15025
15026 return (-1);
15027 }
15028
15029 if (stat (dictfile2, &tmp_stat) == -1)
15030 {
15031 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15032
15033 fclose (fp1);
15034 fclose (fp2);
15035
15036 return (-1);
15037 }
15038
15039 if (S_ISDIR (tmp_stat.st_mode))
15040 {
15041 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15042
15043 fclose (fp1);
15044 fclose (fp2);
15045
15046 return (-1);
15047 }
15048
15049 data.combs_cnt = 1;
15050
15051 data.quiet = 1;
15052
15053 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15054
15055 data.quiet = quiet;
15056
15057 if (words1_cnt == 0)
15058 {
15059 log_error ("ERROR: %s: empty file", dictfile1);
15060
15061 fclose (fp1);
15062 fclose (fp2);
15063
15064 return (-1);
15065 }
15066
15067 data.combs_cnt = 1;
15068
15069 data.quiet = 1;
15070
15071 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15072
15073 data.quiet = quiet;
15074
15075 if (words2_cnt == 0)
15076 {
15077 log_error ("ERROR: %s: empty file", dictfile2);
15078
15079 fclose (fp1);
15080 fclose (fp2);
15081
15082 return (-1);
15083 }
15084
15085 fclose (fp1);
15086 fclose (fp2);
15087
15088 data.dictfile = dictfile1;
15089 data.dictfile2 = dictfile2;
15090
15091 if (words1_cnt >= words2_cnt)
15092 {
15093 data.combs_cnt = words2_cnt;
15094 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15095
15096 dictfiles = &data.dictfile;
15097
15098 dictcnt = 1;
15099 }
15100 else
15101 {
15102 data.combs_cnt = words1_cnt;
15103 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15104
15105 dictfiles = &data.dictfile2;
15106
15107 dictcnt = 1;
15108
15109 // we also have to switch wordlist related rules!
15110
15111 char *tmpc = data.rule_buf_l;
15112
15113 data.rule_buf_l = data.rule_buf_r;
15114 data.rule_buf_r = tmpc;
15115
15116 int tmpi = data.rule_len_l;
15117
15118 data.rule_len_l = data.rule_len_r;
15119 data.rule_len_r = tmpi;
15120 }
15121 }
15122 else if (attack_mode == ATTACK_MODE_BF)
15123 {
15124 char *mask = NULL;
15125
15126 maskcnt = 0;
15127
15128 if (benchmark == 0)
15129 {
15130 mask = myargv[optind + 1];
15131
15132 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15133
15134 if ((optind + 2) <= myargc)
15135 {
15136 struct stat file_stat;
15137
15138 if (stat (mask, &file_stat) == -1)
15139 {
15140 maskcnt = 1;
15141
15142 masks[maskcnt - 1] = mystrdup (mask);
15143 }
15144 else
15145 {
15146 int wls_left = myargc - (optind + 1);
15147
15148 uint masks_avail = INCR_MASKS;
15149
15150 for (int i = 0; i < wls_left; i++)
15151 {
15152 if (i != 0)
15153 {
15154 mask = myargv[optind + 1 + i];
15155
15156 if (stat (mask, &file_stat) == -1)
15157 {
15158 log_error ("ERROR: %s: %s", mask, strerror (errno));
15159
15160 return (-1);
15161 }
15162 }
15163
15164 uint is_file = S_ISREG (file_stat.st_mode);
15165
15166 if (is_file == 1)
15167 {
15168 FILE *mask_fp;
15169
15170 if ((mask_fp = fopen (mask, "r")) == NULL)
15171 {
15172 log_error ("ERROR: %s: %s", mask, strerror (errno));
15173
15174 return (-1);
15175 }
15176
15177 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15178
15179 while (!feof (mask_fp))
15180 {
15181 memset (line_buf, 0, HCBUFSIZ);
15182
15183 int line_len = fgetl (mask_fp, line_buf);
15184
15185 if (line_len == 0) continue;
15186
15187 if (line_buf[0] == '#') continue;
15188
15189 if (masks_avail == maskcnt)
15190 {
15191 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15192
15193 masks_avail += INCR_MASKS;
15194 }
15195
15196 masks[maskcnt] = mystrdup (line_buf);
15197
15198 maskcnt++;
15199 }
15200
15201 myfree (line_buf);
15202
15203 fclose (mask_fp);
15204 }
15205 else
15206 {
15207 log_error ("ERROR: %s: unsupported file-type", mask);
15208
15209 return (-1);
15210 }
15211 }
15212
15213 mask_from_file = 1;
15214 }
15215 }
15216 else
15217 {
15218 custom_charset_1 = (char *) "?l?d?u";
15219 custom_charset_2 = (char *) "?l?d";
15220 custom_charset_3 = (char *) "?l?d*!$@_";
15221
15222 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15223 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15224 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15225
15226 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15227
15228 wordlist_mode = WL_MODE_MASK;
15229
15230 data.wordlist_mode = wordlist_mode;
15231
15232 increment = 1;
15233
15234 maskcnt = 1;
15235 }
15236 }
15237 else
15238 {
15239 /**
15240 * generate full masks and charsets
15241 */
15242
15243 masks = (char **) mymalloc (sizeof (char *));
15244
15245 switch (hash_mode)
15246 {
15247 case 1731: pw_min = 5;
15248 pw_max = 5;
15249 mask = mystrdup ("?b?b?b?b?b");
15250 break;
15251 case 12500: pw_min = 5;
15252 pw_max = 5;
15253 mask = mystrdup ("?b?b?b?b?b");
15254 break;
15255 default: pw_min = 7;
15256 pw_max = 7;
15257 mask = mystrdup ("?b?b?b?b?b?b?b");
15258 break;
15259 }
15260
15261 maskcnt = 1;
15262
15263 masks[maskcnt - 1] = mystrdup (mask);
15264
15265 wordlist_mode = WL_MODE_MASK;
15266
15267 data.wordlist_mode = wordlist_mode;
15268
15269 increment = 1;
15270 }
15271
15272 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15273
15274 if (increment)
15275 {
15276 if (increment_min > pw_min) pw_min = increment_min;
15277
15278 if (increment_max < pw_max) pw_max = increment_max;
15279 }
15280 }
15281 else if (attack_mode == ATTACK_MODE_HYBRID1)
15282 {
15283 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15284
15285 // display
15286
15287 char *mask = myargv[myargc - 1];
15288
15289 maskcnt = 0;
15290
15291 masks = (char **) mymalloc (1 * sizeof (char *));
15292
15293 // mod
15294
15295 struct stat file_stat;
15296
15297 if (stat (mask, &file_stat) == -1)
15298 {
15299 maskcnt = 1;
15300
15301 masks[maskcnt - 1] = mystrdup (mask);
15302 }
15303 else
15304 {
15305 uint is_file = S_ISREG (file_stat.st_mode);
15306
15307 if (is_file == 1)
15308 {
15309 FILE *mask_fp;
15310
15311 if ((mask_fp = fopen (mask, "r")) == NULL)
15312 {
15313 log_error ("ERROR: %s: %s", mask, strerror (errno));
15314
15315 return (-1);
15316 }
15317
15318 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15319
15320 uint masks_avail = 1;
15321
15322 while (!feof (mask_fp))
15323 {
15324 memset (line_buf, 0, HCBUFSIZ);
15325
15326 int line_len = fgetl (mask_fp, line_buf);
15327
15328 if (line_len == 0) continue;
15329
15330 if (line_buf[0] == '#') continue;
15331
15332 if (masks_avail == maskcnt)
15333 {
15334 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15335
15336 masks_avail += INCR_MASKS;
15337 }
15338
15339 masks[maskcnt] = mystrdup (line_buf);
15340
15341 maskcnt++;
15342 }
15343
15344 myfree (line_buf);
15345
15346 fclose (mask_fp);
15347
15348 mask_from_file = 1;
15349 }
15350 else
15351 {
15352 maskcnt = 1;
15353
15354 masks[maskcnt - 1] = mystrdup (mask);
15355 }
15356 }
15357
15358 // base
15359
15360 int wls_left = myargc - (optind + 2);
15361
15362 for (int i = 0; i < wls_left; i++)
15363 {
15364 char *filename = myargv[optind + 1 + i];
15365
15366 struct stat file_stat;
15367
15368 if (stat (filename, &file_stat) == -1)
15369 {
15370 log_error ("ERROR: %s: %s", filename, strerror (errno));
15371
15372 return (-1);
15373 }
15374
15375 uint is_dir = S_ISDIR (file_stat.st_mode);
15376
15377 if (is_dir == 0)
15378 {
15379 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15380
15381 dictcnt++;
15382
15383 dictfiles[dictcnt - 1] = filename;
15384 }
15385 else
15386 {
15387 // do not allow --keyspace w/ a directory
15388
15389 if (keyspace == 1)
15390 {
15391 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15392
15393 return (-1);
15394 }
15395
15396 char **dictionary_files = NULL;
15397
15398 dictionary_files = scan_directory (filename);
15399
15400 if (dictionary_files != NULL)
15401 {
15402 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15403
15404 for (int d = 0; dictionary_files[d] != NULL; d++)
15405 {
15406 char *l1_filename = dictionary_files[d];
15407
15408 struct stat l1_stat;
15409
15410 if (stat (l1_filename, &l1_stat) == -1)
15411 {
15412 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15413
15414 return (-1);
15415 }
15416
15417 if (S_ISREG (l1_stat.st_mode))
15418 {
15419 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15420
15421 dictcnt++;
15422
15423 dictfiles[dictcnt - 1] = strdup (l1_filename);
15424 }
15425 }
15426 }
15427
15428 local_free (dictionary_files);
15429 }
15430 }
15431
15432 if (dictcnt < 1)
15433 {
15434 log_error ("ERROR: No usable dictionary file found.");
15435
15436 return (-1);
15437 }
15438
15439 if (increment)
15440 {
15441 maskcnt = 0;
15442
15443 uint mask_min = increment_min; // we can't reject smaller masks here
15444 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15445
15446 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15447 {
15448 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15449
15450 if (cur_mask == NULL) break;
15451
15452 masks[maskcnt] = cur_mask;
15453
15454 maskcnt++;
15455
15456 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15457 }
15458 }
15459 }
15460 else if (attack_mode == ATTACK_MODE_HYBRID2)
15461 {
15462 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15463
15464 // display
15465
15466 char *mask = myargv[optind + 1 + 0];
15467
15468 maskcnt = 0;
15469
15470 masks = (char **) mymalloc (1 * sizeof (char *));
15471
15472 // mod
15473
15474 struct stat file_stat;
15475
15476 if (stat (mask, &file_stat) == -1)
15477 {
15478 maskcnt = 1;
15479
15480 masks[maskcnt - 1] = mystrdup (mask);
15481 }
15482 else
15483 {
15484 uint is_file = S_ISREG (file_stat.st_mode);
15485
15486 if (is_file == 1)
15487 {
15488 FILE *mask_fp;
15489
15490 if ((mask_fp = fopen (mask, "r")) == NULL)
15491 {
15492 log_error ("ERROR: %s: %s", mask, strerror (errno));
15493
15494 return (-1);
15495 }
15496
15497 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15498
15499 uint masks_avail = 1;
15500
15501 while (!feof (mask_fp))
15502 {
15503 memset (line_buf, 0, HCBUFSIZ);
15504
15505 int line_len = fgetl (mask_fp, line_buf);
15506
15507 if (line_len == 0) continue;
15508
15509 if (line_buf[0] == '#') continue;
15510
15511 if (masks_avail == maskcnt)
15512 {
15513 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15514
15515 masks_avail += INCR_MASKS;
15516 }
15517
15518 masks[maskcnt] = mystrdup (line_buf);
15519
15520 maskcnt++;
15521 }
15522
15523 myfree (line_buf);
15524
15525 fclose (mask_fp);
15526
15527 mask_from_file = 1;
15528 }
15529 else
15530 {
15531 maskcnt = 1;
15532
15533 masks[maskcnt - 1] = mystrdup (mask);
15534 }
15535 }
15536
15537 // base
15538
15539 int wls_left = myargc - (optind + 2);
15540
15541 for (int i = 0; i < wls_left; i++)
15542 {
15543 char *filename = myargv[optind + 2 + i];
15544
15545 struct stat file_stat;
15546
15547 if (stat (filename, &file_stat) == -1)
15548 {
15549 log_error ("ERROR: %s: %s", filename, strerror (errno));
15550
15551 return (-1);
15552 }
15553
15554 uint is_dir = S_ISDIR (file_stat.st_mode);
15555
15556 if (is_dir == 0)
15557 {
15558 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15559
15560 dictcnt++;
15561
15562 dictfiles[dictcnt - 1] = filename;
15563 }
15564 else
15565 {
15566 // do not allow --keyspace w/ a directory
15567
15568 if (keyspace == 1)
15569 {
15570 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15571
15572 return (-1);
15573 }
15574
15575 char **dictionary_files = NULL;
15576
15577 dictionary_files = scan_directory (filename);
15578
15579 if (dictionary_files != NULL)
15580 {
15581 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15582
15583 for (int d = 0; dictionary_files[d] != NULL; d++)
15584 {
15585 char *l1_filename = dictionary_files[d];
15586
15587 struct stat l1_stat;
15588
15589 if (stat (l1_filename, &l1_stat) == -1)
15590 {
15591 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15592
15593 return (-1);
15594 }
15595
15596 if (S_ISREG (l1_stat.st_mode))
15597 {
15598 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15599
15600 dictcnt++;
15601
15602 dictfiles[dictcnt - 1] = strdup (l1_filename);
15603 }
15604 }
15605 }
15606
15607 local_free (dictionary_files);
15608 }
15609 }
15610
15611 if (dictcnt < 1)
15612 {
15613 log_error ("ERROR: No usable dictionary file found.");
15614
15615 return (-1);
15616 }
15617
15618 if (increment)
15619 {
15620 maskcnt = 0;
15621
15622 uint mask_min = increment_min; // we can't reject smaller masks here
15623 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15624
15625 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15626 {
15627 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15628
15629 if (cur_mask == NULL) break;
15630
15631 masks[maskcnt] = cur_mask;
15632
15633 maskcnt++;
15634
15635 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15636 }
15637 }
15638 }
15639
15640 data.pw_min = pw_min;
15641 data.pw_max = pw_max;
15642
15643 /**
15644 * weak hash check
15645 */
15646
15647 if (weak_hash_threshold >= salts_cnt)
15648 {
15649 hc_device_param_t *device_param = NULL;
15650
15651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15652 {
15653 device_param = &data.devices_param[device_id];
15654
15655 if (device_param->skipped) continue;
15656
15657 break;
15658 }
15659
15660 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15661
15662 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15663 {
15664 weak_hash_check (device_param, salt_pos);
15665 }
15666 }
15667
15668 // Display hack, guarantee that there is at least one \r before real start
15669
15670 if (data.quiet == 0) log_info_nn ("");
15671
15672 /**
15673 * status and monitor threads
15674 */
15675
15676 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15677
15678 hc_thread_t i_thread = 0;
15679
15680 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15681 {
15682 hc_thread_create (i_thread, thread_keypress, &benchmark);
15683 }
15684
15685 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15686
15687 uint ni_threads_cnt = 0;
15688
15689 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15690
15691 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15692
15693 ni_threads_cnt++;
15694
15695 /**
15696 * Outfile remove
15697 */
15698
15699 if (keyspace == 0)
15700 {
15701 if (outfile_check_timer != 0)
15702 {
15703 if (data.outfile_check_directory != NULL)
15704 {
15705 if ((hash_mode != 5200) &&
15706 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15707 (hash_mode != 9000))
15708 {
15709 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15710
15711 ni_threads_cnt++;
15712 }
15713 else
15714 {
15715 outfile_check_timer = 0;
15716 }
15717 }
15718 else
15719 {
15720 outfile_check_timer = 0;
15721 }
15722 }
15723 }
15724
15725 /**
15726 * Inform the user if we got some hashes remove because of the pot file remove feature
15727 */
15728
15729 if (data.quiet == 0)
15730 {
15731 if (potfile_remove_cracks > 0)
15732 {
15733 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15734 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15735 }
15736 }
15737
15738 data.outfile_check_timer = outfile_check_timer;
15739
15740 /**
15741 * main loop
15742 */
15743
15744 char **induction_dictionaries = NULL;
15745
15746 int induction_dictionaries_cnt = 0;
15747
15748 hcstat_table_t *root_table_buf = NULL;
15749 hcstat_table_t *markov_table_buf = NULL;
15750
15751 uint initial_restore_done = 0;
15752
15753 data.maskcnt = maskcnt;
15754
15755 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15756 {
15757 if (data.devices_status == STATUS_CRACKED) break;
15758
15759 data.devices_status = STATUS_INIT;
15760
15761 if (maskpos > rd->maskpos)
15762 {
15763 rd->dictpos = 0;
15764 }
15765
15766 rd->maskpos = maskpos;
15767 data.maskpos = maskpos;
15768
15769 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15770 {
15771 char *mask = masks[maskpos];
15772
15773 if (mask_from_file == 1)
15774 {
15775 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15776
15777 char *str_ptr;
15778 uint str_pos;
15779
15780 uint mask_offset = 0;
15781
15782 uint separator_cnt;
15783
15784 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15785 {
15786 str_ptr = strstr (mask + mask_offset, ",");
15787
15788 if (str_ptr == NULL) break;
15789
15790 str_pos = str_ptr - mask;
15791
15792 // escaped separator, i.e. "\,"
15793
15794 if (str_pos > 0)
15795 {
15796 if (mask[str_pos - 1] == '\\')
15797 {
15798 separator_cnt --;
15799
15800 mask_offset = str_pos + 1;
15801
15802 continue;
15803 }
15804 }
15805
15806 // reset the offset
15807
15808 mask_offset = 0;
15809
15810 mask[str_pos] = '\0';
15811
15812 switch (separator_cnt)
15813 {
15814 case 0:
15815 mp_reset_usr (mp_usr, 0);
15816
15817 custom_charset_1 = mask;
15818 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15819 break;
15820
15821 case 1:
15822 mp_reset_usr (mp_usr, 1);
15823
15824 custom_charset_2 = mask;
15825 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15826 break;
15827
15828 case 2:
15829 mp_reset_usr (mp_usr, 2);
15830
15831 custom_charset_3 = mask;
15832 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15833 break;
15834
15835 case 3:
15836 mp_reset_usr (mp_usr, 3);
15837
15838 custom_charset_4 = mask;
15839 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15840 break;
15841 }
15842
15843 mask = mask + str_pos + 1;
15844 }
15845 }
15846
15847 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15848 {
15849 if (maskpos > 0)
15850 {
15851 local_free (css_buf);
15852 local_free (data.root_css_buf);
15853 local_free (data.markov_css_buf);
15854
15855 local_free (masks[maskpos - 1]);
15856 }
15857
15858 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15859
15860 data.mask = mask;
15861 data.css_cnt = css_cnt;
15862 data.css_buf = css_buf;
15863
15864 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15865
15866 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15867
15868 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15869 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15870
15871 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15872
15873 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15874
15875 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15876 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15877
15878 data.root_css_buf = root_css_buf;
15879 data.markov_css_buf = markov_css_buf;
15880
15881 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15882
15883 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15884
15885 local_free (root_table_buf);
15886 local_free (markov_table_buf);
15887
15888 // args
15889
15890 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15891 {
15892 hc_device_param_t *device_param = &data.devices_param[device_id];
15893
15894 if (device_param->skipped) continue;
15895
15896 device_param->kernel_params_mp[0] = &device_param->d_combs;
15897 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15898 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15899
15900 device_param->kernel_params_mp_buf64[3] = 0;
15901 device_param->kernel_params_mp_buf32[4] = css_cnt;
15902 device_param->kernel_params_mp_buf32[5] = 0;
15903 device_param->kernel_params_mp_buf32[6] = 0;
15904 device_param->kernel_params_mp_buf32[7] = 0;
15905
15906 if (attack_mode == ATTACK_MODE_HYBRID1)
15907 {
15908 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15909 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15910 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15911 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15912 }
15913 else if (attack_mode == ATTACK_MODE_HYBRID2)
15914 {
15915 device_param->kernel_params_mp_buf32[5] = 0;
15916 device_param->kernel_params_mp_buf32[6] = 0;
15917 device_param->kernel_params_mp_buf32[7] = 0;
15918 }
15919
15920 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]);
15921 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]);
15922 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]);
15923
15924 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);
15925 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);
15926 }
15927 }
15928 else if (attack_mode == ATTACK_MODE_BF)
15929 {
15930 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15931
15932 if (increment)
15933 {
15934 for (uint i = 0; i < dictcnt; i++)
15935 {
15936 local_free (dictfiles[i]);
15937 }
15938
15939 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15940 {
15941 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15942
15943 if (l1_filename == NULL) break;
15944
15945 dictcnt++;
15946
15947 dictfiles[dictcnt - 1] = l1_filename;
15948 }
15949 }
15950 else
15951 {
15952 dictcnt++;
15953
15954 dictfiles[dictcnt - 1] = mask;
15955 }
15956
15957 if (dictcnt == 0)
15958 {
15959 log_error ("ERROR: Mask is too small");
15960
15961 return (-1);
15962 }
15963 }
15964 }
15965
15966 free (induction_dictionaries);
15967
15968 // induction_dictionaries_cnt = 0; // implied
15969
15970 if (attack_mode != ATTACK_MODE_BF)
15971 {
15972 if (keyspace == 0)
15973 {
15974 induction_dictionaries = scan_directory (induction_directory);
15975
15976 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15977 }
15978 }
15979
15980 if (induction_dictionaries_cnt)
15981 {
15982 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15983 }
15984
15985 /**
15986 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15987 */
15988 if (keyspace == 1)
15989 {
15990 if ((maskcnt > 1) || (dictcnt > 1))
15991 {
15992 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15993
15994 return (-1);
15995 }
15996 }
15997
15998 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15999 {
16000 char *subid = logfile_generate_subid ();
16001
16002 data.subid = subid;
16003
16004 logfile_sub_msg ("START");
16005
16006 data.devices_status = STATUS_INIT;
16007
16008 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16009 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16010 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16011
16012 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16013
16014 data.cpt_pos = 0;
16015
16016 data.cpt_start = time (NULL);
16017
16018 data.cpt_total = 0;
16019
16020 if (data.restore == 0)
16021 {
16022 rd->words_cur = skip;
16023
16024 skip = 0;
16025
16026 data.skip = 0;
16027 }
16028
16029 data.ms_paused = 0;
16030
16031 data.words_cur = rd->words_cur;
16032
16033 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16034 {
16035 hc_device_param_t *device_param = &data.devices_param[device_id];
16036
16037 if (device_param->skipped) continue;
16038
16039 device_param->speed_pos = 0;
16040
16041 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16042 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16043 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16044
16045 device_param->exec_pos = 0;
16046
16047 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16048
16049 device_param->kernel_power = device_param->kernel_power_user;
16050
16051 device_param->outerloop_pos = 0;
16052 device_param->outerloop_left = 0;
16053 device_param->innerloop_pos = 0;
16054 device_param->innerloop_left = 0;
16055
16056 // some more resets:
16057
16058 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16059
16060 device_param->pws_cnt = 0;
16061
16062 device_param->words_off = 0;
16063 device_param->words_done = 0;
16064 }
16065
16066 data.kernel_power_div = 0;
16067
16068 // figure out some workload
16069
16070 if (attack_mode == ATTACK_MODE_STRAIGHT)
16071 {
16072 if (data.wordlist_mode == WL_MODE_FILE)
16073 {
16074 char *dictfile = NULL;
16075
16076 if (induction_dictionaries_cnt)
16077 {
16078 dictfile = induction_dictionaries[0];
16079 }
16080 else
16081 {
16082 dictfile = dictfiles[dictpos];
16083 }
16084
16085 data.dictfile = dictfile;
16086
16087 logfile_sub_string (dictfile);
16088
16089 for (uint i = 0; i < rp_files_cnt; i++)
16090 {
16091 logfile_sub_var_string ("rulefile", rp_files[i]);
16092 }
16093
16094 FILE *fd2 = fopen (dictfile, "rb");
16095
16096 if (fd2 == NULL)
16097 {
16098 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16099
16100 return (-1);
16101 }
16102
16103 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16104
16105 fclose (fd2);
16106
16107 if (data.words_cnt == 0)
16108 {
16109 if (data.devices_status == STATUS_CRACKED) break;
16110 if (data.devices_status == STATUS_ABORTED) break;
16111
16112 dictpos++;
16113
16114 continue;
16115 }
16116 }
16117 }
16118 else if (attack_mode == ATTACK_MODE_COMBI)
16119 {
16120 char *dictfile = data.dictfile;
16121 char *dictfile2 = data.dictfile2;
16122
16123 logfile_sub_string (dictfile);
16124 logfile_sub_string (dictfile2);
16125
16126 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16127 {
16128 FILE *fd2 = fopen (dictfile, "rb");
16129
16130 if (fd2 == NULL)
16131 {
16132 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16133
16134 return (-1);
16135 }
16136
16137 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16138
16139 fclose (fd2);
16140 }
16141 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16142 {
16143 FILE *fd2 = fopen (dictfile2, "rb");
16144
16145 if (fd2 == NULL)
16146 {
16147 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16148
16149 return (-1);
16150 }
16151
16152 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16153
16154 fclose (fd2);
16155 }
16156
16157 if (data.words_cnt == 0)
16158 {
16159 if (data.devices_status == STATUS_CRACKED) break;
16160 if (data.devices_status == STATUS_ABORTED) break;
16161
16162 dictpos++;
16163
16164 continue;
16165 }
16166 }
16167 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16168 {
16169 char *dictfile = NULL;
16170
16171 if (induction_dictionaries_cnt)
16172 {
16173 dictfile = induction_dictionaries[0];
16174 }
16175 else
16176 {
16177 dictfile = dictfiles[dictpos];
16178 }
16179
16180 data.dictfile = dictfile;
16181
16182 char *mask = data.mask;
16183
16184 logfile_sub_string (dictfile);
16185 logfile_sub_string (mask);
16186
16187 FILE *fd2 = fopen (dictfile, "rb");
16188
16189 if (fd2 == NULL)
16190 {
16191 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16192
16193 return (-1);
16194 }
16195
16196 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16197
16198 fclose (fd2);
16199
16200 if (data.words_cnt == 0)
16201 {
16202 if (data.devices_status == STATUS_CRACKED) break;
16203 if (data.devices_status == STATUS_ABORTED) break;
16204
16205 dictpos++;
16206
16207 continue;
16208 }
16209 }
16210 else if (attack_mode == ATTACK_MODE_BF)
16211 {
16212 local_free (css_buf);
16213 local_free (data.root_css_buf);
16214 local_free (data.markov_css_buf);
16215
16216 char *mask = dictfiles[dictpos];
16217
16218 logfile_sub_string (mask);
16219
16220 // base
16221
16222 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16223
16224 if (opts_type & OPTS_TYPE_PT_UNICODE)
16225 {
16226 uint css_cnt_unicode = css_cnt * 2;
16227
16228 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16229
16230 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16231 {
16232 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16233
16234 css_buf_unicode[j + 1].cs_buf[0] = 0;
16235 css_buf_unicode[j + 1].cs_len = 1;
16236 }
16237
16238 free (css_buf);
16239
16240 css_buf = css_buf_unicode;
16241 css_cnt = css_cnt_unicode;
16242 }
16243
16244 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16245
16246 uint mask_min = pw_min;
16247 uint mask_max = pw_max;
16248
16249 if (opts_type & OPTS_TYPE_PT_UNICODE)
16250 {
16251 mask_min *= 2;
16252 mask_max *= 2;
16253 }
16254
16255 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16256 {
16257 if (css_cnt < mask_min)
16258 {
16259 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16260 }
16261
16262 if (css_cnt > mask_max)
16263 {
16264 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16265 }
16266
16267 // skip to next mask
16268
16269 dictpos++;
16270
16271 rd->dictpos = dictpos;
16272
16273 logfile_sub_msg ("STOP");
16274
16275 continue;
16276 }
16277
16278 uint save_css_cnt = css_cnt;
16279
16280 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16281 {
16282 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16283 {
16284 uint salt_len = (uint) data.salts_buf[0].salt_len;
16285 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16286
16287 uint css_cnt_salt = css_cnt + salt_len;
16288
16289 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16290
16291 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16292
16293 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16294 {
16295 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16296 css_buf_salt[j].cs_len = 1;
16297 }
16298
16299 free (css_buf);
16300
16301 css_buf = css_buf_salt;
16302 css_cnt = css_cnt_salt;
16303 }
16304 }
16305
16306 data.mask = mask;
16307 data.css_cnt = css_cnt;
16308 data.css_buf = css_buf;
16309
16310 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16311
16312 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16313
16314 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16315
16316 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16317 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16318
16319 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16320
16321 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16322
16323 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16324 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16325
16326 data.root_css_buf = root_css_buf;
16327 data.markov_css_buf = markov_css_buf;
16328
16329 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16330
16331 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16332
16333 local_free (root_table_buf);
16334 local_free (markov_table_buf);
16335
16336 // copy + args
16337
16338 uint css_cnt_l = css_cnt;
16339 uint css_cnt_r;
16340
16341 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16342 {
16343 if (save_css_cnt < 6)
16344 {
16345 css_cnt_r = 1;
16346 }
16347 else if (save_css_cnt == 6)
16348 {
16349 css_cnt_r = 2;
16350 }
16351 else
16352 {
16353 if (opts_type & OPTS_TYPE_PT_UNICODE)
16354 {
16355 if (save_css_cnt == 8 || save_css_cnt == 10)
16356 {
16357 css_cnt_r = 2;
16358 }
16359 else
16360 {
16361 css_cnt_r = 4;
16362 }
16363 }
16364 else
16365 {
16366 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16367 {
16368 css_cnt_r = 3;
16369 }
16370 else
16371 {
16372 css_cnt_r = 4;
16373 }
16374 }
16375 }
16376 }
16377 else
16378 {
16379 css_cnt_r = 1;
16380
16381 /* unfinished code?
16382 int sum = css_buf[css_cnt_r - 1].cs_len;
16383
16384 for (uint i = 1; i < 4 && i < css_cnt; i++)
16385 {
16386 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16387
16388 css_cnt_r++;
16389
16390 sum *= css_buf[css_cnt_r - 1].cs_len;
16391 }
16392 */
16393 }
16394
16395 css_cnt_l -= css_cnt_r;
16396
16397 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16398
16399 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16400 {
16401 hc_device_param_t *device_param = &data.devices_param[device_id];
16402
16403 if (device_param->skipped) continue;
16404
16405 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16406 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16407 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16408
16409 device_param->kernel_params_mp_l_buf64[3] = 0;
16410 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16411 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16412 device_param->kernel_params_mp_l_buf32[6] = 0;
16413 device_param->kernel_params_mp_l_buf32[7] = 0;
16414 device_param->kernel_params_mp_l_buf32[8] = 0;
16415
16416 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16417 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16418 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16419 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16420
16421 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16422 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16423 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16424
16425 device_param->kernel_params_mp_r_buf64[3] = 0;
16426 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16427 device_param->kernel_params_mp_r_buf32[5] = 0;
16428 device_param->kernel_params_mp_r_buf32[6] = 0;
16429 device_param->kernel_params_mp_r_buf32[7] = 0;
16430
16431 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]);
16432 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]);
16433 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]);
16434
16435 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]);
16436 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]);
16437 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]);
16438
16439 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);
16440 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);
16441 }
16442 }
16443
16444 u64 words_base = data.words_cnt;
16445
16446 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16447 {
16448 if (data.kernel_rules_cnt)
16449 {
16450 words_base /= data.kernel_rules_cnt;
16451 }
16452 }
16453 else if (data.attack_kern == ATTACK_KERN_COMBI)
16454 {
16455 if (data.combs_cnt)
16456 {
16457 words_base /= data.combs_cnt;
16458 }
16459 }
16460 else if (data.attack_kern == ATTACK_KERN_BF)
16461 {
16462 if (data.bfs_cnt)
16463 {
16464 words_base /= data.bfs_cnt;
16465 }
16466 }
16467
16468 data.words_base = words_base;
16469
16470 if (keyspace == 1)
16471 {
16472 log_info ("%llu", (unsigned long long int) words_base);
16473
16474 return (0);
16475 }
16476
16477 if (data.words_cur > data.words_base)
16478 {
16479 log_error ("ERROR: restore value greater keyspace");
16480
16481 return (-1);
16482 }
16483
16484 if (data.words_cur)
16485 {
16486 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16487 {
16488 for (uint i = 0; i < data.salts_cnt; i++)
16489 {
16490 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16491 }
16492 }
16493 else if (data.attack_kern == ATTACK_KERN_COMBI)
16494 {
16495 for (uint i = 0; i < data.salts_cnt; i++)
16496 {
16497 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16498 }
16499 }
16500 else if (data.attack_kern == ATTACK_KERN_BF)
16501 {
16502 for (uint i = 0; i < data.salts_cnt; i++)
16503 {
16504 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16505 }
16506 }
16507 }
16508
16509 /*
16510 * Inform user about possible slow speeds
16511 */
16512
16513 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16514 {
16515 if (data.words_base < kernel_power_all)
16516 {
16517 if (quiet == 0)
16518 {
16519 log_info ("");
16520 log_info ("ATTENTION!");
16521 log_info (" The wordlist or mask you are using is too small.");
16522 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16523 log_info (" The cracking speed will drop.");
16524 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16525 log_info ("");
16526 }
16527 }
16528 }
16529
16530 /*
16531 * Update loopback file
16532 */
16533
16534 if (loopback == 1)
16535 {
16536 time_t now;
16537
16538 time (&now);
16539
16540 uint random_num = get_random_num (0, 9999);
16541
16542 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16543
16544 data.loopback_file = loopback_file;
16545 }
16546
16547 /*
16548 * Update dictionary statistic
16549 */
16550
16551 if (keyspace == 0)
16552 {
16553 dictstat_fp = fopen (dictstat, "wb");
16554
16555 if (dictstat_fp)
16556 {
16557 lock_file (dictstat_fp);
16558
16559 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16560
16561 fclose (dictstat_fp);
16562 }
16563 }
16564
16565 data.devices_status = STATUS_RUNNING;
16566
16567 if (initial_restore_done == 0)
16568 {
16569 if (data.restore_disable == 0) cycle_restore ();
16570
16571 initial_restore_done = 1;
16572 }
16573
16574 hc_timer_set (&data.timer_running);
16575
16576 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16577 {
16578 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16579 {
16580 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16581 if (quiet == 0) fflush (stdout);
16582 }
16583 }
16584 else if (wordlist_mode == WL_MODE_STDIN)
16585 {
16586 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16587 if (data.quiet == 0) log_info ("");
16588 }
16589
16590 time_t runtime_start;
16591
16592 time (&runtime_start);
16593
16594 data.runtime_start = runtime_start;
16595
16596 /**
16597 * create cracker threads
16598 */
16599
16600 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16601
16602 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16603 {
16604 hc_device_param_t *device_param = &devices_param[device_id];
16605
16606 if (wordlist_mode == WL_MODE_STDIN)
16607 {
16608 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16609 }
16610 else
16611 {
16612 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16613 }
16614 }
16615
16616 // wait for crack threads to exit
16617
16618 hc_thread_wait (data.devices_cnt, c_threads);
16619
16620 local_free (c_threads);
16621
16622 data.restore = 0;
16623
16624 // finalize task
16625
16626 logfile_sub_var_uint ("status-after-work", data.devices_status);
16627
16628 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16629
16630 if (data.devices_status == STATUS_CRACKED) break;
16631 if (data.devices_status == STATUS_ABORTED) break;
16632
16633 if (data.devices_status == STATUS_BYPASS)
16634 {
16635 data.devices_status = STATUS_RUNNING;
16636 }
16637
16638 if (induction_dictionaries_cnt)
16639 {
16640 unlink (induction_dictionaries[0]);
16641 }
16642
16643 free (induction_dictionaries);
16644
16645 if (attack_mode != ATTACK_MODE_BF)
16646 {
16647 induction_dictionaries = scan_directory (induction_directory);
16648
16649 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16650 }
16651
16652 if (benchmark == 0)
16653 {
16654 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16655 {
16656 if (quiet == 0) clear_prompt ();
16657
16658 if (quiet == 0) log_info ("");
16659
16660 if (status == 1)
16661 {
16662 status_display ();
16663 }
16664 else
16665 {
16666 if (quiet == 0) status_display ();
16667 }
16668
16669 if (quiet == 0) log_info ("");
16670 }
16671 }
16672
16673 if (attack_mode == ATTACK_MODE_BF)
16674 {
16675 dictpos++;
16676
16677 rd->dictpos = dictpos;
16678 }
16679 else
16680 {
16681 if (induction_dictionaries_cnt)
16682 {
16683 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16684 }
16685 else
16686 {
16687 dictpos++;
16688
16689 rd->dictpos = dictpos;
16690 }
16691 }
16692
16693 time_t runtime_stop;
16694
16695 time (&runtime_stop);
16696
16697 data.runtime_stop = runtime_stop;
16698
16699 logfile_sub_uint (runtime_start);
16700 logfile_sub_uint (runtime_stop);
16701
16702 logfile_sub_msg ("STOP");
16703
16704 global_free (subid);
16705 }
16706
16707 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16708
16709 if (data.devices_status == STATUS_CRACKED) break;
16710 if (data.devices_status == STATUS_ABORTED) break;
16711 if (data.devices_status == STATUS_QUIT) break;
16712
16713 if (data.devices_status == STATUS_BYPASS)
16714 {
16715 data.devices_status = STATUS_RUNNING;
16716 }
16717 }
16718
16719 // 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
16720
16721 if (attack_mode == ATTACK_MODE_STRAIGHT)
16722 {
16723 if (data.wordlist_mode == WL_MODE_FILE)
16724 {
16725 if (data.dictfile == NULL)
16726 {
16727 if (dictfiles != NULL)
16728 {
16729 data.dictfile = dictfiles[0];
16730
16731 hc_timer_set (&data.timer_running);
16732 }
16733 }
16734 }
16735 }
16736 // NOTE: combi is okay because it is already set beforehand
16737 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16738 {
16739 if (data.dictfile == NULL)
16740 {
16741 if (dictfiles != NULL)
16742 {
16743 hc_timer_set (&data.timer_running);
16744
16745 data.dictfile = dictfiles[0];
16746 }
16747 }
16748 }
16749 else if (attack_mode == ATTACK_MODE_BF)
16750 {
16751 if (data.mask == NULL)
16752 {
16753 hc_timer_set (&data.timer_running);
16754
16755 data.mask = masks[0];
16756 }
16757 }
16758
16759 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16760 {
16761 data.devices_status = STATUS_EXHAUSTED;
16762 }
16763
16764 // if cracked / aborted remove last induction dictionary
16765
16766 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16767 {
16768 struct stat induct_stat;
16769
16770 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16771 {
16772 unlink (induction_dictionaries[file_pos]);
16773 }
16774 }
16775
16776 // wait for non-interactive threads
16777
16778 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16779 {
16780 hc_thread_wait (1, &ni_threads[thread_idx]);
16781 }
16782
16783 local_free (ni_threads);
16784
16785 // wait for interactive threads
16786
16787 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16788 {
16789 hc_thread_wait (1, &i_thread);
16790 }
16791
16792 // we dont need restore file anymore
16793 if (data.restore_disable == 0)
16794 {
16795 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16796 {
16797 unlink (eff_restore_file);
16798 unlink (new_restore_file);
16799 }
16800 else
16801 {
16802 cycle_restore ();
16803 }
16804 }
16805
16806 // finally save left hashes
16807
16808 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16809 {
16810 save_hash ();
16811 }
16812
16813 /**
16814 * Clean up
16815 */
16816
16817 if (benchmark == 1)
16818 {
16819 status_benchmark ();
16820
16821 log_info ("");
16822 }
16823 else
16824 {
16825 if (quiet == 0) clear_prompt ();
16826
16827 if (quiet == 0) log_info ("");
16828
16829 if (status == 1)
16830 {
16831 status_display ();
16832 }
16833 else
16834 {
16835 if (quiet == 0) status_display ();
16836 }
16837
16838 if (quiet == 0) log_info ("");
16839 }
16840
16841 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16842 {
16843 hc_device_param_t *device_param = &data.devices_param[device_id];
16844
16845 if (device_param->skipped) continue;
16846
16847 local_free (device_param->result);
16848
16849 local_free (device_param->combs_buf);
16850
16851 local_free (device_param->hooks_buf);
16852
16853 local_free (device_param->device_name);
16854
16855 local_free (device_param->device_name_chksum);
16856
16857 local_free (device_param->device_version);
16858
16859 local_free (device_param->driver_version);
16860
16861 if (device_param->pws_buf) myfree (device_param->pws_buf);
16862 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16863 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16864 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16865 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16866 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16867 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16868 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16869 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16870 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16871 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16872 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16873 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16874 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16875 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16876 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16877 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16878 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16879 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16880 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16881 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16882 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16883 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16884 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16885 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16886 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16887 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16888 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16889 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16890
16891 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16892 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16893 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16894 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16895 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16896 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16897 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16898 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16899 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16900 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16901
16902 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16903 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16904 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16905
16906 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16907 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16908 }
16909
16910 // reset default fan speed
16911
16912 #ifdef HAVE_HWMON
16913 if (gpu_temp_disable == 0)
16914 {
16915 #ifdef HAVE_ADL
16916 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16917 {
16918 hc_thread_mutex_lock (mux_adl);
16919
16920 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16921 {
16922 hc_device_param_t *device_param = &data.devices_param[device_id];
16923
16924 if (device_param->skipped) continue;
16925
16926 if (data.hm_device[device_id].fan_supported == 1)
16927 {
16928 int fanspeed = temp_retain_fanspeed_value[device_id];
16929
16930 if (fanspeed == -1) continue;
16931
16932 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16933
16934 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16935 }
16936 }
16937
16938 hc_thread_mutex_unlock (mux_adl);
16939 }
16940 #endif // HAVE_ADL
16941 }
16942
16943 #ifdef HAVE_ADL
16944 // reset power tuning
16945
16946 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16947 {
16948 hc_thread_mutex_lock (mux_adl);
16949
16950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16951 {
16952 hc_device_param_t *device_param = &data.devices_param[device_id];
16953
16954 if (device_param->skipped) continue;
16955
16956 if (data.hm_device[device_id].od_version == 6)
16957 {
16958 // check powertune capabilities first, if not available then skip device
16959
16960 int powertune_supported = 0;
16961
16962 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16963 {
16964 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16965
16966 return (-1);
16967 }
16968
16969 if (powertune_supported != 0)
16970 {
16971 // powercontrol settings
16972
16973 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)
16974 {
16975 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16976
16977 return (-1);
16978 }
16979
16980 // clocks
16981
16982 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16983
16984 performance_state->iNumberOfPerformanceLevels = 2;
16985
16986 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16987 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16988 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16989 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16990
16991 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)
16992 {
16993 log_info ("ERROR: Failed to restore ADL performance state");
16994
16995 return (-1);
16996 }
16997
16998 local_free (performance_state);
16999 }
17000 }
17001 }
17002
17003 hc_thread_mutex_unlock (mux_adl);
17004 }
17005 #endif // HAVE_ADL
17006
17007 if (gpu_temp_disable == 0)
17008 {
17009 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17010 if (data.hm_nv)
17011 {
17012 #if defined(LINUX) && defined(HAVE_NVML)
17013
17014 hm_NVML_nvmlShutdown (data.hm_nv);
17015
17016 nvml_close (data.hm_nv);
17017
17018 #elif defined(WIN) && (HAVE_NVAPI)
17019
17020 hm_NvAPI_Unload (data.hm_nv);
17021
17022 nvapi_close (data.hm_nv);
17023
17024 #endif
17025
17026 data.hm_nv = NULL;
17027 }
17028 #endif
17029
17030 #ifdef HAVE_ADL
17031 if (data.hm_amd)
17032 {
17033 hm_ADL_Main_Control_Destroy (data.hm_amd);
17034
17035 adl_close (data.hm_amd);
17036 data.hm_amd = NULL;
17037 }
17038 #endif
17039 }
17040 #endif // HAVE_HWMON
17041
17042 // free memory
17043
17044 local_free (masks);
17045
17046 local_free (dictstat_base);
17047
17048 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17049 {
17050 pot_t *pot_ptr = &pot[pot_pos];
17051
17052 hash_t *hash = &pot_ptr->hash;
17053
17054 local_free (hash->digest);
17055
17056 if (isSalted)
17057 {
17058 local_free (hash->salt);
17059 }
17060 }
17061
17062 local_free (pot);
17063
17064 local_free (all_kernel_rules_cnt);
17065 local_free (all_kernel_rules_buf);
17066
17067 local_free (wl_data->buf);
17068 local_free (wl_data);
17069
17070 local_free (bitmap_s1_a);
17071 local_free (bitmap_s1_b);
17072 local_free (bitmap_s1_c);
17073 local_free (bitmap_s1_d);
17074 local_free (bitmap_s2_a);
17075 local_free (bitmap_s2_b);
17076 local_free (bitmap_s2_c);
17077 local_free (bitmap_s2_d);
17078
17079 #ifdef HAVE_HWMON
17080 local_free (temp_retain_fanspeed_value);
17081 #ifdef HAVE_ADL
17082 local_free (od_clock_mem_status);
17083 local_free (od_power_control_status);
17084 #endif // ADL
17085 #endif
17086
17087 global_free (devices_param);
17088
17089 global_free (kernel_rules_buf);
17090
17091 global_free (root_css_buf);
17092 global_free (markov_css_buf);
17093
17094 global_free (digests_buf);
17095 global_free (digests_shown);
17096 global_free (digests_shown_tmp);
17097
17098 global_free (salts_buf);
17099 global_free (salts_shown);
17100
17101 global_free (esalts_buf);
17102
17103 global_free (words_progress_done);
17104 global_free (words_progress_rejected);
17105 global_free (words_progress_restored);
17106
17107 if (pot_fp) fclose (pot_fp);
17108
17109 if (data.devices_status == STATUS_QUIT) break;
17110 }
17111
17112 // destroy others mutex
17113
17114 hc_thread_mutex_delete (mux_dispatcher);
17115 hc_thread_mutex_delete (mux_counter);
17116 hc_thread_mutex_delete (mux_display);
17117 hc_thread_mutex_delete (mux_adl);
17118
17119 // free memory
17120
17121 local_free (eff_restore_file);
17122 local_free (new_restore_file);
17123
17124 local_free (rd);
17125
17126 // tuning db
17127
17128 tuning_db_destroy (tuning_db);
17129
17130 // loopback
17131
17132 local_free (loopback_file);
17133
17134 if (loopback == 1) unlink (loopback_file);
17135
17136 // induction directory
17137
17138 if (induction_dir == NULL)
17139 {
17140 if (attack_mode != ATTACK_MODE_BF)
17141 {
17142 if (rmdir (induction_directory) == -1)
17143 {
17144 if (errno == ENOENT)
17145 {
17146 // good, we can ignore
17147 }
17148 else if (errno == ENOTEMPTY)
17149 {
17150 // good, we can ignore
17151 }
17152 else
17153 {
17154 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17155
17156 return (-1);
17157 }
17158 }
17159
17160 local_free (induction_directory);
17161 }
17162 }
17163
17164 // outfile-check directory
17165
17166 if (outfile_check_dir == NULL)
17167 {
17168 if (rmdir (outfile_check_directory) == -1)
17169 {
17170 if (errno == ENOENT)
17171 {
17172 // good, we can ignore
17173 }
17174 else if (errno == ENOTEMPTY)
17175 {
17176 // good, we can ignore
17177 }
17178 else
17179 {
17180 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17181
17182 return (-1);
17183 }
17184 }
17185
17186 local_free (outfile_check_directory);
17187 }
17188
17189 time_t proc_stop;
17190
17191 time (&proc_stop);
17192
17193 logfile_top_uint (proc_start);
17194 logfile_top_uint (proc_stop);
17195
17196 logfile_top_msg ("STOP");
17197
17198 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17199 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17200
17201 if (data.ocl) ocl_close (data.ocl);
17202
17203 if (data.devices_status == STATUS_ABORTED) return 2;
17204 if (data.devices_status == STATUS_QUIT) return 2;
17205 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17206 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17207 if (data.devices_status == STATUS_CRACKED) return 0;
17208
17209 return -1;
17210 }
Hashcat additions to support pwdhash