projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add compiler kernel hints for algorithms with fixed workgroup size
[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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 136
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 12500,
274 13000,
275 13200,
276 13300,
277 6211,
278 6221,
279 6231,
280 6241,
281 8800,
282 12900,
283 12200,
284 9700,
285 9710,
286 9800,
287 9810,
288 9400,
289 9500,
290 9600,
291 10400,
292 10410,
293 10500,
294 10600,
295 10700,
296 9000,
297 5200,
298 6800,
299 6600,
300 8200,
301 11300,
302 12700,
303 13400,
304 125
305 };
306
307 /**
308 * types
309 */
310
311 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
312
313 /**
314 * globals
315 */
316
317 static unsigned int full01 = 0x01010101;
318 static unsigned int full80 = 0x80808080;
319
320 int SUPPRESS_OUTPUT = 0;
321
322 hc_thread_mutex_t mux_adl;
323 hc_thread_mutex_t mux_counter;
324 hc_thread_mutex_t mux_dispatcher;
325 hc_thread_mutex_t mux_display;
326
327 hc_global_data_t data;
328
329 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
330
331 const char *USAGE_MINI[] =
332 {
333 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
334 "",
335 "Try --help for more help.",
336 NULL
337 };
338
339 const char *USAGE_BIG[] =
340 {
341 "%s, advanced password recovery",
342 "",
343 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
344 "",
345 "=======",
346 "Options",
347 "=======",
348 "",
349 "* General:",
350 "",
351 " -m, --hash-type=NUM Hash-type, see references below",
352 " -a, --attack-mode=NUM Attack-mode, see references below",
353 " -V, --version Print version",
354 " -h, --help Print help",
355 " --quiet Suppress output",
356 "",
357 "* Misc:",
358 "",
359 " --hex-charset Assume charset is given in hex",
360 " --hex-salt Assume salt is given in hex",
361 " --hex-wordlist Assume words in wordlist is given in hex",
362 " --force Ignore warnings",
363 " --status Enable automatic update of the status-screen",
364 " --status-timer=NUM Seconds between status-screen update",
365 " --status-automat Display the status view in a machine readable format",
366 " --loopback Add new plains to induct directory",
367 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
368 "",
369 "* Markov:",
370 "",
371 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
372 " --markov-disable Disables markov-chains, emulates classic brute-force",
373 " --markov-classic Enables classic markov-chains, no per-position enhancement",
374 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
375 "",
376 "* Session:",
377 "",
378 " --runtime=NUM Abort session after NUM seconds of runtime",
379 " --session=STR Define specific session name",
380 " --restore Restore session from --session",
381 " --restore-disable Do not write restore file",
382 "",
383 "* Files:",
384 "",
385 " -o, --outfile=FILE Define outfile for recovered hash",
386 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
387 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
388 " --outfile-check-timer=NUM Seconds between outfile checks",
389 " -p, --separator=CHAR Separator char for hashlists and outfile",
390 " --show Show cracked passwords only",
391 " --left Show un-cracked passwords only",
392 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
393 " --remove Enable remove of hash once it is cracked",
394 " --remove-timer=NUM Update input hash file each NUM seconds",
395 " --potfile-disable Do not write potfile",
396 " --potfile-path Specific path to potfile",
397 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
398 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
399 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
400 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
401 " --logfile-disable Disable the logfile",
402 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
403 "",
404 "* Resources:",
405 "",
406 " -b, --benchmark Run benchmark",
407 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
408 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
409 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
410 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
411 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
412 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
413 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
414 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
415 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
416 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
417 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
418 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
419 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
420 #ifdef HAVE_HWMON
421 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
422 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
423 #ifdef HAVE_ADL
424 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
425 #endif
426 #endif
427 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
428 "",
429 "* Distributed:",
430 "",
431 " -s, --skip=NUM Skip number of words",
432 " -l, --limit=NUM Limit number of words",
433 " --keyspace Show keyspace base:mod values and quit",
434 "",
435 "* Rules:",
436 "",
437 " -j, --rule-left=RULE Single rule applied to each word from left dict",
438 " -k, --rule-right=RULE Single rule applied to each word from right dict",
439 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
440 " -g, --generate-rules=NUM Generate NUM random rules",
441 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
442 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
443 " --generate-rules-seed=NUM Force RNG seed to NUM",
444 "",
445 "* Custom charsets:",
446 "",
447 " -1, --custom-charset1=CS User-defined charsets",
448 " -2, --custom-charset2=CS Example:",
449 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
450 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
451 "",
452 "* Increment:",
453 "",
454 " -i, --increment Enable increment mode",
455 " --increment-min=NUM Start incrementing at NUM",
456 " --increment-max=NUM Stop incrementing at NUM",
457 "",
458 "==========",
459 "References",
460 "==========",
461 "",
462 "* Workload Profile:",
463 "",
464 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
465 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
466 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
467 "",
468 "* OpenCL device-types:",
469 "",
470 " 1 = CPU devices",
471 " 2 = GPU devices",
472 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
473 "",
474 "* Outfile Formats:",
475 "",
476 " 1 = hash[:salt]",
477 " 2 = plain",
478 " 3 = hash[:salt]:plain",
479 " 4 = hex_plain",
480 " 5 = hash[:salt]:hex_plain",
481 " 6 = plain:hex_plain",
482 " 7 = hash[:salt]:plain:hex_plain",
483 " 8 = crackpos",
484 " 9 = hash[:salt]:crackpos",
485 " 10 = plain:crackpos",
486 " 11 = hash[:salt]:plain:crackpos",
487 " 12 = hex_plain:crackpos",
488 " 13 = hash[:salt]:hex_plain:crackpos",
489 " 14 = plain:hex_plain:crackpos",
490 " 15 = hash[:salt]:plain:hex_plain:crackpos",
491 "",
492 "* Debug mode output formats (for hybrid mode only, by using rules):",
493 "",
494 " 1 = save finding rule",
495 " 2 = save original word",
496 " 3 = save original word and finding rule",
497 " 4 = save original word, finding rule and modified plain",
498 "",
499 "* Built-in charsets:",
500 "",
501 " ?l = abcdefghijklmnopqrstuvwxyz",
502 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
503 " ?d = 0123456789",
504 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
505 " ?a = ?l?u?d?s",
506 " ?b = 0x00 - 0xff",
507 "",
508 "* Attack modes:",
509 "",
510 " 0 = Straight",
511 " 1 = Combination",
512 " 3 = Brute-force",
513 " 6 = Hybrid dict + mask",
514 " 7 = Hybrid mask + dict",
515 "",
516 "* Hash types:",
517 "",
518 "[[ Roll-your-own: Raw Hashes ]]",
519 "",
520 " 900 = MD4",
521 " 0 = MD5",
522 " 5100 = Half MD5",
523 " 100 = SHA1",
524 " 10800 = SHA-384",
525 " 1400 = SHA-256",
526 " 1700 = SHA-512",
527 " 5000 = SHA-3(Keccak)",
528 " 10100 = SipHash",
529 " 6000 = RipeMD160",
530 " 6100 = Whirlpool",
531 " 6900 = GOST R 34.11-94",
532 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
533 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
534 "",
535 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
536 "",
537 " 10 = md5($pass.$salt)",
538 " 20 = md5($salt.$pass)",
539 " 30 = md5(unicode($pass).$salt)",
540 " 40 = md5($salt.unicode($pass))",
541 " 3800 = md5($salt.$pass.$salt)",
542 " 3710 = md5($salt.md5($pass))",
543 " 2600 = md5(md5($pass)",
544 " 4300 = md5(strtoupper(md5($pass)))",
545 " 4400 = md5(sha1($pass))",
546 " 110 = sha1($pass.$salt)",
547 " 120 = sha1($salt.$pass)",
548 " 130 = sha1(unicode($pass).$salt)",
549 " 140 = sha1($salt.unicode($pass))",
550 " 4500 = sha1(sha1($pass)",
551 " 4700 = sha1(md5($pass))",
552 " 4900 = sha1($salt.$pass.$salt)",
553 " 1410 = sha256($pass.$salt)",
554 " 1420 = sha256($salt.$pass)",
555 " 1430 = sha256(unicode($pass).$salt)",
556 " 1440 = sha256($salt.unicode($pass))",
557 " 1710 = sha512($pass.$salt)",
558 " 1720 = sha512($salt.$pass)",
559 " 1730 = sha512(unicode($pass).$salt)",
560 " 1740 = sha512($salt.unicode($pass))",
561 "",
562 "[[ Roll-your-own: Authenticated Hashes ]]",
563 "",
564 " 50 = HMAC-MD5 (key = $pass)",
565 " 60 = HMAC-MD5 (key = $salt)",
566 " 150 = HMAC-SHA1 (key = $pass)",
567 " 160 = HMAC-SHA1 (key = $salt)",
568 " 1450 = HMAC-SHA256 (key = $pass)",
569 " 1460 = HMAC-SHA256 (key = $salt)",
570 " 1750 = HMAC-SHA512 (key = $pass)",
571 " 1760 = HMAC-SHA512 (key = $salt)",
572 "",
573 "[[ Generic KDF ]]",
574 "",
575 " 400 = phpass",
576 " 8900 = scrypt",
577 " 11900 = PBKDF2-HMAC-MD5",
578 " 12000 = PBKDF2-HMAC-SHA1",
579 " 10900 = PBKDF2-HMAC-SHA256",
580 " 12100 = PBKDF2-HMAC-SHA512",
581 "",
582 "[[ Network protocols, Challenge-Response ]]",
583 "",
584 " 23 = Skype",
585 " 2500 = WPA/WPA2",
586 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
587 " 5300 = IKE-PSK MD5",
588 " 5400 = IKE-PSK SHA1",
589 " 5500 = NetNTLMv1",
590 " 5500 = NetNTLMv1 + ESS",
591 " 5600 = NetNTLMv2",
592 " 7300 = IPMI2 RAKP HMAC-SHA1",
593 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
594 " 8300 = DNSSEC (NSEC3)",
595 " 10200 = Cram MD5",
596 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
597 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
598 " 11400 = SIP digest authentication (MD5)",
599 " 13100 = Kerberos 5 TGS-REP etype 23",
600 "",
601 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
602 "",
603 " 121 = SMF (Simple Machines Forum)",
604 " 400 = phpBB3",
605 " 2611 = vBulletin < v3.8.5",
606 " 2711 = vBulletin > v3.8.5",
607 " 2811 = MyBB",
608 " 2811 = IPB (Invison Power Board)",
609 " 8400 = WBB3 (Woltlab Burning Board)",
610 " 11 = Joomla < 2.5.18",
611 " 400 = Joomla > 2.5.18",
612 " 400 = Wordpress",
613 " 2612 = PHPS",
614 " 7900 = Drupal7",
615 " 21 = osCommerce",
616 " 21 = xt:Commerce",
617 " 11000 = PrestaShop",
618 " 124 = Django (SHA-1)",
619 " 10000 = Django (PBKDF2-SHA256)",
620 " 3711 = Mediawiki B type",
621 " 7600 = Redmine",
622 "",
623 "[[ Database Server ]]",
624 "",
625 " 12 = PostgreSQL",
626 " 131 = MSSQL(2000)",
627 " 132 = MSSQL(2005)",
628 " 1731 = MSSQL(2012)",
629 " 1731 = MSSQL(2014)",
630 " 200 = MySQL323",
631 " 300 = MySQL4.1/MySQL5",
632 " 3100 = Oracle H: Type (Oracle 7+)",
633 " 112 = Oracle S: Type (Oracle 11+)",
634 " 12300 = Oracle T: Type (Oracle 12+)",
635 " 8000 = Sybase ASE",
636 "",
637 "[[ HTTP, SMTP, LDAP Server ]]",
638 "",
639 " 141 = EPiServer 6.x < v4",
640 " 1441 = EPiServer 6.x > v4",
641 " 1600 = Apache $apr1$",
642 " 12600 = ColdFusion 10+",
643 " 1421 = hMailServer",
644 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
645 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
646 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
647 "",
648 "[[ Checksums ]]",
649 "",
650 " 11500 = CRC32",
651 "",
652 "[[ Operating-Systems ]]",
653 "",
654 " 3000 = LM",
655 " 1000 = NTLM",
656 " 1100 = Domain Cached Credentials (DCC), MS Cache",
657 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
658 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
659 " 1500 = descrypt, DES(Unix), Traditional DES",
660 " 12400 = BSDiCrypt, Extended DES",
661 " 500 = md5crypt $1$, MD5(Unix)",
662 " 3200 = bcrypt $2*$, Blowfish(Unix)",
663 " 7400 = sha256crypt $5$, SHA256(Unix)",
664 " 1800 = sha512crypt $6$, SHA512(Unix)",
665 " 122 = OSX v10.4",
666 " 122 = OSX v10.5",
667 " 122 = OSX v10.6",
668 " 1722 = OSX v10.7",
669 " 7100 = OSX v10.8",
670 " 7100 = OSX v10.9",
671 " 7100 = OSX v10.10",
672 " 6300 = AIX {smd5}",
673 " 6700 = AIX {ssha1}",
674 " 6400 = AIX {ssha256}",
675 " 6500 = AIX {ssha512}",
676 " 2400 = Cisco-PIX",
677 " 2410 = Cisco-ASA",
678 " 500 = Cisco-IOS $1$",
679 " 5700 = Cisco-IOS $4$",
680 " 9200 = Cisco-IOS $8$",
681 " 9300 = Cisco-IOS $9$",
682 " 22 = Juniper Netscreen/SSG (ScreenOS)",
683 " 501 = Juniper IVE",
684 " 5800 = Android PIN",
685 " 8100 = Citrix Netscaler",
686 " 8500 = RACF",
687 " 7200 = GRUB 2",
688 " 9900 = Radmin2",
689 " 125 = ArubaOS",
690 "",
691 "[[ Enterprise Application Software (EAS) ]]",
692 "",
693 " 7700 = SAP CODVN B (BCODE)",
694 " 7800 = SAP CODVN F/G (PASSCODE)",
695 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
696 " 8600 = Lotus Notes/Domino 5",
697 " 8700 = Lotus Notes/Domino 6",
698 " 9100 = Lotus Notes/Domino 8",
699 " 133 = PeopleSoft",
700 " 13500 = PeopleSoft Token",
701 "",
702 "[[ Archives ]]",
703 "",
704 " 11600 = 7-Zip",
705 " 12500 = RAR3-hp",
706 " 13000 = RAR5",
707 " 13200 = AxCrypt",
708 " 13300 = AxCrypt in memory SHA1",
709 "",
710 "[[ Full-Disk encryptions (FDE) ]]",
711 "",
712 " 62XY = TrueCrypt 5.0+",
713 " X = 1 = PBKDF2-HMAC-RipeMD160",
714 " X = 2 = PBKDF2-HMAC-SHA512",
715 " X = 3 = PBKDF2-HMAC-Whirlpool",
716 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
717 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
718 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
719 " Y = 3 = XTS 1536 bit (Ciphers: All)",
720 " 8800 = Android FDE < v4.3",
721 " 12900 = Android FDE (Samsung DEK)",
722 " 12200 = eCryptfs",
723 "",
724 "[[ Documents ]]",
725 "",
726 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
727 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
728 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
729 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
730 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
731 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
732 " 9400 = MS Office 2007",
733 " 9500 = MS Office 2010",
734 " 9600 = MS Office 2013",
735 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
736 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
737 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
738 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
739 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
740 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
741 "",
742 "[[ Password Managers ]]",
743 "",
744 " 9000 = Password Safe v2",
745 " 5200 = Password Safe v3",
746 " 6800 = Lastpass",
747 " 6600 = 1Password, agilekeychain",
748 " 8200 = 1Password, cloudkeychain",
749 " 11300 = Bitcoin/Litecoin wallet.dat",
750 " 12700 = Blockchain, My Wallet",
751 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
752 "",
753 NULL
754 };
755
756 /**
757 * 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 double speed_ms = 0;
807
808 for (int i = 0; i < SPEED_CACHE; i++)
809 {
810 speed_cnt += device_param->speed_cnt[i];
811 speed_ms += device_param->speed_ms[i];
812 }
813
814 speed_cnt /= SPEED_CACHE;
815 speed_ms /= SPEED_CACHE;
816
817 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
818 }
819
820 /**
821 * exec time
822 */
823
824 fprintf (out, "EXEC_RUNTIME\t");
825
826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
827 {
828 hc_device_param_t *device_param = &data.devices_param[device_id];
829
830 if (device_param->skipped) continue;
831
832 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
833
834 fprintf (out, "%f\t", exec_ms_avg);
835 }
836
837 /**
838 * words_cur
839 */
840
841 u64 words_cur = get_lowest_words_done ();
842
843 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
844
845 /**
846 * counter
847 */
848
849 u64 progress_total = data.words_cnt * data.salts_cnt;
850
851 u64 all_done = 0;
852 u64 all_rejected = 0;
853 u64 all_restored = 0;
854
855 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
856 {
857 all_done += data.words_progress_done[salt_pos];
858 all_rejected += data.words_progress_rejected[salt_pos];
859 all_restored += data.words_progress_restored[salt_pos];
860 }
861
862 u64 progress_cur = all_restored + all_done + all_rejected;
863 u64 progress_end = progress_total;
864
865 u64 progress_skip = 0;
866
867 if (data.skip)
868 {
869 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
870
871 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
872 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
873 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
874 }
875
876 if (data.limit)
877 {
878 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
879
880 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
881 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
882 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
883 }
884
885 u64 progress_cur_relative_skip = progress_cur - progress_skip;
886 u64 progress_end_relative_skip = progress_end - progress_skip;
887
888 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
889
890 /**
891 * cracks
892 */
893
894 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
895 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
896
897 /**
898 * temperature
899 */
900
901 #ifdef HAVE_HWMON
902 if (data.gpu_temp_disable == 0)
903 {
904 fprintf (out, "TEMP\t");
905
906 hc_thread_mutex_lock (mux_adl);
907
908 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
909 {
910 hc_device_param_t *device_param = &data.devices_param[device_id];
911
912 if (device_param->skipped) continue;
913
914 int temp = hm_get_temperature_with_device_id (device_id);
915
916 fprintf (out, "%d\t", temp);
917 }
918
919 hc_thread_mutex_unlock (mux_adl);
920 }
921 #endif // HAVE_HWMON
922
923 /**
924 * flush
925 */
926
927 #ifdef _WIN
928 fputc ('\r', out);
929 fputc ('\n', out);
930 #endif
931
932 #ifdef _POSIX
933 fputc ('\n', out);
934 #endif
935
936 fflush (out);
937 }
938
939 void status_display ()
940 {
941 if (data.devices_status == STATUS_INIT) return;
942 if (data.devices_status == STATUS_STARTING) return;
943 if (data.devices_status == STATUS_BYPASS) return;
944
945 if (data.status_automat == 1)
946 {
947 status_display_automat ();
948
949 return;
950 }
951
952 char tmp_buf[1000] = { 0 };
953
954 uint tmp_len = 0;
955
956 log_info ("Session.Name...: %s", data.session);
957
958 char *status_type = strstatus (data.devices_status);
959
960 uint hash_mode = data.hash_mode;
961
962 char *hash_type = strhashtype (hash_mode); // not a bug
963
964 log_info ("Status.........: %s", status_type);
965
966 /**
967 * show rules
968 */
969
970 if (data.rp_files_cnt)
971 {
972 uint i;
973
974 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
975 {
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
977 }
978
979 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
980
981 log_info ("Rules.Type.....: %s", tmp_buf);
982
983 tmp_len = 0;
984 }
985
986 if (data.rp_gen)
987 {
988 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
989
990 if (data.rp_gen_seed)
991 {
992 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
993 }
994 }
995
996 /**
997 * show input
998 */
999
1000 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1001 {
1002 if (data.wordlist_mode == WL_MODE_FILE)
1003 {
1004 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1005 }
1006 else if (data.wordlist_mode == WL_MODE_STDIN)
1007 {
1008 log_info ("Input.Mode.....: Pipe");
1009 }
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_COMBI)
1012 {
1013 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1014 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1015 }
1016 else if (data.attack_mode == ATTACK_MODE_BF)
1017 {
1018 char *mask = data.mask;
1019
1020 if (mask != NULL)
1021 {
1022 uint mask_len = data.css_cnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1025
1026 if (mask_len > 0)
1027 {
1028 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1029 {
1030 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1031 {
1032 mask_len -= data.salts_buf[0].salt_len;
1033 }
1034 }
1035
1036 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1037
1038 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1039 }
1040
1041 if (data.maskcnt > 1)
1042 {
1043 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1044
1045 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1046 }
1047
1048 log_info ("Input.Mode.....: %s", tmp_buf);
1049 }
1050
1051 tmp_len = 0;
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1054 {
1055 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1056 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1057 }
1058 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1059 {
1060 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1061 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1062 }
1063
1064 if (data.digests_cnt == 1)
1065 {
1066 if (data.hash_mode == 2500)
1067 {
1068 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1069
1070 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1071 (char *) data.salts_buf[0].salt_buf,
1072 wpa->orig_mac1[0],
1073 wpa->orig_mac1[1],
1074 wpa->orig_mac1[2],
1075 wpa->orig_mac1[3],
1076 wpa->orig_mac1[4],
1077 wpa->orig_mac1[5],
1078 wpa->orig_mac2[0],
1079 wpa->orig_mac2[1],
1080 wpa->orig_mac2[2],
1081 wpa->orig_mac2[3],
1082 wpa->orig_mac2[4],
1083 wpa->orig_mac2[5]);
1084 }
1085 else if (data.hash_mode == 5200)
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else if (data.hash_mode == 9000)
1090 {
1091 log_info ("Hash.Target....: File (%s)", data.hashfile);
1092 }
1093 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1094 {
1095 log_info ("Hash.Target....: File (%s)", data.hashfile);
1096 }
1097 else
1098 {
1099 char out_buf[HCBUFSIZ] = { 0 };
1100
1101 ascii_digest (out_buf, 0, 0);
1102
1103 // limit length
1104 if (strlen (out_buf) > 40)
1105 {
1106 out_buf[41] = '.';
1107 out_buf[42] = '.';
1108 out_buf[43] = '.';
1109 out_buf[44] = 0;
1110 }
1111
1112 log_info ("Hash.Target....: %s", out_buf);
1113 }
1114 }
1115 else
1116 {
1117 if (data.hash_mode == 3000)
1118 {
1119 char out_buf1[32] = { 0 };
1120 char out_buf2[32] = { 0 };
1121
1122 ascii_digest (out_buf1, 0, 0);
1123 ascii_digest (out_buf2, 0, 1);
1124
1125 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1126 }
1127 else
1128 {
1129 log_info ("Hash.Target....: File (%s)", data.hashfile);
1130 }
1131 }
1132
1133 log_info ("Hash.Type......: %s", hash_type);
1134
1135 /**
1136 * speed new
1137 */
1138
1139 u64 speed_cnt[DEVICES_MAX] = { 0 };
1140 double speed_ms[DEVICES_MAX] = { 0 };
1141
1142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1143 {
1144 hc_device_param_t *device_param = &data.devices_param[device_id];
1145
1146 if (device_param->skipped) continue;
1147
1148 speed_cnt[device_id] = 0;
1149 speed_ms[device_id] = 0;
1150
1151 for (int i = 0; i < SPEED_CACHE; i++)
1152 {
1153 speed_cnt[device_id] += device_param->speed_cnt[i];
1154 speed_ms[device_id] += device_param->speed_ms[i];
1155 }
1156
1157 speed_cnt[device_id] /= SPEED_CACHE;
1158 speed_ms[device_id] /= SPEED_CACHE;
1159 }
1160
1161 float hashes_all_ms = 0;
1162
1163 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1164
1165 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1166 {
1167 hc_device_param_t *device_param = &data.devices_param[device_id];
1168
1169 if (device_param->skipped) continue;
1170
1171 hashes_dev_ms[device_id] = 0;
1172
1173 if (speed_ms[device_id])
1174 {
1175 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1176
1177 hashes_all_ms += hashes_dev_ms[device_id];
1178 }
1179 }
1180
1181 /**
1182 * exec time
1183 */
1184
1185 double exec_all_ms[DEVICES_MAX] = { 0 };
1186
1187 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1188 {
1189 hc_device_param_t *device_param = &data.devices_param[device_id];
1190
1191 if (device_param->skipped) continue;
1192
1193 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1194
1195 exec_all_ms[device_id] = exec_ms_avg;
1196 }
1197
1198 /**
1199 * timers
1200 */
1201
1202 double ms_running = 0;
1203
1204 hc_timer_get (data.timer_running, ms_running);
1205
1206 double ms_paused = data.ms_paused;
1207
1208 if (data.devices_status == STATUS_PAUSED)
1209 {
1210 double ms_paused_tmp = 0;
1211
1212 hc_timer_get (data.timer_paused, ms_paused_tmp);
1213
1214 ms_paused += ms_paused_tmp;
1215 }
1216
1217 #ifdef WIN
1218
1219 __time64_t sec_run = ms_running / 1000;
1220
1221 #else
1222
1223 time_t sec_run = ms_running / 1000;
1224
1225 #endif
1226
1227 if (sec_run)
1228 {
1229 char display_run[32] = { 0 };
1230
1231 struct tm tm_run;
1232
1233 struct tm *tmp = NULL;
1234
1235 #ifdef WIN
1236
1237 tmp = _gmtime64 (&sec_run);
1238
1239 #else
1240
1241 tmp = gmtime (&sec_run);
1242
1243 #endif
1244
1245 if (tmp != NULL)
1246 {
1247 memset (&tm_run, 0, sizeof (tm_run));
1248
1249 memcpy (&tm_run, tmp, sizeof (tm_run));
1250
1251 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1252
1253 char *start = ctime (&data.proc_start);
1254
1255 size_t start_len = strlen (start);
1256
1257 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1258 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1259
1260 log_info ("Time.Started...: %s (%s)", start, display_run);
1261 }
1262 }
1263 else
1264 {
1265 log_info ("Time.Started...: 0 secs");
1266 }
1267
1268 /**
1269 * counters
1270 */
1271
1272 u64 progress_total = data.words_cnt * data.salts_cnt;
1273
1274 u64 all_done = 0;
1275 u64 all_rejected = 0;
1276 u64 all_restored = 0;
1277
1278 u64 progress_noneed = 0;
1279
1280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1281 {
1282 all_done += data.words_progress_done[salt_pos];
1283 all_rejected += data.words_progress_rejected[salt_pos];
1284 all_restored += data.words_progress_restored[salt_pos];
1285
1286 // Important for ETA only
1287
1288 if (data.salts_shown[salt_pos] == 1)
1289 {
1290 const u64 all = data.words_progress_done[salt_pos]
1291 + data.words_progress_rejected[salt_pos]
1292 + data.words_progress_restored[salt_pos];
1293
1294 const u64 left = data.words_cnt - all;
1295
1296 progress_noneed += left;
1297 }
1298 }
1299
1300 u64 progress_cur = all_restored + all_done + all_rejected;
1301 u64 progress_end = progress_total;
1302
1303 u64 progress_skip = 0;
1304
1305 if (data.skip)
1306 {
1307 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1308
1309 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1312 }
1313
1314 if (data.limit)
1315 {
1316 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1317
1318 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1319 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1320 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1321 }
1322
1323 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1324 u64 progress_end_relative_skip = progress_end - progress_skip;
1325
1326 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1327 {
1328 if (data.devices_status != STATUS_CRACKED)
1329 {
1330 #ifdef WIN
1331 __time64_t sec_etc = 0;
1332 #else
1333 time_t sec_etc = 0;
1334 #endif
1335
1336 if (hashes_all_ms)
1337 {
1338 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1339
1340 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1341
1342 sec_etc = ms_left / 1000;
1343 }
1344
1345 if (sec_etc == 0)
1346 {
1347 //log_info ("Time.Estimated.: 0 secs");
1348 }
1349 else if ((u64) sec_etc > ETC_MAX)
1350 {
1351 log_info ("Time.Estimated.: > 10 Years");
1352 }
1353 else
1354 {
1355 char display_etc[32] = { 0 };
1356
1357 struct tm tm_etc;
1358
1359 struct tm *tmp = NULL;
1360
1361 #ifdef WIN
1362
1363 tmp = _gmtime64 (&sec_etc);
1364
1365 #else
1366
1367 tmp = gmtime (&sec_etc);
1368
1369 #endif
1370
1371 if (tmp != NULL)
1372 {
1373 memset (&tm_etc, 0, sizeof (tm_etc));
1374
1375 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1376
1377 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1378
1379 time_t now;
1380
1381 time (&now);
1382
1383 now += sec_etc;
1384
1385 char *etc = ctime (&now);
1386
1387 size_t etc_len = strlen (etc);
1388
1389 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1390 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1391
1392 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1393 }
1394 }
1395 }
1396 }
1397
1398 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1399 {
1400 hc_device_param_t *device_param = &data.devices_param[device_id];
1401
1402 if (device_param->skipped) continue;
1403
1404 char display_dev_cur[16] = { 0 };
1405
1406 strncpy (display_dev_cur, "0.00", 4);
1407
1408 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1409
1410 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1411 }
1412
1413 char display_all_cur[16] = { 0 };
1414
1415 strncpy (display_all_cur, "0.00", 4);
1416
1417 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1418
1419 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1420
1421 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1422 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1423
1424 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1425
1426 // crack-per-time
1427
1428 if (data.digests_cnt > 100)
1429 {
1430 time_t now = time (NULL);
1431
1432 int cpt_cur_min = 0;
1433 int cpt_cur_hour = 0;
1434 int cpt_cur_day = 0;
1435
1436 for (int i = 0; i < CPT_BUF; i++)
1437 {
1438 const uint cracked = data.cpt_buf[i].cracked;
1439 const time_t timestamp = data.cpt_buf[i].timestamp;
1440
1441 if ((timestamp + 60) > now)
1442 {
1443 cpt_cur_min += cracked;
1444 }
1445
1446 if ((timestamp + 3600) > now)
1447 {
1448 cpt_cur_hour += cracked;
1449 }
1450
1451 if ((timestamp + 86400) > now)
1452 {
1453 cpt_cur_day += cracked;
1454 }
1455 }
1456
1457 double ms_real = ms_running - ms_paused;
1458
1459 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1460 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1461 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1462
1463 if ((data.cpt_start + 86400) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_cur_hour,
1468 cpt_cur_day,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else if ((data.cpt_start + 3600) < now)
1474 {
1475 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_cur_min,
1477 cpt_cur_hour,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else if ((data.cpt_start + 60) < now)
1483 {
1484 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_cur_min,
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 else
1491 {
1492 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1493 cpt_avg_min,
1494 cpt_avg_hour,
1495 cpt_avg_day);
1496 }
1497 }
1498
1499 // Restore point
1500
1501 u64 restore_point = get_lowest_words_done ();
1502
1503 u64 restore_total = data.words_base;
1504
1505 float percent_restore = 0;
1506
1507 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1508
1509 if (progress_end_relative_skip)
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1514 float percent_rejected = 0.0;
1515
1516 if (progress_cur)
1517 {
1518 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1519 }
1520
1521 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1522 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1523
1524 if (data.restore_disable == 0)
1525 {
1526 if (percent_finished != 1)
1527 {
1528 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1529 }
1530 }
1531 }
1532 }
1533 else
1534 {
1535 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1536 {
1537 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1538 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1539
1540 if (data.restore_disable == 0)
1541 {
1542 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1543 }
1544 }
1545 else
1546 {
1547 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1548 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1549
1550 // --restore not allowed if stdin is used -- really? why?
1551
1552 //if (data.restore_disable == 0)
1553 //{
1554 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1555 //}
1556 }
1557 }
1558
1559 #ifdef HAVE_HWMON
1560 if (data.gpu_temp_disable == 0)
1561 {
1562 hc_thread_mutex_lock (mux_adl);
1563
1564 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1565 {
1566 hc_device_param_t *device_param = &data.devices_param[device_id];
1567
1568 if (device_param->skipped) continue;
1569
1570 #define HM_STR_BUF_SIZE 255
1571
1572 if (data.hm_device[device_id].fan_supported == 1)
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1577
1578 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1579 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1580
1581 if (device_param->vendor_id == VENDOR_ID_AMD)
1582 {
1583 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1584 }
1585 else if (device_param->vendor_id == VENDOR_ID_NV)
1586 {
1587 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1588 }
1589
1590 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1591 }
1592 else
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596
1597 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1598 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1599
1600 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1601 }
1602 }
1603
1604 hc_thread_mutex_unlock (mux_adl);
1605 }
1606 #endif // HAVE_HWMON
1607 }
1608
1609 static void status_benchmark ()
1610 {
1611 if (data.devices_status == STATUS_INIT) return;
1612 if (data.devices_status == STATUS_STARTING) return;
1613
1614 if (data.words_cnt == 0) return;
1615
1616 u64 speed_cnt[DEVICES_MAX] = { 0 };
1617 double speed_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 speed_cnt[device_id] = device_param->speed_cnt[0];
1626 speed_ms[device_id] = device_param->speed_ms[0];
1627 }
1628
1629 float hashes_all_ms = 0;
1630
1631 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 hashes_dev_ms[device_id] = 0;
1640
1641 if (speed_ms[device_id])
1642 {
1643 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1644
1645 hashes_all_ms += hashes_dev_ms[device_id];
1646 }
1647 }
1648
1649 /**
1650 * exec time
1651 */
1652
1653 double exec_all_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1662
1663 exec_all_ms[device_id] = exec_ms_avg;
1664 }
1665
1666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1667 {
1668 hc_device_param_t *device_param = &data.devices_param[device_id];
1669
1670 if (device_param->skipped) continue;
1671
1672 char display_dev_cur[16] = { 0 };
1673
1674 strncpy (display_dev_cur, "0.00", 4);
1675
1676 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1677
1678 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1679 }
1680
1681 char display_all_cur[16] = { 0 };
1682
1683 strncpy (display_all_cur, "0.00", 4);
1684
1685 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1686
1687 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1688 }
1689
1690 /**
1691 * oclHashcat -only- functions
1692 */
1693
1694 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1695 {
1696 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1697 {
1698 if (attack_kern == ATTACK_KERN_STRAIGHT)
1699 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1700 else if (attack_kern == ATTACK_KERN_COMBI)
1701 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1702 else if (attack_kern == ATTACK_KERN_BF)
1703 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1704 }
1705 else
1706 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1707 }
1708
1709 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1710 {
1711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1712 {
1713 if (attack_kern == ATTACK_KERN_STRAIGHT)
1714 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1715 else if (attack_kern == ATTACK_KERN_COMBI)
1716 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1717 else if (attack_kern == ATTACK_KERN_BF)
1718 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1719 }
1720 else
1721 {
1722 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 }
1724 }
1725
1726 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1727 {
1728 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1729 {
1730 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1731 }
1732 else
1733 {
1734 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1735 }
1736 }
1737
1738 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1739 {
1740 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1741 {
1742 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1743 }
1744 else
1745 {
1746 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1747 }
1748 }
1749
1750 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1751 {
1752 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1753 }
1754
1755 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1756 {
1757 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1758 }
1759
1760 static uint convert_from_hex (char *line_buf, const uint line_len)
1761 {
1762 if (line_len & 1) return (line_len); // not in hex
1763
1764 if (data.hex_wordlist == 1)
1765 {
1766 uint i;
1767 uint j;
1768
1769 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1770 {
1771 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1772 }
1773
1774 memset (line_buf + i, 0, line_len - i);
1775
1776 return (i);
1777 }
1778 else if (line_len >= 6) // $HEX[] = 6
1779 {
1780 if (line_buf[0] != '$') return (line_len);
1781 if (line_buf[1] != 'H') return (line_len);
1782 if (line_buf[2] != 'E') return (line_len);
1783 if (line_buf[3] != 'X') return (line_len);
1784 if (line_buf[4] != '[') return (line_len);
1785 if (line_buf[line_len - 1] != ']') return (line_len);
1786
1787 uint i;
1788 uint j;
1789
1790 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1791 {
1792 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1793 }
1794
1795 memset (line_buf + i, 0, line_len - i);
1796
1797 return (i);
1798 }
1799
1800 return (line_len);
1801 }
1802
1803 static void clear_prompt ()
1804 {
1805 fputc ('\r', stdout);
1806
1807 for (size_t i = 0; i < strlen (PROMPT); i++)
1808 {
1809 fputc (' ', stdout);
1810 }
1811
1812 fputc ('\r', stdout);
1813
1814 fflush (stdout);
1815 }
1816
1817 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1818 {
1819 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1820 }
1821
1822 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1823 {
1824 char *outfile = data.outfile;
1825 uint quiet = data.quiet;
1826 FILE *pot_fp = data.pot_fp;
1827 uint loopback = data.loopback;
1828 uint debug_mode = data.debug_mode;
1829 char *debug_file = data.debug_file;
1830
1831 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1832 int debug_rule_len = 0; // -1 error
1833 uint debug_plain_len = 0;
1834
1835 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1836
1837 // hash
1838
1839 char out_buf[HCBUFSIZ] = { 0 };
1840
1841 ascii_digest (out_buf, salt_pos, digest_pos);
1842
1843 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1844
1845 // plain
1846
1847 plain_t plain;
1848
1849 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1850
1851 uint gidvid = plain.gidvid;
1852 uint il_pos = plain.il_pos;
1853
1854 u64 crackpos = device_param->words_off;
1855
1856 uint plain_buf[16] = { 0 };
1857
1858 u8 *plain_ptr = (u8 *) plain_buf;
1859 unsigned int plain_len = 0;
1860
1861 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1862 {
1863 u64 gidd = gidvid;
1864 u64 gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.i[j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 const uint off = device_param->innerloop_pos + il_pos;
1878
1879 if (debug_mode > 0)
1880 {
1881 debug_rule_len = 0;
1882
1883 // save rule
1884 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1885 {
1886 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1887
1888 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1889 }
1890
1891 // save plain
1892 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1895
1896 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1897
1898 debug_plain_len = plain_len;
1899 }
1900 }
1901
1902 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1903
1904 crackpos += gidvid;
1905 crackpos *= data.kernel_rules_cnt;
1906 crackpos += device_param->innerloop_pos + il_pos;
1907
1908 if (plain_len > data.pw_max) plain_len = data.pw_max;
1909 }
1910 else if (data.attack_mode == ATTACK_MODE_COMBI)
1911 {
1912 u64 gidd = gidvid;
1913 u64 gidm = 0;
1914
1915 pw_t pw;
1916
1917 gidd_to_pw_t (device_param, gidd, &pw);
1918
1919 for (int i = 0, j = gidm; i < 16; i++, j++)
1920 {
1921 plain_buf[i] = pw.i[j];
1922 }
1923
1924 plain_len = pw.pw_len;
1925
1926 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1927 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1928
1929 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1930 {
1931 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1932 }
1933 else
1934 {
1935 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1936
1937 memcpy (plain_ptr, comb_buf, comb_len);
1938 }
1939
1940 plain_len += comb_len;
1941
1942 crackpos += gidvid;
1943 crackpos *= data.combs_cnt;
1944 crackpos += device_param->innerloop_pos + il_pos;
1945
1946 if (data.pw_max != PW_DICTMAX1)
1947 {
1948 if (plain_len > data.pw_max) plain_len = data.pw_max;
1949 }
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_BF)
1952 {
1953 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1954 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1955
1956 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1957 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1958
1959 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1960 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1961
1962 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1963 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1964
1965 plain_len = data.css_cnt;
1966
1967 crackpos += gidvid;
1968 crackpos *= data.bfs_cnt;
1969 crackpos += device_param->innerloop_pos + il_pos;
1970 }
1971 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1972 {
1973 u64 gidd = gidvid;
1974 u64 gidm = 0;
1975
1976 pw_t pw;
1977
1978 gidd_to_pw_t (device_param, gidd, &pw);
1979
1980 for (int i = 0, j = gidm; i < 16; i++, j++)
1981 {
1982 plain_buf[i] = pw.i[j];
1983 }
1984
1985 plain_len = pw.pw_len;
1986
1987 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1988
1989 uint start = 0;
1990 uint stop = device_param->kernel_params_mp_buf32[4];
1991
1992 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1993
1994 plain_len += start + stop;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2006 {
2007 u64 gidd = gidvid;
2008 u64 gidm = 0;
2009
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidd, &pw);
2013
2014 for (int i = 0, j = gidm; i < 16; i++, j++)
2015 {
2016 plain_buf[i] = pw.i[j];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2022
2023 uint start = 0;
2024 uint stop = device_param->kernel_params_mp_buf32[4];
2025
2026 memmove (plain_ptr + stop, plain_ptr, plain_len);
2027
2028 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2029
2030 plain_len += start + stop;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.combs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035
2036 if (data.pw_max != PW_DICTMAX1)
2037 {
2038 if (plain_len > data.pw_max) plain_len = data.pw_max;
2039 }
2040 }
2041
2042 if (data.attack_mode == ATTACK_MODE_BF)
2043 {
2044 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2045 {
2046 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2047 {
2048 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2049 {
2050 plain_len = plain_len - data.salts_buf[0].salt_len;
2051 }
2052 }
2053
2054 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2055 {
2056 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2057 {
2058 plain_ptr[j] = plain_ptr[i];
2059 }
2060
2061 plain_len = plain_len / 2;
2062 }
2063 }
2064 }
2065
2066 // if enabled, update also the potfile
2067
2068 if (pot_fp)
2069 {
2070 lock_file (pot_fp);
2071
2072 fprintf (pot_fp, "%s:", out_buf);
2073
2074 format_plain (pot_fp, plain_ptr, plain_len, 1);
2075
2076 fputc ('\n', pot_fp);
2077
2078 fflush (pot_fp);
2079
2080 unlock_file (pot_fp);
2081 }
2082
2083 // outfile
2084
2085 FILE *out_fp = NULL;
2086
2087 if (outfile != NULL)
2088 {
2089 if ((out_fp = fopen (outfile, "ab")) == NULL)
2090 {
2091 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2092
2093 out_fp = stdout;
2094 }
2095 lock_file (out_fp);
2096 }
2097 else
2098 {
2099 out_fp = stdout;
2100
2101 if (quiet == 0) clear_prompt ();
2102 }
2103
2104 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2105
2106 if (outfile != NULL)
2107 {
2108 if (out_fp != stdout)
2109 {
2110 fclose (out_fp);
2111 }
2112 }
2113 else
2114 {
2115 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2116 {
2117 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2118 {
2119 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2120 if (quiet == 0) fflush (stdout);
2121 }
2122 }
2123 }
2124
2125 // loopback
2126
2127 if (loopback)
2128 {
2129 char *loopback_file = data.loopback_file;
2130
2131 FILE *fb_fp = NULL;
2132
2133 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2134 {
2135 lock_file (fb_fp);
2136
2137 format_plain (fb_fp, plain_ptr, plain_len, 1);
2138
2139 fputc ('\n', fb_fp);
2140
2141 fclose (fb_fp);
2142 }
2143 }
2144
2145 // (rule) debug mode
2146
2147 // the next check implies that:
2148 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2149 // - debug_mode > 0
2150
2151 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2152 {
2153 if (debug_rule_len < 0) debug_rule_len = 0;
2154
2155 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2156
2157 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2158
2159 if ((quiet == 0) && (debug_file == NULL))
2160 {
2161 fprintf (stdout, "%s", PROMPT);
2162 fflush (stdout);
2163 }
2164 }
2165 }
2166
2167 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2168 {
2169 salt_t *salt_buf = &data.salts_buf[salt_pos];
2170
2171 int found = 0;
2172
2173 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2174
2175 for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1;
2176
2177 if (found == 1)
2178 {
2179 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2180
2181 log_info_nn ("");
2182
2183 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2184
2185 uint cpt_cracked = 0;
2186
2187 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2188 {
2189 uint idx = salt_buf->digests_offset + digest_pos;
2190
2191 if (data.digests_shown_tmp[idx] == 0) continue;
2192
2193 if (data.digests_shown[idx] == 1) continue;
2194
2195 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2196 {
2197 data.digests_shown[idx] = 1;
2198
2199 data.digests_done++;
2200
2201 cpt_cracked++;
2202
2203 salt_buf->digests_done++;
2204
2205 if (salt_buf->digests_done == salt_buf->digests_cnt)
2206 {
2207 data.salts_shown[salt_pos] = 1;
2208
2209 data.salts_done++;
2210 }
2211 }
2212
2213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2214
2215 check_hash (device_param, salt_pos, digest_pos);
2216 }
2217
2218 if (cpt_cracked > 0)
2219 {
2220 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2221 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2222
2223 data.cpt_pos++;
2224
2225 data.cpt_total += cpt_cracked;
2226
2227 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2228 }
2229
2230 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2231 {
2232 // we need to reset cracked state on the device
2233 // otherwise host thinks again and again the hash was cracked
2234 // and returns invalid password each time
2235
2236 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2237
2238 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2239 }
2240
2241 memset (device_param->result, 0, device_param->size_results);
2242
2243 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2244 }
2245 }
2246
2247 static void save_hash ()
2248 {
2249 char *hashfile = data.hashfile;
2250
2251 char new_hashfile[256] = { 0 };
2252 char old_hashfile[256] = { 0 };
2253
2254 snprintf (new_hashfile, 255, "%s.new", hashfile);
2255 snprintf (old_hashfile, 255, "%s.old", hashfile);
2256
2257 unlink (new_hashfile);
2258
2259 char separator = data.separator;
2260
2261 FILE *fp = fopen (new_hashfile, "wb");
2262
2263 if (fp == NULL)
2264 {
2265 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2266
2267 exit (-1);
2268 }
2269
2270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2271 {
2272 if (data.salts_shown[salt_pos] == 1) continue;
2273
2274 salt_t *salt_buf = &data.salts_buf[salt_pos];
2275
2276 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2277 {
2278 uint idx = salt_buf->digests_offset + digest_pos;
2279
2280 if (data.digests_shown[idx] == 1) continue;
2281
2282 if (data.hash_mode != 2500)
2283 {
2284 char out_buf[HCBUFSIZ] = { 0 };
2285
2286 if (data.username == 1)
2287 {
2288 user_t *user = data.hash_info[idx]->user;
2289
2290 uint i;
2291
2292 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2293
2294 fputc (separator, fp);
2295 }
2296
2297 ascii_digest (out_buf, salt_pos, digest_pos);
2298
2299 fputs (out_buf, fp);
2300
2301 log_out (fp, "");
2302 }
2303 else
2304 {
2305 hccap_t hccap;
2306
2307 to_hccap_t (&hccap, salt_pos, digest_pos);
2308
2309 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2310 }
2311 }
2312 }
2313
2314 fflush (fp);
2315
2316 fclose (fp);
2317
2318 unlink (old_hashfile);
2319
2320 if (rename (hashfile, old_hashfile) != 0)
2321 {
2322 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2323
2324 exit (-1);
2325 }
2326
2327 unlink (hashfile);
2328
2329 if (rename (new_hashfile, hashfile) != 0)
2330 {
2331 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 unlink (old_hashfile);
2337 }
2338
2339 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2340 {
2341 // function called only in case kernel_power_all > words_left
2342
2343 float kernel_power_div = (float) (total_left) / kernel_power_all;
2344
2345 kernel_power_div += kernel_power_div / 100;
2346
2347 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2348
2349 while (kernel_power_new < total_left)
2350 {
2351 kernel_power_div += kernel_power_div / 100;
2352
2353 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2354 }
2355
2356 if (data.quiet == 0)
2357 {
2358 clear_prompt ();
2359
2360 log_info ("");
2361
2362 log_info ("INFO: approaching final keyspace, workload adjusted");
2363
2364 log_info ("");
2365
2366 fprintf (stdout, "%s", PROMPT);
2367
2368 fflush (stdout);
2369 }
2370
2371 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2372
2373 return kernel_power_div;
2374 }
2375
2376 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2377 {
2378 uint num_elements = num;
2379
2380 device_param->kernel_params_buf32[30] = data.combs_mode;
2381 device_param->kernel_params_buf32[31] = num;
2382
2383 uint kernel_threads = device_param->kernel_threads;
2384
2385 while (num_elements % kernel_threads) num_elements++;
2386
2387 cl_kernel kernel = NULL;
2388
2389 switch (kern_run)
2390 {
2391 case KERN_RUN_1: kernel = device_param->kernel1; break;
2392 case KERN_RUN_12: kernel = device_param->kernel12; break;
2393 case KERN_RUN_2: kernel = device_param->kernel2; break;
2394 case KERN_RUN_23: kernel = device_param->kernel23; break;
2395 case KERN_RUN_3: kernel = device_param->kernel3; break;
2396 }
2397
2398 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2399 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2400 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2401 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2402 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2403 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2404 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2405 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2406 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2407 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2408 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2409
2410 hc_timer_t timer;
2411
2412 hc_timer_set (&timer);
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2420 }
2421 else
2422 {
2423 size_t workgroup_size = 0;
2424
2425 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2426
2427 if (kern_run == KERN_RUN_2)
2428 {
2429 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2430 {
2431 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2432 }
2433 }
2434
2435 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 const size_t global_work_size[3] = { num_elements, 1, 1 };
2440 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2443 }
2444
2445 hc_clFlush (data.ocl, device_param->command_queue);
2446
2447 hc_clFinish (data.ocl, device_param->command_queue);
2448
2449 if (event_update)
2450 {
2451 double exec_time;
2452
2453 hc_timer_get (timer, exec_time);
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468 }
2469
2470 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2471 {
2472 uint num_elements = num;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2477 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2478 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2479 }
2480
2481 // causes problems with special threads like in bcrypt
2482 // const uint kernel_threads = device_param->kernel_threads;
2483
2484 uint kernel_threads = device_param->kernel_threads;
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 cl_kernel kernel = NULL;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2493 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2494 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2495 }
2496
2497 switch (kern_run)
2498 {
2499 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2500 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2501 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2502 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2503 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2504 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2505 break;
2506 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2507 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2508 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2509 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2510 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2511 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2512 break;
2513 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2514 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2515 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2516 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2517 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2518 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2519 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2520 break;
2521 }
2522
2523 size_t workgroup_size = 0;
2524
2525 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2526
2527 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2528
2529 const size_t global_work_size[3] = { num_elements, 1, 1 };
2530 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2531
2532 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2533
2534 hc_clFlush (data.ocl, device_param->command_queue);
2535
2536 hc_clFinish (data.ocl, device_param->command_queue);
2537 }
2538
2539 static void run_kernel_tm (hc_device_param_t *device_param)
2540 {
2541 const uint num_elements = 1024; // fixed
2542
2543 uint kernel_threads = 32;
2544
2545 cl_kernel kernel = device_param->kernel_tm;
2546
2547 size_t workgroup_size = 0;
2548
2549 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2550
2551 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2564 {
2565 uint num_elements = num;
2566
2567 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2568 device_param->kernel_params_amp_buf32[6] = num_elements;
2569
2570 // causes problems with special threads like in bcrypt
2571 // const uint kernel_threads = device_param->kernel_threads;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_amp;
2578
2579 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2580 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2581
2582 size_t workgroup_size = 0;
2583
2584 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2585
2586 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2599 {
2600 int rc = -1;
2601
2602 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2603 {
2604 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2605
2606 const cl_uchar zero = 0;
2607
2608 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2609 }
2610
2611 if (rc != 0)
2612 {
2613 // NOTE: clEnqueueFillBuffer () always fails with -59
2614 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2615 // How's that possible, OpenCL 1.2 support is advertised??
2616 // We need to workaround...
2617
2618 #define FILLSZ 0x100000
2619
2620 char *tmp = (char *) mymalloc (FILLSZ);
2621
2622 for (size_t i = 0; i < size; i += FILLSZ)
2623 {
2624 const size_t left = size - i;
2625
2626 const size_t fillsz = MIN (FILLSZ, left);
2627
2628 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2629 }
2630
2631 myfree (tmp);
2632 }
2633 }
2634
2635 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2636 {
2637 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2638 {
2639 if (attack_mode == ATTACK_MODE_BF)
2640 {
2641 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2642 {
2643 const uint size_tm = 32 * sizeof (bs_word_t);
2644
2645 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2646
2647 run_kernel_tm (device_param);
2648
2649 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2650 }
2651 }
2652
2653 if (highest_pw_len < 16)
2654 {
2655 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2656 }
2657 else if (highest_pw_len < 32)
2658 {
2659 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2660 }
2661 else
2662 {
2663 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2664 }
2665 }
2666 else
2667 {
2668 run_kernel_amp (device_param, pws_cnt);
2669
2670 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2671
2672 if (opts_type & OPTS_TYPE_HOOK12)
2673 {
2674 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2675 }
2676
2677 uint iter = salt_buf->salt_iter;
2678
2679 uint loop_step = device_param->kernel_loops;
2680
2681 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2682 {
2683 uint loop_left = iter - loop_pos;
2684
2685 loop_left = MIN (loop_left, loop_step);
2686
2687 device_param->kernel_params_buf32[25] = loop_pos;
2688 device_param->kernel_params_buf32[26] = loop_left;
2689
2690 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2691
2692 if (data.devices_status == STATUS_CRACKED) break;
2693 if (data.devices_status == STATUS_ABORTED) break;
2694 if (data.devices_status == STATUS_QUIT) break;
2695
2696 /**
2697 * speed
2698 */
2699
2700 const float iter_part = (float) (loop_pos + loop_left) / iter;
2701
2702 const u64 perf_sum_all = pws_cnt * iter_part;
2703
2704 double speed_ms;
2705
2706 hc_timer_get (device_param->timer_speed, speed_ms);
2707
2708 const u32 speed_pos = device_param->speed_pos;
2709
2710 device_param->speed_cnt[speed_pos] = perf_sum_all;
2711
2712 device_param->speed_ms[speed_pos] = speed_ms;
2713
2714 if (data.benchmark == 1)
2715 {
2716 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2717 }
2718 }
2719
2720 if (opts_type & OPTS_TYPE_HOOK23)
2721 {
2722 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2723
2724 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2725
2726 // do something with data
2727
2728 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2729 }
2730
2731 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2732 }
2733 }
2734
2735 static int run_rule_engine (const int rule_len, const char *rule_buf)
2736 {
2737 if (rule_len == 0)
2738 {
2739 return 0;
2740 }
2741 else if (rule_len == 1)
2742 {
2743 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2744 }
2745
2746 return 1;
2747 }
2748
2749 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2750 {
2751 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2752 {
2753 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2754 }
2755 else if (data.attack_kern == ATTACK_KERN_COMBI)
2756 {
2757 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2758 {
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x01;
2768 }
2769 }
2770 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2771 {
2772 for (u32 i = 0; i < pws_cnt; i++)
2773 {
2774 const u32 pw_len = device_param->pws_buf[i].pw_len;
2775
2776 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2777
2778 ptr[pw_len] = 0x80;
2779 }
2780 }
2781 }
2782
2783 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2784 }
2785 else if (data.attack_kern == ATTACK_KERN_BF)
2786 {
2787 const u64 off = device_param->words_off;
2788
2789 device_param->kernel_params_mp_l_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2792 }
2793 }
2794
2795 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2796 {
2797 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2798
2799 device_param->kernel_params_buf32[25] = 0;
2800 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2801 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2802
2803 // init some fake words
2804
2805 if (data.hash_mode == 10700)
2806 {
2807 // hash mode 10700 hangs on length 0 (unlimited loop)
2808
2809 for (u32 i = 0; i < kernel_power; i++)
2810 {
2811 device_param->pws_buf[i].i[0] = i;
2812 device_param->pws_buf[i].i[1] = i + 0x01234567;
2813 device_param->pws_buf[i].i[2] = i + 0x89abcdef;
2814 device_param->pws_buf[i].i[3] = 0xffffffff;
2815 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2816 }
2817
2818 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);
2819
2820 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2821 {
2822 run_kernel_amp (device_param, kernel_power);
2823 }
2824 }
2825
2826 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2827 {
2828 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2829 }
2830 else
2831 {
2832 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2833 }
2834
2835 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2836
2837 // reset fake words
2838
2839 if (data.hash_mode == 10700)
2840 {
2841 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2842
2843 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2844 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2845 }
2846
2847 return exec_ms_prev;
2848 }
2849
2850 static void autotune (hc_device_param_t *device_param)
2851 {
2852 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2853
2854 const u32 kernel_accel_min = device_param->kernel_accel_min;
2855 const u32 kernel_accel_max = device_param->kernel_accel_max;
2856
2857 const u32 kernel_loops_min = device_param->kernel_loops_min;
2858 const u32 kernel_loops_max = device_param->kernel_loops_max;
2859
2860 u32 kernel_accel = kernel_accel_min;
2861 u32 kernel_loops = kernel_loops_min;
2862
2863 #define STEPS_CNT 10
2864
2865 #define MAX_RETRIES 1
2866
2867 if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max))
2868 {
2869 // we do this in case the user specified a fixed -u and -n on the commandline
2870 // so we have a cached kernel for benchmark
2871
2872 try_run (device_param, kernel_accel, kernel_loops);
2873 try_run (device_param, kernel_accel, kernel_loops);
2874 try_run (device_param, kernel_accel, kernel_loops);
2875 try_run (device_param, kernel_accel, kernel_loops);
2876 try_run (device_param, kernel_accel, kernel_loops);
2877 }
2878
2879 double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops);
2880
2881 // first find out highest kernel-loops that stays below target_ms
2882
2883 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2884 {
2885 double exec_ms_best = try_run (device_param, kernel_accel_min, kernel_loops);
2886
2887 for (int i = 0; i < MAX_RETRIES; i++)
2888 {
2889 const double exec_ms_cur = try_run (device_param, kernel_accel_min, kernel_loops);
2890
2891 exec_ms_best = MIN (exec_ms_best, exec_ms_cur);
2892 }
2893
2894 if (exec_ms_best < target_ms) break;
2895 }
2896
2897 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2898
2899 if (kernel_accel_min < kernel_accel_max)
2900 {
2901 for (int i = 0; i < STEPS_CNT; i++)
2902 {
2903 const u32 kernel_accel_try = 1 << i;
2904
2905 if (kernel_accel_try < kernel_accel_min) continue;
2906 if (kernel_accel_try > kernel_accel_max) break;
2907
2908 double exec_ms_best = try_run (device_param, kernel_accel_try, kernel_loops);
2909
2910 for (int i = 0; i < MAX_RETRIES; i++)
2911 {
2912 const double exec_ms_cur = try_run (device_param, kernel_accel_try, kernel_loops);
2913
2914 exec_ms_best = MIN (exec_ms_best, exec_ms_cur);
2915 }
2916
2917 if (exec_ms_best > target_ms) break;
2918
2919 exec_ms_final = exec_ms_best;
2920
2921 kernel_accel = kernel_accel_try;
2922 }
2923 }
2924
2925 // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel
2926 // in such a case the above function would not create any change
2927 // we'll use the runtime to find out if we're allow to do last improvement
2928
2929 if (exec_ms_final > 0)
2930 {
2931 if ((exec_ms_final * 2) <= target_ms)
2932 {
2933 const double exec_left = target_ms / exec_ms_final;
2934
2935 const double accel_left = kernel_accel_max / kernel_accel;
2936
2937 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2938
2939 if (exec_accel_min >= 2)
2940 {
2941 kernel_accel *= exec_accel_min;
2942 }
2943 }
2944 }
2945
2946 // sometimes we're in a bad situation that the algorithm is so slow that we can not
2947 // create enough kernel_accel to do both, keep the gpu busy and stay below target_ms.
2948 // however, we need to have a minimum kernel_accel and kernel_loops of 32.
2949 // luckily, at this level of workload, it became a linear function
2950
2951 if (kernel_accel < 32 || kernel_loops < 32)
2952 {
2953 const u32 kernel_power = kernel_accel * kernel_loops;
2954
2955 // find sqrt
2956
2957 u32 sqrtv;
2958
2959 for (sqrtv = 1; sqrtv < 0x100000; sqrtv++)
2960 {
2961 if ((sqrtv * sqrtv) >= kernel_power) break;
2962 }
2963
2964 const u32 kernel_accel_try = sqrtv;
2965 const u32 kernel_loops_try = sqrtv;
2966
2967 if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min))
2968 {
2969 kernel_accel = kernel_accel_try;
2970 kernel_loops = kernel_loops_try;
2971 }
2972 }
2973
2974 // reset timer
2975
2976 device_param->exec_pos = 0;
2977
2978 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2979
2980 // store
2981
2982 device_param->kernel_accel = kernel_accel;
2983 device_param->kernel_loops = kernel_loops;
2984
2985 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2986
2987 device_param->kernel_power = kernel_power;
2988
2989 #ifdef DEBUG
2990
2991 if (data.quiet == 0)
2992 {
2993 clear_prompt ();
2994
2995 log_info ("Device #%u: autotuned kernel-accel to %u\n"
2996 "Device #%u: autotuned kernel-loops to %u\n",
2997 device_param->device_id + 1, kernel_accel,
2998 device_param->device_id + 1, kernel_loops);
2999
3000 fprintf (stdout, "%s", PROMPT);
3001
3002 fflush (stdout);
3003 }
3004
3005 #endif
3006 }
3007
3008 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3009 {
3010 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3011
3012 // init speed timer
3013
3014 uint speed_pos = device_param->speed_pos;
3015
3016 #ifdef _POSIX
3017 if (device_param->timer_speed.tv_sec == 0)
3018 {
3019 hc_timer_set (&device_param->timer_speed);
3020 }
3021 #endif
3022
3023 #ifdef _WIN
3024 if (device_param->timer_speed.QuadPart == 0)
3025 {
3026 hc_timer_set (&device_param->timer_speed);
3027 }
3028 #endif
3029
3030 // find higest password length, this is for optimization stuff
3031
3032 uint highest_pw_len = 0;
3033
3034 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3035 {
3036 }
3037 else if (data.attack_kern == ATTACK_KERN_COMBI)
3038 {
3039 }
3040 else if (data.attack_kern == ATTACK_KERN_BF)
3041 {
3042 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3043 + device_param->kernel_params_mp_l_buf32[5];
3044 }
3045
3046 // iteration type
3047
3048 uint innerloop_step = 0;
3049 uint innerloop_cnt = 0;
3050
3051 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3052 else innerloop_step = 1;
3053
3054 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3055 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3056 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3057
3058 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3059
3060 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3061 {
3062 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3063
3064 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3065
3066 if (data.devices_status == STATUS_CRACKED) break;
3067 if (data.devices_status == STATUS_ABORTED) break;
3068 if (data.devices_status == STATUS_QUIT) break;
3069 if (data.devices_status == STATUS_BYPASS) break;
3070
3071 salt_t *salt_buf = &data.salts_buf[salt_pos];
3072
3073 device_param->kernel_params_buf32[24] = salt_pos;
3074 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3075 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3076
3077 FILE *combs_fp = device_param->combs_fp;
3078
3079 if (data.attack_mode == ATTACK_MODE_COMBI)
3080 {
3081 rewind (combs_fp);
3082 }
3083
3084 // innerloops
3085
3086 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3087 {
3088 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3089
3090 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3091
3092 if (data.devices_status == STATUS_CRACKED) break;
3093 if (data.devices_status == STATUS_ABORTED) break;
3094 if (data.devices_status == STATUS_QUIT) break;
3095 if (data.devices_status == STATUS_BYPASS) break;
3096
3097 uint innerloop_left = innerloop_cnt - innerloop_pos;
3098
3099 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3100
3101 device_param->innerloop_pos = innerloop_pos;
3102 device_param->innerloop_left = innerloop_left;
3103
3104 device_param->kernel_params_buf32[27] = innerloop_left;
3105
3106 // i think we can get rid of this
3107 if (innerloop_left == 0)
3108 {
3109 puts ("bug, how should this happen????\n");
3110
3111 continue;
3112 }
3113
3114 if (data.salts_shown[salt_pos] == 1)
3115 {
3116 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3117
3118 continue;
3119 }
3120
3121 // initialize amplifiers
3122
3123 if (data.attack_mode == ATTACK_MODE_COMBI)
3124 {
3125 uint i = 0;
3126
3127 while (i < innerloop_left)
3128 {
3129 if (feof (combs_fp)) break;
3130
3131 int line_len = fgetl (combs_fp, line_buf);
3132
3133 if (line_len >= PW_MAX1) continue;
3134
3135 line_len = convert_from_hex (line_buf, line_len);
3136
3137 char *line_buf_new = line_buf;
3138
3139 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3140 {
3141 char rule_buf_out[BLOCK_SIZE] = { 0 };
3142
3143 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3144
3145 if (rule_len_out < 0)
3146 {
3147 data.words_progress_rejected[salt_pos] += pws_cnt;
3148
3149 continue;
3150 }
3151
3152 line_len = rule_len_out;
3153
3154 line_buf_new = rule_buf_out;
3155 }
3156
3157 line_len = MIN (line_len, PW_DICTMAX);
3158
3159 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3160
3161 memcpy (ptr, line_buf_new, line_len);
3162
3163 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3164
3165 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3166 {
3167 uppercase (ptr, line_len);
3168 }
3169
3170 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3171 {
3172 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3173 {
3174 ptr[line_len] = 0x80;
3175 }
3176
3177 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3178 {
3179 ptr[line_len] = 0x01;
3180 }
3181 }
3182
3183 device_param->combs_buf[i].pw_len = line_len;
3184
3185 i++;
3186 }
3187
3188 for (uint j = i; j < innerloop_left; j++)
3189 {
3190 device_param->combs_buf[j].i[0] = 0;
3191 device_param->combs_buf[j].i[1] = 0;
3192 device_param->combs_buf[j].i[2] = 0;
3193 device_param->combs_buf[j].i[3] = 0;
3194 device_param->combs_buf[j].i[4] = 0;
3195 device_param->combs_buf[j].i[5] = 0;
3196 device_param->combs_buf[j].i[6] = 0;
3197 device_param->combs_buf[j].i[7] = 0;
3198
3199 device_param->combs_buf[j].pw_len = 0;
3200 }
3201
3202 innerloop_left = i;
3203 }
3204 else if (data.attack_mode == ATTACK_MODE_BF)
3205 {
3206 u64 off = innerloop_pos;
3207
3208 device_param->kernel_params_mp_r_buf64[3] = off;
3209
3210 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3211 }
3212 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3213 {
3214 u64 off = innerloop_pos;
3215
3216 device_param->kernel_params_mp_buf64[3] = off;
3217
3218 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3219 }
3220 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3221 {
3222 u64 off = innerloop_pos;
3223
3224 device_param->kernel_params_mp_buf64[3] = off;
3225
3226 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3227 }
3228
3229 // copy amplifiers
3230
3231 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3232 {
3233 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);
3234 }
3235 else if (data.attack_mode == ATTACK_MODE_COMBI)
3236 {
3237 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);
3238 }
3239 else if (data.attack_mode == ATTACK_MODE_BF)
3240 {
3241 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);
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3244 {
3245 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);
3246 }
3247 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3248 {
3249 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);
3250 }
3251
3252 if (data.benchmark == 1)
3253 {
3254 hc_timer_set (&device_param->timer_speed);
3255 }
3256
3257 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3258
3259 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3260
3261 if (data.devices_status == STATUS_CRACKED) break;
3262 if (data.devices_status == STATUS_ABORTED) break;
3263 if (data.devices_status == STATUS_QUIT) break;
3264
3265 /**
3266 * result
3267 */
3268
3269 hc_thread_mutex_lock (mux_display);
3270
3271 check_cracked (device_param, salt_pos);
3272
3273 hc_thread_mutex_unlock (mux_display);
3274
3275 /**
3276 * progress
3277 */
3278
3279 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3280
3281 hc_thread_mutex_lock (mux_counter);
3282
3283 data.words_progress_done[salt_pos] += perf_sum_all;
3284
3285 hc_thread_mutex_unlock (mux_counter);
3286
3287 /**
3288 * speed
3289 */
3290
3291 double speed_ms;
3292
3293 hc_timer_get (device_param->timer_speed, speed_ms);
3294
3295 hc_timer_set (&device_param->timer_speed);
3296
3297 hc_thread_mutex_lock (mux_display);
3298
3299 // current speed
3300
3301 device_param->speed_cnt[speed_pos] = perf_sum_all;
3302
3303 device_param->speed_ms[speed_pos] = speed_ms;
3304
3305 hc_thread_mutex_unlock (mux_display);
3306
3307 speed_pos++;
3308
3309 if (speed_pos == SPEED_CACHE)
3310 {
3311 speed_pos = 0;
3312 }
3313
3314 /**
3315 * benchmark
3316 */
3317
3318 if (data.benchmark == 1) break;
3319 }
3320 }
3321
3322 device_param->speed_pos = speed_pos;
3323
3324 myfree (line_buf);
3325 }
3326
3327 static void load_segment (wl_data_t *wl_data, FILE *fd)
3328 {
3329 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3330
3331 wl_data->pos = 0;
3332
3333 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3334
3335 wl_data->buf[wl_data->cnt] = 0;
3336
3337 if (wl_data->cnt == 0) return;
3338
3339 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3340
3341 while (!feof (fd))
3342 {
3343 if (wl_data->cnt == wl_data->avail)
3344 {
3345 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3346
3347 wl_data->avail += wl_data->incr;
3348 }
3349
3350 const int c = fgetc (fd);
3351
3352 if (c == EOF) break;
3353
3354 wl_data->buf[wl_data->cnt] = (char) c;
3355
3356 wl_data->cnt++;
3357
3358 if (c == '\n') break;
3359 }
3360
3361 // ensure stream ends with a newline
3362
3363 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3364 {
3365 wl_data->cnt++;
3366
3367 wl_data->buf[wl_data->cnt - 1] = '\n';
3368 }
3369
3370 return;
3371 }
3372
3373 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3374 {
3375 char *ptr = buf;
3376
3377 for (u32 i = 0; i < sz; i++, ptr++)
3378 {
3379 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3380
3381 if (i == 7)
3382 {
3383 *off = i;
3384 *len = i;
3385
3386 return;
3387 }
3388
3389 if (*ptr != '\n') continue;
3390
3391 *off = i + 1;
3392
3393 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3394
3395 *len = i;
3396
3397 return;
3398 }
3399
3400 *off = sz;
3401 *len = sz;
3402 }
3403
3404 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3405 {
3406 char *ptr = buf;
3407
3408 for (u32 i = 0; i < sz; i++, ptr++)
3409 {
3410 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3411
3412 if (*ptr != '\n') continue;
3413
3414 *off = i + 1;
3415
3416 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3417
3418 *len = i;
3419
3420 return;
3421 }
3422
3423 *off = sz;
3424 *len = sz;
3425 }
3426
3427 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3428 {
3429 char *ptr = buf;
3430
3431 for (u32 i = 0; i < sz; i++, ptr++)
3432 {
3433 if (*ptr != '\n') continue;
3434
3435 *off = i + 1;
3436
3437 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3438
3439 *len = i;
3440
3441 return;
3442 }
3443
3444 *off = sz;
3445 *len = sz;
3446 }
3447
3448 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3449 {
3450 while (wl_data->pos < wl_data->cnt)
3451 {
3452 uint off;
3453 uint len;
3454
3455 char *ptr = wl_data->buf + wl_data->pos;
3456
3457 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3458
3459 wl_data->pos += off;
3460
3461 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3462 {
3463 char rule_buf_out[BLOCK_SIZE] = { 0 };
3464
3465 int rule_len_out = -1;
3466
3467 if (len < BLOCK_SIZE)
3468 {
3469 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3470 }
3471
3472 if (rule_len_out < 0)
3473 {
3474 continue;
3475 }
3476
3477 if (rule_len_out > PW_MAX)
3478 {
3479 continue;
3480 }
3481 }
3482 else
3483 {
3484 if (len > PW_MAX)
3485 {
3486 continue;
3487 }
3488 }
3489
3490 *out_buf = ptr;
3491 *out_len = len;
3492
3493 return;
3494 }
3495
3496 if (feof (fd))
3497 {
3498 fprintf (stderr, "BUG feof()!!\n");
3499
3500 return;
3501 }
3502
3503 load_segment (wl_data, fd);
3504
3505 get_next_word (wl_data, fd, out_buf, out_len);
3506 }
3507
3508 #ifdef _POSIX
3509 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3510 #endif
3511
3512 #ifdef _WIN
3513 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3514 #endif
3515 {
3516 hc_signal (NULL);
3517
3518 dictstat_t d;
3519
3520 d.cnt = 0;
3521
3522 #ifdef _POSIX
3523 fstat (fileno (fd), &d.stat);
3524 #endif
3525
3526 #ifdef _WIN
3527 _fstat64 (fileno (fd), &d.stat);
3528 #endif
3529
3530 d.stat.st_mode = 0;
3531 d.stat.st_nlink = 0;
3532 d.stat.st_uid = 0;
3533 d.stat.st_gid = 0;
3534 d.stat.st_rdev = 0;
3535 d.stat.st_atime = 0;
3536
3537 #ifdef _POSIX
3538 d.stat.st_blksize = 0;
3539 d.stat.st_blocks = 0;
3540 #endif
3541
3542 if (d.stat.st_size == 0) return 0;
3543
3544 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3545
3546 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3547 {
3548 if (d_cache)
3549 {
3550 u64 cnt = d_cache->cnt;
3551
3552 u64 keyspace = cnt;
3553
3554 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3555 {
3556 keyspace *= data.kernel_rules_cnt;
3557 }
3558 else if (data.attack_kern == ATTACK_KERN_COMBI)
3559 {
3560 keyspace *= data.combs_cnt;
3561 }
3562
3563 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);
3564 if (data.quiet == 0) log_info ("");
3565
3566 hc_signal (sigHandler_default);
3567
3568 return (keyspace);
3569 }
3570 }
3571
3572 time_t now = 0;
3573 time_t prev = 0;
3574
3575 u64 comp = 0;
3576 u64 cnt = 0;
3577 u64 cnt2 = 0;
3578
3579 while (!feof (fd))
3580 {
3581 load_segment (wl_data, fd);
3582
3583 comp += wl_data->cnt;
3584
3585 u32 i = 0;
3586
3587 while (i < wl_data->cnt)
3588 {
3589 u32 len;
3590 u32 off;
3591
3592 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3593
3594 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3595 {
3596 char rule_buf_out[BLOCK_SIZE] = { 0 };
3597
3598 int rule_len_out = -1;
3599
3600 if (len < BLOCK_SIZE)
3601 {
3602 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3603 }
3604
3605 if (rule_len_out < 0)
3606 {
3607 len = PW_MAX1;
3608 }
3609 else
3610 {
3611 len = rule_len_out;
3612 }
3613 }
3614
3615 if (len < PW_MAX1)
3616 {
3617 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3618 {
3619 cnt += data.kernel_rules_cnt;
3620 }
3621 else if (data.attack_kern == ATTACK_KERN_COMBI)
3622 {
3623 cnt += data.combs_cnt;
3624 }
3625
3626 d.cnt++;
3627 }
3628
3629 i += off;
3630
3631 cnt2++;
3632 }
3633
3634 time (&now);
3635
3636 if ((now - prev) == 0) continue;
3637
3638 float percent = (float) comp / (float) d.stat.st_size;
3639
3640 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);
3641
3642 time (&prev);
3643 }
3644
3645 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);
3646 if (data.quiet == 0) log_info ("");
3647
3648 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3649
3650 hc_signal (sigHandler_default);
3651
3652 return (cnt);
3653 }
3654
3655 static void *thread_monitor (void *p)
3656 {
3657 uint runtime_check = 0;
3658 uint remove_check = 0;
3659 uint status_check = 0;
3660 uint restore_check = 0;
3661
3662 uint restore_left = data.restore_timer;
3663 uint remove_left = data.remove_timer;
3664 uint status_left = data.status_timer;
3665
3666 #ifdef HAVE_HWMON
3667 uint hwmon_check = 0;
3668
3669 // these variables are mainly used for fan control (AMD only)
3670
3671 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3672
3673 // temperature controller "loopback" values
3674
3675 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3676 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3677
3678 #ifdef HAVE_ADL
3679 int temp_threshold = 1; // degrees celcius
3680
3681 int fan_speed_min = 15; // in percentage
3682 int fan_speed_max = 100;
3683 #endif // HAVE_ADL
3684
3685 time_t last_temp_check_time;
3686 #endif // HAVE_HWMON
3687
3688 uint sleep_time = 1;
3689
3690 if (data.runtime)
3691 {
3692 runtime_check = 1;
3693 }
3694
3695 if (data.restore_timer)
3696 {
3697 restore_check = 1;
3698 }
3699
3700 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3701 {
3702 remove_check = 1;
3703 }
3704
3705 if (data.status == 1)
3706 {
3707 status_check = 1;
3708 }
3709
3710 #ifdef HAVE_HWMON
3711 if (data.gpu_temp_disable == 0)
3712 {
3713 time (&last_temp_check_time);
3714
3715 hwmon_check = 1;
3716 }
3717 #endif
3718
3719 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3720 {
3721 #ifdef HAVE_HWMON
3722 if (hwmon_check == 0)
3723 #endif
3724 return (p);
3725 }
3726
3727 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3728 {
3729 hc_sleep (sleep_time);
3730
3731 if (data.devices_status != STATUS_RUNNING) continue;
3732
3733 #ifdef HAVE_HWMON
3734 if (hwmon_check == 1)
3735 {
3736 hc_thread_mutex_lock (mux_adl);
3737
3738 time_t temp_check_time;
3739
3740 time (&temp_check_time);
3741
3742 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3743
3744 if (Ta == 0) Ta = 1;
3745
3746 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3747 {
3748 hc_device_param_t *device_param = &data.devices_param[device_id];
3749
3750 if (device_param->skipped) continue;
3751
3752 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3753
3754 const int temperature = hm_get_temperature_with_device_id (device_id);
3755
3756 if (temperature > (int) data.gpu_temp_abort)
3757 {
3758 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3759
3760 if (data.devices_status != STATUS_QUIT) myabort ();
3761
3762 break;
3763 }
3764
3765 #ifdef HAVE_ADL
3766 const int gpu_temp_retain = data.gpu_temp_retain;
3767
3768 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3769 {
3770 if (data.hm_device[device_id].fan_supported == 1)
3771 {
3772 int temp_cur = temperature;
3773
3774 int temp_diff_new = gpu_temp_retain - temp_cur;
3775
3776 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3777
3778 // calculate Ta value (time difference in seconds between the last check and this check)
3779
3780 last_temp_check_time = temp_check_time;
3781
3782 float Kp = 1.8;
3783 float Ki = 0.005;
3784 float Kd = 6;
3785
3786 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3787
3788 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);
3789
3790 if (abs (fan_diff_required) >= temp_threshold)
3791 {
3792 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3793
3794 int fan_speed_level = fan_speed_cur;
3795
3796 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3797
3798 int fan_speed_new = fan_speed_level - fan_diff_required;
3799
3800 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3801 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3802
3803 if (fan_speed_new != fan_speed_cur)
3804 {
3805 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3806 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3807
3808 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3809 {
3810 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3811
3812 fan_speed_chgd[device_id] = 1;
3813 }
3814
3815 temp_diff_old[device_id] = temp_diff_new;
3816 }
3817 }
3818 }
3819 }
3820 #endif // HAVE_ADL
3821 }
3822
3823 hc_thread_mutex_unlock (mux_adl);
3824 }
3825 #endif // HAVE_HWMON
3826
3827 if (restore_check == 1)
3828 {
3829 restore_left--;
3830
3831 if (restore_left == 0)
3832 {
3833 if (data.restore_disable == 0) cycle_restore ();
3834
3835 restore_left = data.restore_timer;
3836 }
3837 }
3838
3839 if ((runtime_check == 1) && (data.runtime_start > 0))
3840 {
3841 time_t runtime_cur;
3842
3843 time (&runtime_cur);
3844
3845 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3846
3847 if (runtime_left <= 0)
3848 {
3849 if (data.benchmark == 0)
3850 {
3851 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3852 }
3853
3854 if (data.devices_status != STATUS_QUIT) myabort ();
3855 }
3856 }
3857
3858 if (remove_check == 1)
3859 {
3860 remove_left--;
3861
3862 if (remove_left == 0)
3863 {
3864 if (data.digests_saved != data.digests_done)
3865 {
3866 data.digests_saved = data.digests_done;
3867
3868 save_hash ();
3869 }
3870
3871 remove_left = data.remove_timer;
3872 }
3873 }
3874
3875 if (status_check == 1)
3876 {
3877 status_left--;
3878
3879 if (status_left == 0)
3880 {
3881 hc_thread_mutex_lock (mux_display);
3882
3883 if (data.quiet == 0) clear_prompt ();
3884
3885 if (data.quiet == 0) log_info ("");
3886
3887 status_display ();
3888
3889 if (data.quiet == 0) log_info ("");
3890
3891 hc_thread_mutex_unlock (mux_display);
3892
3893 status_left = data.status_timer;
3894 }
3895 }
3896 }
3897
3898 #ifdef HAVE_HWMON
3899 myfree (fan_speed_chgd);
3900
3901 myfree (temp_diff_old);
3902 myfree (temp_diff_sum);
3903 #endif
3904
3905 p = NULL;
3906
3907 return (p);
3908 }
3909
3910 static void *thread_outfile_remove (void *p)
3911 {
3912 // some hash-dependent constants
3913 char *outfile_dir = data.outfile_check_directory;
3914 uint dgst_size = data.dgst_size;
3915 uint isSalted = data.isSalted;
3916 uint esalt_size = data.esalt_size;
3917 uint hash_mode = data.hash_mode;
3918
3919 uint outfile_check_timer = data.outfile_check_timer;
3920
3921 char separator = data.separator;
3922
3923 // some hash-dependent functions
3924 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3925 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3926
3927 // buffers
3928 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3929
3930 hash_buf.digest = mymalloc (dgst_size);
3931
3932 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3933
3934 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3935
3936 uint digest_buf[64] = { 0 };
3937
3938 outfile_data_t *out_info = NULL;
3939
3940 char **out_files = NULL;
3941
3942 time_t folder_mtime = 0;
3943
3944 int out_cnt = 0;
3945
3946 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3947
3948 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3949 {
3950 hc_sleep (1);
3951
3952 if (data.devices_status != STATUS_RUNNING) continue;
3953
3954 check_left--;
3955
3956 if (check_left == 0)
3957 {
3958 struct stat outfile_check_stat;
3959
3960 if (stat (outfile_dir, &outfile_check_stat) == 0)
3961 {
3962 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3963
3964 if (is_dir == 1)
3965 {
3966 if (outfile_check_stat.st_mtime > folder_mtime)
3967 {
3968 char **out_files_new = scan_directory (outfile_dir);
3969
3970 int out_cnt_new = count_dictionaries (out_files_new);
3971
3972 outfile_data_t *out_info_new = NULL;
3973
3974 if (out_cnt_new > 0)
3975 {
3976 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3977
3978 for (int i = 0; i < out_cnt_new; i++)
3979 {
3980 out_info_new[i].file_name = out_files_new[i];
3981
3982 // check if there are files that we have seen/checked before (and not changed)
3983
3984 for (int j = 0; j < out_cnt; j++)
3985 {
3986 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3987 {
3988 struct stat outfile_stat;
3989
3990 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3991 {
3992 if (outfile_stat.st_ctime == out_info[j].ctime)
3993 {
3994 out_info_new[i].ctime = out_info[j].ctime;
3995 out_info_new[i].seek = out_info[j].seek;
3996 }
3997 }
3998 }
3999 }
4000 }
4001 }
4002
4003 local_free (out_info);
4004 local_free (out_files);
4005
4006 out_files = out_files_new;
4007 out_cnt = out_cnt_new;
4008 out_info = out_info_new;
4009
4010 folder_mtime = outfile_check_stat.st_mtime;
4011 }
4012
4013 for (int j = 0; j < out_cnt; j++)
4014 {
4015 FILE *fp = fopen (out_info[j].file_name, "rb");
4016
4017 if (fp != NULL)
4018 {
4019 //hc_thread_mutex_lock (mux_display);
4020
4021 #ifdef _POSIX
4022 struct stat outfile_stat;
4023
4024 fstat (fileno (fp), &outfile_stat);
4025 #endif
4026
4027 #ifdef _WIN
4028 struct stat64 outfile_stat;
4029
4030 _fstat64 (fileno (fp), &outfile_stat);
4031 #endif
4032
4033 if (outfile_stat.st_ctime > out_info[j].ctime)
4034 {
4035 out_info[j].ctime = outfile_stat.st_ctime;
4036 out_info[j].seek = 0;
4037 }
4038
4039 fseek (fp, out_info[j].seek, SEEK_SET);
4040
4041 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4042
4043 while (!feof (fp))
4044 {
4045 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4046
4047 if (ptr == NULL) break;
4048
4049 int line_len = strlen (line_buf);
4050
4051 if (line_len <= 0) continue;
4052
4053 int iter = MAX_CUT_TRIES;
4054
4055 for (uint i = line_len - 1; i && iter; i--, line_len--)
4056 {
4057 if (line_buf[i] != separator) continue;
4058
4059 int parser_status = PARSER_OK;
4060
4061 if ((hash_mode != 2500) && (hash_mode != 6800))
4062 {
4063 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4064 }
4065
4066 uint found = 0;
4067
4068 if (parser_status == PARSER_OK)
4069 {
4070 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4071 {
4072 if (data.salts_shown[salt_pos] == 1) continue;
4073
4074 salt_t *salt_buf = &data.salts_buf[salt_pos];
4075
4076 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4077 {
4078 uint idx = salt_buf->digests_offset + digest_pos;
4079
4080 if (data.digests_shown[idx] == 1) continue;
4081
4082 uint cracked = 0;
4083
4084 if (hash_mode == 6800)
4085 {
4086 if (i == salt_buf->salt_len)
4087 {
4088 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4089 }
4090 }
4091 else if (hash_mode == 2500)
4092 {
4093 // BSSID : MAC1 : MAC2 (:plain)
4094 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4095 {
4096 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4097
4098 if (!cracked) continue;
4099
4100 // now compare MAC1 and MAC2 too, since we have this additional info
4101 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4102 char *mac2_pos = mac1_pos + 12 + 1;
4103
4104 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4105 wpa_t *wpa = &wpas[salt_pos];
4106
4107 // compare hex string(s) vs binary MAC address(es)
4108
4109 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4110 {
4111 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4112 {
4113 cracked = 0;
4114
4115 break;
4116 }
4117 }
4118
4119 // early skip ;)
4120 if (!cracked) continue;
4121
4122 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4123 {
4124 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4125 {
4126 cracked = 0;
4127
4128 break;
4129 }
4130 }
4131 }
4132 }
4133 else
4134 {
4135 char *digests_buf_ptr = (char *) data.digests_buf;
4136
4137 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4138
4139 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4140 }
4141
4142 if (cracked == 1)
4143 {
4144 found = 1;
4145
4146 data.digests_shown[idx] = 1;
4147
4148 data.digests_done++;
4149
4150 salt_buf->digests_done++;
4151
4152 if (salt_buf->digests_done == salt_buf->digests_cnt)
4153 {
4154 data.salts_shown[salt_pos] = 1;
4155
4156 data.salts_done++;
4157
4158 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4159 }
4160 }
4161 }
4162
4163 if (data.devices_status == STATUS_CRACKED) break;
4164 }
4165 }
4166
4167 if (found) break;
4168
4169 if (data.devices_status == STATUS_CRACKED) break;
4170
4171 iter--;
4172 }
4173
4174 if (data.devices_status == STATUS_CRACKED) break;
4175 }
4176
4177 myfree (line_buf);
4178
4179 out_info[j].seek = ftell (fp);
4180
4181 //hc_thread_mutex_unlock (mux_display);
4182
4183 fclose (fp);
4184 }
4185 }
4186 }
4187 }
4188
4189 check_left = outfile_check_timer;
4190 }
4191 }
4192
4193 if (esalt_size) local_free (hash_buf.esalt);
4194
4195 if (isSalted) local_free (hash_buf.salt);
4196
4197 local_free (hash_buf.digest);
4198
4199 local_free (out_info);
4200
4201 local_free (out_files);
4202
4203 p = NULL;
4204
4205 return (p);
4206 }
4207
4208 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4209 {
4210 if (device_param->pws_cnt < device_param->kernel_power)
4211 {
4212 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4213
4214 u8 *ptr = (u8 *) pw->i;
4215
4216 memcpy (ptr, pw_buf, pw_len);
4217
4218 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4219
4220 pw->pw_len = pw_len;
4221
4222 device_param->pws_cnt++;
4223 }
4224 else
4225 {
4226 fprintf (stderr, "BUG pw_add()!!\n");
4227
4228 return;
4229 }
4230 }
4231
4232 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4233 {
4234 hc_thread_mutex_lock (mux_dispatcher);
4235
4236 const u64 words_cur = data.words_cur;
4237 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4238
4239 device_param->words_off = words_cur;
4240
4241 const u64 words_left = words_base - words_cur;
4242
4243 if (allow_div)
4244 {
4245 if (data.kernel_power_all > words_left)
4246 {
4247 if (data.kernel_power_div == 0)
4248 {
4249 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4250 }
4251 }
4252
4253 if (data.kernel_power_div)
4254 {
4255 if (device_param->kernel_power == device_param->kernel_power_user)
4256 {
4257 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4258
4259 if (kernel_power_new < device_param->kernel_power)
4260 {
4261 device_param->kernel_power = kernel_power_new;
4262 }
4263 }
4264 }
4265 }
4266
4267 const uint kernel_power = device_param->kernel_power;
4268
4269 uint work = MIN (words_left, kernel_power);
4270
4271 work = MIN (work, max);
4272
4273 data.words_cur += work;
4274
4275 hc_thread_mutex_unlock (mux_dispatcher);
4276
4277 return work;
4278 }
4279
4280 static void *thread_calc_stdin (void *p)
4281 {
4282 hc_device_param_t *device_param = (hc_device_param_t *) p;
4283
4284 if (device_param->skipped) return NULL;
4285
4286 autotune (device_param);
4287
4288 char *buf = (char *) mymalloc (HCBUFSIZ);
4289
4290 const uint attack_kern = data.attack_kern;
4291
4292 const uint kernel_power = device_param->kernel_power;
4293
4294 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4295 {
4296 hc_thread_mutex_lock (mux_dispatcher);
4297
4298 if (feof (stdin) != 0)
4299 {
4300 hc_thread_mutex_unlock (mux_dispatcher);
4301
4302 break;
4303 }
4304
4305 uint words_cur = 0;
4306
4307 while (words_cur < kernel_power)
4308 {
4309 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4310
4311 if (line_buf == NULL) break;
4312
4313 uint line_len = in_superchop (line_buf);
4314
4315 line_len = convert_from_hex (line_buf, line_len);
4316
4317 // post-process rule engine
4318
4319 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4320 {
4321 char rule_buf_out[BLOCK_SIZE] = { 0 };
4322
4323 int rule_len_out = -1;
4324
4325 if (line_len < BLOCK_SIZE)
4326 {
4327 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4328 }
4329
4330 if (rule_len_out < 0) continue;
4331
4332 line_buf = rule_buf_out;
4333 line_len = rule_len_out;
4334 }
4335
4336 if (line_len > PW_MAX)
4337 {
4338 continue;
4339 }
4340
4341 if (attack_kern == ATTACK_KERN_STRAIGHT)
4342 {
4343 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4344 {
4345 hc_thread_mutex_lock (mux_counter);
4346
4347 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4348 {
4349 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4350 }
4351
4352 hc_thread_mutex_unlock (mux_counter);
4353
4354 continue;
4355 }
4356 }
4357 else if (attack_kern == ATTACK_KERN_COMBI)
4358 {
4359 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4360 // since we still need to combine the plains
4361
4362 if (line_len > data.pw_max)
4363 {
4364 hc_thread_mutex_lock (mux_counter);
4365
4366 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4367 {
4368 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4369 }
4370
4371 hc_thread_mutex_unlock (mux_counter);
4372
4373 continue;
4374 }
4375 }
4376
4377 pw_add (device_param, (u8 *) line_buf, line_len);
4378
4379 words_cur++;
4380
4381 if (data.devices_status == STATUS_CRACKED) break;
4382 if (data.devices_status == STATUS_ABORTED) break;
4383 if (data.devices_status == STATUS_QUIT) break;
4384 if (data.devices_status == STATUS_BYPASS) break;
4385 }
4386
4387 hc_thread_mutex_unlock (mux_dispatcher);
4388
4389 if (data.devices_status == STATUS_CRACKED) break;
4390 if (data.devices_status == STATUS_ABORTED) break;
4391 if (data.devices_status == STATUS_QUIT) break;
4392 if (data.devices_status == STATUS_BYPASS) break;
4393
4394 // flush
4395
4396 const uint pws_cnt = device_param->pws_cnt;
4397
4398 if (pws_cnt)
4399 {
4400 run_copy (device_param, pws_cnt);
4401
4402 run_cracker (device_param, pws_cnt);
4403
4404 device_param->pws_cnt = 0;
4405
4406 if (attack_kern == ATTACK_KERN_STRAIGHT)
4407 {
4408 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4409 }
4410 else if (attack_kern == ATTACK_KERN_COMBI)
4411 {
4412 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4413 }
4414 }
4415 }
4416
4417 device_param->kernel_accel = 0;
4418 device_param->kernel_loops = 0;
4419
4420 myfree (buf);
4421
4422 return NULL;
4423 }
4424
4425 static void *thread_calc (void *p)
4426 {
4427 hc_device_param_t *device_param = (hc_device_param_t *) p;
4428
4429 if (device_param->skipped) return NULL;
4430
4431 autotune (device_param);
4432
4433 const uint attack_mode = data.attack_mode;
4434 const uint attack_kern = data.attack_kern;
4435
4436 if (attack_mode == ATTACK_MODE_BF)
4437 {
4438 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4439 {
4440 const uint work = get_work (device_param, -1, true);
4441
4442 if (work == 0) break;
4443
4444 const u64 words_off = device_param->words_off;
4445 const u64 words_fin = words_off + work;
4446
4447 const uint pws_cnt = work;
4448
4449 device_param->pws_cnt = pws_cnt;
4450
4451 if (pws_cnt)
4452 {
4453 run_copy (device_param, pws_cnt);
4454
4455 run_cracker (device_param, pws_cnt);
4456
4457 device_param->pws_cnt = 0;
4458
4459 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4460 }
4461
4462 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4463
4464 if (data.devices_status == STATUS_CRACKED) break;
4465 if (data.devices_status == STATUS_ABORTED) break;
4466 if (data.devices_status == STATUS_QUIT) break;
4467 if (data.devices_status == STATUS_BYPASS) break;
4468
4469 if (data.benchmark == 1) break;
4470
4471 device_param->words_done = words_fin;
4472 }
4473 }
4474 else
4475 {
4476 const uint segment_size = data.segment_size;
4477
4478 char *dictfile = data.dictfile;
4479
4480 if (attack_mode == ATTACK_MODE_COMBI)
4481 {
4482 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4483 {
4484 dictfile = data.dictfile2;
4485 }
4486 }
4487
4488 FILE *fd = fopen (dictfile, "rb");
4489
4490 if (fd == NULL)
4491 {
4492 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4493
4494 return NULL;
4495 }
4496
4497 if (attack_mode == ATTACK_MODE_COMBI)
4498 {
4499 const uint combs_mode = data.combs_mode;
4500
4501 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4502 {
4503 const char *dictfilec = data.dictfile2;
4504
4505 FILE *combs_fp = fopen (dictfilec, "rb");
4506
4507 if (combs_fp == NULL)
4508 {
4509 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4510
4511 fclose (fd);
4512
4513 return NULL;
4514 }
4515
4516 device_param->combs_fp = combs_fp;
4517 }
4518 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4519 {
4520 const char *dictfilec = data.dictfile;
4521
4522 FILE *combs_fp = fopen (dictfilec, "rb");
4523
4524 if (combs_fp == NULL)
4525 {
4526 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4527
4528 fclose (fd);
4529
4530 return NULL;
4531 }
4532
4533 device_param->combs_fp = combs_fp;
4534 }
4535 }
4536
4537 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4538
4539 wl_data->buf = (char *) mymalloc (segment_size);
4540 wl_data->avail = segment_size;
4541 wl_data->incr = segment_size;
4542 wl_data->cnt = 0;
4543 wl_data->pos = 0;
4544
4545 u64 words_cur = 0;
4546
4547 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4548 {
4549 u64 words_off = 0;
4550 u64 words_fin = 0;
4551
4552 bool allow_div = true;
4553
4554 u64 max = -1;
4555
4556 while (max)
4557 {
4558 const uint work = get_work (device_param, max, allow_div);
4559
4560 allow_div = false;
4561
4562 if (work == 0) break;
4563
4564 words_off = device_param->words_off;
4565 words_fin = words_off + work;
4566
4567 char *line_buf;
4568 uint line_len;
4569
4570 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4571
4572 max = 0;
4573
4574 for ( ; words_cur < words_fin; words_cur++)
4575 {
4576 get_next_word (wl_data, fd, &line_buf, &line_len);
4577
4578 line_len = convert_from_hex (line_buf, line_len);
4579
4580 // post-process rule engine
4581
4582 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4583 {
4584 char rule_buf_out[BLOCK_SIZE] = { 0 };
4585
4586 int rule_len_out = -1;
4587
4588 if (line_len < BLOCK_SIZE)
4589 {
4590 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4591 }
4592
4593 if (rule_len_out < 0) continue;
4594
4595 line_buf = rule_buf_out;
4596 line_len = rule_len_out;
4597 }
4598
4599 if (attack_kern == ATTACK_KERN_STRAIGHT)
4600 {
4601 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4602 {
4603 max++;
4604
4605 hc_thread_mutex_lock (mux_counter);
4606
4607 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4608 {
4609 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4610 }
4611
4612 hc_thread_mutex_unlock (mux_counter);
4613
4614 continue;
4615 }
4616 }
4617 else if (attack_kern == ATTACK_KERN_COMBI)
4618 {
4619 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4620 // since we still need to combine the plains
4621
4622 if (line_len > data.pw_max)
4623 {
4624 max++;
4625
4626 hc_thread_mutex_lock (mux_counter);
4627
4628 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4629 {
4630 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4631 }
4632
4633 hc_thread_mutex_unlock (mux_counter);
4634
4635 continue;
4636 }
4637 }
4638
4639 pw_add (device_param, (u8 *) line_buf, line_len);
4640
4641 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4642
4643 if (data.devices_status == STATUS_CRACKED) break;
4644 if (data.devices_status == STATUS_ABORTED) break;
4645 if (data.devices_status == STATUS_QUIT) break;
4646 if (data.devices_status == STATUS_BYPASS) break;
4647 }
4648
4649 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4650
4651 if (data.devices_status == STATUS_CRACKED) break;
4652 if (data.devices_status == STATUS_ABORTED) break;
4653 if (data.devices_status == STATUS_QUIT) break;
4654 if (data.devices_status == STATUS_BYPASS) break;
4655 }
4656
4657 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4658
4659 if (data.devices_status == STATUS_CRACKED) break;
4660 if (data.devices_status == STATUS_ABORTED) break;
4661 if (data.devices_status == STATUS_QUIT) break;
4662 if (data.devices_status == STATUS_BYPASS) break;
4663
4664 //
4665 // flush
4666 //
4667
4668 const uint pws_cnt = device_param->pws_cnt;
4669
4670 if (pws_cnt)
4671 {
4672 run_copy (device_param, pws_cnt);
4673
4674 run_cracker (device_param, pws_cnt);
4675
4676 device_param->pws_cnt = 0;
4677
4678 if (attack_kern == ATTACK_KERN_STRAIGHT)
4679 {
4680 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4681 }
4682 else if (attack_kern == ATTACK_KERN_COMBI)
4683 {
4684 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4685 }
4686 }
4687
4688 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4689
4690 if (data.devices_status == STATUS_CRACKED) break;
4691 if (data.devices_status == STATUS_ABORTED) break;
4692 if (data.devices_status == STATUS_QUIT) break;
4693 if (data.devices_status == STATUS_BYPASS) break;
4694
4695 if (words_fin == 0) break;
4696
4697 device_param->words_done = words_fin;
4698 }
4699
4700 if (attack_mode == ATTACK_MODE_COMBI)
4701 {
4702 fclose (device_param->combs_fp);
4703 }
4704
4705 free (wl_data->buf);
4706 free (wl_data);
4707
4708 fclose (fd);
4709 }
4710
4711 device_param->kernel_accel = 0;
4712 device_param->kernel_loops = 0;
4713
4714 return NULL;
4715 }
4716
4717 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4718 {
4719 if (!device_param)
4720 {
4721 log_error ("ERROR: %s : Invalid argument", __func__);
4722
4723 exit (-1);
4724 }
4725
4726 salt_t *salt_buf = &data.salts_buf[salt_pos];
4727
4728 device_param->kernel_params_buf32[24] = salt_pos;
4729 device_param->kernel_params_buf32[27] = 1;
4730 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4731 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4732 device_param->kernel_params_buf32[30] = 0;
4733 device_param->kernel_params_buf32[31] = 1;
4734
4735 char *dictfile_old = data.dictfile;
4736
4737 const char *weak_hash_check = "weak-hash-check";
4738
4739 data.dictfile = (char *) weak_hash_check;
4740
4741 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4742
4743 data.kernel_rules_buf[0].cmds[0] = 0;
4744
4745 /**
4746 * run the kernel
4747 */
4748
4749 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4750 {
4751 run_kernel (KERN_RUN_1, device_param, 1, false);
4752 }
4753 else
4754 {
4755 run_kernel (KERN_RUN_1, device_param, 1, false);
4756
4757 uint loop_step = 16;
4758
4759 const uint iter = salt_buf->salt_iter;
4760
4761 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4762 {
4763 uint loop_left = iter - loop_pos;
4764
4765 loop_left = MIN (loop_left, loop_step);
4766
4767 device_param->kernel_params_buf32[25] = loop_pos;
4768 device_param->kernel_params_buf32[26] = loop_left;
4769
4770 run_kernel (KERN_RUN_2, device_param, 1, false);
4771 }
4772
4773 run_kernel (KERN_RUN_3, device_param, 1, false);
4774 }
4775
4776 /**
4777 * result
4778 */
4779
4780 check_cracked (device_param, salt_pos);
4781
4782 /**
4783 * cleanup
4784 */
4785
4786 device_param->kernel_params_buf32[24] = 0;
4787 device_param->kernel_params_buf32[25] = 0;
4788 device_param->kernel_params_buf32[26] = 0;
4789 device_param->kernel_params_buf32[27] = 0;
4790 device_param->kernel_params_buf32[28] = 0;
4791 device_param->kernel_params_buf32[29] = 0;
4792 device_param->kernel_params_buf32[30] = 0;
4793 device_param->kernel_params_buf32[31] = 0;
4794
4795 data.dictfile = dictfile_old;
4796
4797 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4798 }
4799
4800 // hlfmt hashcat
4801
4802 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4803 {
4804 if (data.username == 0)
4805 {
4806 *hashbuf_pos = line_buf;
4807 *hashbuf_len = line_len;
4808 }
4809 else
4810 {
4811 char *pos = line_buf;
4812 int len = line_len;
4813
4814 for (int i = 0; i < line_len; i++, pos++, len--)
4815 {
4816 if (line_buf[i] == data.separator)
4817 {
4818 pos++;
4819
4820 len--;
4821
4822 break;
4823 }
4824 }
4825
4826 *hashbuf_pos = pos;
4827 *hashbuf_len = len;
4828 }
4829 }
4830
4831 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4832 {
4833 char *pos = NULL;
4834 int len = 0;
4835
4836 int sep_cnt = 0;
4837
4838 for (int i = 0; i < line_len; i++)
4839 {
4840 if (line_buf[i] == data.separator)
4841 {
4842 sep_cnt++;
4843
4844 continue;
4845 }
4846
4847 if (sep_cnt == 0)
4848 {
4849 if (pos == NULL) pos = line_buf + i;
4850
4851 len++;
4852 }
4853 }
4854
4855 *userbuf_pos = pos;
4856 *userbuf_len = len;
4857 }
4858
4859 // hlfmt pwdump
4860
4861 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4862 {
4863 int sep_cnt = 0;
4864
4865 int sep2_len = 0;
4866 int sep3_len = 0;
4867
4868 for (int i = 0; i < line_len; i++)
4869 {
4870 if (line_buf[i] == ':')
4871 {
4872 sep_cnt++;
4873
4874 continue;
4875 }
4876
4877 if (sep_cnt == 2) sep2_len++;
4878 if (sep_cnt == 3) sep3_len++;
4879 }
4880
4881 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4882
4883 return 0;
4884 }
4885
4886 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4887 {
4888 char *pos = NULL;
4889 int len = 0;
4890
4891 int sep_cnt = 0;
4892
4893 for (int i = 0; i < line_len; i++)
4894 {
4895 if (line_buf[i] == ':')
4896 {
4897 sep_cnt++;
4898
4899 continue;
4900 }
4901
4902 if (data.hash_mode == 1000)
4903 {
4904 if (sep_cnt == 3)
4905 {
4906 if (pos == NULL) pos = line_buf + i;
4907
4908 len++;
4909 }
4910 }
4911 else if (data.hash_mode == 3000)
4912 {
4913 if (sep_cnt == 2)
4914 {
4915 if (pos == NULL) pos = line_buf + i;
4916
4917 len++;
4918 }
4919 }
4920 }
4921
4922 *hashbuf_pos = pos;
4923 *hashbuf_len = len;
4924 }
4925
4926 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4927 {
4928 char *pos = NULL;
4929 int len = 0;
4930
4931 int sep_cnt = 0;
4932
4933 for (int i = 0; i < line_len; i++)
4934 {
4935 if (line_buf[i] == ':')
4936 {
4937 sep_cnt++;
4938
4939 continue;
4940 }
4941
4942 if (sep_cnt == 0)
4943 {
4944 if (pos == NULL) pos = line_buf + i;
4945
4946 len++;
4947 }
4948 }
4949
4950 *userbuf_pos = pos;
4951 *userbuf_len = len;
4952 }
4953
4954 // hlfmt passwd
4955
4956 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4957 {
4958 int sep_cnt = 0;
4959
4960 char sep5_first = 0;
4961 char sep6_first = 0;
4962
4963 for (int i = 0; i < line_len; i++)
4964 {
4965 if (line_buf[i] == ':')
4966 {
4967 sep_cnt++;
4968
4969 continue;
4970 }
4971
4972 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4973 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4974 }
4975
4976 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4977
4978 return 0;
4979 }
4980
4981 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4982 {
4983 char *pos = NULL;
4984 int len = 0;
4985
4986 int sep_cnt = 0;
4987
4988 for (int i = 0; i < line_len; i++)
4989 {
4990 if (line_buf[i] == ':')
4991 {
4992 sep_cnt++;
4993
4994 continue;
4995 }
4996
4997 if (sep_cnt == 1)
4998 {
4999 if (pos == NULL) pos = line_buf + i;
5000
5001 len++;
5002 }
5003 }
5004
5005 *hashbuf_pos = pos;
5006 *hashbuf_len = len;
5007 }
5008
5009 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5010 {
5011 char *pos = NULL;
5012 int len = 0;
5013
5014 int sep_cnt = 0;
5015
5016 for (int i = 0; i < line_len; i++)
5017 {
5018 if (line_buf[i] == ':')
5019 {
5020 sep_cnt++;
5021
5022 continue;
5023 }
5024
5025 if (sep_cnt == 0)
5026 {
5027 if (pos == NULL) pos = line_buf + i;
5028
5029 len++;
5030 }
5031 }
5032
5033 *userbuf_pos = pos;
5034 *userbuf_len = len;
5035 }
5036
5037 // hlfmt shadow
5038
5039 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5040 {
5041 int sep_cnt = 0;
5042
5043 for (int i = 0; i < line_len; i++)
5044 {
5045 if (line_buf[i] == ':') sep_cnt++;
5046 }
5047
5048 if (sep_cnt == 8) return 1;
5049
5050 return 0;
5051 }
5052
5053 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5054 {
5055 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5056 }
5057
5058 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5059 {
5060 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5061 }
5062
5063 // hlfmt main
5064
5065 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5066 {
5067 switch (hashfile_format)
5068 {
5069 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5070 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5071 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5072 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5073 }
5074 }
5075
5076 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5077 {
5078 switch (hashfile_format)
5079 {
5080 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5081 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5082 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5083 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5084 }
5085 }
5086
5087 char *strhlfmt (const uint hashfile_format)
5088 {
5089 switch (hashfile_format)
5090 {
5091 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5092 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5093 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5094 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5095 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5096 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5097 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5098 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5099 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5100 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5101 }
5102
5103 return ((char *) "Unknown");
5104 }
5105
5106 static uint hlfmt_detect (FILE *fp, uint max_check)
5107 {
5108 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5109
5110 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5111 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5112
5113 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5114
5115 uint num_check = 0;
5116
5117 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5118
5119 while (!feof (fp))
5120 {
5121 int line_len = fgetl (fp, line_buf);
5122
5123 if (line_len == 0) continue;
5124
5125 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5126 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5127 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5128
5129 if (num_check == max_check) break;
5130
5131 num_check++;
5132 }
5133
5134 myfree (line_buf);
5135
5136 uint hashlist_format = HLFMT_HASHCAT;
5137
5138 for (int i = 1; i < HLFMTS_CNT; i++)
5139 {
5140 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5141
5142 hashlist_format = i;
5143 }
5144
5145 free (formats_cnt);
5146
5147 return hashlist_format;
5148 }
5149
5150 /**
5151 * some further helper function
5152 */
5153
5154 // wrapper around mymalloc for ADL
5155
5156 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5157 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5158 {
5159 return mymalloc (iSize);
5160 }
5161 #endif
5162
5163 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)
5164 {
5165 u64 collisions = 0;
5166
5167 const uint dgst_pos0 = data.dgst_pos0;
5168 const uint dgst_pos1 = data.dgst_pos1;
5169 const uint dgst_pos2 = data.dgst_pos2;
5170 const uint dgst_pos3 = data.dgst_pos3;
5171
5172 memset (bitmap_a, 0, bitmap_size);
5173 memset (bitmap_b, 0, bitmap_size);
5174 memset (bitmap_c, 0, bitmap_size);
5175 memset (bitmap_d, 0, bitmap_size);
5176
5177 for (uint i = 0; i < digests_cnt; i++)
5178 {
5179 uint *digest_ptr = (uint *) digests_buf_ptr;
5180
5181 digests_buf_ptr += dgst_size;
5182
5183 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5184 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5185 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5186 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5187
5188 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5189 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5190 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5191 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5192
5193 if (bitmap_a[idx0] & val0) collisions++;
5194 if (bitmap_b[idx1] & val1) collisions++;
5195 if (bitmap_c[idx2] & val2) collisions++;
5196 if (bitmap_d[idx3] & val3) collisions++;
5197
5198 bitmap_a[idx0] |= val0;
5199 bitmap_b[idx1] |= val1;
5200 bitmap_c[idx2] |= val2;
5201 bitmap_d[idx3] |= val3;
5202
5203 if (collisions >= collisions_max) return 0x7fffffff;
5204 }
5205
5206 return collisions;
5207 }
5208
5209 /**
5210 * main
5211 */
5212
5213 int main (int argc, char **argv)
5214 {
5215 /**
5216 * To help users a bit
5217 */
5218
5219 char *compute = getenv ("COMPUTE");
5220
5221 if (compute)
5222 {
5223 static char display[100];
5224
5225 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5226
5227 putenv (display);
5228 }
5229 else
5230 {
5231 if (getenv ("DISPLAY") == NULL)
5232 putenv ((char *) "DISPLAY=:0");
5233 }
5234
5235 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5236 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5237
5238 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5239 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5240
5241 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5242 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5243
5244 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5245 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5246
5247 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5248 putenv ((char *) "POCL_KERNEL_CACHE=0");
5249
5250 /**
5251 * Real init
5252 */
5253
5254 memset (&data, 0, sizeof (hc_global_data_t));
5255
5256 time_t proc_start;
5257
5258 time (&proc_start);
5259
5260 data.proc_start = proc_start;
5261
5262 int myargc = argc;
5263 char **myargv = argv;
5264
5265 hc_thread_mutex_init (mux_dispatcher);
5266 hc_thread_mutex_init (mux_counter);
5267 hc_thread_mutex_init (mux_display);
5268 hc_thread_mutex_init (mux_adl);
5269
5270 /**
5271 * commandline parameters
5272 */
5273
5274 uint usage = USAGE;
5275 uint version = VERSION;
5276 uint quiet = QUIET;
5277 uint benchmark = BENCHMARK;
5278 uint show = SHOW;
5279 uint left = LEFT;
5280 uint username = USERNAME;
5281 uint remove = REMOVE;
5282 uint remove_timer = REMOVE_TIMER;
5283 u64 skip = SKIP;
5284 u64 limit = LIMIT;
5285 uint keyspace = KEYSPACE;
5286 uint potfile_disable = POTFILE_DISABLE;
5287 char *potfile_path = NULL;
5288 uint debug_mode = DEBUG_MODE;
5289 char *debug_file = NULL;
5290 char *induction_dir = NULL;
5291 char *outfile_check_dir = NULL;
5292 uint force = FORCE;
5293 uint runtime = RUNTIME;
5294 uint hash_mode = HASH_MODE;
5295 uint attack_mode = ATTACK_MODE;
5296 uint markov_disable = MARKOV_DISABLE;
5297 uint markov_classic = MARKOV_CLASSIC;
5298 uint markov_threshold = MARKOV_THRESHOLD;
5299 char *markov_hcstat = NULL;
5300 char *outfile = NULL;
5301 uint outfile_format = OUTFILE_FORMAT;
5302 uint outfile_autohex = OUTFILE_AUTOHEX;
5303 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5304 uint restore = RESTORE;
5305 uint restore_timer = RESTORE_TIMER;
5306 uint restore_disable = RESTORE_DISABLE;
5307 uint status = STATUS;
5308 uint status_timer = STATUS_TIMER;
5309 uint status_automat = STATUS_AUTOMAT;
5310 uint loopback = LOOPBACK;
5311 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5312 char *session = NULL;
5313 uint hex_charset = HEX_CHARSET;
5314 uint hex_salt = HEX_SALT;
5315 uint hex_wordlist = HEX_WORDLIST;
5316 uint rp_gen = RP_GEN;
5317 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5318 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5319 uint rp_gen_seed = RP_GEN_SEED;
5320 char *rule_buf_l = (char *) RULE_BUF_L;
5321 char *rule_buf_r = (char *) RULE_BUF_R;
5322 uint increment = INCREMENT;
5323 uint increment_min = INCREMENT_MIN;
5324 uint increment_max = INCREMENT_MAX;
5325 char *cpu_affinity = NULL;
5326 OCL_PTR *ocl = NULL;
5327 char *opencl_devices = NULL;
5328 char *opencl_platforms = NULL;
5329 char *opencl_device_types = NULL;
5330 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5331 char *truecrypt_keyfiles = NULL;
5332 uint workload_profile = WORKLOAD_PROFILE;
5333 uint kernel_accel = KERNEL_ACCEL;
5334 uint kernel_loops = KERNEL_LOOPS;
5335 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5336 #ifdef HAVE_HWMON
5337 uint gpu_temp_abort = GPU_TEMP_ABORT;
5338 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5339 #ifdef HAVE_ADL
5340 uint powertune_enable = POWERTUNE_ENABLE;
5341 #endif
5342 #endif
5343 uint logfile_disable = LOGFILE_DISABLE;
5344 uint segment_size = SEGMENT_SIZE;
5345 uint scrypt_tmto = SCRYPT_TMTO;
5346 char separator = SEPARATOR;
5347 uint bitmap_min = BITMAP_MIN;
5348 uint bitmap_max = BITMAP_MAX;
5349 char *custom_charset_1 = NULL;
5350 char *custom_charset_2 = NULL;
5351 char *custom_charset_3 = NULL;
5352 char *custom_charset_4 = NULL;
5353
5354 #define IDX_HELP 'h'
5355 #define IDX_VERSION 'V'
5356 #define IDX_VERSION_LOWER 'v'
5357 #define IDX_QUIET 0xff02
5358 #define IDX_SHOW 0xff03
5359 #define IDX_LEFT 0xff04
5360 #define IDX_REMOVE 0xff05
5361 #define IDX_REMOVE_TIMER 0xff37
5362 #define IDX_SKIP 's'
5363 #define IDX_LIMIT 'l'
5364 #define IDX_KEYSPACE 0xff35
5365 #define IDX_POTFILE_DISABLE 0xff06
5366 #define IDX_POTFILE_PATH 0xffe0
5367 #define IDX_DEBUG_MODE 0xff43
5368 #define IDX_DEBUG_FILE 0xff44
5369 #define IDX_INDUCTION_DIR 0xff46
5370 #define IDX_OUTFILE_CHECK_DIR 0xff47
5371 #define IDX_USERNAME 0xff07
5372 #define IDX_FORCE 0xff08
5373 #define IDX_RUNTIME 0xff09
5374 #define IDX_BENCHMARK 'b'
5375 #define IDX_HASH_MODE 'm'
5376 #define IDX_ATTACK_MODE 'a'
5377 #define IDX_RP_FILE 'r'
5378 #define IDX_RP_GEN 'g'
5379 #define IDX_RP_GEN_FUNC_MIN 0xff10
5380 #define IDX_RP_GEN_FUNC_MAX 0xff11
5381 #define IDX_RP_GEN_SEED 0xff34
5382 #define IDX_RULE_BUF_L 'j'
5383 #define IDX_RULE_BUF_R 'k'
5384 #define IDX_INCREMENT 'i'
5385 #define IDX_INCREMENT_MIN 0xff12
5386 #define IDX_INCREMENT_MAX 0xff13
5387 #define IDX_OUTFILE 'o'
5388 #define IDX_OUTFILE_FORMAT 0xff14
5389 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5390 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5391 #define IDX_RESTORE 0xff15
5392 #define IDX_RESTORE_DISABLE 0xff27
5393 #define IDX_STATUS 0xff17
5394 #define IDX_STATUS_TIMER 0xff18
5395 #define IDX_STATUS_AUTOMAT 0xff50
5396 #define IDX_LOOPBACK 0xff38
5397 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5398 #define IDX_SESSION 0xff19
5399 #define IDX_HEX_CHARSET 0xff20
5400 #define IDX_HEX_SALT 0xff21
5401 #define IDX_HEX_WORDLIST 0xff40
5402 #define IDX_MARKOV_DISABLE 0xff22
5403 #define IDX_MARKOV_CLASSIC 0xff23
5404 #define IDX_MARKOV_THRESHOLD 't'
5405 #define IDX_MARKOV_HCSTAT 0xff24
5406 #define IDX_CPU_AFFINITY 0xff25
5407 #define IDX_OPENCL_DEVICES 'd'
5408 #define IDX_OPENCL_PLATFORMS 0xff72
5409 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5410 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5411 #define IDX_WORKLOAD_PROFILE 'w'
5412 #define IDX_KERNEL_ACCEL 'n'
5413 #define IDX_KERNEL_LOOPS 'u'
5414 #define IDX_GPU_TEMP_DISABLE 0xff29
5415 #define IDX_GPU_TEMP_ABORT 0xff30
5416 #define IDX_GPU_TEMP_RETAIN 0xff31
5417 #define IDX_POWERTUNE_ENABLE 0xff41
5418 #define IDX_LOGFILE_DISABLE 0xff51
5419 #define IDX_TRUECRYPT_KEYFILES 0xff52
5420 #define IDX_SCRYPT_TMTO 0xff61
5421 #define IDX_SEGMENT_SIZE 'c'
5422 #define IDX_SEPARATOR 'p'
5423 #define IDX_BITMAP_MIN 0xff70
5424 #define IDX_BITMAP_MAX 0xff71
5425 #define IDX_CUSTOM_CHARSET_1 '1'
5426 #define IDX_CUSTOM_CHARSET_2 '2'
5427 #define IDX_CUSTOM_CHARSET_3 '3'
5428 #define IDX_CUSTOM_CHARSET_4 '4'
5429
5430 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5431
5432 struct option long_options[] =
5433 {
5434 {"help", no_argument, 0, IDX_HELP},
5435 {"version", no_argument, 0, IDX_VERSION},
5436 {"quiet", no_argument, 0, IDX_QUIET},
5437 {"show", no_argument, 0, IDX_SHOW},
5438 {"left", no_argument, 0, IDX_LEFT},
5439 {"username", no_argument, 0, IDX_USERNAME},
5440 {"remove", no_argument, 0, IDX_REMOVE},
5441 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5442 {"skip", required_argument, 0, IDX_SKIP},
5443 {"limit", required_argument, 0, IDX_LIMIT},
5444 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5445 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5446 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5447 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5448 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5449 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5450 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5451 {"force", no_argument, 0, IDX_FORCE},
5452 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5453 {"restore", no_argument, 0, IDX_RESTORE},
5454 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5455 {"status", no_argument, 0, IDX_STATUS},
5456 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5457 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5458 {"loopback", no_argument, 0, IDX_LOOPBACK},
5459 {"weak-hash-threshold",
5460 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5461 {"session", required_argument, 0, IDX_SESSION},
5462 {"runtime", required_argument, 0, IDX_RUNTIME},
5463 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5464 {"generate-rules-func-min",
5465 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5466 {"generate-rules-func-max",
5467 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5468 {"generate-rules-seed",
5469 required_argument, 0, IDX_RP_GEN_SEED},
5470 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5471 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5472 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5473 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5474 {"rules-file", required_argument, 0, IDX_RP_FILE},
5475 {"outfile", required_argument, 0, IDX_OUTFILE},
5476 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5477 {"outfile-autohex-disable",
5478 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5479 {"outfile-check-timer",
5480 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5481 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5482 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5483 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5484 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5485 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5486 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5487 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5488 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5489 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5490 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5491 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5492 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5493 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5494 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5495 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5496 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5497 #ifdef HAVE_HWMON
5498 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5499 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5500 #ifdef HAVE_ADL
5501 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5502 #endif
5503 #endif // HAVE_HWMON
5504 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5505 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5506 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5507 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5508 // deprecated
5509 {"seperator", required_argument, 0, IDX_SEPARATOR},
5510 {"separator", required_argument, 0, IDX_SEPARATOR},
5511 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5512 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5513 {"increment", no_argument, 0, IDX_INCREMENT},
5514 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5515 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5516 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5517 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5518 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5519 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5520
5521 {0, 0, 0, 0}
5522 };
5523
5524 uint rp_files_cnt = 0;
5525
5526 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5527
5528 int option_index = 0;
5529 int c = -1;
5530
5531 optind = 1;
5532 optopt = 0;
5533
5534 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5535 {
5536 switch (c)
5537 {
5538 case IDX_HELP: usage = 1; break;
5539 case IDX_VERSION:
5540 case IDX_VERSION_LOWER: version = 1; break;
5541 case IDX_RESTORE: restore = 1; break;
5542 case IDX_SESSION: session = optarg; break;
5543 case IDX_SHOW: show = 1; break;
5544 case IDX_LEFT: left = 1; break;
5545 case '?': return (-1);
5546 }
5547 }
5548
5549 if (optopt != 0)
5550 {
5551 log_error ("ERROR: Invalid argument specified");
5552
5553 return (-1);
5554 }
5555
5556 /**
5557 * exit functions
5558 */
5559
5560 if (version)
5561 {
5562 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5563
5564 return (0);
5565 }
5566
5567 if (usage)
5568 {
5569 usage_big_print (PROGNAME);
5570
5571 return (0);
5572 }
5573
5574 /**
5575 * session needs to be set, always!
5576 */
5577
5578 if (session == NULL) session = (char *) PROGNAME;
5579
5580 /**
5581 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5582 */
5583
5584 char *exec_path = get_exec_path ();
5585
5586 #ifdef LINUX
5587
5588 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5589 char *resolved_exec_path = realpath (exec_path, NULL);
5590
5591 char *install_dir = get_install_dir (resolved_exec_path);
5592 char *profile_dir = NULL;
5593 char *session_dir = NULL;
5594 char *shared_dir = NULL;
5595
5596 if (strcmp (install_dir, resolved_install_folder) == 0)
5597 {
5598 struct passwd *pw = getpwuid (getuid ());
5599
5600 const char *homedir = pw->pw_dir;
5601
5602 profile_dir = get_profile_dir (homedir);
5603 session_dir = get_session_dir (profile_dir);
5604 shared_dir = strdup (SHARED_FOLDER);
5605
5606 mkdir (profile_dir, 0700);
5607 mkdir (session_dir, 0700);
5608 }
5609 else
5610 {
5611 profile_dir = install_dir;
5612 session_dir = install_dir;
5613 shared_dir = install_dir;
5614 }
5615
5616 myfree (resolved_install_folder);
5617 myfree (resolved_exec_path);
5618
5619 #else
5620
5621 char *install_dir = get_install_dir (exec_path);
5622 char *profile_dir = install_dir;
5623 char *session_dir = install_dir;
5624 char *shared_dir = install_dir;
5625
5626 #endif
5627
5628 data.install_dir = install_dir;
5629 data.profile_dir = profile_dir;
5630 data.session_dir = session_dir;
5631 data.shared_dir = shared_dir;
5632
5633 myfree (exec_path);
5634
5635 /**
5636 * kernel cache, we need to make sure folder exist
5637 */
5638
5639 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5640
5641 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5642
5643 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5644
5645 mkdir (kernels_folder, 0700);
5646
5647 myfree (kernels_folder);
5648
5649 /**
5650 * session
5651 */
5652
5653 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5654
5655 data.session = session;
5656
5657 char *eff_restore_file = (char *) mymalloc (session_size);
5658 char *new_restore_file = (char *) mymalloc (session_size);
5659
5660 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5661 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5662
5663 data.eff_restore_file = eff_restore_file;
5664 data.new_restore_file = new_restore_file;
5665
5666 if (((show == 1) || (left == 1)) && (restore == 1))
5667 {
5668 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5669 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5670
5671 return (-1);
5672 }
5673
5674 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5675 if ((show == 1) || (left == 1))
5676 {
5677 restore_disable = 1;
5678
5679 restore = 0;
5680 }
5681
5682 data.restore_disable = restore_disable;
5683
5684 restore_data_t *rd = init_restore (argc, argv);
5685
5686 data.rd = rd;
5687
5688 /**
5689 * restore file
5690 */
5691
5692 if (restore == 1)
5693 {
5694 read_restore (eff_restore_file, rd);
5695
5696 if (rd->version_bin < RESTORE_MIN)
5697 {
5698 log_error ("ERROR: Incompatible restore-file version");
5699
5700 return (-1);
5701 }
5702
5703 myargc = rd->argc;
5704 myargv = rd->argv;
5705
5706 #ifdef _POSIX
5707 rd->pid = getpid ();
5708 #elif _WIN
5709 rd->pid = GetCurrentProcessId ();
5710 #endif
5711 }
5712
5713 uint hash_mode_chgd = 0;
5714 uint runtime_chgd = 0;
5715 uint kernel_loops_chgd = 0;
5716 uint kernel_accel_chgd = 0;
5717 uint attack_mode_chgd = 0;
5718 uint outfile_format_chgd = 0;
5719 uint rp_gen_seed_chgd = 0;
5720 uint remove_timer_chgd = 0;
5721 uint increment_min_chgd = 0;
5722 uint increment_max_chgd = 0;
5723 uint workload_profile_chgd = 0;
5724 uint opencl_vector_width_chgd = 0;
5725
5726 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5727 uint gpu_temp_retain_chgd = 0;
5728 uint gpu_temp_abort_chgd = 0;
5729 #endif
5730
5731 optind = 1;
5732 optopt = 0;
5733 option_index = 0;
5734
5735 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5736 {
5737 switch (c)
5738 {
5739 //case IDX_HELP: usage = 1; break;
5740 //case IDX_VERSION: version = 1; break;
5741 //case IDX_RESTORE: restore = 1; break;
5742 case IDX_QUIET: quiet = 1; break;
5743 //case IDX_SHOW: show = 1; break;
5744 case IDX_SHOW: break;
5745 //case IDX_LEFT: left = 1; break;
5746 case IDX_LEFT: break;
5747 case IDX_USERNAME: username = 1; break;
5748 case IDX_REMOVE: remove = 1; break;
5749 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5750 remove_timer_chgd = 1; break;
5751 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5752 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5753 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5754 case IDX_DEBUG_FILE: debug_file = optarg; break;
5755 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5756 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5757 case IDX_FORCE: force = 1; break;
5758 case IDX_SKIP: skip = atoll (optarg); break;
5759 case IDX_LIMIT: limit = atoll (optarg); break;
5760 case IDX_KEYSPACE: keyspace = 1; break;
5761 case IDX_BENCHMARK: benchmark = 1; break;
5762 case IDX_RESTORE: break;
5763 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5764 case IDX_STATUS: status = 1; break;
5765 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5766 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5767 case IDX_LOOPBACK: loopback = 1; break;
5768 case IDX_WEAK_HASH_THRESHOLD:
5769 weak_hash_threshold = atoi (optarg); break;
5770 //case IDX_SESSION: session = optarg; break;
5771 case IDX_SESSION: break;
5772 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5773 hash_mode_chgd = 1; break;
5774 case IDX_RUNTIME: runtime = atoi (optarg);
5775 runtime_chgd = 1; break;
5776 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5777 attack_mode_chgd = 1; break;
5778 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5779 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5780 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5781 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5782 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5783 rp_gen_seed_chgd = 1; break;
5784 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5785 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5786 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5787 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5788 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5789 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5790 case IDX_OUTFILE: outfile = optarg; break;
5791 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5792 outfile_format_chgd = 1; break;
5793 case IDX_OUTFILE_AUTOHEX_DISABLE:
5794 outfile_autohex = 0; break;
5795 case IDX_OUTFILE_CHECK_TIMER:
5796 outfile_check_timer = atoi (optarg); break;
5797 case IDX_HEX_CHARSET: hex_charset = 1; break;
5798 case IDX_HEX_SALT: hex_salt = 1; break;
5799 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5800 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5801 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5802 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5803 case IDX_OPENCL_DEVICE_TYPES:
5804 opencl_device_types = optarg; break;
5805 case IDX_OPENCL_VECTOR_WIDTH:
5806 opencl_vector_width = atoi (optarg);
5807 opencl_vector_width_chgd = 1; break;
5808 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5809 workload_profile_chgd = 1; break;
5810 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5811 kernel_accel_chgd = 1; break;
5812 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5813 kernel_loops_chgd = 1; break;
5814 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5815 #ifdef HAVE_HWMON
5816 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5817 #ifdef HAVE_ADL
5818 gpu_temp_abort_chgd = 1;
5819 #endif
5820 break;
5821 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5822 #ifdef HAVE_ADL
5823 gpu_temp_retain_chgd = 1;
5824 #endif
5825 break;
5826 #ifdef HAVE_ADL
5827 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5828 #endif
5829 #endif // HAVE_HWMON
5830 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5831 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5832 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5833 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5834 case IDX_SEPARATOR: separator = optarg[0]; break;
5835 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5836 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5837 case IDX_INCREMENT: increment = 1; break;
5838 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5839 increment_min_chgd = 1; break;
5840 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5841 increment_max_chgd = 1; break;
5842 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5843 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5844 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5845 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5846
5847 default:
5848 log_error ("ERROR: Invalid argument specified");
5849 return (-1);
5850 }
5851 }
5852
5853 if (optopt != 0)
5854 {
5855 log_error ("ERROR: Invalid argument specified");
5856
5857 return (-1);
5858 }
5859
5860 /**
5861 * Inform user things getting started,
5862 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5863 * - we do not need to check algorithm_pos
5864 */
5865
5866 if (quiet == 0)
5867 {
5868 if (benchmark == 1)
5869 {
5870 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5871
5872 log_info ("");
5873 }
5874 else if (restore == 1)
5875 {
5876 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5877
5878 log_info ("");
5879 }
5880 else
5881 {
5882 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5883
5884 log_info ("");
5885 }
5886 }
5887
5888 /**
5889 * sanity check
5890 */
5891
5892 if (attack_mode > 7)
5893 {
5894 log_error ("ERROR: Invalid attack-mode specified");
5895
5896 return (-1);
5897 }
5898
5899 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5900 {
5901 log_error ("ERROR: Invalid runtime specified");
5902
5903 return (-1);
5904 }
5905
5906 if (hash_mode_chgd && hash_mode > 13500) // just added to remove compiler warnings for hash_mode_chgd
5907 {
5908 log_error ("ERROR: Invalid hash-type specified");
5909
5910 return (-1);
5911 }
5912
5913 // renamed hash modes
5914
5915 if (hash_mode_chgd)
5916 {
5917 int n = -1;
5918
5919 switch (hash_mode)
5920 {
5921 case 123: n = 124;
5922 break;
5923 }
5924
5925 if (n >= 0)
5926 {
5927 log_error ("Old -m specified, use -m %d instead", n);
5928
5929 return (-1);
5930 }
5931 }
5932
5933 if (username == 1)
5934 {
5935 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5936 {
5937 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5938
5939 return (-1);
5940 }
5941 }
5942
5943 if (outfile_format > 16)
5944 {
5945 log_error ("ERROR: Invalid outfile-format specified");
5946
5947 return (-1);
5948 }
5949
5950 if (left == 1)
5951 {
5952 if (outfile_format_chgd == 1)
5953 {
5954 if (outfile_format > 1)
5955 {
5956 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5957
5958 return (-1);
5959 }
5960 }
5961 else
5962 {
5963 outfile_format = OUTFILE_FMT_HASH;
5964 }
5965 }
5966
5967 if (show == 1)
5968 {
5969 if (outfile_format_chgd == 1)
5970 {
5971 if ((outfile_format > 7) && (outfile_format < 16))
5972 {
5973 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5974
5975 return (-1);
5976 }
5977 }
5978 }
5979
5980 if (increment_min < INCREMENT_MIN)
5981 {
5982 log_error ("ERROR: Invalid increment-min specified");
5983
5984 return (-1);
5985 }
5986
5987 if (increment_max > INCREMENT_MAX)
5988 {
5989 log_error ("ERROR: Invalid increment-max specified");
5990
5991 return (-1);
5992 }
5993
5994 if (increment_min > increment_max)
5995 {
5996 log_error ("ERROR: Invalid increment-min specified");
5997
5998 return (-1);
5999 }
6000
6001 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6002 {
6003 log_error ("ERROR: increment is not allowed in attack-mode 0");
6004
6005 return (-1);
6006 }
6007
6008 if ((increment == 0) && (increment_min_chgd == 1))
6009 {
6010 log_error ("ERROR: increment-min is only supported together with increment switch");
6011
6012 return (-1);
6013 }
6014
6015 if ((increment == 0) && (increment_max_chgd == 1))
6016 {
6017 log_error ("ERROR: increment-max is only supported together with increment switch");
6018
6019 return (-1);
6020 }
6021
6022 if (rp_files_cnt && rp_gen)
6023 {
6024 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6025
6026 return (-1);
6027 }
6028
6029 if (rp_files_cnt || rp_gen)
6030 {
6031 if (attack_mode != ATTACK_MODE_STRAIGHT)
6032 {
6033 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6034
6035 return (-1);
6036 }
6037 }
6038
6039 if (rp_gen_func_min > rp_gen_func_max)
6040 {
6041 log_error ("ERROR: Invalid rp-gen-func-min specified");
6042
6043 return (-1);
6044 }
6045
6046 if (kernel_accel_chgd == 1)
6047 {
6048 if (kernel_accel < 1)
6049 {
6050 log_error ("ERROR: Invalid kernel-accel specified");
6051
6052 return (-1);
6053 }
6054
6055 if (kernel_accel > 1024)
6056 {
6057 log_error ("ERROR: Invalid kernel-accel specified");
6058
6059 return (-1);
6060 }
6061 }
6062
6063 if (kernel_loops_chgd == 1)
6064 {
6065 if (kernel_loops < 1)
6066 {
6067 log_error ("ERROR: Invalid kernel-loops specified");
6068
6069 return (-1);
6070 }
6071
6072 if (kernel_loops > 1024)
6073 {
6074 log_error ("ERROR: Invalid kernel-loops specified");
6075
6076 return (-1);
6077 }
6078 }
6079
6080 if ((workload_profile < 1) || (workload_profile > 3))
6081 {
6082 log_error ("ERROR: workload-profile %i not available", workload_profile);
6083
6084 return (-1);
6085 }
6086
6087 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6088 {
6089 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6090
6091 return (-1);
6092 }
6093
6094 if (show == 1 || left == 1)
6095 {
6096 attack_mode = ATTACK_MODE_NONE;
6097
6098 if (remove == 1)
6099 {
6100 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6101
6102 return (-1);
6103 }
6104
6105 if (potfile_disable == 1)
6106 {
6107 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6108
6109 return (-1);
6110 }
6111 }
6112
6113 uint attack_kern = ATTACK_KERN_NONE;
6114
6115 switch (attack_mode)
6116 {
6117 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6118 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6119 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6120 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6121 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6122 }
6123
6124 if (benchmark == 0)
6125 {
6126 if (keyspace == 1)
6127 {
6128 int num_additional_params = 1;
6129
6130 if (attack_kern == ATTACK_KERN_COMBI)
6131 {
6132 num_additional_params = 2;
6133 }
6134
6135 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6136
6137 if (keyspace_wordlist_specified == 0) optind--;
6138 }
6139
6140 if (attack_kern == ATTACK_KERN_NONE)
6141 {
6142 if ((optind + 1) != myargc)
6143 {
6144 usage_mini_print (myargv[0]);
6145
6146 return (-1);
6147 }
6148 }
6149 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6150 {
6151 if ((optind + 1) > myargc)
6152 {
6153 usage_mini_print (myargv[0]);
6154
6155 return (-1);
6156 }
6157 }
6158 else if (attack_kern == ATTACK_KERN_COMBI)
6159 {
6160 if ((optind + 3) != myargc)
6161 {
6162 usage_mini_print (myargv[0]);
6163
6164 return (-1);
6165 }
6166 }
6167 else if (attack_kern == ATTACK_KERN_BF)
6168 {
6169 if ((optind + 1) > myargc)
6170 {
6171 usage_mini_print (myargv[0]);
6172
6173 return (-1);
6174 }
6175 }
6176 else
6177 {
6178 usage_mini_print (myargv[0]);
6179
6180 return (-1);
6181 }
6182 }
6183 else
6184 {
6185 if (myargv[optind] != 0)
6186 {
6187 log_error ("ERROR: Invalid argument for benchmark mode specified");
6188
6189 return (-1);
6190 }
6191
6192 if (attack_mode_chgd == 1)
6193 {
6194 if (attack_mode != ATTACK_MODE_BF)
6195 {
6196 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6197
6198 return (-1);
6199 }
6200 }
6201 }
6202
6203 if (skip != 0 && limit != 0)
6204 {
6205 limit += skip;
6206 }
6207
6208 if (keyspace == 1)
6209 {
6210 if (show == 1)
6211 {
6212 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6213
6214 return (-1);
6215 }
6216 else if (left == 1)
6217 {
6218 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6219
6220 return (-1);
6221 }
6222
6223 potfile_disable = 1;
6224
6225 restore_disable = 1;
6226
6227 restore = 0;
6228
6229 weak_hash_threshold = 0;
6230
6231 quiet = 1;
6232 }
6233
6234 if (remove_timer_chgd == 1)
6235 {
6236 if (remove == 0)
6237 {
6238 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6239
6240 return (-1);
6241 }
6242
6243 if (remove_timer < 1)
6244 {
6245 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6246
6247 return (-1);
6248 }
6249 }
6250
6251 if (loopback == 1)
6252 {
6253 if (attack_mode == ATTACK_MODE_STRAIGHT)
6254 {
6255 if ((rp_files_cnt == 0) && (rp_gen == 0))
6256 {
6257 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6258
6259 return (-1);
6260 }
6261 }
6262 else
6263 {
6264 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6265
6266 return (-1);
6267 }
6268 }
6269
6270 if (debug_mode > 0)
6271 {
6272 if (attack_mode != ATTACK_MODE_STRAIGHT)
6273 {
6274 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6275
6276 return (-1);
6277 }
6278
6279 if ((rp_files_cnt == 0) && (rp_gen == 0))
6280 {
6281 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6282
6283 return (-1);
6284 }
6285 }
6286
6287 if (debug_mode > 4)
6288 {
6289 log_error ("ERROR: Invalid debug-mode specified");
6290
6291 return (-1);
6292 }
6293
6294 if (debug_file != NULL)
6295 {
6296 if (debug_mode < 1)
6297 {
6298 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6299
6300 return (-1);
6301 }
6302 }
6303
6304 if (induction_dir != NULL)
6305 {
6306 if (attack_mode == ATTACK_MODE_BF)
6307 {
6308 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6309
6310 return (-1);
6311 }
6312 }
6313
6314 if (attack_mode != ATTACK_MODE_STRAIGHT)
6315 {
6316 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6317 {
6318 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6319
6320 return (-1);
6321 }
6322
6323 weak_hash_threshold = 0;
6324 }
6325
6326 /**
6327 * induction directory
6328 */
6329
6330 char *induction_directory = NULL;
6331
6332 if (attack_mode != ATTACK_MODE_BF)
6333 {
6334 if (induction_dir == NULL)
6335 {
6336 induction_directory = (char *) mymalloc (session_size);
6337
6338 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6339
6340 // create induction folder if it does not already exist
6341
6342 if (keyspace == 0)
6343 {
6344 if (rmdir (induction_directory) == -1)
6345 {
6346 if (errno == ENOENT)
6347 {
6348 // good, we can ignore
6349 }
6350 else if (errno == ENOTEMPTY)
6351 {
6352 char *induction_directory_mv = (char *) mymalloc (session_size);
6353
6354 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6355
6356 if (rename (induction_directory, induction_directory_mv) != 0)
6357 {
6358 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6359
6360 return (-1);
6361 }
6362 }
6363 else
6364 {
6365 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6366
6367 return (-1);
6368 }
6369 }
6370
6371 if (mkdir (induction_directory, 0700) == -1)
6372 {
6373 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6374
6375 return (-1);
6376 }
6377 }
6378 }
6379 else
6380 {
6381 induction_directory = induction_dir;
6382 }
6383 }
6384
6385 data.induction_directory = induction_directory;
6386
6387 /**
6388 * loopback
6389 */
6390
6391 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6392
6393 char *loopback_file = (char *) mymalloc (loopback_size);
6394
6395 /**
6396 * tuning db
6397 */
6398
6399 char tuning_db_file[256] = { 0 };
6400
6401 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6402
6403 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6404
6405 /**
6406 * outfile-check directory
6407 */
6408
6409 char *outfile_check_directory = NULL;
6410
6411 if (outfile_check_dir == NULL)
6412 {
6413 outfile_check_directory = (char *) mymalloc (session_size);
6414
6415 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6416 }
6417 else
6418 {
6419 outfile_check_directory = outfile_check_dir;
6420 }
6421
6422 data.outfile_check_directory = outfile_check_directory;
6423
6424 if (keyspace == 0)
6425 {
6426 struct stat outfile_check_stat;
6427
6428 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6429 {
6430 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6431
6432 if (is_dir == 0)
6433 {
6434 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6435
6436 return (-1);
6437 }
6438 }
6439 else if (outfile_check_dir == NULL)
6440 {
6441 if (mkdir (outfile_check_directory, 0700) == -1)
6442 {
6443 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6444
6445 return (-1);
6446 }
6447 }
6448 }
6449
6450 /**
6451 * special other stuff
6452 */
6453
6454 if (hash_mode == 9710)
6455 {
6456 outfile_format = 5;
6457 outfile_format_chgd = 1;
6458 }
6459
6460 if (hash_mode == 9810)
6461 {
6462 outfile_format = 5;
6463 outfile_format_chgd = 1;
6464 }
6465
6466 if (hash_mode == 10410)
6467 {
6468 outfile_format = 5;
6469 outfile_format_chgd = 1;
6470 }
6471
6472 /**
6473 * store stuff
6474 */
6475
6476 data.hash_mode = hash_mode;
6477 data.restore = restore;
6478 data.restore_timer = restore_timer;
6479 data.restore_disable = restore_disable;
6480 data.status = status;
6481 data.status_timer = status_timer;
6482 data.status_automat = status_automat;
6483 data.loopback = loopback;
6484 data.runtime = runtime;
6485 data.remove = remove;
6486 data.remove_timer = remove_timer;
6487 data.debug_mode = debug_mode;
6488 data.debug_file = debug_file;
6489 data.username = username;
6490 data.quiet = quiet;
6491 data.outfile = outfile;
6492 data.outfile_format = outfile_format;
6493 data.outfile_autohex = outfile_autohex;
6494 data.hex_charset = hex_charset;
6495 data.hex_salt = hex_salt;
6496 data.hex_wordlist = hex_wordlist;
6497 data.separator = separator;
6498 data.rp_files = rp_files;
6499 data.rp_files_cnt = rp_files_cnt;
6500 data.rp_gen = rp_gen;
6501 data.rp_gen_seed = rp_gen_seed;
6502 data.force = force;
6503 data.benchmark = benchmark;
6504 data.skip = skip;
6505 data.limit = limit;
6506 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6507 data.powertune_enable = powertune_enable;
6508 #endif
6509 data.logfile_disable = logfile_disable;
6510 data.truecrypt_keyfiles = truecrypt_keyfiles;
6511 data.scrypt_tmto = scrypt_tmto;
6512 data.workload_profile = workload_profile;
6513
6514 /**
6515 * cpu affinity
6516 */
6517
6518 if (cpu_affinity)
6519 {
6520 set_cpu_affinity (cpu_affinity);
6521 }
6522
6523 if (rp_gen_seed_chgd == 0)
6524 {
6525 srand (proc_start);
6526 }
6527 else
6528 {
6529 srand (rp_gen_seed);
6530 }
6531
6532 /**
6533 * logfile init
6534 */
6535
6536 if (logfile_disable == 0)
6537 {
6538 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6539
6540 char *logfile = (char *) mymalloc (logfile_size);
6541
6542 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6543
6544 data.logfile = logfile;
6545
6546 char *topid = logfile_generate_topid ();
6547
6548 data.topid = topid;
6549 }
6550
6551 // logfile_append() checks for logfile_disable internally to make it easier from here
6552
6553 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6554 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6555 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6556 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6557 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6558 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6559 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6560 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6561 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6562 #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));
6563
6564 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6565 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6566 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6567 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6568 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6569 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6570 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6571 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6572
6573 logfile_top_msg ("START");
6574
6575 logfile_top_uint (attack_mode);
6576 logfile_top_uint (attack_kern);
6577 logfile_top_uint (benchmark);
6578 logfile_top_uint (bitmap_min);
6579 logfile_top_uint (bitmap_max);
6580 logfile_top_uint (debug_mode);
6581 logfile_top_uint (force);
6582 logfile_top_uint (kernel_accel);
6583 logfile_top_uint (kernel_loops);
6584 logfile_top_uint (gpu_temp_disable);
6585 #ifdef HAVE_HWMON
6586 logfile_top_uint (gpu_temp_abort);
6587 logfile_top_uint (gpu_temp_retain);
6588 #endif
6589 logfile_top_uint (hash_mode);
6590 logfile_top_uint (hex_charset);
6591 logfile_top_uint (hex_salt);
6592 logfile_top_uint (hex_wordlist);
6593 logfile_top_uint (increment);
6594 logfile_top_uint (increment_max);
6595 logfile_top_uint (increment_min);
6596 logfile_top_uint (keyspace);
6597 logfile_top_uint (left);
6598 logfile_top_uint (logfile_disable);
6599 logfile_top_uint (loopback);
6600 logfile_top_uint (markov_classic);
6601 logfile_top_uint (markov_disable);
6602 logfile_top_uint (markov_threshold);
6603 logfile_top_uint (outfile_autohex);
6604 logfile_top_uint (outfile_check_timer);
6605 logfile_top_uint (outfile_format);
6606 logfile_top_uint (potfile_disable);
6607 logfile_top_string (potfile_path);
6608 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6609 logfile_top_uint (powertune_enable);
6610 #endif
6611 logfile_top_uint (scrypt_tmto);
6612 logfile_top_uint (quiet);
6613 logfile_top_uint (remove);
6614 logfile_top_uint (remove_timer);
6615 logfile_top_uint (restore);
6616 logfile_top_uint (restore_disable);
6617 logfile_top_uint (restore_timer);
6618 logfile_top_uint (rp_gen);
6619 logfile_top_uint (rp_gen_func_max);
6620 logfile_top_uint (rp_gen_func_min);
6621 logfile_top_uint (rp_gen_seed);
6622 logfile_top_uint (runtime);
6623 logfile_top_uint (segment_size);
6624 logfile_top_uint (show);
6625 logfile_top_uint (status);
6626 logfile_top_uint (status_automat);
6627 logfile_top_uint (status_timer);
6628 logfile_top_uint (usage);
6629 logfile_top_uint (username);
6630 logfile_top_uint (version);
6631 logfile_top_uint (weak_hash_threshold);
6632 logfile_top_uint (workload_profile);
6633 logfile_top_uint64 (limit);
6634 logfile_top_uint64 (skip);
6635 logfile_top_char (separator);
6636 logfile_top_string (cpu_affinity);
6637 logfile_top_string (custom_charset_1);
6638 logfile_top_string (custom_charset_2);
6639 logfile_top_string (custom_charset_3);
6640 logfile_top_string (custom_charset_4);
6641 logfile_top_string (debug_file);
6642 logfile_top_string (opencl_devices);
6643 logfile_top_string (opencl_platforms);
6644 logfile_top_string (opencl_device_types);
6645 logfile_top_uint (opencl_vector_width);
6646 logfile_top_string (induction_dir);
6647 logfile_top_string (markov_hcstat);
6648 logfile_top_string (outfile);
6649 logfile_top_string (outfile_check_dir);
6650 logfile_top_string (rule_buf_l);
6651 logfile_top_string (rule_buf_r);
6652 logfile_top_string (session);
6653 logfile_top_string (truecrypt_keyfiles);
6654
6655 /**
6656 * Init OpenCL library loader
6657 */
6658
6659 if (keyspace == 0)
6660 {
6661 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6662
6663 ocl_init (ocl);
6664
6665 data.ocl = ocl;
6666 }
6667
6668 /**
6669 * OpenCL platform selection
6670 */
6671
6672 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6673
6674 /**
6675 * OpenCL device selection
6676 */
6677
6678 u32 devices_filter = setup_devices_filter (opencl_devices);
6679
6680 /**
6681 * OpenCL device type selection
6682 */
6683
6684 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6685
6686 /**
6687 * benchmark
6688 */
6689
6690 if (benchmark == 1)
6691 {
6692 /**
6693 * disable useless stuff for benchmark
6694 */
6695
6696 status_timer = 0;
6697 restore_timer = 0;
6698 restore_disable = 1;
6699 potfile_disable = 1;
6700 weak_hash_threshold = 0;
6701 gpu_temp_disable = 1;
6702
6703 data.status_timer = status_timer;
6704 data.restore_timer = restore_timer;
6705 data.restore_disable = restore_disable;
6706
6707 /**
6708 * force attack mode to be bruteforce
6709 */
6710
6711 attack_mode = ATTACK_MODE_BF;
6712 attack_kern = ATTACK_KERN_BF;
6713
6714 if (workload_profile_chgd == 0)
6715 {
6716 workload_profile = 3;
6717
6718 data.workload_profile = workload_profile;
6719 }
6720 }
6721
6722 /**
6723 * config
6724 */
6725
6726 uint hash_type = 0;
6727 uint salt_type = 0;
6728 uint attack_exec = 0;
6729 uint opts_type = 0;
6730 uint kern_type = 0;
6731 uint dgst_size = 0;
6732 uint esalt_size = 0;
6733 uint opti_type = 0;
6734 uint dgst_pos0 = -1;
6735 uint dgst_pos1 = -1;
6736 uint dgst_pos2 = -1;
6737 uint dgst_pos3 = -1;
6738
6739 int (*parse_func) (char *, uint, hash_t *);
6740 int (*sort_by_digest) (const void *, const void *);
6741
6742 uint algorithm_pos = 0;
6743 uint algorithm_max = 1;
6744
6745 uint *algorithms = default_benchmark_algorithms;
6746
6747 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6748
6749 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6750 {
6751 /*
6752 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6753 * the following algos are skipped entirely
6754 */
6755
6756 if (algorithm_pos > 0)
6757 {
6758 local_free (rd);
6759
6760 rd = init_restore (argc, argv);
6761
6762 data.rd = rd;
6763 }
6764
6765 /**
6766 * update hash_mode in case of multihash benchmark
6767 */
6768
6769 if (benchmark == 1)
6770 {
6771 if (hash_mode_chgd == 0)
6772 {
6773 hash_mode = algorithms[algorithm_pos];
6774
6775 data.hash_mode = hash_mode;
6776 }
6777
6778 quiet = 1;
6779
6780 data.quiet = quiet;
6781 }
6782
6783 switch (hash_mode)
6784 {
6785 case 0: hash_type = HASH_TYPE_MD5;
6786 salt_type = SALT_TYPE_NONE;
6787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6788 opts_type = OPTS_TYPE_PT_GENERATE_LE
6789 | OPTS_TYPE_PT_ADD80
6790 | OPTS_TYPE_PT_ADDBITS14;
6791 kern_type = KERN_TYPE_MD5;
6792 dgst_size = DGST_SIZE_4_4;
6793 parse_func = md5_parse_hash;
6794 sort_by_digest = sort_by_digest_4_4;
6795 opti_type = OPTI_TYPE_ZERO_BYTE
6796 | OPTI_TYPE_PRECOMPUTE_INIT
6797 | OPTI_TYPE_PRECOMPUTE_MERKLE
6798 | OPTI_TYPE_MEET_IN_MIDDLE
6799 | OPTI_TYPE_EARLY_SKIP
6800 | OPTI_TYPE_NOT_ITERATED
6801 | OPTI_TYPE_NOT_SALTED
6802 | OPTI_TYPE_RAW_HASH;
6803 dgst_pos0 = 0;
6804 dgst_pos1 = 3;
6805 dgst_pos2 = 2;
6806 dgst_pos3 = 1;
6807 break;
6808
6809 case 10: hash_type = HASH_TYPE_MD5;
6810 salt_type = SALT_TYPE_INTERN;
6811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6812 opts_type = OPTS_TYPE_PT_GENERATE_LE
6813 | OPTS_TYPE_ST_ADD80
6814 | OPTS_TYPE_ST_ADDBITS14;
6815 kern_type = KERN_TYPE_MD5_PWSLT;
6816 dgst_size = DGST_SIZE_4_4;
6817 parse_func = md5s_parse_hash;
6818 sort_by_digest = sort_by_digest_4_4;
6819 opti_type = OPTI_TYPE_ZERO_BYTE
6820 | OPTI_TYPE_PRECOMPUTE_INIT
6821 | OPTI_TYPE_PRECOMPUTE_MERKLE
6822 | OPTI_TYPE_MEET_IN_MIDDLE
6823 | OPTI_TYPE_EARLY_SKIP
6824 | OPTI_TYPE_NOT_ITERATED
6825 | OPTI_TYPE_APPENDED_SALT
6826 | OPTI_TYPE_RAW_HASH;
6827 dgst_pos0 = 0;
6828 dgst_pos1 = 3;
6829 dgst_pos2 = 2;
6830 dgst_pos3 = 1;
6831 break;
6832
6833 case 11: hash_type = HASH_TYPE_MD5;
6834 salt_type = SALT_TYPE_INTERN;
6835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6836 opts_type = OPTS_TYPE_PT_GENERATE_LE
6837 | OPTS_TYPE_ST_ADD80
6838 | OPTS_TYPE_ST_ADDBITS14;
6839 kern_type = KERN_TYPE_MD5_PWSLT;
6840 dgst_size = DGST_SIZE_4_4;
6841 parse_func = joomla_parse_hash;
6842 sort_by_digest = sort_by_digest_4_4;
6843 opti_type = OPTI_TYPE_ZERO_BYTE
6844 | OPTI_TYPE_PRECOMPUTE_INIT
6845 | OPTI_TYPE_PRECOMPUTE_MERKLE
6846 | OPTI_TYPE_MEET_IN_MIDDLE
6847 | OPTI_TYPE_EARLY_SKIP
6848 | OPTI_TYPE_NOT_ITERATED
6849 | OPTI_TYPE_APPENDED_SALT
6850 | OPTI_TYPE_RAW_HASH;
6851 dgst_pos0 = 0;
6852 dgst_pos1 = 3;
6853 dgst_pos2 = 2;
6854 dgst_pos3 = 1;
6855 break;
6856
6857 case 12: hash_type = HASH_TYPE_MD5;
6858 salt_type = SALT_TYPE_INTERN;
6859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6860 opts_type = OPTS_TYPE_PT_GENERATE_LE
6861 | OPTS_TYPE_ST_ADD80
6862 | OPTS_TYPE_ST_ADDBITS14;
6863 kern_type = KERN_TYPE_MD5_PWSLT;
6864 dgst_size = DGST_SIZE_4_4;
6865 parse_func = postgresql_parse_hash;
6866 sort_by_digest = sort_by_digest_4_4;
6867 opti_type = OPTI_TYPE_ZERO_BYTE
6868 | OPTI_TYPE_PRECOMPUTE_INIT
6869 | OPTI_TYPE_PRECOMPUTE_MERKLE
6870 | OPTI_TYPE_MEET_IN_MIDDLE
6871 | OPTI_TYPE_EARLY_SKIP
6872 | OPTI_TYPE_NOT_ITERATED
6873 | OPTI_TYPE_APPENDED_SALT
6874 | OPTI_TYPE_RAW_HASH;
6875 dgst_pos0 = 0;
6876 dgst_pos1 = 3;
6877 dgst_pos2 = 2;
6878 dgst_pos3 = 1;
6879 break;
6880
6881 case 20: hash_type = HASH_TYPE_MD5;
6882 salt_type = SALT_TYPE_INTERN;
6883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6884 opts_type = OPTS_TYPE_PT_GENERATE_LE
6885 | OPTS_TYPE_PT_ADD80
6886 | OPTS_TYPE_PT_ADDBITS14;
6887 kern_type = KERN_TYPE_MD5_SLTPW;
6888 dgst_size = DGST_SIZE_4_4;
6889 parse_func = md5s_parse_hash;
6890 sort_by_digest = sort_by_digest_4_4;
6891 opti_type = OPTI_TYPE_ZERO_BYTE
6892 | OPTI_TYPE_PRECOMPUTE_INIT
6893 | OPTI_TYPE_PRECOMPUTE_MERKLE
6894 | OPTI_TYPE_EARLY_SKIP
6895 | OPTI_TYPE_NOT_ITERATED
6896 | OPTI_TYPE_PREPENDED_SALT
6897 | OPTI_TYPE_RAW_HASH;
6898 dgst_pos0 = 0;
6899 dgst_pos1 = 3;
6900 dgst_pos2 = 2;
6901 dgst_pos3 = 1;
6902 break;
6903
6904 case 21: hash_type = HASH_TYPE_MD5;
6905 salt_type = SALT_TYPE_INTERN;
6906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6907 opts_type = OPTS_TYPE_PT_GENERATE_LE
6908 | OPTS_TYPE_PT_ADD80
6909 | OPTS_TYPE_PT_ADDBITS14;
6910 kern_type = KERN_TYPE_MD5_SLTPW;
6911 dgst_size = DGST_SIZE_4_4;
6912 parse_func = osc_parse_hash;
6913 sort_by_digest = sort_by_digest_4_4;
6914 opti_type = OPTI_TYPE_ZERO_BYTE
6915 | OPTI_TYPE_PRECOMPUTE_INIT
6916 | OPTI_TYPE_PRECOMPUTE_MERKLE
6917 | OPTI_TYPE_EARLY_SKIP
6918 | OPTI_TYPE_NOT_ITERATED
6919 | OPTI_TYPE_PREPENDED_SALT
6920 | OPTI_TYPE_RAW_HASH;
6921 dgst_pos0 = 0;
6922 dgst_pos1 = 3;
6923 dgst_pos2 = 2;
6924 dgst_pos3 = 1;
6925 break;
6926
6927 case 22: hash_type = HASH_TYPE_MD5;
6928 salt_type = SALT_TYPE_EMBEDDED;
6929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6930 opts_type = OPTS_TYPE_PT_GENERATE_LE
6931 | OPTS_TYPE_PT_ADD80
6932 | OPTS_TYPE_PT_ADDBITS14;
6933 kern_type = KERN_TYPE_MD5_SLTPW;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = netscreen_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_PRECOMPUTE_INIT
6939 | OPTI_TYPE_PRECOMPUTE_MERKLE
6940 | OPTI_TYPE_EARLY_SKIP
6941 | OPTI_TYPE_NOT_ITERATED
6942 | OPTI_TYPE_PREPENDED_SALT
6943 | OPTI_TYPE_RAW_HASH;
6944 dgst_pos0 = 0;
6945 dgst_pos1 = 3;
6946 dgst_pos2 = 2;
6947 dgst_pos3 = 1;
6948 break;
6949
6950 case 23: hash_type = HASH_TYPE_MD5;
6951 salt_type = SALT_TYPE_EMBEDDED;
6952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6953 opts_type = OPTS_TYPE_PT_GENERATE_LE
6954 | OPTS_TYPE_PT_ADD80
6955 | OPTS_TYPE_PT_ADDBITS14;
6956 kern_type = KERN_TYPE_MD5_SLTPW;
6957 dgst_size = DGST_SIZE_4_4;
6958 parse_func = skype_parse_hash;
6959 sort_by_digest = sort_by_digest_4_4;
6960 opti_type = OPTI_TYPE_ZERO_BYTE
6961 | OPTI_TYPE_PRECOMPUTE_INIT
6962 | OPTI_TYPE_PRECOMPUTE_MERKLE
6963 | OPTI_TYPE_EARLY_SKIP
6964 | OPTI_TYPE_NOT_ITERATED
6965 | OPTI_TYPE_PREPENDED_SALT
6966 | OPTI_TYPE_RAW_HASH;
6967 dgst_pos0 = 0;
6968 dgst_pos1 = 3;
6969 dgst_pos2 = 2;
6970 dgst_pos3 = 1;
6971 break;
6972
6973 case 30: hash_type = HASH_TYPE_MD5;
6974 salt_type = SALT_TYPE_INTERN;
6975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6976 opts_type = OPTS_TYPE_PT_GENERATE_LE
6977 | OPTS_TYPE_PT_UNICODE
6978 | OPTS_TYPE_ST_ADD80
6979 | OPTS_TYPE_ST_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_PWUSLT;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = md5s_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_MEET_IN_MIDDLE
6988 | OPTI_TYPE_EARLY_SKIP
6989 | OPTI_TYPE_NOT_ITERATED
6990 | OPTI_TYPE_APPENDED_SALT
6991 | OPTI_TYPE_RAW_HASH;
6992 dgst_pos0 = 0;
6993 dgst_pos1 = 3;
6994 dgst_pos2 = 2;
6995 dgst_pos3 = 1;
6996 break;
6997
6998 case 40: hash_type = HASH_TYPE_MD5;
6999 salt_type = SALT_TYPE_INTERN;
7000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7001 opts_type = OPTS_TYPE_PT_GENERATE_LE
7002 | OPTS_TYPE_PT_ADD80
7003 | OPTS_TYPE_PT_ADDBITS14
7004 | OPTS_TYPE_PT_UNICODE;
7005 kern_type = KERN_TYPE_MD5_SLTPWU;
7006 dgst_size = DGST_SIZE_4_4;
7007 parse_func = md5s_parse_hash;
7008 sort_by_digest = sort_by_digest_4_4;
7009 opti_type = OPTI_TYPE_ZERO_BYTE
7010 | OPTI_TYPE_PRECOMPUTE_INIT
7011 | OPTI_TYPE_PRECOMPUTE_MERKLE
7012 | OPTI_TYPE_EARLY_SKIP
7013 | OPTI_TYPE_NOT_ITERATED
7014 | OPTI_TYPE_PREPENDED_SALT
7015 | OPTI_TYPE_RAW_HASH;
7016 dgst_pos0 = 0;
7017 dgst_pos1 = 3;
7018 dgst_pos2 = 2;
7019 dgst_pos3 = 1;
7020 break;
7021
7022 case 50: hash_type = HASH_TYPE_MD5;
7023 salt_type = SALT_TYPE_INTERN;
7024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7025 opts_type = OPTS_TYPE_PT_GENERATE_LE
7026 | OPTS_TYPE_ST_ADD80
7027 | OPTS_TYPE_ST_ADDBITS14;
7028 kern_type = KERN_TYPE_HMACMD5_PW;
7029 dgst_size = DGST_SIZE_4_4;
7030 parse_func = hmacmd5_parse_hash;
7031 sort_by_digest = sort_by_digest_4_4;
7032 opti_type = OPTI_TYPE_ZERO_BYTE
7033 | OPTI_TYPE_NOT_ITERATED;
7034 dgst_pos0 = 0;
7035 dgst_pos1 = 3;
7036 dgst_pos2 = 2;
7037 dgst_pos3 = 1;
7038 break;
7039
7040 case 60: hash_type = HASH_TYPE_MD5;
7041 salt_type = SALT_TYPE_INTERN;
7042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7043 opts_type = OPTS_TYPE_PT_GENERATE_LE
7044 | OPTS_TYPE_PT_ADD80
7045 | OPTS_TYPE_PT_ADDBITS14;
7046 kern_type = KERN_TYPE_HMACMD5_SLT;
7047 dgst_size = DGST_SIZE_4_4;
7048 parse_func = hmacmd5_parse_hash;
7049 sort_by_digest = sort_by_digest_4_4;
7050 opti_type = OPTI_TYPE_ZERO_BYTE
7051 | OPTI_TYPE_NOT_ITERATED;
7052 dgst_pos0 = 0;
7053 dgst_pos1 = 3;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 100: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_NONE;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_PT_ADD80
7063 | OPTS_TYPE_PT_ADDBITS15;
7064 kern_type = KERN_TYPE_SHA1;
7065 dgst_size = DGST_SIZE_4_5;
7066 parse_func = sha1_parse_hash;
7067 sort_by_digest = sort_by_digest_4_5;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_NOT_SALTED
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 3;
7076 dgst_pos1 = 4;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 101: hash_type = HASH_TYPE_SHA1;
7082 salt_type = SALT_TYPE_NONE;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_BE
7085 | OPTS_TYPE_PT_ADD80
7086 | OPTS_TYPE_PT_ADDBITS15;
7087 kern_type = KERN_TYPE_SHA1;
7088 dgst_size = DGST_SIZE_4_5;
7089 parse_func = sha1b64_parse_hash;
7090 sort_by_digest = sort_by_digest_4_5;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_EARLY_SKIP
7095 | OPTI_TYPE_NOT_ITERATED
7096 | OPTI_TYPE_NOT_SALTED
7097 | OPTI_TYPE_RAW_HASH;
7098 dgst_pos0 = 3;
7099 dgst_pos1 = 4;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 110: hash_type = HASH_TYPE_SHA1;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_BE
7108 | OPTS_TYPE_ST_ADD80
7109 | OPTS_TYPE_ST_ADDBITS15;
7110 kern_type = KERN_TYPE_SHA1_PWSLT;
7111 dgst_size = DGST_SIZE_4_5;
7112 parse_func = sha1s_parse_hash;
7113 sort_by_digest = sort_by_digest_4_5;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_PRECOMPUTE_INIT
7116 | OPTI_TYPE_PRECOMPUTE_MERKLE
7117 | OPTI_TYPE_EARLY_SKIP
7118 | OPTI_TYPE_NOT_ITERATED
7119 | OPTI_TYPE_APPENDED_SALT
7120 | OPTI_TYPE_RAW_HASH;
7121 dgst_pos0 = 3;
7122 dgst_pos1 = 4;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 111: hash_type = HASH_TYPE_SHA1;
7128 salt_type = SALT_TYPE_EMBEDDED;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_BE
7131 | OPTS_TYPE_ST_ADD80
7132 | OPTS_TYPE_ST_ADDBITS15;
7133 kern_type = KERN_TYPE_SHA1_PWSLT;
7134 dgst_size = DGST_SIZE_4_5;
7135 parse_func = sha1b64s_parse_hash;
7136 sort_by_digest = sort_by_digest_4_5;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_PRECOMPUTE_MERKLE
7140 | OPTI_TYPE_EARLY_SKIP
7141 | OPTI_TYPE_NOT_ITERATED
7142 | OPTI_TYPE_APPENDED_SALT
7143 | OPTI_TYPE_RAW_HASH;
7144 dgst_pos0 = 3;
7145 dgst_pos1 = 4;
7146 dgst_pos2 = 2;
7147 dgst_pos3 = 1;
7148 break;
7149
7150 case 112: hash_type = HASH_TYPE_SHA1;
7151 salt_type = SALT_TYPE_INTERN;
7152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7153 opts_type = OPTS_TYPE_PT_GENERATE_BE
7154 | OPTS_TYPE_ST_ADD80
7155 | OPTS_TYPE_ST_ADDBITS15
7156 | OPTS_TYPE_ST_HEX;
7157 kern_type = KERN_TYPE_SHA1_PWSLT;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = oracles_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_APPENDED_SALT
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 120: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_INTERN;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_PT_ADD80
7179 | OPTS_TYPE_PT_ADDBITS15;
7180 kern_type = KERN_TYPE_SHA1_SLTPW;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = sha1s_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_PREPENDED_SALT
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 121: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_INTERN;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_PT_ADD80
7202 | OPTS_TYPE_PT_ADDBITS15
7203 | OPTS_TYPE_ST_LOWER;
7204 kern_type = KERN_TYPE_SHA1_SLTPW;
7205 dgst_size = DGST_SIZE_4_5;
7206 parse_func = smf_parse_hash;
7207 sort_by_digest = sort_by_digest_4_5;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_PREPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 3;
7216 dgst_pos1 = 4;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 122: hash_type = HASH_TYPE_SHA1;
7222 salt_type = SALT_TYPE_EMBEDDED;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_BE
7225 | OPTS_TYPE_PT_ADD80
7226 | OPTS_TYPE_PT_ADDBITS15
7227 | OPTS_TYPE_ST_HEX;
7228 kern_type = KERN_TYPE_SHA1_SLTPW;
7229 dgst_size = DGST_SIZE_4_5;
7230 parse_func = osx1_parse_hash;
7231 sort_by_digest = sort_by_digest_4_5;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_PREPENDED_SALT
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 3;
7240 dgst_pos1 = 4;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 1;
7243 break;
7244
7245 case 124: hash_type = HASH_TYPE_SHA1;
7246 salt_type = SALT_TYPE_EMBEDDED;
7247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7248 opts_type = OPTS_TYPE_PT_GENERATE_BE
7249 | OPTS_TYPE_PT_ADD80
7250 | OPTS_TYPE_PT_ADDBITS15;
7251 kern_type = KERN_TYPE_SHA1_SLTPW;
7252 dgst_size = DGST_SIZE_4_5;
7253 parse_func = djangosha1_parse_hash;
7254 sort_by_digest = sort_by_digest_4_5;
7255 opti_type = OPTI_TYPE_ZERO_BYTE
7256 | OPTI_TYPE_PRECOMPUTE_INIT
7257 | OPTI_TYPE_PRECOMPUTE_MERKLE
7258 | OPTI_TYPE_EARLY_SKIP
7259 | OPTI_TYPE_NOT_ITERATED
7260 | OPTI_TYPE_PREPENDED_SALT
7261 | OPTI_TYPE_RAW_HASH;
7262 dgst_pos0 = 3;
7263 dgst_pos1 = 4;
7264 dgst_pos2 = 2;
7265 dgst_pos3 = 1;
7266 break;
7267
7268 case 125: hash_type = HASH_TYPE_SHA1;
7269 salt_type = SALT_TYPE_EMBEDDED;
7270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7271 opts_type = OPTS_TYPE_PT_GENERATE_BE
7272 | OPTS_TYPE_PT_ADD80
7273 | OPTS_TYPE_PT_ADDBITS15
7274 | OPTS_TYPE_ST_HEX;
7275 kern_type = KERN_TYPE_SHA1_SLTPW;
7276 dgst_size = DGST_SIZE_4_5;
7277 parse_func = arubaos_parse_hash;
7278 sort_by_digest = sort_by_digest_4_5;
7279 opti_type = OPTI_TYPE_ZERO_BYTE
7280 | OPTI_TYPE_PRECOMPUTE_INIT
7281 | OPTI_TYPE_PRECOMPUTE_MERKLE
7282 | OPTI_TYPE_EARLY_SKIP
7283 | OPTI_TYPE_NOT_ITERATED
7284 | OPTI_TYPE_PREPENDED_SALT
7285 | OPTI_TYPE_RAW_HASH;
7286 dgst_pos0 = 3;
7287 dgst_pos1 = 4;
7288 dgst_pos2 = 2;
7289 dgst_pos3 = 1;
7290 break;
7291
7292 case 130: hash_type = HASH_TYPE_SHA1;
7293 salt_type = SALT_TYPE_INTERN;
7294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7295 opts_type = OPTS_TYPE_PT_GENERATE_BE
7296 | OPTS_TYPE_PT_UNICODE
7297 | OPTS_TYPE_ST_ADD80
7298 | OPTS_TYPE_ST_ADDBITS15;
7299 kern_type = KERN_TYPE_SHA1_PWUSLT;
7300 dgst_size = DGST_SIZE_4_5;
7301 parse_func = sha1s_parse_hash;
7302 sort_by_digest = sort_by_digest_4_5;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_PRECOMPUTE_INIT
7305 | OPTI_TYPE_PRECOMPUTE_MERKLE
7306 | OPTI_TYPE_EARLY_SKIP
7307 | OPTI_TYPE_NOT_ITERATED
7308 | OPTI_TYPE_APPENDED_SALT
7309 | OPTI_TYPE_RAW_HASH;
7310 dgst_pos0 = 3;
7311 dgst_pos1 = 4;
7312 dgst_pos2 = 2;
7313 dgst_pos3 = 1;
7314 break;
7315
7316 case 131: hash_type = HASH_TYPE_SHA1;
7317 salt_type = SALT_TYPE_EMBEDDED;
7318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7319 opts_type = OPTS_TYPE_PT_GENERATE_BE
7320 | OPTS_TYPE_PT_UNICODE
7321 | OPTS_TYPE_PT_UPPER
7322 | OPTS_TYPE_ST_ADD80
7323 | OPTS_TYPE_ST_ADDBITS15
7324 | OPTS_TYPE_ST_HEX;
7325 kern_type = KERN_TYPE_SHA1_PWUSLT;
7326 dgst_size = DGST_SIZE_4_5;
7327 parse_func = mssql2000_parse_hash;
7328 sort_by_digest = sort_by_digest_4_5;
7329 opti_type = OPTI_TYPE_ZERO_BYTE
7330 | OPTI_TYPE_PRECOMPUTE_INIT
7331 | OPTI_TYPE_PRECOMPUTE_MERKLE
7332 | OPTI_TYPE_EARLY_SKIP
7333 | OPTI_TYPE_NOT_ITERATED
7334 | OPTI_TYPE_APPENDED_SALT
7335 | OPTI_TYPE_RAW_HASH;
7336 dgst_pos0 = 3;
7337 dgst_pos1 = 4;
7338 dgst_pos2 = 2;
7339 dgst_pos3 = 1;
7340 break;
7341
7342 case 132: hash_type = HASH_TYPE_SHA1;
7343 salt_type = SALT_TYPE_EMBEDDED;
7344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7345 opts_type = OPTS_TYPE_PT_GENERATE_BE
7346 | OPTS_TYPE_PT_UNICODE
7347 | OPTS_TYPE_ST_ADD80
7348 | OPTS_TYPE_ST_ADDBITS15
7349 | OPTS_TYPE_ST_HEX;
7350 kern_type = KERN_TYPE_SHA1_PWUSLT;
7351 dgst_size = DGST_SIZE_4_5;
7352 parse_func = mssql2005_parse_hash;
7353 sort_by_digest = sort_by_digest_4_5;
7354 opti_type = OPTI_TYPE_ZERO_BYTE
7355 | OPTI_TYPE_PRECOMPUTE_INIT
7356 | OPTI_TYPE_PRECOMPUTE_MERKLE
7357 | OPTI_TYPE_EARLY_SKIP
7358 | OPTI_TYPE_NOT_ITERATED
7359 | OPTI_TYPE_APPENDED_SALT
7360 | OPTI_TYPE_RAW_HASH;
7361 dgst_pos0 = 3;
7362 dgst_pos1 = 4;
7363 dgst_pos2 = 2;
7364 dgst_pos3 = 1;
7365 break;
7366
7367 case 133: hash_type = HASH_TYPE_SHA1;
7368 salt_type = SALT_TYPE_EMBEDDED;
7369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7370 opts_type = OPTS_TYPE_PT_GENERATE_BE
7371 | OPTS_TYPE_PT_UNICODE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA1_PWUSLT;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = peoplesoft_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 140: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_ADD80
7396 | OPTS_TYPE_PT_ADDBITS15
7397 | OPTS_TYPE_PT_UNICODE;
7398 kern_type = KERN_TYPE_SHA1_SLTPWU;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = sha1s_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_PREPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 4;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 1;
7413 break;
7414
7415 case 141: hash_type = HASH_TYPE_SHA1;
7416 salt_type = SALT_TYPE_EMBEDDED;
7417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_ADD80
7420 | OPTS_TYPE_PT_ADDBITS15
7421 | OPTS_TYPE_PT_UNICODE
7422 | OPTS_TYPE_ST_BASE64;
7423 kern_type = KERN_TYPE_SHA1_SLTPWU;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = episerver_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_PREPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 150: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_INTERN;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_ST_ADD80
7445 | OPTS_TYPE_ST_ADDBITS15;
7446 kern_type = KERN_TYPE_HMACSHA1_PW;
7447 dgst_size = DGST_SIZE_4_5;
7448 parse_func = hmacsha1_parse_hash;
7449 sort_by_digest = sort_by_digest_4_5;
7450 opti_type = OPTI_TYPE_ZERO_BYTE
7451 | OPTI_TYPE_NOT_ITERATED;
7452 dgst_pos0 = 3;
7453 dgst_pos1 = 4;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 1;
7456 break;
7457
7458 case 160: hash_type = HASH_TYPE_SHA1;
7459 salt_type = SALT_TYPE_INTERN;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_BE
7462 | OPTS_TYPE_PT_ADD80
7463 | OPTS_TYPE_PT_ADDBITS15;
7464 kern_type = KERN_TYPE_HMACSHA1_SLT;
7465 dgst_size = DGST_SIZE_4_5;
7466 parse_func = hmacsha1_parse_hash;
7467 sort_by_digest = sort_by_digest_4_5;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_NOT_ITERATED;
7470 dgst_pos0 = 3;
7471 dgst_pos1 = 4;
7472 dgst_pos2 = 2;
7473 dgst_pos3 = 1;
7474 break;
7475
7476 case 190: hash_type = HASH_TYPE_SHA1;
7477 salt_type = SALT_TYPE_NONE;
7478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7479 opts_type = OPTS_TYPE_PT_GENERATE_BE
7480 | OPTS_TYPE_PT_ADD80
7481 | OPTS_TYPE_PT_ADDBITS15;
7482 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7483 dgst_size = DGST_SIZE_4_5;
7484 parse_func = sha1linkedin_parse_hash;
7485 sort_by_digest = sort_by_digest_4_5;
7486 opti_type = OPTI_TYPE_ZERO_BYTE
7487 | OPTI_TYPE_PRECOMPUTE_INIT
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_NOT_SALTED;
7491 dgst_pos0 = 0;
7492 dgst_pos1 = 4;
7493 dgst_pos2 = 3;
7494 dgst_pos3 = 2;
7495 break;
7496
7497 case 200: hash_type = HASH_TYPE_MYSQL;
7498 salt_type = SALT_TYPE_NONE;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = 0;
7501 kern_type = KERN_TYPE_MYSQL;
7502 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7503 parse_func = mysql323_parse_hash;
7504 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7505 opti_type = OPTI_TYPE_ZERO_BYTE;
7506 dgst_pos0 = 0;
7507 dgst_pos1 = 1;
7508 dgst_pos2 = 2;
7509 dgst_pos3 = 3;
7510 break;
7511
7512 case 300: hash_type = HASH_TYPE_SHA1;
7513 salt_type = SALT_TYPE_NONE;
7514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7515 opts_type = OPTS_TYPE_PT_GENERATE_BE
7516 | OPTS_TYPE_PT_ADD80
7517 | OPTS_TYPE_PT_ADDBITS15;
7518 kern_type = KERN_TYPE_MYSQL41;
7519 dgst_size = DGST_SIZE_4_5;
7520 parse_func = sha1_parse_hash;
7521 sort_by_digest = sort_by_digest_4_5;
7522 opti_type = OPTI_TYPE_ZERO_BYTE
7523 | OPTI_TYPE_PRECOMPUTE_INIT
7524 | OPTI_TYPE_PRECOMPUTE_MERKLE
7525 | OPTI_TYPE_EARLY_SKIP
7526 | OPTI_TYPE_NOT_ITERATED
7527 | OPTI_TYPE_NOT_SALTED;
7528 dgst_pos0 = 3;
7529 dgst_pos1 = 4;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 400: hash_type = HASH_TYPE_MD5;
7535 salt_type = SALT_TYPE_EMBEDDED;
7536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7538 kern_type = KERN_TYPE_PHPASS;
7539 dgst_size = DGST_SIZE_4_4;
7540 parse_func = phpass_parse_hash;
7541 sort_by_digest = sort_by_digest_4_4;
7542 opti_type = OPTI_TYPE_ZERO_BYTE
7543 | OPTI_TYPE_SLOW_HASH_SIMD;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 1;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 3;
7548 break;
7549
7550 case 500: hash_type = HASH_TYPE_MD5;
7551 salt_type = SALT_TYPE_EMBEDDED;
7552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7554 kern_type = KERN_TYPE_MD5CRYPT;
7555 dgst_size = DGST_SIZE_4_4;
7556 parse_func = md5crypt_parse_hash;
7557 sort_by_digest = sort_by_digest_4_4;
7558 opti_type = OPTI_TYPE_ZERO_BYTE;
7559 dgst_pos0 = 0;
7560 dgst_pos1 = 1;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 3;
7563 break;
7564
7565 case 501: hash_type = HASH_TYPE_MD5;
7566 salt_type = SALT_TYPE_EMBEDDED;
7567 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_LE
7569 | OPTS_TYPE_HASH_COPY;
7570 kern_type = KERN_TYPE_MD5CRYPT;
7571 dgst_size = DGST_SIZE_4_4;
7572 parse_func = juniper_parse_hash;
7573 sort_by_digest = sort_by_digest_4_4;
7574 opti_type = OPTI_TYPE_ZERO_BYTE;
7575 dgst_pos0 = 0;
7576 dgst_pos1 = 1;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 3;
7579 break;
7580
7581 case 900: hash_type = HASH_TYPE_MD4;
7582 salt_type = SALT_TYPE_NONE;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS14;
7587 kern_type = KERN_TYPE_MD4;
7588 dgst_size = DGST_SIZE_4_4;
7589 parse_func = md4_parse_hash;
7590 sort_by_digest = sort_by_digest_4_4;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_PRECOMPUTE_MERKLE
7594 | OPTI_TYPE_MEET_IN_MIDDLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_NOT_SALTED
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 3;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 1000: hash_type = HASH_TYPE_MD4;
7606 salt_type = SALT_TYPE_NONE;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE
7609 | OPTS_TYPE_PT_ADD80
7610 | OPTS_TYPE_PT_ADDBITS14
7611 | OPTS_TYPE_PT_UNICODE;
7612 kern_type = KERN_TYPE_MD4_PWU;
7613 dgst_size = DGST_SIZE_4_4;
7614 parse_func = md4_parse_hash;
7615 sort_by_digest = sort_by_digest_4_4;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_MEET_IN_MIDDLE
7620 | OPTI_TYPE_EARLY_SKIP
7621 | OPTI_TYPE_NOT_ITERATED
7622 | OPTI_TYPE_NOT_SALTED
7623 | OPTI_TYPE_RAW_HASH;
7624 dgst_pos0 = 0;
7625 dgst_pos1 = 3;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 1;
7628 break;
7629
7630 case 1100: hash_type = HASH_TYPE_MD4;
7631 salt_type = SALT_TYPE_INTERN;
7632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_LE
7634 | OPTS_TYPE_PT_ADD80
7635 | OPTS_TYPE_PT_ADDBITS14
7636 | OPTS_TYPE_PT_UNICODE
7637 | OPTS_TYPE_ST_ADD80
7638 | OPTS_TYPE_ST_UNICODE
7639 | OPTS_TYPE_ST_LOWER;
7640 kern_type = KERN_TYPE_MD44_PWUSLT;
7641 dgst_size = DGST_SIZE_4_4;
7642 parse_func = dcc_parse_hash;
7643 sort_by_digest = sort_by_digest_4_4;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED;
7649 dgst_pos0 = 0;
7650 dgst_pos1 = 3;
7651 dgst_pos2 = 2;
7652 dgst_pos3 = 1;
7653 break;
7654
7655 case 1400: hash_type = HASH_TYPE_SHA256;
7656 salt_type = SALT_TYPE_NONE;
7657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7658 opts_type = OPTS_TYPE_PT_GENERATE_BE
7659 | OPTS_TYPE_PT_ADD80
7660 | OPTS_TYPE_PT_ADDBITS15;
7661 kern_type = KERN_TYPE_SHA256;
7662 dgst_size = DGST_SIZE_4_8;
7663 parse_func = sha256_parse_hash;
7664 sort_by_digest = sort_by_digest_4_8;
7665 opti_type = OPTI_TYPE_ZERO_BYTE
7666 | OPTI_TYPE_PRECOMPUTE_INIT
7667 | OPTI_TYPE_PRECOMPUTE_MERKLE
7668 | OPTI_TYPE_EARLY_SKIP
7669 | OPTI_TYPE_NOT_ITERATED
7670 | OPTI_TYPE_NOT_SALTED
7671 | OPTI_TYPE_RAW_HASH;
7672 dgst_pos0 = 3;
7673 dgst_pos1 = 7;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 6;
7676 break;
7677
7678 case 1410: hash_type = HASH_TYPE_SHA256;
7679 salt_type = SALT_TYPE_INTERN;
7680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7681 opts_type = OPTS_TYPE_PT_GENERATE_BE
7682 | OPTS_TYPE_ST_ADD80
7683 | OPTS_TYPE_ST_ADDBITS15;
7684 kern_type = KERN_TYPE_SHA256_PWSLT;
7685 dgst_size = DGST_SIZE_4_8;
7686 parse_func = sha256s_parse_hash;
7687 sort_by_digest = sort_by_digest_4_8;
7688 opti_type = OPTI_TYPE_ZERO_BYTE
7689 | OPTI_TYPE_PRECOMPUTE_INIT
7690 | OPTI_TYPE_PRECOMPUTE_MERKLE
7691 | OPTI_TYPE_EARLY_SKIP
7692 | OPTI_TYPE_NOT_ITERATED
7693 | OPTI_TYPE_APPENDED_SALT
7694 | OPTI_TYPE_RAW_HASH;
7695 dgst_pos0 = 3;
7696 dgst_pos1 = 7;
7697 dgst_pos2 = 2;
7698 dgst_pos3 = 6;
7699 break;
7700
7701 case 1420: hash_type = HASH_TYPE_SHA256;
7702 salt_type = SALT_TYPE_INTERN;
7703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7704 opts_type = OPTS_TYPE_PT_GENERATE_BE
7705 | OPTS_TYPE_PT_ADD80
7706 | OPTS_TYPE_PT_ADDBITS15;
7707 kern_type = KERN_TYPE_SHA256_SLTPW;
7708 dgst_size = DGST_SIZE_4_8;
7709 parse_func = sha256s_parse_hash;
7710 sort_by_digest = sort_by_digest_4_8;
7711 opti_type = OPTI_TYPE_ZERO_BYTE
7712 | OPTI_TYPE_PRECOMPUTE_INIT
7713 | OPTI_TYPE_PRECOMPUTE_MERKLE
7714 | OPTI_TYPE_EARLY_SKIP
7715 | OPTI_TYPE_NOT_ITERATED
7716 | OPTI_TYPE_PREPENDED_SALT
7717 | OPTI_TYPE_RAW_HASH;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 7;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 6;
7722 break;
7723
7724 case 1421: hash_type = HASH_TYPE_SHA256;
7725 salt_type = SALT_TYPE_EMBEDDED;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA256_SLTPW;
7731 dgst_size = DGST_SIZE_4_8;
7732 parse_func = hmailserver_parse_hash;
7733 sort_by_digest = sort_by_digest_4_8;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_EARLY_SKIP
7738 | OPTI_TYPE_NOT_ITERATED
7739 | OPTI_TYPE_PREPENDED_SALT
7740 | OPTI_TYPE_RAW_HASH;
7741 dgst_pos0 = 3;
7742 dgst_pos1 = 7;
7743 dgst_pos2 = 2;
7744 dgst_pos3 = 6;
7745 break;
7746
7747 case 1430: hash_type = HASH_TYPE_SHA256;
7748 salt_type = SALT_TYPE_INTERN;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = OPTS_TYPE_PT_GENERATE_BE
7751 | OPTS_TYPE_PT_UNICODE
7752 | OPTS_TYPE_ST_ADD80
7753 | OPTS_TYPE_ST_ADDBITS15;
7754 kern_type = KERN_TYPE_SHA256_PWUSLT;
7755 dgst_size = DGST_SIZE_4_8;
7756 parse_func = sha256s_parse_hash;
7757 sort_by_digest = sort_by_digest_4_8;
7758 opti_type = OPTI_TYPE_ZERO_BYTE
7759 | OPTI_TYPE_PRECOMPUTE_INIT
7760 | OPTI_TYPE_PRECOMPUTE_MERKLE
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_APPENDED_SALT
7764 | OPTI_TYPE_RAW_HASH;
7765 dgst_pos0 = 3;
7766 dgst_pos1 = 7;
7767 dgst_pos2 = 2;
7768 dgst_pos3 = 6;
7769 break;
7770
7771 case 1440: hash_type = HASH_TYPE_SHA256;
7772 salt_type = SALT_TYPE_INTERN;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_BE
7775 | OPTS_TYPE_PT_ADD80
7776 | OPTS_TYPE_PT_ADDBITS15
7777 | OPTS_TYPE_PT_UNICODE;
7778 kern_type = KERN_TYPE_SHA256_SLTPWU;
7779 dgst_size = DGST_SIZE_4_8;
7780 parse_func = sha256s_parse_hash;
7781 sort_by_digest = sort_by_digest_4_8;
7782 opti_type = OPTI_TYPE_ZERO_BYTE
7783 | OPTI_TYPE_PRECOMPUTE_INIT
7784 | OPTI_TYPE_PRECOMPUTE_MERKLE
7785 | OPTI_TYPE_EARLY_SKIP
7786 | OPTI_TYPE_NOT_ITERATED
7787 | OPTI_TYPE_PREPENDED_SALT
7788 | OPTI_TYPE_RAW_HASH;
7789 dgst_pos0 = 3;
7790 dgst_pos1 = 7;
7791 dgst_pos2 = 2;
7792 dgst_pos3 = 6;
7793 break;
7794
7795 case 1441: hash_type = HASH_TYPE_SHA256;
7796 salt_type = SALT_TYPE_EMBEDDED;
7797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7798 opts_type = OPTS_TYPE_PT_GENERATE_BE
7799 | OPTS_TYPE_PT_ADD80
7800 | OPTS_TYPE_PT_ADDBITS15
7801 | OPTS_TYPE_PT_UNICODE
7802 | OPTS_TYPE_ST_BASE64;
7803 kern_type = KERN_TYPE_SHA256_SLTPWU;
7804 dgst_size = DGST_SIZE_4_8;
7805 parse_func = episerver4_parse_hash;
7806 sort_by_digest = sort_by_digest_4_8;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_PREPENDED_SALT
7813 | OPTI_TYPE_RAW_HASH;
7814 dgst_pos0 = 3;
7815 dgst_pos1 = 7;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 6;
7818 break;
7819
7820 case 1450: hash_type = HASH_TYPE_SHA256;
7821 salt_type = SALT_TYPE_INTERN;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_BE
7824 | OPTS_TYPE_ST_ADD80;
7825 kern_type = KERN_TYPE_HMACSHA256_PW;
7826 dgst_size = DGST_SIZE_4_8;
7827 parse_func = hmacsha256_parse_hash;
7828 sort_by_digest = sort_by_digest_4_8;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_NOT_ITERATED;
7831 dgst_pos0 = 3;
7832 dgst_pos1 = 7;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 6;
7835 break;
7836
7837 case 1460: hash_type = HASH_TYPE_SHA256;
7838 salt_type = SALT_TYPE_INTERN;
7839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7840 opts_type = OPTS_TYPE_PT_GENERATE_BE
7841 | OPTS_TYPE_PT_ADD80
7842 | OPTS_TYPE_PT_ADDBITS15;
7843 kern_type = KERN_TYPE_HMACSHA256_SLT;
7844 dgst_size = DGST_SIZE_4_8;
7845 parse_func = hmacsha256_parse_hash;
7846 sort_by_digest = sort_by_digest_4_8;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_NOT_ITERATED;
7849 dgst_pos0 = 3;
7850 dgst_pos1 = 7;
7851 dgst_pos2 = 2;
7852 dgst_pos3 = 6;
7853 break;
7854
7855 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7856 salt_type = SALT_TYPE_EMBEDDED;
7857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7858 opts_type = OPTS_TYPE_PT_GENERATE_LE
7859 | OPTS_TYPE_PT_BITSLICE;
7860 kern_type = KERN_TYPE_DESCRYPT;
7861 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7862 parse_func = descrypt_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7866 dgst_pos0 = 0;
7867 dgst_pos1 = 1;
7868 dgst_pos2 = 2;
7869 dgst_pos3 = 3;
7870 break;
7871
7872 case 1600: hash_type = HASH_TYPE_MD5;
7873 salt_type = SALT_TYPE_EMBEDDED;
7874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7876 kern_type = KERN_TYPE_APR1CRYPT;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = md5apr1_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 1;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 3;
7885 break;
7886
7887 case 1700: hash_type = HASH_TYPE_SHA512;
7888 salt_type = SALT_TYPE_NONE;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_BE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS15;
7893 kern_type = KERN_TYPE_SHA512;
7894 dgst_size = DGST_SIZE_8_8;
7895 parse_func = sha512_parse_hash;
7896 sort_by_digest = sort_by_digest_8_8;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_NOT_SALTED
7903 | OPTI_TYPE_USES_BITS_64
7904 | OPTI_TYPE_RAW_HASH;
7905 dgst_pos0 = 14;
7906 dgst_pos1 = 15;
7907 dgst_pos2 = 6;
7908 dgst_pos3 = 7;
7909 break;
7910
7911 case 1710: hash_type = HASH_TYPE_SHA512;
7912 salt_type = SALT_TYPE_INTERN;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_BE
7915 | OPTS_TYPE_ST_ADD80
7916 | OPTS_TYPE_ST_ADDBITS15;
7917 kern_type = KERN_TYPE_SHA512_PWSLT;
7918 dgst_size = DGST_SIZE_8_8;
7919 parse_func = sha512s_parse_hash;
7920 sort_by_digest = sort_by_digest_8_8;
7921 opti_type = OPTI_TYPE_ZERO_BYTE
7922 | OPTI_TYPE_PRECOMPUTE_INIT
7923 | OPTI_TYPE_PRECOMPUTE_MERKLE
7924 | OPTI_TYPE_EARLY_SKIP
7925 | OPTI_TYPE_NOT_ITERATED
7926 | OPTI_TYPE_APPENDED_SALT
7927 | OPTI_TYPE_USES_BITS_64
7928 | OPTI_TYPE_RAW_HASH;
7929 dgst_pos0 = 14;
7930 dgst_pos1 = 15;
7931 dgst_pos2 = 6;
7932 dgst_pos3 = 7;
7933 break;
7934
7935 case 1711: hash_type = HASH_TYPE_SHA512;
7936 salt_type = SALT_TYPE_EMBEDDED;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_ST_ADD80
7940 | OPTS_TYPE_ST_ADDBITS15;
7941 kern_type = KERN_TYPE_SHA512_PWSLT;
7942 dgst_size = DGST_SIZE_8_8;
7943 parse_func = sha512b64s_parse_hash;
7944 sort_by_digest = sort_by_digest_8_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_PRECOMPUTE_INIT
7947 | OPTI_TYPE_PRECOMPUTE_MERKLE
7948 | OPTI_TYPE_EARLY_SKIP
7949 | OPTI_TYPE_NOT_ITERATED
7950 | OPTI_TYPE_APPENDED_SALT
7951 | OPTI_TYPE_USES_BITS_64
7952 | OPTI_TYPE_RAW_HASH;
7953 dgst_pos0 = 14;
7954 dgst_pos1 = 15;
7955 dgst_pos2 = 6;
7956 dgst_pos3 = 7;
7957 break;
7958
7959 case 1720: hash_type = HASH_TYPE_SHA512;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_BE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS15;
7965 kern_type = KERN_TYPE_SHA512_SLTPW;
7966 dgst_size = DGST_SIZE_8_8;
7967 parse_func = sha512s_parse_hash;
7968 sort_by_digest = sort_by_digest_8_8;
7969 opti_type = OPTI_TYPE_ZERO_BYTE
7970 | OPTI_TYPE_PRECOMPUTE_INIT
7971 | OPTI_TYPE_PRECOMPUTE_MERKLE
7972 | OPTI_TYPE_EARLY_SKIP
7973 | OPTI_TYPE_NOT_ITERATED
7974 | OPTI_TYPE_PREPENDED_SALT
7975 | OPTI_TYPE_USES_BITS_64
7976 | OPTI_TYPE_RAW_HASH;
7977 dgst_pos0 = 14;
7978 dgst_pos1 = 15;
7979 dgst_pos2 = 6;
7980 dgst_pos3 = 7;
7981 break;
7982
7983 case 1722: hash_type = HASH_TYPE_SHA512;
7984 salt_type = SALT_TYPE_EMBEDDED;
7985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7986 opts_type = OPTS_TYPE_PT_GENERATE_BE
7987 | OPTS_TYPE_PT_ADD80
7988 | OPTS_TYPE_PT_ADDBITS15
7989 | OPTS_TYPE_ST_HEX;
7990 kern_type = KERN_TYPE_SHA512_SLTPW;
7991 dgst_size = DGST_SIZE_8_8;
7992 parse_func = osx512_parse_hash;
7993 sort_by_digest = sort_by_digest_8_8;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_PRECOMPUTE_INIT
7996 | OPTI_TYPE_PRECOMPUTE_MERKLE
7997 | OPTI_TYPE_EARLY_SKIP
7998 | OPTI_TYPE_NOT_ITERATED
7999 | OPTI_TYPE_PREPENDED_SALT
8000 | OPTI_TYPE_USES_BITS_64
8001 | OPTI_TYPE_RAW_HASH;
8002 dgst_pos0 = 14;
8003 dgst_pos1 = 15;
8004 dgst_pos2 = 6;
8005 dgst_pos3 = 7;
8006 break;
8007
8008 case 1730: hash_type = HASH_TYPE_SHA512;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_BE
8012 | OPTS_TYPE_PT_UNICODE
8013 | OPTS_TYPE_ST_ADD80
8014 | OPTS_TYPE_ST_ADDBITS15;
8015 kern_type = KERN_TYPE_SHA512_PWSLTU;
8016 dgst_size = DGST_SIZE_8_8;
8017 parse_func = sha512s_parse_hash;
8018 sort_by_digest = sort_by_digest_8_8;
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_PRECOMPUTE_INIT
8021 | OPTI_TYPE_PRECOMPUTE_MERKLE
8022 | OPTI_TYPE_EARLY_SKIP
8023 | OPTI_TYPE_NOT_ITERATED
8024 | OPTI_TYPE_APPENDED_SALT
8025 | OPTI_TYPE_USES_BITS_64
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 14;
8028 dgst_pos1 = 15;
8029 dgst_pos2 = 6;
8030 dgst_pos3 = 7;
8031 break;
8032
8033 case 1731: hash_type = HASH_TYPE_SHA512;
8034 salt_type = SALT_TYPE_EMBEDDED;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_UNICODE
8038 | OPTS_TYPE_ST_ADD80
8039 | OPTS_TYPE_ST_ADDBITS15
8040 | OPTS_TYPE_ST_HEX;
8041 kern_type = KERN_TYPE_SHA512_PWSLTU;
8042 dgst_size = DGST_SIZE_8_8;
8043 parse_func = mssql2012_parse_hash;
8044 sort_by_digest = sort_by_digest_8_8;
8045 opti_type = OPTI_TYPE_ZERO_BYTE
8046 | OPTI_TYPE_PRECOMPUTE_INIT
8047 | OPTI_TYPE_PRECOMPUTE_MERKLE
8048 | OPTI_TYPE_EARLY_SKIP
8049 | OPTI_TYPE_NOT_ITERATED
8050 | OPTI_TYPE_APPENDED_SALT
8051 | OPTI_TYPE_USES_BITS_64
8052 | OPTI_TYPE_RAW_HASH;
8053 dgst_pos0 = 14;
8054 dgst_pos1 = 15;
8055 dgst_pos2 = 6;
8056 dgst_pos3 = 7;
8057 break;
8058
8059 case 1740: hash_type = HASH_TYPE_SHA512;
8060 salt_type = SALT_TYPE_INTERN;
8061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8062 opts_type = OPTS_TYPE_PT_GENERATE_BE
8063 | OPTS_TYPE_PT_ADD80
8064 | OPTS_TYPE_PT_ADDBITS15
8065 | OPTS_TYPE_PT_UNICODE;
8066 kern_type = KERN_TYPE_SHA512_SLTPWU;
8067 dgst_size = DGST_SIZE_8_8;
8068 parse_func = sha512s_parse_hash;
8069 sort_by_digest = sort_by_digest_8_8;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_PRECOMPUTE_INIT
8072 | OPTI_TYPE_PRECOMPUTE_MERKLE
8073 | OPTI_TYPE_EARLY_SKIP
8074 | OPTI_TYPE_NOT_ITERATED
8075 | OPTI_TYPE_PREPENDED_SALT
8076 | OPTI_TYPE_USES_BITS_64
8077 | OPTI_TYPE_RAW_HASH;
8078 dgst_pos0 = 14;
8079 dgst_pos1 = 15;
8080 dgst_pos2 = 6;
8081 dgst_pos3 = 7;
8082 break;
8083
8084 case 1750: hash_type = HASH_TYPE_SHA512;
8085 salt_type = SALT_TYPE_INTERN;
8086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8087 opts_type = OPTS_TYPE_PT_GENERATE_BE
8088 | OPTS_TYPE_ST_ADD80;
8089 kern_type = KERN_TYPE_HMACSHA512_PW;
8090 dgst_size = DGST_SIZE_8_8;
8091 parse_func = hmacsha512_parse_hash;
8092 sort_by_digest = sort_by_digest_8_8;
8093 opti_type = OPTI_TYPE_ZERO_BYTE
8094 | OPTI_TYPE_USES_BITS_64
8095 | OPTI_TYPE_NOT_ITERATED;
8096 dgst_pos0 = 14;
8097 dgst_pos1 = 15;
8098 dgst_pos2 = 6;
8099 dgst_pos3 = 7;
8100 break;
8101
8102 case 1760: hash_type = HASH_TYPE_SHA512;
8103 salt_type = SALT_TYPE_INTERN;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_BE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS15;
8108 kern_type = KERN_TYPE_HMACSHA512_SLT;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = hmacsha512_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_USES_BITS_64
8114 | OPTI_TYPE_NOT_ITERATED;
8115 dgst_pos0 = 14;
8116 dgst_pos1 = 15;
8117 dgst_pos2 = 6;
8118 dgst_pos3 = 7;
8119 break;
8120
8121 case 1800: hash_type = HASH_TYPE_SHA512;
8122 salt_type = SALT_TYPE_EMBEDDED;
8123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8125 kern_type = KERN_TYPE_SHA512CRYPT;
8126 dgst_size = DGST_SIZE_8_8;
8127 parse_func = sha512crypt_parse_hash;
8128 sort_by_digest = sort_by_digest_8_8;
8129 opti_type = OPTI_TYPE_ZERO_BYTE
8130 | OPTI_TYPE_USES_BITS_64;
8131 dgst_pos0 = 0;
8132 dgst_pos1 = 1;
8133 dgst_pos2 = 2;
8134 dgst_pos3 = 3;
8135 break;
8136
8137 case 2100: hash_type = HASH_TYPE_DCC2;
8138 salt_type = SALT_TYPE_EMBEDDED;
8139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_ST_LOWER
8142 | OPTS_TYPE_ST_UNICODE;
8143 kern_type = KERN_TYPE_DCC2;
8144 dgst_size = DGST_SIZE_4_4;
8145 parse_func = dcc2_parse_hash;
8146 sort_by_digest = sort_by_digest_4_4;
8147 opti_type = OPTI_TYPE_ZERO_BYTE;
8148 dgst_pos0 = 0;
8149 dgst_pos1 = 1;
8150 dgst_pos2 = 2;
8151 dgst_pos3 = 3;
8152 break;
8153
8154 case 2400: hash_type = HASH_TYPE_MD5;
8155 salt_type = SALT_TYPE_NONE;
8156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8157 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8158 kern_type = KERN_TYPE_MD5PIX;
8159 dgst_size = DGST_SIZE_4_4;
8160 parse_func = md5pix_parse_hash;
8161 sort_by_digest = sort_by_digest_4_4;
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_PRECOMPUTE_INIT
8164 | OPTI_TYPE_PRECOMPUTE_MERKLE
8165 | OPTI_TYPE_EARLY_SKIP
8166 | OPTI_TYPE_NOT_ITERATED
8167 | OPTI_TYPE_NOT_SALTED;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174 case 2410: hash_type = HASH_TYPE_MD5;
8175 salt_type = SALT_TYPE_INTERN;
8176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8177 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8178 kern_type = KERN_TYPE_MD5ASA;
8179 dgst_size = DGST_SIZE_4_4;
8180 parse_func = md5asa_parse_hash;
8181 sort_by_digest = sort_by_digest_4_4;
8182 opti_type = OPTI_TYPE_ZERO_BYTE
8183 | OPTI_TYPE_PRECOMPUTE_INIT
8184 | OPTI_TYPE_PRECOMPUTE_MERKLE
8185 | OPTI_TYPE_EARLY_SKIP
8186 | OPTI_TYPE_NOT_ITERATED;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 3;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 1;
8191 break;
8192
8193 case 2500: hash_type = HASH_TYPE_WPA;
8194 salt_type = SALT_TYPE_EMBEDDED;
8195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8197 kern_type = KERN_TYPE_WPA;
8198 dgst_size = DGST_SIZE_4_4;
8199 parse_func = wpa_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4;
8201 opti_type = OPTI_TYPE_ZERO_BYTE;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 2600: hash_type = HASH_TYPE_MD5;
8209 salt_type = SALT_TYPE_VIRTUAL;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE
8212 | OPTS_TYPE_PT_ADD80
8213 | OPTS_TYPE_PT_ADDBITS14
8214 | OPTS_TYPE_ST_ADD80;
8215 kern_type = KERN_TYPE_MD55_PWSLT1;
8216 dgst_size = DGST_SIZE_4_4;
8217 parse_func = md5md5_parse_hash;
8218 sort_by_digest = sort_by_digest_4_4;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_EARLY_SKIP;
8223 dgst_pos0 = 0;
8224 dgst_pos1 = 3;
8225 dgst_pos2 = 2;
8226 dgst_pos3 = 1;
8227 break;
8228
8229 case 2611: hash_type = HASH_TYPE_MD5;
8230 salt_type = SALT_TYPE_INTERN;
8231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8232 opts_type = OPTS_TYPE_PT_GENERATE_LE
8233 | OPTS_TYPE_PT_ADD80
8234 | OPTS_TYPE_PT_ADDBITS14
8235 | OPTS_TYPE_ST_ADD80;
8236 kern_type = KERN_TYPE_MD55_PWSLT1;
8237 dgst_size = DGST_SIZE_4_4;
8238 parse_func = vb3_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_PRECOMPUTE_INIT
8242 | OPTI_TYPE_PRECOMPUTE_MERKLE
8243 | OPTI_TYPE_EARLY_SKIP;
8244 dgst_pos0 = 0;
8245 dgst_pos1 = 3;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 1;
8248 break;
8249
8250 case 2612: hash_type = HASH_TYPE_MD5;
8251 salt_type = SALT_TYPE_EMBEDDED;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_PT_ADD80
8255 | OPTS_TYPE_PT_ADDBITS14
8256 | OPTS_TYPE_ST_ADD80
8257 | OPTS_TYPE_ST_HEX;
8258 kern_type = KERN_TYPE_MD55_PWSLT1;
8259 dgst_size = DGST_SIZE_4_4;
8260 parse_func = phps_parse_hash;
8261 sort_by_digest = sort_by_digest_4_4;
8262 opti_type = OPTI_TYPE_ZERO_BYTE
8263 | OPTI_TYPE_PRECOMPUTE_INIT
8264 | OPTI_TYPE_PRECOMPUTE_MERKLE
8265 | OPTI_TYPE_EARLY_SKIP;
8266 dgst_pos0 = 0;
8267 dgst_pos1 = 3;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 1;
8270 break;
8271
8272 case 2711: hash_type = HASH_TYPE_MD5;
8273 salt_type = SALT_TYPE_INTERN;
8274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_LE
8276 | OPTS_TYPE_PT_ADD80
8277 | OPTS_TYPE_PT_ADDBITS14
8278 | OPTS_TYPE_ST_ADD80;
8279 kern_type = KERN_TYPE_MD55_PWSLT2;
8280 dgst_size = DGST_SIZE_4_4;
8281 parse_func = vb30_parse_hash;
8282 sort_by_digest = sort_by_digest_4_4;
8283 opti_type = OPTI_TYPE_ZERO_BYTE
8284 | OPTI_TYPE_PRECOMPUTE_INIT
8285 | OPTI_TYPE_EARLY_SKIP;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2811: hash_type = HASH_TYPE_MD5;
8293 salt_type = SALT_TYPE_INTERN;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS14;
8298 kern_type = KERN_TYPE_MD55_SLTPW;
8299 dgst_size = DGST_SIZE_4_4;
8300 parse_func = ipb2_parse_hash;
8301 sort_by_digest = sort_by_digest_4_4;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_PRECOMPUTE_INIT
8304 | OPTI_TYPE_EARLY_SKIP;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 3000: hash_type = HASH_TYPE_LM;
8312 salt_type = SALT_TYPE_NONE;
8313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE
8315 | OPTS_TYPE_PT_UPPER
8316 | OPTS_TYPE_PT_BITSLICE;
8317 kern_type = KERN_TYPE_LM;
8318 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8319 parse_func = lm_parse_hash;
8320 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8321 opti_type = OPTI_TYPE_ZERO_BYTE
8322 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 1;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 3;
8327 break;
8328
8329 case 3100: hash_type = HASH_TYPE_ORACLEH;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_PT_UPPER
8334 | OPTS_TYPE_ST_UPPER;
8335 kern_type = KERN_TYPE_ORACLEH;
8336 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8337 parse_func = oracleh_parse_hash;
8338 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8339 opti_type = OPTI_TYPE_ZERO_BYTE;
8340 dgst_pos0 = 0;
8341 dgst_pos1 = 1;
8342 dgst_pos2 = 2;
8343 dgst_pos3 = 3;
8344 break;
8345
8346 case 3200: hash_type = HASH_TYPE_BCRYPT;
8347 salt_type = SALT_TYPE_EMBEDDED;
8348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8349 opts_type = OPTS_TYPE_PT_GENERATE_LE
8350 | OPTS_TYPE_ST_GENERATE_LE;
8351 kern_type = KERN_TYPE_BCRYPT;
8352 dgst_size = DGST_SIZE_4_6;
8353 parse_func = bcrypt_parse_hash;
8354 sort_by_digest = sort_by_digest_4_6;
8355 opti_type = OPTI_TYPE_ZERO_BYTE;
8356 dgst_pos0 = 0;
8357 dgst_pos1 = 1;
8358 dgst_pos2 = 2;
8359 dgst_pos3 = 3;
8360 break;
8361
8362 case 3710: hash_type = HASH_TYPE_MD5;
8363 salt_type = SALT_TYPE_INTERN;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_LE
8366 | OPTS_TYPE_PT_ADD80
8367 | OPTS_TYPE_PT_ADDBITS14;
8368 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8369 dgst_size = DGST_SIZE_4_4;
8370 parse_func = md5s_parse_hash;
8371 sort_by_digest = sort_by_digest_4_4;
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_PRECOMPUTE_INIT
8374 | OPTI_TYPE_PRECOMPUTE_MERKLE
8375 | OPTI_TYPE_EARLY_SKIP;
8376 dgst_pos0 = 0;
8377 dgst_pos1 = 3;
8378 dgst_pos2 = 2;
8379 dgst_pos3 = 1;
8380 break;
8381
8382 case 3711: hash_type = HASH_TYPE_MD5;
8383 salt_type = SALT_TYPE_EMBEDDED;
8384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8385 opts_type = OPTS_TYPE_PT_GENERATE_LE
8386 | OPTS_TYPE_PT_ADD80
8387 | OPTS_TYPE_PT_ADDBITS14;
8388 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8389 dgst_size = DGST_SIZE_4_4;
8390 parse_func = mediawiki_b_parse_hash;
8391 sort_by_digest = sort_by_digest_4_4;
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_PRECOMPUTE_INIT
8394 | OPTI_TYPE_PRECOMPUTE_MERKLE
8395 | OPTI_TYPE_EARLY_SKIP;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 3;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 1;
8400 break;
8401
8402 case 3800: hash_type = HASH_TYPE_MD5;
8403 salt_type = SALT_TYPE_INTERN;
8404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_LE
8406 | OPTS_TYPE_ST_ADDBITS14;
8407 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5s_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP
8415 | OPTI_TYPE_NOT_ITERATED
8416 | OPTI_TYPE_RAW_HASH;
8417 dgst_pos0 = 0;
8418 dgst_pos1 = 3;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 1;
8421 break;
8422
8423 case 4300: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_VIRTUAL;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE
8427 | OPTS_TYPE_PT_ADD80
8428 | OPTS_TYPE_PT_ADDBITS14
8429 | OPTS_TYPE_ST_ADD80;
8430 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = md5md5_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444
8445 case 4400: hash_type = HASH_TYPE_MD5;
8446 salt_type = SALT_TYPE_NONE;
8447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8448 opts_type = OPTS_TYPE_PT_GENERATE_BE
8449 | OPTS_TYPE_PT_ADD80
8450 | OPTS_TYPE_PT_ADDBITS15;
8451 kern_type = KERN_TYPE_MD5_SHA1;
8452 dgst_size = DGST_SIZE_4_4;
8453 parse_func = md5_parse_hash;
8454 sort_by_digest = sort_by_digest_4_4;
8455 opti_type = OPTI_TYPE_ZERO_BYTE
8456 | OPTI_TYPE_PRECOMPUTE_INIT
8457 | OPTI_TYPE_PRECOMPUTE_MERKLE
8458 | OPTI_TYPE_EARLY_SKIP
8459 | OPTI_TYPE_NOT_ITERATED
8460 | OPTI_TYPE_NOT_SALTED
8461 | OPTI_TYPE_RAW_HASH;
8462 dgst_pos0 = 0;
8463 dgst_pos1 = 3;
8464 dgst_pos2 = 2;
8465 dgst_pos3 = 1;
8466 break;
8467
8468 case 4500: hash_type = HASH_TYPE_SHA1;
8469 salt_type = SALT_TYPE_NONE;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_BE
8472 | OPTS_TYPE_PT_ADD80
8473 | OPTS_TYPE_PT_ADDBITS15;
8474 kern_type = KERN_TYPE_SHA11;
8475 dgst_size = DGST_SIZE_4_5;
8476 parse_func = sha1_parse_hash;
8477 sort_by_digest = sort_by_digest_4_5;
8478 opti_type = OPTI_TYPE_ZERO_BYTE
8479 | OPTI_TYPE_PRECOMPUTE_INIT
8480 | OPTI_TYPE_PRECOMPUTE_MERKLE
8481 | OPTI_TYPE_EARLY_SKIP
8482 | OPTI_TYPE_NOT_SALTED;
8483 dgst_pos0 = 3;
8484 dgst_pos1 = 4;
8485 dgst_pos2 = 2;
8486 dgst_pos3 = 1;
8487 break;
8488
8489 case 4700: hash_type = HASH_TYPE_SHA1;
8490 salt_type = SALT_TYPE_NONE;
8491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8492 opts_type = OPTS_TYPE_PT_GENERATE_LE
8493 | OPTS_TYPE_PT_ADD80
8494 | OPTS_TYPE_PT_ADDBITS14;
8495 kern_type = KERN_TYPE_SHA1_MD5;
8496 dgst_size = DGST_SIZE_4_5;
8497 parse_func = sha1_parse_hash;
8498 sort_by_digest = sort_by_digest_4_5;
8499 opti_type = OPTI_TYPE_ZERO_BYTE
8500 | OPTI_TYPE_PRECOMPUTE_INIT
8501 | OPTI_TYPE_PRECOMPUTE_MERKLE
8502 | OPTI_TYPE_EARLY_SKIP
8503 | OPTI_TYPE_NOT_ITERATED
8504 | OPTI_TYPE_NOT_SALTED
8505 | OPTI_TYPE_RAW_HASH;
8506 dgst_pos0 = 3;
8507 dgst_pos1 = 4;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 4800: hash_type = HASH_TYPE_MD5;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADDBITS14;
8517 kern_type = KERN_TYPE_MD5_CHAP;
8518 dgst_size = DGST_SIZE_4_4;
8519 parse_func = chap_parse_hash;
8520 sort_by_digest = sort_by_digest_4_4;
8521 opti_type = OPTI_TYPE_ZERO_BYTE
8522 | OPTI_TYPE_PRECOMPUTE_INIT
8523 | OPTI_TYPE_PRECOMPUTE_MERKLE
8524 | OPTI_TYPE_MEET_IN_MIDDLE
8525 | OPTI_TYPE_EARLY_SKIP
8526 | OPTI_TYPE_NOT_ITERATED
8527 | OPTI_TYPE_RAW_HASH;
8528 dgst_pos0 = 0;
8529 dgst_pos1 = 3;
8530 dgst_pos2 = 2;
8531 dgst_pos3 = 1;
8532 break;
8533
8534 case 4900: hash_type = HASH_TYPE_SHA1;
8535 salt_type = SALT_TYPE_INTERN;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8538 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8539 dgst_size = DGST_SIZE_4_5;
8540 parse_func = sha1s_parse_hash;
8541 sort_by_digest = sort_by_digest_4_5;
8542 opti_type = OPTI_TYPE_ZERO_BYTE
8543 | OPTI_TYPE_PRECOMPUTE_INIT
8544 | OPTI_TYPE_PRECOMPUTE_MERKLE
8545 | OPTI_TYPE_EARLY_SKIP;
8546 dgst_pos0 = 3;
8547 dgst_pos1 = 4;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 1;
8550 break;
8551
8552 case 5000: hash_type = HASH_TYPE_KECCAK;
8553 salt_type = SALT_TYPE_EMBEDDED;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_LE
8556 | OPTS_TYPE_PT_ADD01;
8557 kern_type = KERN_TYPE_KECCAK;
8558 dgst_size = DGST_SIZE_8_25;
8559 parse_func = keccak_parse_hash;
8560 sort_by_digest = sort_by_digest_8_25;
8561 opti_type = OPTI_TYPE_ZERO_BYTE
8562 | OPTI_TYPE_USES_BITS_64
8563 | OPTI_TYPE_RAW_HASH;
8564 dgst_pos0 = 2;
8565 dgst_pos1 = 3;
8566 dgst_pos2 = 4;
8567 dgst_pos3 = 5;
8568 break;
8569
8570 case 5100: hash_type = HASH_TYPE_MD5H;
8571 salt_type = SALT_TYPE_NONE;
8572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8573 opts_type = OPTS_TYPE_PT_GENERATE_LE
8574 | OPTS_TYPE_PT_ADD80
8575 | OPTS_TYPE_PT_ADDBITS14;
8576 kern_type = KERN_TYPE_MD5H;
8577 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8578 parse_func = md5half_parse_hash;
8579 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8580 opti_type = OPTI_TYPE_ZERO_BYTE
8581 | OPTI_TYPE_RAW_HASH;
8582 dgst_pos0 = 0;
8583 dgst_pos1 = 1;
8584 dgst_pos2 = 2;
8585 dgst_pos3 = 3;
8586 break;
8587
8588 case 5200: hash_type = HASH_TYPE_SHA256;
8589 salt_type = SALT_TYPE_EMBEDDED;
8590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8591 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8592 kern_type = KERN_TYPE_PSAFE3;
8593 dgst_size = DGST_SIZE_4_8;
8594 parse_func = psafe3_parse_hash;
8595 sort_by_digest = sort_by_digest_4_8;
8596 opti_type = OPTI_TYPE_ZERO_BYTE;
8597 dgst_pos0 = 0;
8598 dgst_pos1 = 1;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 3;
8601 break;
8602
8603 case 5300: hash_type = HASH_TYPE_MD5;
8604 salt_type = SALT_TYPE_EMBEDDED;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE
8607 | OPTS_TYPE_ST_ADD80;
8608 kern_type = KERN_TYPE_IKEPSK_MD5;
8609 dgst_size = DGST_SIZE_4_4;
8610 parse_func = ikepsk_md5_parse_hash;
8611 sort_by_digest = sort_by_digest_4_4;
8612 opti_type = OPTI_TYPE_ZERO_BYTE;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 3;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 1;
8617 break;
8618
8619 case 5400: hash_type = HASH_TYPE_SHA1;
8620 salt_type = SALT_TYPE_EMBEDDED;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_BE
8623 | OPTS_TYPE_ST_ADD80;
8624 kern_type = KERN_TYPE_IKEPSK_SHA1;
8625 dgst_size = DGST_SIZE_4_5;
8626 parse_func = ikepsk_sha1_parse_hash;
8627 sort_by_digest = sort_by_digest_4_5;
8628 opti_type = OPTI_TYPE_ZERO_BYTE;
8629 dgst_pos0 = 3;
8630 dgst_pos1 = 4;
8631 dgst_pos2 = 2;
8632 dgst_pos3 = 1;
8633 break;
8634
8635 case 5500: hash_type = HASH_TYPE_NETNTLM;
8636 salt_type = SALT_TYPE_EMBEDDED;
8637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8638 opts_type = OPTS_TYPE_PT_GENERATE_LE
8639 | OPTS_TYPE_PT_ADD80
8640 | OPTS_TYPE_PT_ADDBITS14
8641 | OPTS_TYPE_PT_UNICODE
8642 | OPTS_TYPE_ST_HEX;
8643 kern_type = KERN_TYPE_NETNTLMv1;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = netntlmv1_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8649 dgst_pos0 = 0;
8650 dgst_pos1 = 1;
8651 dgst_pos2 = 2;
8652 dgst_pos3 = 3;
8653 break;
8654
8655 case 5600: hash_type = HASH_TYPE_MD5;
8656 salt_type = SALT_TYPE_EMBEDDED;
8657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE
8659 | OPTS_TYPE_PT_ADD80
8660 | OPTS_TYPE_PT_ADDBITS14
8661 | OPTS_TYPE_PT_UNICODE;
8662 kern_type = KERN_TYPE_NETNTLMv2;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = netntlmv2_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4;
8666 opti_type = OPTI_TYPE_ZERO_BYTE;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 3;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 1;
8671 break;
8672
8673 case 5700: hash_type = HASH_TYPE_SHA256;
8674 salt_type = SALT_TYPE_NONE;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_BE
8677 | OPTS_TYPE_PT_ADD80
8678 | OPTS_TYPE_PT_ADDBITS15;
8679 kern_type = KERN_TYPE_SHA256;
8680 dgst_size = DGST_SIZE_4_8;
8681 parse_func = cisco4_parse_hash;
8682 sort_by_digest = sort_by_digest_4_8;
8683 opti_type = OPTI_TYPE_ZERO_BYTE
8684 | OPTI_TYPE_PRECOMPUTE_INIT
8685 | OPTI_TYPE_PRECOMPUTE_MERKLE
8686 | OPTI_TYPE_EARLY_SKIP
8687 | OPTI_TYPE_NOT_ITERATED
8688 | OPTI_TYPE_NOT_SALTED
8689 | OPTI_TYPE_RAW_HASH;
8690 dgst_pos0 = 3;
8691 dgst_pos1 = 7;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 6;
8694 break;
8695
8696 case 5800: hash_type = HASH_TYPE_SHA1;
8697 salt_type = SALT_TYPE_INTERN;
8698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8699 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8700 | OPTS_TYPE_ST_ADD80;
8701 kern_type = KERN_TYPE_ANDROIDPIN;
8702 dgst_size = DGST_SIZE_4_5;
8703 parse_func = androidpin_parse_hash;
8704 sort_by_digest = sort_by_digest_4_5;
8705 opti_type = OPTI_TYPE_ZERO_BYTE;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 1;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 3;
8710 break;
8711
8712 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8713 salt_type = SALT_TYPE_NONE;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_LE
8716 | OPTS_TYPE_PT_ADD80;
8717 kern_type = KERN_TYPE_RIPEMD160;
8718 dgst_size = DGST_SIZE_4_5;
8719 parse_func = ripemd160_parse_hash;
8720 sort_by_digest = sort_by_digest_4_5;
8721 opti_type = OPTI_TYPE_ZERO_BYTE;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 1;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 3;
8726 break;
8727
8728 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8729 salt_type = SALT_TYPE_NONE;
8730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_BE
8732 | OPTS_TYPE_PT_ADD80;
8733 kern_type = KERN_TYPE_WHIRLPOOL;
8734 dgst_size = DGST_SIZE_4_16;
8735 parse_func = whirlpool_parse_hash;
8736 sort_by_digest = sort_by_digest_4_16;
8737 opti_type = OPTI_TYPE_ZERO_BYTE;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8748 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8749 dgst_size = DGST_SIZE_4_5;
8750 parse_func = truecrypt_parse_hash_2k;
8751 sort_by_digest = sort_by_digest_4_5;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8760 salt_type = SALT_TYPE_EMBEDDED;
8761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8763 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = truecrypt_parse_hash_2k;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8778 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8779 dgst_size = DGST_SIZE_4_5;
8780 parse_func = truecrypt_parse_hash_2k;
8781 sort_by_digest = sort_by_digest_4_5;
8782 opti_type = OPTI_TYPE_ZERO_BYTE;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 1;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 3;
8787 break;
8788
8789 case 6221: hash_type = HASH_TYPE_SHA512;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8793 kern_type = KERN_TYPE_TCSHA512_XTS512;
8794 dgst_size = DGST_SIZE_8_8;
8795 parse_func = truecrypt_parse_hash_1k;
8796 sort_by_digest = sort_by_digest_8_8;
8797 opti_type = OPTI_TYPE_ZERO_BYTE
8798 | OPTI_TYPE_USES_BITS_64;
8799 dgst_pos0 = 0;
8800 dgst_pos1 = 1;
8801 dgst_pos2 = 2;
8802 dgst_pos3 = 3;
8803 break;
8804
8805 case 6222: hash_type = HASH_TYPE_SHA512;
8806 salt_type = SALT_TYPE_EMBEDDED;
8807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8808 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8809 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8810 dgst_size = DGST_SIZE_8_8;
8811 parse_func = truecrypt_parse_hash_1k;
8812 sort_by_digest = sort_by_digest_8_8;
8813 opti_type = OPTI_TYPE_ZERO_BYTE
8814 | OPTI_TYPE_USES_BITS_64;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 6223: hash_type = HASH_TYPE_SHA512;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8825 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8826 dgst_size = DGST_SIZE_8_8;
8827 parse_func = truecrypt_parse_hash_1k;
8828 sort_by_digest = sort_by_digest_8_8;
8829 opti_type = OPTI_TYPE_ZERO_BYTE
8830 | OPTI_TYPE_USES_BITS_64;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8841 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8842 dgst_size = DGST_SIZE_4_8;
8843 parse_func = truecrypt_parse_hash_1k;
8844 sort_by_digest = sort_by_digest_4_8;
8845 opti_type = OPTI_TYPE_ZERO_BYTE;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8856 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8857 dgst_size = DGST_SIZE_4_8;
8858 parse_func = truecrypt_parse_hash_1k;
8859 sort_by_digest = sort_by_digest_4_8;
8860 opti_type = OPTI_TYPE_ZERO_BYTE;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8871 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8872 dgst_size = DGST_SIZE_4_8;
8873 parse_func = truecrypt_parse_hash_1k;
8874 sort_by_digest = sort_by_digest_4_8;
8875 opti_type = OPTI_TYPE_ZERO_BYTE;
8876 dgst_pos0 = 0;
8877 dgst_pos1 = 1;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 3;
8880 break;
8881
8882 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8886 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = truecrypt_parse_hash_1k;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8898 salt_type = SALT_TYPE_EMBEDDED;
8899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8901 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8902 dgst_size = DGST_SIZE_4_5;
8903 parse_func = truecrypt_parse_hash_1k;
8904 sort_by_digest = sort_by_digest_4_5;
8905 opti_type = OPTI_TYPE_ZERO_BYTE;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8913 salt_type = SALT_TYPE_EMBEDDED;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8916 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8917 dgst_size = DGST_SIZE_4_5;
8918 parse_func = truecrypt_parse_hash_1k;
8919 sort_by_digest = sort_by_digest_4_5;
8920 opti_type = OPTI_TYPE_ZERO_BYTE;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 6300: hash_type = HASH_TYPE_MD5;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8931 kern_type = KERN_TYPE_MD5AIX;
8932 dgst_size = DGST_SIZE_4_4;
8933 parse_func = md5aix_parse_hash;
8934 sort_by_digest = sort_by_digest_4_4;
8935 opti_type = OPTI_TYPE_ZERO_BYTE;
8936 dgst_pos0 = 0;
8937 dgst_pos1 = 1;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 3;
8940 break;
8941
8942 case 6400: hash_type = HASH_TYPE_SHA256;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8946 kern_type = KERN_TYPE_SHA256AIX;
8947 dgst_size = DGST_SIZE_4_8;
8948 parse_func = sha256aix_parse_hash;
8949 sort_by_digest = sort_by_digest_4_8;
8950 opti_type = OPTI_TYPE_ZERO_BYTE;
8951 dgst_pos0 = 0;
8952 dgst_pos1 = 1;
8953 dgst_pos2 = 2;
8954 dgst_pos3 = 3;
8955 break;
8956
8957 case 6500: hash_type = HASH_TYPE_SHA512;
8958 salt_type = SALT_TYPE_EMBEDDED;
8959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8960 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8961 kern_type = KERN_TYPE_SHA512AIX;
8962 dgst_size = DGST_SIZE_8_8;
8963 parse_func = sha512aix_parse_hash;
8964 sort_by_digest = sort_by_digest_8_8;
8965 opti_type = OPTI_TYPE_ZERO_BYTE
8966 | OPTI_TYPE_USES_BITS_64;
8967 dgst_pos0 = 0;
8968 dgst_pos1 = 1;
8969 dgst_pos2 = 2;
8970 dgst_pos3 = 3;
8971 break;
8972
8973 case 6600: hash_type = HASH_TYPE_AES;
8974 salt_type = SALT_TYPE_EMBEDDED;
8975 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8976 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8977 kern_type = KERN_TYPE_AGILEKEY;
8978 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8979 parse_func = agilekey_parse_hash;
8980 sort_by_digest = sort_by_digest_4_5;
8981 opti_type = OPTI_TYPE_ZERO_BYTE;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 6700: hash_type = HASH_TYPE_SHA1;
8989 salt_type = SALT_TYPE_EMBEDDED;
8990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8992 kern_type = KERN_TYPE_SHA1AIX;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = sha1aix_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 6800: hash_type = HASH_TYPE_AES;
9004 salt_type = SALT_TYPE_EMBEDDED;
9005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9007 kern_type = KERN_TYPE_LASTPASS;
9008 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9009 parse_func = lastpass_parse_hash;
9010 sort_by_digest = sort_by_digest_4_8;
9011 opti_type = OPTI_TYPE_ZERO_BYTE;
9012 dgst_pos0 = 0;
9013 dgst_pos1 = 1;
9014 dgst_pos2 = 2;
9015 dgst_pos3 = 3;
9016 break;
9017
9018 case 6900: hash_type = HASH_TYPE_GOST;
9019 salt_type = SALT_TYPE_NONE;
9020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9021 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9022 kern_type = KERN_TYPE_GOST;
9023 dgst_size = DGST_SIZE_4_8;
9024 parse_func = gost_parse_hash;
9025 sort_by_digest = sort_by_digest_4_8;
9026 opti_type = OPTI_TYPE_ZERO_BYTE;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 7100: hash_type = HASH_TYPE_SHA512;
9034 salt_type = SALT_TYPE_EMBEDDED;
9035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9037 kern_type = KERN_TYPE_PBKDF2_SHA512;
9038 dgst_size = DGST_SIZE_8_16;
9039 parse_func = sha512osx_parse_hash;
9040 sort_by_digest = sort_by_digest_8_16;
9041 opti_type = OPTI_TYPE_ZERO_BYTE
9042 | OPTI_TYPE_USES_BITS_64;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 7200: hash_type = HASH_TYPE_SHA512;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9053 kern_type = KERN_TYPE_PBKDF2_SHA512;
9054 dgst_size = DGST_SIZE_8_16;
9055 parse_func = sha512grub_parse_hash;
9056 sort_by_digest = sort_by_digest_8_16;
9057 opti_type = OPTI_TYPE_ZERO_BYTE
9058 | OPTI_TYPE_USES_BITS_64;
9059 dgst_pos0 = 0;
9060 dgst_pos1 = 1;
9061 dgst_pos2 = 2;
9062 dgst_pos3 = 3;
9063 break;
9064
9065 case 7300: hash_type = HASH_TYPE_SHA1;
9066 salt_type = SALT_TYPE_EMBEDDED;
9067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9068 opts_type = OPTS_TYPE_PT_GENERATE_BE
9069 | OPTS_TYPE_ST_ADD80
9070 | OPTS_TYPE_ST_ADDBITS15;
9071 kern_type = KERN_TYPE_RAKP;
9072 dgst_size = DGST_SIZE_4_5;
9073 parse_func = rakp_parse_hash;
9074 sort_by_digest = sort_by_digest_4_5;
9075 opti_type = OPTI_TYPE_ZERO_BYTE
9076 | OPTI_TYPE_NOT_ITERATED;
9077 dgst_pos0 = 3;
9078 dgst_pos1 = 4;
9079 dgst_pos2 = 2;
9080 dgst_pos3 = 1;
9081 break;
9082
9083 case 7400: hash_type = HASH_TYPE_SHA256;
9084 salt_type = SALT_TYPE_EMBEDDED;
9085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9087 kern_type = KERN_TYPE_SHA256CRYPT;
9088 dgst_size = DGST_SIZE_4_8;
9089 parse_func = sha256crypt_parse_hash;
9090 sort_by_digest = sort_by_digest_4_8;
9091 opti_type = OPTI_TYPE_ZERO_BYTE;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 1;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 3;
9096 break;
9097
9098 case 7500: hash_type = HASH_TYPE_KRB5PA;
9099 salt_type = SALT_TYPE_EMBEDDED;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9102 kern_type = KERN_TYPE_KRB5PA;
9103 dgst_size = DGST_SIZE_4_4;
9104 parse_func = krb5pa_parse_hash;
9105 sort_by_digest = sort_by_digest_4_4;
9106 opti_type = OPTI_TYPE_ZERO_BYTE
9107 | OPTI_TYPE_NOT_ITERATED;
9108 dgst_pos0 = 0;
9109 dgst_pos1 = 1;
9110 dgst_pos2 = 2;
9111 dgst_pos3 = 3;
9112 break;
9113
9114 case 7600: hash_type = HASH_TYPE_SHA1;
9115 salt_type = SALT_TYPE_INTERN;
9116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9117 opts_type = OPTS_TYPE_PT_GENERATE_BE
9118 | OPTS_TYPE_PT_ADD80
9119 | OPTS_TYPE_PT_ADDBITS15;
9120 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9121 dgst_size = DGST_SIZE_4_5;
9122 parse_func = redmine_parse_hash;
9123 sort_by_digest = sort_by_digest_4_5;
9124 opti_type = OPTI_TYPE_ZERO_BYTE
9125 | OPTI_TYPE_PRECOMPUTE_INIT
9126 | OPTI_TYPE_EARLY_SKIP
9127 | OPTI_TYPE_NOT_ITERATED
9128 | OPTI_TYPE_PREPENDED_SALT;
9129 dgst_pos0 = 3;
9130 dgst_pos1 = 4;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 1;
9133 break;
9134
9135 case 7700: hash_type = HASH_TYPE_SAPB;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE
9139 | OPTS_TYPE_PT_UPPER
9140 | OPTS_TYPE_ST_UPPER;
9141 kern_type = KERN_TYPE_SAPB;
9142 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9143 parse_func = sapb_parse_hash;
9144 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_PRECOMPUTE_INIT
9147 | OPTI_TYPE_NOT_ITERATED;
9148 dgst_pos0 = 0;
9149 dgst_pos1 = 1;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 3;
9152 break;
9153
9154 case 7800: hash_type = HASH_TYPE_SAPG;
9155 salt_type = SALT_TYPE_EMBEDDED;
9156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9157 opts_type = OPTS_TYPE_PT_GENERATE_BE
9158 | OPTS_TYPE_ST_ADD80
9159 | OPTS_TYPE_ST_UPPER;
9160 kern_type = KERN_TYPE_SAPG;
9161 dgst_size = DGST_SIZE_4_5;
9162 parse_func = sapg_parse_hash;
9163 sort_by_digest = sort_by_digest_4_5;
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_PRECOMPUTE_INIT
9166 | OPTI_TYPE_NOT_ITERATED;
9167 dgst_pos0 = 3;
9168 dgst_pos1 = 4;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 1;
9171 break;
9172
9173 case 7900: hash_type = HASH_TYPE_SHA512;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9177 kern_type = KERN_TYPE_DRUPAL7;
9178 dgst_size = DGST_SIZE_8_8;
9179 parse_func = drupal7_parse_hash;
9180 sort_by_digest = sort_by_digest_8_8;
9181 opti_type = OPTI_TYPE_ZERO_BYTE
9182 | OPTI_TYPE_USES_BITS_64;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 8000: hash_type = HASH_TYPE_SHA256;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_BE
9193 | OPTS_TYPE_PT_UNICODE
9194 | OPTS_TYPE_ST_ADD80
9195 | OPTS_TYPE_ST_HEX;
9196 kern_type = KERN_TYPE_SYBASEASE;
9197 dgst_size = DGST_SIZE_4_8;
9198 parse_func = sybasease_parse_hash;
9199 sort_by_digest = sort_by_digest_4_8;
9200 opti_type = OPTI_TYPE_ZERO_BYTE
9201 | OPTI_TYPE_PRECOMPUTE_INIT
9202 | OPTI_TYPE_EARLY_SKIP
9203 | OPTI_TYPE_NOT_ITERATED
9204 | OPTI_TYPE_RAW_HASH;
9205 dgst_pos0 = 3;
9206 dgst_pos1 = 7;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 6;
9209 break;
9210
9211 case 8100: hash_type = HASH_TYPE_SHA1;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9215 kern_type = KERN_TYPE_NETSCALER;
9216 dgst_size = DGST_SIZE_4_5;
9217 parse_func = netscaler_parse_hash;
9218 sort_by_digest = sort_by_digest_4_5;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_PRECOMPUTE_INIT
9221 | OPTI_TYPE_PRECOMPUTE_MERKLE
9222 | OPTI_TYPE_EARLY_SKIP
9223 | OPTI_TYPE_NOT_ITERATED
9224 | OPTI_TYPE_PREPENDED_SALT
9225 | OPTI_TYPE_RAW_HASH;
9226 dgst_pos0 = 3;
9227 dgst_pos1 = 4;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 1;
9230 break;
9231
9232 case 8200: hash_type = HASH_TYPE_SHA256;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9236 kern_type = KERN_TYPE_CLOUDKEY;
9237 dgst_size = DGST_SIZE_4_8;
9238 parse_func = cloudkey_parse_hash;
9239 sort_by_digest = sort_by_digest_4_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE;
9241 dgst_pos0 = 0;
9242 dgst_pos1 = 1;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 3;
9245 break;
9246
9247 case 8300: hash_type = HASH_TYPE_SHA1;
9248 salt_type = SALT_TYPE_EMBEDDED;
9249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_BE
9251 | OPTS_TYPE_ST_HEX
9252 | OPTS_TYPE_ST_ADD80;
9253 kern_type = KERN_TYPE_NSEC3;
9254 dgst_size = DGST_SIZE_4_5;
9255 parse_func = nsec3_parse_hash;
9256 sort_by_digest = sort_by_digest_4_5;
9257 opti_type = OPTI_TYPE_ZERO_BYTE;
9258 dgst_pos0 = 3;
9259 dgst_pos1 = 4;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 1;
9262 break;
9263
9264 case 8400: hash_type = HASH_TYPE_SHA1;
9265 salt_type = SALT_TYPE_INTERN;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE
9268 | OPTS_TYPE_PT_ADD80
9269 | OPTS_TYPE_PT_ADDBITS15;
9270 kern_type = KERN_TYPE_WBB3;
9271 dgst_size = DGST_SIZE_4_5;
9272 parse_func = wbb3_parse_hash;
9273 sort_by_digest = sort_by_digest_4_5;
9274 opti_type = OPTI_TYPE_ZERO_BYTE
9275 | OPTI_TYPE_PRECOMPUTE_INIT
9276 | OPTI_TYPE_NOT_ITERATED;
9277 dgst_pos0 = 3;
9278 dgst_pos1 = 4;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 1;
9281 break;
9282
9283 case 8500: hash_type = HASH_TYPE_DESRACF;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE
9287 | OPTS_TYPE_ST_UPPER;
9288 kern_type = KERN_TYPE_RACF;
9289 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9290 parse_func = racf_parse_hash;
9291 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9292 opti_type = OPTI_TYPE_ZERO_BYTE
9293 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 8600: hash_type = HASH_TYPE_LOTUS5;
9301 salt_type = SALT_TYPE_NONE;
9302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9304 kern_type = KERN_TYPE_LOTUS5;
9305 dgst_size = DGST_SIZE_4_4;
9306 parse_func = lotus5_parse_hash;
9307 sort_by_digest = sort_by_digest_4_4;
9308 opti_type = OPTI_TYPE_EARLY_SKIP
9309 | OPTI_TYPE_NOT_ITERATED
9310 | OPTI_TYPE_NOT_SALTED
9311 | OPTI_TYPE_RAW_HASH;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 8700: hash_type = HASH_TYPE_LOTUS6;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9322 kern_type = KERN_TYPE_LOTUS6;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = lotus6_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_EARLY_SKIP
9327 | OPTI_TYPE_NOT_ITERATED
9328 | OPTI_TYPE_RAW_HASH;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9339 kern_type = KERN_TYPE_ANDROIDFDE;
9340 dgst_size = DGST_SIZE_4_4;
9341 parse_func = androidfde_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 8900: hash_type = HASH_TYPE_SCRYPT;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9354 kern_type = KERN_TYPE_SCRYPT;
9355 dgst_size = DGST_SIZE_4_8;
9356 parse_func = scrypt_parse_hash;
9357 sort_by_digest = sort_by_digest_4_8;
9358 opti_type = OPTI_TYPE_ZERO_BYTE;
9359 dgst_pos0 = 0;
9360 dgst_pos1 = 1;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 3;
9363 break;
9364
9365 case 9000: hash_type = HASH_TYPE_SHA1;
9366 salt_type = SALT_TYPE_EMBEDDED;
9367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE
9369 | OPTS_TYPE_ST_GENERATE_LE;
9370 kern_type = KERN_TYPE_PSAFE2;
9371 dgst_size = DGST_SIZE_4_5;
9372 parse_func = psafe2_parse_hash;
9373 sort_by_digest = sort_by_digest_4_5;
9374 opti_type = OPTI_TYPE_ZERO_BYTE;
9375 dgst_pos0 = 0;
9376 dgst_pos1 = 1;
9377 dgst_pos2 = 2;
9378 dgst_pos3 = 3;
9379 break;
9380
9381 case 9100: hash_type = HASH_TYPE_LOTUS8;
9382 salt_type = SALT_TYPE_EMBEDDED;
9383 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9384 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9385 kern_type = KERN_TYPE_LOTUS8;
9386 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9387 parse_func = lotus8_parse_hash;
9388 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9389 opti_type = OPTI_TYPE_ZERO_BYTE;
9390 dgst_pos0 = 0;
9391 dgst_pos1 = 1;
9392 dgst_pos2 = 2;
9393 dgst_pos3 = 3;
9394 break;
9395
9396 case 9200: hash_type = HASH_TYPE_SHA256;
9397 salt_type = SALT_TYPE_EMBEDDED;
9398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9399 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9400 kern_type = KERN_TYPE_PBKDF2_SHA256;
9401 dgst_size = DGST_SIZE_4_32;
9402 parse_func = cisco8_parse_hash;
9403 sort_by_digest = sort_by_digest_4_32;
9404 opti_type = OPTI_TYPE_ZERO_BYTE;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 9300: hash_type = HASH_TYPE_SCRYPT;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9415 kern_type = KERN_TYPE_SCRYPT;
9416 dgst_size = DGST_SIZE_4_8;
9417 parse_func = cisco9_parse_hash;
9418 sort_by_digest = sort_by_digest_4_8;
9419 opti_type = OPTI_TYPE_ZERO_BYTE;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_OFFICE2007;
9431 dgst_size = DGST_SIZE_4_4;
9432 parse_func = office2007_parse_hash;
9433 sort_by_digest = sort_by_digest_4_4;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_OFFICE2010;
9446 dgst_size = DGST_SIZE_4_4;
9447 parse_func = office2010_parse_hash;
9448 sort_by_digest = sort_by_digest_4_4;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9460 kern_type = KERN_TYPE_OFFICE2013;
9461 dgst_size = DGST_SIZE_4_4;
9462 parse_func = office2013_parse_hash;
9463 sort_by_digest = sort_by_digest_4_4;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE
9475 | OPTS_TYPE_PT_ADD80
9476 | OPTS_TYPE_PT_UNICODE;
9477 kern_type = KERN_TYPE_OLDOFFICE01;
9478 dgst_size = DGST_SIZE_4_4;
9479 parse_func = oldoffice01_parse_hash;
9480 sort_by_digest = sort_by_digest_4_4;
9481 opti_type = OPTI_TYPE_ZERO_BYTE
9482 | OPTI_TYPE_PRECOMPUTE_INIT
9483 | OPTI_TYPE_NOT_ITERATED;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE
9494 | OPTS_TYPE_PT_ADD80;
9495 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9496 dgst_size = DGST_SIZE_4_4;
9497 parse_func = oldoffice01cm1_parse_hash;
9498 sort_by_digest = sort_by_digest_4_4;
9499 opti_type = OPTI_TYPE_ZERO_BYTE
9500 | OPTI_TYPE_PRECOMPUTE_INIT
9501 | OPTI_TYPE_NOT_ITERATED;
9502 dgst_pos0 = 0;
9503 dgst_pos1 = 1;
9504 dgst_pos2 = 2;
9505 dgst_pos3 = 3;
9506 break;
9507
9508 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9509 salt_type = SALT_TYPE_EMBEDDED;
9510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9511 opts_type = OPTS_TYPE_PT_GENERATE_LE
9512 | OPTS_TYPE_PT_ADD80
9513 | OPTS_TYPE_PT_UNICODE
9514 | OPTS_TYPE_PT_NEVERCRACK;
9515 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9516 dgst_size = DGST_SIZE_4_4;
9517 parse_func = oldoffice01cm2_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4;
9519 opti_type = OPTI_TYPE_ZERO_BYTE
9520 | OPTI_TYPE_PRECOMPUTE_INIT
9521 | OPTI_TYPE_NOT_ITERATED;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_BE
9532 | OPTS_TYPE_PT_ADD80
9533 | OPTS_TYPE_PT_UNICODE;
9534 kern_type = KERN_TYPE_OLDOFFICE34;
9535 dgst_size = DGST_SIZE_4_4;
9536 parse_func = oldoffice34_parse_hash;
9537 sort_by_digest = sort_by_digest_4_4;
9538 opti_type = OPTI_TYPE_ZERO_BYTE
9539 | OPTI_TYPE_PRECOMPUTE_INIT
9540 | OPTI_TYPE_NOT_ITERATED;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9551 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9552 dgst_size = DGST_SIZE_4_4;
9553 parse_func = oldoffice34cm1_parse_hash;
9554 sort_by_digest = sort_by_digest_4_4;
9555 opti_type = OPTI_TYPE_ZERO_BYTE
9556 | OPTI_TYPE_PRECOMPUTE_INIT
9557 | OPTI_TYPE_NOT_ITERATED;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9565 salt_type = SALT_TYPE_EMBEDDED;
9566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_BE
9568 | OPTS_TYPE_PT_ADD80
9569 | OPTS_TYPE_PT_UNICODE
9570 | OPTS_TYPE_PT_NEVERCRACK;
9571 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9572 dgst_size = DGST_SIZE_4_4;
9573 parse_func = oldoffice34cm2_parse_hash;
9574 sort_by_digest = sort_by_digest_4_4;
9575 opti_type = OPTI_TYPE_ZERO_BYTE
9576 | OPTI_TYPE_PRECOMPUTE_INIT
9577 | OPTI_TYPE_NOT_ITERATED;
9578 dgst_pos0 = 0;
9579 dgst_pos1 = 1;
9580 dgst_pos2 = 2;
9581 dgst_pos3 = 3;
9582 break;
9583
9584 case 9900: hash_type = HASH_TYPE_MD5;
9585 salt_type = SALT_TYPE_NONE;
9586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9587 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9588 kern_type = KERN_TYPE_RADMIN2;
9589 dgst_size = DGST_SIZE_4_4;
9590 parse_func = radmin2_parse_hash;
9591 sort_by_digest = sort_by_digest_4_4;
9592 opti_type = OPTI_TYPE_ZERO_BYTE
9593 | OPTI_TYPE_PRECOMPUTE_INIT
9594 | OPTI_TYPE_EARLY_SKIP
9595 | OPTI_TYPE_NOT_ITERATED
9596 | OPTI_TYPE_NOT_SALTED;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 3;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 1;
9601 break;
9602
9603 case 10000: hash_type = HASH_TYPE_SHA256;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9607 kern_type = KERN_TYPE_PBKDF2_SHA256;
9608 dgst_size = DGST_SIZE_4_32;
9609 parse_func = djangopbkdf2_parse_hash;
9610 sort_by_digest = sort_by_digest_4_32;
9611 opti_type = OPTI_TYPE_ZERO_BYTE;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 10100: hash_type = HASH_TYPE_SIPHASH;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_SIPHASH;
9623 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9624 parse_func = siphash_parse_hash;
9625 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_NOT_ITERATED
9628 | OPTI_TYPE_RAW_HASH;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 10200: hash_type = HASH_TYPE_MD5;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE
9639 | OPTS_TYPE_ST_ADD80
9640 | OPTS_TYPE_ST_ADDBITS14;
9641 kern_type = KERN_TYPE_HMACMD5_PW;
9642 dgst_size = DGST_SIZE_4_4;
9643 parse_func = crammd5_parse_hash;
9644 sort_by_digest = sort_by_digest_4_4;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_NOT_ITERATED;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 3;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 1;
9651 break;
9652
9653 case 10300: hash_type = HASH_TYPE_SHA1;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9657 kern_type = KERN_TYPE_SAPH_SHA1;
9658 dgst_size = DGST_SIZE_4_5;
9659 parse_func = saph_sha1_parse_hash;
9660 sort_by_digest = sort_by_digest_4_5;
9661 opti_type = OPTI_TYPE_ZERO_BYTE;
9662 dgst_pos0 = 0;
9663 dgst_pos1 = 1;
9664 dgst_pos2 = 2;
9665 dgst_pos3 = 3;
9666 break;
9667
9668 case 10400: hash_type = HASH_TYPE_PDFU16;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9672 kern_type = KERN_TYPE_PDF11;
9673 dgst_size = DGST_SIZE_4_4;
9674 parse_func = pdf11_parse_hash;
9675 sort_by_digest = sort_by_digest_4_4;
9676 opti_type = OPTI_TYPE_ZERO_BYTE
9677 | OPTI_TYPE_NOT_ITERATED;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 10410: hash_type = HASH_TYPE_PDFU16;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_PDF11CM1;
9689 dgst_size = DGST_SIZE_4_4;
9690 parse_func = pdf11cm1_parse_hash;
9691 sort_by_digest = sort_by_digest_4_4;
9692 opti_type = OPTI_TYPE_ZERO_BYTE
9693 | OPTI_TYPE_NOT_ITERATED;
9694 dgst_pos0 = 0;
9695 dgst_pos1 = 1;
9696 dgst_pos2 = 2;
9697 dgst_pos3 = 3;
9698 break;
9699
9700 case 10420: hash_type = HASH_TYPE_PDFU16;
9701 salt_type = SALT_TYPE_EMBEDDED;
9702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9703 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9704 kern_type = KERN_TYPE_PDF11CM2;
9705 dgst_size = DGST_SIZE_4_4;
9706 parse_func = pdf11cm2_parse_hash;
9707 sort_by_digest = sort_by_digest_4_4;
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_NOT_ITERATED;
9710 dgst_pos0 = 0;
9711 dgst_pos1 = 1;
9712 dgst_pos2 = 2;
9713 dgst_pos3 = 3;
9714 break;
9715
9716 case 10500: hash_type = HASH_TYPE_PDFU16;
9717 salt_type = SALT_TYPE_EMBEDDED;
9718 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9719 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9720 kern_type = KERN_TYPE_PDF14;
9721 dgst_size = DGST_SIZE_4_4;
9722 parse_func = pdf14_parse_hash;
9723 sort_by_digest = sort_by_digest_4_4;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_NOT_ITERATED;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 1;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 3;
9730 break;
9731
9732 case 10600: hash_type = HASH_TYPE_SHA256;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_BE
9736 | OPTS_TYPE_ST_ADD80
9737 | OPTS_TYPE_ST_ADDBITS15
9738 | OPTS_TYPE_HASH_COPY;
9739 kern_type = KERN_TYPE_SHA256_PWSLT;
9740 dgst_size = DGST_SIZE_4_8;
9741 parse_func = pdf17l3_parse_hash;
9742 sort_by_digest = sort_by_digest_4_8;
9743 opti_type = OPTI_TYPE_ZERO_BYTE
9744 | OPTI_TYPE_PRECOMPUTE_INIT
9745 | OPTI_TYPE_PRECOMPUTE_MERKLE
9746 | OPTI_TYPE_EARLY_SKIP
9747 | OPTI_TYPE_NOT_ITERATED
9748 | OPTI_TYPE_APPENDED_SALT
9749 | OPTI_TYPE_RAW_HASH;
9750 dgst_pos0 = 3;
9751 dgst_pos1 = 7;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 6;
9754 break;
9755
9756 case 10700: hash_type = HASH_TYPE_PDFU32;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE
9760 | OPTS_TYPE_HASH_COPY;
9761 kern_type = KERN_TYPE_PDF17L8;
9762 dgst_size = DGST_SIZE_4_8;
9763 parse_func = pdf17l8_parse_hash;
9764 sort_by_digest = sort_by_digest_4_8;
9765 opti_type = OPTI_TYPE_ZERO_BYTE
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 10800: hash_type = HASH_TYPE_SHA384;
9774 salt_type = SALT_TYPE_NONE;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_BE
9777 | OPTS_TYPE_PT_ADD80
9778 | OPTS_TYPE_PT_ADDBITS15;
9779 kern_type = KERN_TYPE_SHA384;
9780 dgst_size = DGST_SIZE_8_8;
9781 parse_func = sha384_parse_hash;
9782 sort_by_digest = sort_by_digest_8_8;
9783 opti_type = OPTI_TYPE_ZERO_BYTE
9784 | OPTI_TYPE_PRECOMPUTE_INIT
9785 | OPTI_TYPE_PRECOMPUTE_MERKLE
9786 | OPTI_TYPE_EARLY_SKIP
9787 | OPTI_TYPE_NOT_ITERATED
9788 | OPTI_TYPE_NOT_SALTED
9789 | OPTI_TYPE_USES_BITS_64
9790 | OPTI_TYPE_RAW_HASH;
9791 dgst_pos0 = 6;
9792 dgst_pos1 = 7;
9793 dgst_pos2 = 4;
9794 dgst_pos3 = 5;
9795 break;
9796
9797 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE
9801 | OPTS_TYPE_ST_BASE64
9802 | OPTS_TYPE_HASH_COPY;
9803 kern_type = KERN_TYPE_PBKDF2_SHA256;
9804 dgst_size = DGST_SIZE_4_32;
9805 parse_func = pbkdf2_sha256_parse_hash;
9806 sort_by_digest = sort_by_digest_4_32;
9807 opti_type = OPTI_TYPE_ZERO_BYTE;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 11000: hash_type = HASH_TYPE_MD5;
9815 salt_type = SALT_TYPE_INTERN;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_LE
9818 | OPTS_TYPE_PT_ADD80;
9819 kern_type = KERN_TYPE_PRESTASHOP;
9820 dgst_size = DGST_SIZE_4_4;
9821 parse_func = prestashop_parse_hash;
9822 sort_by_digest = sort_by_digest_4_4;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_PRECOMPUTE_INIT
9825 | OPTI_TYPE_NOT_ITERATED
9826 | OPTI_TYPE_PREPENDED_SALT;
9827 dgst_pos0 = 0;
9828 dgst_pos1 = 3;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 1;
9831 break;
9832
9833 case 11100: hash_type = HASH_TYPE_MD5;
9834 salt_type = SALT_TYPE_EMBEDDED;
9835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_ST_ADD80;
9838 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9839 dgst_size = DGST_SIZE_4_4;
9840 parse_func = postgresql_auth_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_PRECOMPUTE_MERKLE
9845 | OPTI_TYPE_EARLY_SKIP;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 3;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 1;
9850 break;
9851
9852 case 11200: hash_type = HASH_TYPE_SHA1;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_BE
9856 | OPTS_TYPE_PT_ADD80
9857 | OPTS_TYPE_ST_HEX;
9858 kern_type = KERN_TYPE_MYSQL_AUTH;
9859 dgst_size = DGST_SIZE_4_5;
9860 parse_func = mysql_auth_parse_hash;
9861 sort_by_digest = sort_by_digest_4_5;
9862 opti_type = OPTI_TYPE_ZERO_BYTE
9863 | OPTI_TYPE_EARLY_SKIP;
9864 dgst_pos0 = 3;
9865 dgst_pos1 = 4;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 1;
9868 break;
9869
9870 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9871 salt_type = SALT_TYPE_EMBEDDED;
9872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE
9874 | OPTS_TYPE_ST_HEX
9875 | OPTS_TYPE_ST_ADD80;
9876 kern_type = KERN_TYPE_BITCOIN_WALLET;
9877 dgst_size = DGST_SIZE_4_4;
9878 parse_func = bitcoin_wallet_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4;
9880 opti_type = OPTI_TYPE_ZERO_BYTE;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 11400: hash_type = HASH_TYPE_MD5;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_LE
9891 | OPTS_TYPE_PT_ADD80
9892 | OPTS_TYPE_HASH_COPY;
9893 kern_type = KERN_TYPE_SIP_AUTH;
9894 dgst_size = DGST_SIZE_4_4;
9895 parse_func = sip_auth_parse_hash;
9896 sort_by_digest = sort_by_digest_4_4;
9897 opti_type = OPTI_TYPE_ZERO_BYTE;
9898 dgst_pos0 = 0;
9899 dgst_pos1 = 3;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 1;
9902 break;
9903
9904 case 11500: hash_type = HASH_TYPE_CRC32;
9905 salt_type = SALT_TYPE_INTERN;
9906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_LE
9908 | OPTS_TYPE_ST_GENERATE_LE
9909 | OPTS_TYPE_ST_HEX;
9910 kern_type = KERN_TYPE_CRC32;
9911 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9912 parse_func = crc32_parse_hash;
9913 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9914 opti_type = OPTI_TYPE_ZERO_BYTE;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 11600: hash_type = HASH_TYPE_AES;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE
9925 | OPTS_TYPE_PT_NEVERCRACK;
9926 kern_type = KERN_TYPE_SEVEN_ZIP;
9927 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9928 parse_func = seven_zip_parse_hash;
9929 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9930 opti_type = OPTI_TYPE_ZERO_BYTE;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 1;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 3;
9935 break;
9936
9937 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9938 salt_type = SALT_TYPE_NONE;
9939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE
9941 | OPTS_TYPE_PT_ADD01;
9942 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9943 dgst_size = DGST_SIZE_4_8;
9944 parse_func = gost2012sbog_256_parse_hash;
9945 sort_by_digest = sort_by_digest_4_8;
9946 opti_type = OPTI_TYPE_ZERO_BYTE;
9947 dgst_pos0 = 0;
9948 dgst_pos1 = 1;
9949 dgst_pos2 = 2;
9950 dgst_pos3 = 3;
9951 break;
9952
9953 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9954 salt_type = SALT_TYPE_NONE;
9955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9956 opts_type = OPTS_TYPE_PT_GENERATE_LE
9957 | OPTS_TYPE_PT_ADD01;
9958 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9959 dgst_size = DGST_SIZE_4_16;
9960 parse_func = gost2012sbog_512_parse_hash;
9961 sort_by_digest = sort_by_digest_4_16;
9962 opti_type = OPTI_TYPE_ZERO_BYTE;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9970 salt_type = SALT_TYPE_EMBEDDED;
9971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_LE
9973 | OPTS_TYPE_ST_BASE64
9974 | OPTS_TYPE_HASH_COPY;
9975 kern_type = KERN_TYPE_PBKDF2_MD5;
9976 dgst_size = DGST_SIZE_4_32;
9977 parse_func = pbkdf2_md5_parse_hash;
9978 sort_by_digest = sort_by_digest_4_32;
9979 opti_type = OPTI_TYPE_ZERO_BYTE;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_LE
9990 | OPTS_TYPE_ST_BASE64
9991 | OPTS_TYPE_HASH_COPY;
9992 kern_type = KERN_TYPE_PBKDF2_SHA1;
9993 dgst_size = DGST_SIZE_4_32;
9994 parse_func = pbkdf2_sha1_parse_hash;
9995 sort_by_digest = sort_by_digest_4_32;
9996 opti_type = OPTI_TYPE_ZERO_BYTE;
9997 dgst_pos0 = 0;
9998 dgst_pos1 = 1;
9999 dgst_pos2 = 2;
10000 dgst_pos3 = 3;
10001 break;
10002
10003 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10004 salt_type = SALT_TYPE_EMBEDDED;
10005 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10006 opts_type = OPTS_TYPE_PT_GENERATE_LE
10007 | OPTS_TYPE_ST_BASE64
10008 | OPTS_TYPE_HASH_COPY;
10009 kern_type = KERN_TYPE_PBKDF2_SHA512;
10010 dgst_size = DGST_SIZE_8_16;
10011 parse_func = pbkdf2_sha512_parse_hash;
10012 sort_by_digest = sort_by_digest_8_16;
10013 opti_type = OPTI_TYPE_ZERO_BYTE
10014 | OPTI_TYPE_USES_BITS_64;
10015 dgst_pos0 = 0;
10016 dgst_pos1 = 1;
10017 dgst_pos2 = 2;
10018 dgst_pos3 = 3;
10019 break;
10020
10021 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10022 salt_type = SALT_TYPE_EMBEDDED;
10023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10025 kern_type = KERN_TYPE_ECRYPTFS;
10026 dgst_size = DGST_SIZE_8_8;
10027 parse_func = ecryptfs_parse_hash;
10028 sort_by_digest = sort_by_digest_8_8;
10029 opti_type = OPTI_TYPE_ZERO_BYTE
10030 | OPTI_TYPE_USES_BITS_64;
10031 dgst_pos0 = 0;
10032 dgst_pos1 = 1;
10033 dgst_pos2 = 2;
10034 dgst_pos3 = 3;
10035 break;
10036
10037 case 12300: hash_type = HASH_TYPE_ORACLET;
10038 salt_type = SALT_TYPE_EMBEDDED;
10039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10040 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10041 kern_type = KERN_TYPE_ORACLET;
10042 dgst_size = DGST_SIZE_8_16;
10043 parse_func = oraclet_parse_hash;
10044 sort_by_digest = sort_by_digest_8_16;
10045 opti_type = OPTI_TYPE_ZERO_BYTE
10046 | OPTI_TYPE_USES_BITS_64;
10047 dgst_pos0 = 0;
10048 dgst_pos1 = 1;
10049 dgst_pos2 = 2;
10050 dgst_pos3 = 3;
10051 break;
10052
10053 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10054 salt_type = SALT_TYPE_EMBEDDED;
10055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10057 kern_type = KERN_TYPE_BSDICRYPT;
10058 dgst_size = DGST_SIZE_4_4;
10059 parse_func = bsdicrypt_parse_hash;
10060 sort_by_digest = sort_by_digest_4_4;
10061 opti_type = OPTI_TYPE_ZERO_BYTE
10062 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10063 dgst_pos0 = 0;
10064 dgst_pos1 = 1;
10065 dgst_pos2 = 2;
10066 dgst_pos3 = 3;
10067 break;
10068
10069 case 12500: hash_type = HASH_TYPE_RAR3HP;
10070 salt_type = SALT_TYPE_EMBEDDED;
10071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10073 kern_type = KERN_TYPE_RAR3;
10074 dgst_size = DGST_SIZE_4_4;
10075 parse_func = rar3hp_parse_hash;
10076 sort_by_digest = sort_by_digest_4_4;
10077 opti_type = OPTI_TYPE_ZERO_BYTE;
10078 dgst_pos0 = 0;
10079 dgst_pos1 = 1;
10080 dgst_pos2 = 2;
10081 dgst_pos3 = 3;
10082 break;
10083
10084 case 12600: hash_type = HASH_TYPE_SHA256;
10085 salt_type = SALT_TYPE_INTERN;
10086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10087 opts_type = OPTS_TYPE_PT_GENERATE_BE
10088 | OPTS_TYPE_PT_ADD80;
10089 kern_type = KERN_TYPE_CF10;
10090 dgst_size = DGST_SIZE_4_8;
10091 parse_func = cf10_parse_hash;
10092 sort_by_digest = sort_by_digest_4_8;
10093 opti_type = OPTI_TYPE_ZERO_BYTE
10094 | OPTI_TYPE_PRECOMPUTE_INIT
10095 | OPTI_TYPE_EARLY_SKIP
10096 | OPTI_TYPE_NOT_ITERATED;
10097 dgst_pos0 = 3;
10098 dgst_pos1 = 7;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 6;
10101 break;
10102
10103 case 12700: hash_type = HASH_TYPE_AES;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE
10107 | OPTS_TYPE_HASH_COPY;
10108 kern_type = KERN_TYPE_MYWALLET;
10109 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10110 parse_func = mywallet_parse_hash;
10111 sort_by_digest = sort_by_digest_4_5;
10112 opti_type = OPTI_TYPE_ZERO_BYTE;
10113 dgst_pos0 = 0;
10114 dgst_pos1 = 1;
10115 dgst_pos2 = 2;
10116 dgst_pos3 = 3;
10117 break;
10118
10119 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10120 salt_type = SALT_TYPE_EMBEDDED;
10121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10123 kern_type = KERN_TYPE_MS_DRSR;
10124 dgst_size = DGST_SIZE_4_8;
10125 parse_func = ms_drsr_parse_hash;
10126 sort_by_digest = sort_by_digest_4_8;
10127 opti_type = OPTI_TYPE_ZERO_BYTE;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10138 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10139 dgst_size = DGST_SIZE_4_8;
10140 parse_func = androidfde_samsung_parse_hash;
10141 sort_by_digest = sort_by_digest_4_8;
10142 opti_type = OPTI_TYPE_ZERO_BYTE;
10143 dgst_pos0 = 0;
10144 dgst_pos1 = 1;
10145 dgst_pos2 = 2;
10146 dgst_pos3 = 3;
10147 break;
10148
10149 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10150 salt_type = SALT_TYPE_EMBEDDED;
10151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10152 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10153 kern_type = KERN_TYPE_RAR5;
10154 dgst_size = DGST_SIZE_4_4;
10155 parse_func = rar5_parse_hash;
10156 sort_by_digest = sort_by_digest_4_4;
10157 opti_type = OPTI_TYPE_ZERO_BYTE;
10158 dgst_pos0 = 0;
10159 dgst_pos1 = 1;
10160 dgst_pos2 = 2;
10161 dgst_pos3 = 3;
10162 break;
10163
10164 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10165 salt_type = SALT_TYPE_EMBEDDED;
10166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10167 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10168 kern_type = KERN_TYPE_KRB5TGS;
10169 dgst_size = DGST_SIZE_4_4;
10170 parse_func = krb5tgs_parse_hash;
10171 sort_by_digest = sort_by_digest_4_4;
10172 opti_type = OPTI_TYPE_ZERO_BYTE
10173 | OPTI_TYPE_NOT_ITERATED;
10174 dgst_pos0 = 0;
10175 dgst_pos1 = 1;
10176 dgst_pos2 = 2;
10177 dgst_pos3 = 3;
10178 break;
10179
10180 case 13200: hash_type = HASH_TYPE_AES;
10181 salt_type = SALT_TYPE_EMBEDDED;
10182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10184 kern_type = KERN_TYPE_AXCRYPT;
10185 dgst_size = DGST_SIZE_4_4;
10186 parse_func = axcrypt_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4;
10188 opti_type = OPTI_TYPE_ZERO_BYTE;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 1;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 3;
10193 break;
10194
10195 case 13300: hash_type = HASH_TYPE_SHA1;
10196 salt_type = SALT_TYPE_NONE;
10197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_BE
10199 | OPTS_TYPE_PT_ADD80
10200 | OPTS_TYPE_PT_ADDBITS15;
10201 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10202 dgst_size = DGST_SIZE_4_5;
10203 parse_func = sha1axcrypt_parse_hash;
10204 sort_by_digest = sort_by_digest_4_5;
10205 opti_type = OPTI_TYPE_ZERO_BYTE
10206 | OPTI_TYPE_PRECOMPUTE_INIT
10207 | OPTI_TYPE_EARLY_SKIP
10208 | OPTI_TYPE_NOT_ITERATED
10209 | OPTI_TYPE_NOT_SALTED;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 4;
10212 dgst_pos2 = 3;
10213 dgst_pos3 = 2;
10214 break;
10215
10216 case 13400: hash_type = HASH_TYPE_AES;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10220 kern_type = KERN_TYPE_KEEPASS;
10221 dgst_size = DGST_SIZE_4_4;
10222 parse_func = keepass_parse_hash;
10223 sort_by_digest = sort_by_digest_4_4;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 13500: hash_type = HASH_TYPE_SHA1;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_BE
10235 | OPTS_TYPE_PT_UNICODE
10236 | OPTS_TYPE_PT_ADD80;
10237 kern_type = KERN_TYPE_PSTOKEN;
10238 dgst_size = DGST_SIZE_4_5;
10239 parse_func = pstoken_parse_hash;
10240 sort_by_digest = sort_by_digest_4_5;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_PRECOMPUTE_INIT
10243 | OPTI_TYPE_EARLY_SKIP
10244 | OPTI_TYPE_NOT_ITERATED
10245 | OPTI_TYPE_PREPENDED_SALT
10246 | OPTI_TYPE_RAW_HASH;
10247 dgst_pos0 = 3;
10248 dgst_pos1 = 4;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 1;
10251 break;
10252
10253 default: usage_mini_print (PROGNAME); return (-1);
10254 }
10255
10256 /**
10257 * parser
10258 */
10259
10260 data.parse_func = parse_func;
10261
10262 /**
10263 * misc stuff
10264 */
10265
10266 if (hex_salt)
10267 {
10268 if (salt_type == SALT_TYPE_INTERN)
10269 {
10270 opts_type |= OPTS_TYPE_ST_HEX;
10271 }
10272 else
10273 {
10274 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10275
10276 return (-1);
10277 }
10278 }
10279
10280 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10281 | (salt_type == SALT_TYPE_EXTERN)
10282 | (salt_type == SALT_TYPE_EMBEDDED)
10283 | (salt_type == SALT_TYPE_VIRTUAL));
10284
10285 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10286
10287 data.hash_type = hash_type;
10288 data.attack_mode = attack_mode;
10289 data.attack_kern = attack_kern;
10290 data.attack_exec = attack_exec;
10291 data.kern_type = kern_type;
10292 data.opts_type = opts_type;
10293 data.dgst_size = dgst_size;
10294 data.salt_type = salt_type;
10295 data.isSalted = isSalted;
10296 data.sort_by_digest = sort_by_digest;
10297 data.dgst_pos0 = dgst_pos0;
10298 data.dgst_pos1 = dgst_pos1;
10299 data.dgst_pos2 = dgst_pos2;
10300 data.dgst_pos3 = dgst_pos3;
10301
10302 esalt_size = 0;
10303
10304 switch (hash_mode)
10305 {
10306 case 2500: esalt_size = sizeof (wpa_t); break;
10307 case 5300: esalt_size = sizeof (ikepsk_t); break;
10308 case 5400: esalt_size = sizeof (ikepsk_t); break;
10309 case 5500: esalt_size = sizeof (netntlm_t); break;
10310 case 5600: esalt_size = sizeof (netntlm_t); break;
10311 case 6211: esalt_size = sizeof (tc_t); break;
10312 case 6212: esalt_size = sizeof (tc_t); break;
10313 case 6213: esalt_size = sizeof (tc_t); break;
10314 case 6221: esalt_size = sizeof (tc_t); break;
10315 case 6222: esalt_size = sizeof (tc_t); break;
10316 case 6223: esalt_size = sizeof (tc_t); break;
10317 case 6231: esalt_size = sizeof (tc_t); break;
10318 case 6232: esalt_size = sizeof (tc_t); break;
10319 case 6233: esalt_size = sizeof (tc_t); break;
10320 case 6241: esalt_size = sizeof (tc_t); break;
10321 case 6242: esalt_size = sizeof (tc_t); break;
10322 case 6243: esalt_size = sizeof (tc_t); break;
10323 case 6600: esalt_size = sizeof (agilekey_t); break;
10324 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10325 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10326 case 7300: esalt_size = sizeof (rakp_t); break;
10327 case 7500: esalt_size = sizeof (krb5pa_t); break;
10328 case 8200: esalt_size = sizeof (cloudkey_t); break;
10329 case 8800: esalt_size = sizeof (androidfde_t); break;
10330 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10331 case 9400: esalt_size = sizeof (office2007_t); break;
10332 case 9500: esalt_size = sizeof (office2010_t); break;
10333 case 9600: esalt_size = sizeof (office2013_t); break;
10334 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10335 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10336 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10337 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10338 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10339 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10340 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10341 case 10200: esalt_size = sizeof (cram_md5_t); break;
10342 case 10400: esalt_size = sizeof (pdf_t); break;
10343 case 10410: esalt_size = sizeof (pdf_t); break;
10344 case 10420: esalt_size = sizeof (pdf_t); break;
10345 case 10500: esalt_size = sizeof (pdf_t); break;
10346 case 10600: esalt_size = sizeof (pdf_t); break;
10347 case 10700: esalt_size = sizeof (pdf_t); break;
10348 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10349 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10350 case 11400: esalt_size = sizeof (sip_t); break;
10351 case 11600: esalt_size = sizeof (seven_zip_t); break;
10352 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10353 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10354 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10355 case 13000: esalt_size = sizeof (rar5_t); break;
10356 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10357 case 13400: esalt_size = sizeof (keepass_t); break;
10358 case 13500: esalt_size = sizeof (pstoken_t); break;
10359 }
10360
10361 data.esalt_size = esalt_size;
10362
10363 /**
10364 * choose dictionary parser
10365 */
10366
10367 if (hash_type == HASH_TYPE_LM)
10368 {
10369 get_next_word_func = get_next_word_lm;
10370 }
10371 else if (opts_type & OPTS_TYPE_PT_UPPER)
10372 {
10373 get_next_word_func = get_next_word_uc;
10374 }
10375 else
10376 {
10377 get_next_word_func = get_next_word_std;
10378 }
10379
10380 /**
10381 * dictstat
10382 */
10383
10384 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10385
10386 #ifdef _POSIX
10387 size_t dictstat_nmemb = 0;
10388 #endif
10389
10390 #ifdef _WIN
10391 uint dictstat_nmemb = 0;
10392 #endif
10393
10394 char dictstat[256] = { 0 };
10395
10396 FILE *dictstat_fp = NULL;
10397
10398 if (keyspace == 0)
10399 {
10400 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10401
10402 dictstat_fp = fopen (dictstat, "rb");
10403
10404 if (dictstat_fp)
10405 {
10406 #ifdef _POSIX
10407 struct stat tmpstat;
10408
10409 fstat (fileno (dictstat_fp), &tmpstat);
10410 #endif
10411
10412 #ifdef _WIN
10413 struct stat64 tmpstat;
10414
10415 _fstat64 (fileno (dictstat_fp), &tmpstat);
10416 #endif
10417
10418 if (tmpstat.st_mtime < COMPTIME)
10419 {
10420 /* with v0.15 the format changed so we have to ensure user is using a good version
10421 since there is no version-header in the dictstat file */
10422
10423 fclose (dictstat_fp);
10424
10425 unlink (dictstat);
10426 }
10427 else
10428 {
10429 while (!feof (dictstat_fp))
10430 {
10431 dictstat_t d;
10432
10433 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10434
10435 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10436
10437 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10438 {
10439 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10440
10441 return -1;
10442 }
10443 }
10444
10445 fclose (dictstat_fp);
10446 }
10447 }
10448 }
10449
10450 /**
10451 * potfile
10452 */
10453
10454 char potfile[256] = { 0 };
10455
10456 if (potfile_path == NULL)
10457 {
10458 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10459 }
10460 else
10461 {
10462 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10463 }
10464
10465 data.pot_fp = NULL;
10466
10467 FILE *out_fp = NULL;
10468 FILE *pot_fp = NULL;
10469
10470 if (show == 1 || left == 1)
10471 {
10472 pot_fp = fopen (potfile, "rb");
10473
10474 if (pot_fp == NULL)
10475 {
10476 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10477
10478 return (-1);
10479 }
10480
10481 if (outfile != NULL)
10482 {
10483 if ((out_fp = fopen (outfile, "ab")) == NULL)
10484 {
10485 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10486
10487 fclose (pot_fp);
10488
10489 return (-1);
10490 }
10491 }
10492 else
10493 {
10494 out_fp = stdout;
10495 }
10496 }
10497 else
10498 {
10499 if (potfile_disable == 0)
10500 {
10501 pot_fp = fopen (potfile, "ab");
10502
10503 if (pot_fp == NULL)
10504 {
10505 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10506
10507 return (-1);
10508 }
10509
10510 data.pot_fp = pot_fp;
10511 }
10512 }
10513
10514 pot_t *pot = NULL;
10515
10516 uint pot_cnt = 0;
10517 uint pot_avail = 0;
10518
10519 if (show == 1 || left == 1)
10520 {
10521 SUPPRESS_OUTPUT = 1;
10522
10523 pot_avail = count_lines (pot_fp);
10524
10525 rewind (pot_fp);
10526
10527 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10528
10529 uint pot_hashes_avail = 0;
10530
10531 uint line_num = 0;
10532
10533 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10534
10535 while (!feof (pot_fp))
10536 {
10537 line_num++;
10538
10539 int line_len = fgetl (pot_fp, line_buf);
10540
10541 if (line_len == 0) continue;
10542
10543 char *plain_buf = line_buf + line_len;
10544
10545 pot_t *pot_ptr = &pot[pot_cnt];
10546
10547 hash_t *hashes_buf = &pot_ptr->hash;
10548
10549 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10550 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10551
10552 if (pot_cnt == pot_hashes_avail)
10553 {
10554 uint pos = 0;
10555
10556 for (pos = 0; pos < INCR_POT; pos++)
10557 {
10558 if ((pot_cnt + pos) >= pot_avail) break;
10559
10560 pot_t *tmp_pot = &pot[pot_cnt + pos];
10561
10562 hash_t *tmp_hash = &tmp_pot->hash;
10563
10564 tmp_hash->digest = mymalloc (dgst_size);
10565
10566 if (isSalted)
10567 {
10568 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10569 }
10570
10571 if (esalt_size)
10572 {
10573 tmp_hash->esalt = mymalloc (esalt_size);
10574 }
10575
10576 pot_hashes_avail++;
10577 }
10578 }
10579
10580 int plain_len = 0;
10581
10582 int parser_status;
10583
10584 int iter = MAX_CUT_TRIES;
10585
10586 do
10587 {
10588 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10589 {
10590 if (line_buf[i] == ':')
10591 {
10592 line_len--;
10593
10594 break;
10595 }
10596 }
10597
10598 if (data.hash_mode != 2500)
10599 {
10600 parser_status = parse_func (line_buf, line_len, hashes_buf);
10601 }
10602 else
10603 {
10604 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10605
10606 if (line_len > max_salt_size)
10607 {
10608 parser_status = PARSER_GLOBAL_LENGTH;
10609 }
10610 else
10611 {
10612 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10613
10614 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10615
10616 hashes_buf->salt->salt_len = line_len;
10617
10618 parser_status = PARSER_OK;
10619 }
10620 }
10621
10622 // if NOT parsed without error, we add the ":" to the plain
10623
10624 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10625 {
10626 plain_len++;
10627 plain_buf--;
10628 }
10629
10630 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10631
10632 if (parser_status < PARSER_GLOBAL_ZERO)
10633 {
10634 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10635
10636 continue;
10637 }
10638
10639 if (plain_len >= 255) continue;
10640
10641 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10642
10643 pot_ptr->plain_len = plain_len;
10644
10645 pot_cnt++;
10646 }
10647
10648 myfree (line_buf);
10649
10650 fclose (pot_fp);
10651
10652 SUPPRESS_OUTPUT = 0;
10653
10654 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10655 }
10656
10657 /**
10658 * word len
10659 */
10660
10661 uint pw_min = PW_MIN;
10662 uint pw_max = PW_MAX;
10663
10664 switch (hash_mode)
10665 {
10666 case 125: if (pw_max > 32) pw_max = 32;
10667 break;
10668 case 400: if (pw_max > 40) pw_max = 40;
10669 break;
10670 case 500: if (pw_max > 16) pw_max = 16;
10671 break;
10672 case 1500: if (pw_max > 8) pw_max = 8;
10673 break;
10674 case 1600: if (pw_max > 16) pw_max = 16;
10675 break;
10676 case 1800: if (pw_max > 16) pw_max = 16;
10677 break;
10678 case 2100: if (pw_max > 16) pw_max = 16;
10679 break;
10680 case 2500: if (pw_min < 8) pw_min = 8;
10681 break;
10682 case 3000: if (pw_max > 7) pw_max = 7;
10683 break;
10684 case 5200: if (pw_max > 24) pw_max = 24;
10685 break;
10686 case 5800: if (pw_max > 16) pw_max = 16;
10687 break;
10688 case 6300: if (pw_max > 16) pw_max = 16;
10689 break;
10690 case 7400: if (pw_max > 16) pw_max = 16;
10691 break;
10692 case 7900: if (pw_max > 48) pw_max = 48;
10693 break;
10694 case 8500: if (pw_max > 8) pw_max = 8;
10695 break;
10696 case 8600: if (pw_max > 16) pw_max = 16;
10697 break;
10698 case 9710: pw_min = 5;
10699 pw_max = 5;
10700 break;
10701 case 9810: pw_min = 5;
10702 pw_max = 5;
10703 break;
10704 case 10410: pw_min = 5;
10705 pw_max = 5;
10706 break;
10707 case 10300: if (pw_max < 3) pw_min = 3;
10708 if (pw_max > 40) pw_max = 40;
10709 break;
10710 case 10500: if (pw_max < 3) pw_min = 3;
10711 if (pw_max > 40) pw_max = 40;
10712 break;
10713 case 10700: if (pw_max > 16) pw_max = 16;
10714 break;
10715 case 11300: if (pw_max > 40) pw_max = 40;
10716 break;
10717 case 11600: if (pw_max > 32) pw_max = 32;
10718 break;
10719 case 12500: if (pw_max > 20) pw_max = 20;
10720 break;
10721 case 12800: if (pw_max > 24) pw_max = 24;
10722 break;
10723 }
10724
10725 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10726 {
10727 switch (attack_kern)
10728 {
10729 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10730 break;
10731 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10732 break;
10733 }
10734 }
10735
10736 /**
10737 * charsets : keep them together for more easy maintainnce
10738 */
10739
10740 cs_t mp_sys[6] = { { { 0 }, 0 } };
10741 cs_t mp_usr[4] = { { { 0 }, 0 } };
10742
10743 mp_setup_sys (mp_sys);
10744
10745 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10746 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10747 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10748 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10749
10750 /**
10751 * load hashes, part I: find input mode, count hashes
10752 */
10753
10754 uint hashlist_mode = 0;
10755 uint hashlist_format = HLFMT_HASHCAT;
10756
10757 uint hashes_avail = 0;
10758
10759 if (benchmark == 0)
10760 {
10761 struct stat f;
10762
10763 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10764
10765 if ((hash_mode == 2500) ||
10766 (hash_mode == 5200) ||
10767 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10768 (hash_mode == 9000))
10769 {
10770 hashlist_mode = HL_MODE_ARG;
10771
10772 char *hashfile = myargv[optind];
10773
10774 data.hashfile = hashfile;
10775
10776 logfile_top_var_string ("target", hashfile);
10777 }
10778
10779 if (hashlist_mode == HL_MODE_ARG)
10780 {
10781 if (hash_mode == 2500)
10782 {
10783 struct stat st;
10784
10785 if (stat (data.hashfile, &st) == -1)
10786 {
10787 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10788
10789 return (-1);
10790 }
10791
10792 hashes_avail = st.st_size / sizeof (hccap_t);
10793 }
10794 else
10795 {
10796 hashes_avail = 1;
10797 }
10798 }
10799 else if (hashlist_mode == HL_MODE_FILE)
10800 {
10801 char *hashfile = myargv[optind];
10802
10803 data.hashfile = hashfile;
10804
10805 logfile_top_var_string ("target", hashfile);
10806
10807 FILE *fp = NULL;
10808
10809 if ((fp = fopen (hashfile, "rb")) == NULL)
10810 {
10811 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10812
10813 return (-1);
10814 }
10815
10816 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10817
10818 hashes_avail = count_lines (fp);
10819
10820 rewind (fp);
10821
10822 if (hashes_avail == 0)
10823 {
10824 log_error ("ERROR: hashfile is empty or corrupt");
10825
10826 fclose (fp);
10827
10828 return (-1);
10829 }
10830
10831 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10832
10833 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10834 {
10835 log_error ("ERROR: remove not supported in native hashfile-format mode");
10836
10837 fclose (fp);
10838
10839 return (-1);
10840 }
10841
10842 fclose (fp);
10843 }
10844 }
10845 else
10846 {
10847 hashlist_mode = HL_MODE_ARG;
10848
10849 hashes_avail = 1;
10850 }
10851
10852 if (hash_mode == 3000) hashes_avail *= 2;
10853
10854 data.hashlist_mode = hashlist_mode;
10855 data.hashlist_format = hashlist_format;
10856
10857 logfile_top_uint (hashlist_mode);
10858 logfile_top_uint (hashlist_format);
10859
10860 /**
10861 * load hashes, part II: allocate required memory, set pointers
10862 */
10863
10864 hash_t *hashes_buf = NULL;
10865 void *digests_buf = NULL;
10866 salt_t *salts_buf = NULL;
10867 void *esalts_buf = NULL;
10868
10869 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10870
10871 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10872
10873 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10874 {
10875 u32 hash_pos;
10876
10877 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10878 {
10879 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10880
10881 hashes_buf[hash_pos].hash_info = hash_info;
10882
10883 if (username && (remove || show || left))
10884 {
10885 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10886 }
10887
10888 if (benchmark)
10889 {
10890 hash_info->orighash = (char *) mymalloc (256);
10891 }
10892 }
10893 }
10894
10895 if (isSalted)
10896 {
10897 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10898
10899 if (esalt_size)
10900 {
10901 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10902 }
10903 }
10904 else
10905 {
10906 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10907 }
10908
10909 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10910 {
10911 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10912
10913 if (isSalted)
10914 {
10915 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10916
10917 if (esalt_size)
10918 {
10919 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10920 }
10921 }
10922 else
10923 {
10924 hashes_buf[hash_pos].salt = &salts_buf[0];
10925 }
10926 }
10927
10928 /**
10929 * load hashes, part III: parse hashes or generate them if benchmark
10930 */
10931
10932 uint hashes_cnt = 0;
10933
10934 if (benchmark == 0)
10935 {
10936 if (keyspace == 1)
10937 {
10938 // useless to read hash file for keyspace, cheat a little bit w/ optind
10939 }
10940 else if (hashes_avail == 0)
10941 {
10942 }
10943 else if (hashlist_mode == HL_MODE_ARG)
10944 {
10945 char *input_buf = myargv[optind];
10946
10947 uint input_len = strlen (input_buf);
10948
10949 logfile_top_var_string ("target", input_buf);
10950
10951 char *hash_buf = NULL;
10952 int hash_len = 0;
10953
10954 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10955
10956 bool hash_fmt_error = 0;
10957
10958 if (hash_len < 1) hash_fmt_error = 1;
10959 if (hash_buf == NULL) hash_fmt_error = 1;
10960
10961 if (hash_fmt_error)
10962 {
10963 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10964 }
10965 else
10966 {
10967 if (opts_type & OPTS_TYPE_HASH_COPY)
10968 {
10969 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10970
10971 hash_info_tmp->orighash = mystrdup (hash_buf);
10972 }
10973
10974 if (isSalted)
10975 {
10976 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10977 }
10978
10979 int parser_status = PARSER_OK;
10980
10981 if (hash_mode == 2500)
10982 {
10983 if (hash_len == 0)
10984 {
10985 log_error ("ERROR: hccap file not specified");
10986
10987 return (-1);
10988 }
10989
10990 hashlist_mode = HL_MODE_FILE;
10991
10992 data.hashlist_mode = hashlist_mode;
10993
10994 FILE *fp = fopen (hash_buf, "rb");
10995
10996 if (fp == NULL)
10997 {
10998 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10999
11000 return (-1);
11001 }
11002
11003 if (hashes_avail < 1)
11004 {
11005 log_error ("ERROR: hccap file is empty or corrupt");
11006
11007 fclose (fp);
11008
11009 return (-1);
11010 }
11011
11012 uint hccap_size = sizeof (hccap_t);
11013
11014 char *in = (char *) mymalloc (hccap_size);
11015
11016 while (!feof (fp))
11017 {
11018 int n = fread (in, hccap_size, 1, fp);
11019
11020 if (n != 1)
11021 {
11022 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11023
11024 break;
11025 }
11026
11027 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11028
11029 if (parser_status != PARSER_OK)
11030 {
11031 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11032
11033 continue;
11034 }
11035
11036 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11037
11038 if ((show == 1) || (left == 1))
11039 {
11040 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11041
11042 char *salt_ptr = (char *) tmp_salt->salt_buf;
11043
11044 int cur_pos = tmp_salt->salt_len;
11045 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11046
11047 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11048
11049 // do the appending task
11050
11051 snprintf (salt_ptr + cur_pos,
11052 rem_len,
11053 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11054 wpa->orig_mac1[0],
11055 wpa->orig_mac1[1],
11056 wpa->orig_mac1[2],
11057 wpa->orig_mac1[3],
11058 wpa->orig_mac1[4],
11059 wpa->orig_mac1[5],
11060 wpa->orig_mac2[0],
11061 wpa->orig_mac2[1],
11062 wpa->orig_mac2[2],
11063 wpa->orig_mac2[3],
11064 wpa->orig_mac2[4],
11065 wpa->orig_mac2[5]);
11066
11067 // memset () the remaining part of the salt
11068
11069 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11070 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11071
11072 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11073
11074 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11075 }
11076
11077 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);
11078 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);
11079
11080 hashes_cnt++;
11081 }
11082
11083 fclose (fp);
11084
11085 myfree (in);
11086 }
11087 else if (hash_mode == 3000)
11088 {
11089 if (hash_len == 32)
11090 {
11091 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11092
11093 hash_t *lm_hash_left = NULL;
11094
11095 if (parser_status == PARSER_OK)
11096 {
11097 lm_hash_left = &hashes_buf[hashes_cnt];
11098
11099 hashes_cnt++;
11100 }
11101 else
11102 {
11103 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11104 }
11105
11106 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11107
11108 hash_t *lm_hash_right = NULL;
11109
11110 if (parser_status == PARSER_OK)
11111 {
11112 lm_hash_right = &hashes_buf[hashes_cnt];
11113
11114 hashes_cnt++;
11115 }
11116 else
11117 {
11118 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11119 }
11120
11121 // show / left
11122
11123 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11124 {
11125 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);
11126 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);
11127 }
11128 }
11129 else
11130 {
11131 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11132
11133 if (parser_status == PARSER_OK)
11134 {
11135 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11136 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11137 }
11138
11139 if (parser_status == PARSER_OK)
11140 {
11141 hashes_cnt++;
11142 }
11143 else
11144 {
11145 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11146 }
11147 }
11148 }
11149 else
11150 {
11151 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11152
11153 if (parser_status == PARSER_OK)
11154 {
11155 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11156 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11157 }
11158
11159 if (parser_status == PARSER_OK)
11160 {
11161 hashes_cnt++;
11162 }
11163 else
11164 {
11165 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11166 }
11167 }
11168 }
11169 }
11170 else if (hashlist_mode == HL_MODE_FILE)
11171 {
11172 char *hashfile = data.hashfile;
11173
11174 FILE *fp;
11175
11176 if ((fp = fopen (hashfile, "rb")) == NULL)
11177 {
11178 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11179
11180 return (-1);
11181 }
11182
11183 uint line_num = 0;
11184
11185 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11186
11187 while (!feof (fp))
11188 {
11189 line_num++;
11190
11191 int line_len = fgetl (fp, line_buf);
11192
11193 if (line_len == 0) continue;
11194
11195 char *hash_buf = NULL;
11196 int hash_len = 0;
11197
11198 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11199
11200 bool hash_fmt_error = 0;
11201
11202 if (hash_len < 1) hash_fmt_error = 1;
11203 if (hash_buf == NULL) hash_fmt_error = 1;
11204
11205 if (hash_fmt_error)
11206 {
11207 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11208
11209 continue;
11210 }
11211
11212 if (username)
11213 {
11214 char *user_buf = NULL;
11215 int user_len = 0;
11216
11217 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11218
11219 if (remove || show)
11220 {
11221 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11222
11223 *user = (user_t *) mymalloc (sizeof (user_t));
11224
11225 user_t *user_ptr = *user;
11226
11227 if (user_buf != NULL)
11228 {
11229 user_ptr->user_name = mystrdup (user_buf);
11230 }
11231 else
11232 {
11233 user_ptr->user_name = mystrdup ("");
11234 }
11235
11236 user_ptr->user_len = user_len;
11237 }
11238 }
11239
11240 if (opts_type & OPTS_TYPE_HASH_COPY)
11241 {
11242 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11243
11244 hash_info_tmp->orighash = mystrdup (hash_buf);
11245 }
11246
11247 if (isSalted)
11248 {
11249 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11250 }
11251
11252 if (hash_mode == 3000)
11253 {
11254 if (hash_len == 32)
11255 {
11256 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11257
11258 if (parser_status < PARSER_GLOBAL_ZERO)
11259 {
11260 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11261
11262 continue;
11263 }
11264
11265 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11266
11267 hashes_cnt++;
11268
11269 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11270
11271 if (parser_status < PARSER_GLOBAL_ZERO)
11272 {
11273 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11274
11275 continue;
11276 }
11277
11278 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11279
11280 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11281
11282 hashes_cnt++;
11283
11284 // show / left
11285
11286 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);
11287 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);
11288 }
11289 else
11290 {
11291 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11292
11293 if (parser_status < PARSER_GLOBAL_ZERO)
11294 {
11295 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11296
11297 continue;
11298 }
11299
11300 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);
11301
11302 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11303 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11304
11305 hashes_cnt++;
11306 }
11307 }
11308 else
11309 {
11310 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11311
11312 if (parser_status < PARSER_GLOBAL_ZERO)
11313 {
11314 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11315
11316 continue;
11317 }
11318
11319 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);
11320
11321 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11322 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11323
11324 hashes_cnt++;
11325 }
11326 }
11327
11328 myfree (line_buf);
11329
11330 fclose (fp);
11331
11332 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11333
11334 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11335 }
11336 }
11337 else
11338 {
11339 if (isSalted)
11340 {
11341 hashes_buf[0].salt->salt_len = 8;
11342
11343 // special salt handling
11344
11345 switch (hash_mode)
11346 {
11347 case 1500: hashes_buf[0].salt->salt_len = 2;
11348 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11349 break;
11350 case 1731: hashes_buf[0].salt->salt_len = 4;
11351 break;
11352 case 2410: hashes_buf[0].salt->salt_len = 4;
11353 break;
11354 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11355 break;
11356 case 3100: hashes_buf[0].salt->salt_len = 1;
11357 break;
11358 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11359 break;
11360 case 5800: hashes_buf[0].salt->salt_len = 16;
11361 break;
11362 case 6800: hashes_buf[0].salt->salt_len = 32;
11363 break;
11364 case 8400: hashes_buf[0].salt->salt_len = 40;
11365 break;
11366 case 8800: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 8900: hashes_buf[0].salt->salt_len = 16;
11369 hashes_buf[0].salt->scrypt_N = 1024;
11370 hashes_buf[0].salt->scrypt_r = 1;
11371 hashes_buf[0].salt->scrypt_p = 1;
11372 break;
11373 case 9100: hashes_buf[0].salt->salt_len = 16;
11374 break;
11375 case 9300: hashes_buf[0].salt->salt_len = 14;
11376 hashes_buf[0].salt->scrypt_N = 16384;
11377 hashes_buf[0].salt->scrypt_r = 1;
11378 hashes_buf[0].salt->scrypt_p = 1;
11379 break;
11380 case 9400: hashes_buf[0].salt->salt_len = 16;
11381 break;
11382 case 9500: hashes_buf[0].salt->salt_len = 16;
11383 break;
11384 case 9600: hashes_buf[0].salt->salt_len = 16;
11385 break;
11386 case 9700: hashes_buf[0].salt->salt_len = 16;
11387 break;
11388 case 9710: hashes_buf[0].salt->salt_len = 16;
11389 break;
11390 case 9720: hashes_buf[0].salt->salt_len = 16;
11391 break;
11392 case 9800: hashes_buf[0].salt->salt_len = 16;
11393 break;
11394 case 9810: hashes_buf[0].salt->salt_len = 16;
11395 break;
11396 case 9820: hashes_buf[0].salt->salt_len = 16;
11397 break;
11398 case 10300: hashes_buf[0].salt->salt_len = 12;
11399 break;
11400 case 11500: hashes_buf[0].salt->salt_len = 4;
11401 break;
11402 case 11600: hashes_buf[0].salt->salt_len = 4;
11403 break;
11404 case 12400: hashes_buf[0].salt->salt_len = 4;
11405 break;
11406 case 12500: hashes_buf[0].salt->salt_len = 8;
11407 break;
11408 case 12600: hashes_buf[0].salt->salt_len = 64;
11409 break;
11410 }
11411
11412 // special esalt handling
11413
11414 switch (hash_mode)
11415 {
11416 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11417 break;
11418 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11419 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11420 break;
11421 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11422 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11423 break;
11424 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11425 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11426 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11427 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11428 break;
11429 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11430 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11431 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11432 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11433 break;
11434 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11435 break;
11436 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11437 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11438 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11439 break;
11440 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11441 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11442 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11443 break;
11444 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11445 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11446 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11447 break;
11448 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11449 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11450 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11451 break;
11452 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11453 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11454 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11455 break;
11456 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11457 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11458 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11459 break;
11460 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11461 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11462 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11463 break;
11464 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11465 break;
11466 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11467 break;
11468 }
11469 }
11470
11471 // set hashfile
11472
11473 switch (hash_mode)
11474 {
11475 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11476 break;
11477 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11478 break;
11479 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11480 break;
11481 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11482 break;
11483 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11484 break;
11485 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11486 break;
11487 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11488 break;
11489 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11490 break;
11491 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11492 break;
11493 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11494 break;
11495 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11496 break;
11497 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11498 break;
11499 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11500 break;
11501 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11502 break;
11503 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11504 break;
11505 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11506 break;
11507 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11508 break;
11509 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11510 break;
11511 }
11512
11513 // set default iterations
11514
11515 switch (hash_mode)
11516 {
11517 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11518 break;
11519 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11520 break;
11521 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11522 break;
11523 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11524 break;
11525 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11526 break;
11527 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11528 break;
11529 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11530 break;
11531 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11532 break;
11533 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11534 break;
11535 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11536 break;
11537 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11538 break;
11539 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11540 break;
11541 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11542 break;
11543 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11544 break;
11545 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11546 break;
11547 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11548 break;
11549 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11550 break;
11551 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11552 break;
11553 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11554 break;
11555 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11556 break;
11557 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11558 break;
11559 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11560 break;
11561 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11562 break;
11563 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11564 break;
11565 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11566 break;
11567 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11568 break;
11569 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11570 break;
11571 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11572 break;
11573 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11574 break;
11575 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11576 break;
11577 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11578 break;
11579 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11580 break;
11581 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11582 break;
11583 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11584 break;
11585 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11586 break;
11587 case 8900: hashes_buf[0].salt->salt_iter = 1;
11588 break;
11589 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11590 break;
11591 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11592 break;
11593 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11594 break;
11595 case 9300: hashes_buf[0].salt->salt_iter = 1;
11596 break;
11597 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11598 break;
11599 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11600 break;
11601 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11602 break;
11603 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11604 break;
11605 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11606 break;
11607 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11608 break;
11609 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11610 break;
11611 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11612 break;
11613 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11614 break;
11615 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11616 break;
11617 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11618 break;
11619 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11620 break;
11621 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11622 break;
11623 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11624 break;
11625 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11626 break;
11627 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11628 break;
11629 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11630 break;
11631 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11632 break;
11633 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11634 break;
11635 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11636 break;
11637 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11638 break;
11639 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11640 break;
11641 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11642 break;
11643 }
11644
11645 hashes_cnt = 1;
11646 }
11647
11648 if (show == 1 || left == 1)
11649 {
11650 for (uint i = 0; i < pot_cnt; i++)
11651 {
11652 pot_t *pot_ptr = &pot[i];
11653
11654 hash_t *hashes_buf = &pot_ptr->hash;
11655
11656 local_free (hashes_buf->digest);
11657
11658 if (isSalted)
11659 {
11660 local_free (hashes_buf->salt);
11661 }
11662 }
11663
11664 local_free (pot);
11665
11666 if (data.quiet == 0) log_info_nn ("");
11667
11668 return (0);
11669 }
11670
11671 if (keyspace == 0)
11672 {
11673 if (hashes_cnt == 0)
11674 {
11675 log_error ("ERROR: No hashes loaded");
11676
11677 return (-1);
11678 }
11679 }
11680
11681 /**
11682 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11683 */
11684
11685 if (data.outfile != NULL)
11686 {
11687 if (data.hashfile != NULL)
11688 {
11689 #ifdef _POSIX
11690 struct stat tmpstat_outfile;
11691 struct stat tmpstat_hashfile;
11692 #endif
11693
11694 #ifdef _WIN
11695 struct stat64 tmpstat_outfile;
11696 struct stat64 tmpstat_hashfile;
11697 #endif
11698
11699 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11700
11701 if (tmp_outfile_fp)
11702 {
11703 #ifdef _POSIX
11704 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11705 #endif
11706
11707 #ifdef _WIN
11708 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11709 #endif
11710
11711 fclose (tmp_outfile_fp);
11712 }
11713
11714 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11715
11716 if (tmp_hashfile_fp)
11717 {
11718 #ifdef _POSIX
11719 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11720 #endif
11721
11722 #ifdef _WIN
11723 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11724 #endif
11725
11726 fclose (tmp_hashfile_fp);
11727 }
11728
11729 if (tmp_outfile_fp && tmp_outfile_fp)
11730 {
11731 tmpstat_outfile.st_mode = 0;
11732 tmpstat_outfile.st_nlink = 0;
11733 tmpstat_outfile.st_uid = 0;
11734 tmpstat_outfile.st_gid = 0;
11735 tmpstat_outfile.st_rdev = 0;
11736 tmpstat_outfile.st_atime = 0;
11737
11738 tmpstat_hashfile.st_mode = 0;
11739 tmpstat_hashfile.st_nlink = 0;
11740 tmpstat_hashfile.st_uid = 0;
11741 tmpstat_hashfile.st_gid = 0;
11742 tmpstat_hashfile.st_rdev = 0;
11743 tmpstat_hashfile.st_atime = 0;
11744
11745 #ifdef _POSIX
11746 tmpstat_outfile.st_blksize = 0;
11747 tmpstat_outfile.st_blocks = 0;
11748
11749 tmpstat_hashfile.st_blksize = 0;
11750 tmpstat_hashfile.st_blocks = 0;
11751 #endif
11752
11753 #ifdef _POSIX
11754 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11755 {
11756 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11757
11758 return (-1);
11759 }
11760 #endif
11761
11762 #ifdef _WIN
11763 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11764 {
11765 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11766
11767 return (-1);
11768 }
11769 #endif
11770 }
11771 }
11772 }
11773
11774 /**
11775 * Remove duplicates
11776 */
11777
11778 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11779
11780 if (isSalted)
11781 {
11782 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11783 }
11784 else
11785 {
11786 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11787 }
11788
11789 uint hashes_cnt_orig = hashes_cnt;
11790
11791 hashes_cnt = 1;
11792
11793 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11794 {
11795 if (isSalted)
11796 {
11797 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11798 {
11799 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11800 }
11801 }
11802 else
11803 {
11804 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11805 }
11806
11807 if (hashes_pos > hashes_cnt)
11808 {
11809 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11810 }
11811
11812 hashes_cnt++;
11813 }
11814
11815 /**
11816 * Potfile removes
11817 */
11818
11819 uint potfile_remove_cracks = 0;
11820
11821 if (potfile_disable == 0)
11822 {
11823 hash_t hash_buf;
11824
11825 hash_buf.digest = mymalloc (dgst_size);
11826 hash_buf.salt = NULL;
11827 hash_buf.esalt = NULL;
11828 hash_buf.hash_info = NULL;
11829 hash_buf.cracked = 0;
11830
11831 if (isSalted)
11832 {
11833 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11834 }
11835
11836 if (esalt_size)
11837 {
11838 hash_buf.esalt = mymalloc (esalt_size);
11839 }
11840
11841 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11842
11843 // no solution for these special hash types (for instane because they use hashfile in output etc)
11844 if ((hash_mode != 5200) &&
11845 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11846 (hash_mode != 9000))
11847 {
11848 FILE *fp = fopen (potfile, "rb");
11849
11850 if (fp != NULL)
11851 {
11852 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11853
11854 // to be safe work with a copy (because of line_len loop, i etc)
11855 // moved up here because it's easier to handle continue case
11856 // it's just 64kb
11857
11858 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11859
11860 while (!feof (fp))
11861 {
11862 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11863
11864 if (ptr == NULL) break;
11865
11866 int line_len = strlen (line_buf);
11867
11868 if (line_len == 0) continue;
11869
11870 int iter = MAX_CUT_TRIES;
11871
11872 for (int i = line_len - 1; i && iter; i--, line_len--)
11873 {
11874 if (line_buf[i] != ':') continue;
11875
11876 if (isSalted)
11877 {
11878 memset (hash_buf.salt, 0, sizeof (salt_t));
11879 }
11880
11881 hash_t *found = NULL;
11882
11883 if (hash_mode == 6800)
11884 {
11885 if (i < 64) // 64 = 16 * uint in salt_buf[]
11886 {
11887 // manipulate salt_buf
11888 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11889
11890 hash_buf.salt->salt_len = i;
11891
11892 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11893 }
11894 }
11895 else if (hash_mode == 2500)
11896 {
11897 if (i < 64) // 64 = 16 * uint in salt_buf[]
11898 {
11899 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11900 // manipulate salt_buf
11901
11902 memcpy (line_buf_cpy, line_buf, i);
11903
11904 char *mac2_pos = strrchr (line_buf_cpy, ':');
11905
11906 if (mac2_pos == NULL) continue;
11907
11908 mac2_pos[0] = 0;
11909 mac2_pos++;
11910
11911 if (strlen (mac2_pos) != 12) continue;
11912
11913 char *mac1_pos = strrchr (line_buf_cpy, ':');
11914
11915 if (mac1_pos == NULL) continue;
11916
11917 mac1_pos[0] = 0;
11918 mac1_pos++;
11919
11920 if (strlen (mac1_pos) != 12) continue;
11921
11922 uint essid_length = mac1_pos - line_buf_cpy - 1;
11923
11924 // here we need the ESSID
11925 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11926
11927 hash_buf.salt->salt_len = essid_length;
11928
11929 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11930
11931 if (found)
11932 {
11933 wpa_t *wpa = (wpa_t *) found->esalt;
11934
11935 // compare hex string(s) vs binary MAC address(es)
11936
11937 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11938 {
11939 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11940 {
11941 found = NULL;
11942
11943 break;
11944 }
11945 }
11946
11947 // early skip ;)
11948 if (!found) continue;
11949
11950 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11951 {
11952 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11953 {
11954 found = NULL;
11955
11956 break;
11957 }
11958 }
11959 }
11960 }
11961 }
11962 else
11963 {
11964 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11965
11966 if (parser_status == PARSER_OK)
11967 {
11968 if (isSalted)
11969 {
11970 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11971 }
11972 else
11973 {
11974 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11975 }
11976 }
11977 }
11978
11979 if (found == NULL) continue;
11980
11981 if (!found->cracked) potfile_remove_cracks++;
11982
11983 found->cracked = 1;
11984
11985 if (found) break;
11986
11987 iter--;
11988 }
11989 }
11990
11991 myfree (line_buf_cpy);
11992
11993 myfree (line_buf);
11994
11995 fclose (fp);
11996 }
11997 }
11998
11999 if (esalt_size)
12000 {
12001 local_free (hash_buf.esalt);
12002 }
12003
12004 if (isSalted)
12005 {
12006 local_free (hash_buf.salt);
12007 }
12008
12009 local_free (hash_buf.digest);
12010 }
12011
12012 /**
12013 * Now generate all the buffers required for later
12014 */
12015
12016 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12017
12018 salt_t *salts_buf_new = NULL;
12019 void *esalts_buf_new = NULL;
12020
12021 if (isSalted)
12022 {
12023 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12024
12025 if (esalt_size)
12026 {
12027 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12028 }
12029 }
12030 else
12031 {
12032 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12033 }
12034
12035 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12036
12037 uint digests_cnt = hashes_cnt;
12038 uint digests_done = 0;
12039
12040 size_t size_digests = digests_cnt * dgst_size;
12041 size_t size_shown = digests_cnt * sizeof (uint);
12042
12043 uint *digests_shown = (uint *) mymalloc (size_shown);
12044 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12045
12046 uint salts_cnt = 0;
12047 uint salts_done = 0;
12048
12049 hashinfo_t **hash_info = NULL;
12050
12051 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12052 {
12053 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12054
12055 if (username && (remove || show))
12056 {
12057 uint user_pos;
12058
12059 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12060 {
12061 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12062
12063 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12064 }
12065 }
12066 }
12067
12068 uint *salts_shown = (uint *) mymalloc (size_shown);
12069
12070 salt_t *salt_buf;
12071
12072 {
12073 // copied from inner loop
12074
12075 salt_buf = &salts_buf_new[salts_cnt];
12076
12077 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12078
12079 if (esalt_size)
12080 {
12081 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12082 }
12083
12084 salt_buf->digests_cnt = 0;
12085 salt_buf->digests_done = 0;
12086 salt_buf->digests_offset = 0;
12087
12088 salts_cnt++;
12089 }
12090
12091 if (hashes_buf[0].cracked == 1)
12092 {
12093 digests_shown[0] = 1;
12094
12095 digests_done++;
12096
12097 salt_buf->digests_done++;
12098 }
12099
12100 salt_buf->digests_cnt++;
12101
12102 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12103
12104 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12105 {
12106 hash_info[0] = hashes_buf[0].hash_info;
12107 }
12108
12109 // copy from inner loop
12110
12111 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12112 {
12113 if (isSalted)
12114 {
12115 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12116 {
12117 salt_buf = &salts_buf_new[salts_cnt];
12118
12119 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12120
12121 if (esalt_size)
12122 {
12123 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12124 }
12125
12126 salt_buf->digests_cnt = 0;
12127 salt_buf->digests_done = 0;
12128 salt_buf->digests_offset = hashes_pos;
12129
12130 salts_cnt++;
12131 }
12132 }
12133
12134 if (hashes_buf[hashes_pos].cracked == 1)
12135 {
12136 digests_shown[hashes_pos] = 1;
12137
12138 digests_done++;
12139
12140 salt_buf->digests_done++;
12141 }
12142
12143 salt_buf->digests_cnt++;
12144
12145 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12146
12147 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12148 {
12149 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12150 }
12151 }
12152
12153 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12154 {
12155 salt_t *salt_buf = &salts_buf_new[salt_pos];
12156
12157 if (salt_buf->digests_done == salt_buf->digests_cnt)
12158 {
12159 salts_shown[salt_pos] = 1;
12160
12161 salts_done++;
12162 }
12163
12164 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12165 }
12166
12167 local_free (digests_buf);
12168 local_free (salts_buf);
12169 local_free (esalts_buf);
12170
12171 digests_buf = digests_buf_new;
12172 salts_buf = salts_buf_new;
12173 esalts_buf = esalts_buf_new;
12174
12175 local_free (hashes_buf);
12176
12177 /**
12178 * special modification not set from parser
12179 */
12180
12181 switch (hash_mode)
12182 {
12183 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12184 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12185 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12186 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12187 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12188 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12189 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12190 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12191 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12192 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12193 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12194 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12195 }
12196
12197 if (truecrypt_keyfiles)
12198 {
12199 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12200
12201 char *keyfiles = strdup (truecrypt_keyfiles);
12202
12203 char *keyfile = strtok (keyfiles, ",");
12204
12205 do
12206 {
12207 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12208
12209 } while ((keyfile = strtok (NULL, ",")) != NULL);
12210
12211 free (keyfiles);
12212 }
12213
12214 data.digests_cnt = digests_cnt;
12215 data.digests_done = digests_done;
12216 data.digests_buf = digests_buf;
12217 data.digests_shown = digests_shown;
12218 data.digests_shown_tmp = digests_shown_tmp;
12219
12220 data.salts_cnt = salts_cnt;
12221 data.salts_done = salts_done;
12222 data.salts_buf = salts_buf;
12223 data.salts_shown = salts_shown;
12224
12225 data.esalts_buf = esalts_buf;
12226 data.hash_info = hash_info;
12227
12228 /**
12229 * Automatic Optimizers
12230 */
12231
12232 if (salts_cnt == 1)
12233 opti_type |= OPTI_TYPE_SINGLE_SALT;
12234
12235 if (digests_cnt == 1)
12236 opti_type |= OPTI_TYPE_SINGLE_HASH;
12237
12238 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12239 opti_type |= OPTI_TYPE_NOT_ITERATED;
12240
12241 if (attack_mode == ATTACK_MODE_BF)
12242 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12243
12244 data.opti_type = opti_type;
12245
12246 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12247 {
12248 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12249 {
12250 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12251 {
12252 if (opts_type & OPTS_TYPE_ST_ADD80)
12253 {
12254 opts_type &= ~OPTS_TYPE_ST_ADD80;
12255 opts_type |= OPTS_TYPE_PT_ADD80;
12256 }
12257
12258 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12259 {
12260 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12261 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12262 }
12263
12264 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12265 {
12266 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12267 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12268 }
12269 }
12270 }
12271 }
12272
12273 /**
12274 * Some algorithm, like descrypt, can benefit from JIT compilation
12275 */
12276
12277 int force_jit_compilation = -1;
12278
12279 if (hash_mode == 8900)
12280 {
12281 force_jit_compilation = 8900;
12282 }
12283 else if (hash_mode == 9300)
12284 {
12285 force_jit_compilation = 8900;
12286 }
12287 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12288 {
12289 force_jit_compilation = 1500;
12290 }
12291
12292 /**
12293 * generate bitmap tables
12294 */
12295
12296 const uint bitmap_shift1 = 5;
12297 const uint bitmap_shift2 = 13;
12298
12299 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12300
12301 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12302 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12303 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12304 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12305 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12306 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12307 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12308 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12309
12310 uint bitmap_bits;
12311 uint bitmap_nums;
12312 uint bitmap_mask;
12313 uint bitmap_size;
12314
12315 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12316 {
12317 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12318
12319 bitmap_nums = 1 << bitmap_bits;
12320
12321 bitmap_mask = bitmap_nums - 1;
12322
12323 bitmap_size = bitmap_nums * sizeof (uint);
12324
12325 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12326
12327 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;
12328 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;
12329
12330 break;
12331 }
12332
12333 bitmap_nums = 1 << bitmap_bits;
12334
12335 bitmap_mask = bitmap_nums - 1;
12336
12337 bitmap_size = bitmap_nums * sizeof (uint);
12338
12339 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);
12340 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);
12341
12342 /**
12343 * prepare quick rule
12344 */
12345
12346 data.rule_buf_l = rule_buf_l;
12347 data.rule_buf_r = rule_buf_r;
12348
12349 int rule_len_l = (int) strlen (rule_buf_l);
12350 int rule_len_r = (int) strlen (rule_buf_r);
12351
12352 data.rule_len_l = rule_len_l;
12353 data.rule_len_r = rule_len_r;
12354
12355 /**
12356 * load rules
12357 */
12358
12359 uint *all_kernel_rules_cnt = NULL;
12360
12361 kernel_rule_t **all_kernel_rules_buf = NULL;
12362
12363 if (rp_files_cnt)
12364 {
12365 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12366
12367 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12368 }
12369
12370 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12371
12372 int rule_len = 0;
12373
12374 for (uint i = 0; i < rp_files_cnt; i++)
12375 {
12376 uint kernel_rules_avail = 0;
12377
12378 uint kernel_rules_cnt = 0;
12379
12380 kernel_rule_t *kernel_rules_buf = NULL;
12381
12382 char *rp_file = rp_files[i];
12383
12384 char in[BLOCK_SIZE] = { 0 };
12385 char out[BLOCK_SIZE] = { 0 };
12386
12387 FILE *fp = NULL;
12388
12389 uint rule_line = 0;
12390
12391 if ((fp = fopen (rp_file, "rb")) == NULL)
12392 {
12393 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12394
12395 return (-1);
12396 }
12397
12398 while (!feof (fp))
12399 {
12400 memset (rule_buf, 0, HCBUFSIZ);
12401
12402 rule_len = fgetl (fp, rule_buf);
12403
12404 rule_line++;
12405
12406 if (rule_len == 0) continue;
12407
12408 if (rule_buf[0] == '#') continue;
12409
12410 if (kernel_rules_avail == kernel_rules_cnt)
12411 {
12412 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12413
12414 kernel_rules_avail += INCR_RULES;
12415 }
12416
12417 memset (in, 0, BLOCK_SIZE);
12418 memset (out, 0, BLOCK_SIZE);
12419
12420 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12421
12422 if (result == -1)
12423 {
12424 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12425
12426 continue;
12427 }
12428
12429 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12430 {
12431 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12432
12433 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12434
12435 continue;
12436 }
12437
12438 /* its so slow
12439 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12440 {
12441 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12442
12443 continue;
12444 }
12445 */
12446
12447 kernel_rules_cnt++;
12448 }
12449
12450 fclose (fp);
12451
12452 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12453
12454 all_kernel_rules_buf[i] = kernel_rules_buf;
12455 }
12456
12457 /**
12458 * merge rules or automatic rule generator
12459 */
12460
12461 uint kernel_rules_cnt = 0;
12462
12463 kernel_rule_t *kernel_rules_buf = NULL;
12464
12465 if (attack_mode == ATTACK_MODE_STRAIGHT)
12466 {
12467 if (rp_files_cnt)
12468 {
12469 kernel_rules_cnt = 1;
12470
12471 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12472
12473 repeats[0] = kernel_rules_cnt;
12474
12475 for (uint i = 0; i < rp_files_cnt; i++)
12476 {
12477 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12478
12479 repeats[i + 1] = kernel_rules_cnt;
12480 }
12481
12482 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12483
12484 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12485
12486 for (uint i = 0; i < kernel_rules_cnt; i++)
12487 {
12488 uint out_pos = 0;
12489
12490 kernel_rule_t *out = &kernel_rules_buf[i];
12491
12492 for (uint j = 0; j < rp_files_cnt; j++)
12493 {
12494 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12495 uint in_pos;
12496
12497 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12498
12499 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12500 {
12501 if (out_pos == RULES_MAX - 1)
12502 {
12503 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12504
12505 break;
12506 }
12507
12508 out->cmds[out_pos] = in->cmds[in_pos];
12509 }
12510 }
12511 }
12512
12513 local_free (repeats);
12514 }
12515 else if (rp_gen)
12516 {
12517 uint kernel_rules_avail = 0;
12518
12519 while (kernel_rules_cnt < rp_gen)
12520 {
12521 if (kernel_rules_avail == kernel_rules_cnt)
12522 {
12523 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12524
12525 kernel_rules_avail += INCR_RULES;
12526 }
12527
12528 memset (rule_buf, 0, HCBUFSIZ);
12529
12530 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12531
12532 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12533
12534 kernel_rules_cnt++;
12535 }
12536 }
12537 }
12538
12539 myfree (rule_buf);
12540
12541 /**
12542 * generate NOP rules
12543 */
12544
12545 if (kernel_rules_cnt == 0)
12546 {
12547 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12548
12549 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12550
12551 kernel_rules_cnt++;
12552 }
12553
12554 data.kernel_rules_cnt = kernel_rules_cnt;
12555 data.kernel_rules_buf = kernel_rules_buf;
12556
12557 /**
12558 * OpenCL platforms: detect
12559 */
12560
12561 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12562 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12563
12564 cl_uint platforms_cnt = 0;
12565 cl_uint platform_devices_cnt = 0;
12566
12567 if (keyspace == 0)
12568 {
12569 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12570
12571 if (platforms_cnt == 0)
12572 {
12573 log_error ("ERROR: No OpenCL compatible platform found");
12574
12575 return (-1);
12576 }
12577
12578 if (opencl_platforms_filter != (uint) -1)
12579 {
12580 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12581
12582 if (opencl_platforms_filter > platform_cnt_mask)
12583 {
12584 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12585
12586 return (-1);
12587 }
12588 }
12589 }
12590
12591 /**
12592 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12593 */
12594
12595 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12596 {
12597 cl_platform_id platform = platforms[platform_id];
12598
12599 char platform_vendor[INFOSZ] = { 0 };
12600
12601 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12602
12603 #ifdef HAVE_HWMON
12604 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12605 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12606 {
12607 // make sure that we do not directly control the fan for NVidia
12608
12609 gpu_temp_retain = 0;
12610
12611 data.gpu_temp_retain = gpu_temp_retain;
12612 }
12613 #endif // HAVE_NVML || HAVE_NVAPI
12614 #endif
12615 }
12616
12617 /**
12618 * OpenCL devices: simply push all devices from all platforms into the same device array
12619 */
12620
12621 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12622
12623 data.devices_param = devices_param;
12624
12625 uint devices_cnt = 0;
12626
12627 uint devices_active = 0;
12628
12629 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12630 {
12631 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12632
12633 cl_platform_id platform = platforms[platform_id];
12634
12635 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12636
12637 char platform_vendor[INFOSZ] = { 0 };
12638
12639 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12640
12641 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
12642 // this causes trouble with vendor id based macros
12643 // we'll assign generic to those without special optimization available
12644
12645 cl_uint vendor_id = 0;
12646
12647 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
12648 {
12649 vendor_id = VENDOR_ID_AMD;
12650 }
12651 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
12652 {
12653 vendor_id = VENDOR_ID_GENERIC;
12654 }
12655 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
12656 {
12657 vendor_id = VENDOR_ID_GENERIC;
12658 }
12659 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
12660 {
12661 vendor_id = VENDOR_ID_GENERIC;
12662 }
12663 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
12664 {
12665 vendor_id = VENDOR_ID_GENERIC;
12666 }
12667 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12668 {
12669 vendor_id = VENDOR_ID_NV;
12670 }
12671 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
12672 {
12673 vendor_id = VENDOR_ID_GENERIC;
12674 }
12675 else
12676 {
12677 vendor_id = VENDOR_ID_GENERIC;
12678 }
12679
12680 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12681 {
12682 size_t param_value_size = 0;
12683
12684 const uint device_id = devices_cnt;
12685
12686 hc_device_param_t *device_param = &data.devices_param[device_id];
12687
12688 device_param->vendor_id = vendor_id;
12689
12690 device_param->device = platform_devices[platform_devices_id];
12691
12692 device_param->device_id = device_id;
12693
12694 device_param->platform_devices_id = platform_devices_id;
12695
12696 // device_type
12697
12698 cl_device_type device_type;
12699
12700 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12701
12702 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12703
12704 device_param->device_type = device_type;
12705
12706 // device_name
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12709
12710 char *device_name = (char *) mymalloc (param_value_size);
12711
12712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12713
12714 device_param->device_name = device_name;
12715
12716 // tuning db
12717
12718 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12719
12720 // device_version
12721
12722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12723
12724 char *device_version = (char *) mymalloc (param_value_size);
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12727
12728 device_param->device_version = device_version;
12729
12730 // device_opencl_version
12731
12732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12733
12734 char *device_opencl_version = (char *) mymalloc (param_value_size);
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12737
12738 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12739
12740 myfree (device_opencl_version);
12741
12742 // vector_width
12743
12744 cl_uint vector_width;
12745
12746 if (opencl_vector_width_chgd == 0)
12747 {
12748 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12749 {
12750 if (opti_type & OPTI_TYPE_USES_BITS_64)
12751 {
12752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12753 }
12754 else
12755 {
12756 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12757 }
12758 }
12759 else
12760 {
12761 vector_width = (cl_uint) tuningdb_entry->vector_width;
12762 }
12763 }
12764 else
12765 {
12766 vector_width = opencl_vector_width;
12767 }
12768
12769 if (vector_width > 16) vector_width = 16;
12770
12771 device_param->vector_width = vector_width;
12772
12773 // max_compute_units
12774
12775 cl_uint device_processors;
12776
12777 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12778
12779 device_param->device_processors = device_processors;
12780
12781 // device_maxmem_alloc
12782 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
12783
12784 cl_ulong device_maxmem_alloc;
12785
12786 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12787
12788 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
12789
12790 // device_global_mem
12791
12792 cl_ulong device_global_mem;
12793
12794 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12795
12796 device_param->device_global_mem = device_global_mem;
12797
12798 // max_work_group_size
12799
12800 size_t device_maxworkgroup_size;
12801
12802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
12803
12804 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
12805
12806 // max_clock_frequency
12807
12808 cl_uint device_maxclock_frequency;
12809
12810 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12811
12812 device_param->device_maxclock_frequency = device_maxclock_frequency;
12813
12814 // device_endian_little
12815
12816 cl_bool device_endian_little;
12817
12818 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
12819
12820 if (device_endian_little == CL_FALSE)
12821 {
12822 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
12823
12824 device_param->skipped = 1;
12825 }
12826
12827 // device_available
12828
12829 cl_bool device_available;
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
12832
12833 if (device_available == CL_FALSE)
12834 {
12835 log_info ("Device #%u: WARNING: device not available", device_id + 1);
12836
12837 device_param->skipped = 1;
12838 }
12839
12840 // device_compiler_available
12841
12842 cl_bool device_compiler_available;
12843
12844 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
12845
12846 if (device_compiler_available == CL_FALSE)
12847 {
12848 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
12849
12850 device_param->skipped = 1;
12851 }
12852
12853 // device_execution_capabilities
12854
12855 cl_device_exec_capabilities device_execution_capabilities;
12856
12857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
12858
12859 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
12860 {
12861 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
12862
12863 device_param->skipped = 1;
12864 }
12865
12866 // device_extensions
12867
12868 size_t device_extensions_size;
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
12871
12872 char *device_extensions = mymalloc (device_extensions_size + 1);
12873
12874 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
12875
12876 if (strstr (device_extensions, "base_atomics") == 0)
12877 {
12878 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
12879
12880 device_param->skipped = 1;
12881 }
12882
12883 if (strstr (device_extensions, "byte_addressable_store") == 0)
12884 {
12885 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
12886
12887 device_param->skipped = 1;
12888 }
12889
12890 myfree (device_extensions);
12891
12892 // device_local_mem_size
12893
12894 cl_ulong device_local_mem_size;
12895
12896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
12897
12898 if (device_local_mem_size < 32768)
12899 {
12900 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
12901
12902 device_param->skipped = 1;
12903 }
12904
12905
12906 // skipped
12907
12908 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
12909 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
12910
12911 // driver_version
12912
12913 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12914
12915 char *driver_version = (char *) mymalloc (param_value_size);
12916
12917 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12918
12919 device_param->driver_version = driver_version;
12920
12921 // device_name_chksum
12922
12923 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12924
12925 #if __x86_64__
12926 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);
12927 #else
12928 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);
12929 #endif
12930
12931 uint device_name_digest[4] = { 0 };
12932
12933 md5_64 ((uint *) device_name_chksum, device_name_digest);
12934
12935 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12936
12937 device_param->device_name_chksum = device_name_chksum;
12938
12939 // device_processor_cores
12940
12941 if (device_type & CL_DEVICE_TYPE_CPU)
12942 {
12943 cl_uint device_processor_cores = 1;
12944
12945 device_param->device_processor_cores = device_processor_cores;
12946 }
12947
12948 if (device_type & CL_DEVICE_TYPE_GPU)
12949 {
12950 if (vendor_id == VENDOR_ID_AMD)
12951 {
12952 cl_uint device_processor_cores = 0;
12953
12954 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12955
12956 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12957
12958 device_param->device_processor_cores = device_processor_cores;
12959 }
12960 else if (vendor_id == VENDOR_ID_NV)
12961 {
12962 cl_uint kernel_exec_timeout = 0;
12963
12964 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12965
12966 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12967
12968 device_param->kernel_exec_timeout = kernel_exec_timeout;
12969
12970 cl_uint device_processor_cores = 0;
12971
12972 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12973
12974 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12975
12976 device_param->device_processor_cores = device_processor_cores;
12977
12978 cl_uint sm_minor = 0;
12979 cl_uint sm_major = 0;
12980
12981 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12982 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12983
12984 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12985 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12986
12987 device_param->sm_minor = sm_minor;
12988 device_param->sm_major = sm_major;
12989 }
12990 else
12991 {
12992 cl_uint device_processor_cores = 1;
12993
12994 device_param->device_processor_cores = device_processor_cores;
12995 }
12996 }
12997
12998 // display results
12999
13000 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13001 {
13002 if (device_param->skipped == 0)
13003 {
13004 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13005 device_id + 1,
13006 device_name,
13007 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13008 (unsigned int) (device_global_mem / 1024 / 1024),
13009 (unsigned int) (device_maxclock_frequency),
13010 (unsigned int) device_processors);
13011 }
13012 else
13013 {
13014 log_info ("Device #%u: %s, skipped",
13015 device_id + 1,
13016 device_name);
13017 }
13018 }
13019
13020 // common driver check
13021
13022 if (device_param->skipped == 0)
13023 {
13024 if (device_type & CL_DEVICE_TYPE_GPU)
13025 {
13026 if (vendor_id == VENDOR_ID_AMD)
13027 {
13028 int catalyst_check = (force == 1) ? 0 : 1;
13029
13030 int catalyst_warn = 0;
13031
13032 int catalyst_broken = 0;
13033
13034 if (catalyst_check == 1)
13035 {
13036 catalyst_warn = 1;
13037
13038 // v14.9 and higher
13039 if (atoi (device_param->driver_version) >= 1573)
13040 {
13041 catalyst_warn = 0;
13042 }
13043
13044 catalyst_check = 0;
13045 }
13046
13047 if (catalyst_broken == 1)
13048 {
13049 log_info ("");
13050 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13051 log_info ("It will pass over cracked hashes and does not report them as cracked");
13052 log_info ("You are STRONGLY encouraged not to use it");
13053 log_info ("You can use --force to override this but do not post error reports if you do so");
13054 log_info ("");
13055
13056 return (-1);
13057 }
13058
13059 if (catalyst_warn == 1)
13060 {
13061 log_info ("");
13062 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13063 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13064 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13065 #ifdef _WIN
13066 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13067 #endif
13068 log_info ("You can use --force to override this but do not post error reports if you do so");
13069 log_info ("");
13070
13071 return (-1);
13072 }
13073 }
13074 else if (vendor_id == VENDOR_ID_NV)
13075 {
13076 if (device_param->kernel_exec_timeout != 0)
13077 {
13078 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);
13079 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13080 }
13081 }
13082 }
13083
13084 if (device_type & CL_DEVICE_TYPE_CPU)
13085 {
13086 if (vendor_id == VENDOR_ID_AMD)
13087 {
13088 if (force == 0)
13089 {
13090 log_info ("");
13091 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13092 log_info ("You are STRONGLY encouraged not to use it");
13093 log_info ("You can use --force to override this but do not post error reports if you do so");
13094 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13095 log_info ("");
13096
13097 return (-1);
13098 }
13099 }
13100 }
13101
13102 /**
13103 * kernel accel and loops tuning db adjustment
13104 */
13105
13106 device_param->kernel_accel_min = 1;
13107 device_param->kernel_accel_max = 1024;
13108
13109 device_param->kernel_loops_min = 1;
13110 device_param->kernel_loops_max = 1024;
13111
13112 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13113
13114 if (tuningdb_entry)
13115 {
13116 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13117 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13118
13119 if (_kernel_accel)
13120 {
13121 device_param->kernel_accel_min = _kernel_accel;
13122 device_param->kernel_accel_max = _kernel_accel;
13123 }
13124
13125 if (_kernel_loops)
13126 {
13127 if (workload_profile == 1)
13128 {
13129 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13130 }
13131 else if (workload_profile == 2)
13132 {
13133 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13134 }
13135
13136 device_param->kernel_loops_min = _kernel_loops;
13137 device_param->kernel_loops_max = _kernel_loops;
13138 }
13139 }
13140
13141 // commandline parameters overwrite tuningdb entries
13142
13143 if (kernel_accel)
13144 {
13145 device_param->kernel_accel_min = kernel_accel;
13146 device_param->kernel_accel_max = kernel_accel;
13147 }
13148
13149 if (kernel_loops)
13150 {
13151 device_param->kernel_loops_min = kernel_loops;
13152 device_param->kernel_loops_max = kernel_loops;
13153 }
13154
13155 /**
13156 * activate device
13157 */
13158
13159 devices_active++;
13160 }
13161
13162 // next please
13163
13164 devices_cnt++;
13165 }
13166 }
13167
13168 if (keyspace == 0 && devices_active == 0)
13169 {
13170 log_error ("ERROR: No devices found/left");
13171
13172 return (-1);
13173 }
13174
13175 // 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)
13176
13177 if (devices_filter != (uint) -1)
13178 {
13179 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13180
13181 if (devices_filter > devices_cnt_mask)
13182 {
13183 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13184
13185 return (-1);
13186 }
13187 }
13188
13189 data.devices_cnt = devices_cnt;
13190
13191 data.devices_active = devices_active;
13192
13193 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13194 {
13195 log_info ("");
13196 }
13197
13198 /**
13199 * HM devices: init
13200 */
13201
13202 #ifdef HAVE_HWMON
13203 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13204 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13205 #endif
13206
13207 #ifdef HAVE_ADL
13208 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13209 #endif
13210
13211 if (gpu_temp_disable == 0)
13212 {
13213 #if defined(WIN) && defined(HAVE_NVAPI)
13214 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13215
13216 if (nvapi_init (nvapi) == 0)
13217 data.hm_nv = nvapi;
13218
13219 if (data.hm_nv)
13220 {
13221 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13222 {
13223 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13224
13225 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13226
13227 int tmp_out = 0;
13228
13229 for (int i = 0; i < tmp_in; i++)
13230 {
13231 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13232 }
13233
13234 for (int i = 0; i < tmp_out; i++)
13235 {
13236 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13237
13238 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13239
13240 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;
13241 }
13242 }
13243 }
13244 #endif // WIN && HAVE_NVAPI
13245
13246 #if defined(LINUX) && defined(HAVE_NVML)
13247 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13248
13249 if (nvml_init (nvml) == 0)
13250 data.hm_nv = nvml;
13251
13252 if (data.hm_nv)
13253 {
13254 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13255 {
13256 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13257
13258 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13259
13260 int tmp_out = 0;
13261
13262 for (int i = 0; i < tmp_in; i++)
13263 {
13264 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13265 }
13266
13267 for (int i = 0; i < tmp_out; i++)
13268 {
13269 unsigned int speed;
13270
13271 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;
13272 }
13273 }
13274 }
13275 #endif // LINUX && HAVE_NVML
13276
13277 data.hm_amd = NULL;
13278
13279 #ifdef HAVE_ADL
13280 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13281
13282 if (adl_init (adl) == 0)
13283 data.hm_amd = adl;
13284
13285 if (data.hm_amd)
13286 {
13287 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13288 {
13289 // total number of adapters
13290
13291 int hm_adapters_num;
13292
13293 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13294
13295 // adapter info
13296
13297 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13298
13299 if (lpAdapterInfo == NULL) return (-1);
13300
13301 // get a list (of ids of) valid/usable adapters
13302
13303 int num_adl_adapters = 0;
13304
13305 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13306
13307 if (num_adl_adapters > 0)
13308 {
13309 hc_thread_mutex_lock (mux_adl);
13310
13311 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13312
13313 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13314
13315 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13316 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13317
13318 hc_thread_mutex_unlock (mux_adl);
13319 }
13320
13321 myfree (valid_adl_device_list);
13322 myfree (lpAdapterInfo);
13323 }
13324 }
13325 #endif // HAVE_ADL
13326
13327 if (data.hm_amd == NULL && data.hm_nv == NULL)
13328 {
13329 gpu_temp_disable = 1;
13330 }
13331 }
13332
13333 /**
13334 * OpenCL devices: allocate buffer for device specific information
13335 */
13336
13337 #ifdef HAVE_HWMON
13338 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13339
13340 #ifdef HAVE_ADL
13341 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13342
13343 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13344 #endif // ADL
13345 #endif
13346
13347 /**
13348 * enable custom signal handler(s)
13349 */
13350
13351 if (benchmark == 0)
13352 {
13353 hc_signal (sigHandler_default);
13354 }
13355 else
13356 {
13357 hc_signal (sigHandler_benchmark);
13358 }
13359
13360 /**
13361 * User-defined GPU temp handling
13362 */
13363
13364 #ifdef HAVE_HWMON
13365 if (gpu_temp_disable == 1)
13366 {
13367 gpu_temp_abort = 0;
13368 gpu_temp_retain = 0;
13369 }
13370
13371 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13372 {
13373 if (gpu_temp_abort < gpu_temp_retain)
13374 {
13375 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13376
13377 return (-1);
13378 }
13379 }
13380
13381 data.gpu_temp_disable = gpu_temp_disable;
13382 data.gpu_temp_abort = gpu_temp_abort;
13383 data.gpu_temp_retain = gpu_temp_retain;
13384 #endif
13385
13386 /**
13387 * inform the user
13388 */
13389
13390 if (data.quiet == 0)
13391 {
13392 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13393
13394 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);
13395
13396 if (attack_mode == ATTACK_MODE_STRAIGHT)
13397 {
13398 log_info ("Rules: %u", kernel_rules_cnt);
13399 }
13400
13401 if (opti_type)
13402 {
13403 log_info ("Applicable Optimizers:");
13404
13405 for (uint i = 0; i < 32; i++)
13406 {
13407 const uint opti_bit = 1u << i;
13408
13409 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13410 }
13411 }
13412
13413 /**
13414 * Watchdog and Temperature balance
13415 */
13416
13417 #ifdef HAVE_HWMON
13418 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13419 {
13420 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13421 }
13422
13423 if (gpu_temp_abort == 0)
13424 {
13425 log_info ("Watchdog: Temperature abort trigger disabled");
13426 }
13427 else
13428 {
13429 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13430 }
13431
13432 if (gpu_temp_retain == 0)
13433 {
13434 log_info ("Watchdog: Temperature retain trigger disabled");
13435 }
13436 else
13437 {
13438 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13439 }
13440 #endif
13441 }
13442
13443 if (data.quiet == 0) log_info ("");
13444
13445 /**
13446 * HM devices: copy
13447 */
13448
13449 if (gpu_temp_disable == 0)
13450 {
13451 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13452 {
13453 hc_device_param_t *device_param = &data.devices_param[device_id];
13454
13455 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13456
13457 if (device_param->skipped) continue;
13458
13459 const uint platform_devices_id = device_param->platform_devices_id;
13460
13461 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13462 if (device_param->vendor_id == VENDOR_ID_NV)
13463 {
13464 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13465 }
13466 #endif
13467
13468 #ifdef HAVE_ADL
13469 if (device_param->vendor_id == VENDOR_ID_AMD)
13470 {
13471 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13472 }
13473 #endif
13474 }
13475 }
13476
13477 /*
13478 * Temporary fix:
13479 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13480 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13481 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13482 * Driver / ADL bug?
13483 */
13484
13485 #ifdef HAVE_ADL
13486 if (powertune_enable == 1)
13487 {
13488 hc_thread_mutex_lock (mux_adl);
13489
13490 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13491 {
13492 hc_device_param_t *device_param = &data.devices_param[device_id];
13493
13494 if (device_param->skipped) continue;
13495
13496 if (data.hm_device[device_id].od_version == 6)
13497 {
13498 // set powertune value only
13499
13500 int powertune_supported = 0;
13501
13502 int ADL_rc = 0;
13503
13504 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13505 {
13506 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13507
13508 return (-1);
13509 }
13510
13511 if (powertune_supported != 0)
13512 {
13513 // powertune set
13514 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13515
13516 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13517 {
13518 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13519
13520 return (-1);
13521 }
13522
13523 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13524 {
13525 log_error ("ERROR: Failed to set new ADL PowerControl values");
13526
13527 return (-1);
13528 }
13529 }
13530 }
13531 }
13532
13533 hc_thread_mutex_unlock (mux_adl);
13534 }
13535 #endif // HAVE_ADK
13536 #endif // HAVE_HWMON
13537
13538 #ifdef DEBUG
13539 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13540 #endif
13541
13542 uint kernel_power_all = 0;
13543
13544 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13545 {
13546 /**
13547 * host buffer
13548 */
13549
13550 hc_device_param_t *device_param = &data.devices_param[device_id];
13551
13552 if (device_param->skipped) continue;
13553
13554 /**
13555 * device properties
13556 */
13557
13558 const char *device_name_chksum = device_param->device_name_chksum;
13559 const u32 device_processors = device_param->device_processors;
13560 const u32 device_processor_cores = device_param->device_processor_cores;
13561
13562 /**
13563 * create context for each device
13564 */
13565
13566 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13567
13568 /**
13569 * create command-queue
13570 */
13571
13572 // not supported with NV
13573 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13574
13575 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13576
13577 /**
13578 * kernel threads: some algorithms need a fixed kernel-threads count
13579 * because of shared memory usage or bitslice
13580 * there needs to be some upper limit, otherwise there's too much overhead
13581 */
13582
13583 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
13584
13585 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
13586 {
13587 kernel_threads = KERNEL_THREADS_MAX_CPU;
13588 }
13589
13590 //if (hash_mode == 1500) kernel_threads = 64; // DES
13591 //if (hash_mode == 3000) kernel_threads = 64; // DES
13592 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
13593 if (hash_mode == 7500) kernel_threads = 64; // RC4
13594 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
13595 if (hash_mode == 9700) kernel_threads = 64; // RC4
13596 if (hash_mode == 9710) kernel_threads = 64; // RC4
13597 if (hash_mode == 9800) kernel_threads = 64; // RC4
13598 if (hash_mode == 9810) kernel_threads = 64; // RC4
13599 if (hash_mode == 10400) kernel_threads = 64; // RC4
13600 if (hash_mode == 10410) kernel_threads = 64; // RC4
13601 if (hash_mode == 10500) kernel_threads = 64; // RC4
13602 if (hash_mode == 13100) kernel_threads = 64; // RC4
13603
13604 /**
13605 * create input buffers on device : calculate size of fixed memory buffers
13606 */
13607
13608 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
13609 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13610
13611 device_param->size_root_css = size_root_css;
13612 device_param->size_markov_css = size_markov_css;
13613
13614 size_t size_results = kernel_threads * sizeof (uint);
13615
13616 device_param->size_results = size_results;
13617
13618 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13619 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13620
13621 size_t size_plains = digests_cnt * sizeof (plain_t);
13622 size_t size_salts = salts_cnt * sizeof (salt_t);
13623 size_t size_esalts = salts_cnt * esalt_size;
13624
13625 device_param->size_plains = size_plains;
13626 device_param->size_digests = size_digests;
13627 device_param->size_shown = size_shown;
13628 device_param->size_salts = size_salts;
13629
13630 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
13631 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
13632 size_t size_tm = 32 * sizeof (bs_word_t);
13633
13634 // scryptV stuff
13635
13636 size_t size_scryptV = 1;
13637
13638 if ((hash_mode == 8900) || (hash_mode == 9300))
13639 {
13640 uint tmto_start = 0;
13641 uint tmto_stop = 10;
13642
13643 if (scrypt_tmto)
13644 {
13645 tmto_start = scrypt_tmto;
13646 }
13647 else
13648 {
13649 // in case the user did not specify the tmto manually
13650 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13651 // but set the lower end only in case the user has a device with too less memory
13652
13653 if (hash_mode == 8900)
13654 {
13655 if (device_param->vendor_id == VENDOR_ID_AMD)
13656 {
13657 tmto_start = 1;
13658 }
13659 else if (device_param->vendor_id == VENDOR_ID_NV)
13660 {
13661 tmto_start = 2;
13662 }
13663 }
13664 else if (hash_mode == 9300)
13665 {
13666 if (device_param->vendor_id == VENDOR_ID_AMD)
13667 {
13668 tmto_start = 2;
13669 }
13670 else if (device_param->vendor_id == VENDOR_ID_NV)
13671 {
13672 tmto_start = 2;
13673 }
13674 }
13675 }
13676
13677 if (quiet == 0) log_info ("");
13678
13679 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13680 {
13681 // TODO: in theory the following calculation needs to be done per salt, not global
13682 // we assume all hashes have the same scrypt settings
13683
13684 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13685
13686 size_scryptV /= 1 << tmto;
13687
13688 size_scryptV *= device_processors * device_processor_cores;
13689
13690 if (size_scryptV > device_param->device_maxmem_alloc)
13691 {
13692 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13693
13694 continue;
13695 }
13696
13697 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13698 {
13699 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13700 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
13701 }
13702
13703 break;
13704 }
13705
13706 if (data.salts_buf[0].scrypt_phy == 0)
13707 {
13708 log_error ("ERROR: can't allocate enough device memory");
13709
13710 return -1;
13711 }
13712
13713 if (quiet == 0) log_info ("");
13714 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13715 }
13716
13717 /**
13718 * some algorithms need a fixed kernel-loops count
13719 */
13720
13721 if (hash_mode == 1500)
13722 {
13723 const u32 kernel_loops_fixed = 1024;
13724
13725 device_param->kernel_loops_min = kernel_loops_fixed;
13726 device_param->kernel_loops_max = kernel_loops_fixed;
13727 }
13728
13729 if (hash_mode == 3000)
13730 {
13731 const u32 kernel_loops_fixed = 1024;
13732
13733 device_param->kernel_loops_min = kernel_loops_fixed;
13734 device_param->kernel_loops_max = kernel_loops_fixed;
13735 }
13736
13737 if (hash_mode == 8900)
13738 {
13739 const u32 kernel_loops_fixed = 1;
13740
13741 device_param->kernel_loops_min = kernel_loops_fixed;
13742 device_param->kernel_loops_max = kernel_loops_fixed;
13743 }
13744
13745 if (hash_mode == 9300)
13746 {
13747 const u32 kernel_loops_fixed = 1;
13748
13749 device_param->kernel_loops_min = kernel_loops_fixed;
13750 device_param->kernel_loops_max = kernel_loops_fixed;
13751 }
13752
13753 if (hash_mode == 12500)
13754 {
13755 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13756
13757 device_param->kernel_loops_min = kernel_loops_fixed;
13758 device_param->kernel_loops_max = kernel_loops_fixed;
13759 }
13760
13761 /**
13762 * some algorithms have a maximum kernel-loops count
13763 */
13764
13765 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13766 {
13767 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13768 {
13769 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13770 }
13771 }
13772
13773 /**
13774 * some algorithms need a special kernel-accel
13775 */
13776
13777 if (hash_mode == 8900)
13778 {
13779 device_param->kernel_accel_min = 1;
13780 device_param->kernel_accel_max = 64;
13781 }
13782
13783 if (hash_mode == 9300)
13784 {
13785 device_param->kernel_accel_min = 1;
13786 device_param->kernel_accel_max = 64;
13787 }
13788
13789 u32 kernel_accel_min = device_param->kernel_accel_min;
13790 u32 kernel_accel_max = device_param->kernel_accel_max;
13791
13792 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13793
13794 size_t size_pws = 4;
13795 size_t size_tmps = 4;
13796 size_t size_hooks = 4;
13797
13798 while (kernel_accel_max >= kernel_accel_min)
13799 {
13800 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13801
13802 // size_pws
13803
13804 size_pws = kernel_power_max * sizeof (pw_t);
13805
13806 // size_tmps
13807
13808 switch (hash_mode)
13809 {
13810 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13811 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13812 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13813 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13814 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13815 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13816 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13817 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13818 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13819 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13820 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13821 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13822 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13823 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13824 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13825 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13826 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13827 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13828 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13829 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13830 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13831 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13832 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13833 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13834 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13835 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13836 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13837 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13838 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13839 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13840 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13841 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13842 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13843 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13844 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13845 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13846 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13847 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13848 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13849 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13850 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13851 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13852 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13853 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13854 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13855 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13856 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13857 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13858 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13859 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13860 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13861 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13862 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13863 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13864 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13865 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13866 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13867 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13868 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13869 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13870 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13871 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13872 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13873 };
13874
13875 // size_hooks
13876
13877 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13878 {
13879 // none yet
13880 }
13881
13882 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13883 // if not, decrease amplifier and try again
13884
13885 int skip = 0;
13886
13887 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13888 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13889 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13890
13891 if (( bitmap_size
13892 + bitmap_size
13893 + bitmap_size
13894 + bitmap_size
13895 + bitmap_size
13896 + bitmap_size
13897 + bitmap_size
13898 + bitmap_size
13899 + size_bfs
13900 + size_combs
13901 + size_digests
13902 + size_esalts
13903 + size_hooks
13904 + size_markov_css
13905 + size_plains
13906 + size_pws
13907 + size_pws // not a bug
13908 + size_results
13909 + size_root_css
13910 + size_rules
13911 + size_rules_c
13912 + size_salts
13913 + size_scryptV
13914 + size_shown
13915 + size_tm
13916 + size_tmps) > device_param->device_global_mem) skip = 1;
13917
13918 if (skip == 1)
13919 {
13920 kernel_accel_max--;
13921
13922 continue;
13923 }
13924
13925 break;
13926 }
13927
13928 /*
13929 if (kernel_accel_max == 0)
13930 {
13931 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13932
13933 return -1;
13934 }
13935 */
13936
13937 device_param->kernel_accel_min = kernel_accel_min;
13938 device_param->kernel_accel_max = kernel_accel_max;
13939
13940 /*
13941 if (kernel_accel_max < kernel_accel)
13942 {
13943 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13944
13945 device_param->kernel_accel = kernel_accel_max;
13946 }
13947 */
13948
13949 device_param->size_bfs = size_bfs;
13950 device_param->size_combs = size_combs;
13951 device_param->size_rules = size_rules;
13952 device_param->size_rules_c = size_rules_c;
13953 device_param->size_pws = size_pws;
13954 device_param->size_tmps = size_tmps;
13955 device_param->size_hooks = size_hooks;
13956
13957 // do not confuse kernel_accel_max with kernel_accel here
13958
13959 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13960
13961 device_param->kernel_threads = kernel_threads;
13962 device_param->kernel_power_user = kernel_power;
13963
13964 kernel_power_all += kernel_power;
13965
13966 /**
13967 * default building options
13968 */
13969
13970 char build_opts[1024] = { 0 };
13971
13972 // we don't have sm_* on vendors not NV but it doesn't matter
13973
13974 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13975
13976 /**
13977 * main kernel
13978 */
13979
13980 {
13981 /**
13982 * kernel source filename
13983 */
13984
13985 char source_file[256] = { 0 };
13986
13987 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13988
13989 struct stat sst;
13990
13991 if (stat (source_file, &sst) == -1)
13992 {
13993 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13994
13995 return -1;
13996 }
13997
13998 /**
13999 * kernel cached filename
14000 */
14001
14002 char cached_file[256] = { 0 };
14003
14004 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14005
14006 int cached = 1;
14007
14008 struct stat cst;
14009
14010 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14011 {
14012 cached = 0;
14013 }
14014
14015 /**
14016 * kernel compile or load
14017 */
14018
14019 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14020
14021 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14022
14023 if (force_jit_compilation == -1)
14024 {
14025 if (cached == 0)
14026 {
14027 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14028
14029 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14030
14031 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14032
14033 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14034
14035 #ifdef DEBUG
14036 size_t build_log_size = 0;
14037
14038 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14039
14040 if (build_log_size > 1)
14041 {
14042 char *build_log = (char *) malloc (build_log_size + 1);
14043
14044 memset (build_log, 0, build_log_size + 1);
14045
14046 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14047
14048 puts (build_log);
14049
14050 free (build_log);
14051 }
14052 #endif
14053
14054 if (rc != 0)
14055 {
14056 device_param->skipped = true;
14057 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14058 continue;
14059 }
14060
14061 size_t binary_size;
14062
14063 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14064
14065 u8 *binary = (u8 *) mymalloc (binary_size);
14066
14067 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14068
14069 writeProgramBin (cached_file, binary, binary_size);
14070
14071 local_free (binary);
14072 }
14073 else
14074 {
14075 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14076
14077 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14078
14079 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14080
14081 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14082 }
14083 }
14084 else
14085 {
14086 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14087
14088 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14089
14090 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14091
14092 char build_opts_update[1024] = { 0 };
14093
14094 if (force_jit_compilation == 1500)
14095 {
14096 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14097 }
14098 else if (force_jit_compilation == 8900)
14099 {
14100 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);
14101 }
14102 else
14103 {
14104 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14105 }
14106
14107 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14108
14109 #ifdef DEBUG
14110 size_t build_log_size = 0;
14111
14112 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14113
14114 if (build_log_size > 1)
14115 {
14116 char *build_log = (char *) malloc (build_log_size + 1);
14117
14118 memset (build_log, 0, build_log_size + 1);
14119
14120 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14121
14122 puts (build_log);
14123
14124 free (build_log);
14125 }
14126 #endif
14127
14128 if (rc != 0)
14129 {
14130 device_param->skipped = true;
14131
14132 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14133 }
14134 }
14135
14136 local_free (kernel_lengths);
14137 local_free (kernel_sources[0]);
14138 local_free (kernel_sources);
14139 }
14140
14141 /**
14142 * word generator kernel
14143 */
14144
14145 if (attack_mode != ATTACK_MODE_STRAIGHT)
14146 {
14147 /**
14148 * kernel mp source filename
14149 */
14150
14151 char source_file[256] = { 0 };
14152
14153 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14154
14155 struct stat sst;
14156
14157 if (stat (source_file, &sst) == -1)
14158 {
14159 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14160
14161 return -1;
14162 }
14163
14164 /**
14165 * kernel mp cached filename
14166 */
14167
14168 char cached_file[256] = { 0 };
14169
14170 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14171
14172 int cached = 1;
14173
14174 struct stat cst;
14175
14176 if (stat (cached_file, &cst) == -1)
14177 {
14178 cached = 0;
14179 }
14180
14181 /**
14182 * kernel compile or load
14183 */
14184
14185 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14186
14187 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14188
14189 if (cached == 0)
14190 {
14191 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14192
14193 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14194
14195 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14196
14197 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14198
14199 if (rc != 0)
14200 {
14201 device_param->skipped = true;
14202 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14203 continue;
14204 }
14205
14206 size_t binary_size;
14207
14208 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14209
14210 u8 *binary = (u8 *) mymalloc (binary_size);
14211
14212 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14213
14214 writeProgramBin (cached_file, binary, binary_size);
14215
14216 local_free (binary);
14217 }
14218 else
14219 {
14220 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14221
14222 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14223
14224 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14225
14226 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14227 }
14228
14229 local_free (kernel_lengths);
14230 local_free (kernel_sources[0]);
14231 local_free (kernel_sources);
14232 }
14233
14234 /**
14235 * amplifier kernel
14236 */
14237
14238 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14239 {
14240
14241 }
14242 else
14243 {
14244 /**
14245 * kernel amp source filename
14246 */
14247
14248 char source_file[256] = { 0 };
14249
14250 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14251
14252 struct stat sst;
14253
14254 if (stat (source_file, &sst) == -1)
14255 {
14256 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14257
14258 return -1;
14259 }
14260
14261 /**
14262 * kernel amp cached filename
14263 */
14264
14265 char cached_file[256] = { 0 };
14266
14267 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14268
14269 int cached = 1;
14270
14271 struct stat cst;
14272
14273 if (stat (cached_file, &cst) == -1)
14274 {
14275 cached = 0;
14276 }
14277
14278 /**
14279 * kernel compile or load
14280 */
14281
14282 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14283
14284 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14285
14286 if (cached == 0)
14287 {
14288 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14289
14290 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14291
14292 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14293
14294 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14295
14296 if (rc != 0)
14297 {
14298 device_param->skipped = true;
14299 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14300 continue;
14301 }
14302
14303 size_t binary_size;
14304
14305 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14306
14307 u8 *binary = (u8 *) mymalloc (binary_size);
14308
14309 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14310
14311 writeProgramBin (cached_file, binary, binary_size);
14312
14313 local_free (binary);
14314 }
14315 else
14316 {
14317 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14318
14319 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14320
14321 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14322
14323 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14324 }
14325
14326 local_free (kernel_lengths);
14327 local_free (kernel_sources[0]);
14328 local_free (kernel_sources);
14329 }
14330
14331 // some algorithm collide too fast, make that impossible
14332
14333 if (benchmark == 1)
14334 {
14335 ((uint *) digests_buf)[0] = -1;
14336 ((uint *) digests_buf)[1] = -1;
14337 ((uint *) digests_buf)[2] = -1;
14338 ((uint *) digests_buf)[3] = -1;
14339 }
14340
14341 /**
14342 * global buffers
14343 */
14344
14345 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14346 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14347 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14348 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14349 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14350 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14351 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14352 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14353 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14354 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14355 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14356 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14357 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14358 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14359 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14360 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14361 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14362 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14363
14364 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);
14365 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);
14366 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);
14367 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);
14368 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);
14369 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);
14370 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);
14371 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);
14372 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14373 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14374 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14375
14376 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14377 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14378 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14379 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14380 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14381 run_kernel_bzero (device_param, device_param->d_result, size_results);
14382
14383 /**
14384 * special buffers
14385 */
14386
14387 if (attack_kern == ATTACK_KERN_STRAIGHT)
14388 {
14389 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14390 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14391
14392 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14393
14394 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14395 }
14396 else if (attack_kern == ATTACK_KERN_COMBI)
14397 {
14398 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14399 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14400 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14401 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14402
14403 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14404 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14405 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14406 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14407 }
14408 else if (attack_kern == ATTACK_KERN_BF)
14409 {
14410 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14411 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14412 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14413 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14414 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14415
14416 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14417 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14418 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14419 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14420 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14421 }
14422
14423 if (size_esalts)
14424 {
14425 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14426
14427 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14428 }
14429
14430 /**
14431 * main host data
14432 */
14433
14434 uint *result = (uint *) mymalloc (size_results);
14435
14436 device_param->result = result;
14437
14438 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14439
14440 device_param->pws_buf = pws_buf;
14441
14442 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14443
14444 device_param->combs_buf = combs_buf;
14445
14446 void *hooks_buf = mymalloc (size_hooks);
14447
14448 device_param->hooks_buf = hooks_buf;
14449
14450 /**
14451 * kernel args
14452 */
14453
14454 device_param->kernel_params_buf32[21] = bitmap_mask;
14455 device_param->kernel_params_buf32[22] = bitmap_shift1;
14456 device_param->kernel_params_buf32[23] = bitmap_shift2;
14457 device_param->kernel_params_buf32[24] = 0; // salt_pos
14458 device_param->kernel_params_buf32[25] = 0; // loop_pos
14459 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14460 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14461 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14462 device_param->kernel_params_buf32[29] = 0; // digests_offset
14463 device_param->kernel_params_buf32[30] = 0; // combs_mode
14464 device_param->kernel_params_buf32[31] = 0; // gid_max
14465
14466 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14467 ? &device_param->d_pws_buf
14468 : &device_param->d_pws_amp_buf;
14469 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14470 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14471 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14472 device_param->kernel_params[ 4] = &device_param->d_tmps;
14473 device_param->kernel_params[ 5] = &device_param->d_hooks;
14474 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14475 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14476 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14477 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14478 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14479 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14480 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14481 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14482 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14483 device_param->kernel_params[15] = &device_param->d_digests_buf;
14484 device_param->kernel_params[16] = &device_param->d_digests_shown;
14485 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14486 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14487 device_param->kernel_params[19] = &device_param->d_result;
14488 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14489 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14490 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14491 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14492 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14493 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14494 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14495 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14496 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14497 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14498 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14499 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14500
14501 device_param->kernel_params_mp_buf64[3] = 0;
14502 device_param->kernel_params_mp_buf32[4] = 0;
14503 device_param->kernel_params_mp_buf32[5] = 0;
14504 device_param->kernel_params_mp_buf32[6] = 0;
14505 device_param->kernel_params_mp_buf32[7] = 0;
14506 device_param->kernel_params_mp_buf32[8] = 0;
14507
14508 device_param->kernel_params_mp[0] = NULL;
14509 device_param->kernel_params_mp[1] = NULL;
14510 device_param->kernel_params_mp[2] = NULL;
14511 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14512 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14513 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14514 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14515 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14516 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14517
14518 device_param->kernel_params_mp_l_buf64[3] = 0;
14519 device_param->kernel_params_mp_l_buf32[4] = 0;
14520 device_param->kernel_params_mp_l_buf32[5] = 0;
14521 device_param->kernel_params_mp_l_buf32[6] = 0;
14522 device_param->kernel_params_mp_l_buf32[7] = 0;
14523 device_param->kernel_params_mp_l_buf32[8] = 0;
14524 device_param->kernel_params_mp_l_buf32[9] = 0;
14525
14526 device_param->kernel_params_mp_l[0] = NULL;
14527 device_param->kernel_params_mp_l[1] = NULL;
14528 device_param->kernel_params_mp_l[2] = NULL;
14529 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14530 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14531 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14532 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14533 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14534 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14535 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14536
14537 device_param->kernel_params_mp_r_buf64[3] = 0;
14538 device_param->kernel_params_mp_r_buf32[4] = 0;
14539 device_param->kernel_params_mp_r_buf32[5] = 0;
14540 device_param->kernel_params_mp_r_buf32[6] = 0;
14541 device_param->kernel_params_mp_r_buf32[7] = 0;
14542 device_param->kernel_params_mp_r_buf32[8] = 0;
14543
14544 device_param->kernel_params_mp_r[0] = NULL;
14545 device_param->kernel_params_mp_r[1] = NULL;
14546 device_param->kernel_params_mp_r[2] = NULL;
14547 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14548 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14549 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14550 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14551 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14552 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14553
14554 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14555 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14556
14557 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14558 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14559 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14560 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14561 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14562 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14563 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14564
14565 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14566 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14567
14568 /**
14569 * kernel name
14570 */
14571
14572 char kernel_name[64] = { 0 };
14573
14574 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14575 {
14576 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14577 {
14578 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14579
14580 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14581
14582 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14583
14584 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14585
14586 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14587
14588 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14589 }
14590 else
14591 {
14592 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14593
14594 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14595
14596 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14597
14598 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14599
14600 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14601
14602 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14603 }
14604
14605 if (data.attack_mode == ATTACK_MODE_BF)
14606 {
14607 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14608 {
14609 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14610
14611 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14612 }
14613 }
14614 }
14615 else
14616 {
14617 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14618
14619 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14620
14621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14622
14623 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14624
14625 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14626
14627 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14628
14629 if (opts_type & OPTS_TYPE_HOOK12)
14630 {
14631 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14632
14633 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14634 }
14635
14636 if (opts_type & OPTS_TYPE_HOOK23)
14637 {
14638 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14639
14640 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14641 }
14642 }
14643
14644 for (uint i = 0; i <= 20; i++)
14645 {
14646 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14647 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14648 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14649
14650 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14651 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14652 }
14653
14654 for (uint i = 21; i <= 31; i++)
14655 {
14656 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14657 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14658 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14659
14660 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14661 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14662 }
14663
14664 if (attack_mode == ATTACK_MODE_BF)
14665 {
14666 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14667 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14668
14669 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14670 {
14671 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14672 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14673 }
14674 }
14675 else if (attack_mode == ATTACK_MODE_HYBRID1)
14676 {
14677 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14678 }
14679 else if (attack_mode == ATTACK_MODE_HYBRID2)
14680 {
14681 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14682 }
14683
14684 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14685 {
14686 // nothing to do
14687 }
14688 else
14689 {
14690 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14691 }
14692
14693 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14694 {
14695 // nothing to do
14696 }
14697 else
14698 {
14699 for (uint i = 0; i < 5; i++)
14700 {
14701 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14702 }
14703
14704 for (uint i = 5; i < 7; i++)
14705 {
14706 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14707 }
14708 }
14709
14710 /**
14711 * Store initial fanspeed if gpu_temp_retain is enabled
14712 */
14713
14714 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14715 int gpu_temp_retain_set = 0;
14716
14717 if (gpu_temp_disable == 0)
14718 {
14719 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14720 {
14721 hc_thread_mutex_lock (mux_adl);
14722
14723 if (data.hm_device[device_id].fan_supported == 1)
14724 {
14725 if (gpu_temp_retain_chgd == 0)
14726 {
14727 uint cur_temp = 0;
14728 uint default_temp = 0;
14729
14730 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);
14731
14732 if (ADL_rc == ADL_OK)
14733 {
14734 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14735
14736 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14737
14738 // special case with multi gpu setups: always use minimum retain
14739
14740 if (gpu_temp_retain_set == 0)
14741 {
14742 gpu_temp_retain = gpu_temp_retain_target;
14743 gpu_temp_retain_set = 1;
14744 }
14745 else
14746 {
14747 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14748 }
14749
14750 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14751 }
14752 }
14753
14754 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14755
14756 temp_retain_fanspeed_value[device_id] = fan_speed;
14757
14758 if (fan_speed == -1)
14759 {
14760 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14761
14762 temp_retain_fanspeed_value[device_id] = 0;
14763 }
14764 }
14765
14766 hc_thread_mutex_unlock (mux_adl);
14767 }
14768 }
14769
14770 /**
14771 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14772 */
14773
14774 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14775 {
14776 hc_thread_mutex_lock (mux_adl);
14777
14778 if (data.hm_device[device_id].od_version == 6)
14779 {
14780 int ADL_rc;
14781
14782 // check powertune capabilities first, if not available then skip device
14783
14784 int powertune_supported = 0;
14785
14786 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14787 {
14788 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14789
14790 return (-1);
14791 }
14792
14793 if (powertune_supported != 0)
14794 {
14795 // powercontrol settings
14796
14797 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14798
14799 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14800 {
14801 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14802 }
14803
14804 if (ADL_rc != ADL_OK)
14805 {
14806 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14807
14808 return (-1);
14809 }
14810
14811 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14812 {
14813 log_error ("ERROR: Failed to set new ADL PowerControl values");
14814
14815 return (-1);
14816 }
14817
14818 // clocks
14819
14820 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14821
14822 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14823
14824 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)
14825 {
14826 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14827
14828 return (-1);
14829 }
14830
14831 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14832
14833 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14834
14835 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14836 {
14837 log_error ("ERROR: Failed to get ADL device capabilities");
14838
14839 return (-1);
14840 }
14841
14842 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14843 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14844
14845 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14846 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14847
14848 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14849 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14850
14851 // warning if profile has too low max values
14852
14853 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14854 {
14855 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14856 }
14857
14858 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14859 {
14860 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14861 }
14862
14863 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14864
14865 performance_state->iNumberOfPerformanceLevels = 2;
14866
14867 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14868 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14869 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14870 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14871
14872 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)
14873 {
14874 log_info ("ERROR: Failed to set ADL performance state");
14875
14876 return (-1);
14877 }
14878
14879 local_free (performance_state);
14880 }
14881 }
14882
14883 hc_thread_mutex_unlock (mux_adl);
14884 }
14885 #endif // HAVE_HWMON && HAVE_ADL
14886 }
14887
14888 data.kernel_power_all = kernel_power_all;
14889
14890 if (data.quiet == 0) log_info ("");
14891
14892 /**
14893 * In benchmark-mode, inform user which algorithm is checked
14894 */
14895
14896 if (benchmark == 1)
14897 {
14898 quiet = 0;
14899
14900 data.quiet = quiet;
14901
14902 char *hash_type = strhashtype (data.hash_mode); // not a bug
14903
14904 log_info ("Hashtype: %s", hash_type);
14905 log_info ("");
14906 }
14907
14908 /**
14909 * keep track of the progress
14910 */
14911
14912 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14913 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14914 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14915
14916 /**
14917 * open filehandles
14918 */
14919
14920 #if _WIN
14921 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14922 {
14923 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14924
14925 return (-1);
14926 }
14927
14928 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14929 {
14930 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14931
14932 return (-1);
14933 }
14934
14935 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14936 {
14937 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14938
14939 return (-1);
14940 }
14941 #endif
14942
14943 /**
14944 * dictionary pad
14945 */
14946
14947 segment_size *= (1024 * 1024);
14948
14949 data.segment_size = segment_size;
14950
14951 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14952
14953 wl_data->buf = (char *) mymalloc (segment_size);
14954 wl_data->avail = segment_size;
14955 wl_data->incr = segment_size;
14956 wl_data->cnt = 0;
14957 wl_data->pos = 0;
14958
14959 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14960
14961 data.wordlist_mode = wordlist_mode;
14962
14963 cs_t *css_buf = NULL;
14964 uint css_cnt = 0;
14965 uint dictcnt = 0;
14966 uint maskcnt = 1;
14967 char **masks = NULL;
14968 char **dictfiles = NULL;
14969
14970 uint mask_from_file = 0;
14971
14972 if (attack_mode == ATTACK_MODE_STRAIGHT)
14973 {
14974 if (wordlist_mode == WL_MODE_FILE)
14975 {
14976 int wls_left = myargc - (optind + 1);
14977
14978 for (int i = 0; i < wls_left; i++)
14979 {
14980 char *l0_filename = myargv[optind + 1 + i];
14981
14982 struct stat l0_stat;
14983
14984 if (stat (l0_filename, &l0_stat) == -1)
14985 {
14986 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14987
14988 return (-1);
14989 }
14990
14991 uint is_dir = S_ISDIR (l0_stat.st_mode);
14992
14993 if (is_dir == 0)
14994 {
14995 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14996
14997 dictcnt++;
14998
14999 dictfiles[dictcnt - 1] = l0_filename;
15000 }
15001 else
15002 {
15003 // do not allow --keyspace w/ a directory
15004
15005 if (keyspace == 1)
15006 {
15007 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15008
15009 return (-1);
15010 }
15011
15012 char **dictionary_files = NULL;
15013
15014 dictionary_files = scan_directory (l0_filename);
15015
15016 if (dictionary_files != NULL)
15017 {
15018 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15019
15020 for (int d = 0; dictionary_files[d] != NULL; d++)
15021 {
15022 char *l1_filename = dictionary_files[d];
15023
15024 struct stat l1_stat;
15025
15026 if (stat (l1_filename, &l1_stat) == -1)
15027 {
15028 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15029
15030 return (-1);
15031 }
15032
15033 if (S_ISREG (l1_stat.st_mode))
15034 {
15035 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15036
15037 dictcnt++;
15038
15039 dictfiles[dictcnt - 1] = strdup (l1_filename);
15040 }
15041 }
15042 }
15043
15044 local_free (dictionary_files);
15045 }
15046 }
15047
15048 if (dictcnt < 1)
15049 {
15050 log_error ("ERROR: No usable dictionary file found.");
15051
15052 return (-1);
15053 }
15054 }
15055 else if (wordlist_mode == WL_MODE_STDIN)
15056 {
15057 dictcnt = 1;
15058 }
15059 }
15060 else if (attack_mode == ATTACK_MODE_COMBI)
15061 {
15062 // display
15063
15064 char *dictfile1 = myargv[optind + 1 + 0];
15065 char *dictfile2 = myargv[optind + 1 + 1];
15066
15067 // find the bigger dictionary and use as base
15068
15069 FILE *fp1 = NULL;
15070 FILE *fp2 = NULL;
15071
15072 struct stat tmp_stat;
15073
15074 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15075 {
15076 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15077
15078 return (-1);
15079 }
15080
15081 if (stat (dictfile1, &tmp_stat) == -1)
15082 {
15083 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15084
15085 fclose (fp1);
15086
15087 return (-1);
15088 }
15089
15090 if (S_ISDIR (tmp_stat.st_mode))
15091 {
15092 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15093
15094 fclose (fp1);
15095
15096 return (-1);
15097 }
15098
15099 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15100 {
15101 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15102
15103 fclose (fp1);
15104
15105 return (-1);
15106 }
15107
15108 if (stat (dictfile2, &tmp_stat) == -1)
15109 {
15110 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15111
15112 fclose (fp1);
15113 fclose (fp2);
15114
15115 return (-1);
15116 }
15117
15118 if (S_ISDIR (tmp_stat.st_mode))
15119 {
15120 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15121
15122 fclose (fp1);
15123 fclose (fp2);
15124
15125 return (-1);
15126 }
15127
15128 data.combs_cnt = 1;
15129
15130 data.quiet = 1;
15131
15132 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15133
15134 data.quiet = quiet;
15135
15136 if (words1_cnt == 0)
15137 {
15138 log_error ("ERROR: %s: empty file", dictfile1);
15139
15140 fclose (fp1);
15141 fclose (fp2);
15142
15143 return (-1);
15144 }
15145
15146 data.combs_cnt = 1;
15147
15148 data.quiet = 1;
15149
15150 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15151
15152 data.quiet = quiet;
15153
15154 if (words2_cnt == 0)
15155 {
15156 log_error ("ERROR: %s: empty file", dictfile2);
15157
15158 fclose (fp1);
15159 fclose (fp2);
15160
15161 return (-1);
15162 }
15163
15164 fclose (fp1);
15165 fclose (fp2);
15166
15167 data.dictfile = dictfile1;
15168 data.dictfile2 = dictfile2;
15169
15170 if (words1_cnt >= words2_cnt)
15171 {
15172 data.combs_cnt = words2_cnt;
15173 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15174
15175 dictfiles = &data.dictfile;
15176
15177 dictcnt = 1;
15178 }
15179 else
15180 {
15181 data.combs_cnt = words1_cnt;
15182 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15183
15184 dictfiles = &data.dictfile2;
15185
15186 dictcnt = 1;
15187
15188 // we also have to switch wordlist related rules!
15189
15190 char *tmpc = data.rule_buf_l;
15191
15192 data.rule_buf_l = data.rule_buf_r;
15193 data.rule_buf_r = tmpc;
15194
15195 int tmpi = data.rule_len_l;
15196
15197 data.rule_len_l = data.rule_len_r;
15198 data.rule_len_r = tmpi;
15199 }
15200 }
15201 else if (attack_mode == ATTACK_MODE_BF)
15202 {
15203 char *mask = NULL;
15204
15205 maskcnt = 0;
15206
15207 if (benchmark == 0)
15208 {
15209 mask = myargv[optind + 1];
15210
15211 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15212
15213 if ((optind + 2) <= myargc)
15214 {
15215 struct stat file_stat;
15216
15217 if (stat (mask, &file_stat) == -1)
15218 {
15219 maskcnt = 1;
15220
15221 masks[maskcnt - 1] = mystrdup (mask);
15222 }
15223 else
15224 {
15225 int wls_left = myargc - (optind + 1);
15226
15227 uint masks_avail = INCR_MASKS;
15228
15229 for (int i = 0; i < wls_left; i++)
15230 {
15231 if (i != 0)
15232 {
15233 mask = myargv[optind + 1 + i];
15234
15235 if (stat (mask, &file_stat) == -1)
15236 {
15237 log_error ("ERROR: %s: %s", mask, strerror (errno));
15238
15239 return (-1);
15240 }
15241 }
15242
15243 uint is_file = S_ISREG (file_stat.st_mode);
15244
15245 if (is_file == 1)
15246 {
15247 FILE *mask_fp;
15248
15249 if ((mask_fp = fopen (mask, "r")) == NULL)
15250 {
15251 log_error ("ERROR: %s: %s", mask, strerror (errno));
15252
15253 return (-1);
15254 }
15255
15256 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15257
15258 while (!feof (mask_fp))
15259 {
15260 memset (line_buf, 0, HCBUFSIZ);
15261
15262 int line_len = fgetl (mask_fp, line_buf);
15263
15264 if (line_len == 0) continue;
15265
15266 if (line_buf[0] == '#') continue;
15267
15268 if (masks_avail == maskcnt)
15269 {
15270 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15271
15272 masks_avail += INCR_MASKS;
15273 }
15274
15275 masks[maskcnt] = mystrdup (line_buf);
15276
15277 maskcnt++;
15278 }
15279
15280 myfree (line_buf);
15281
15282 fclose (mask_fp);
15283 }
15284 else
15285 {
15286 log_error ("ERROR: %s: unsupported file-type", mask);
15287
15288 return (-1);
15289 }
15290 }
15291
15292 mask_from_file = 1;
15293 }
15294 }
15295 else
15296 {
15297 custom_charset_1 = (char *) "?l?d?u";
15298 custom_charset_2 = (char *) "?l?d";
15299 custom_charset_3 = (char *) "?l?d*!$@_";
15300
15301 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15302 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15303 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15304
15305 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15306
15307 wordlist_mode = WL_MODE_MASK;
15308
15309 data.wordlist_mode = wordlist_mode;
15310
15311 increment = 1;
15312
15313 maskcnt = 1;
15314 }
15315 }
15316 else
15317 {
15318 /**
15319 * generate full masks and charsets
15320 */
15321
15322 masks = (char **) mymalloc (sizeof (char *));
15323
15324 switch (hash_mode)
15325 {
15326 case 1731: pw_min = 5;
15327 pw_max = 5;
15328 mask = mystrdup ("?b?b?b?b?b");
15329 break;
15330 case 12500: pw_min = 5;
15331 pw_max = 5;
15332 mask = mystrdup ("?b?b?b?b?b");
15333 break;
15334 default: pw_min = 7;
15335 pw_max = 7;
15336 mask = mystrdup ("?b?b?b?b?b?b?b");
15337 break;
15338 }
15339
15340 maskcnt = 1;
15341
15342 masks[maskcnt - 1] = mystrdup (mask);
15343
15344 wordlist_mode = WL_MODE_MASK;
15345
15346 data.wordlist_mode = wordlist_mode;
15347
15348 increment = 1;
15349 }
15350
15351 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15352
15353 if (increment)
15354 {
15355 if (increment_min > pw_min) pw_min = increment_min;
15356
15357 if (increment_max < pw_max) pw_max = increment_max;
15358 }
15359 }
15360 else if (attack_mode == ATTACK_MODE_HYBRID1)
15361 {
15362 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15363
15364 // display
15365
15366 char *mask = myargv[myargc - 1];
15367
15368 maskcnt = 0;
15369
15370 masks = (char **) mymalloc (1 * sizeof (char *));
15371
15372 // mod
15373
15374 struct stat file_stat;
15375
15376 if (stat (mask, &file_stat) == -1)
15377 {
15378 maskcnt = 1;
15379
15380 masks[maskcnt - 1] = mystrdup (mask);
15381 }
15382 else
15383 {
15384 uint is_file = S_ISREG (file_stat.st_mode);
15385
15386 if (is_file == 1)
15387 {
15388 FILE *mask_fp;
15389
15390 if ((mask_fp = fopen (mask, "r")) == NULL)
15391 {
15392 log_error ("ERROR: %s: %s", mask, strerror (errno));
15393
15394 return (-1);
15395 }
15396
15397 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15398
15399 uint masks_avail = 1;
15400
15401 while (!feof (mask_fp))
15402 {
15403 memset (line_buf, 0, HCBUFSIZ);
15404
15405 int line_len = fgetl (mask_fp, line_buf);
15406
15407 if (line_len == 0) continue;
15408
15409 if (line_buf[0] == '#') continue;
15410
15411 if (masks_avail == maskcnt)
15412 {
15413 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15414
15415 masks_avail += INCR_MASKS;
15416 }
15417
15418 masks[maskcnt] = mystrdup (line_buf);
15419
15420 maskcnt++;
15421 }
15422
15423 myfree (line_buf);
15424
15425 fclose (mask_fp);
15426
15427 mask_from_file = 1;
15428 }
15429 else
15430 {
15431 maskcnt = 1;
15432
15433 masks[maskcnt - 1] = mystrdup (mask);
15434 }
15435 }
15436
15437 // base
15438
15439 int wls_left = myargc - (optind + 2);
15440
15441 for (int i = 0; i < wls_left; i++)
15442 {
15443 char *filename = myargv[optind + 1 + i];
15444
15445 struct stat file_stat;
15446
15447 if (stat (filename, &file_stat) == -1)
15448 {
15449 log_error ("ERROR: %s: %s", filename, strerror (errno));
15450
15451 return (-1);
15452 }
15453
15454 uint is_dir = S_ISDIR (file_stat.st_mode);
15455
15456 if (is_dir == 0)
15457 {
15458 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15459
15460 dictcnt++;
15461
15462 dictfiles[dictcnt - 1] = filename;
15463 }
15464 else
15465 {
15466 // do not allow --keyspace w/ a directory
15467
15468 if (keyspace == 1)
15469 {
15470 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15471
15472 return (-1);
15473 }
15474
15475 char **dictionary_files = NULL;
15476
15477 dictionary_files = scan_directory (filename);
15478
15479 if (dictionary_files != NULL)
15480 {
15481 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15482
15483 for (int d = 0; dictionary_files[d] != NULL; d++)
15484 {
15485 char *l1_filename = dictionary_files[d];
15486
15487 struct stat l1_stat;
15488
15489 if (stat (l1_filename, &l1_stat) == -1)
15490 {
15491 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15492
15493 return (-1);
15494 }
15495
15496 if (S_ISREG (l1_stat.st_mode))
15497 {
15498 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15499
15500 dictcnt++;
15501
15502 dictfiles[dictcnt - 1] = strdup (l1_filename);
15503 }
15504 }
15505 }
15506
15507 local_free (dictionary_files);
15508 }
15509 }
15510
15511 if (dictcnt < 1)
15512 {
15513 log_error ("ERROR: No usable dictionary file found.");
15514
15515 return (-1);
15516 }
15517
15518 if (increment)
15519 {
15520 maskcnt = 0;
15521
15522 uint mask_min = increment_min; // we can't reject smaller masks here
15523 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15524
15525 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15526 {
15527 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15528
15529 if (cur_mask == NULL) break;
15530
15531 masks[maskcnt] = cur_mask;
15532
15533 maskcnt++;
15534
15535 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15536 }
15537 }
15538 }
15539 else if (attack_mode == ATTACK_MODE_HYBRID2)
15540 {
15541 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15542
15543 // display
15544
15545 char *mask = myargv[optind + 1 + 0];
15546
15547 maskcnt = 0;
15548
15549 masks = (char **) mymalloc (1 * sizeof (char *));
15550
15551 // mod
15552
15553 struct stat file_stat;
15554
15555 if (stat (mask, &file_stat) == -1)
15556 {
15557 maskcnt = 1;
15558
15559 masks[maskcnt - 1] = mystrdup (mask);
15560 }
15561 else
15562 {
15563 uint is_file = S_ISREG (file_stat.st_mode);
15564
15565 if (is_file == 1)
15566 {
15567 FILE *mask_fp;
15568
15569 if ((mask_fp = fopen (mask, "r")) == NULL)
15570 {
15571 log_error ("ERROR: %s: %s", mask, strerror (errno));
15572
15573 return (-1);
15574 }
15575
15576 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15577
15578 uint masks_avail = 1;
15579
15580 while (!feof (mask_fp))
15581 {
15582 memset (line_buf, 0, HCBUFSIZ);
15583
15584 int line_len = fgetl (mask_fp, line_buf);
15585
15586 if (line_len == 0) continue;
15587
15588 if (line_buf[0] == '#') continue;
15589
15590 if (masks_avail == maskcnt)
15591 {
15592 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15593
15594 masks_avail += INCR_MASKS;
15595 }
15596
15597 masks[maskcnt] = mystrdup (line_buf);
15598
15599 maskcnt++;
15600 }
15601
15602 myfree (line_buf);
15603
15604 fclose (mask_fp);
15605
15606 mask_from_file = 1;
15607 }
15608 else
15609 {
15610 maskcnt = 1;
15611
15612 masks[maskcnt - 1] = mystrdup (mask);
15613 }
15614 }
15615
15616 // base
15617
15618 int wls_left = myargc - (optind + 2);
15619
15620 for (int i = 0; i < wls_left; i++)
15621 {
15622 char *filename = myargv[optind + 2 + i];
15623
15624 struct stat file_stat;
15625
15626 if (stat (filename, &file_stat) == -1)
15627 {
15628 log_error ("ERROR: %s: %s", filename, strerror (errno));
15629
15630 return (-1);
15631 }
15632
15633 uint is_dir = S_ISDIR (file_stat.st_mode);
15634
15635 if (is_dir == 0)
15636 {
15637 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15638
15639 dictcnt++;
15640
15641 dictfiles[dictcnt - 1] = filename;
15642 }
15643 else
15644 {
15645 // do not allow --keyspace w/ a directory
15646
15647 if (keyspace == 1)
15648 {
15649 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15650
15651 return (-1);
15652 }
15653
15654 char **dictionary_files = NULL;
15655
15656 dictionary_files = scan_directory (filename);
15657
15658 if (dictionary_files != NULL)
15659 {
15660 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15661
15662 for (int d = 0; dictionary_files[d] != NULL; d++)
15663 {
15664 char *l1_filename = dictionary_files[d];
15665
15666 struct stat l1_stat;
15667
15668 if (stat (l1_filename, &l1_stat) == -1)
15669 {
15670 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15671
15672 return (-1);
15673 }
15674
15675 if (S_ISREG (l1_stat.st_mode))
15676 {
15677 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15678
15679 dictcnt++;
15680
15681 dictfiles[dictcnt - 1] = strdup (l1_filename);
15682 }
15683 }
15684 }
15685
15686 local_free (dictionary_files);
15687 }
15688 }
15689
15690 if (dictcnt < 1)
15691 {
15692 log_error ("ERROR: No usable dictionary file found.");
15693
15694 return (-1);
15695 }
15696
15697 if (increment)
15698 {
15699 maskcnt = 0;
15700
15701 uint mask_min = increment_min; // we can't reject smaller masks here
15702 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15703
15704 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15705 {
15706 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15707
15708 if (cur_mask == NULL) break;
15709
15710 masks[maskcnt] = cur_mask;
15711
15712 maskcnt++;
15713
15714 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15715 }
15716 }
15717 }
15718
15719 data.pw_min = pw_min;
15720 data.pw_max = pw_max;
15721
15722 /**
15723 * weak hash check
15724 */
15725
15726 if (weak_hash_threshold >= salts_cnt)
15727 {
15728 hc_device_param_t *device_param = NULL;
15729
15730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15731 {
15732 device_param = &data.devices_param[device_id];
15733
15734 if (device_param->skipped) continue;
15735
15736 break;
15737 }
15738
15739 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15740
15741 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15742 {
15743 weak_hash_check (device_param, salt_pos);
15744 }
15745 }
15746
15747 // Display hack, guarantee that there is at least one \r before real start
15748
15749 if (data.quiet == 0) log_info_nn ("");
15750
15751 /**
15752 * status and monitor threads
15753 */
15754
15755 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15756
15757 hc_thread_t i_thread = 0;
15758
15759 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15760 {
15761 hc_thread_create (i_thread, thread_keypress, &benchmark);
15762 }
15763
15764 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15765
15766 uint ni_threads_cnt = 0;
15767
15768 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15769
15770 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15771
15772 ni_threads_cnt++;
15773
15774 /**
15775 * Outfile remove
15776 */
15777
15778 if (keyspace == 0)
15779 {
15780 if (outfile_check_timer != 0)
15781 {
15782 if (data.outfile_check_directory != NULL)
15783 {
15784 if ((hash_mode != 5200) &&
15785 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15786 (hash_mode != 9000))
15787 {
15788 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15789
15790 ni_threads_cnt++;
15791 }
15792 else
15793 {
15794 outfile_check_timer = 0;
15795 }
15796 }
15797 else
15798 {
15799 outfile_check_timer = 0;
15800 }
15801 }
15802 }
15803
15804 /**
15805 * Inform the user if we got some hashes remove because of the pot file remove feature
15806 */
15807
15808 if (data.quiet == 0)
15809 {
15810 if (potfile_remove_cracks > 0)
15811 {
15812 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15813 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15814 }
15815 }
15816
15817 data.outfile_check_timer = outfile_check_timer;
15818
15819 /**
15820 * main loop
15821 */
15822
15823 char **induction_dictionaries = NULL;
15824
15825 int induction_dictionaries_cnt = 0;
15826
15827 hcstat_table_t *root_table_buf = NULL;
15828 hcstat_table_t *markov_table_buf = NULL;
15829
15830 uint initial_restore_done = 0;
15831
15832 data.maskcnt = maskcnt;
15833
15834 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15835 {
15836 if (data.devices_status == STATUS_CRACKED) break;
15837
15838 data.devices_status = STATUS_INIT;
15839
15840 if (maskpos > rd->maskpos)
15841 {
15842 rd->dictpos = 0;
15843 }
15844
15845 rd->maskpos = maskpos;
15846 data.maskpos = maskpos;
15847
15848 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15849 {
15850 char *mask = masks[maskpos];
15851
15852 if (mask_from_file == 1)
15853 {
15854 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15855
15856 char *str_ptr;
15857 uint str_pos;
15858
15859 uint mask_offset = 0;
15860
15861 uint separator_cnt;
15862
15863 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15864 {
15865 str_ptr = strstr (mask + mask_offset, ",");
15866
15867 if (str_ptr == NULL) break;
15868
15869 str_pos = str_ptr - mask;
15870
15871 // escaped separator, i.e. "\,"
15872
15873 if (str_pos > 0)
15874 {
15875 if (mask[str_pos - 1] == '\\')
15876 {
15877 separator_cnt --;
15878
15879 mask_offset = str_pos + 1;
15880
15881 continue;
15882 }
15883 }
15884
15885 // reset the offset
15886
15887 mask_offset = 0;
15888
15889 mask[str_pos] = '\0';
15890
15891 switch (separator_cnt)
15892 {
15893 case 0:
15894 mp_reset_usr (mp_usr, 0);
15895
15896 custom_charset_1 = mask;
15897 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15898 break;
15899
15900 case 1:
15901 mp_reset_usr (mp_usr, 1);
15902
15903 custom_charset_2 = mask;
15904 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15905 break;
15906
15907 case 2:
15908 mp_reset_usr (mp_usr, 2);
15909
15910 custom_charset_3 = mask;
15911 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15912 break;
15913
15914 case 3:
15915 mp_reset_usr (mp_usr, 3);
15916
15917 custom_charset_4 = mask;
15918 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15919 break;
15920 }
15921
15922 mask = mask + str_pos + 1;
15923 }
15924 }
15925
15926 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15927 {
15928 if (maskpos > 0)
15929 {
15930 local_free (css_buf);
15931 local_free (data.root_css_buf);
15932 local_free (data.markov_css_buf);
15933
15934 local_free (masks[maskpos - 1]);
15935 }
15936
15937 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15938
15939 data.mask = mask;
15940 data.css_cnt = css_cnt;
15941 data.css_buf = css_buf;
15942
15943 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15944
15945 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15946
15947 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15948 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15949
15950 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15951
15952 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15953
15954 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15955 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15956
15957 data.root_css_buf = root_css_buf;
15958 data.markov_css_buf = markov_css_buf;
15959
15960 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15961
15962 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15963
15964 local_free (root_table_buf);
15965 local_free (markov_table_buf);
15966
15967 // args
15968
15969 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15970 {
15971 hc_device_param_t *device_param = &data.devices_param[device_id];
15972
15973 if (device_param->skipped) continue;
15974
15975 device_param->kernel_params_mp[0] = &device_param->d_combs;
15976 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15977 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15978
15979 device_param->kernel_params_mp_buf64[3] = 0;
15980 device_param->kernel_params_mp_buf32[4] = css_cnt;
15981 device_param->kernel_params_mp_buf32[5] = 0;
15982 device_param->kernel_params_mp_buf32[6] = 0;
15983 device_param->kernel_params_mp_buf32[7] = 0;
15984
15985 if (attack_mode == ATTACK_MODE_HYBRID1)
15986 {
15987 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15988 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15989 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15990 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15991 }
15992 else if (attack_mode == ATTACK_MODE_HYBRID2)
15993 {
15994 device_param->kernel_params_mp_buf32[5] = 0;
15995 device_param->kernel_params_mp_buf32[6] = 0;
15996 device_param->kernel_params_mp_buf32[7] = 0;
15997 }
15998
15999 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]);
16000 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]);
16001 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]);
16002
16003 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);
16004 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);
16005 }
16006 }
16007 else if (attack_mode == ATTACK_MODE_BF)
16008 {
16009 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16010
16011 if (increment)
16012 {
16013 for (uint i = 0; i < dictcnt; i++)
16014 {
16015 local_free (dictfiles[i]);
16016 }
16017
16018 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16019 {
16020 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16021
16022 if (l1_filename == NULL) break;
16023
16024 dictcnt++;
16025
16026 dictfiles[dictcnt - 1] = l1_filename;
16027 }
16028 }
16029 else
16030 {
16031 dictcnt++;
16032
16033 dictfiles[dictcnt - 1] = mask;
16034 }
16035
16036 if (dictcnt == 0)
16037 {
16038 log_error ("ERROR: Mask is too small");
16039
16040 return (-1);
16041 }
16042 }
16043 }
16044
16045 free (induction_dictionaries);
16046
16047 // induction_dictionaries_cnt = 0; // implied
16048
16049 if (attack_mode != ATTACK_MODE_BF)
16050 {
16051 if (keyspace == 0)
16052 {
16053 induction_dictionaries = scan_directory (induction_directory);
16054
16055 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16056 }
16057 }
16058
16059 if (induction_dictionaries_cnt)
16060 {
16061 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16062 }
16063
16064 /**
16065 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16066 */
16067 if (keyspace == 1)
16068 {
16069 if ((maskcnt > 1) || (dictcnt > 1))
16070 {
16071 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16072
16073 return (-1);
16074 }
16075 }
16076
16077 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16078 {
16079 char *subid = logfile_generate_subid ();
16080
16081 data.subid = subid;
16082
16083 logfile_sub_msg ("START");
16084
16085 data.devices_status = STATUS_INIT;
16086
16087 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16088 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16089 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16090
16091 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16092
16093 data.cpt_pos = 0;
16094
16095 data.cpt_start = time (NULL);
16096
16097 data.cpt_total = 0;
16098
16099 if (data.restore == 0)
16100 {
16101 rd->words_cur = skip;
16102
16103 skip = 0;
16104
16105 data.skip = 0;
16106 }
16107
16108 data.ms_paused = 0;
16109
16110 data.words_cur = rd->words_cur;
16111
16112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16113 {
16114 hc_device_param_t *device_param = &data.devices_param[device_id];
16115
16116 if (device_param->skipped) continue;
16117
16118 device_param->speed_pos = 0;
16119
16120 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16121 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16122
16123 device_param->exec_pos = 0;
16124
16125 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16126
16127 device_param->kernel_power = device_param->kernel_power_user;
16128
16129 device_param->outerloop_pos = 0;
16130 device_param->outerloop_left = 0;
16131 device_param->innerloop_pos = 0;
16132 device_param->innerloop_left = 0;
16133
16134 // some more resets:
16135
16136 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16137
16138 device_param->pws_cnt = 0;
16139
16140 device_param->words_off = 0;
16141 device_param->words_done = 0;
16142 }
16143
16144 data.kernel_power_div = 0;
16145
16146 // figure out some workload
16147
16148 if (attack_mode == ATTACK_MODE_STRAIGHT)
16149 {
16150 if (data.wordlist_mode == WL_MODE_FILE)
16151 {
16152 char *dictfile = NULL;
16153
16154 if (induction_dictionaries_cnt)
16155 {
16156 dictfile = induction_dictionaries[0];
16157 }
16158 else
16159 {
16160 dictfile = dictfiles[dictpos];
16161 }
16162
16163 data.dictfile = dictfile;
16164
16165 logfile_sub_string (dictfile);
16166
16167 for (uint i = 0; i < rp_files_cnt; i++)
16168 {
16169 logfile_sub_var_string ("rulefile", rp_files[i]);
16170 }
16171
16172 FILE *fd2 = fopen (dictfile, "rb");
16173
16174 if (fd2 == NULL)
16175 {
16176 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16177
16178 return (-1);
16179 }
16180
16181 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16182
16183 fclose (fd2);
16184
16185 if (data.words_cnt == 0)
16186 {
16187 if (data.devices_status == STATUS_CRACKED) break;
16188 if (data.devices_status == STATUS_ABORTED) break;
16189
16190 dictpos++;
16191
16192 continue;
16193 }
16194 }
16195 }
16196 else if (attack_mode == ATTACK_MODE_COMBI)
16197 {
16198 char *dictfile = data.dictfile;
16199 char *dictfile2 = data.dictfile2;
16200
16201 logfile_sub_string (dictfile);
16202 logfile_sub_string (dictfile2);
16203
16204 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16205 {
16206 FILE *fd2 = fopen (dictfile, "rb");
16207
16208 if (fd2 == NULL)
16209 {
16210 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16211
16212 return (-1);
16213 }
16214
16215 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16216
16217 fclose (fd2);
16218 }
16219 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16220 {
16221 FILE *fd2 = fopen (dictfile2, "rb");
16222
16223 if (fd2 == NULL)
16224 {
16225 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16226
16227 return (-1);
16228 }
16229
16230 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16231
16232 fclose (fd2);
16233 }
16234
16235 if (data.words_cnt == 0)
16236 {
16237 if (data.devices_status == STATUS_CRACKED) break;
16238 if (data.devices_status == STATUS_ABORTED) break;
16239
16240 dictpos++;
16241
16242 continue;
16243 }
16244 }
16245 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16246 {
16247 char *dictfile = NULL;
16248
16249 if (induction_dictionaries_cnt)
16250 {
16251 dictfile = induction_dictionaries[0];
16252 }
16253 else
16254 {
16255 dictfile = dictfiles[dictpos];
16256 }
16257
16258 data.dictfile = dictfile;
16259
16260 char *mask = data.mask;
16261
16262 logfile_sub_string (dictfile);
16263 logfile_sub_string (mask);
16264
16265 FILE *fd2 = fopen (dictfile, "rb");
16266
16267 if (fd2 == NULL)
16268 {
16269 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16270
16271 return (-1);
16272 }
16273
16274 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16275
16276 fclose (fd2);
16277
16278 if (data.words_cnt == 0)
16279 {
16280 if (data.devices_status == STATUS_CRACKED) break;
16281 if (data.devices_status == STATUS_ABORTED) break;
16282
16283 dictpos++;
16284
16285 continue;
16286 }
16287 }
16288 else if (attack_mode == ATTACK_MODE_BF)
16289 {
16290 local_free (css_buf);
16291 local_free (data.root_css_buf);
16292 local_free (data.markov_css_buf);
16293
16294 char *mask = dictfiles[dictpos];
16295
16296 logfile_sub_string (mask);
16297
16298 // base
16299
16300 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16301
16302 if (opts_type & OPTS_TYPE_PT_UNICODE)
16303 {
16304 uint css_cnt_unicode = css_cnt * 2;
16305
16306 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16307
16308 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16309 {
16310 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16311
16312 css_buf_unicode[j + 1].cs_buf[0] = 0;
16313 css_buf_unicode[j + 1].cs_len = 1;
16314 }
16315
16316 free (css_buf);
16317
16318 css_buf = css_buf_unicode;
16319 css_cnt = css_cnt_unicode;
16320 }
16321
16322 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16323
16324 uint mask_min = pw_min;
16325 uint mask_max = pw_max;
16326
16327 if (opts_type & OPTS_TYPE_PT_UNICODE)
16328 {
16329 mask_min *= 2;
16330 mask_max *= 2;
16331 }
16332
16333 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16334 {
16335 if (css_cnt < mask_min)
16336 {
16337 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16338 }
16339
16340 if (css_cnt > mask_max)
16341 {
16342 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16343 }
16344
16345 // skip to next mask
16346
16347 dictpos++;
16348
16349 rd->dictpos = dictpos;
16350
16351 logfile_sub_msg ("STOP");
16352
16353 continue;
16354 }
16355
16356 uint save_css_cnt = css_cnt;
16357
16358 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16359 {
16360 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16361 {
16362 uint salt_len = (uint) data.salts_buf[0].salt_len;
16363 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16364
16365 uint css_cnt_salt = css_cnt + salt_len;
16366
16367 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16368
16369 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16370
16371 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16372 {
16373 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16374 css_buf_salt[j].cs_len = 1;
16375 }
16376
16377 free (css_buf);
16378
16379 css_buf = css_buf_salt;
16380 css_cnt = css_cnt_salt;
16381 }
16382 }
16383
16384 data.mask = mask;
16385 data.css_cnt = css_cnt;
16386 data.css_buf = css_buf;
16387
16388 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16389
16390 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16391
16392 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16393
16394 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16395 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16396
16397 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16398
16399 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16400
16401 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16402 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16403
16404 data.root_css_buf = root_css_buf;
16405 data.markov_css_buf = markov_css_buf;
16406
16407 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16408
16409 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16410
16411 local_free (root_table_buf);
16412 local_free (markov_table_buf);
16413
16414 // copy + args
16415
16416 uint css_cnt_l = css_cnt;
16417 uint css_cnt_r;
16418
16419 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16420 {
16421 if (save_css_cnt < 6)
16422 {
16423 css_cnt_r = 1;
16424 }
16425 else if (save_css_cnt == 6)
16426 {
16427 css_cnt_r = 2;
16428 }
16429 else
16430 {
16431 if (opts_type & OPTS_TYPE_PT_UNICODE)
16432 {
16433 if (save_css_cnt == 8 || save_css_cnt == 10)
16434 {
16435 css_cnt_r = 2;
16436 }
16437 else
16438 {
16439 css_cnt_r = 4;
16440 }
16441 }
16442 else
16443 {
16444 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16445 {
16446 css_cnt_r = 3;
16447 }
16448 else
16449 {
16450 css_cnt_r = 4;
16451 }
16452 }
16453 }
16454 }
16455 else
16456 {
16457 css_cnt_r = 1;
16458
16459 /* unfinished code?
16460 int sum = css_buf[css_cnt_r - 1].cs_len;
16461
16462 for (uint i = 1; i < 4 && i < css_cnt; i++)
16463 {
16464 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16465
16466 css_cnt_r++;
16467
16468 sum *= css_buf[css_cnt_r - 1].cs_len;
16469 }
16470 */
16471 }
16472
16473 css_cnt_l -= css_cnt_r;
16474
16475 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16476
16477 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16478 {
16479 hc_device_param_t *device_param = &data.devices_param[device_id];
16480
16481 if (device_param->skipped) continue;
16482
16483 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16484 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16485 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16486
16487 device_param->kernel_params_mp_l_buf64[3] = 0;
16488 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16489 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16490 device_param->kernel_params_mp_l_buf32[6] = 0;
16491 device_param->kernel_params_mp_l_buf32[7] = 0;
16492 device_param->kernel_params_mp_l_buf32[8] = 0;
16493
16494 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16495 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16496 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16497 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16498
16499 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16500 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16501 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16502
16503 device_param->kernel_params_mp_r_buf64[3] = 0;
16504 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16505 device_param->kernel_params_mp_r_buf32[5] = 0;
16506 device_param->kernel_params_mp_r_buf32[6] = 0;
16507 device_param->kernel_params_mp_r_buf32[7] = 0;
16508
16509 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]);
16510 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]);
16511 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]);
16512
16513 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]);
16514 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]);
16515 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]);
16516
16517 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);
16518 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);
16519 }
16520 }
16521
16522 u64 words_base = data.words_cnt;
16523
16524 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16525 {
16526 if (data.kernel_rules_cnt)
16527 {
16528 words_base /= data.kernel_rules_cnt;
16529 }
16530 }
16531 else if (data.attack_kern == ATTACK_KERN_COMBI)
16532 {
16533 if (data.combs_cnt)
16534 {
16535 words_base /= data.combs_cnt;
16536 }
16537 }
16538 else if (data.attack_kern == ATTACK_KERN_BF)
16539 {
16540 if (data.bfs_cnt)
16541 {
16542 words_base /= data.bfs_cnt;
16543 }
16544 }
16545
16546 data.words_base = words_base;
16547
16548 if (keyspace == 1)
16549 {
16550 log_info ("%llu", (unsigned long long int) words_base);
16551
16552 return (0);
16553 }
16554
16555 if (data.words_cur > data.words_base)
16556 {
16557 log_error ("ERROR: restore value greater keyspace");
16558
16559 return (-1);
16560 }
16561
16562 if (data.words_cur)
16563 {
16564 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16565 {
16566 for (uint i = 0; i < data.salts_cnt; i++)
16567 {
16568 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16569 }
16570 }
16571 else if (data.attack_kern == ATTACK_KERN_COMBI)
16572 {
16573 for (uint i = 0; i < data.salts_cnt; i++)
16574 {
16575 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16576 }
16577 }
16578 else if (data.attack_kern == ATTACK_KERN_BF)
16579 {
16580 for (uint i = 0; i < data.salts_cnt; i++)
16581 {
16582 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16583 }
16584 }
16585 }
16586
16587 /*
16588 * Inform user about possible slow speeds
16589 */
16590
16591 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16592 {
16593 if (data.words_base < kernel_power_all)
16594 {
16595 if (quiet == 0)
16596 {
16597 log_info ("");
16598 log_info ("ATTENTION!");
16599 log_info (" The wordlist or mask you are using is too small.");
16600 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16601 log_info (" The cracking speed will drop.");
16602 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16603 log_info ("");
16604 }
16605 }
16606 }
16607
16608 /*
16609 * Update loopback file
16610 */
16611
16612 if (loopback == 1)
16613 {
16614 time_t now;
16615
16616 time (&now);
16617
16618 uint random_num = get_random_num (0, 9999);
16619
16620 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16621
16622 data.loopback_file = loopback_file;
16623 }
16624
16625 /*
16626 * Update dictionary statistic
16627 */
16628
16629 if (keyspace == 0)
16630 {
16631 dictstat_fp = fopen (dictstat, "wb");
16632
16633 if (dictstat_fp)
16634 {
16635 lock_file (dictstat_fp);
16636
16637 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16638
16639 fclose (dictstat_fp);
16640 }
16641 }
16642
16643 data.devices_status = STATUS_RUNNING;
16644
16645 if (initial_restore_done == 0)
16646 {
16647 if (data.restore_disable == 0) cycle_restore ();
16648
16649 initial_restore_done = 1;
16650 }
16651
16652 hc_timer_set (&data.timer_running);
16653
16654 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16655 {
16656 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16657 {
16658 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16659 if (quiet == 0) fflush (stdout);
16660 }
16661 }
16662 else if (wordlist_mode == WL_MODE_STDIN)
16663 {
16664 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16665 if (data.quiet == 0) log_info ("");
16666 }
16667
16668 time_t runtime_start;
16669
16670 time (&runtime_start);
16671
16672 data.runtime_start = runtime_start;
16673
16674 /**
16675 * create cracker threads
16676 */
16677
16678 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16679
16680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16681 {
16682 hc_device_param_t *device_param = &devices_param[device_id];
16683
16684 if (wordlist_mode == WL_MODE_STDIN)
16685 {
16686 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16687 }
16688 else
16689 {
16690 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16691 }
16692 }
16693
16694 // wait for crack threads to exit
16695
16696 hc_thread_wait (data.devices_cnt, c_threads);
16697
16698 local_free (c_threads);
16699
16700 data.restore = 0;
16701
16702 // finalize task
16703
16704 logfile_sub_var_uint ("status-after-work", data.devices_status);
16705
16706 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16707
16708 if (data.devices_status == STATUS_CRACKED) break;
16709 if (data.devices_status == STATUS_ABORTED) break;
16710
16711 if (data.devices_status == STATUS_BYPASS)
16712 {
16713 data.devices_status = STATUS_RUNNING;
16714 }
16715
16716 if (induction_dictionaries_cnt)
16717 {
16718 unlink (induction_dictionaries[0]);
16719 }
16720
16721 free (induction_dictionaries);
16722
16723 if (attack_mode != ATTACK_MODE_BF)
16724 {
16725 induction_dictionaries = scan_directory (induction_directory);
16726
16727 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16728 }
16729
16730 if (benchmark == 0)
16731 {
16732 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16733 {
16734 if (quiet == 0) clear_prompt ();
16735
16736 if (quiet == 0) log_info ("");
16737
16738 if (status == 1)
16739 {
16740 status_display ();
16741 }
16742 else
16743 {
16744 if (quiet == 0) status_display ();
16745 }
16746
16747 if (quiet == 0) log_info ("");
16748 }
16749 }
16750
16751 if (attack_mode == ATTACK_MODE_BF)
16752 {
16753 dictpos++;
16754
16755 rd->dictpos = dictpos;
16756 }
16757 else
16758 {
16759 if (induction_dictionaries_cnt)
16760 {
16761 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16762 }
16763 else
16764 {
16765 dictpos++;
16766
16767 rd->dictpos = dictpos;
16768 }
16769 }
16770
16771 time_t runtime_stop;
16772
16773 time (&runtime_stop);
16774
16775 data.runtime_stop = runtime_stop;
16776
16777 logfile_sub_uint (runtime_start);
16778 logfile_sub_uint (runtime_stop);
16779
16780 logfile_sub_msg ("STOP");
16781
16782 global_free (subid);
16783 }
16784
16785 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16786
16787 if (data.devices_status == STATUS_CRACKED) break;
16788 if (data.devices_status == STATUS_ABORTED) break;
16789 if (data.devices_status == STATUS_QUIT) break;
16790
16791 if (data.devices_status == STATUS_BYPASS)
16792 {
16793 data.devices_status = STATUS_RUNNING;
16794 }
16795 }
16796
16797 // 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
16798
16799 if (attack_mode == ATTACK_MODE_STRAIGHT)
16800 {
16801 if (data.wordlist_mode == WL_MODE_FILE)
16802 {
16803 if (data.dictfile == NULL)
16804 {
16805 if (dictfiles != NULL)
16806 {
16807 data.dictfile = dictfiles[0];
16808
16809 hc_timer_set (&data.timer_running);
16810 }
16811 }
16812 }
16813 }
16814 // NOTE: combi is okay because it is already set beforehand
16815 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16816 {
16817 if (data.dictfile == NULL)
16818 {
16819 if (dictfiles != NULL)
16820 {
16821 hc_timer_set (&data.timer_running);
16822
16823 data.dictfile = dictfiles[0];
16824 }
16825 }
16826 }
16827 else if (attack_mode == ATTACK_MODE_BF)
16828 {
16829 if (data.mask == NULL)
16830 {
16831 hc_timer_set (&data.timer_running);
16832
16833 data.mask = masks[0];
16834 }
16835 }
16836
16837 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16838 {
16839 data.devices_status = STATUS_EXHAUSTED;
16840 }
16841
16842 // if cracked / aborted remove last induction dictionary
16843
16844 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16845 {
16846 struct stat induct_stat;
16847
16848 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16849 {
16850 unlink (induction_dictionaries[file_pos]);
16851 }
16852 }
16853
16854 // wait for non-interactive threads
16855
16856 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16857 {
16858 hc_thread_wait (1, &ni_threads[thread_idx]);
16859 }
16860
16861 local_free (ni_threads);
16862
16863 // wait for interactive threads
16864
16865 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16866 {
16867 hc_thread_wait (1, &i_thread);
16868 }
16869
16870 // we dont need restore file anymore
16871 if (data.restore_disable == 0)
16872 {
16873 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16874 {
16875 unlink (eff_restore_file);
16876 unlink (new_restore_file);
16877 }
16878 else
16879 {
16880 cycle_restore ();
16881 }
16882 }
16883
16884 // finally save left hashes
16885
16886 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16887 {
16888 save_hash ();
16889 }
16890
16891 /**
16892 * Clean up
16893 */
16894
16895 if (benchmark == 1)
16896 {
16897 status_benchmark ();
16898
16899 log_info ("");
16900 }
16901 else
16902 {
16903 if (quiet == 0) clear_prompt ();
16904
16905 if (quiet == 0) log_info ("");
16906
16907 if (status == 1)
16908 {
16909 status_display ();
16910 }
16911 else
16912 {
16913 if (quiet == 0) status_display ();
16914 }
16915
16916 if (quiet == 0) log_info ("");
16917 }
16918
16919 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16920 {
16921 hc_device_param_t *device_param = &data.devices_param[device_id];
16922
16923 if (device_param->skipped) continue;
16924
16925 local_free (device_param->result);
16926
16927 local_free (device_param->combs_buf);
16928
16929 local_free (device_param->hooks_buf);
16930
16931 local_free (device_param->device_name);
16932
16933 local_free (device_param->device_name_chksum);
16934
16935 local_free (device_param->device_version);
16936
16937 local_free (device_param->driver_version);
16938
16939 if (device_param->pws_buf) myfree (device_param->pws_buf);
16940 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16941 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16942 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16943 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16944 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16945 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16946 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16947 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16948 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16949 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16950 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16951 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16952 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16953 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16954 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16955 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16956 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16957 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16958 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16959 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16960 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16961 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16962 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16963 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16964 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16965 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16966 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16967 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16968
16969 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16970 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16971 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16972 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16973 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16974 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16975 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16976 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16977 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16978 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16979
16980 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16981 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16982 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16983
16984 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16985 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16986 }
16987
16988 // reset default fan speed
16989
16990 #ifdef HAVE_HWMON
16991 if (gpu_temp_disable == 0)
16992 {
16993 #ifdef HAVE_ADL
16994 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16995 {
16996 hc_thread_mutex_lock (mux_adl);
16997
16998 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16999 {
17000 hc_device_param_t *device_param = &data.devices_param[device_id];
17001
17002 if (device_param->skipped) continue;
17003
17004 if (data.hm_device[device_id].fan_supported == 1)
17005 {
17006 int fanspeed = temp_retain_fanspeed_value[device_id];
17007
17008 if (fanspeed == -1) continue;
17009
17010 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17011
17012 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17013 }
17014 }
17015
17016 hc_thread_mutex_unlock (mux_adl);
17017 }
17018 #endif // HAVE_ADL
17019 }
17020
17021 #ifdef HAVE_ADL
17022 // reset power tuning
17023
17024 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17025 {
17026 hc_thread_mutex_lock (mux_adl);
17027
17028 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17029 {
17030 hc_device_param_t *device_param = &data.devices_param[device_id];
17031
17032 if (device_param->skipped) continue;
17033
17034 if (data.hm_device[device_id].od_version == 6)
17035 {
17036 // check powertune capabilities first, if not available then skip device
17037
17038 int powertune_supported = 0;
17039
17040 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17041 {
17042 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17043
17044 return (-1);
17045 }
17046
17047 if (powertune_supported != 0)
17048 {
17049 // powercontrol settings
17050
17051 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)
17052 {
17053 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17054
17055 return (-1);
17056 }
17057
17058 // clocks
17059
17060 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17061
17062 performance_state->iNumberOfPerformanceLevels = 2;
17063
17064 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17065 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17066 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17067 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17068
17069 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)
17070 {
17071 log_info ("ERROR: Failed to restore ADL performance state");
17072
17073 return (-1);
17074 }
17075
17076 local_free (performance_state);
17077 }
17078 }
17079 }
17080
17081 hc_thread_mutex_unlock (mux_adl);
17082 }
17083 #endif // HAVE_ADL
17084
17085 if (gpu_temp_disable == 0)
17086 {
17087 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17088 if (data.hm_nv)
17089 {
17090 #if defined(LINUX) && defined(HAVE_NVML)
17091
17092 hm_NVML_nvmlShutdown (data.hm_nv);
17093
17094 nvml_close (data.hm_nv);
17095
17096 #elif defined(WIN) && (HAVE_NVAPI)
17097
17098 hm_NvAPI_Unload (data.hm_nv);
17099
17100 nvapi_close (data.hm_nv);
17101
17102 #endif
17103
17104 data.hm_nv = NULL;
17105 }
17106 #endif
17107
17108 #ifdef HAVE_ADL
17109 if (data.hm_amd)
17110 {
17111 hm_ADL_Main_Control_Destroy (data.hm_amd);
17112
17113 adl_close (data.hm_amd);
17114 data.hm_amd = NULL;
17115 }
17116 #endif
17117 }
17118 #endif // HAVE_HWMON
17119
17120 // free memory
17121
17122 local_free (masks);
17123
17124 local_free (dictstat_base);
17125
17126 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17127 {
17128 pot_t *pot_ptr = &pot[pot_pos];
17129
17130 hash_t *hash = &pot_ptr->hash;
17131
17132 local_free (hash->digest);
17133
17134 if (isSalted)
17135 {
17136 local_free (hash->salt);
17137 }
17138 }
17139
17140 local_free (pot);
17141
17142 local_free (all_kernel_rules_cnt);
17143 local_free (all_kernel_rules_buf);
17144
17145 local_free (wl_data->buf);
17146 local_free (wl_data);
17147
17148 local_free (bitmap_s1_a);
17149 local_free (bitmap_s1_b);
17150 local_free (bitmap_s1_c);
17151 local_free (bitmap_s1_d);
17152 local_free (bitmap_s2_a);
17153 local_free (bitmap_s2_b);
17154 local_free (bitmap_s2_c);
17155 local_free (bitmap_s2_d);
17156
17157 #ifdef HAVE_HWMON
17158 local_free (temp_retain_fanspeed_value);
17159 #ifdef HAVE_ADL
17160 local_free (od_clock_mem_status);
17161 local_free (od_power_control_status);
17162 #endif // ADL
17163 #endif
17164
17165 global_free (devices_param);
17166
17167 global_free (kernel_rules_buf);
17168
17169 global_free (root_css_buf);
17170 global_free (markov_css_buf);
17171
17172 global_free (digests_buf);
17173 global_free (digests_shown);
17174 global_free (digests_shown_tmp);
17175
17176 global_free (salts_buf);
17177 global_free (salts_shown);
17178
17179 global_free (esalts_buf);
17180
17181 global_free (words_progress_done);
17182 global_free (words_progress_rejected);
17183 global_free (words_progress_restored);
17184
17185 if (pot_fp) fclose (pot_fp);
17186
17187 if (data.devices_status == STATUS_QUIT) break;
17188 }
17189
17190 // destroy others mutex
17191
17192 hc_thread_mutex_delete (mux_dispatcher);
17193 hc_thread_mutex_delete (mux_counter);
17194 hc_thread_mutex_delete (mux_display);
17195 hc_thread_mutex_delete (mux_adl);
17196
17197 // free memory
17198
17199 local_free (eff_restore_file);
17200 local_free (new_restore_file);
17201
17202 local_free (rd);
17203
17204 // tuning db
17205
17206 tuning_db_destroy (tuning_db);
17207
17208 // loopback
17209
17210 local_free (loopback_file);
17211
17212 if (loopback == 1) unlink (loopback_file);
17213
17214 // induction directory
17215
17216 if (induction_dir == NULL)
17217 {
17218 if (attack_mode != ATTACK_MODE_BF)
17219 {
17220 if (rmdir (induction_directory) == -1)
17221 {
17222 if (errno == ENOENT)
17223 {
17224 // good, we can ignore
17225 }
17226 else if (errno == ENOTEMPTY)
17227 {
17228 // good, we can ignore
17229 }
17230 else
17231 {
17232 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17233
17234 return (-1);
17235 }
17236 }
17237
17238 local_free (induction_directory);
17239 }
17240 }
17241
17242 // outfile-check directory
17243
17244 if (outfile_check_dir == NULL)
17245 {
17246 if (rmdir (outfile_check_directory) == -1)
17247 {
17248 if (errno == ENOENT)
17249 {
17250 // good, we can ignore
17251 }
17252 else if (errno == ENOTEMPTY)
17253 {
17254 // good, we can ignore
17255 }
17256 else
17257 {
17258 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17259
17260 return (-1);
17261 }
17262 }
17263
17264 local_free (outfile_check_directory);
17265 }
17266
17267 time_t proc_stop;
17268
17269 time (&proc_stop);
17270
17271 logfile_top_uint (proc_start);
17272 logfile_top_uint (proc_stop);
17273
17274 logfile_top_msg ("STOP");
17275
17276 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17277 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17278
17279 if (data.ocl) ocl_close (data.ocl);
17280
17281 if (data.devices_status == STATUS_ABORTED) return 2;
17282 if (data.devices_status == STATUS_QUIT) return 2;
17283 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17284 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17285 if (data.devices_status == STATUS_CRACKED) return 0;
17286
17287 return -1;
17288 }
Hashcat additions to support pwdhash