projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
show build log whenever 'make DEBUG > 0' is set
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 133
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000,
224 1000,
225 1100,
226 2100,
227 12800,
228 1500,
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 13200,
264 13300,
265 6211,
266 6221,
267 6231,
268 6241,
269 8800,
270 12900,
271 12200,
272 9700,
273 9710,
274 9800,
275 9810,
276 9400,
277 9500,
278 9600,
279 10400,
280 10410,
281 10500,
282 10600,
283 10700,
284 9000,
285 5200,
286 6800,
287 6600,
288 8200,
289 11300,
290 12700
291 };
292
293 /**
294 * types
295 */
296
297 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
298
299 /**
300 * globals
301 */
302
303 static unsigned int full01 = 0x01010101;
304 static unsigned int full80 = 0x80808080;
305
306 int SUPPRESS_OUTPUT = 0;
307
308 hc_thread_mutex_t mux_adl;
309 hc_thread_mutex_t mux_counter;
310 hc_thread_mutex_t mux_dispatcher;
311 hc_thread_mutex_t mux_display;
312
313 hc_global_data_t data;
314
315 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
316
317 const char *USAGE_MINI[] =
318 {
319 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
320 "",
321 "Try --help for more help.",
322 NULL
323 };
324
325 const char *USAGE_BIG[] =
326 {
327 "%s, advanced password recovery",
328 "",
329 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
330 "",
331 "=======",
332 "Options",
333 "=======",
334 "",
335 "* General:",
336 "",
337 " -m, --hash-type=NUM Hash-type, see references below",
338 " -a, --attack-mode=NUM Attack-mode, see references below",
339 " -V, --version Print version",
340 " -h, --help Print help",
341 " --quiet Suppress output",
342 "",
343 "* Misc:",
344 "",
345 " --hex-charset Assume charset is given in hex",
346 " --hex-salt Assume salt is given in hex",
347 " --hex-wordlist Assume words in wordlist is given in hex",
348 " --force Ignore warnings",
349 " --status Enable automatic update of the status-screen",
350 " --status-timer=NUM Seconds between status-screen update",
351 " --status-automat Display the status view in a machine readable format",
352 " --loopback Add new plains to induct directory",
353 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
354 "",
355 "* Markov:",
356 "",
357 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
358 " --markov-disable Disables markov-chains, emulates classic brute-force",
359 " --markov-classic Enables classic markov-chains, no per-position enhancement",
360 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
361 "",
362 "* Session:",
363 "",
364 " --runtime=NUM Abort session after NUM seconds of runtime",
365 " --session=STR Define specific session name",
366 " --restore Restore session from --session",
367 " --restore-disable Do not write restore file",
368 "",
369 "* Files:",
370 "",
371 " -o, --outfile=FILE Define outfile for recovered hash",
372 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
373 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
374 " --outfile-check-timer=NUM Seconds between outfile checks",
375 " -p, --separator=CHAR Separator char for hashlists and outfile",
376 " --show Show cracked passwords only",
377 " --left Show un-cracked passwords only",
378 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
379 " --remove Enable remove of hash once it is cracked",
380 " --remove-timer=NUM Update input hash file each NUM seconds",
381 " --potfile-disable Do not write potfile",
382 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
383 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
384 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
385 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
386 " --logfile-disable Disable the logfile",
387 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
388 "",
389 "* Resources:",
390 "",
391 " -b, --benchmark Run benchmark",
392 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
393 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
394 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
395 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
397 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
398 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
399 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
400 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
401 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
402 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
403 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
404 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
405 #ifdef HAVE_HWMON
406 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
407 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
408 #ifdef HAVE_ADL
409 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
410 #endif
411 #endif
412 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
413 "",
414 "* Distributed:",
415 "",
416 " -s, --skip=NUM Skip number of words",
417 " -l, --limit=NUM Limit number of words",
418 " --keyspace Show keyspace base:mod values and quit",
419 "",
420 "* Rules:",
421 "",
422 " -j, --rule-left=RULE Single rule applied to each word from left dict",
423 " -k, --rule-right=RULE Single rule applied to each word from right dict",
424 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
425 " -g, --generate-rules=NUM Generate NUM random rules",
426 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
427 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
428 " --generate-rules-seed=NUM Force RNG seed to NUM",
429 "",
430 "* Custom charsets:",
431 "",
432 " -1, --custom-charset1=CS User-defined charsets",
433 " -2, --custom-charset2=CS Example:",
434 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
435 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
436 "",
437 "* Increment:",
438 "",
439 " -i, --increment Enable increment mode",
440 " --increment-min=NUM Start incrementing at NUM",
441 " --increment-max=NUM Stop incrementing at NUM",
442 "",
443 "==========",
444 "References",
445 "==========",
446 "",
447 "* Workload Profile:",
448 "",
449 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
450 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
451 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
452 "",
453 "* OpenCL device-types:",
454 "",
455 " 1 = CPU devices",
456 " 2 = GPU devices",
457 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
458 "",
459 "* Outfile Formats:",
460 "",
461 " 1 = hash[:salt]",
462 " 2 = plain",
463 " 3 = hash[:salt]:plain",
464 " 4 = hex_plain",
465 " 5 = hash[:salt]:hex_plain",
466 " 6 = plain:hex_plain",
467 " 7 = hash[:salt]:plain:hex_plain",
468 " 8 = crackpos",
469 " 9 = hash[:salt]:crackpos",
470 " 10 = plain:crackpos",
471 " 11 = hash[:salt]:plain:crackpos",
472 " 12 = hex_plain:crackpos",
473 " 13 = hash[:salt]:hex_plain:crackpos",
474 " 14 = plain:hex_plain:crackpos",
475 " 15 = hash[:salt]:plain:hex_plain:crackpos",
476 "",
477 "* Debug mode output formats (for hybrid mode only, by using rules):",
478 "",
479 " 1 = save finding rule",
480 " 2 = save original word",
481 " 3 = save original word and finding rule",
482 " 4 = save original word, finding rule and modified plain",
483 "",
484 "* Built-in charsets:",
485 "",
486 " ?l = abcdefghijklmnopqrstuvwxyz",
487 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
488 " ?d = 0123456789",
489 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
490 " ?a = ?l?u?d?s",
491 " ?b = 0x00 - 0xff",
492 "",
493 "* Attack modes:",
494 "",
495 " 0 = Straight",
496 " 1 = Combination",
497 " 3 = Brute-force",
498 " 6 = Hybrid dict + mask",
499 " 7 = Hybrid mask + dict",
500 "",
501 "* Hash types:",
502 "",
503 "[[ Roll-your-own: Raw Hashes ]]",
504 "",
505 " 900 = MD4",
506 " 0 = MD5",
507 " 5100 = Half MD5",
508 " 100 = SHA1",
509 " 10800 = SHA-384",
510 " 1400 = SHA-256",
511 " 1700 = SHA-512",
512 " 5000 = SHA-3(Keccak)",
513 " 10100 = SipHash",
514 " 6000 = RipeMD160",
515 " 6100 = Whirlpool",
516 " 6900 = GOST R 34.11-94",
517 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
518 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
519 "",
520 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
521 "",
522 " 10 = md5($pass.$salt)",
523 " 20 = md5($salt.$pass)",
524 " 30 = md5(unicode($pass).$salt)",
525 " 40 = md5($salt.unicode($pass))",
526 " 3800 = md5($salt.$pass.$salt)",
527 " 3710 = md5($salt.md5($pass))",
528 " 2600 = md5(md5($pass)",
529 " 4300 = md5(strtoupper(md5($pass)))",
530 " 4400 = md5(sha1($pass))",
531 " 110 = sha1($pass.$salt)",
532 " 120 = sha1($salt.$pass)",
533 " 130 = sha1(unicode($pass).$salt)",
534 " 140 = sha1($salt.unicode($pass))",
535 " 4500 = sha1(sha1($pass)",
536 " 4700 = sha1(md5($pass))",
537 " 4900 = sha1($salt.$pass.$salt)",
538 " 1410 = sha256($pass.$salt)",
539 " 1420 = sha256($salt.$pass)",
540 " 1430 = sha256(unicode($pass).$salt)",
541 " 1440 = sha256($salt.unicode($pass))",
542 " 1710 = sha512($pass.$salt)",
543 " 1720 = sha512($salt.$pass)",
544 " 1730 = sha512(unicode($pass).$salt)",
545 " 1740 = sha512($salt.unicode($pass))",
546 "",
547 "[[ Roll-your-own: Authenticated Hashes ]]",
548 "",
549 " 50 = HMAC-MD5 (key = $pass)",
550 " 60 = HMAC-MD5 (key = $salt)",
551 " 150 = HMAC-SHA1 (key = $pass)",
552 " 160 = HMAC-SHA1 (key = $salt)",
553 " 1450 = HMAC-SHA256 (key = $pass)",
554 " 1460 = HMAC-SHA256 (key = $salt)",
555 " 1750 = HMAC-SHA512 (key = $pass)",
556 " 1760 = HMAC-SHA512 (key = $salt)",
557 "",
558 "[[ Generic KDF ]]",
559 "",
560 " 400 = phpass",
561 " 8900 = scrypt",
562 " 11900 = PBKDF2-HMAC-MD5",
563 " 12000 = PBKDF2-HMAC-SHA1",
564 " 10900 = PBKDF2-HMAC-SHA256",
565 " 12100 = PBKDF2-HMAC-SHA512",
566 "",
567 "[[ Network protocols, Challenge-Response ]]",
568 "",
569 " 23 = Skype",
570 " 2500 = WPA/WPA2",
571 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
572 " 5300 = IKE-PSK MD5",
573 " 5400 = IKE-PSK SHA1",
574 " 5500 = NetNTLMv1",
575 " 5500 = NetNTLMv1 + ESS",
576 " 5600 = NetNTLMv2",
577 " 7300 = IPMI2 RAKP HMAC-SHA1",
578 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
579 " 8300 = DNSSEC (NSEC3)",
580 " 10200 = Cram MD5",
581 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
582 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
583 " 11400 = SIP digest authentication (MD5)",
584 " 13100 = Kerberos 5 TGS-REP etype 23",
585 "",
586 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
587 "",
588 " 121 = SMF (Simple Machines Forum)",
589 " 400 = phpBB3",
590 " 2611 = vBulletin < v3.8.5",
591 " 2711 = vBulletin > v3.8.5",
592 " 2811 = MyBB",
593 " 2811 = IPB (Invison Power Board)",
594 " 8400 = WBB3 (Woltlab Burning Board)",
595 " 11 = Joomla < 2.5.18",
596 " 400 = Joomla > 2.5.18",
597 " 400 = Wordpress",
598 " 2612 = PHPS",
599 " 7900 = Drupal7",
600 " 21 = osCommerce",
601 " 21 = xt:Commerce",
602 " 11000 = PrestaShop",
603 " 124 = Django (SHA-1)",
604 " 10000 = Django (PBKDF2-SHA256)",
605 " 3711 = Mediawiki B type",
606 " 7600 = Redmine",
607 "",
608 "[[ Database Server ]]",
609 "",
610 " 12 = PostgreSQL",
611 " 131 = MSSQL(2000)",
612 " 132 = MSSQL(2005)",
613 " 1731 = MSSQL(2012)",
614 " 1731 = MSSQL(2014)",
615 " 200 = MySQL323",
616 " 300 = MySQL4.1/MySQL5",
617 " 3100 = Oracle H: Type (Oracle 7+)",
618 " 112 = Oracle S: Type (Oracle 11+)",
619 " 12300 = Oracle T: Type (Oracle 12+)",
620 " 8000 = Sybase ASE",
621 "",
622 "[[ HTTP, SMTP, LDAP Server ]]",
623 "",
624 " 141 = EPiServer 6.x < v4",
625 " 1441 = EPiServer 6.x > v4",
626 " 1600 = Apache $apr1$",
627 " 12600 = ColdFusion 10+",
628 " 1421 = hMailServer",
629 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
630 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
631 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
632 "",
633 "[[ Checksums ]]",
634 "",
635 " 11500 = CRC32",
636 "",
637 "[[ Operating-Systems ]]",
638 "",
639 " 3000 = LM",
640 " 1000 = NTLM",
641 " 1100 = Domain Cached Credentials (DCC), MS Cache",
642 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
643 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
644 " 1500 = descrypt, DES(Unix), Traditional DES",
645 " 12400 = BSDiCrypt, Extended DES",
646 " 500 = md5crypt $1$, MD5(Unix)",
647 " 3200 = bcrypt $2*$, Blowfish(Unix)",
648 " 7400 = sha256crypt $5$, SHA256(Unix)",
649 " 1800 = sha512crypt $6$, SHA512(Unix)",
650 " 122 = OSX v10.4",
651 " 122 = OSX v10.5",
652 " 122 = OSX v10.6",
653 " 1722 = OSX v10.7",
654 " 7100 = OSX v10.8",
655 " 7100 = OSX v10.9",
656 " 7100 = OSX v10.10",
657 " 6300 = AIX {smd5}",
658 " 6700 = AIX {ssha1}",
659 " 6400 = AIX {ssha256}",
660 " 6500 = AIX {ssha512}",
661 " 2400 = Cisco-PIX",
662 " 2410 = Cisco-ASA",
663 " 500 = Cisco-IOS $1$",
664 " 5700 = Cisco-IOS $4$",
665 " 9200 = Cisco-IOS $8$",
666 " 9300 = Cisco-IOS $9$",
667 " 22 = Juniper Netscreen/SSG (ScreenOS)",
668 " 501 = Juniper IVE",
669 " 5800 = Android PIN",
670 " 8100 = Citrix Netscaler",
671 " 8500 = RACF",
672 " 7200 = GRUB 2",
673 " 9900 = Radmin2",
674 "",
675 "[[ Enterprise Application Software (EAS) ]]",
676 "",
677 " 7700 = SAP CODVN B (BCODE)",
678 " 7800 = SAP CODVN F/G (PASSCODE)",
679 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
680 " 8600 = Lotus Notes/Domino 5",
681 " 8700 = Lotus Notes/Domino 6",
682 " 9100 = Lotus Notes/Domino 8",
683 " 133 = PeopleSoft",
684 "",
685 "[[ Archives ]]",
686 "",
687 " 11600 = 7-Zip",
688 " 12500 = RAR3-hp",
689 " 13000 = RAR5",
690 " 13200 = AxCrypt",
691 " 13300 = AxCrypt in memory SHA1",
692 "",
693 "[[ Full-Disk encryptions (FDE) ]]",
694 "",
695 " 62XY = TrueCrypt 5.0+",
696 " X = 1 = PBKDF2-HMAC-RipeMD160",
697 " X = 2 = PBKDF2-HMAC-SHA512",
698 " X = 3 = PBKDF2-HMAC-Whirlpool",
699 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
700 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
701 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
702 " Y = 3 = XTS 1536 bit (Ciphers: All)",
703 " 8800 = Android FDE < v4.3",
704 " 12900 = Android FDE (Samsung DEK)",
705 " 12200 = eCryptfs",
706 "",
707 "[[ Documents ]]",
708 "",
709 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
710 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
711 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
712 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
713 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
714 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
715 " 9400 = MS Office 2007",
716 " 9500 = MS Office 2010",
717 " 9600 = MS Office 2013",
718 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
719 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
720 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
721 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
722 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
723 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
724 "",
725 "[[ Password Managers ]]",
726 "",
727 " 9000 = Password Safe v2",
728 " 5200 = Password Safe v3",
729 " 6800 = Lastpass",
730 " 6600 = 1Password, agilekeychain",
731 " 8200 = 1Password, cloudkeychain",
732 " 11300 = Bitcoin/Litecoin wallet.dat",
733 " 12700 = Blockchain, My Wallet",
734 "",
735 NULL
736 };
737
738 /**
739 * oclHashcat specific functions
740 */
741
742 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
743 {
744 int exec_pos = (int) device_param->exec_pos - last_num_entries;
745
746 if (exec_pos < 0) exec_pos += EXEC_CACHE;
747
748 double exec_ms_sum = 0;
749
750 int exec_ms_cnt = 0;
751
752 for (int i = 0; i < last_num_entries; i++)
753 {
754 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
755
756 if (exec_ms)
757 {
758 exec_ms_sum += exec_ms;
759
760 exec_ms_cnt++;
761 }
762 }
763
764 if (exec_ms_cnt == 0) return 0;
765
766 return exec_ms_sum / exec_ms_cnt;
767 }
768
769 void status_display_automat ()
770 {
771 FILE *out = stdout;
772
773 fprintf (out, "STATUS\t%u\t", data.devices_status);
774
775 /**
776 * speed new
777 */
778
779 fprintf (out, "SPEED\t");
780
781 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
782 {
783 hc_device_param_t *device_param = &data.devices_param[device_id];
784
785 if (device_param->skipped) continue;
786
787 u64 speed_cnt = 0;
788 float speed_ms = 0;
789
790 for (int i = 0; i < SPEED_CACHE; i++)
791 {
792 float rec_ms;
793
794 hc_timer_get (device_param->speed_rec[i], rec_ms);
795
796 if (rec_ms > SPEED_MAXAGE) continue;
797
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 uint salts_left = data.salts_cnt - data.salts_done;
838
839 if (salts_left == 0) salts_left = 1;
840
841 u64 progress_total = data.words_cnt * salts_left;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 if (salts_left > 1)
850 {
851 // otherwise the final cracked status shows 0/XXX progress
852
853 if (data.salts_shown[salt_pos] == 1) continue;
854 }
855
856 all_done += data.words_progress_done[salt_pos];
857 all_rejected += data.words_progress_rejected[salt_pos];
858 all_restored += data.words_progress_restored[salt_pos];
859 }
860
861 u64 progress_cur = all_restored + all_done + all_rejected;
862 u64 progress_end = progress_total;
863
864 u64 progress_skip = 0;
865
866 if (data.skip)
867 {
868 progress_skip = MIN (data.skip, data.words_base) * salts_left;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
873 }
874
875 if (data.limit)
876 {
877 progress_end = MIN (data.limit, data.words_base) * salts_left;
878
879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
880 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
881 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
882 }
883
884 u64 progress_cur_relative_skip = progress_cur - progress_skip;
885 u64 progress_end_relative_skip = progress_end - progress_skip;
886
887 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
888
889 /**
890 * cracks
891 */
892
893 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
894 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
895
896 /**
897 * temperature
898 */
899
900 #ifdef HAVE_HWMON
901 if (data.gpu_temp_disable == 0)
902 {
903 fprintf (out, "TEMP\t");
904
905 hc_thread_mutex_lock (mux_adl);
906
907 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
908 {
909 hc_device_param_t *device_param = &data.devices_param[device_id];
910
911 if (device_param->skipped) continue;
912
913 int temp = hm_get_temperature_with_device_id (device_id);
914
915 fprintf (out, "%d\t", temp);
916 }
917
918 hc_thread_mutex_unlock (mux_adl);
919 }
920 #endif // HAVE_HWMON
921
922 /**
923 * flush
924 */
925
926 #ifdef _WIN
927 fputc ('\r', out);
928 fputc ('\n', out);
929 #endif
930
931 #ifdef _POSIX
932 fputc ('\n', out);
933 #endif
934
935 fflush (out);
936 }
937
938 void status_display ()
939 {
940 if (data.devices_status == STATUS_INIT) return;
941 if (data.devices_status == STATUS_STARTING) return;
942 if (data.devices_status == STATUS_BYPASS) return;
943
944 if (data.status_automat == 1)
945 {
946 status_display_automat ();
947
948 return;
949 }
950
951 char tmp_buf[1000] = { 0 };
952
953 uint tmp_len = 0;
954
955 log_info ("Session.Name...: %s", data.session);
956
957 char *status_type = strstatus (data.devices_status);
958
959 uint hash_mode = data.hash_mode;
960
961 char *hash_type = strhashtype (hash_mode); // not a bug
962
963 log_info ("Status.........: %s", status_type);
964
965 /**
966 * show rules
967 */
968
969 if (data.rp_files_cnt)
970 {
971 uint i;
972
973 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
974 {
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
976 }
977
978 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
979
980 log_info ("Rules.Type.....: %s", tmp_buf);
981
982 tmp_len = 0;
983 }
984
985 if (data.rp_gen)
986 {
987 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
988
989 if (data.rp_gen_seed)
990 {
991 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
992 }
993 }
994
995 /**
996 * show input
997 */
998
999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1000 {
1001 if (data.wordlist_mode == WL_MODE_FILE)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1004 }
1005 else if (data.wordlist_mode == WL_MODE_STDIN)
1006 {
1007 log_info ("Input.Mode.....: Pipe");
1008 }
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_COMBI)
1011 {
1012 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1013 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1014 }
1015 else if (data.attack_mode == ATTACK_MODE_BF)
1016 {
1017 char *mask = data.mask;
1018
1019 if (mask != NULL)
1020 {
1021 uint mask_len = data.css_cnt;
1022
1023 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1024
1025 if (mask_len > 0)
1026 {
1027 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1028 {
1029 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1030 {
1031 mask_len -= data.salts_buf[0].salt_len;
1032 }
1033 }
1034
1035 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1036
1037 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1038 }
1039
1040 if (data.maskcnt > 1)
1041 {
1042 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1043
1044 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1045 }
1046
1047 log_info ("Input.Mode.....: %s", tmp_buf);
1048 }
1049
1050 tmp_len = 0;
1051 }
1052 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1053 {
1054 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1055 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 }
1057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1058 {
1059 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1060 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1061 }
1062
1063 if (data.digests_cnt == 1)
1064 {
1065 if (data.hash_mode == 2500)
1066 {
1067 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1068
1069 uint pke[25] = { 0 };
1070
1071 char *pke_ptr = (char *) pke;
1072
1073 for (uint i = 0; i < 25; i++)
1074 {
1075 pke[i] = byte_swap_32 (wpa->pke[i]);
1076 }
1077
1078 char mac1[6] = { 0 };
1079 char mac2[6] = { 0 };
1080
1081 memcpy (mac1, pke_ptr + 23, 6);
1082 memcpy (mac2, pke_ptr + 29, 6);
1083
1084 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1085 (char *) data.salts_buf[0].salt_buf,
1086 mac1[0] & 0xff,
1087 mac1[1] & 0xff,
1088 mac1[2] & 0xff,
1089 mac1[3] & 0xff,
1090 mac1[4] & 0xff,
1091 mac1[5] & 0xff,
1092 mac2[0] & 0xff,
1093 mac2[1] & 0xff,
1094 mac2[2] & 0xff,
1095 mac2[3] & 0xff,
1096 mac2[4] & 0xff,
1097 mac2[5] & 0xff);
1098 }
1099 else if (data.hash_mode == 5200)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if (data.hash_mode == 9000)
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 else
1112 {
1113 char out_buf[4096] = { 0 };
1114
1115 ascii_digest (out_buf, 0, 0);
1116
1117 // limit length
1118 if (strlen (out_buf) > 40)
1119 {
1120 out_buf[41] = '.';
1121 out_buf[42] = '.';
1122 out_buf[43] = '.';
1123 out_buf[44] = 0;
1124 }
1125
1126 log_info ("Hash.Target....: %s", out_buf);
1127 }
1128 }
1129 else
1130 {
1131 if (data.hash_mode == 3000)
1132 {
1133 char out_buf1[4096] = { 0 };
1134 char out_buf2[4096] = { 0 };
1135
1136 ascii_digest (out_buf1, 0, 0);
1137 ascii_digest (out_buf2, 0, 1);
1138
1139 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1140 }
1141 else
1142 {
1143 log_info ("Hash.Target....: File (%s)", data.hashfile);
1144 }
1145 }
1146
1147 log_info ("Hash.Type......: %s", hash_type);
1148
1149 /**
1150 * speed new
1151 */
1152
1153 u64 speed_cnt[DEVICES_MAX] = { 0 };
1154 float speed_ms[DEVICES_MAX] = { 0 };
1155
1156 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1157 {
1158 hc_device_param_t *device_param = &data.devices_param[device_id];
1159
1160 if (device_param->skipped) continue;
1161
1162 // we need to clear values (set to 0) because in case the device does
1163 // not get new candidates it idles around but speed display would
1164 // show it as working.
1165 // if we instantly set it to 0 after reading it happens that the
1166 // speed can be shown as zero if the users refreshes too fast.
1167 // therefore, we add a timestamp when a stat was recorded and if its
1168 // too old we will not use it
1169
1170 speed_cnt[device_id] = 0;
1171 speed_ms[device_id] = 0;
1172
1173 for (int i = 0; i < SPEED_CACHE; i++)
1174 {
1175 float rec_ms;
1176
1177 hc_timer_get (device_param->speed_rec[i], rec_ms);
1178
1179 if (rec_ms > SPEED_MAXAGE) continue;
1180
1181 speed_cnt[device_id] += device_param->speed_cnt[i];
1182 speed_ms[device_id] += device_param->speed_ms[i];
1183 }
1184
1185 speed_cnt[device_id] /= SPEED_CACHE;
1186 speed_ms[device_id] /= SPEED_CACHE;
1187 }
1188
1189 float hashes_all_ms = 0;
1190
1191 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1192
1193 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1194 {
1195 hc_device_param_t *device_param = &data.devices_param[device_id];
1196
1197 if (device_param->skipped) continue;
1198
1199 hashes_dev_ms[device_id] = 0;
1200
1201 if (speed_ms[device_id])
1202 {
1203 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1204
1205 hashes_all_ms += hashes_dev_ms[device_id];
1206 }
1207 }
1208
1209 /**
1210 * exec time
1211 */
1212
1213 double exec_all_ms[DEVICES_MAX] = { 0 };
1214
1215 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1216 {
1217 hc_device_param_t *device_param = &data.devices_param[device_id];
1218
1219 if (device_param->skipped) continue;
1220
1221 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1222
1223 exec_all_ms[device_id] = exec_ms_avg;
1224 }
1225
1226 /**
1227 * timers
1228 */
1229
1230 float ms_running = 0;
1231
1232 hc_timer_get (data.timer_running, ms_running);
1233
1234 float ms_paused = data.ms_paused;
1235
1236 if (data.devices_status == STATUS_PAUSED)
1237 {
1238 float ms_paused_tmp = 0;
1239
1240 hc_timer_get (data.timer_paused, ms_paused_tmp);
1241
1242 ms_paused += ms_paused_tmp;
1243 }
1244
1245 #ifdef WIN
1246
1247 __time64_t sec_run = ms_running / 1000;
1248
1249 #else
1250
1251 time_t sec_run = ms_running / 1000;
1252
1253 #endif
1254
1255 if (sec_run)
1256 {
1257 char display_run[32] = { 0 };
1258
1259 struct tm tm_run;
1260
1261 struct tm *tmp = NULL;
1262
1263 #ifdef WIN
1264
1265 tmp = _gmtime64 (&sec_run);
1266
1267 #else
1268
1269 tmp = gmtime (&sec_run);
1270
1271 #endif
1272
1273 if (tmp != NULL)
1274 {
1275 memset (&tm_run, 0, sizeof (tm_run));
1276
1277 memcpy (&tm_run, tmp, sizeof (tm_run));
1278
1279 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1280
1281 char *start = ctime (&data.proc_start);
1282
1283 size_t start_len = strlen (start);
1284
1285 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1286 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1287
1288 log_info ("Time.Started...: %s (%s)", start, display_run);
1289 }
1290 }
1291 else
1292 {
1293 log_info ("Time.Started...: 0 secs");
1294 }
1295
1296 /**
1297 * counters
1298 */
1299
1300 uint salts_left = data.salts_cnt - data.salts_done;
1301
1302 if (salts_left == 0) salts_left = 1;
1303
1304 u64 progress_total = data.words_cnt * salts_left;
1305
1306 u64 all_done = 0;
1307 u64 all_rejected = 0;
1308 u64 all_restored = 0;
1309
1310 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1311 {
1312 if (salts_left > 1)
1313 {
1314 // otherwise the final cracked status shows 0/XXX progress
1315
1316 if (data.salts_shown[salt_pos] == 1) continue;
1317 }
1318
1319 all_done += data.words_progress_done[salt_pos];
1320 all_rejected += data.words_progress_rejected[salt_pos];
1321 all_restored += data.words_progress_restored[salt_pos];
1322 }
1323
1324 u64 progress_cur = all_restored + all_done + all_rejected;
1325 u64 progress_end = progress_total;
1326
1327 u64 progress_skip = 0;
1328
1329 if (data.skip)
1330 {
1331 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1336 }
1337
1338 if (data.limit)
1339 {
1340 progress_end = MIN (data.limit, data.words_base) * salts_left;
1341
1342 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1343 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1344 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1345 }
1346
1347 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1348 u64 progress_end_relative_skip = progress_end - progress_skip;
1349
1350 float speed_ms_real = ms_running - ms_paused;
1351 u64 speed_plains_real = all_done;
1352
1353 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1354 {
1355 if (data.devices_status != STATUS_CRACKED)
1356 {
1357 u64 words_per_ms = 0;
1358
1359 if (speed_plains_real && speed_ms_real)
1360 {
1361 words_per_ms = speed_plains_real / speed_ms_real;
1362 }
1363
1364 #ifdef WIN
1365 __time64_t sec_etc = 0;
1366 #else
1367 time_t sec_etc = 0;
1368 #endif
1369
1370 if (words_per_ms)
1371 {
1372 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1373
1374 u64 ms_left = progress_left_relative_skip / words_per_ms;
1375
1376 sec_etc = ms_left / 1000;
1377 }
1378
1379 if (sec_etc == 0)
1380 {
1381 log_info ("Time.Estimated.: 0 secs");
1382 }
1383 else if ((u64) sec_etc > ETC_MAX)
1384 {
1385 log_info ("Time.Estimated.: > 10 Years");
1386 }
1387 else
1388 {
1389 char display_etc[32] = { 0 };
1390
1391 struct tm tm_etc;
1392
1393 struct tm *tmp = NULL;
1394
1395 #ifdef WIN
1396
1397 tmp = _gmtime64 (&sec_etc);
1398
1399 #else
1400
1401 tmp = gmtime (&sec_etc);
1402
1403 #endif
1404
1405 if (tmp != NULL)
1406 {
1407 memset (&tm_etc, 0, sizeof (tm_etc));
1408
1409 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1410
1411 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1412
1413 time_t now;
1414
1415 time (&now);
1416
1417 now += sec_etc;
1418
1419 char *etc = ctime (&now);
1420
1421 size_t etc_len = strlen (etc);
1422
1423 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1424 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1425
1426 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1427 }
1428 }
1429 }
1430 }
1431
1432 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1433 {
1434 hc_device_param_t *device_param = &data.devices_param[device_id];
1435
1436 if (device_param->skipped) continue;
1437
1438 char display_dev_cur[16] = { 0 };
1439
1440 strncpy (display_dev_cur, "0.00", 4);
1441
1442 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1443
1444 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1445 }
1446
1447 char display_all_cur[16] = { 0 };
1448
1449 strncpy (display_all_cur, "0.00", 4);
1450
1451 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1452
1453 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1454
1455 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1456 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1457
1458 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);
1459
1460 // crack-per-time
1461
1462 if (data.digests_cnt > 100)
1463 {
1464 time_t now = time (NULL);
1465
1466 int cpt_cur_min = 0;
1467 int cpt_cur_hour = 0;
1468 int cpt_cur_day = 0;
1469
1470 for (int i = 0; i < CPT_BUF; i++)
1471 {
1472 const uint cracked = data.cpt_buf[i].cracked;
1473 const time_t timestamp = data.cpt_buf[i].timestamp;
1474
1475 if ((timestamp + 60) > now)
1476 {
1477 cpt_cur_min += cracked;
1478 }
1479
1480 if ((timestamp + 3600) > now)
1481 {
1482 cpt_cur_hour += cracked;
1483 }
1484
1485 if ((timestamp + 86400) > now)
1486 {
1487 cpt_cur_day += cracked;
1488 }
1489 }
1490
1491 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1492 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1493 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1494
1495 if ((data.cpt_start + 86400) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_cur_day,
1501 cpt_avg_min,
1502 cpt_avg_hour,
1503 cpt_avg_day);
1504 }
1505 else if ((data.cpt_start + 3600) < now)
1506 {
1507 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1508 cpt_cur_min,
1509 cpt_cur_hour,
1510 cpt_avg_min,
1511 cpt_avg_hour,
1512 cpt_avg_day);
1513 }
1514 else if ((data.cpt_start + 60) < now)
1515 {
1516 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1517 cpt_cur_min,
1518 cpt_avg_min,
1519 cpt_avg_hour,
1520 cpt_avg_day);
1521 }
1522 else
1523 {
1524 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1525 cpt_avg_min,
1526 cpt_avg_hour,
1527 cpt_avg_day);
1528 }
1529 }
1530
1531 // Restore point
1532
1533 u64 restore_point = get_lowest_words_done ();
1534
1535 u64 restore_total = data.words_base;
1536
1537 float percent_restore = 0;
1538
1539 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1540
1541 if (progress_end_relative_skip)
1542 {
1543 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1544 {
1545 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1546 float percent_rejected = 0.0;
1547
1548 if (progress_cur)
1549 {
1550 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1551 }
1552
1553 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);
1554 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1555
1556 if (data.restore_disable == 0)
1557 {
1558 if (percent_finished != 1)
1559 {
1560 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1561 }
1562 }
1563 }
1564 }
1565 else
1566 {
1567 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1568 {
1569 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1570 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571
1572 if (data.restore_disable == 0)
1573 {
1574 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1575 }
1576 }
1577 else
1578 {
1579 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1580 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1581
1582 // --restore not allowed if stdin is used -- really? why?
1583
1584 //if (data.restore_disable == 0)
1585 //{
1586 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1587 //}
1588 }
1589 }
1590
1591 #ifdef HAVE_HWMON
1592 if (data.gpu_temp_disable == 0)
1593 {
1594 hc_thread_mutex_lock (mux_adl);
1595
1596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597 {
1598 hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600 if (device_param->skipped) continue;
1601
1602 #define HM_STR_BUF_SIZE 255
1603
1604 if (data.hm_device[device_id].fan_supported == 1)
1605 {
1606 char utilization[HM_STR_BUF_SIZE] = { 0 };
1607 char temperature[HM_STR_BUF_SIZE] = { 0 };
1608 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1609
1610 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1611 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1612
1613 if (device_param->vendor_id == VENDOR_ID_AMD)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617 else if (device_param->vendor_id == VENDOR_ID_NV)
1618 {
1619 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1620 }
1621
1622 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1623 }
1624 else
1625 {
1626 char utilization[HM_STR_BUF_SIZE] = { 0 };
1627 char temperature[HM_STR_BUF_SIZE] = { 0 };
1628
1629 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1630 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1631
1632 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1633 }
1634 }
1635
1636 hc_thread_mutex_unlock (mux_adl);
1637 }
1638 #endif // HAVE_HWMON
1639 }
1640
1641 static void status_benchmark ()
1642 {
1643 if (data.devices_status == STATUS_INIT) return;
1644 if (data.devices_status == STATUS_STARTING) return;
1645
1646 if (data.words_cnt == 0) return;
1647
1648 u64 speed_cnt[DEVICES_MAX] = { 0 };
1649 float speed_ms[DEVICES_MAX] = { 0 };
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 speed_cnt[device_id] = 0;
1658 speed_ms[device_id] = 0;
1659
1660 for (int i = 0; i < SPEED_CACHE; i++)
1661 {
1662 speed_cnt[device_id] += device_param->speed_cnt[i];
1663 speed_ms[device_id] += device_param->speed_ms[i];
1664 }
1665
1666 speed_cnt[device_id] /= SPEED_CACHE;
1667 speed_ms[device_id] /= SPEED_CACHE;
1668 }
1669
1670 float hashes_all_ms = 0;
1671
1672 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1673
1674 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1675 {
1676 hc_device_param_t *device_param = &data.devices_param[device_id];
1677
1678 if (device_param->skipped) continue;
1679
1680 hashes_dev_ms[device_id] = 0;
1681
1682 if (speed_ms[device_id])
1683 {
1684 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1685
1686 hashes_all_ms += hashes_dev_ms[device_id];
1687 }
1688 }
1689
1690 /**
1691 * exec time
1692 */
1693
1694 double exec_all_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1703
1704 exec_all_ms[device_id] = exec_ms_avg;
1705 }
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 char display_dev_cur[16] = { 0 };
1714
1715 strncpy (display_dev_cur, "0.00", 4);
1716
1717 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1718
1719 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1720 }
1721
1722 char display_all_cur[16] = { 0 };
1723
1724 strncpy (display_all_cur, "0.00", 4);
1725
1726 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1727
1728 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1729 }
1730
1731 /**
1732 * oclHashcat -only- functions
1733 */
1734
1735 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1736 {
1737 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1738 {
1739 if (attack_kern == ATTACK_KERN_STRAIGHT)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_COMBI)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1743 else if (attack_kern == ATTACK_KERN_BF)
1744 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1745 }
1746 else
1747 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1748 }
1749
1750 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)
1751 {
1752 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1753 {
1754 if (attack_kern == ATTACK_KERN_STRAIGHT)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_COMBI)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 else if (attack_kern == ATTACK_KERN_BF)
1759 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 else
1762 {
1763 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1764 }
1765 }
1766
1767 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1768 {
1769 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1772 }
1773 else
1774 {
1775 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1776 }
1777 }
1778
1779 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)
1780 {
1781 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 else
1786 {
1787 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1788 }
1789 }
1790
1791 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1792 {
1793 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1794 }
1795
1796 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1799 }
1800
1801 static uint convert_from_hex (char *line_buf, const uint line_len)
1802 {
1803 if (line_len & 1) return (line_len); // not in hex
1804
1805 if (data.hex_wordlist == 1)
1806 {
1807 uint i;
1808 uint j;
1809
1810 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1811 {
1812 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1813 }
1814
1815 memset (line_buf + i, 0, line_len - i);
1816
1817 return (i);
1818 }
1819 else if (line_len >= 6) // $HEX[] = 6
1820 {
1821 if (line_buf[0] != '$') return (line_len);
1822 if (line_buf[1] != 'H') return (line_len);
1823 if (line_buf[2] != 'E') return (line_len);
1824 if (line_buf[3] != 'X') return (line_len);
1825 if (line_buf[4] != '[') return (line_len);
1826 if (line_buf[line_len - 1] != ']') return (line_len);
1827
1828 uint i;
1829 uint j;
1830
1831 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1832 {
1833 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1834 }
1835
1836 memset (line_buf + i, 0, line_len - i);
1837
1838 return (i);
1839 }
1840
1841 return (line_len);
1842 }
1843
1844 static void clear_prompt ()
1845 {
1846 fputc ('\r', stdout);
1847
1848 for (size_t i = 0; i < strlen (PROMPT); i++)
1849 {
1850 fputc (' ', stdout);
1851 }
1852
1853 fputc ('\r', stdout);
1854
1855 fflush (stdout);
1856 }
1857
1858 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1859 {
1860 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);
1861 }
1862
1863 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1864 {
1865 char *outfile = data.outfile;
1866 uint quiet = data.quiet;
1867 FILE *pot_fp = data.pot_fp;
1868 uint loopback = data.loopback;
1869 uint debug_mode = data.debug_mode;
1870 char *debug_file = data.debug_file;
1871
1872 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1873 int debug_rule_len = 0; // -1 error
1874 uint debug_plain_len = 0;
1875
1876 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1877
1878 // hash
1879
1880 char out_buf[4096] = { 0 };
1881
1882 ascii_digest (out_buf, salt_pos, digest_pos);
1883
1884 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1885
1886 // plain
1887
1888 plain_t plain;
1889
1890 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);
1891
1892 uint gidvid = plain.gidvid;
1893 uint il_pos = plain.il_pos;
1894
1895 u64 crackpos = device_param->words_off;
1896
1897 uint plain_buf[16] = { 0 };
1898
1899 u8 *plain_ptr = (u8 *) plain_buf;
1900 unsigned int plain_len = 0;
1901
1902 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1903 {
1904 u64 gidd = gidvid;
1905 u64 gidm = 0;
1906
1907 pw_t pw;
1908
1909 gidd_to_pw_t (device_param, gidd, &pw);
1910
1911 for (int i = 0, j = gidm; i < 16; i++, j++)
1912 {
1913 plain_buf[i] = pw.i[j];
1914 }
1915
1916 plain_len = pw.pw_len;
1917
1918 const uint off = device_param->innerloop_pos + il_pos;
1919
1920 if (debug_mode > 0)
1921 {
1922 debug_rule_len = 0;
1923
1924 // save rule
1925 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1928
1929 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1930 }
1931
1932 // save plain
1933 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1934 {
1935 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1936
1937 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1938
1939 debug_plain_len = plain_len;
1940 }
1941 }
1942
1943 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1944
1945 crackpos += gidvid;
1946 crackpos *= data.kernel_rules_cnt;
1947 crackpos += device_param->innerloop_pos + il_pos;
1948
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 else if (data.attack_mode == ATTACK_MODE_COMBI)
1952 {
1953 u64 gidd = gidvid;
1954 u64 gidm = 0;
1955
1956 pw_t pw;
1957
1958 gidd_to_pw_t (device_param, gidd, &pw);
1959
1960 for (int i = 0, j = gidm; i < 16; i++, j++)
1961 {
1962 plain_buf[i] = pw.i[j];
1963 }
1964
1965 plain_len = pw.pw_len;
1966
1967 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1968 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1969
1970 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1971 {
1972 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1973 }
1974 else
1975 {
1976 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1977
1978 memcpy (plain_ptr, comb_buf, comb_len);
1979 }
1980
1981 plain_len += comb_len;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992 else if (data.attack_mode == ATTACK_MODE_BF)
1993 {
1994 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1995 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1996
1997 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1998 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1999
2000 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2001 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2002
2003 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2004 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2005
2006 plain_len = data.css_cnt;
2007
2008 crackpos += gidvid;
2009 crackpos *= data.bfs_cnt;
2010 crackpos += device_param->innerloop_pos + il_pos;
2011 }
2012 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2013 {
2014 u64 gidd = gidvid;
2015 u64 gidm = 0;
2016
2017 pw_t pw;
2018
2019 gidd_to_pw_t (device_param, gidd, &pw);
2020
2021 for (int i = 0, j = gidm; i < 16; i++, j++)
2022 {
2023 plain_buf[i] = pw.i[j];
2024 }
2025
2026 plain_len = pw.pw_len;
2027
2028 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2029
2030 uint start = 0;
2031 uint stop = device_param->kernel_params_mp_buf32[4];
2032
2033 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2034
2035 plain_len += start + stop;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2047 {
2048 u64 gidd = gidvid;
2049 u64 gidm = 0;
2050
2051 pw_t pw;
2052
2053 gidd_to_pw_t (device_param, gidd, &pw);
2054
2055 for (int i = 0, j = gidm; i < 16; i++, j++)
2056 {
2057 plain_buf[i] = pw.i[j];
2058 }
2059
2060 plain_len = pw.pw_len;
2061
2062 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2063
2064 uint start = 0;
2065 uint stop = device_param->kernel_params_mp_buf32[4];
2066
2067 memmove (plain_ptr + stop, plain_ptr, plain_len);
2068
2069 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2070
2071 plain_len += start + stop;
2072
2073 crackpos += gidvid;
2074 crackpos *= data.combs_cnt;
2075 crackpos += device_param->innerloop_pos + il_pos;
2076
2077 if (data.pw_max != PW_DICTMAX1)
2078 {
2079 if (plain_len > data.pw_max) plain_len = data.pw_max;
2080 }
2081 }
2082
2083 if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2086 {
2087 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2088 {
2089 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2090 {
2091 plain_len = plain_len - data.salts_buf[0].salt_len;
2092 }
2093 }
2094
2095 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2096 {
2097 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2098 {
2099 plain_ptr[j] = plain_ptr[i];
2100 }
2101
2102 plain_len = plain_len / 2;
2103 }
2104 }
2105 }
2106
2107 // if enabled, update also the potfile
2108
2109 if (pot_fp)
2110 {
2111 lock_file (pot_fp);
2112
2113 fprintf (pot_fp, "%s:", out_buf);
2114
2115 format_plain (pot_fp, plain_ptr, plain_len, 1);
2116
2117 fputc ('\n', pot_fp);
2118
2119 fflush (pot_fp);
2120
2121 unlock_file (pot_fp);
2122 }
2123
2124 // outfile
2125
2126 FILE *out_fp = NULL;
2127
2128 if (outfile != NULL)
2129 {
2130 if ((out_fp = fopen (outfile, "ab")) == NULL)
2131 {
2132 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2133
2134 out_fp = stdout;
2135 }
2136 lock_file (out_fp);
2137 }
2138 else
2139 {
2140 out_fp = stdout;
2141
2142 if (quiet == 0) clear_prompt ();
2143 }
2144
2145 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2146
2147 if (outfile != NULL)
2148 {
2149 if (out_fp != stdout)
2150 {
2151 fclose (out_fp);
2152 }
2153 }
2154 else
2155 {
2156 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2157 {
2158 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2159 {
2160 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2161 if (quiet == 0) fflush (stdout);
2162 }
2163 }
2164 }
2165
2166 // loopback
2167
2168 if (loopback)
2169 {
2170 char *loopback_file = data.loopback_file;
2171
2172 FILE *fb_fp = NULL;
2173
2174 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2175 {
2176 lock_file (fb_fp);
2177
2178 format_plain (fb_fp, plain_ptr, plain_len, 1);
2179
2180 fputc ('\n', fb_fp);
2181
2182 fclose (fb_fp);
2183 }
2184 }
2185
2186 // (rule) debug mode
2187
2188 // the next check implies that:
2189 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2190 // - debug_mode > 0
2191
2192 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2193 {
2194 if (debug_rule_len < 0) debug_rule_len = 0;
2195
2196 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2197
2198 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2199
2200 if ((quiet == 0) && (debug_file == NULL))
2201 {
2202 fprintf (stdout, "%s", PROMPT);
2203 fflush (stdout);
2204 }
2205 }
2206 }
2207
2208 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2209 {
2210 salt_t *salt_buf = &data.salts_buf[salt_pos];
2211
2212 int found = 0;
2213
2214 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);
2215
2216 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2217
2218 if (found == 1)
2219 {
2220 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2221
2222 log_info_nn ("");
2223
2224 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);
2225
2226 uint cpt_cracked = 0;
2227
2228 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2229 {
2230 uint idx = salt_buf->digests_offset + digest_pos;
2231
2232 if (data.digests_shown_tmp[idx] == 0) continue;
2233
2234 if (data.digests_shown[idx] == 1) continue;
2235
2236 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2237 {
2238 data.digests_shown[idx] = 1;
2239
2240 data.digests_done++;
2241
2242 cpt_cracked++;
2243
2244 salt_buf->digests_done++;
2245
2246 if (salt_buf->digests_done == salt_buf->digests_cnt)
2247 {
2248 data.salts_shown[salt_pos] = 1;
2249
2250 data.salts_done++;
2251 }
2252 }
2253
2254 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2255
2256 check_hash (device_param, salt_pos, digest_pos);
2257 }
2258
2259 if (cpt_cracked > 0)
2260 {
2261 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2262 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2263
2264 data.cpt_pos++;
2265
2266 data.cpt_total += cpt_cracked;
2267
2268 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2269 }
2270
2271 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2272 {
2273 // we need to reset cracked state on the device
2274 // otherwise host thinks again and again the hash was cracked
2275 // and returns invalid password each time
2276
2277 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2278
2279 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);
2280 }
2281
2282 memset (device_param->result, 0, device_param->size_results);
2283
2284 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);
2285 }
2286 }
2287
2288 static void save_hash ()
2289 {
2290 char *hashfile = data.hashfile;
2291
2292 char new_hashfile[256] = { 0 };
2293 char old_hashfile[256] = { 0 };
2294
2295 snprintf (new_hashfile, 255, "%s.new", hashfile);
2296 snprintf (old_hashfile, 255, "%s.old", hashfile);
2297
2298 unlink (new_hashfile);
2299
2300 char separator = data.separator;
2301
2302 FILE *fp = fopen (new_hashfile, "wb");
2303
2304 if (fp == NULL)
2305 {
2306 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2307
2308 exit (-1);
2309 }
2310
2311 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2312 {
2313 if (data.salts_shown[salt_pos] == 1) continue;
2314
2315 salt_t *salt_buf = &data.salts_buf[salt_pos];
2316
2317 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2318 {
2319 uint idx = salt_buf->digests_offset + digest_pos;
2320
2321 if (data.digests_shown[idx] == 1) continue;
2322
2323 if (data.hash_mode != 2500)
2324 {
2325 char out_buf[4096] = { 0 };
2326
2327 if (data.username == 1)
2328 {
2329 user_t *user = data.hash_info[idx]->user;
2330
2331 uint i;
2332
2333 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2334
2335 fputc (separator, fp);
2336 }
2337
2338 ascii_digest (out_buf, salt_pos, digest_pos);
2339
2340 fputs (out_buf, fp);
2341
2342 log_out (fp, "");
2343 }
2344 else
2345 {
2346 hccap_t hccap;
2347
2348 to_hccap_t (&hccap, salt_pos, digest_pos);
2349
2350 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2351 }
2352 }
2353 }
2354
2355 fflush (fp);
2356
2357 fclose (fp);
2358
2359 unlink (old_hashfile);
2360
2361 if (rename (hashfile, old_hashfile) != 0)
2362 {
2363 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2364
2365 exit (-1);
2366 }
2367
2368 unlink (hashfile);
2369
2370 if (rename (new_hashfile, hashfile) != 0)
2371 {
2372 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2373
2374 exit (-1);
2375 }
2376
2377 unlink (old_hashfile);
2378 }
2379
2380 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2381 {
2382 // function called only in case kernel_power_all > words_left
2383
2384 float kernel_power_div = (float) (total_left) / kernel_power_all;
2385
2386 kernel_power_div += kernel_power_div / 100;
2387
2388 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2389
2390 while (kernel_power_new < total_left)
2391 {
2392 kernel_power_div += kernel_power_div / 100;
2393
2394 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2395 }
2396
2397 if (data.quiet == 0)
2398 {
2399 clear_prompt ();
2400
2401 log_info ("");
2402
2403 log_info ("INFO: approaching final keyspace, workload adjusted");
2404
2405 log_info ("");
2406
2407 fprintf (stdout, "%s", PROMPT);
2408
2409 fflush (stdout);
2410 }
2411
2412 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2413
2414 return kernel_power_div;
2415 }
2416
2417 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2418 {
2419 uint num_elements = num;
2420
2421 device_param->kernel_params_buf32[30] = data.combs_mode;
2422 device_param->kernel_params_buf32[31] = num;
2423
2424 uint kernel_threads = device_param->kernel_threads;
2425
2426 while (num_elements % kernel_threads) num_elements++;
2427
2428 cl_kernel kernel = NULL;
2429
2430 switch (kern_run)
2431 {
2432 case KERN_RUN_1: kernel = device_param->kernel1; break;
2433 case KERN_RUN_12: kernel = device_param->kernel12; break;
2434 case KERN_RUN_2: kernel = device_param->kernel2; break;
2435 case KERN_RUN_23: kernel = device_param->kernel23; break;
2436 case KERN_RUN_3: kernel = device_param->kernel3; break;
2437 }
2438
2439 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2440 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2441 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2442 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2443 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2444 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2445 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2446 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2447 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2448 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2449 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2450
2451 hc_timer_t timer;
2452
2453 hc_timer_set (&timer);
2454
2455 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2456 {
2457 const size_t global_work_size[3] = { num_elements, 32, 1 };
2458 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2459
2460 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2461 }
2462 else
2463 {
2464 size_t workgroup_size = 0;
2465
2466 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2467
2468 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2469
2470 const size_t global_work_size[3] = { num_elements, 1, 1 };
2471 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2472
2473 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2474 }
2475
2476 hc_clFlush (data.ocl, device_param->command_queue);
2477
2478 hc_clFinish (data.ocl, device_param->command_queue);
2479
2480 if (event_update)
2481 {
2482 float exec_time;
2483
2484 hc_timer_get (timer, exec_time);
2485
2486 uint exec_pos = device_param->exec_pos;
2487
2488 device_param->exec_ms[exec_pos] = exec_time;
2489
2490 exec_pos++;
2491
2492 if (exec_pos == EXEC_CACHE)
2493 {
2494 exec_pos = 0;
2495 }
2496
2497 device_param->exec_pos = exec_pos;
2498 }
2499 }
2500
2501 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2502 {
2503 uint num_elements = num;
2504
2505 switch (kern_run)
2506 {
2507 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2508 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2509 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2510 }
2511
2512 // causes problems with special threads like in bcrypt
2513 // const uint kernel_threads = device_param->kernel_threads;
2514
2515 uint kernel_threads = KERNEL_THREADS;
2516
2517 while (num_elements % kernel_threads) num_elements++;
2518
2519 cl_kernel kernel = NULL;
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2524 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2525 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2526 }
2527
2528 switch (kern_run)
2529 {
2530 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2536 break;
2537 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2543 break;
2544 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2545 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2546 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2547 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2548 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2549 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2550 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2551 break;
2552 }
2553
2554 size_t workgroup_size = 0;
2555 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2556 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2557
2558 const size_t global_work_size[3] = { num_elements, 1, 1 };
2559 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2562
2563 hc_clFlush (data.ocl, device_param->command_queue);
2564
2565 hc_clFinish (data.ocl, device_param->command_queue);
2566 }
2567
2568 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2569 {
2570 uint num_elements = num;
2571
2572 uint kernel_threads = device_param->kernel_threads;
2573
2574 while (num_elements % kernel_threads) num_elements++;
2575
2576 cl_kernel kernel = device_param->kernel_tb;
2577
2578 size_t workgroup_size = 0;
2579 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2580 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2581
2582 const size_t global_work_size[3] = { num_elements, 1, 1 };
2583 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2584
2585 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2586
2587 hc_clFlush (data.ocl, device_param->command_queue);
2588
2589 hc_clFinish (data.ocl, device_param->command_queue);
2590 }
2591
2592 static void run_kernel_tm (hc_device_param_t *device_param)
2593 {
2594 const uint num_elements = 1024; // fixed
2595
2596 uint kernel_threads = 32;
2597
2598 cl_kernel kernel = device_param->kernel_tm;
2599
2600 size_t workgroup_size = 0;
2601 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2602 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2603
2604 const size_t global_work_size[3] = { num_elements, 1, 1 };
2605 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2606
2607 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2608
2609 hc_clFlush (data.ocl, device_param->command_queue);
2610
2611 hc_clFinish (data.ocl, device_param->command_queue);
2612 }
2613
2614 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2615 {
2616 uint num_elements = num;
2617
2618 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2619 device_param->kernel_params_amp_buf32[6] = num_elements;
2620
2621 // causes problems with special threads like in bcrypt
2622 // const uint kernel_threads = device_param->kernel_threads;
2623
2624 uint kernel_threads = KERNEL_THREADS;
2625
2626 while (num_elements % kernel_threads) num_elements++;
2627
2628 cl_kernel kernel = device_param->kernel_amp;
2629
2630 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2631 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2632
2633 size_t workgroup_size = 0;
2634 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2635 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2636
2637 const size_t global_work_size[3] = { num_elements, 1, 1 };
2638 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2639
2640 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2641
2642 hc_clFlush (data.ocl, device_param->command_queue);
2643
2644 hc_clFinish (data.ocl, device_param->command_queue);
2645 }
2646
2647 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2648 {
2649 int rc = -1;
2650
2651 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2652 {
2653 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2654
2655 const cl_uchar zero = 0;
2656
2657 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2658 }
2659
2660 if (rc != 0)
2661 {
2662 // NOTE: clEnqueueFillBuffer () always fails with -59
2663 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2664 // How's that possible, OpenCL 1.2 support is advertised??
2665 // We need to workaround...
2666
2667 #define FILLSZ 0x100000
2668
2669 char *tmp = (char *) mymalloc (FILLSZ);
2670
2671 for (uint i = 0; i < size; i += FILLSZ)
2672 {
2673 const int left = size - i;
2674
2675 const int fillsz = MIN (FILLSZ, left);
2676
2677 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2678 }
2679
2680 myfree (tmp);
2681 }
2682 }
2683
2684 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)
2685 {
2686 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2687 {
2688 if (attack_mode == ATTACK_MODE_BF)
2689 {
2690 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2691 {
2692 const uint size_tm = 32 * sizeof (bs_word_t);
2693
2694 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2695
2696 run_kernel_tm (device_param);
2697
2698 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);
2699 }
2700 }
2701
2702 if (highest_pw_len < 16)
2703 {
2704 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2705 }
2706 else if (highest_pw_len < 32)
2707 {
2708 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2709 }
2710 else
2711 {
2712 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2713 }
2714 }
2715 else
2716 {
2717 run_kernel_amp (device_param, pws_cnt);
2718
2719 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2720
2721 if (opts_type & OPTS_TYPE_HOOK12)
2722 {
2723 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2724 }
2725
2726 uint iter = salt_buf->salt_iter;
2727
2728 uint loop_step = device_param->kernel_loops;
2729
2730 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2731 {
2732 uint loop_left = iter - loop_pos;
2733
2734 loop_left = MIN (loop_left, loop_step);
2735
2736 device_param->kernel_params_buf32[25] = loop_pos;
2737 device_param->kernel_params_buf32[26] = loop_left;
2738
2739 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2740
2741 if (data.devices_status == STATUS_CRACKED) break;
2742 if (data.devices_status == STATUS_ABORTED) break;
2743 if (data.devices_status == STATUS_QUIT) break;
2744 }
2745
2746 if (opts_type & OPTS_TYPE_HOOK23)
2747 {
2748 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2749
2750 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);
2751
2752 // do something with data
2753
2754 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);
2755 }
2756
2757 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2758 }
2759 }
2760
2761 static int run_rule_engine (const int rule_len, const char *rule_buf)
2762 {
2763 if (rule_len == 0)
2764 {
2765 return 0;
2766 }
2767 else if (rule_len == 1)
2768 {
2769 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2770 }
2771
2772 return 1;
2773 }
2774
2775 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2776 {
2777 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2778 {
2779 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);
2780 }
2781 else if (data.attack_kern == ATTACK_KERN_COMBI)
2782 {
2783 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2784 {
2785 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2786 {
2787 for (u32 i = 0; i < pws_cnt; i++)
2788 {
2789 const u32 pw_len = device_param->pws_buf[i].pw_len;
2790
2791 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2792
2793 ptr[pw_len] = 0x01;
2794 }
2795 }
2796 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2797 {
2798 for (u32 i = 0; i < pws_cnt; i++)
2799 {
2800 const u32 pw_len = device_param->pws_buf[i].pw_len;
2801
2802 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2803
2804 ptr[pw_len] = 0x80;
2805 }
2806 }
2807 }
2808
2809 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);
2810 }
2811 else if (data.attack_kern == ATTACK_KERN_BF)
2812 {
2813 const u64 off = device_param->words_off;
2814
2815 device_param->kernel_params_mp_l_buf64[3] = off;
2816
2817 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2818 }
2819 }
2820
2821 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2822 {
2823 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2824
2825 device_param->kernel_params_buf32[26] = kernel_loops;
2826 device_param->kernel_params_buf32[27] = kernel_loops;
2827
2828 // init some fake words
2829
2830 for (u32 i = 0; i < kernel_power; i++)
2831 {
2832 device_param->pws_buf[i].i[0] = i;
2833 device_param->pws_buf[i].i[1] = 0x01234567;
2834 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2835 }
2836
2837 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);
2838
2839 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2840 {
2841 run_kernel_amp (device_param, kernel_power);
2842 }
2843
2844 // caching run
2845
2846 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2847 {
2848 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2849 }
2850 else
2851 {
2852 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2853 }
2854
2855 // now user repeats
2856
2857 for (int i = 0; i < repeat; i++)
2858 {
2859 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2860 {
2861 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2862 }
2863 else
2864 {
2865 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2866 }
2867 }
2868
2869 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2870
2871 // reset fake words
2872
2873 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2874
2875 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);
2876 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);
2877
2878 return exec_ms_prev;
2879 }
2880
2881 static void autotune (hc_device_param_t *device_param)
2882 {
2883 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2884
2885 const u32 kernel_accel_min = device_param->kernel_accel_min;
2886 const u32 kernel_accel_max = device_param->kernel_accel_max;
2887
2888 const u32 kernel_loops_min = device_param->kernel_loops_min;
2889 const u32 kernel_loops_max = device_param->kernel_loops_max;
2890
2891 u32 kernel_accel = kernel_accel_min;
2892 u32 kernel_loops = kernel_loops_min;
2893
2894 // steps
2895
2896 #define STEPS_CNT 10
2897
2898 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2899 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2900
2901 u32 steps_accel[STEPS_ACCEL_CNT];
2902 u32 steps_loops[STEPS_LOOPS_CNT];
2903
2904 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2905 {
2906 steps_accel[i] = 1 << i;
2907 }
2908
2909 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2910 {
2911 steps_loops[i] = 1 << i;
2912 }
2913
2914 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2915 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2916
2917 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2918 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2919
2920 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2921 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2922
2923 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2924
2925 u32 kernel_loops_tmp;
2926
2927 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2928 {
2929 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2930
2931 if (exec_ms < target_ms) break;
2932 }
2933
2934 // kernel-accel
2935
2936 if (kernel_accel_min < kernel_accel_max)
2937 {
2938 double e_best = 0;
2939
2940 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2941 {
2942 const u32 kernel_accel_try = steps_accel[i];
2943
2944 if (kernel_accel_try < kernel_accel_min) continue;
2945 if (kernel_accel_try > kernel_accel_max) break;
2946
2947 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2948
2949 if (exec_ms > target_ms) break;
2950
2951 const double e = kernel_accel_try / exec_ms;
2952
2953 if (e > e_best)
2954 {
2955 kernel_accel = kernel_accel_try;
2956
2957 e_best = e;
2958 }
2959 }
2960 }
2961
2962 // kernel-loops final
2963
2964 if (kernel_loops_min < kernel_loops_max)
2965 {
2966 double e_best = 0;
2967
2968 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2969 {
2970 const u32 kernel_loops_try = steps_loops[i];
2971
2972 if (kernel_loops_try < kernel_loops_min) continue;
2973 if (kernel_loops_try > kernel_loops_max) break;
2974
2975 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2976
2977 if (exec_ms > target_ms) break;
2978
2979 const double e = kernel_loops_try / exec_ms;
2980
2981 if (e > e_best)
2982 {
2983 kernel_loops = kernel_loops_try;
2984
2985 e_best = e;
2986 }
2987 }
2988 }
2989
2990 // final balance
2991
2992 u32 kernel_accel_best = kernel_accel;
2993 u32 kernel_loops_best = kernel_loops;
2994
2995 u32 exec_best = -1;
2996
2997 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2998 {
2999 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
3000
3001 exec_best = exec_ms;
3002 }
3003
3004 // reset
3005
3006 if (kernel_accel_min < kernel_accel_max)
3007 {
3008 u32 kernel_accel_try = kernel_accel;
3009 u32 kernel_loops_try = kernel_loops;
3010
3011 for (int i = 0; i < 2; i++)
3012 {
3013 kernel_accel_try >>= 1;
3014 kernel_loops_try <<= 1;
3015
3016 if (kernel_accel_try < kernel_accel_min) break;
3017 if (kernel_loops_try > kernel_loops_max) break;
3018
3019 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3020
3021 if (exec_ms < exec_best)
3022 {
3023 kernel_accel_best = kernel_accel_try;
3024 kernel_loops_best = kernel_loops_try;
3025
3026 exec_best = exec_ms;
3027 }
3028 }
3029 }
3030
3031 // reset
3032
3033 if (kernel_loops_min < kernel_loops_max)
3034 {
3035 u32 kernel_accel_try = kernel_accel;
3036 u32 kernel_loops_try = kernel_loops;
3037
3038 for (int i = 0; i < 2; i++)
3039 {
3040 kernel_accel_try <<= 1;
3041 kernel_loops_try >>= 1;
3042
3043 if (kernel_accel_try > kernel_accel_max) break;
3044 if (kernel_loops_try < kernel_loops_min) break;
3045
3046 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3047
3048 if (exec_ms < exec_best)
3049 {
3050 kernel_accel_best = kernel_accel_try;
3051 kernel_loops_best = kernel_loops_try;
3052
3053 exec_best = exec_ms;
3054 }
3055 }
3056 }
3057
3058 // reset timer
3059
3060 device_param->exec_pos = 0;
3061
3062 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3063
3064 // store
3065
3066 kernel_accel = kernel_accel_best;
3067 kernel_loops = kernel_loops_best;
3068
3069 device_param->kernel_accel = kernel_accel;
3070 device_param->kernel_loops = kernel_loops;
3071
3072 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3073
3074 device_param->kernel_power = kernel_power;
3075
3076 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3077 if (data.quiet == 0) log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3078 if (data.quiet == 0) log_info ("");
3079 }
3080
3081 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3082 {
3083 // init speed timer
3084
3085 uint speed_pos = device_param->speed_pos;
3086
3087 #ifdef _POSIX
3088 if (device_param->timer_speed.tv_sec == 0)
3089 {
3090 hc_timer_set (&device_param->timer_speed);
3091 }
3092 #endif
3093
3094 #ifdef _WIN
3095 if (device_param->timer_speed.QuadPart == 0)
3096 {
3097 hc_timer_set (&device_param->timer_speed);
3098 }
3099 #endif
3100
3101 // find higest password length, this is for optimization stuff
3102
3103 uint highest_pw_len = 0;
3104
3105 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3106 {
3107 }
3108 else if (data.attack_kern == ATTACK_KERN_COMBI)
3109 {
3110 }
3111 else if (data.attack_kern == ATTACK_KERN_BF)
3112 {
3113 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3114 + device_param->kernel_params_mp_l_buf32[5];
3115 }
3116
3117 // bitslice optimization stuff
3118
3119 if (data.attack_mode == ATTACK_MODE_BF)
3120 {
3121 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3122 {
3123 run_kernel_tb (device_param, pws_cnt);
3124 }
3125 }
3126
3127 // iteration type
3128
3129 uint innerloop_step = 0;
3130 uint innerloop_cnt = 0;
3131
3132 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3133 else innerloop_step = 1;
3134
3135 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3136 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3137 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3138
3139 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3140
3141 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3142 {
3143 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3144
3145 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3146
3147 if (data.devices_status == STATUS_CRACKED) break;
3148 if (data.devices_status == STATUS_ABORTED) break;
3149 if (data.devices_status == STATUS_QUIT) break;
3150 if (data.devices_status == STATUS_BYPASS) break;
3151
3152 if (data.salts_shown[salt_pos] == 1) continue;
3153
3154 salt_t *salt_buf = &data.salts_buf[salt_pos];
3155
3156 device_param->kernel_params_buf32[24] = salt_pos;
3157 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3158 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3159
3160 FILE *combs_fp = device_param->combs_fp;
3161
3162 if (data.attack_mode == ATTACK_MODE_COMBI)
3163 {
3164 rewind (combs_fp);
3165 }
3166
3167 // innerloops
3168
3169 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3170 {
3171 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3172
3173 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3174
3175 if (data.devices_status == STATUS_CRACKED) break;
3176 if (data.devices_status == STATUS_ABORTED) break;
3177 if (data.devices_status == STATUS_QUIT) break;
3178 if (data.devices_status == STATUS_BYPASS) break;
3179
3180 uint innerloop_left = innerloop_cnt - innerloop_pos;
3181
3182 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3183
3184 device_param->innerloop_pos = innerloop_pos;
3185 device_param->innerloop_left = innerloop_left;
3186
3187 device_param->kernel_params_buf32[27] = innerloop_left;
3188
3189 // i think we can get rid of this
3190 if (innerloop_left == 0)
3191 {
3192 puts ("bug, how should this happen????\n");
3193
3194 continue;
3195 }
3196
3197 // initialize amplifiers
3198
3199 if (data.attack_mode == ATTACK_MODE_COMBI)
3200 {
3201 char line_buf[BUFSIZ] = { 0 };
3202
3203 uint i = 0;
3204
3205 while (i < innerloop_left)
3206 {
3207 if (feof (combs_fp)) break;
3208
3209 int line_len = fgetl (combs_fp, line_buf);
3210
3211 if (line_len >= PW_MAX1) continue;
3212
3213 line_len = convert_from_hex (line_buf, line_len);
3214
3215 char *line_buf_new = line_buf;
3216
3217 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3218 {
3219 char rule_buf_out[BLOCK_SIZE] = { 0 };
3220
3221 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3222
3223 if (rule_len_out < 0)
3224 {
3225 data.words_progress_rejected[salt_pos] += pws_cnt;
3226
3227 continue;
3228 }
3229
3230 line_len = rule_len_out;
3231
3232 line_buf_new = rule_buf_out;
3233 }
3234
3235 line_len = MIN (line_len, PW_DICTMAX);
3236
3237 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3238
3239 memcpy (ptr, line_buf_new, line_len);
3240
3241 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3242
3243 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3244 {
3245 uppercase (ptr, line_len);
3246 }
3247
3248 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3249 {
3250 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3251 {
3252 ptr[line_len] = 0x80;
3253 }
3254
3255 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3256 {
3257 ptr[line_len] = 0x01;
3258 }
3259 }
3260
3261 device_param->combs_buf[i].pw_len = line_len;
3262
3263 i++;
3264 }
3265
3266 for (uint j = i; j < innerloop_left; j++)
3267 {
3268 device_param->combs_buf[j].i[0] = 0;
3269 device_param->combs_buf[j].i[1] = 0;
3270 device_param->combs_buf[j].i[2] = 0;
3271 device_param->combs_buf[j].i[3] = 0;
3272 device_param->combs_buf[j].i[4] = 0;
3273 device_param->combs_buf[j].i[5] = 0;
3274 device_param->combs_buf[j].i[6] = 0;
3275 device_param->combs_buf[j].i[7] = 0;
3276
3277 device_param->combs_buf[j].pw_len = 0;
3278 }
3279
3280 innerloop_left = i;
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_BF)
3283 {
3284 u64 off = innerloop_pos;
3285
3286 device_param->kernel_params_mp_r_buf64[3] = off;
3287
3288 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3289 }
3290 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3291 {
3292 u64 off = innerloop_pos;
3293
3294 device_param->kernel_params_mp_buf64[3] = off;
3295
3296 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3297 }
3298 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3299 {
3300 u64 off = innerloop_pos;
3301
3302 device_param->kernel_params_mp_buf64[3] = off;
3303
3304 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3305 }
3306
3307 // copy amplifiers
3308
3309 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3310 {
3311 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);
3312 }
3313 else if (data.attack_mode == ATTACK_MODE_COMBI)
3314 {
3315 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);
3316 }
3317 else if (data.attack_mode == ATTACK_MODE_BF)
3318 {
3319 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);
3320 }
3321 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3322 {
3323 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);
3324 }
3325 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3326 {
3327 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);
3328 }
3329
3330 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3331
3332 if (data.benchmark == 1)
3333 {
3334 for (u32 i = 0; i < data.benchmark_repeats; i++)
3335 {
3336 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3337 }
3338 }
3339
3340 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3341
3342 if (data.devices_status == STATUS_CRACKED) break;
3343 if (data.devices_status == STATUS_ABORTED) break;
3344 if (data.devices_status == STATUS_QUIT) break;
3345
3346 /**
3347 * result
3348 */
3349
3350 hc_thread_mutex_lock (mux_display);
3351
3352 check_cracked (device_param, salt_pos);
3353
3354 hc_thread_mutex_unlock (mux_display);
3355
3356 /**
3357 * progress
3358 */
3359
3360 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3361
3362 if (data.benchmark == 1)
3363 {
3364 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3365 }
3366
3367 hc_thread_mutex_lock (mux_counter);
3368
3369 data.words_progress_done[salt_pos] += perf_sum_all;
3370
3371 hc_thread_mutex_unlock (mux_counter);
3372
3373 /**
3374 * speed
3375 */
3376
3377 float speed_ms;
3378
3379 hc_timer_get (device_param->timer_speed, speed_ms);
3380
3381 hc_timer_set (&device_param->timer_speed);
3382
3383 hc_thread_mutex_lock (mux_display);
3384
3385 device_param->speed_cnt[speed_pos] = perf_sum_all;
3386
3387 device_param->speed_ms[speed_pos] = speed_ms;
3388
3389 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3390
3391 hc_thread_mutex_unlock (mux_display);
3392
3393 speed_pos++;
3394
3395 if (speed_pos == SPEED_CACHE)
3396 {
3397 speed_pos = 0;
3398 }
3399
3400 /**
3401 * benchmark
3402 */
3403
3404 if (data.benchmark == 1) break;
3405 }
3406 }
3407
3408 device_param->speed_pos = speed_pos;
3409 }
3410
3411 static void load_segment (wl_data_t *wl_data, FILE *fd)
3412 {
3413 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3414
3415 wl_data->pos = 0;
3416
3417 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3418
3419 wl_data->buf[wl_data->cnt] = 0;
3420
3421 if (wl_data->cnt == 0) return;
3422
3423 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3424
3425 while (!feof (fd))
3426 {
3427 if (wl_data->cnt == wl_data->avail)
3428 {
3429 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3430
3431 wl_data->avail += wl_data->incr;
3432 }
3433
3434 const int c = fgetc (fd);
3435
3436 if (c == EOF) break;
3437
3438 wl_data->buf[wl_data->cnt] = (char) c;
3439
3440 wl_data->cnt++;
3441
3442 if (c == '\n') break;
3443 }
3444
3445 // ensure stream ends with a newline
3446
3447 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3448 {
3449 wl_data->cnt++;
3450
3451 wl_data->buf[wl_data->cnt - 1] = '\n';
3452 }
3453
3454 return;
3455 }
3456
3457 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3458 {
3459 char *ptr = buf;
3460
3461 for (u32 i = 0; i < sz; i++, ptr++)
3462 {
3463 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3464
3465 if (i == 7)
3466 {
3467 *off = i;
3468 *len = i;
3469
3470 return;
3471 }
3472
3473 if (*ptr != '\n') continue;
3474
3475 *off = i + 1;
3476
3477 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3478
3479 *len = i;
3480
3481 return;
3482 }
3483
3484 *off = sz;
3485 *len = sz;
3486 }
3487
3488 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3489 {
3490 char *ptr = buf;
3491
3492 for (u32 i = 0; i < sz; i++, ptr++)
3493 {
3494 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3495
3496 if (*ptr != '\n') continue;
3497
3498 *off = i + 1;
3499
3500 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3501
3502 *len = i;
3503
3504 return;
3505 }
3506
3507 *off = sz;
3508 *len = sz;
3509 }
3510
3511 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3512 {
3513 char *ptr = buf;
3514
3515 for (u32 i = 0; i < sz; i++, ptr++)
3516 {
3517 if (*ptr != '\n') continue;
3518
3519 *off = i + 1;
3520
3521 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3522
3523 *len = i;
3524
3525 return;
3526 }
3527
3528 *off = sz;
3529 *len = sz;
3530 }
3531
3532 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3533 {
3534 while (wl_data->pos < wl_data->cnt)
3535 {
3536 uint off;
3537 uint len;
3538
3539 char *ptr = wl_data->buf + wl_data->pos;
3540
3541 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3542
3543 wl_data->pos += off;
3544
3545 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3546 {
3547 char rule_buf_out[BLOCK_SIZE] = { 0 };
3548
3549 int rule_len_out = -1;
3550
3551 if (len < BLOCK_SIZE)
3552 {
3553 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3554 }
3555
3556 if (rule_len_out < 0)
3557 {
3558 continue;
3559 }
3560
3561 if (rule_len_out > PW_MAX)
3562 {
3563 continue;
3564 }
3565 }
3566 else
3567 {
3568 if (len > PW_MAX)
3569 {
3570 continue;
3571 }
3572 }
3573
3574 *out_buf = ptr;
3575 *out_len = len;
3576
3577 return;
3578 }
3579
3580 if (feof (fd))
3581 {
3582 fprintf (stderr, "BUG feof()!!\n");
3583
3584 return;
3585 }
3586
3587 load_segment (wl_data, fd);
3588
3589 get_next_word (wl_data, fd, out_buf, out_len);
3590 }
3591
3592 #ifdef _POSIX
3593 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3594 #endif
3595
3596 #ifdef _WIN
3597 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3598 #endif
3599 {
3600 hc_signal (NULL);
3601
3602 dictstat_t d;
3603
3604 d.cnt = 0;
3605
3606 #ifdef _POSIX
3607 fstat (fileno (fd), &d.stat);
3608 #endif
3609
3610 #ifdef _WIN
3611 _fstat64 (fileno (fd), &d.stat);
3612 #endif
3613
3614 d.stat.st_mode = 0;
3615 d.stat.st_nlink = 0;
3616 d.stat.st_uid = 0;
3617 d.stat.st_gid = 0;
3618 d.stat.st_rdev = 0;
3619 d.stat.st_atime = 0;
3620
3621 #ifdef _POSIX
3622 d.stat.st_blksize = 0;
3623 d.stat.st_blocks = 0;
3624 #endif
3625
3626 if (d.stat.st_size == 0) return 0;
3627
3628 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3629
3630 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3631 {
3632 if (d_cache)
3633 {
3634 u64 cnt = d_cache->cnt;
3635
3636 u64 keyspace = cnt;
3637
3638 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3639 {
3640 keyspace *= data.kernel_rules_cnt;
3641 }
3642 else if (data.attack_kern == ATTACK_KERN_COMBI)
3643 {
3644 keyspace *= data.combs_cnt;
3645 }
3646
3647 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);
3648 if (data.quiet == 0) log_info ("");
3649
3650 hc_signal (sigHandler_default);
3651
3652 return (keyspace);
3653 }
3654 }
3655
3656 time_t now = 0;
3657 time_t prev = 0;
3658
3659 u64 comp = 0;
3660 u64 cnt = 0;
3661 u64 cnt2 = 0;
3662
3663 while (!feof (fd))
3664 {
3665 load_segment (wl_data, fd);
3666
3667 comp += wl_data->cnt;
3668
3669 u32 i = 0;
3670
3671 while (i < wl_data->cnt)
3672 {
3673 u32 len;
3674 u32 off;
3675
3676 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3677
3678 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3679 {
3680 char rule_buf_out[BLOCK_SIZE] = { 0 };
3681
3682 int rule_len_out = -1;
3683
3684 if (len < BLOCK_SIZE)
3685 {
3686 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3687 }
3688
3689 if (rule_len_out < 0)
3690 {
3691 len = PW_MAX1;
3692 }
3693 else
3694 {
3695 len = rule_len_out;
3696 }
3697 }
3698
3699 if (len < PW_MAX1)
3700 {
3701 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3702 {
3703 cnt += data.kernel_rules_cnt;
3704 }
3705 else if (data.attack_kern == ATTACK_KERN_COMBI)
3706 {
3707 cnt += data.combs_cnt;
3708 }
3709
3710 d.cnt++;
3711 }
3712
3713 i += off;
3714
3715 cnt2++;
3716 }
3717
3718 time (&now);
3719
3720 if ((now - prev) == 0) continue;
3721
3722 float percent = (float) comp / (float) d.stat.st_size;
3723
3724 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);
3725
3726 time (&prev);
3727 }
3728
3729 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);
3730 if (data.quiet == 0) log_info ("");
3731
3732 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3733
3734 hc_signal (sigHandler_default);
3735
3736 return (cnt);
3737 }
3738
3739 static void *thread_monitor (void *p)
3740 {
3741 uint runtime_check = 0;
3742 uint remove_check = 0;
3743 uint status_check = 0;
3744 uint restore_check = 0;
3745
3746 uint restore_left = data.restore_timer;
3747 uint remove_left = data.remove_timer;
3748 uint status_left = data.status_timer;
3749
3750 #ifdef HAVE_HWMON
3751 uint hwmon_check = 0;
3752
3753 // these variables are mainly used for fan control (AMD only)
3754
3755 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3756
3757 // temperature controller "loopback" values
3758
3759 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3760 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3761
3762 #ifdef HAVE_ADL
3763 int temp_threshold = 1; // degrees celcius
3764
3765 int fan_speed_min = 15; // in percentage
3766 int fan_speed_max = 100;
3767 #endif // HAVE_ADL
3768
3769 time_t last_temp_check_time;
3770 #endif // HAVE_HWMON
3771
3772 uint sleep_time = 1;
3773
3774 if (data.runtime)
3775 {
3776 runtime_check = 1;
3777 }
3778
3779 if (data.restore_timer)
3780 {
3781 restore_check = 1;
3782 }
3783
3784 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3785 {
3786 remove_check = 1;
3787 }
3788
3789 if (data.status == 1)
3790 {
3791 status_check = 1;
3792 }
3793
3794 #ifdef HAVE_HWMON
3795 if (data.gpu_temp_disable == 0)
3796 {
3797 time (&last_temp_check_time);
3798
3799 hwmon_check = 1;
3800 }
3801 #endif
3802
3803 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3804 {
3805 #ifdef HAVE_HWMON
3806 if (hwmon_check == 0)
3807 #endif
3808 return (p);
3809 }
3810
3811 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3812 {
3813 hc_sleep (sleep_time);
3814
3815 if (data.devices_status != STATUS_RUNNING) continue;
3816
3817 #ifdef HAVE_HWMON
3818 if (hwmon_check == 1)
3819 {
3820 hc_thread_mutex_lock (mux_adl);
3821
3822 time_t temp_check_time;
3823
3824 time (&temp_check_time);
3825
3826 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3827
3828 if (Ta == 0) Ta = 1;
3829
3830 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3831 {
3832 hc_device_param_t *device_param = &data.devices_param[device_id];
3833
3834 if (device_param->skipped) continue;
3835
3836 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3837
3838 const int temperature = hm_get_temperature_with_device_id (device_id);
3839
3840 if (temperature > (int) data.gpu_temp_abort)
3841 {
3842 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3843
3844 if (data.devices_status != STATUS_QUIT) myabort ();
3845
3846 break;
3847 }
3848
3849 #ifdef HAVE_ADL
3850 const int gpu_temp_retain = data.gpu_temp_retain;
3851
3852 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3853 {
3854 if (data.hm_device[device_id].fan_supported == 1)
3855 {
3856 int temp_cur = temperature;
3857
3858 int temp_diff_new = gpu_temp_retain - temp_cur;
3859
3860 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3861
3862 // calculate Ta value (time difference in seconds between the last check and this check)
3863
3864 last_temp_check_time = temp_check_time;
3865
3866 float Kp = 1.8;
3867 float Ki = 0.005;
3868 float Kd = 6;
3869
3870 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3871
3872 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);
3873
3874 if (abs (fan_diff_required) >= temp_threshold)
3875 {
3876 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3877
3878 int fan_speed_level = fan_speed_cur;
3879
3880 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3881
3882 int fan_speed_new = fan_speed_level - fan_diff_required;
3883
3884 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3885 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3886
3887 if (fan_speed_new != fan_speed_cur)
3888 {
3889 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3890 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3891
3892 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3893 {
3894 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3895
3896 fan_speed_chgd[device_id] = 1;
3897 }
3898
3899 temp_diff_old[device_id] = temp_diff_new;
3900 }
3901 }
3902 }
3903 }
3904 #endif // HAVE_ADL
3905 }
3906
3907 hc_thread_mutex_unlock (mux_adl);
3908 }
3909 #endif // HAVE_HWMON
3910
3911 if (restore_check == 1)
3912 {
3913 restore_left--;
3914
3915 if (restore_left == 0)
3916 {
3917 if (data.restore_disable == 0) cycle_restore ();
3918
3919 restore_left = data.restore_timer;
3920 }
3921 }
3922
3923 if ((runtime_check == 1) && (data.runtime_start > 0))
3924 {
3925 time_t runtime_cur;
3926
3927 time (&runtime_cur);
3928
3929 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3930
3931 if (runtime_left <= 0)
3932 {
3933 if (data.benchmark == 0)
3934 {
3935 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3936 }
3937
3938 if (data.devices_status != STATUS_QUIT) myabort ();
3939 }
3940 }
3941
3942 if (remove_check == 1)
3943 {
3944 remove_left--;
3945
3946 if (remove_left == 0)
3947 {
3948 if (data.digests_saved != data.digests_done)
3949 {
3950 data.digests_saved = data.digests_done;
3951
3952 save_hash ();
3953 }
3954
3955 remove_left = data.remove_timer;
3956 }
3957 }
3958
3959 if (status_check == 1)
3960 {
3961 status_left--;
3962
3963 if (status_left == 0)
3964 {
3965 hc_thread_mutex_lock (mux_display);
3966
3967 if (data.quiet == 0) clear_prompt ();
3968
3969 if (data.quiet == 0) log_info ("");
3970
3971 status_display ();
3972
3973 if (data.quiet == 0) log_info ("");
3974
3975 hc_thread_mutex_unlock (mux_display);
3976
3977 status_left = data.status_timer;
3978 }
3979 }
3980 }
3981
3982 #ifdef HAVE_HWMON
3983 myfree (fan_speed_chgd);
3984
3985 myfree (temp_diff_old);
3986 myfree (temp_diff_sum);
3987 #endif
3988
3989 p = NULL;
3990
3991 return (p);
3992 }
3993
3994 static void *thread_outfile_remove (void *p)
3995 {
3996 // some hash-dependent constants
3997 char *outfile_dir = data.outfile_check_directory;
3998 uint dgst_size = data.dgst_size;
3999 uint isSalted = data.isSalted;
4000 uint esalt_size = data.esalt_size;
4001 uint hash_mode = data.hash_mode;
4002
4003 uint outfile_check_timer = data.outfile_check_timer;
4004
4005 char separator = data.separator;
4006
4007 // some hash-dependent functions
4008 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4009 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4010
4011 // buffers
4012 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4013
4014 hash_buf.digest = mymalloc (dgst_size);
4015
4016 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4017
4018 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4019
4020 uint digest_buf[64] = { 0 };
4021
4022 outfile_data_t *out_info = NULL;
4023
4024 char **out_files = NULL;
4025
4026 time_t folder_mtime = 0;
4027
4028 int out_cnt = 0;
4029
4030 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4031
4032 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4033 {
4034 hc_sleep (1);
4035
4036 if (data.devices_status != STATUS_RUNNING) continue;
4037
4038 check_left--;
4039
4040 if (check_left == 0)
4041 {
4042 struct stat outfile_check_stat;
4043
4044 if (stat (outfile_dir, &outfile_check_stat) == 0)
4045 {
4046 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4047
4048 if (is_dir == 1)
4049 {
4050 if (outfile_check_stat.st_mtime > folder_mtime)
4051 {
4052 char **out_files_new = scan_directory (outfile_dir);
4053
4054 int out_cnt_new = count_dictionaries (out_files_new);
4055
4056 outfile_data_t *out_info_new = NULL;
4057
4058 if (out_cnt_new > 0)
4059 {
4060 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4061
4062 for (int i = 0; i < out_cnt_new; i++)
4063 {
4064 out_info_new[i].file_name = out_files_new[i];
4065
4066 // check if there are files that we have seen/checked before (and not changed)
4067
4068 for (int j = 0; j < out_cnt; j++)
4069 {
4070 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4071 {
4072 struct stat outfile_stat;
4073
4074 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4075 {
4076 if (outfile_stat.st_ctime == out_info[j].ctime)
4077 {
4078 out_info_new[i].ctime = out_info[j].ctime;
4079 out_info_new[i].seek = out_info[j].seek;
4080 }
4081 }
4082 }
4083 }
4084 }
4085 }
4086
4087 local_free (out_info);
4088 local_free (out_files);
4089
4090 out_files = out_files_new;
4091 out_cnt = out_cnt_new;
4092 out_info = out_info_new;
4093
4094 folder_mtime = outfile_check_stat.st_mtime;
4095 }
4096
4097 for (int j = 0; j < out_cnt; j++)
4098 {
4099 FILE *fp = fopen (out_info[j].file_name, "rb");
4100
4101 if (fp != NULL)
4102 {
4103 //hc_thread_mutex_lock (mux_display);
4104
4105 #ifdef _POSIX
4106 struct stat outfile_stat;
4107
4108 fstat (fileno (fp), &outfile_stat);
4109 #endif
4110
4111 #ifdef _WIN
4112 struct stat64 outfile_stat;
4113
4114 _fstat64 (fileno (fp), &outfile_stat);
4115 #endif
4116
4117 if (outfile_stat.st_ctime > out_info[j].ctime)
4118 {
4119 out_info[j].ctime = outfile_stat.st_ctime;
4120 out_info[j].seek = 0;
4121 }
4122
4123 fseek (fp, out_info[j].seek, SEEK_SET);
4124
4125 while (!feof (fp))
4126 {
4127 char line_buf[BUFSIZ] = { 0 };
4128
4129 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4130
4131 if (ptr == NULL) break;
4132
4133 int line_len = strlen (line_buf);
4134
4135 if (line_len <= 0) continue;
4136
4137 int iter = MAX_CUT_TRIES;
4138
4139 for (uint i = line_len - 1; i && iter; i--, line_len--)
4140 {
4141 if (line_buf[i] != separator) continue;
4142
4143 int parser_status = PARSER_OK;
4144
4145 if ((hash_mode != 2500) && (hash_mode != 6800))
4146 {
4147 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4148 }
4149
4150 uint found = 0;
4151
4152 if (parser_status == PARSER_OK)
4153 {
4154 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4155 {
4156 if (data.salts_shown[salt_pos] == 1) continue;
4157
4158 salt_t *salt_buf = &data.salts_buf[salt_pos];
4159
4160 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4161 {
4162 uint idx = salt_buf->digests_offset + digest_pos;
4163
4164 if (data.digests_shown[idx] == 1) continue;
4165
4166 uint cracked = 0;
4167
4168 if (hash_mode == 6800)
4169 {
4170 if (i == salt_buf->salt_len)
4171 {
4172 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4173 }
4174 }
4175 else if (hash_mode == 2500)
4176 {
4177 // BSSID : MAC1 : MAC2 (:plain)
4178 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4179 {
4180 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4181
4182 if (!cracked) continue;
4183
4184 // now compare MAC1 and MAC2 too, since we have this additional info
4185 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4186 char *mac2_pos = mac1_pos + 12 + 1;
4187
4188 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4189 wpa_t *wpa = &wpas[salt_pos];
4190
4191 uint pke[25] = { 0 };
4192
4193 char *pke_ptr = (char *) pke;
4194
4195 for (uint i = 0; i < 25; i++)
4196 {
4197 pke[i] = byte_swap_32 (wpa->pke[i]);
4198 }
4199
4200 u8 mac1[6] = { 0 };
4201 u8 mac2[6] = { 0 };
4202
4203 memcpy (mac1, pke_ptr + 23, 6);
4204 memcpy (mac2, pke_ptr + 29, 6);
4205
4206 // compare hex string(s) vs binary MAC address(es)
4207
4208 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4209 {
4210 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4211 {
4212 cracked = 0;
4213 break;
4214 }
4215 }
4216
4217 // early skip ;)
4218 if (!cracked) continue;
4219
4220 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4221 {
4222 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4223 {
4224 cracked = 0;
4225 break;
4226 }
4227 }
4228 }
4229 }
4230 else
4231 {
4232 char *digests_buf_ptr = (char *) data.digests_buf;
4233
4234 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4235
4236 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4237 }
4238
4239 if (cracked == 1)
4240 {
4241 found = 1;
4242
4243 data.digests_shown[idx] = 1;
4244
4245 data.digests_done++;
4246
4247 salt_buf->digests_done++;
4248
4249 if (salt_buf->digests_done == salt_buf->digests_cnt)
4250 {
4251 data.salts_shown[salt_pos] = 1;
4252
4253 data.salts_done++;
4254
4255 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4256 }
4257 }
4258 }
4259
4260 if (data.devices_status == STATUS_CRACKED) break;
4261 }
4262 }
4263
4264 if (found) break;
4265
4266 if (data.devices_status == STATUS_CRACKED) break;
4267
4268 iter--;
4269 }
4270
4271 if (data.devices_status == STATUS_CRACKED) break;
4272 }
4273
4274 out_info[j].seek = ftell (fp);
4275
4276 //hc_thread_mutex_unlock (mux_display);
4277
4278 fclose (fp);
4279 }
4280 }
4281 }
4282 }
4283
4284 check_left = outfile_check_timer;
4285 }
4286 }
4287
4288 if (esalt_size) local_free (hash_buf.esalt);
4289
4290 if (isSalted) local_free (hash_buf.salt);
4291
4292 local_free (hash_buf.digest);
4293
4294 local_free (out_info);
4295
4296 local_free (out_files);
4297
4298 p = NULL;
4299
4300 return (p);
4301 }
4302
4303 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4304 {
4305 if (device_param->pws_cnt < device_param->kernel_power)
4306 {
4307 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4308
4309 u8 *ptr = (u8 *) pw->i;
4310
4311 memcpy (ptr, pw_buf, pw_len);
4312
4313 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4314
4315 pw->pw_len = pw_len;
4316
4317 device_param->pws_cnt++;
4318 }
4319 else
4320 {
4321 fprintf (stderr, "BUG pw_add()!!\n");
4322
4323 return;
4324 }
4325 }
4326
4327 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4328 {
4329 hc_thread_mutex_lock (mux_dispatcher);
4330
4331 const u64 words_cur = data.words_cur;
4332 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4333
4334 device_param->words_off = words_cur;
4335
4336 const u64 words_left = words_base - words_cur;
4337
4338 if (allow_div)
4339 {
4340 if (data.kernel_power_all > words_left)
4341 {
4342 if (data.kernel_power_div == 0)
4343 {
4344 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4345 }
4346 }
4347
4348 if (data.kernel_power_div)
4349 {
4350 if (device_param->kernel_power == device_param->kernel_power_user)
4351 {
4352 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4353
4354 if (kernel_power_new < device_param->kernel_power)
4355 {
4356 device_param->kernel_power = kernel_power_new;
4357 }
4358 }
4359 }
4360 }
4361
4362 const uint kernel_power = device_param->kernel_power;
4363
4364 uint work = MIN (words_left, kernel_power);
4365
4366 work = MIN (work, max);
4367
4368 data.words_cur += work;
4369
4370 hc_thread_mutex_unlock (mux_dispatcher);
4371
4372 return work;
4373 }
4374
4375 static void *thread_calc_stdin (void *p)
4376 {
4377 hc_device_param_t *device_param = (hc_device_param_t *) p;
4378
4379 if (device_param->skipped) return NULL;
4380
4381 autotune (device_param);
4382
4383 const uint attack_kern = data.attack_kern;
4384
4385 const uint kernel_power = device_param->kernel_power;
4386
4387 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4388 {
4389 hc_thread_mutex_lock (mux_dispatcher);
4390
4391 if (feof (stdin) != 0)
4392 {
4393 hc_thread_mutex_unlock (mux_dispatcher);
4394
4395 break;
4396 }
4397
4398 uint words_cur = 0;
4399
4400 while (words_cur < kernel_power)
4401 {
4402 char buf[BUFSIZ] = { 0 };
4403
4404 char *line_buf = fgets (buf, sizeof (buf), stdin);
4405
4406 if (line_buf == NULL) break;
4407
4408 uint line_len = in_superchop (line_buf);
4409
4410 line_len = convert_from_hex (line_buf, line_len);
4411
4412 // post-process rule engine
4413
4414 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4415 {
4416 char rule_buf_out[BLOCK_SIZE] = { 0 };
4417
4418 int rule_len_out = -1;
4419
4420 if (line_len < BLOCK_SIZE)
4421 {
4422 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4423 }
4424
4425 if (rule_len_out < 0) continue;
4426
4427 line_buf = rule_buf_out;
4428 line_len = rule_len_out;
4429 }
4430
4431 if (line_len > PW_MAX)
4432 {
4433 continue;
4434 }
4435
4436 if (attack_kern == ATTACK_KERN_STRAIGHT)
4437 {
4438 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4439 {
4440 hc_thread_mutex_lock (mux_counter);
4441
4442 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4443 {
4444 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4445 }
4446
4447 hc_thread_mutex_unlock (mux_counter);
4448
4449 continue;
4450 }
4451 }
4452 else if (attack_kern == ATTACK_KERN_COMBI)
4453 {
4454 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4455 // since we still need to combine the plains
4456
4457 if (line_len > data.pw_max)
4458 {
4459 hc_thread_mutex_lock (mux_counter);
4460
4461 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4462 {
4463 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4464 }
4465
4466 hc_thread_mutex_unlock (mux_counter);
4467
4468 continue;
4469 }
4470 }
4471
4472 pw_add (device_param, (u8 *) line_buf, line_len);
4473
4474 words_cur++;
4475
4476 if (data.devices_status == STATUS_CRACKED) break;
4477 if (data.devices_status == STATUS_ABORTED) break;
4478 if (data.devices_status == STATUS_QUIT) break;
4479 if (data.devices_status == STATUS_BYPASS) break;
4480 }
4481
4482 hc_thread_mutex_unlock (mux_dispatcher);
4483
4484 if (data.devices_status == STATUS_CRACKED) break;
4485 if (data.devices_status == STATUS_ABORTED) break;
4486 if (data.devices_status == STATUS_QUIT) break;
4487 if (data.devices_status == STATUS_BYPASS) break;
4488
4489 // flush
4490
4491 const uint pws_cnt = device_param->pws_cnt;
4492
4493 if (pws_cnt)
4494 {
4495 run_copy (device_param, pws_cnt);
4496
4497 run_cracker (device_param, pws_cnt);
4498
4499 device_param->pws_cnt = 0;
4500
4501 if (attack_kern == ATTACK_KERN_STRAIGHT)
4502 {
4503 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4504 }
4505 else if (attack_kern == ATTACK_KERN_COMBI)
4506 {
4507 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4508 }
4509 }
4510 }
4511
4512 device_param->kernel_accel = 0;
4513 device_param->kernel_loops = 0;
4514
4515 return NULL;
4516 }
4517
4518 static void *thread_calc (void *p)
4519 {
4520 hc_device_param_t *device_param = (hc_device_param_t *) p;
4521
4522 if (device_param->skipped) return NULL;
4523
4524 autotune (device_param);
4525
4526 const uint attack_mode = data.attack_mode;
4527 const uint attack_kern = data.attack_kern;
4528
4529 if (attack_mode == ATTACK_MODE_BF)
4530 {
4531 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4532 {
4533 const uint work = get_work (device_param, -1, true);
4534
4535 if (work == 0) break;
4536
4537 const u64 words_off = device_param->words_off;
4538 const u64 words_fin = words_off + work;
4539
4540 const uint pws_cnt = work;
4541
4542 device_param->pws_cnt = pws_cnt;
4543
4544 if (pws_cnt)
4545 {
4546 run_copy (device_param, pws_cnt);
4547
4548 run_cracker (device_param, pws_cnt);
4549
4550 device_param->pws_cnt = 0;
4551
4552 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4553 }
4554
4555 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4556
4557 if (data.devices_status == STATUS_CRACKED) break;
4558 if (data.devices_status == STATUS_ABORTED) break;
4559 if (data.devices_status == STATUS_QUIT) break;
4560 if (data.devices_status == STATUS_BYPASS) break;
4561
4562 if (data.benchmark == 1) break;
4563
4564 device_param->words_done = words_fin;
4565 }
4566 }
4567 else
4568 {
4569 const uint segment_size = data.segment_size;
4570
4571 char *dictfile = data.dictfile;
4572
4573 if (attack_mode == ATTACK_MODE_COMBI)
4574 {
4575 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4576 {
4577 dictfile = data.dictfile2;
4578 }
4579 }
4580
4581 FILE *fd = fopen (dictfile, "rb");
4582
4583 if (fd == NULL)
4584 {
4585 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4586
4587 return NULL;
4588 }
4589
4590 if (attack_mode == ATTACK_MODE_COMBI)
4591 {
4592 const uint combs_mode = data.combs_mode;
4593
4594 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4595 {
4596 const char *dictfilec = data.dictfile2;
4597
4598 FILE *combs_fp = fopen (dictfilec, "rb");
4599
4600 if (combs_fp == NULL)
4601 {
4602 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4603
4604 fclose (fd);
4605
4606 return NULL;
4607 }
4608
4609 device_param->combs_fp = combs_fp;
4610 }
4611 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4612 {
4613 const char *dictfilec = data.dictfile;
4614
4615 FILE *combs_fp = fopen (dictfilec, "rb");
4616
4617 if (combs_fp == NULL)
4618 {
4619 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4620
4621 fclose (fd);
4622
4623 return NULL;
4624 }
4625
4626 device_param->combs_fp = combs_fp;
4627 }
4628 }
4629
4630 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4631
4632 wl_data->buf = (char *) mymalloc (segment_size);
4633 wl_data->avail = segment_size;
4634 wl_data->incr = segment_size;
4635 wl_data->cnt = 0;
4636 wl_data->pos = 0;
4637
4638 u64 words_cur = 0;
4639
4640 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4641 {
4642 u64 words_off = 0;
4643 u64 words_fin = 0;
4644
4645 bool allow_div = true;
4646
4647 u64 max = -1;
4648
4649 while (max)
4650 {
4651 const uint work = get_work (device_param, max, allow_div);
4652
4653 allow_div = false;
4654
4655 if (work == 0) break;
4656
4657 words_off = device_param->words_off;
4658 words_fin = words_off + work;
4659
4660 char *line_buf;
4661 uint line_len;
4662
4663 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4664
4665 max = 0;
4666
4667 for ( ; words_cur < words_fin; words_cur++)
4668 {
4669 get_next_word (wl_data, fd, &line_buf, &line_len);
4670
4671 line_len = convert_from_hex (line_buf, line_len);
4672
4673 // post-process rule engine
4674
4675 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4676 {
4677 char rule_buf_out[BLOCK_SIZE] = { 0 };
4678
4679 int rule_len_out = -1;
4680
4681 if (line_len < BLOCK_SIZE)
4682 {
4683 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4684 }
4685
4686 if (rule_len_out < 0) continue;
4687
4688 line_buf = rule_buf_out;
4689 line_len = rule_len_out;
4690 }
4691
4692 if (attack_kern == ATTACK_KERN_STRAIGHT)
4693 {
4694 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4695 {
4696 max++;
4697
4698 hc_thread_mutex_lock (mux_counter);
4699
4700 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4701 {
4702 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4703 }
4704
4705 hc_thread_mutex_unlock (mux_counter);
4706
4707 continue;
4708 }
4709 }
4710 else if (attack_kern == ATTACK_KERN_COMBI)
4711 {
4712 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4713 // since we still need to combine the plains
4714
4715 if (line_len > data.pw_max)
4716 {
4717 max++;
4718
4719 hc_thread_mutex_lock (mux_counter);
4720
4721 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4722 {
4723 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4724 }
4725
4726 hc_thread_mutex_unlock (mux_counter);
4727
4728 continue;
4729 }
4730 }
4731
4732 pw_add (device_param, (u8 *) line_buf, line_len);
4733
4734 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4735
4736 if (data.devices_status == STATUS_CRACKED) break;
4737 if (data.devices_status == STATUS_ABORTED) break;
4738 if (data.devices_status == STATUS_QUIT) break;
4739 if (data.devices_status == STATUS_BYPASS) break;
4740 }
4741
4742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4743
4744 if (data.devices_status == STATUS_CRACKED) break;
4745 if (data.devices_status == STATUS_ABORTED) break;
4746 if (data.devices_status == STATUS_QUIT) break;
4747 if (data.devices_status == STATUS_BYPASS) break;
4748 }
4749
4750 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4751
4752 if (data.devices_status == STATUS_CRACKED) break;
4753 if (data.devices_status == STATUS_ABORTED) break;
4754 if (data.devices_status == STATUS_QUIT) break;
4755 if (data.devices_status == STATUS_BYPASS) break;
4756
4757 //
4758 // flush
4759 //
4760
4761 const uint pws_cnt = device_param->pws_cnt;
4762
4763 if (pws_cnt)
4764 {
4765 run_copy (device_param, pws_cnt);
4766
4767 run_cracker (device_param, pws_cnt);
4768
4769 device_param->pws_cnt = 0;
4770
4771 if (attack_kern == ATTACK_KERN_STRAIGHT)
4772 {
4773 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4774 }
4775 else if (attack_kern == ATTACK_KERN_COMBI)
4776 {
4777 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4778 }
4779 }
4780
4781 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4782
4783 if (data.devices_status == STATUS_CRACKED) break;
4784 if (data.devices_status == STATUS_ABORTED) break;
4785 if (data.devices_status == STATUS_QUIT) break;
4786 if (data.devices_status == STATUS_BYPASS) break;
4787
4788 if (words_fin == 0) break;
4789
4790 device_param->words_done = words_fin;
4791 }
4792
4793 if (attack_mode == ATTACK_MODE_COMBI)
4794 {
4795 fclose (device_param->combs_fp);
4796 }
4797
4798 free (wl_data->buf);
4799 free (wl_data);
4800
4801 fclose (fd);
4802 }
4803
4804 device_param->kernel_accel = 0;
4805 device_param->kernel_loops = 0;
4806
4807 return NULL;
4808 }
4809
4810 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4811 {
4812 if (!device_param)
4813 {
4814 log_error ("ERROR: %s : Invalid argument", __func__);
4815
4816 exit (-1);
4817 }
4818
4819 salt_t *salt_buf = &data.salts_buf[salt_pos];
4820
4821 device_param->kernel_params_buf32[24] = salt_pos;
4822 device_param->kernel_params_buf32[27] = 1;
4823 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4824 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4825 device_param->kernel_params_buf32[30] = 0;
4826 device_param->kernel_params_buf32[31] = 1;
4827
4828 char *dictfile_old = data.dictfile;
4829
4830 const char *weak_hash_check = "weak-hash-check";
4831
4832 data.dictfile = (char *) weak_hash_check;
4833
4834 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4835
4836 data.kernel_rules_buf[0].cmds[0] = 0;
4837
4838 /**
4839 * run the kernel
4840 */
4841
4842 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4843 {
4844 run_kernel (KERN_RUN_1, device_param, 1, false);
4845 }
4846 else
4847 {
4848 run_kernel (KERN_RUN_1, device_param, 1, false);
4849
4850 uint loop_step = 16;
4851
4852 const uint iter = salt_buf->salt_iter;
4853
4854 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4855 {
4856 uint loop_left = iter - loop_pos;
4857
4858 loop_left = MIN (loop_left, loop_step);
4859
4860 device_param->kernel_params_buf32[25] = loop_pos;
4861 device_param->kernel_params_buf32[26] = loop_left;
4862
4863 run_kernel (KERN_RUN_2, device_param, 1, false);
4864 }
4865
4866 run_kernel (KERN_RUN_3, device_param, 1, false);
4867 }
4868
4869 /**
4870 * result
4871 */
4872
4873 check_cracked (device_param, salt_pos);
4874
4875 /**
4876 * cleanup
4877 */
4878
4879 device_param->kernel_params_buf32[24] = 0;
4880 device_param->kernel_params_buf32[25] = 0;
4881 device_param->kernel_params_buf32[26] = 0;
4882 device_param->kernel_params_buf32[27] = 0;
4883 device_param->kernel_params_buf32[28] = 0;
4884 device_param->kernel_params_buf32[29] = 0;
4885 device_param->kernel_params_buf32[30] = 0;
4886 device_param->kernel_params_buf32[31] = 0;
4887
4888 data.dictfile = dictfile_old;
4889
4890 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4891 }
4892
4893 // hlfmt hashcat
4894
4895 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4896 {
4897 if (data.username == 0)
4898 {
4899 *hashbuf_pos = line_buf;
4900 *hashbuf_len = line_len;
4901 }
4902 else
4903 {
4904 char *pos = line_buf;
4905 int len = line_len;
4906
4907 for (int i = 0; i < line_len; i++, pos++, len--)
4908 {
4909 if (line_buf[i] == data.separator)
4910 {
4911 pos++;
4912
4913 len--;
4914
4915 break;
4916 }
4917 }
4918
4919 *hashbuf_pos = pos;
4920 *hashbuf_len = len;
4921 }
4922 }
4923
4924 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4925 {
4926 char *pos = NULL;
4927 int len = 0;
4928
4929 int sep_cnt = 0;
4930
4931 for (int i = 0; i < line_len; i++)
4932 {
4933 if (line_buf[i] == data.separator)
4934 {
4935 sep_cnt++;
4936
4937 continue;
4938 }
4939
4940 if (sep_cnt == 0)
4941 {
4942 if (pos == NULL) pos = line_buf + i;
4943
4944 len++;
4945 }
4946 }
4947
4948 *userbuf_pos = pos;
4949 *userbuf_len = len;
4950 }
4951
4952 // hlfmt pwdump
4953
4954 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4955 {
4956 int sep_cnt = 0;
4957
4958 int sep2_len = 0;
4959 int sep3_len = 0;
4960
4961 for (int i = 0; i < line_len; i++)
4962 {
4963 if (line_buf[i] == ':')
4964 {
4965 sep_cnt++;
4966
4967 continue;
4968 }
4969
4970 if (sep_cnt == 2) sep2_len++;
4971 if (sep_cnt == 3) sep3_len++;
4972 }
4973
4974 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4975
4976 return 0;
4977 }
4978
4979 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4980 {
4981 char *pos = NULL;
4982 int len = 0;
4983
4984 int sep_cnt = 0;
4985
4986 for (int i = 0; i < line_len; i++)
4987 {
4988 if (line_buf[i] == ':')
4989 {
4990 sep_cnt++;
4991
4992 continue;
4993 }
4994
4995 if (data.hash_mode == 1000)
4996 {
4997 if (sep_cnt == 3)
4998 {
4999 if (pos == NULL) pos = line_buf + i;
5000
5001 len++;
5002 }
5003 }
5004 else if (data.hash_mode == 3000)
5005 {
5006 if (sep_cnt == 2)
5007 {
5008 if (pos == NULL) pos = line_buf + i;
5009
5010 len++;
5011 }
5012 }
5013 }
5014
5015 *hashbuf_pos = pos;
5016 *hashbuf_len = len;
5017 }
5018
5019 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5020 {
5021 char *pos = NULL;
5022 int len = 0;
5023
5024 int sep_cnt = 0;
5025
5026 for (int i = 0; i < line_len; i++)
5027 {
5028 if (line_buf[i] == ':')
5029 {
5030 sep_cnt++;
5031
5032 continue;
5033 }
5034
5035 if (sep_cnt == 0)
5036 {
5037 if (pos == NULL) pos = line_buf + i;
5038
5039 len++;
5040 }
5041 }
5042
5043 *userbuf_pos = pos;
5044 *userbuf_len = len;
5045 }
5046
5047 // hlfmt passwd
5048
5049 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5050 {
5051 int sep_cnt = 0;
5052
5053 char sep5_first = 0;
5054 char sep6_first = 0;
5055
5056 for (int i = 0; i < line_len; i++)
5057 {
5058 if (line_buf[i] == ':')
5059 {
5060 sep_cnt++;
5061
5062 continue;
5063 }
5064
5065 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5066 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5067 }
5068
5069 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5070
5071 return 0;
5072 }
5073
5074 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5075 {
5076 char *pos = NULL;
5077 int len = 0;
5078
5079 int sep_cnt = 0;
5080
5081 for (int i = 0; i < line_len; i++)
5082 {
5083 if (line_buf[i] == ':')
5084 {
5085 sep_cnt++;
5086
5087 continue;
5088 }
5089
5090 if (sep_cnt == 1)
5091 {
5092 if (pos == NULL) pos = line_buf + i;
5093
5094 len++;
5095 }
5096 }
5097
5098 *hashbuf_pos = pos;
5099 *hashbuf_len = len;
5100 }
5101
5102 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5103 {
5104 char *pos = NULL;
5105 int len = 0;
5106
5107 int sep_cnt = 0;
5108
5109 for (int i = 0; i < line_len; i++)
5110 {
5111 if (line_buf[i] == ':')
5112 {
5113 sep_cnt++;
5114
5115 continue;
5116 }
5117
5118 if (sep_cnt == 0)
5119 {
5120 if (pos == NULL) pos = line_buf + i;
5121
5122 len++;
5123 }
5124 }
5125
5126 *userbuf_pos = pos;
5127 *userbuf_len = len;
5128 }
5129
5130 // hlfmt shadow
5131
5132 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5133 {
5134 int sep_cnt = 0;
5135
5136 for (int i = 0; i < line_len; i++)
5137 {
5138 if (line_buf[i] == ':') sep_cnt++;
5139 }
5140
5141 if (sep_cnt == 8) return 1;
5142
5143 return 0;
5144 }
5145
5146 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5147 {
5148 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5149 }
5150
5151 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5152 {
5153 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5154 }
5155
5156 // hlfmt main
5157
5158 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5159 {
5160 switch (hashfile_format)
5161 {
5162 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5163 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5164 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5165 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5166 }
5167 }
5168
5169 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5170 {
5171 switch (hashfile_format)
5172 {
5173 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5174 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5175 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5176 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5177 }
5178 }
5179
5180 static uint hlfmt_detect (FILE *fp, uint max_check)
5181 {
5182 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5183
5184 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5185 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5186
5187 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5188
5189 uint num_check = 0;
5190
5191 while (!feof (fp))
5192 {
5193 char line_buf[BUFSIZ] = { 0 };
5194
5195 int line_len = fgetl (fp, line_buf);
5196
5197 if (line_len == 0) continue;
5198
5199 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5200 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5201 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5202
5203 if (num_check == max_check) break;
5204
5205 num_check++;
5206 }
5207
5208 uint hashlist_format = HLFMT_HASHCAT;
5209
5210 for (int i = 1; i < HLFMTS_CNT; i++)
5211 {
5212 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5213
5214 hashlist_format = i;
5215 }
5216
5217 free (formats_cnt);
5218
5219 return hashlist_format;
5220 }
5221
5222 /**
5223 * some further helper function
5224 */
5225
5226 // wrapper around mymalloc for ADL
5227
5228 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5229 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5230 {
5231 return mymalloc (iSize);
5232 }
5233 #endif
5234
5235 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)
5236 {
5237 u64 collisions = 0;
5238
5239 const uint dgst_pos0 = data.dgst_pos0;
5240 const uint dgst_pos1 = data.dgst_pos1;
5241 const uint dgst_pos2 = data.dgst_pos2;
5242 const uint dgst_pos3 = data.dgst_pos3;
5243
5244 memset (bitmap_a, 0, bitmap_size);
5245 memset (bitmap_b, 0, bitmap_size);
5246 memset (bitmap_c, 0, bitmap_size);
5247 memset (bitmap_d, 0, bitmap_size);
5248
5249 for (uint i = 0; i < digests_cnt; i++)
5250 {
5251 uint *digest_ptr = (uint *) digests_buf_ptr;
5252
5253 digests_buf_ptr += dgst_size;
5254
5255 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5256 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5257 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5258 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5259
5260 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5261 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5262 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5263 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5264
5265 if (bitmap_a[idx0] & val0) collisions++;
5266 if (bitmap_b[idx1] & val1) collisions++;
5267 if (bitmap_c[idx2] & val2) collisions++;
5268 if (bitmap_d[idx3] & val3) collisions++;
5269
5270 bitmap_a[idx0] |= val0;
5271 bitmap_b[idx1] |= val1;
5272 bitmap_c[idx2] |= val2;
5273 bitmap_d[idx3] |= val3;
5274
5275 if (collisions >= collisions_max) return 0x7fffffff;
5276 }
5277
5278 return collisions;
5279 }
5280
5281 /**
5282 * main
5283 */
5284
5285 int main (int argc, char **argv)
5286 {
5287 /**
5288 * To help users a bit
5289 */
5290
5291 char *compute = getenv ("COMPUTE");
5292
5293 if (compute)
5294 {
5295 static char display[100];
5296
5297 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5298
5299 putenv (display);
5300 }
5301 else
5302 {
5303 if (getenv ("DISPLAY") == NULL)
5304 putenv ((char *) "DISPLAY=:0");
5305 }
5306
5307 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5308 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5309
5310 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5311 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5312
5313 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5314 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5315
5316 /**
5317 * Real init
5318 */
5319
5320 memset (&data, 0, sizeof (hc_global_data_t));
5321
5322 time_t proc_start;
5323
5324 time (&proc_start);
5325
5326 data.proc_start = proc_start;
5327
5328 int myargc = argc;
5329 char **myargv = argv;
5330
5331 hc_thread_mutex_init (mux_dispatcher);
5332 hc_thread_mutex_init (mux_counter);
5333 hc_thread_mutex_init (mux_display);
5334 hc_thread_mutex_init (mux_adl);
5335
5336 /**
5337 * commandline parameters
5338 */
5339
5340 uint usage = USAGE;
5341 uint version = VERSION;
5342 uint quiet = QUIET;
5343 uint benchmark = BENCHMARK;
5344 uint benchmark_repeats = BENCHMARK_REPEATS;
5345 uint show = SHOW;
5346 uint left = LEFT;
5347 uint username = USERNAME;
5348 uint remove = REMOVE;
5349 uint remove_timer = REMOVE_TIMER;
5350 u64 skip = SKIP;
5351 u64 limit = LIMIT;
5352 uint keyspace = KEYSPACE;
5353 uint potfile_disable = POTFILE_DISABLE;
5354 uint debug_mode = DEBUG_MODE;
5355 char *debug_file = NULL;
5356 char *induction_dir = NULL;
5357 char *outfile_check_dir = NULL;
5358 uint force = FORCE;
5359 uint runtime = RUNTIME;
5360 uint hash_mode = HASH_MODE;
5361 uint attack_mode = ATTACK_MODE;
5362 uint markov_disable = MARKOV_DISABLE;
5363 uint markov_classic = MARKOV_CLASSIC;
5364 uint markov_threshold = MARKOV_THRESHOLD;
5365 char *markov_hcstat = NULL;
5366 char *outfile = NULL;
5367 uint outfile_format = OUTFILE_FORMAT;
5368 uint outfile_autohex = OUTFILE_AUTOHEX;
5369 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5370 uint restore = RESTORE;
5371 uint restore_timer = RESTORE_TIMER;
5372 uint restore_disable = RESTORE_DISABLE;
5373 uint status = STATUS;
5374 uint status_timer = STATUS_TIMER;
5375 uint status_automat = STATUS_AUTOMAT;
5376 uint loopback = LOOPBACK;
5377 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5378 char *session = NULL;
5379 uint hex_charset = HEX_CHARSET;
5380 uint hex_salt = HEX_SALT;
5381 uint hex_wordlist = HEX_WORDLIST;
5382 uint rp_gen = RP_GEN;
5383 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5384 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5385 uint rp_gen_seed = RP_GEN_SEED;
5386 char *rule_buf_l = (char *) RULE_BUF_L;
5387 char *rule_buf_r = (char *) RULE_BUF_R;
5388 uint increment = INCREMENT;
5389 uint increment_min = INCREMENT_MIN;
5390 uint increment_max = INCREMENT_MAX;
5391 char *cpu_affinity = NULL;
5392 OCL_PTR *ocl = NULL;
5393 char *opencl_devices = NULL;
5394 char *opencl_platforms = NULL;
5395 char *opencl_device_types = NULL;
5396 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5397 char *truecrypt_keyfiles = NULL;
5398 uint workload_profile = WORKLOAD_PROFILE;
5399 uint kernel_accel = KERNEL_ACCEL;
5400 uint kernel_loops = KERNEL_LOOPS;
5401 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5402 #ifdef HAVE_HWMON
5403 uint gpu_temp_abort = GPU_TEMP_ABORT;
5404 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5405 #ifdef HAVE_ADL
5406 uint powertune_enable = POWERTUNE_ENABLE;
5407 #endif
5408 #endif
5409 uint logfile_disable = LOGFILE_DISABLE;
5410 uint segment_size = SEGMENT_SIZE;
5411 uint scrypt_tmto = SCRYPT_TMTO;
5412 char separator = SEPARATOR;
5413 uint bitmap_min = BITMAP_MIN;
5414 uint bitmap_max = BITMAP_MAX;
5415 char *custom_charset_1 = NULL;
5416 char *custom_charset_2 = NULL;
5417 char *custom_charset_3 = NULL;
5418 char *custom_charset_4 = NULL;
5419
5420 #define IDX_HELP 'h'
5421 #define IDX_VERSION 'V'
5422 #define IDX_VERSION_LOWER 'v'
5423 #define IDX_QUIET 0xff02
5424 #define IDX_SHOW 0xff03
5425 #define IDX_LEFT 0xff04
5426 #define IDX_REMOVE 0xff05
5427 #define IDX_REMOVE_TIMER 0xff37
5428 #define IDX_SKIP 's'
5429 #define IDX_LIMIT 'l'
5430 #define IDX_KEYSPACE 0xff35
5431 #define IDX_POTFILE_DISABLE 0xff06
5432 #define IDX_DEBUG_MODE 0xff43
5433 #define IDX_DEBUG_FILE 0xff44
5434 #define IDX_INDUCTION_DIR 0xff46
5435 #define IDX_OUTFILE_CHECK_DIR 0xff47
5436 #define IDX_USERNAME 0xff07
5437 #define IDX_FORCE 0xff08
5438 #define IDX_RUNTIME 0xff09
5439 #define IDX_BENCHMARK 'b'
5440 #define IDX_BENCHMARK_REPEATS 0xff78
5441 #define IDX_HASH_MODE 'm'
5442 #define IDX_ATTACK_MODE 'a'
5443 #define IDX_RP_FILE 'r'
5444 #define IDX_RP_GEN 'g'
5445 #define IDX_RP_GEN_FUNC_MIN 0xff10
5446 #define IDX_RP_GEN_FUNC_MAX 0xff11
5447 #define IDX_RP_GEN_SEED 0xff34
5448 #define IDX_RULE_BUF_L 'j'
5449 #define IDX_RULE_BUF_R 'k'
5450 #define IDX_INCREMENT 'i'
5451 #define IDX_INCREMENT_MIN 0xff12
5452 #define IDX_INCREMENT_MAX 0xff13
5453 #define IDX_OUTFILE 'o'
5454 #define IDX_OUTFILE_FORMAT 0xff14
5455 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5456 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5457 #define IDX_RESTORE 0xff15
5458 #define IDX_RESTORE_DISABLE 0xff27
5459 #define IDX_STATUS 0xff17
5460 #define IDX_STATUS_TIMER 0xff18
5461 #define IDX_STATUS_AUTOMAT 0xff50
5462 #define IDX_LOOPBACK 0xff38
5463 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5464 #define IDX_SESSION 0xff19
5465 #define IDX_HEX_CHARSET 0xff20
5466 #define IDX_HEX_SALT 0xff21
5467 #define IDX_HEX_WORDLIST 0xff40
5468 #define IDX_MARKOV_DISABLE 0xff22
5469 #define IDX_MARKOV_CLASSIC 0xff23
5470 #define IDX_MARKOV_THRESHOLD 't'
5471 #define IDX_MARKOV_HCSTAT 0xff24
5472 #define IDX_CPU_AFFINITY 0xff25
5473 #define IDX_OPENCL_DEVICES 'd'
5474 #define IDX_OPENCL_PLATFORMS 0xff72
5475 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5476 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5477 #define IDX_WORKLOAD_PROFILE 'w'
5478 #define IDX_KERNEL_ACCEL 'n'
5479 #define IDX_KERNEL_LOOPS 'u'
5480 #define IDX_GPU_TEMP_DISABLE 0xff29
5481 #define IDX_GPU_TEMP_ABORT 0xff30
5482 #define IDX_GPU_TEMP_RETAIN 0xff31
5483 #define IDX_POWERTUNE_ENABLE 0xff41
5484 #define IDX_LOGFILE_DISABLE 0xff51
5485 #define IDX_TRUECRYPT_KEYFILES 0xff52
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5513 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5514 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5515 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5516 {"force", no_argument, 0, IDX_FORCE},
5517 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5518 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5519 {"restore", no_argument, 0, IDX_RESTORE},
5520 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5521 {"status", no_argument, 0, IDX_STATUS},
5522 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5523 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5524 {"loopback", no_argument, 0, IDX_LOOPBACK},
5525 {"weak-hash-threshold",
5526 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5527 {"session", required_argument, 0, IDX_SESSION},
5528 {"runtime", required_argument, 0, IDX_RUNTIME},
5529 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5530 {"generate-rules-func-min",
5531 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5532 {"generate-rules-func-max",
5533 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5534 {"generate-rules-seed",
5535 required_argument, 0, IDX_RP_GEN_SEED},
5536 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5537 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5538 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5539 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5540 {"rules-file", required_argument, 0, IDX_RP_FILE},
5541 {"outfile", required_argument, 0, IDX_OUTFILE},
5542 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5543 {"outfile-autohex-disable",
5544 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5545 {"outfile-check-timer",
5546 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5547 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5548 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5549 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5550 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5551 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5552 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5553 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5554 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5555 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5556 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5557 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5558 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5559 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5560 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5561 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5562 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5563 #ifdef HAVE_HWMON
5564 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5565 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5566 #ifdef HAVE_ADL
5567 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5568 #endif
5569 #endif // HAVE_HWMON
5570 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5571 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5572 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5573 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5574 // deprecated
5575 {"seperator", required_argument, 0, IDX_SEPARATOR},
5576 {"separator", required_argument, 0, IDX_SEPARATOR},
5577 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5578 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5579 {"increment", no_argument, 0, IDX_INCREMENT},
5580 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5581 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5582 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5583 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5584 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5585 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5586
5587 {0, 0, 0, 0}
5588 };
5589
5590 uint rp_files_cnt = 0;
5591
5592 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5593
5594 int option_index = 0;
5595 int c = -1;
5596
5597 optind = 1;
5598 optopt = 0;
5599
5600 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5601 {
5602 switch (c)
5603 {
5604 case IDX_HELP: usage = 1; break;
5605 case IDX_VERSION:
5606 case IDX_VERSION_LOWER: version = 1; break;
5607 case IDX_RESTORE: restore = 1; break;
5608 case IDX_SESSION: session = optarg; break;
5609 case IDX_SHOW: show = 1; break;
5610 case IDX_LEFT: left = 1; break;
5611 case '?': return (-1);
5612 }
5613 }
5614
5615 if (optopt != 0)
5616 {
5617 log_error ("ERROR: Invalid argument specified");
5618
5619 return (-1);
5620 }
5621
5622 /**
5623 * exit functions
5624 */
5625
5626 if (version)
5627 {
5628 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5629
5630 return (0);
5631 }
5632
5633 if (usage)
5634 {
5635 usage_big_print (PROGNAME);
5636
5637 return (0);
5638 }
5639
5640 /**
5641 * session needs to be set, always!
5642 */
5643
5644 if (session == NULL) session = (char *) PROGNAME;
5645
5646 /**
5647 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5648 */
5649
5650 char *exec_path = get_exec_path ();
5651
5652 #ifdef LINUX
5653
5654 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5655 char *resolved_exec_path = realpath (exec_path, NULL);
5656
5657 char *install_dir = get_install_dir (resolved_exec_path);
5658 char *profile_dir = NULL;
5659 char *session_dir = NULL;
5660 char *shared_dir = NULL;
5661
5662 if (strcmp (install_dir, resolved_install_folder) == 0)
5663 {
5664 struct passwd *pw = getpwuid (getuid ());
5665
5666 const char *homedir = pw->pw_dir;
5667
5668 profile_dir = get_profile_dir (homedir);
5669 session_dir = get_session_dir (profile_dir);
5670 shared_dir = strdup (SHARED_FOLDER);
5671
5672 mkdir (profile_dir, 0700);
5673 mkdir (session_dir, 0700);
5674 }
5675 else
5676 {
5677 profile_dir = install_dir;
5678 session_dir = install_dir;
5679 shared_dir = install_dir;
5680 }
5681
5682 myfree (resolved_install_folder);
5683 myfree (resolved_exec_path);
5684
5685 #else
5686
5687 char *install_dir = get_install_dir (exec_path);
5688 char *profile_dir = install_dir;
5689 char *session_dir = install_dir;
5690 char *shared_dir = install_dir;
5691
5692 #endif
5693
5694 data.install_dir = install_dir;
5695 data.profile_dir = profile_dir;
5696 data.session_dir = session_dir;
5697 data.shared_dir = shared_dir;
5698
5699 myfree (exec_path);
5700
5701 /**
5702 * kernel cache, we need to make sure folder exist
5703 */
5704
5705 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5706
5707 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5708
5709 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5710
5711 mkdir (kernels_folder, 0700);
5712
5713 myfree (kernels_folder);
5714
5715 /**
5716 * session
5717 */
5718
5719 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5720
5721 data.session = session;
5722
5723 char *eff_restore_file = (char *) mymalloc (session_size);
5724 char *new_restore_file = (char *) mymalloc (session_size);
5725
5726 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5727 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5728
5729 data.eff_restore_file = eff_restore_file;
5730 data.new_restore_file = new_restore_file;
5731
5732 if (((show == 1) || (left == 1)) && (restore == 1))
5733 {
5734 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5735 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5736
5737 return (-1);
5738 }
5739
5740 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5741 if ((show == 1) || (left == 1))
5742 {
5743 restore_disable = 1;
5744
5745 restore = 0;
5746 }
5747
5748 data.restore_disable = restore_disable;
5749
5750 restore_data_t *rd = init_restore (argc, argv);
5751
5752 data.rd = rd;
5753
5754 /**
5755 * restore file
5756 */
5757
5758 if (restore == 1)
5759 {
5760 read_restore (eff_restore_file, rd);
5761
5762 if (rd->version_bin < RESTORE_MIN)
5763 {
5764 log_error ("ERROR: Incompatible restore-file version");
5765
5766 return (-1);
5767 }
5768
5769 myargc = rd->argc;
5770 myargv = rd->argv;
5771
5772 #ifdef _POSIX
5773 rd->pid = getpid ();
5774 #elif _WIN
5775 rd->pid = GetCurrentProcessId ();
5776 #endif
5777 }
5778
5779 uint hash_mode_chgd = 0;
5780 uint runtime_chgd = 0;
5781 uint kernel_loops_chgd = 0;
5782 uint kernel_accel_chgd = 0;
5783 uint attack_mode_chgd = 0;
5784 uint outfile_format_chgd = 0;
5785 uint rp_gen_seed_chgd = 0;
5786 uint remove_timer_chgd = 0;
5787 uint increment_min_chgd = 0;
5788 uint increment_max_chgd = 0;
5789 uint workload_profile_chgd = 0;
5790 uint opencl_vector_width_chgd = 0;
5791
5792 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5793 uint gpu_temp_retain_chgd = 0;
5794 uint gpu_temp_abort_chgd = 0;
5795 #endif
5796
5797 optind = 1;
5798 optopt = 0;
5799 option_index = 0;
5800
5801 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5802 {
5803 switch (c)
5804 {
5805 //case IDX_HELP: usage = 1; break;
5806 //case IDX_VERSION: version = 1; break;
5807 //case IDX_RESTORE: restore = 1; break;
5808 case IDX_QUIET: quiet = 1; break;
5809 //case IDX_SHOW: show = 1; break;
5810 case IDX_SHOW: break;
5811 //case IDX_LEFT: left = 1; break;
5812 case IDX_LEFT: break;
5813 case IDX_USERNAME: username = 1; break;
5814 case IDX_REMOVE: remove = 1; break;
5815 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5816 remove_timer_chgd = 1; break;
5817 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5818 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5819 case IDX_DEBUG_FILE: debug_file = optarg; break;
5820 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5821 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5822 case IDX_FORCE: force = 1; break;
5823 case IDX_SKIP: skip = atoll (optarg); break;
5824 case IDX_LIMIT: limit = atoll (optarg); break;
5825 case IDX_KEYSPACE: keyspace = 1; break;
5826 case IDX_BENCHMARK: benchmark = 1; break;
5827 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5828 case IDX_RESTORE: break;
5829 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5830 case IDX_STATUS: status = 1; break;
5831 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5832 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5833 case IDX_LOOPBACK: loopback = 1; break;
5834 case IDX_WEAK_HASH_THRESHOLD:
5835 weak_hash_threshold = atoi (optarg); break;
5836 //case IDX_SESSION: session = optarg; break;
5837 case IDX_SESSION: break;
5838 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5839 hash_mode_chgd = 1; break;
5840 case IDX_RUNTIME: runtime = atoi (optarg);
5841 runtime_chgd = 1; break;
5842 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5843 attack_mode_chgd = 1; break;
5844 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5845 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5846 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5847 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5848 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5849 rp_gen_seed_chgd = 1; break;
5850 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5851 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5852 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5853 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5854 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5855 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5856 case IDX_OUTFILE: outfile = optarg; break;
5857 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5858 outfile_format_chgd = 1; break;
5859 case IDX_OUTFILE_AUTOHEX_DISABLE:
5860 outfile_autohex = 0; break;
5861 case IDX_OUTFILE_CHECK_TIMER:
5862 outfile_check_timer = atoi (optarg); break;
5863 case IDX_HEX_CHARSET: hex_charset = 1; break;
5864 case IDX_HEX_SALT: hex_salt = 1; break;
5865 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5866 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5867 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5868 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5869 case IDX_OPENCL_DEVICE_TYPES:
5870 opencl_device_types = optarg; break;
5871 case IDX_OPENCL_VECTOR_WIDTH:
5872 opencl_vector_width = atoi (optarg);
5873 opencl_vector_width_chgd = 1; break;
5874 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5875 workload_profile_chgd = 1; break;
5876 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5877 kernel_accel_chgd = 1; break;
5878 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5879 kernel_loops_chgd = 1; break;
5880 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5881 #ifdef HAVE_HWMON
5882 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_abort_chgd = 1;
5885 #endif
5886 break;
5887 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5888 #ifdef HAVE_ADL
5889 gpu_temp_retain_chgd = 1;
5890 #endif
5891 break;
5892 #ifdef HAVE_ADL
5893 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5894 #endif
5895 #endif // HAVE_HWMON
5896 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5897 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5898 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5899 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5900 case IDX_SEPARATOR: separator = optarg[0]; break;
5901 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5902 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5903 case IDX_INCREMENT: increment = 1; break;
5904 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5905 increment_min_chgd = 1; break;
5906 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5907 increment_max_chgd = 1; break;
5908 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5909 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5910 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5912
5913 default:
5914 log_error ("ERROR: Invalid argument specified");
5915 return (-1);
5916 }
5917 }
5918
5919 if (optopt != 0)
5920 {
5921 log_error ("ERROR: Invalid argument specified");
5922
5923 return (-1);
5924 }
5925
5926 /**
5927 * Inform user things getting started,
5928 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5929 * - we do not need to check algorithm_pos
5930 */
5931
5932 if (quiet == 0)
5933 {
5934 if (benchmark == 1)
5935 {
5936 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5937
5938 log_info ("");
5939 }
5940 else if (restore == 1)
5941 {
5942 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5943
5944 log_info ("");
5945 }
5946 else
5947 {
5948 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5949
5950 log_info ("");
5951 }
5952 }
5953
5954 /**
5955 * sanity check
5956 */
5957
5958 if (attack_mode > 7)
5959 {
5960 log_error ("ERROR: Invalid attack-mode specified");
5961
5962 return (-1);
5963 }
5964
5965 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5966 {
5967 log_error ("ERROR: Invalid runtime specified");
5968
5969 return (-1);
5970 }
5971
5972 if (hash_mode_chgd && hash_mode > 13300) // just added to remove compiler warnings for hash_mode_chgd
5973 {
5974 log_error ("ERROR: Invalid hash-type specified");
5975
5976 return (-1);
5977 }
5978
5979 // renamed hash modes
5980
5981 if (hash_mode_chgd)
5982 {
5983 int n = -1;
5984
5985 switch (hash_mode)
5986 {
5987 case 123: n = 124;
5988 break;
5989 }
5990
5991 if (n >= 0)
5992 {
5993 log_error ("Old -m specified, use -m %d instead", n);
5994
5995 return (-1);
5996 }
5997 }
5998
5999 if (username == 1)
6000 {
6001 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6002 {
6003 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6004
6005 return (-1);
6006 }
6007 }
6008
6009 if (outfile_format > 16)
6010 {
6011 log_error ("ERROR: Invalid outfile-format specified");
6012
6013 return (-1);
6014 }
6015
6016 if (left == 1)
6017 {
6018 if (outfile_format_chgd == 1)
6019 {
6020 if (outfile_format > 1)
6021 {
6022 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6023
6024 return (-1);
6025 }
6026 }
6027 else
6028 {
6029 outfile_format = OUTFILE_FMT_HASH;
6030 }
6031 }
6032
6033 if (show == 1)
6034 {
6035 if (outfile_format_chgd == 1)
6036 {
6037 if ((outfile_format > 7) && (outfile_format < 16))
6038 {
6039 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6040
6041 return (-1);
6042 }
6043 }
6044 }
6045
6046 if (increment_min < INCREMENT_MIN)
6047 {
6048 log_error ("ERROR: Invalid increment-min specified");
6049
6050 return (-1);
6051 }
6052
6053 if (increment_max > INCREMENT_MAX)
6054 {
6055 log_error ("ERROR: Invalid increment-max specified");
6056
6057 return (-1);
6058 }
6059
6060 if (increment_min > increment_max)
6061 {
6062 log_error ("ERROR: Invalid increment-min specified");
6063
6064 return (-1);
6065 }
6066
6067 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6068 {
6069 log_error ("ERROR: increment is not allowed in attack-mode 0");
6070
6071 return (-1);
6072 }
6073
6074 if ((increment == 0) && (increment_min_chgd == 1))
6075 {
6076 log_error ("ERROR: increment-min is only supported together with increment switch");
6077
6078 return (-1);
6079 }
6080
6081 if ((increment == 0) && (increment_max_chgd == 1))
6082 {
6083 log_error ("ERROR: increment-max is only supported together with increment switch");
6084
6085 return (-1);
6086 }
6087
6088 if (rp_files_cnt && rp_gen)
6089 {
6090 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6091
6092 return (-1);
6093 }
6094
6095 if (rp_files_cnt || rp_gen)
6096 {
6097 if (attack_mode != ATTACK_MODE_STRAIGHT)
6098 {
6099 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6100
6101 return (-1);
6102 }
6103 }
6104
6105 if (rp_gen_func_min > rp_gen_func_max)
6106 {
6107 log_error ("ERROR: Invalid rp-gen-func-min specified");
6108
6109 return (-1);
6110 }
6111
6112 if (kernel_accel_chgd == 1)
6113 {
6114 if (kernel_accel < 1)
6115 {
6116 log_error ("ERROR: Invalid kernel-accel specified");
6117
6118 return (-1);
6119 }
6120
6121 if (kernel_accel > 1024)
6122 {
6123 log_error ("ERROR: Invalid kernel-accel specified");
6124
6125 return (-1);
6126 }
6127 }
6128
6129 if (kernel_loops_chgd == 1)
6130 {
6131 if (kernel_loops < 1)
6132 {
6133 log_error ("ERROR: Invalid kernel-loops specified");
6134
6135 return (-1);
6136 }
6137
6138 if (kernel_loops > 1024)
6139 {
6140 log_error ("ERROR: Invalid kernel-loops specified");
6141
6142 return (-1);
6143 }
6144 }
6145
6146 if ((workload_profile < 1) || (workload_profile > 3))
6147 {
6148 log_error ("ERROR: workload-profile %i not available", workload_profile);
6149
6150 return (-1);
6151 }
6152
6153 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6154 {
6155 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6156
6157 return (-1);
6158 }
6159
6160 if (show == 1 || left == 1)
6161 {
6162 attack_mode = ATTACK_MODE_NONE;
6163
6164 if (remove == 1)
6165 {
6166 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6167
6168 return (-1);
6169 }
6170
6171 if (potfile_disable == 1)
6172 {
6173 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6174
6175 return (-1);
6176 }
6177 }
6178
6179 uint attack_kern = ATTACK_KERN_NONE;
6180
6181 switch (attack_mode)
6182 {
6183 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6184 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6185 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6186 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6187 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6188 }
6189
6190 if (benchmark == 0)
6191 {
6192 if (keyspace == 1)
6193 {
6194 int num_additional_params = 1;
6195
6196 if (attack_kern == ATTACK_KERN_COMBI)
6197 {
6198 num_additional_params = 2;
6199 }
6200
6201 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6202
6203 if (keyspace_wordlist_specified == 0) optind--;
6204 }
6205
6206 if (attack_kern == ATTACK_KERN_NONE)
6207 {
6208 if ((optind + 1) != myargc)
6209 {
6210 usage_mini_print (myargv[0]);
6211
6212 return (-1);
6213 }
6214 }
6215 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6216 {
6217 if ((optind + 1) > myargc)
6218 {
6219 usage_mini_print (myargv[0]);
6220
6221 return (-1);
6222 }
6223 }
6224 else if (attack_kern == ATTACK_KERN_COMBI)
6225 {
6226 if ((optind + 3) != myargc)
6227 {
6228 usage_mini_print (myargv[0]);
6229
6230 return (-1);
6231 }
6232 }
6233 else if (attack_kern == ATTACK_KERN_BF)
6234 {
6235 if ((optind + 1) > myargc)
6236 {
6237 usage_mini_print (myargv[0]);
6238
6239 return (-1);
6240 }
6241 }
6242 else
6243 {
6244 usage_mini_print (myargv[0]);
6245
6246 return (-1);
6247 }
6248 }
6249 else
6250 {
6251 if (myargv[optind] != 0)
6252 {
6253 log_error ("ERROR: Invalid argument for benchmark mode specified");
6254
6255 return (-1);
6256 }
6257
6258 if (attack_mode_chgd == 1)
6259 {
6260 if (attack_mode != ATTACK_MODE_BF)
6261 {
6262 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6263
6264 return (-1);
6265 }
6266 }
6267 }
6268
6269 if (skip != 0 && limit != 0)
6270 {
6271 limit += skip;
6272 }
6273
6274 if (keyspace == 1)
6275 {
6276 if (show == 1)
6277 {
6278 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6279
6280 return (-1);
6281 }
6282 else if (left == 1)
6283 {
6284 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6285
6286 return (-1);
6287 }
6288
6289 potfile_disable = 1;
6290
6291 restore_disable = 1;
6292
6293 restore = 0;
6294
6295 weak_hash_threshold = 0;
6296
6297 quiet = 1;
6298 }
6299
6300 if (remove_timer_chgd == 1)
6301 {
6302 if (remove == 0)
6303 {
6304 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6305
6306 return (-1);
6307 }
6308
6309 if (remove_timer < 1)
6310 {
6311 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6312
6313 return (-1);
6314 }
6315 }
6316
6317 if (loopback == 1)
6318 {
6319 if (attack_mode == ATTACK_MODE_BF)
6320 {
6321 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6322
6323 return (-1);
6324 }
6325 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6326 {
6327 if ((rp_files_cnt == 0) && (rp_gen == 0))
6328 {
6329 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6330
6331 return (-1);
6332 }
6333 }
6334 }
6335
6336 if (debug_mode > 0)
6337 {
6338 if (attack_mode != ATTACK_MODE_STRAIGHT)
6339 {
6340 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6341
6342 return (-1);
6343 }
6344
6345 if ((rp_files_cnt == 0) && (rp_gen == 0))
6346 {
6347 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 if (debug_mode > 4)
6354 {
6355 log_error ("ERROR: Invalid debug-mode specified");
6356
6357 return (-1);
6358 }
6359
6360 if (debug_file != NULL)
6361 {
6362 if (debug_mode < 1)
6363 {
6364 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6365
6366 return (-1);
6367 }
6368 }
6369
6370 if (induction_dir != NULL)
6371 {
6372 if (attack_mode == ATTACK_MODE_BF)
6373 {
6374 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6375
6376 return (-1);
6377 }
6378 }
6379
6380 if (attack_mode != ATTACK_MODE_STRAIGHT)
6381 {
6382 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6383 {
6384 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6385
6386 return (-1);
6387 }
6388
6389 weak_hash_threshold = 0;
6390 }
6391
6392 /**
6393 * induction directory
6394 */
6395
6396 char *induction_directory = NULL;
6397
6398 if (attack_mode != ATTACK_MODE_BF)
6399 {
6400 if (induction_dir == NULL)
6401 {
6402 induction_directory = (char *) mymalloc (session_size);
6403
6404 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6405
6406 // create induction folder if it does not already exist
6407
6408 if (keyspace == 0)
6409 {
6410 if (rmdir (induction_directory) == -1)
6411 {
6412 if (errno == ENOENT)
6413 {
6414 // good, we can ignore
6415 }
6416 else if (errno == ENOTEMPTY)
6417 {
6418 char *induction_directory_mv = (char *) mymalloc (session_size);
6419
6420 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6421
6422 if (rename (induction_directory, induction_directory_mv) != 0)
6423 {
6424 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6425
6426 return (-1);
6427 }
6428 }
6429 else
6430 {
6431 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6432
6433 return (-1);
6434 }
6435 }
6436
6437 if (mkdir (induction_directory, 0700) == -1)
6438 {
6439 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6440
6441 return (-1);
6442 }
6443 }
6444 }
6445 else
6446 {
6447 induction_directory = induction_dir;
6448 }
6449 }
6450
6451 data.induction_directory = induction_directory;
6452
6453 /**
6454 * loopback
6455 */
6456
6457 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6458
6459 char *loopback_file = (char *) mymalloc (loopback_size);
6460
6461 /**
6462 * tuning db
6463 */
6464
6465 char tuning_db_file[256] = { 0 };
6466
6467 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6468
6469 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6470
6471 /**
6472 * outfile-check directory
6473 */
6474
6475 char *outfile_check_directory = NULL;
6476
6477 if (outfile_check_dir == NULL)
6478 {
6479 outfile_check_directory = (char *) mymalloc (session_size);
6480
6481 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6482 }
6483 else
6484 {
6485 outfile_check_directory = outfile_check_dir;
6486 }
6487
6488 data.outfile_check_directory = outfile_check_directory;
6489
6490 if (keyspace == 0)
6491 {
6492 struct stat outfile_check_stat;
6493
6494 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6495 {
6496 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6497
6498 if (is_dir == 0)
6499 {
6500 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6501
6502 return (-1);
6503 }
6504 }
6505 else if (outfile_check_dir == NULL)
6506 {
6507 if (mkdir (outfile_check_directory, 0700) == -1)
6508 {
6509 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6510
6511 return (-1);
6512 }
6513 }
6514 }
6515
6516 /**
6517 * special other stuff
6518 */
6519
6520 if (hash_mode == 9710)
6521 {
6522 outfile_format = 5;
6523 outfile_format_chgd = 1;
6524 }
6525
6526 if (hash_mode == 9810)
6527 {
6528 outfile_format = 5;
6529 outfile_format_chgd = 1;
6530 }
6531
6532 if (hash_mode == 10410)
6533 {
6534 outfile_format = 5;
6535 outfile_format_chgd = 1;
6536 }
6537
6538 /**
6539 * store stuff
6540 */
6541
6542 data.hash_mode = hash_mode;
6543 data.restore = restore;
6544 data.restore_timer = restore_timer;
6545 data.restore_disable = restore_disable;
6546 data.status = status;
6547 data.status_timer = status_timer;
6548 data.status_automat = status_automat;
6549 data.loopback = loopback;
6550 data.runtime = runtime;
6551 data.remove = remove;
6552 data.remove_timer = remove_timer;
6553 data.debug_mode = debug_mode;
6554 data.debug_file = debug_file;
6555 data.username = username;
6556 data.quiet = quiet;
6557 data.outfile = outfile;
6558 data.outfile_format = outfile_format;
6559 data.outfile_autohex = outfile_autohex;
6560 data.hex_charset = hex_charset;
6561 data.hex_salt = hex_salt;
6562 data.hex_wordlist = hex_wordlist;
6563 data.separator = separator;
6564 data.rp_files = rp_files;
6565 data.rp_files_cnt = rp_files_cnt;
6566 data.rp_gen = rp_gen;
6567 data.rp_gen_seed = rp_gen_seed;
6568 data.force = force;
6569 data.benchmark = benchmark;
6570 data.benchmark_repeats = benchmark_repeats;
6571 data.skip = skip;
6572 data.limit = limit;
6573 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6574 data.powertune_enable = powertune_enable;
6575 #endif
6576 data.logfile_disable = logfile_disable;
6577 data.truecrypt_keyfiles = truecrypt_keyfiles;
6578 data.scrypt_tmto = scrypt_tmto;
6579 data.workload_profile = workload_profile;
6580
6581 /**
6582 * cpu affinity
6583 */
6584
6585 if (cpu_affinity)
6586 {
6587 set_cpu_affinity (cpu_affinity);
6588 }
6589
6590 if (rp_gen_seed_chgd == 0)
6591 {
6592 srand (proc_start);
6593 }
6594 else
6595 {
6596 srand (rp_gen_seed);
6597 }
6598
6599 /**
6600 * logfile init
6601 */
6602
6603 if (logfile_disable == 0)
6604 {
6605 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6606
6607 char *logfile = (char *) mymalloc (logfile_size);
6608
6609 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6610
6611 data.logfile = logfile;
6612
6613 char *topid = logfile_generate_topid ();
6614
6615 data.topid = topid;
6616 }
6617
6618 // logfile_append() checks for logfile_disable internally to make it easier from here
6619
6620 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6621 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6622 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6623 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6624 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6625 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6627 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6628 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6629 #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));
6630
6631 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6632 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6633 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6634 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6635 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6636 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6637 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6638 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6639
6640 logfile_top_msg ("START");
6641
6642 logfile_top_uint (attack_mode);
6643 logfile_top_uint (attack_kern);
6644 logfile_top_uint (benchmark);
6645 logfile_top_uint (benchmark_repeats);
6646 logfile_top_uint (bitmap_min);
6647 logfile_top_uint (bitmap_max);
6648 logfile_top_uint (debug_mode);
6649 logfile_top_uint (force);
6650 logfile_top_uint (kernel_accel);
6651 logfile_top_uint (kernel_loops);
6652 logfile_top_uint (gpu_temp_disable);
6653 #ifdef HAVE_HWMON
6654 logfile_top_uint (gpu_temp_abort);
6655 logfile_top_uint (gpu_temp_retain);
6656 #endif
6657 logfile_top_uint (hash_mode);
6658 logfile_top_uint (hex_charset);
6659 logfile_top_uint (hex_salt);
6660 logfile_top_uint (hex_wordlist);
6661 logfile_top_uint (increment);
6662 logfile_top_uint (increment_max);
6663 logfile_top_uint (increment_min);
6664 logfile_top_uint (keyspace);
6665 logfile_top_uint (left);
6666 logfile_top_uint (logfile_disable);
6667 logfile_top_uint (loopback);
6668 logfile_top_uint (markov_classic);
6669 logfile_top_uint (markov_disable);
6670 logfile_top_uint (markov_threshold);
6671 logfile_top_uint (outfile_autohex);
6672 logfile_top_uint (outfile_check_timer);
6673 logfile_top_uint (outfile_format);
6674 logfile_top_uint (potfile_disable);
6675 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6676 logfile_top_uint (powertune_enable);
6677 #endif
6678 logfile_top_uint (scrypt_tmto);
6679 logfile_top_uint (quiet);
6680 logfile_top_uint (remove);
6681 logfile_top_uint (remove_timer);
6682 logfile_top_uint (restore);
6683 logfile_top_uint (restore_disable);
6684 logfile_top_uint (restore_timer);
6685 logfile_top_uint (rp_gen);
6686 logfile_top_uint (rp_gen_func_max);
6687 logfile_top_uint (rp_gen_func_min);
6688 logfile_top_uint (rp_gen_seed);
6689 logfile_top_uint (runtime);
6690 logfile_top_uint (segment_size);
6691 logfile_top_uint (show);
6692 logfile_top_uint (status);
6693 logfile_top_uint (status_automat);
6694 logfile_top_uint (status_timer);
6695 logfile_top_uint (usage);
6696 logfile_top_uint (username);
6697 logfile_top_uint (version);
6698 logfile_top_uint (weak_hash_threshold);
6699 logfile_top_uint (workload_profile);
6700 logfile_top_uint64 (limit);
6701 logfile_top_uint64 (skip);
6702 logfile_top_char (separator);
6703 logfile_top_string (cpu_affinity);
6704 logfile_top_string (custom_charset_1);
6705 logfile_top_string (custom_charset_2);
6706 logfile_top_string (custom_charset_3);
6707 logfile_top_string (custom_charset_4);
6708 logfile_top_string (debug_file);
6709 logfile_top_string (opencl_devices);
6710 logfile_top_string (opencl_platforms);
6711 logfile_top_string (opencl_device_types);
6712 logfile_top_uint (opencl_vector_width);
6713 logfile_top_string (induction_dir);
6714 logfile_top_string (markov_hcstat);
6715 logfile_top_string (outfile);
6716 logfile_top_string (outfile_check_dir);
6717 logfile_top_string (rule_buf_l);
6718 logfile_top_string (rule_buf_r);
6719 logfile_top_string (session);
6720 logfile_top_string (truecrypt_keyfiles);
6721
6722 /**
6723 * Init OpenCL library loader
6724 */
6725
6726 if (keyspace == 0)
6727 {
6728 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6729
6730 ocl_init (ocl);
6731
6732 data.ocl = ocl;
6733 }
6734
6735 /**
6736 * OpenCL platform selection
6737 */
6738
6739 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6740
6741 /**
6742 * OpenCL device selection
6743 */
6744
6745 u32 devices_filter = setup_devices_filter (opencl_devices);
6746
6747 /**
6748 * OpenCL device type selection
6749 */
6750
6751 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6752
6753 /**
6754 * benchmark
6755 */
6756
6757 if (benchmark == 1)
6758 {
6759 /**
6760 * disable useless stuff for benchmark
6761 */
6762
6763 status_timer = 0;
6764 restore_timer = 0;
6765 restore_disable = 1;
6766 potfile_disable = 1;
6767 weak_hash_threshold = 0;
6768 gpu_temp_disable = 1;
6769
6770 data.status_timer = status_timer;
6771 data.restore_timer = restore_timer;
6772 data.restore_disable = restore_disable;
6773
6774 /**
6775 * force attack mode to be bruteforce
6776 */
6777
6778 attack_mode = ATTACK_MODE_BF;
6779 attack_kern = ATTACK_KERN_BF;
6780
6781 if (workload_profile_chgd == 0)
6782 {
6783 workload_profile = 3;
6784
6785 data.workload_profile = workload_profile;
6786 }
6787 }
6788
6789 /**
6790 * config
6791 */
6792
6793 uint hash_type = 0;
6794 uint salt_type = 0;
6795 uint attack_exec = 0;
6796 uint opts_type = 0;
6797 uint kern_type = 0;
6798 uint dgst_size = 0;
6799 uint esalt_size = 0;
6800 uint opti_type = 0;
6801 uint dgst_pos0 = -1;
6802 uint dgst_pos1 = -1;
6803 uint dgst_pos2 = -1;
6804 uint dgst_pos3 = -1;
6805
6806 int (*parse_func) (char *, uint, hash_t *);
6807 int (*sort_by_digest) (const void *, const void *);
6808
6809 uint algorithm_pos = 0;
6810 uint algorithm_max = 1;
6811
6812 uint *algorithms = default_benchmark_algorithms;
6813
6814 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6815
6816 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6817 {
6818 /*
6819 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6820 * the following algos are skipped entirely
6821 */
6822
6823 if (algorithm_pos > 0)
6824 {
6825 local_free (rd);
6826
6827 rd = init_restore (argc, argv);
6828
6829 data.rd = rd;
6830 }
6831
6832 /**
6833 * update hash_mode in case of multihash benchmark
6834 */
6835
6836 if (benchmark == 1)
6837 {
6838 if (hash_mode_chgd == 0)
6839 {
6840 hash_mode = algorithms[algorithm_pos];
6841
6842 data.hash_mode = hash_mode;
6843 }
6844
6845 quiet = 1;
6846
6847 data.quiet = quiet;
6848 }
6849
6850 switch (hash_mode)
6851 {
6852 case 0: hash_type = HASH_TYPE_MD5;
6853 salt_type = SALT_TYPE_NONE;
6854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6855 opts_type = OPTS_TYPE_PT_GENERATE_LE
6856 | OPTS_TYPE_PT_ADD80
6857 | OPTS_TYPE_PT_ADDBITS14;
6858 kern_type = KERN_TYPE_MD5;
6859 dgst_size = DGST_SIZE_4_4;
6860 parse_func = md5_parse_hash;
6861 sort_by_digest = sort_by_digest_4_4;
6862 opti_type = OPTI_TYPE_ZERO_BYTE
6863 | OPTI_TYPE_PRECOMPUTE_INIT
6864 | OPTI_TYPE_PRECOMPUTE_MERKLE
6865 | OPTI_TYPE_MEET_IN_MIDDLE
6866 | OPTI_TYPE_EARLY_SKIP
6867 | OPTI_TYPE_NOT_ITERATED
6868 | OPTI_TYPE_NOT_SALTED
6869 | OPTI_TYPE_RAW_HASH;
6870 dgst_pos0 = 0;
6871 dgst_pos1 = 3;
6872 dgst_pos2 = 2;
6873 dgst_pos3 = 1;
6874 break;
6875
6876 case 10: hash_type = HASH_TYPE_MD5;
6877 salt_type = SALT_TYPE_INTERN;
6878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6879 opts_type = OPTS_TYPE_PT_GENERATE_LE
6880 | OPTS_TYPE_ST_ADD80
6881 | OPTS_TYPE_ST_ADDBITS14;
6882 kern_type = KERN_TYPE_MD5_PWSLT;
6883 dgst_size = DGST_SIZE_4_4;
6884 parse_func = md5s_parse_hash;
6885 sort_by_digest = sort_by_digest_4_4;
6886 opti_type = OPTI_TYPE_ZERO_BYTE
6887 | OPTI_TYPE_PRECOMPUTE_INIT
6888 | OPTI_TYPE_PRECOMPUTE_MERKLE
6889 | OPTI_TYPE_MEET_IN_MIDDLE
6890 | OPTI_TYPE_EARLY_SKIP
6891 | OPTI_TYPE_NOT_ITERATED
6892 | OPTI_TYPE_APPENDED_SALT
6893 | OPTI_TYPE_RAW_HASH;
6894 dgst_pos0 = 0;
6895 dgst_pos1 = 3;
6896 dgst_pos2 = 2;
6897 dgst_pos3 = 1;
6898 break;
6899
6900 case 11: hash_type = HASH_TYPE_MD5;
6901 salt_type = SALT_TYPE_INTERN;
6902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6903 opts_type = OPTS_TYPE_PT_GENERATE_LE
6904 | OPTS_TYPE_ST_ADD80
6905 | OPTS_TYPE_ST_ADDBITS14;
6906 kern_type = KERN_TYPE_MD5_PWSLT;
6907 dgst_size = DGST_SIZE_4_4;
6908 parse_func = joomla_parse_hash;
6909 sort_by_digest = sort_by_digest_4_4;
6910 opti_type = OPTI_TYPE_ZERO_BYTE
6911 | OPTI_TYPE_PRECOMPUTE_INIT
6912 | OPTI_TYPE_PRECOMPUTE_MERKLE
6913 | OPTI_TYPE_MEET_IN_MIDDLE
6914 | OPTI_TYPE_EARLY_SKIP
6915 | OPTI_TYPE_NOT_ITERATED
6916 | OPTI_TYPE_APPENDED_SALT
6917 | OPTI_TYPE_RAW_HASH;
6918 dgst_pos0 = 0;
6919 dgst_pos1 = 3;
6920 dgst_pos2 = 2;
6921 dgst_pos3 = 1;
6922 break;
6923
6924 case 12: hash_type = HASH_TYPE_MD5;
6925 salt_type = SALT_TYPE_INTERN;
6926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6927 opts_type = OPTS_TYPE_PT_GENERATE_LE
6928 | OPTS_TYPE_ST_ADD80
6929 | OPTS_TYPE_ST_ADDBITS14;
6930 kern_type = KERN_TYPE_MD5_PWSLT;
6931 dgst_size = DGST_SIZE_4_4;
6932 parse_func = postgresql_parse_hash;
6933 sort_by_digest = sort_by_digest_4_4;
6934 opti_type = OPTI_TYPE_ZERO_BYTE
6935 | OPTI_TYPE_PRECOMPUTE_INIT
6936 | OPTI_TYPE_PRECOMPUTE_MERKLE
6937 | OPTI_TYPE_MEET_IN_MIDDLE
6938 | OPTI_TYPE_EARLY_SKIP
6939 | OPTI_TYPE_NOT_ITERATED
6940 | OPTI_TYPE_APPENDED_SALT
6941 | OPTI_TYPE_RAW_HASH;
6942 dgst_pos0 = 0;
6943 dgst_pos1 = 3;
6944 dgst_pos2 = 2;
6945 dgst_pos3 = 1;
6946 break;
6947
6948 case 20: hash_type = HASH_TYPE_MD5;
6949 salt_type = SALT_TYPE_INTERN;
6950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6951 opts_type = OPTS_TYPE_PT_GENERATE_LE
6952 | OPTS_TYPE_PT_ADD80
6953 | OPTS_TYPE_PT_ADDBITS14;
6954 kern_type = KERN_TYPE_MD5_SLTPW;
6955 dgst_size = DGST_SIZE_4_4;
6956 parse_func = md5s_parse_hash;
6957 sort_by_digest = sort_by_digest_4_4;
6958 opti_type = OPTI_TYPE_ZERO_BYTE
6959 | OPTI_TYPE_PRECOMPUTE_INIT
6960 | OPTI_TYPE_PRECOMPUTE_MERKLE
6961 | OPTI_TYPE_EARLY_SKIP
6962 | OPTI_TYPE_NOT_ITERATED
6963 | OPTI_TYPE_PREPENDED_SALT
6964 | OPTI_TYPE_RAW_HASH;
6965 dgst_pos0 = 0;
6966 dgst_pos1 = 3;
6967 dgst_pos2 = 2;
6968 dgst_pos3 = 1;
6969 break;
6970
6971 case 21: hash_type = HASH_TYPE_MD5;
6972 salt_type = SALT_TYPE_INTERN;
6973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6974 opts_type = OPTS_TYPE_PT_GENERATE_LE
6975 | OPTS_TYPE_PT_ADD80
6976 | OPTS_TYPE_PT_ADDBITS14;
6977 kern_type = KERN_TYPE_MD5_SLTPW;
6978 dgst_size = DGST_SIZE_4_4;
6979 parse_func = osc_parse_hash;
6980 sort_by_digest = sort_by_digest_4_4;
6981 opti_type = OPTI_TYPE_ZERO_BYTE
6982 | OPTI_TYPE_PRECOMPUTE_INIT
6983 | OPTI_TYPE_PRECOMPUTE_MERKLE
6984 | OPTI_TYPE_EARLY_SKIP
6985 | OPTI_TYPE_NOT_ITERATED
6986 | OPTI_TYPE_PREPENDED_SALT
6987 | OPTI_TYPE_RAW_HASH;
6988 dgst_pos0 = 0;
6989 dgst_pos1 = 3;
6990 dgst_pos2 = 2;
6991 dgst_pos3 = 1;
6992 break;
6993
6994 case 22: hash_type = HASH_TYPE_MD5;
6995 salt_type = SALT_TYPE_EMBEDDED;
6996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6997 opts_type = OPTS_TYPE_PT_GENERATE_LE
6998 | OPTS_TYPE_PT_ADD80
6999 | OPTS_TYPE_PT_ADDBITS14;
7000 kern_type = KERN_TYPE_MD5_SLTPW;
7001 dgst_size = DGST_SIZE_4_4;
7002 parse_func = netscreen_parse_hash;
7003 sort_by_digest = sort_by_digest_4_4;
7004 opti_type = OPTI_TYPE_ZERO_BYTE
7005 | OPTI_TYPE_PRECOMPUTE_INIT
7006 | OPTI_TYPE_PRECOMPUTE_MERKLE
7007 | OPTI_TYPE_EARLY_SKIP
7008 | OPTI_TYPE_NOT_ITERATED
7009 | OPTI_TYPE_PREPENDED_SALT
7010 | OPTI_TYPE_RAW_HASH;
7011 dgst_pos0 = 0;
7012 dgst_pos1 = 3;
7013 dgst_pos2 = 2;
7014 dgst_pos3 = 1;
7015 break;
7016
7017 case 23: hash_type = HASH_TYPE_MD5;
7018 salt_type = SALT_TYPE_EMBEDDED;
7019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7020 opts_type = OPTS_TYPE_PT_GENERATE_LE
7021 | OPTS_TYPE_PT_ADD80
7022 | OPTS_TYPE_PT_ADDBITS14;
7023 kern_type = KERN_TYPE_MD5_SLTPW;
7024 dgst_size = DGST_SIZE_4_4;
7025 parse_func = skype_parse_hash;
7026 sort_by_digest = sort_by_digest_4_4;
7027 opti_type = OPTI_TYPE_ZERO_BYTE
7028 | OPTI_TYPE_PRECOMPUTE_INIT
7029 | OPTI_TYPE_PRECOMPUTE_MERKLE
7030 | OPTI_TYPE_EARLY_SKIP
7031 | OPTI_TYPE_NOT_ITERATED
7032 | OPTI_TYPE_PREPENDED_SALT
7033 | OPTI_TYPE_RAW_HASH;
7034 dgst_pos0 = 0;
7035 dgst_pos1 = 3;
7036 dgst_pos2 = 2;
7037 dgst_pos3 = 1;
7038 break;
7039
7040 case 30: 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_UNICODE
7045 | OPTS_TYPE_ST_ADD80
7046 | OPTS_TYPE_ST_ADDBITS14;
7047 kern_type = KERN_TYPE_MD5_PWUSLT;
7048 dgst_size = DGST_SIZE_4_4;
7049 parse_func = md5s_parse_hash;
7050 sort_by_digest = sort_by_digest_4_4;
7051 opti_type = OPTI_TYPE_ZERO_BYTE
7052 | OPTI_TYPE_PRECOMPUTE_INIT
7053 | OPTI_TYPE_PRECOMPUTE_MERKLE
7054 | OPTI_TYPE_MEET_IN_MIDDLE
7055 | OPTI_TYPE_EARLY_SKIP
7056 | OPTI_TYPE_NOT_ITERATED
7057 | OPTI_TYPE_APPENDED_SALT
7058 | OPTI_TYPE_RAW_HASH;
7059 dgst_pos0 = 0;
7060 dgst_pos1 = 3;
7061 dgst_pos2 = 2;
7062 dgst_pos3 = 1;
7063 break;
7064
7065 case 40: hash_type = HASH_TYPE_MD5;
7066 salt_type = SALT_TYPE_INTERN;
7067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7068 opts_type = OPTS_TYPE_PT_GENERATE_LE
7069 | OPTS_TYPE_PT_ADD80
7070 | OPTS_TYPE_PT_ADDBITS14
7071 | OPTS_TYPE_PT_UNICODE;
7072 kern_type = KERN_TYPE_MD5_SLTPWU;
7073 dgst_size = DGST_SIZE_4_4;
7074 parse_func = md5s_parse_hash;
7075 sort_by_digest = sort_by_digest_4_4;
7076 opti_type = OPTI_TYPE_ZERO_BYTE
7077 | OPTI_TYPE_PRECOMPUTE_INIT
7078 | OPTI_TYPE_PRECOMPUTE_MERKLE
7079 | OPTI_TYPE_EARLY_SKIP
7080 | OPTI_TYPE_NOT_ITERATED
7081 | OPTI_TYPE_PREPENDED_SALT
7082 | OPTI_TYPE_RAW_HASH;
7083 dgst_pos0 = 0;
7084 dgst_pos1 = 3;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 1;
7087 break;
7088
7089 case 50: hash_type = HASH_TYPE_MD5;
7090 salt_type = SALT_TYPE_INTERN;
7091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7092 opts_type = OPTS_TYPE_PT_GENERATE_LE
7093 | OPTS_TYPE_ST_ADD80
7094 | OPTS_TYPE_ST_ADDBITS14;
7095 kern_type = KERN_TYPE_HMACMD5_PW;
7096 dgst_size = DGST_SIZE_4_4;
7097 parse_func = hmacmd5_parse_hash;
7098 sort_by_digest = sort_by_digest_4_4;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_NOT_ITERATED;
7101 dgst_pos0 = 0;
7102 dgst_pos1 = 3;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 60: hash_type = HASH_TYPE_MD5;
7108 salt_type = SALT_TYPE_INTERN;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_LE
7111 | OPTS_TYPE_PT_ADD80
7112 | OPTS_TYPE_PT_ADDBITS14;
7113 kern_type = KERN_TYPE_HMACMD5_SLT;
7114 dgst_size = DGST_SIZE_4_4;
7115 parse_func = hmacmd5_parse_hash;
7116 sort_by_digest = sort_by_digest_4_4;
7117 opti_type = OPTI_TYPE_ZERO_BYTE
7118 | OPTI_TYPE_NOT_ITERATED;
7119 dgst_pos0 = 0;
7120 dgst_pos1 = 3;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 100: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_NONE;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS15;
7131 kern_type = KERN_TYPE_SHA1;
7132 dgst_size = DGST_SIZE_4_5;
7133 parse_func = sha1_parse_hash;
7134 sort_by_digest = sort_by_digest_4_5;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_EARLY_SKIP
7139 | OPTI_TYPE_NOT_ITERATED
7140 | OPTI_TYPE_NOT_SALTED
7141 | OPTI_TYPE_RAW_HASH;
7142 dgst_pos0 = 3;
7143 dgst_pos1 = 4;
7144 dgst_pos2 = 2;
7145 dgst_pos3 = 1;
7146 break;
7147
7148 case 101: hash_type = HASH_TYPE_SHA1;
7149 salt_type = SALT_TYPE_NONE;
7150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7151 opts_type = OPTS_TYPE_PT_GENERATE_BE
7152 | OPTS_TYPE_PT_ADD80
7153 | OPTS_TYPE_PT_ADDBITS15;
7154 kern_type = KERN_TYPE_SHA1;
7155 dgst_size = DGST_SIZE_4_5;
7156 parse_func = sha1b64_parse_hash;
7157 sort_by_digest = sort_by_digest_4_5;
7158 opti_type = OPTI_TYPE_ZERO_BYTE
7159 | OPTI_TYPE_PRECOMPUTE_INIT
7160 | OPTI_TYPE_PRECOMPUTE_MERKLE
7161 | OPTI_TYPE_EARLY_SKIP
7162 | OPTI_TYPE_NOT_ITERATED
7163 | OPTI_TYPE_NOT_SALTED
7164 | OPTI_TYPE_RAW_HASH;
7165 dgst_pos0 = 3;
7166 dgst_pos1 = 4;
7167 dgst_pos2 = 2;
7168 dgst_pos3 = 1;
7169 break;
7170
7171 case 110: hash_type = HASH_TYPE_SHA1;
7172 salt_type = SALT_TYPE_INTERN;
7173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7174 opts_type = OPTS_TYPE_PT_GENERATE_BE
7175 | OPTS_TYPE_ST_ADD80
7176 | OPTS_TYPE_ST_ADDBITS15;
7177 kern_type = KERN_TYPE_SHA1_PWSLT;
7178 dgst_size = DGST_SIZE_4_5;
7179 parse_func = sha1s_parse_hash;
7180 sort_by_digest = sort_by_digest_4_5;
7181 opti_type = OPTI_TYPE_ZERO_BYTE
7182 | OPTI_TYPE_PRECOMPUTE_INIT
7183 | OPTI_TYPE_PRECOMPUTE_MERKLE
7184 | OPTI_TYPE_EARLY_SKIP
7185 | OPTI_TYPE_NOT_ITERATED
7186 | OPTI_TYPE_APPENDED_SALT
7187 | OPTI_TYPE_RAW_HASH;
7188 dgst_pos0 = 3;
7189 dgst_pos1 = 4;
7190 dgst_pos2 = 2;
7191 dgst_pos3 = 1;
7192 break;
7193
7194 case 111: hash_type = HASH_TYPE_SHA1;
7195 salt_type = SALT_TYPE_EMBEDDED;
7196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7197 opts_type = OPTS_TYPE_PT_GENERATE_BE
7198 | OPTS_TYPE_ST_ADD80
7199 | OPTS_TYPE_ST_ADDBITS15;
7200 kern_type = KERN_TYPE_SHA1_PWSLT;
7201 dgst_size = DGST_SIZE_4_5;
7202 parse_func = sha1b64s_parse_hash;
7203 sort_by_digest = sort_by_digest_4_5;
7204 opti_type = OPTI_TYPE_ZERO_BYTE
7205 | OPTI_TYPE_PRECOMPUTE_INIT
7206 | OPTI_TYPE_PRECOMPUTE_MERKLE
7207 | OPTI_TYPE_EARLY_SKIP
7208 | OPTI_TYPE_NOT_ITERATED
7209 | OPTI_TYPE_APPENDED_SALT
7210 | OPTI_TYPE_RAW_HASH;
7211 dgst_pos0 = 3;
7212 dgst_pos1 = 4;
7213 dgst_pos2 = 2;
7214 dgst_pos3 = 1;
7215 break;
7216
7217 case 112: hash_type = HASH_TYPE_SHA1;
7218 salt_type = SALT_TYPE_INTERN;
7219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7220 opts_type = OPTS_TYPE_PT_GENERATE_BE
7221 | OPTS_TYPE_ST_ADD80
7222 | OPTS_TYPE_ST_ADDBITS15
7223 | OPTS_TYPE_ST_HEX;
7224 kern_type = KERN_TYPE_SHA1_PWSLT;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = oracles_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_PRECOMPUTE_MERKLE
7231 | OPTI_TYPE_EARLY_SKIP
7232 | OPTI_TYPE_NOT_ITERATED
7233 | OPTI_TYPE_APPENDED_SALT
7234 | OPTI_TYPE_RAW_HASH;
7235 dgst_pos0 = 3;
7236 dgst_pos1 = 4;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 120: hash_type = HASH_TYPE_SHA1;
7242 salt_type = SALT_TYPE_INTERN;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_BE
7245 | OPTS_TYPE_PT_ADD80
7246 | OPTS_TYPE_PT_ADDBITS15;
7247 kern_type = KERN_TYPE_SHA1_SLTPW;
7248 dgst_size = DGST_SIZE_4_5;
7249 parse_func = sha1s_parse_hash;
7250 sort_by_digest = sort_by_digest_4_5;
7251 opti_type = OPTI_TYPE_ZERO_BYTE
7252 | OPTI_TYPE_PRECOMPUTE_INIT
7253 | OPTI_TYPE_PRECOMPUTE_MERKLE
7254 | OPTI_TYPE_EARLY_SKIP
7255 | OPTI_TYPE_NOT_ITERATED
7256 | OPTI_TYPE_PREPENDED_SALT
7257 | OPTI_TYPE_RAW_HASH;
7258 dgst_pos0 = 3;
7259 dgst_pos1 = 4;
7260 dgst_pos2 = 2;
7261 dgst_pos3 = 1;
7262 break;
7263
7264 case 121: hash_type = HASH_TYPE_SHA1;
7265 salt_type = SALT_TYPE_INTERN;
7266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7267 opts_type = OPTS_TYPE_PT_GENERATE_BE
7268 | OPTS_TYPE_PT_ADD80
7269 | OPTS_TYPE_PT_ADDBITS15
7270 | OPTS_TYPE_ST_LOWER;
7271 kern_type = KERN_TYPE_SHA1_SLTPW;
7272 dgst_size = DGST_SIZE_4_5;
7273 parse_func = smf_parse_hash;
7274 sort_by_digest = sort_by_digest_4_5;
7275 opti_type = OPTI_TYPE_ZERO_BYTE
7276 | OPTI_TYPE_PRECOMPUTE_INIT
7277 | OPTI_TYPE_PRECOMPUTE_MERKLE
7278 | OPTI_TYPE_EARLY_SKIP
7279 | OPTI_TYPE_NOT_ITERATED
7280 | OPTI_TYPE_PREPENDED_SALT
7281 | OPTI_TYPE_RAW_HASH;
7282 dgst_pos0 = 3;
7283 dgst_pos1 = 4;
7284 dgst_pos2 = 2;
7285 dgst_pos3 = 1;
7286 break;
7287
7288 case 122: hash_type = HASH_TYPE_SHA1;
7289 salt_type = SALT_TYPE_EMBEDDED;
7290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7291 opts_type = OPTS_TYPE_PT_GENERATE_BE
7292 | OPTS_TYPE_PT_ADD80
7293 | OPTS_TYPE_PT_ADDBITS15
7294 | OPTS_TYPE_ST_HEX;
7295 kern_type = KERN_TYPE_SHA1_SLTPW;
7296 dgst_size = DGST_SIZE_4_5;
7297 parse_func = osx1_parse_hash;
7298 sort_by_digest = sort_by_digest_4_5;
7299 opti_type = OPTI_TYPE_ZERO_BYTE
7300 | OPTI_TYPE_PRECOMPUTE_INIT
7301 | OPTI_TYPE_PRECOMPUTE_MERKLE
7302 | OPTI_TYPE_EARLY_SKIP
7303 | OPTI_TYPE_NOT_ITERATED
7304 | OPTI_TYPE_PREPENDED_SALT
7305 | OPTI_TYPE_RAW_HASH;
7306 dgst_pos0 = 3;
7307 dgst_pos1 = 4;
7308 dgst_pos2 = 2;
7309 dgst_pos3 = 1;
7310 break;
7311
7312 case 124: hash_type = HASH_TYPE_SHA1;
7313 salt_type = SALT_TYPE_EMBEDDED;
7314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7315 opts_type = OPTS_TYPE_PT_GENERATE_BE
7316 | OPTS_TYPE_PT_ADD80
7317 | OPTS_TYPE_PT_ADDBITS15;
7318 kern_type = KERN_TYPE_SHA1_SLTPW;
7319 dgst_size = DGST_SIZE_4_5;
7320 parse_func = djangosha1_parse_hash;
7321 sort_by_digest = sort_by_digest_4_5;
7322 opti_type = OPTI_TYPE_ZERO_BYTE
7323 | OPTI_TYPE_PRECOMPUTE_INIT
7324 | OPTI_TYPE_PRECOMPUTE_MERKLE
7325 | OPTI_TYPE_EARLY_SKIP
7326 | OPTI_TYPE_NOT_ITERATED
7327 | OPTI_TYPE_PREPENDED_SALT
7328 | OPTI_TYPE_RAW_HASH;
7329 dgst_pos0 = 3;
7330 dgst_pos1 = 4;
7331 dgst_pos2 = 2;
7332 dgst_pos3 = 1;
7333 break;
7334
7335 case 130: hash_type = HASH_TYPE_SHA1;
7336 salt_type = SALT_TYPE_INTERN;
7337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7338 opts_type = OPTS_TYPE_PT_GENERATE_BE
7339 | OPTS_TYPE_PT_UNICODE
7340 | OPTS_TYPE_ST_ADD80
7341 | OPTS_TYPE_ST_ADDBITS15;
7342 kern_type = KERN_TYPE_SHA1_PWUSLT;
7343 dgst_size = DGST_SIZE_4_5;
7344 parse_func = sha1s_parse_hash;
7345 sort_by_digest = sort_by_digest_4_5;
7346 opti_type = OPTI_TYPE_ZERO_BYTE
7347 | OPTI_TYPE_PRECOMPUTE_INIT
7348 | OPTI_TYPE_PRECOMPUTE_MERKLE
7349 | OPTI_TYPE_EARLY_SKIP
7350 | OPTI_TYPE_NOT_ITERATED
7351 | OPTI_TYPE_APPENDED_SALT
7352 | OPTI_TYPE_RAW_HASH;
7353 dgst_pos0 = 3;
7354 dgst_pos1 = 4;
7355 dgst_pos2 = 2;
7356 dgst_pos3 = 1;
7357 break;
7358
7359 case 131: hash_type = HASH_TYPE_SHA1;
7360 salt_type = SALT_TYPE_EMBEDDED;
7361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7362 opts_type = OPTS_TYPE_PT_GENERATE_BE
7363 | OPTS_TYPE_PT_UNICODE
7364 | OPTS_TYPE_PT_UPPER
7365 | OPTS_TYPE_ST_ADD80
7366 | OPTS_TYPE_ST_ADDBITS15
7367 | OPTS_TYPE_ST_HEX;
7368 kern_type = KERN_TYPE_SHA1_PWUSLT;
7369 dgst_size = DGST_SIZE_4_5;
7370 parse_func = mssql2000_parse_hash;
7371 sort_by_digest = sort_by_digest_4_5;
7372 opti_type = OPTI_TYPE_ZERO_BYTE
7373 | OPTI_TYPE_PRECOMPUTE_INIT
7374 | OPTI_TYPE_PRECOMPUTE_MERKLE
7375 | OPTI_TYPE_EARLY_SKIP
7376 | OPTI_TYPE_NOT_ITERATED
7377 | OPTI_TYPE_APPENDED_SALT
7378 | OPTI_TYPE_RAW_HASH;
7379 dgst_pos0 = 3;
7380 dgst_pos1 = 4;
7381 dgst_pos2 = 2;
7382 dgst_pos3 = 1;
7383 break;
7384
7385 case 132: hash_type = HASH_TYPE_SHA1;
7386 salt_type = SALT_TYPE_EMBEDDED;
7387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7388 opts_type = OPTS_TYPE_PT_GENERATE_BE
7389 | OPTS_TYPE_PT_UNICODE
7390 | OPTS_TYPE_ST_ADD80
7391 | OPTS_TYPE_ST_ADDBITS15
7392 | OPTS_TYPE_ST_HEX;
7393 kern_type = KERN_TYPE_SHA1_PWUSLT;
7394 dgst_size = DGST_SIZE_4_5;
7395 parse_func = mssql2005_parse_hash;
7396 sort_by_digest = sort_by_digest_4_5;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_PRECOMPUTE_INIT
7399 | OPTI_TYPE_PRECOMPUTE_MERKLE
7400 | OPTI_TYPE_EARLY_SKIP
7401 | OPTI_TYPE_NOT_ITERATED
7402 | OPTI_TYPE_APPENDED_SALT
7403 | OPTI_TYPE_RAW_HASH;
7404 dgst_pos0 = 3;
7405 dgst_pos1 = 4;
7406 dgst_pos2 = 2;
7407 dgst_pos3 = 1;
7408 break;
7409
7410 case 133: hash_type = HASH_TYPE_SHA1;
7411 salt_type = SALT_TYPE_EMBEDDED;
7412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7413 opts_type = OPTS_TYPE_PT_GENERATE_BE
7414 | OPTS_TYPE_PT_UNICODE
7415 | OPTS_TYPE_ST_ADD80
7416 | OPTS_TYPE_ST_ADDBITS15;
7417 kern_type = KERN_TYPE_SHA1_PWUSLT;
7418 dgst_size = DGST_SIZE_4_5;
7419 parse_func = peoplesoft_parse_hash;
7420 sort_by_digest = sort_by_digest_4_5;
7421 opti_type = OPTI_TYPE_ZERO_BYTE
7422 | OPTI_TYPE_PRECOMPUTE_INIT
7423 | OPTI_TYPE_PRECOMPUTE_MERKLE
7424 | OPTI_TYPE_EARLY_SKIP
7425 | OPTI_TYPE_NOT_ITERATED
7426 | OPTI_TYPE_APPENDED_SALT
7427 | OPTI_TYPE_RAW_HASH;
7428 dgst_pos0 = 3;
7429 dgst_pos1 = 4;
7430 dgst_pos2 = 2;
7431 dgst_pos3 = 1;
7432 break;
7433
7434 case 140: hash_type = HASH_TYPE_SHA1;
7435 salt_type = SALT_TYPE_INTERN;
7436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7437 opts_type = OPTS_TYPE_PT_GENERATE_BE
7438 | OPTS_TYPE_PT_ADD80
7439 | OPTS_TYPE_PT_ADDBITS15
7440 | OPTS_TYPE_PT_UNICODE;
7441 kern_type = KERN_TYPE_SHA1_SLTPWU;
7442 dgst_size = DGST_SIZE_4_5;
7443 parse_func = sha1s_parse_hash;
7444 sort_by_digest = sort_by_digest_4_5;
7445 opti_type = OPTI_TYPE_ZERO_BYTE
7446 | OPTI_TYPE_PRECOMPUTE_INIT
7447 | OPTI_TYPE_PRECOMPUTE_MERKLE
7448 | OPTI_TYPE_EARLY_SKIP
7449 | OPTI_TYPE_NOT_ITERATED
7450 | OPTI_TYPE_PREPENDED_SALT
7451 | OPTI_TYPE_RAW_HASH;
7452 dgst_pos0 = 3;
7453 dgst_pos1 = 4;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 1;
7456 break;
7457
7458 case 141: hash_type = HASH_TYPE_SHA1;
7459 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_PT_UNICODE
7465 | OPTS_TYPE_ST_BASE64;
7466 kern_type = KERN_TYPE_SHA1_SLTPWU;
7467 dgst_size = DGST_SIZE_4_5;
7468 parse_func = episerver_parse_hash;
7469 sort_by_digest = sort_by_digest_4_5;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_PRECOMPUTE_INIT
7472 | OPTI_TYPE_PRECOMPUTE_MERKLE
7473 | OPTI_TYPE_EARLY_SKIP
7474 | OPTI_TYPE_NOT_ITERATED
7475 | OPTI_TYPE_PREPENDED_SALT
7476 | OPTI_TYPE_RAW_HASH;
7477 dgst_pos0 = 3;
7478 dgst_pos1 = 4;
7479 dgst_pos2 = 2;
7480 dgst_pos3 = 1;
7481 break;
7482
7483 case 150: hash_type = HASH_TYPE_SHA1;
7484 salt_type = SALT_TYPE_INTERN;
7485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7486 opts_type = OPTS_TYPE_PT_GENERATE_BE
7487 | OPTS_TYPE_ST_ADD80
7488 | OPTS_TYPE_ST_ADDBITS15;
7489 kern_type = KERN_TYPE_HMACSHA1_PW;
7490 dgst_size = DGST_SIZE_4_5;
7491 parse_func = hmacsha1_parse_hash;
7492 sort_by_digest = sort_by_digest_4_5;
7493 opti_type = OPTI_TYPE_ZERO_BYTE
7494 | OPTI_TYPE_NOT_ITERATED;
7495 dgst_pos0 = 3;
7496 dgst_pos1 = 4;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 1;
7499 break;
7500
7501 case 160: hash_type = HASH_TYPE_SHA1;
7502 salt_type = SALT_TYPE_INTERN;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_BE
7505 | OPTS_TYPE_PT_ADD80
7506 | OPTS_TYPE_PT_ADDBITS15;
7507 kern_type = KERN_TYPE_HMACSHA1_SLT;
7508 dgst_size = DGST_SIZE_4_5;
7509 parse_func = hmacsha1_parse_hash;
7510 sort_by_digest = sort_by_digest_4_5;
7511 opti_type = OPTI_TYPE_ZERO_BYTE
7512 | OPTI_TYPE_NOT_ITERATED;
7513 dgst_pos0 = 3;
7514 dgst_pos1 = 4;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 190: hash_type = HASH_TYPE_SHA1;
7520 salt_type = SALT_TYPE_NONE;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_BE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS15;
7525 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7526 dgst_size = DGST_SIZE_4_5;
7527 parse_func = sha1linkedin_parse_hash;
7528 sort_by_digest = sort_by_digest_4_5;
7529 opti_type = OPTI_TYPE_ZERO_BYTE
7530 | OPTI_TYPE_PRECOMPUTE_INIT
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_NOT_SALTED;
7534 dgst_pos0 = 0;
7535 dgst_pos1 = 4;
7536 dgst_pos2 = 3;
7537 dgst_pos3 = 2;
7538 break;
7539
7540 case 200: hash_type = HASH_TYPE_MYSQL;
7541 salt_type = SALT_TYPE_NONE;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = 0;
7544 kern_type = KERN_TYPE_MYSQL;
7545 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7546 parse_func = mysql323_parse_hash;
7547 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7548 opti_type = OPTI_TYPE_ZERO_BYTE;
7549 dgst_pos0 = 0;
7550 dgst_pos1 = 1;
7551 dgst_pos2 = 2;
7552 dgst_pos3 = 3;
7553 break;
7554
7555 case 300: hash_type = HASH_TYPE_SHA1;
7556 salt_type = SALT_TYPE_NONE;
7557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7558 opts_type = OPTS_TYPE_PT_GENERATE_BE
7559 | OPTS_TYPE_PT_ADD80
7560 | OPTS_TYPE_PT_ADDBITS15;
7561 kern_type = KERN_TYPE_MYSQL41;
7562 dgst_size = DGST_SIZE_4_5;
7563 parse_func = sha1_parse_hash;
7564 sort_by_digest = sort_by_digest_4_5;
7565 opti_type = OPTI_TYPE_ZERO_BYTE
7566 | OPTI_TYPE_PRECOMPUTE_INIT
7567 | OPTI_TYPE_PRECOMPUTE_MERKLE
7568 | OPTI_TYPE_EARLY_SKIP
7569 | OPTI_TYPE_NOT_ITERATED
7570 | OPTI_TYPE_NOT_SALTED;
7571 dgst_pos0 = 3;
7572 dgst_pos1 = 4;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 1;
7575 break;
7576
7577 case 400: hash_type = HASH_TYPE_MD5;
7578 salt_type = SALT_TYPE_EMBEDDED;
7579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7581 kern_type = KERN_TYPE_PHPASS;
7582 dgst_size = DGST_SIZE_4_4;
7583 parse_func = phpass_parse_hash;
7584 sort_by_digest = sort_by_digest_4_4;
7585 opti_type = OPTI_TYPE_ZERO_BYTE;
7586 dgst_pos0 = 0;
7587 dgst_pos1 = 1;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 3;
7590 break;
7591
7592 case 500: hash_type = HASH_TYPE_MD5;
7593 salt_type = SALT_TYPE_EMBEDDED;
7594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7596 kern_type = KERN_TYPE_MD5CRYPT;
7597 dgst_size = DGST_SIZE_4_4;
7598 parse_func = md5crypt_parse_hash;
7599 sort_by_digest = sort_by_digest_4_4;
7600 opti_type = OPTI_TYPE_ZERO_BYTE;
7601 dgst_pos0 = 0;
7602 dgst_pos1 = 1;
7603 dgst_pos2 = 2;
7604 dgst_pos3 = 3;
7605 break;
7606
7607 case 501: hash_type = HASH_TYPE_MD5;
7608 salt_type = SALT_TYPE_EMBEDDED;
7609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7610 opts_type = OPTS_TYPE_PT_GENERATE_LE
7611 | OPTS_TYPE_HASH_COPY;
7612 kern_type = KERN_TYPE_MD5CRYPT;
7613 dgst_size = DGST_SIZE_4_4;
7614 parse_func = juniper_parse_hash;
7615 sort_by_digest = sort_by_digest_4_4;
7616 opti_type = OPTI_TYPE_ZERO_BYTE;
7617 dgst_pos0 = 0;
7618 dgst_pos1 = 1;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 3;
7621 break;
7622
7623 case 900: hash_type = HASH_TYPE_MD4;
7624 salt_type = SALT_TYPE_NONE;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_LE
7627 | OPTS_TYPE_PT_ADD80
7628 | OPTS_TYPE_PT_ADDBITS14;
7629 kern_type = KERN_TYPE_MD4;
7630 dgst_size = DGST_SIZE_4_4;
7631 parse_func = md4_parse_hash;
7632 sort_by_digest = sort_by_digest_4_4;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_MEET_IN_MIDDLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_NOT_SALTED
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 0;
7642 dgst_pos1 = 3;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 1;
7645 break;
7646
7647 case 1000: hash_type = HASH_TYPE_MD4;
7648 salt_type = SALT_TYPE_NONE;
7649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_LE
7651 | OPTS_TYPE_PT_ADD80
7652 | OPTS_TYPE_PT_ADDBITS14
7653 | OPTS_TYPE_PT_UNICODE;
7654 kern_type = KERN_TYPE_MD4_PWU;
7655 dgst_size = DGST_SIZE_4_4;
7656 parse_func = md4_parse_hash;
7657 sort_by_digest = sort_by_digest_4_4;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_MEET_IN_MIDDLE
7662 | OPTI_TYPE_EARLY_SKIP
7663 | OPTI_TYPE_NOT_ITERATED
7664 | OPTI_TYPE_NOT_SALTED
7665 | OPTI_TYPE_RAW_HASH;
7666 dgst_pos0 = 0;
7667 dgst_pos1 = 3;
7668 dgst_pos2 = 2;
7669 dgst_pos3 = 1;
7670 break;
7671
7672 case 1100: hash_type = HASH_TYPE_MD4;
7673 salt_type = SALT_TYPE_INTERN;
7674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7675 opts_type = OPTS_TYPE_PT_GENERATE_LE
7676 | OPTS_TYPE_PT_ADD80
7677 | OPTS_TYPE_PT_ADDBITS14
7678 | OPTS_TYPE_PT_UNICODE
7679 | OPTS_TYPE_ST_ADD80
7680 | OPTS_TYPE_ST_UNICODE
7681 | OPTS_TYPE_ST_LOWER;
7682 kern_type = KERN_TYPE_MD44_PWUSLT;
7683 dgst_size = DGST_SIZE_4_4;
7684 parse_func = dcc_parse_hash;
7685 sort_by_digest = sort_by_digest_4_4;
7686 opti_type = OPTI_TYPE_ZERO_BYTE
7687 | OPTI_TYPE_PRECOMPUTE_INIT
7688 | OPTI_TYPE_PRECOMPUTE_MERKLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED;
7691 dgst_pos0 = 0;
7692 dgst_pos1 = 3;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 1;
7695 break;
7696
7697 case 1400: hash_type = HASH_TYPE_SHA256;
7698 salt_type = SALT_TYPE_NONE;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_PT_ADD80
7702 | OPTS_TYPE_PT_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA256;
7704 dgst_size = DGST_SIZE_4_8;
7705 parse_func = sha256_parse_hash;
7706 sort_by_digest = sort_by_digest_4_8;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_NOT_SALTED
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 3;
7715 dgst_pos1 = 7;
7716 dgst_pos2 = 2;
7717 dgst_pos3 = 6;
7718 break;
7719
7720 case 1410: hash_type = HASH_TYPE_SHA256;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_ST_ADD80
7725 | OPTS_TYPE_ST_ADDBITS15;
7726 kern_type = KERN_TYPE_SHA256_PWSLT;
7727 dgst_size = DGST_SIZE_4_8;
7728 parse_func = sha256s_parse_hash;
7729 sort_by_digest = sort_by_digest_4_8;
7730 opti_type = OPTI_TYPE_ZERO_BYTE
7731 | OPTI_TYPE_PRECOMPUTE_INIT
7732 | OPTI_TYPE_PRECOMPUTE_MERKLE
7733 | OPTI_TYPE_EARLY_SKIP
7734 | OPTI_TYPE_NOT_ITERATED
7735 | OPTI_TYPE_APPENDED_SALT
7736 | OPTI_TYPE_RAW_HASH;
7737 dgst_pos0 = 3;
7738 dgst_pos1 = 7;
7739 dgst_pos2 = 2;
7740 dgst_pos3 = 6;
7741 break;
7742
7743 case 1420: hash_type = HASH_TYPE_SHA256;
7744 salt_type = SALT_TYPE_INTERN;
7745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7746 opts_type = OPTS_TYPE_PT_GENERATE_BE
7747 | OPTS_TYPE_PT_ADD80
7748 | OPTS_TYPE_PT_ADDBITS15;
7749 kern_type = KERN_TYPE_SHA256_SLTPW;
7750 dgst_size = DGST_SIZE_4_8;
7751 parse_func = sha256s_parse_hash;
7752 sort_by_digest = sort_by_digest_4_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 3;
7761 dgst_pos1 = 7;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 6;
7764 break;
7765
7766 case 1421: hash_type = HASH_TYPE_SHA256;
7767 salt_type = SALT_TYPE_EMBEDDED;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_ADD80
7771 | OPTS_TYPE_PT_ADDBITS15;
7772 kern_type = KERN_TYPE_SHA256_SLTPW;
7773 dgst_size = DGST_SIZE_4_8;
7774 parse_func = hmailserver_parse_hash;
7775 sort_by_digest = sort_by_digest_4_8;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_PREPENDED_SALT
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 7;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 6;
7787 break;
7788
7789 case 1430: hash_type = HASH_TYPE_SHA256;
7790 salt_type = SALT_TYPE_INTERN;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_PT_UNICODE
7794 | OPTS_TYPE_ST_ADD80
7795 | OPTS_TYPE_ST_ADDBITS15;
7796 kern_type = KERN_TYPE_SHA256_PWUSLT;
7797 dgst_size = DGST_SIZE_4_8;
7798 parse_func = sha256s_parse_hash;
7799 sort_by_digest = sort_by_digest_4_8;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_APPENDED_SALT
7806 | OPTI_TYPE_RAW_HASH;
7807 dgst_pos0 = 3;
7808 dgst_pos1 = 7;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 6;
7811 break;
7812
7813 case 1440: hash_type = HASH_TYPE_SHA256;
7814 salt_type = SALT_TYPE_INTERN;
7815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_BE
7817 | OPTS_TYPE_PT_ADD80
7818 | OPTS_TYPE_PT_ADDBITS15
7819 | OPTS_TYPE_PT_UNICODE;
7820 kern_type = KERN_TYPE_SHA256_SLTPWU;
7821 dgst_size = DGST_SIZE_4_8;
7822 parse_func = sha256s_parse_hash;
7823 sort_by_digest = sort_by_digest_4_8;
7824 opti_type = OPTI_TYPE_ZERO_BYTE
7825 | OPTI_TYPE_PRECOMPUTE_INIT
7826 | OPTI_TYPE_PRECOMPUTE_MERKLE
7827 | OPTI_TYPE_EARLY_SKIP
7828 | OPTI_TYPE_NOT_ITERATED
7829 | OPTI_TYPE_PREPENDED_SALT
7830 | OPTI_TYPE_RAW_HASH;
7831 dgst_pos0 = 3;
7832 dgst_pos1 = 7;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 6;
7835 break;
7836
7837 case 1441: hash_type = HASH_TYPE_SHA256;
7838 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_PT_UNICODE
7844 | OPTS_TYPE_ST_BASE64;
7845 kern_type = KERN_TYPE_SHA256_SLTPWU;
7846 dgst_size = DGST_SIZE_4_8;
7847 parse_func = episerver4_parse_hash;
7848 sort_by_digest = sort_by_digest_4_8;
7849 opti_type = OPTI_TYPE_ZERO_BYTE
7850 | OPTI_TYPE_PRECOMPUTE_INIT
7851 | OPTI_TYPE_PRECOMPUTE_MERKLE
7852 | OPTI_TYPE_EARLY_SKIP
7853 | OPTI_TYPE_NOT_ITERATED
7854 | OPTI_TYPE_PREPENDED_SALT
7855 | OPTI_TYPE_RAW_HASH;
7856 dgst_pos0 = 3;
7857 dgst_pos1 = 7;
7858 dgst_pos2 = 2;
7859 dgst_pos3 = 6;
7860 break;
7861
7862 case 1450: hash_type = HASH_TYPE_SHA256;
7863 salt_type = SALT_TYPE_INTERN;
7864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865 opts_type = OPTS_TYPE_PT_GENERATE_BE
7866 | OPTS_TYPE_ST_ADD80;
7867 kern_type = KERN_TYPE_HMACSHA256_PW;
7868 dgst_size = DGST_SIZE_4_8;
7869 parse_func = hmacsha256_parse_hash;
7870 sort_by_digest = sort_by_digest_4_8;
7871 opti_type = OPTI_TYPE_ZERO_BYTE
7872 | OPTI_TYPE_NOT_ITERATED;
7873 dgst_pos0 = 3;
7874 dgst_pos1 = 7;
7875 dgst_pos2 = 2;
7876 dgst_pos3 = 6;
7877 break;
7878
7879 case 1460: hash_type = HASH_TYPE_SHA256;
7880 salt_type = SALT_TYPE_INTERN;
7881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7882 opts_type = OPTS_TYPE_PT_GENERATE_BE
7883 | OPTS_TYPE_PT_ADD80
7884 | OPTS_TYPE_PT_ADDBITS15;
7885 kern_type = KERN_TYPE_HMACSHA256_SLT;
7886 dgst_size = DGST_SIZE_4_8;
7887 parse_func = hmacsha256_parse_hash;
7888 sort_by_digest = sort_by_digest_4_8;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_NOT_ITERATED;
7891 dgst_pos0 = 3;
7892 dgst_pos1 = 7;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 6;
7895 break;
7896
7897 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7898 salt_type = SALT_TYPE_EMBEDDED;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_LE
7901 | OPTS_TYPE_PT_BITSLICE;
7902 kern_type = KERN_TYPE_DESCRYPT;
7903 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7904 parse_func = descrypt_parse_hash;
7905 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7908 dgst_pos0 = 0;
7909 dgst_pos1 = 1;
7910 dgst_pos2 = 2;
7911 dgst_pos3 = 3;
7912 break;
7913
7914 case 1600: hash_type = HASH_TYPE_MD5;
7915 salt_type = SALT_TYPE_EMBEDDED;
7916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7918 kern_type = KERN_TYPE_APR1CRYPT;
7919 dgst_size = DGST_SIZE_4_4;
7920 parse_func = md5apr1_parse_hash;
7921 sort_by_digest = sort_by_digest_4_4;
7922 opti_type = OPTI_TYPE_ZERO_BYTE;
7923 dgst_pos0 = 0;
7924 dgst_pos1 = 1;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 3;
7927 break;
7928
7929 case 1700: hash_type = HASH_TYPE_SHA512;
7930 salt_type = SALT_TYPE_NONE;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS15;
7935 kern_type = KERN_TYPE_SHA512;
7936 dgst_size = DGST_SIZE_8_8;
7937 parse_func = sha512_parse_hash;
7938 sort_by_digest = sort_by_digest_8_8;
7939 opti_type = OPTI_TYPE_ZERO_BYTE
7940 | OPTI_TYPE_PRECOMPUTE_INIT
7941 | OPTI_TYPE_PRECOMPUTE_MERKLE
7942 | OPTI_TYPE_EARLY_SKIP
7943 | OPTI_TYPE_NOT_ITERATED
7944 | OPTI_TYPE_NOT_SALTED
7945 | OPTI_TYPE_USES_BITS_64
7946 | OPTI_TYPE_RAW_HASH;
7947 dgst_pos0 = 14;
7948 dgst_pos1 = 15;
7949 dgst_pos2 = 6;
7950 dgst_pos3 = 7;
7951 break;
7952
7953 case 1710: hash_type = HASH_TYPE_SHA512;
7954 salt_type = SALT_TYPE_INTERN;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_ST_ADD80
7958 | OPTS_TYPE_ST_ADDBITS15;
7959 kern_type = KERN_TYPE_SHA512_PWSLT;
7960 dgst_size = DGST_SIZE_8_8;
7961 parse_func = sha512s_parse_hash;
7962 sort_by_digest = sort_by_digest_8_8;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_APPENDED_SALT
7969 | OPTI_TYPE_USES_BITS_64
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 14;
7972 dgst_pos1 = 15;
7973 dgst_pos2 = 6;
7974 dgst_pos3 = 7;
7975 break;
7976
7977 case 1711: hash_type = HASH_TYPE_SHA512;
7978 salt_type = SALT_TYPE_EMBEDDED;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_ST_ADD80
7982 | OPTS_TYPE_ST_ADDBITS15;
7983 kern_type = KERN_TYPE_SHA512_PWSLT;
7984 dgst_size = DGST_SIZE_8_8;
7985 parse_func = sha512b64s_parse_hash;
7986 sort_by_digest = sort_by_digest_8_8;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_APPENDED_SALT
7993 | OPTI_TYPE_USES_BITS_64
7994 | OPTI_TYPE_RAW_HASH;
7995 dgst_pos0 = 14;
7996 dgst_pos1 = 15;
7997 dgst_pos2 = 6;
7998 dgst_pos3 = 7;
7999 break;
8000
8001 case 1720: hash_type = HASH_TYPE_SHA512;
8002 salt_type = SALT_TYPE_INTERN;
8003 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8004 opts_type = OPTS_TYPE_PT_GENERATE_BE
8005 | OPTS_TYPE_PT_ADD80
8006 | OPTS_TYPE_PT_ADDBITS15;
8007 kern_type = KERN_TYPE_SHA512_SLTPW;
8008 dgst_size = DGST_SIZE_8_8;
8009 parse_func = sha512s_parse_hash;
8010 sort_by_digest = sort_by_digest_8_8;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_PREPENDED_SALT
8017 | OPTI_TYPE_USES_BITS_64
8018 | OPTI_TYPE_RAW_HASH;
8019 dgst_pos0 = 14;
8020 dgst_pos1 = 15;
8021 dgst_pos2 = 6;
8022 dgst_pos3 = 7;
8023 break;
8024
8025 case 1722: hash_type = HASH_TYPE_SHA512;
8026 salt_type = SALT_TYPE_EMBEDDED;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_BE
8029 | OPTS_TYPE_PT_ADD80
8030 | OPTS_TYPE_PT_ADDBITS15
8031 | OPTS_TYPE_ST_HEX;
8032 kern_type = KERN_TYPE_SHA512_SLTPW;
8033 dgst_size = DGST_SIZE_8_8;
8034 parse_func = osx512_parse_hash;
8035 sort_by_digest = sort_by_digest_8_8;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_INIT
8038 | OPTI_TYPE_PRECOMPUTE_MERKLE
8039 | OPTI_TYPE_EARLY_SKIP
8040 | OPTI_TYPE_NOT_ITERATED
8041 | OPTI_TYPE_PREPENDED_SALT
8042 | OPTI_TYPE_USES_BITS_64
8043 | OPTI_TYPE_RAW_HASH;
8044 dgst_pos0 = 14;
8045 dgst_pos1 = 15;
8046 dgst_pos2 = 6;
8047 dgst_pos3 = 7;
8048 break;
8049
8050 case 1730: hash_type = HASH_TYPE_SHA512;
8051 salt_type = SALT_TYPE_INTERN;
8052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8053 opts_type = OPTS_TYPE_PT_GENERATE_BE
8054 | OPTS_TYPE_PT_UNICODE
8055 | OPTS_TYPE_ST_ADD80
8056 | OPTS_TYPE_ST_ADDBITS15;
8057 kern_type = KERN_TYPE_SHA512_PWSLTU;
8058 dgst_size = DGST_SIZE_8_8;
8059 parse_func = sha512s_parse_hash;
8060 sort_by_digest = sort_by_digest_8_8;
8061 opti_type = OPTI_TYPE_ZERO_BYTE
8062 | OPTI_TYPE_PRECOMPUTE_INIT
8063 | OPTI_TYPE_PRECOMPUTE_MERKLE
8064 | OPTI_TYPE_EARLY_SKIP
8065 | OPTI_TYPE_NOT_ITERATED
8066 | OPTI_TYPE_APPENDED_SALT
8067 | OPTI_TYPE_USES_BITS_64
8068 | OPTI_TYPE_RAW_HASH;
8069 dgst_pos0 = 14;
8070 dgst_pos1 = 15;
8071 dgst_pos2 = 6;
8072 dgst_pos3 = 7;
8073 break;
8074
8075 case 1731: hash_type = HASH_TYPE_SHA512;
8076 salt_type = SALT_TYPE_EMBEDDED;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_BE
8079 | OPTS_TYPE_PT_UNICODE
8080 | OPTS_TYPE_ST_ADD80
8081 | OPTS_TYPE_ST_ADDBITS15
8082 | OPTS_TYPE_ST_HEX;
8083 kern_type = KERN_TYPE_SHA512_PWSLTU;
8084 dgst_size = DGST_SIZE_8_8;
8085 parse_func = mssql2012_parse_hash;
8086 sort_by_digest = sort_by_digest_8_8;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP
8091 | OPTI_TYPE_NOT_ITERATED
8092 | OPTI_TYPE_APPENDED_SALT
8093 | OPTI_TYPE_USES_BITS_64
8094 | OPTI_TYPE_RAW_HASH;
8095 dgst_pos0 = 14;
8096 dgst_pos1 = 15;
8097 dgst_pos2 = 6;
8098 dgst_pos3 = 7;
8099 break;
8100
8101 case 1740: hash_type = HASH_TYPE_SHA512;
8102 salt_type = SALT_TYPE_INTERN;
8103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_PT_ADD80
8106 | OPTS_TYPE_PT_ADDBITS15
8107 | OPTS_TYPE_PT_UNICODE;
8108 kern_type = KERN_TYPE_SHA512_SLTPWU;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = sha512s_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_INIT
8114 | OPTI_TYPE_PRECOMPUTE_MERKLE
8115 | OPTI_TYPE_EARLY_SKIP
8116 | OPTI_TYPE_NOT_ITERATED
8117 | OPTI_TYPE_PREPENDED_SALT
8118 | OPTI_TYPE_USES_BITS_64
8119 | OPTI_TYPE_RAW_HASH;
8120 dgst_pos0 = 14;
8121 dgst_pos1 = 15;
8122 dgst_pos2 = 6;
8123 dgst_pos3 = 7;
8124 break;
8125
8126 case 1750: hash_type = HASH_TYPE_SHA512;
8127 salt_type = SALT_TYPE_INTERN;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_BE
8130 | OPTS_TYPE_ST_ADD80;
8131 kern_type = KERN_TYPE_HMACSHA512_PW;
8132 dgst_size = DGST_SIZE_8_8;
8133 parse_func = hmacsha512_parse_hash;
8134 sort_by_digest = sort_by_digest_8_8;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_USES_BITS_64
8137 | OPTI_TYPE_NOT_ITERATED;
8138 dgst_pos0 = 14;
8139 dgst_pos1 = 15;
8140 dgst_pos2 = 6;
8141 dgst_pos3 = 7;
8142 break;
8143
8144 case 1760: hash_type = HASH_TYPE_SHA512;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_BE
8148 | OPTS_TYPE_PT_ADD80
8149 | OPTS_TYPE_PT_ADDBITS15;
8150 kern_type = KERN_TYPE_HMACSHA512_SLT;
8151 dgst_size = DGST_SIZE_8_8;
8152 parse_func = hmacsha512_parse_hash;
8153 sort_by_digest = sort_by_digest_8_8;
8154 opti_type = OPTI_TYPE_ZERO_BYTE
8155 | OPTI_TYPE_USES_BITS_64
8156 | OPTI_TYPE_NOT_ITERATED;
8157 dgst_pos0 = 14;
8158 dgst_pos1 = 15;
8159 dgst_pos2 = 6;
8160 dgst_pos3 = 7;
8161 break;
8162
8163 case 1800: hash_type = HASH_TYPE_SHA512;
8164 salt_type = SALT_TYPE_EMBEDDED;
8165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8167 kern_type = KERN_TYPE_SHA512CRYPT;
8168 dgst_size = DGST_SIZE_8_8;
8169 parse_func = sha512crypt_parse_hash;
8170 sort_by_digest = sort_by_digest_8_8;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_USES_BITS_64;
8173 dgst_pos0 = 0;
8174 dgst_pos1 = 1;
8175 dgst_pos2 = 2;
8176 dgst_pos3 = 3;
8177 break;
8178
8179 case 2100: hash_type = HASH_TYPE_DCC2;
8180 salt_type = SALT_TYPE_EMBEDDED;
8181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8183 | OPTS_TYPE_ST_LOWER
8184 | OPTS_TYPE_ST_UNICODE;
8185 kern_type = KERN_TYPE_DCC2;
8186 dgst_size = DGST_SIZE_4_4;
8187 parse_func = dcc2_parse_hash;
8188 sort_by_digest = sort_by_digest_4_4;
8189 opti_type = OPTI_TYPE_ZERO_BYTE;
8190 dgst_pos0 = 0;
8191 dgst_pos1 = 1;
8192 dgst_pos2 = 2;
8193 dgst_pos3 = 3;
8194 break;
8195
8196 case 2400: hash_type = HASH_TYPE_MD5;
8197 salt_type = SALT_TYPE_NONE;
8198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8200 kern_type = KERN_TYPE_MD5PIX;
8201 dgst_size = DGST_SIZE_4_4;
8202 parse_func = md5pix_parse_hash;
8203 sort_by_digest = sort_by_digest_4_4;
8204 opti_type = OPTI_TYPE_ZERO_BYTE
8205 | OPTI_TYPE_PRECOMPUTE_INIT
8206 | OPTI_TYPE_PRECOMPUTE_MERKLE
8207 | OPTI_TYPE_EARLY_SKIP
8208 | OPTI_TYPE_NOT_ITERATED
8209 | OPTI_TYPE_NOT_SALTED;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 3;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 1;
8214 break;
8215
8216 case 2410: hash_type = HASH_TYPE_MD5;
8217 salt_type = SALT_TYPE_INTERN;
8218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8220 kern_type = KERN_TYPE_MD5ASA;
8221 dgst_size = DGST_SIZE_4_4;
8222 parse_func = md5asa_parse_hash;
8223 sort_by_digest = sort_by_digest_4_4;
8224 opti_type = OPTI_TYPE_ZERO_BYTE
8225 | OPTI_TYPE_PRECOMPUTE_INIT
8226 | OPTI_TYPE_PRECOMPUTE_MERKLE
8227 | OPTI_TYPE_EARLY_SKIP
8228 | OPTI_TYPE_NOT_ITERATED;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 3;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 1;
8233 break;
8234
8235 case 2500: hash_type = HASH_TYPE_WPA;
8236 salt_type = SALT_TYPE_EMBEDDED;
8237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8239 kern_type = KERN_TYPE_WPA;
8240 dgst_size = DGST_SIZE_4_4;
8241 parse_func = wpa_parse_hash;
8242 sort_by_digest = sort_by_digest_4_4;
8243 opti_type = OPTI_TYPE_ZERO_BYTE;
8244 dgst_pos0 = 0;
8245 dgst_pos1 = 1;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 3;
8248 break;
8249
8250 case 2600: hash_type = HASH_TYPE_MD5;
8251 salt_type = SALT_TYPE_VIRTUAL;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_LE
8254 | OPTS_TYPE_PT_ADD80
8255 | OPTS_TYPE_PT_ADDBITS14
8256 | OPTS_TYPE_ST_ADD80;
8257 kern_type = KERN_TYPE_MD55_PWSLT1;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5md5_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP;
8265 dgst_pos0 = 0;
8266 dgst_pos1 = 3;
8267 dgst_pos2 = 2;
8268 dgst_pos3 = 1;
8269 break;
8270
8271 case 2611: hash_type = HASH_TYPE_MD5;
8272 salt_type = SALT_TYPE_INTERN;
8273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8274 opts_type = OPTS_TYPE_PT_GENERATE_LE
8275 | OPTS_TYPE_PT_ADD80
8276 | OPTS_TYPE_PT_ADDBITS14
8277 | OPTS_TYPE_ST_ADD80;
8278 kern_type = KERN_TYPE_MD55_PWSLT1;
8279 dgst_size = DGST_SIZE_4_4;
8280 parse_func = vb3_parse_hash;
8281 sort_by_digest = sort_by_digest_4_4;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_PRECOMPUTE_INIT
8284 | OPTI_TYPE_PRECOMPUTE_MERKLE
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 2612: hash_type = HASH_TYPE_MD5;
8293 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_ADD80
8299 | OPTS_TYPE_ST_HEX;
8300 kern_type = KERN_TYPE_MD55_PWSLT1;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = phps_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 3;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 1;
8312 break;
8313
8314 case 2711: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_ST_ADD80;
8321 kern_type = KERN_TYPE_MD55_PWSLT2;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = vb30_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_EARLY_SKIP;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 2811: hash_type = HASH_TYPE_MD5;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_LE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS14;
8340 kern_type = KERN_TYPE_MD55_SLTPW;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = ipb2_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_EARLY_SKIP;
8347 dgst_pos0 = 0;
8348 dgst_pos1 = 3;
8349 dgst_pos2 = 2;
8350 dgst_pos3 = 1;
8351 break;
8352
8353 case 3000: hash_type = HASH_TYPE_LM;
8354 salt_type = SALT_TYPE_NONE;
8355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8356 opts_type = OPTS_TYPE_PT_GENERATE_LE
8357 | OPTS_TYPE_PT_UPPER
8358 | OPTS_TYPE_PT_BITSLICE;
8359 kern_type = KERN_TYPE_LM;
8360 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8361 parse_func = lm_parse_hash;
8362 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8363 opti_type = OPTI_TYPE_ZERO_BYTE
8364 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 1;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 3;
8369 break;
8370
8371 case 3100: hash_type = HASH_TYPE_ORACLEH;
8372 salt_type = SALT_TYPE_INTERN;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE
8375 | OPTS_TYPE_PT_UPPER
8376 | OPTS_TYPE_ST_UPPER;
8377 kern_type = KERN_TYPE_ORACLEH;
8378 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8379 parse_func = oracleh_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8381 opti_type = OPTI_TYPE_ZERO_BYTE;
8382 dgst_pos0 = 0;
8383 dgst_pos1 = 1;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 3;
8386 break;
8387
8388 case 3200: hash_type = HASH_TYPE_BCRYPT;
8389 salt_type = SALT_TYPE_EMBEDDED;
8390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_LE
8392 | OPTS_TYPE_ST_GENERATE_LE;
8393 kern_type = KERN_TYPE_BCRYPT;
8394 dgst_size = DGST_SIZE_4_6;
8395 parse_func = bcrypt_parse_hash;
8396 sort_by_digest = sort_by_digest_4_6;
8397 opti_type = OPTI_TYPE_ZERO_BYTE;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 1;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 3;
8402 break;
8403
8404 case 3710: hash_type = HASH_TYPE_MD5;
8405 salt_type = SALT_TYPE_INTERN;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE
8408 | OPTS_TYPE_PT_ADD80
8409 | OPTS_TYPE_PT_ADDBITS14;
8410 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8411 dgst_size = DGST_SIZE_4_4;
8412 parse_func = md5s_parse_hash;
8413 sort_by_digest = sort_by_digest_4_4;
8414 opti_type = OPTI_TYPE_ZERO_BYTE
8415 | OPTI_TYPE_PRECOMPUTE_INIT
8416 | OPTI_TYPE_PRECOMPUTE_MERKLE
8417 | OPTI_TYPE_EARLY_SKIP;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 3;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 1;
8422 break;
8423
8424 case 3711: hash_type = HASH_TYPE_MD5;
8425 salt_type = SALT_TYPE_EMBEDDED;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_ADD80
8429 | OPTS_TYPE_PT_ADDBITS14;
8430 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8431 dgst_size = DGST_SIZE_4_4;
8432 parse_func = mediawiki_b_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4;
8434 opti_type = OPTI_TYPE_ZERO_BYTE
8435 | OPTI_TYPE_PRECOMPUTE_INIT
8436 | OPTI_TYPE_PRECOMPUTE_MERKLE
8437 | OPTI_TYPE_EARLY_SKIP;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 3800: hash_type = HASH_TYPE_MD5;
8445 salt_type = SALT_TYPE_INTERN;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE
8448 | OPTS_TYPE_ST_ADDBITS14;
8449 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8450 dgst_size = DGST_SIZE_4_4;
8451 parse_func = md5s_parse_hash;
8452 sort_by_digest = sort_by_digest_4_4;
8453 opti_type = OPTI_TYPE_ZERO_BYTE
8454 | OPTI_TYPE_PRECOMPUTE_INIT
8455 | OPTI_TYPE_PRECOMPUTE_MERKLE
8456 | OPTI_TYPE_EARLY_SKIP
8457 | OPTI_TYPE_NOT_ITERATED
8458 | OPTI_TYPE_RAW_HASH;
8459 dgst_pos0 = 0;
8460 dgst_pos1 = 3;
8461 dgst_pos2 = 2;
8462 dgst_pos3 = 1;
8463 break;
8464
8465 case 4300: hash_type = HASH_TYPE_MD5;
8466 salt_type = SALT_TYPE_VIRTUAL;
8467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8468 opts_type = OPTS_TYPE_PT_GENERATE_LE
8469 | OPTS_TYPE_PT_ADD80
8470 | OPTS_TYPE_PT_ADDBITS14
8471 | OPTS_TYPE_ST_ADD80;
8472 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8473 dgst_size = DGST_SIZE_4_4;
8474 parse_func = md5md5_parse_hash;
8475 sort_by_digest = sort_by_digest_4_4;
8476 opti_type = OPTI_TYPE_ZERO_BYTE
8477 | OPTI_TYPE_PRECOMPUTE_INIT
8478 | OPTI_TYPE_PRECOMPUTE_MERKLE
8479 | OPTI_TYPE_EARLY_SKIP;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 3;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486
8487 case 4400: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_NONE;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_MD5_SHA1;
8494 dgst_size = DGST_SIZE_4_4;
8495 parse_func = md5_parse_hash;
8496 sort_by_digest = sort_by_digest_4_4;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_ITERATED
8502 | OPTI_TYPE_NOT_SALTED
8503 | OPTI_TYPE_RAW_HASH;
8504 dgst_pos0 = 0;
8505 dgst_pos1 = 3;
8506 dgst_pos2 = 2;
8507 dgst_pos3 = 1;
8508 break;
8509
8510 case 4500: hash_type = HASH_TYPE_SHA1;
8511 salt_type = SALT_TYPE_NONE;
8512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8513 opts_type = OPTS_TYPE_PT_GENERATE_BE
8514 | OPTS_TYPE_PT_ADD80
8515 | OPTS_TYPE_PT_ADDBITS15;
8516 kern_type = KERN_TYPE_SHA11;
8517 dgst_size = DGST_SIZE_4_5;
8518 parse_func = sha1_parse_hash;
8519 sort_by_digest = sort_by_digest_4_5;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP
8524 | OPTI_TYPE_NOT_SALTED;
8525 dgst_pos0 = 3;
8526 dgst_pos1 = 4;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 1;
8529 break;
8530
8531 case 4700: hash_type = HASH_TYPE_SHA1;
8532 salt_type = SALT_TYPE_NONE;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE
8535 | OPTS_TYPE_PT_ADD80
8536 | OPTS_TYPE_PT_ADDBITS14;
8537 kern_type = KERN_TYPE_SHA1_MD5;
8538 dgst_size = DGST_SIZE_4_5;
8539 parse_func = sha1_parse_hash;
8540 sort_by_digest = sort_by_digest_4_5;
8541 opti_type = OPTI_TYPE_ZERO_BYTE
8542 | OPTI_TYPE_PRECOMPUTE_INIT
8543 | OPTI_TYPE_PRECOMPUTE_MERKLE
8544 | OPTI_TYPE_EARLY_SKIP
8545 | OPTI_TYPE_NOT_ITERATED
8546 | OPTI_TYPE_NOT_SALTED
8547 | OPTI_TYPE_RAW_HASH;
8548 dgst_pos0 = 3;
8549 dgst_pos1 = 4;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 1;
8552 break;
8553
8554 case 4800: hash_type = HASH_TYPE_MD5;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE
8558 | OPTS_TYPE_PT_ADDBITS14;
8559 kern_type = KERN_TYPE_MD5_CHAP;
8560 dgst_size = DGST_SIZE_4_4;
8561 parse_func = chap_parse_hash;
8562 sort_by_digest = sort_by_digest_4_4;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_MEET_IN_MIDDLE
8567 | OPTI_TYPE_EARLY_SKIP
8568 | OPTI_TYPE_NOT_ITERATED
8569 | OPTI_TYPE_RAW_HASH;
8570 dgst_pos0 = 0;
8571 dgst_pos1 = 3;
8572 dgst_pos2 = 2;
8573 dgst_pos3 = 1;
8574 break;
8575
8576 case 4900: hash_type = HASH_TYPE_SHA1;
8577 salt_type = SALT_TYPE_INTERN;
8578 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8580 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = sha1s_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP;
8588 dgst_pos0 = 3;
8589 dgst_pos1 = 4;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 5000: hash_type = HASH_TYPE_KECCAK;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_PT_ADD01;
8599 kern_type = KERN_TYPE_KECCAK;
8600 dgst_size = DGST_SIZE_8_25;
8601 parse_func = keccak_parse_hash;
8602 sort_by_digest = sort_by_digest_8_25;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_USES_BITS_64
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 2;
8607 dgst_pos1 = 3;
8608 dgst_pos2 = 4;
8609 dgst_pos3 = 5;
8610 break;
8611
8612 case 5100: hash_type = HASH_TYPE_MD5H;
8613 salt_type = SALT_TYPE_NONE;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS14;
8618 kern_type = KERN_TYPE_MD5H;
8619 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8620 parse_func = md5half_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_RAW_HASH;
8624 dgst_pos0 = 0;
8625 dgst_pos1 = 1;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 3;
8628 break;
8629
8630 case 5200: hash_type = HASH_TYPE_SHA256;
8631 salt_type = SALT_TYPE_EMBEDDED;
8632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8634 kern_type = KERN_TYPE_PSAFE3;
8635 dgst_size = DGST_SIZE_4_8;
8636 parse_func = psafe3_parse_hash;
8637 sort_by_digest = sort_by_digest_4_8;
8638 opti_type = OPTI_TYPE_ZERO_BYTE;
8639 dgst_pos0 = 0;
8640 dgst_pos1 = 1;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 3;
8643 break;
8644
8645 case 5300: hash_type = HASH_TYPE_MD5;
8646 salt_type = SALT_TYPE_EMBEDDED;
8647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE
8649 | OPTS_TYPE_ST_ADD80;
8650 kern_type = KERN_TYPE_IKEPSK_MD5;
8651 dgst_size = DGST_SIZE_4_4;
8652 parse_func = ikepsk_md5_parse_hash;
8653 sort_by_digest = sort_by_digest_4_4;
8654 opti_type = OPTI_TYPE_ZERO_BYTE;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 3;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 1;
8659 break;
8660
8661 case 5400: hash_type = HASH_TYPE_SHA1;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_BE
8665 | OPTS_TYPE_ST_ADD80;
8666 kern_type = KERN_TYPE_IKEPSK_SHA1;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = ikepsk_sha1_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 3;
8672 dgst_pos1 = 4;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 1;
8675 break;
8676
8677 case 5500: hash_type = HASH_TYPE_NETNTLM;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE
8681 | OPTS_TYPE_PT_ADD80
8682 | OPTS_TYPE_PT_ADDBITS14
8683 | OPTS_TYPE_PT_UNICODE
8684 | OPTS_TYPE_ST_HEX;
8685 kern_type = KERN_TYPE_NETNTLMv1;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = netntlmv1_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 1;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 3;
8695 break;
8696
8697 case 5600: hash_type = HASH_TYPE_MD5;
8698 salt_type = SALT_TYPE_EMBEDDED;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS14
8703 | OPTS_TYPE_PT_UNICODE;
8704 kern_type = KERN_TYPE_NETNTLMv2;
8705 dgst_size = DGST_SIZE_4_4;
8706 parse_func = netntlmv2_parse_hash;
8707 sort_by_digest = sort_by_digest_4_4;
8708 opti_type = OPTI_TYPE_ZERO_BYTE;
8709 dgst_pos0 = 0;
8710 dgst_pos1 = 3;
8711 dgst_pos2 = 2;
8712 dgst_pos3 = 1;
8713 break;
8714
8715 case 5700: hash_type = HASH_TYPE_SHA256;
8716 salt_type = SALT_TYPE_NONE;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_BE
8719 | OPTS_TYPE_PT_ADD80
8720 | OPTS_TYPE_PT_ADDBITS15;
8721 kern_type = KERN_TYPE_SHA256;
8722 dgst_size = DGST_SIZE_4_8;
8723 parse_func = cisco4_parse_hash;
8724 sort_by_digest = sort_by_digest_4_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_PRECOMPUTE_INIT
8727 | OPTI_TYPE_PRECOMPUTE_MERKLE
8728 | OPTI_TYPE_EARLY_SKIP
8729 | OPTI_TYPE_NOT_ITERATED
8730 | OPTI_TYPE_NOT_SALTED
8731 | OPTI_TYPE_RAW_HASH;
8732 dgst_pos0 = 3;
8733 dgst_pos1 = 7;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 6;
8736 break;
8737
8738 case 5800: hash_type = HASH_TYPE_SHA1;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_ST_ADD80;
8743 kern_type = KERN_TYPE_ANDROIDPIN;
8744 dgst_size = DGST_SIZE_4_5;
8745 parse_func = androidpin_parse_hash;
8746 sort_by_digest = sort_by_digest_4_5;
8747 opti_type = OPTI_TYPE_ZERO_BYTE;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 1;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 3;
8752 break;
8753
8754 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8755 salt_type = SALT_TYPE_NONE;
8756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE
8758 | OPTS_TYPE_PT_ADD80;
8759 kern_type = KERN_TYPE_RIPEMD160;
8760 dgst_size = DGST_SIZE_4_5;
8761 parse_func = ripemd160_parse_hash;
8762 sort_by_digest = sort_by_digest_4_5;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8771 salt_type = SALT_TYPE_NONE;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_BE
8774 | OPTS_TYPE_PT_ADD80;
8775 kern_type = KERN_TYPE_WHIRLPOOL;
8776 dgst_size = DGST_SIZE_4_16;
8777 parse_func = whirlpool_parse_hash;
8778 sort_by_digest = sort_by_digest_4_16;
8779 opti_type = OPTI_TYPE_ZERO_BYTE;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 1;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 3;
8784 break;
8785
8786 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8787 salt_type = SALT_TYPE_EMBEDDED;
8788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8790 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = truecrypt_parse_hash_2k;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8805 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8806 dgst_size = DGST_SIZE_4_5;
8807 parse_func = truecrypt_parse_hash_2k;
8808 sort_by_digest = sort_by_digest_4_5;
8809 opti_type = OPTI_TYPE_ZERO_BYTE;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8817 salt_type = SALT_TYPE_EMBEDDED;
8818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8820 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8821 dgst_size = DGST_SIZE_4_5;
8822 parse_func = truecrypt_parse_hash_2k;
8823 sort_by_digest = sort_by_digest_4_5;
8824 opti_type = OPTI_TYPE_ZERO_BYTE;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 1;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 3;
8829 break;
8830
8831 case 6221: hash_type = HASH_TYPE_SHA512;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8835 kern_type = KERN_TYPE_TCSHA512_XTS512;
8836 dgst_size = DGST_SIZE_8_8;
8837 parse_func = truecrypt_parse_hash_1k;
8838 sort_by_digest = sort_by_digest_8_8;
8839 opti_type = OPTI_TYPE_ZERO_BYTE
8840 | OPTI_TYPE_USES_BITS_64;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 1;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 3;
8845 break;
8846
8847 case 6222: hash_type = HASH_TYPE_SHA512;
8848 salt_type = SALT_TYPE_EMBEDDED;
8849 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8851 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8852 dgst_size = DGST_SIZE_8_8;
8853 parse_func = truecrypt_parse_hash_1k;
8854 sort_by_digest = sort_by_digest_8_8;
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_USES_BITS_64;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 6223: hash_type = HASH_TYPE_SHA512;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8868 dgst_size = DGST_SIZE_8_8;
8869 parse_func = truecrypt_parse_hash_1k;
8870 sort_by_digest = sort_by_digest_8_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_USES_BITS_64;
8873 dgst_pos0 = 0;
8874 dgst_pos1 = 1;
8875 dgst_pos2 = 2;
8876 dgst_pos3 = 3;
8877 break;
8878
8879 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8880 salt_type = SALT_TYPE_EMBEDDED;
8881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8882 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8883 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8884 dgst_size = DGST_SIZE_4_8;
8885 parse_func = truecrypt_parse_hash_1k;
8886 sort_by_digest = sort_by_digest_4_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8898 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8899 dgst_size = DGST_SIZE_4_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_4_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8913 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8914 dgst_size = DGST_SIZE_4_8;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_4_8;
8917 opti_type = OPTI_TYPE_ZERO_BYTE;
8918 dgst_pos0 = 0;
8919 dgst_pos1 = 1;
8920 dgst_pos2 = 2;
8921 dgst_pos3 = 3;
8922 break;
8923
8924 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8925 salt_type = SALT_TYPE_EMBEDDED;
8926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8928 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8929 dgst_size = DGST_SIZE_4_5;
8930 parse_func = truecrypt_parse_hash_1k;
8931 sort_by_digest = sort_by_digest_4_5;
8932 opti_type = OPTI_TYPE_ZERO_BYTE;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8944 dgst_size = DGST_SIZE_4_5;
8945 parse_func = truecrypt_parse_hash_1k;
8946 sort_by_digest = sort_by_digest_4_5;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8958 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8959 dgst_size = DGST_SIZE_4_5;
8960 parse_func = truecrypt_parse_hash_1k;
8961 sort_by_digest = sort_by_digest_4_5;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 6300: hash_type = HASH_TYPE_MD5;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8973 kern_type = KERN_TYPE_MD5AIX;
8974 dgst_size = DGST_SIZE_4_4;
8975 parse_func = md5aix_parse_hash;
8976 sort_by_digest = sort_by_digest_4_4;
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 6400: hash_type = HASH_TYPE_SHA256;
8985 salt_type = SALT_TYPE_EMBEDDED;
8986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8988 kern_type = KERN_TYPE_SHA256AIX;
8989 dgst_size = DGST_SIZE_4_8;
8990 parse_func = sha256aix_parse_hash;
8991 sort_by_digest = sort_by_digest_4_8;
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 6500: hash_type = HASH_TYPE_SHA512;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9003 kern_type = KERN_TYPE_SHA512AIX;
9004 dgst_size = DGST_SIZE_8_8;
9005 parse_func = sha512aix_parse_hash;
9006 sort_by_digest = sort_by_digest_8_8;
9007 opti_type = OPTI_TYPE_ZERO_BYTE
9008 | OPTI_TYPE_USES_BITS_64;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6600: hash_type = HASH_TYPE_AES;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_AGILEKEY;
9020 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9021 parse_func = agilekey_parse_hash;
9022 sort_by_digest = sort_by_digest_4_5;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6700: hash_type = HASH_TYPE_SHA1;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9034 kern_type = KERN_TYPE_SHA1AIX;
9035 dgst_size = DGST_SIZE_4_5;
9036 parse_func = sha1aix_parse_hash;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 6800: hash_type = HASH_TYPE_AES;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9049 kern_type = KERN_TYPE_LASTPASS;
9050 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9051 parse_func = lastpass_parse_hash;
9052 sort_by_digest = sort_by_digest_4_8;
9053 opti_type = OPTI_TYPE_ZERO_BYTE;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6900: hash_type = HASH_TYPE_GOST;
9061 salt_type = SALT_TYPE_NONE;
9062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9064 kern_type = KERN_TYPE_GOST;
9065 dgst_size = DGST_SIZE_4_8;
9066 parse_func = gost_parse_hash;
9067 sort_by_digest = sort_by_digest_4_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE;
9069 dgst_pos0 = 0;
9070 dgst_pos1 = 1;
9071 dgst_pos2 = 2;
9072 dgst_pos3 = 3;
9073 break;
9074
9075 case 7100: hash_type = HASH_TYPE_SHA512;
9076 salt_type = SALT_TYPE_EMBEDDED;
9077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9079 kern_type = KERN_TYPE_PBKDF2_SHA512;
9080 dgst_size = DGST_SIZE_8_16;
9081 parse_func = sha512osx_parse_hash;
9082 sort_by_digest = sort_by_digest_8_16;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_USES_BITS_64;
9085 dgst_pos0 = 0;
9086 dgst_pos1 = 1;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 3;
9089 break;
9090
9091 case 7200: hash_type = HASH_TYPE_SHA512;
9092 salt_type = SALT_TYPE_EMBEDDED;
9093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9095 kern_type = KERN_TYPE_PBKDF2_SHA512;
9096 dgst_size = DGST_SIZE_8_16;
9097 parse_func = sha512grub_parse_hash;
9098 sort_by_digest = sort_by_digest_8_16;
9099 opti_type = OPTI_TYPE_ZERO_BYTE
9100 | OPTI_TYPE_USES_BITS_64;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 7300: hash_type = HASH_TYPE_SHA1;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_BE
9111 | OPTS_TYPE_ST_ADD80
9112 | OPTS_TYPE_ST_ADDBITS15;
9113 kern_type = KERN_TYPE_RAKP;
9114 dgst_size = DGST_SIZE_4_5;
9115 parse_func = rakp_parse_hash;
9116 sort_by_digest = sort_by_digest_4_5;
9117 opti_type = OPTI_TYPE_ZERO_BYTE
9118 | OPTI_TYPE_NOT_ITERATED;
9119 dgst_pos0 = 3;
9120 dgst_pos1 = 4;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 1;
9123 break;
9124
9125 case 7400: hash_type = HASH_TYPE_SHA256;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9129 kern_type = KERN_TYPE_SHA256CRYPT;
9130 dgst_size = DGST_SIZE_4_8;
9131 parse_func = sha256crypt_parse_hash;
9132 sort_by_digest = sort_by_digest_4_8;
9133 opti_type = OPTI_TYPE_ZERO_BYTE;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 7500: hash_type = HASH_TYPE_KRB5PA;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9144 kern_type = KERN_TYPE_KRB5PA;
9145 dgst_size = DGST_SIZE_4_4;
9146 parse_func = krb5pa_parse_hash;
9147 sort_by_digest = sort_by_digest_4_4;
9148 opti_type = OPTI_TYPE_ZERO_BYTE
9149 | OPTI_TYPE_NOT_ITERATED;
9150 dgst_pos0 = 0;
9151 dgst_pos1 = 1;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 3;
9154 break;
9155
9156 case 7600: hash_type = HASH_TYPE_SHA1;
9157 salt_type = SALT_TYPE_INTERN;
9158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_BE
9160 | OPTS_TYPE_PT_ADD80
9161 | OPTS_TYPE_PT_ADDBITS15;
9162 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9163 dgst_size = DGST_SIZE_4_5;
9164 parse_func = redmine_parse_hash;
9165 sort_by_digest = sort_by_digest_4_5;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_PRECOMPUTE_INIT
9168 | OPTI_TYPE_EARLY_SKIP
9169 | OPTI_TYPE_NOT_ITERATED
9170 | OPTI_TYPE_PREPENDED_SALT;
9171 dgst_pos0 = 3;
9172 dgst_pos1 = 4;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 1;
9175 break;
9176
9177 case 7700: hash_type = HASH_TYPE_SAPB;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE
9181 | OPTS_TYPE_PT_UPPER
9182 | OPTS_TYPE_ST_UPPER;
9183 kern_type = KERN_TYPE_SAPB;
9184 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9185 parse_func = sapb_parse_hash;
9186 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_PRECOMPUTE_INIT
9189 | OPTI_TYPE_NOT_ITERATED;
9190 dgst_pos0 = 0;
9191 dgst_pos1 = 1;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 3;
9194 break;
9195
9196 case 7800: hash_type = HASH_TYPE_SAPG;
9197 salt_type = SALT_TYPE_EMBEDDED;
9198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_BE
9200 | OPTS_TYPE_ST_ADD80
9201 | OPTS_TYPE_ST_UPPER;
9202 kern_type = KERN_TYPE_SAPG;
9203 dgst_size = DGST_SIZE_4_5;
9204 parse_func = sapg_parse_hash;
9205 sort_by_digest = sort_by_digest_4_5;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_NOT_ITERATED;
9209 dgst_pos0 = 3;
9210 dgst_pos1 = 4;
9211 dgst_pos2 = 2;
9212 dgst_pos3 = 1;
9213 break;
9214
9215 case 7900: hash_type = HASH_TYPE_SHA512;
9216 salt_type = SALT_TYPE_EMBEDDED;
9217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9219 kern_type = KERN_TYPE_DRUPAL7;
9220 dgst_size = DGST_SIZE_8_8;
9221 parse_func = drupal7_parse_hash;
9222 sort_by_digest = sort_by_digest_8_8;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_USES_BITS_64;
9225 dgst_pos0 = 0;
9226 dgst_pos1 = 1;
9227 dgst_pos2 = 2;
9228 dgst_pos3 = 3;
9229 break;
9230
9231 case 8000: hash_type = HASH_TYPE_SHA256;
9232 salt_type = SALT_TYPE_EMBEDDED;
9233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9234 opts_type = OPTS_TYPE_PT_GENERATE_BE
9235 | OPTS_TYPE_PT_UNICODE
9236 | OPTS_TYPE_ST_ADD80
9237 | OPTS_TYPE_ST_HEX;
9238 kern_type = KERN_TYPE_SYBASEASE;
9239 dgst_size = DGST_SIZE_4_8;
9240 parse_func = sybasease_parse_hash;
9241 sort_by_digest = sort_by_digest_4_8;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_EARLY_SKIP
9245 | OPTI_TYPE_NOT_ITERATED
9246 | OPTI_TYPE_RAW_HASH;
9247 dgst_pos0 = 3;
9248 dgst_pos1 = 7;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 6;
9251 break;
9252
9253 case 8100: hash_type = HASH_TYPE_SHA1;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9257 kern_type = KERN_TYPE_NETSCALER;
9258 dgst_size = DGST_SIZE_4_5;
9259 parse_func = netscaler_parse_hash;
9260 sort_by_digest = sort_by_digest_4_5;
9261 opti_type = OPTI_TYPE_ZERO_BYTE
9262 | OPTI_TYPE_PRECOMPUTE_INIT
9263 | OPTI_TYPE_PRECOMPUTE_MERKLE
9264 | OPTI_TYPE_EARLY_SKIP
9265 | OPTI_TYPE_NOT_ITERATED
9266 | OPTI_TYPE_PREPENDED_SALT
9267 | OPTI_TYPE_RAW_HASH;
9268 dgst_pos0 = 3;
9269 dgst_pos1 = 4;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 1;
9272 break;
9273
9274 case 8200: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9278 kern_type = KERN_TYPE_CLOUDKEY;
9279 dgst_size = DGST_SIZE_4_8;
9280 parse_func = cloudkey_parse_hash;
9281 sort_by_digest = sort_by_digest_4_8;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 8300: hash_type = HASH_TYPE_SHA1;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE
9293 | OPTS_TYPE_ST_HEX
9294 | OPTS_TYPE_ST_ADD80;
9295 kern_type = KERN_TYPE_NSEC3;
9296 dgst_size = DGST_SIZE_4_5;
9297 parse_func = nsec3_parse_hash;
9298 sort_by_digest = sort_by_digest_4_5;
9299 opti_type = OPTI_TYPE_ZERO_BYTE;
9300 dgst_pos0 = 3;
9301 dgst_pos1 = 4;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 1;
9304 break;
9305
9306 case 8400: hash_type = HASH_TYPE_SHA1;
9307 salt_type = SALT_TYPE_INTERN;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_BE
9310 | OPTS_TYPE_PT_ADD80
9311 | OPTS_TYPE_PT_ADDBITS15;
9312 kern_type = KERN_TYPE_WBB3;
9313 dgst_size = DGST_SIZE_4_5;
9314 parse_func = wbb3_parse_hash;
9315 sort_by_digest = sort_by_digest_4_5;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_PRECOMPUTE_INIT
9318 | OPTI_TYPE_NOT_ITERATED;
9319 dgst_pos0 = 3;
9320 dgst_pos1 = 4;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 1;
9323 break;
9324
9325 case 8500: hash_type = HASH_TYPE_DESRACF;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE
9329 | OPTS_TYPE_ST_UPPER;
9330 kern_type = KERN_TYPE_RACF;
9331 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9332 parse_func = racf_parse_hash;
9333 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9334 opti_type = OPTI_TYPE_ZERO_BYTE
9335 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 8600: hash_type = HASH_TYPE_LOTUS5;
9343 salt_type = SALT_TYPE_NONE;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9346 kern_type = KERN_TYPE_LOTUS5;
9347 dgst_size = DGST_SIZE_4_4;
9348 parse_func = lotus5_parse_hash;
9349 sort_by_digest = sort_by_digest_4_4;
9350 opti_type = OPTI_TYPE_EARLY_SKIP
9351 | OPTI_TYPE_NOT_ITERATED
9352 | OPTI_TYPE_NOT_SALTED
9353 | OPTI_TYPE_RAW_HASH;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 1;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 3;
9358 break;
9359
9360 case 8700: hash_type = HASH_TYPE_LOTUS6;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9364 kern_type = KERN_TYPE_LOTUS6;
9365 dgst_size = DGST_SIZE_4_4;
9366 parse_func = lotus6_parse_hash;
9367 sort_by_digest = sort_by_digest_4_4;
9368 opti_type = OPTI_TYPE_EARLY_SKIP
9369 | OPTI_TYPE_NOT_ITERATED
9370 | OPTI_TYPE_RAW_HASH;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 1;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 3;
9375 break;
9376
9377 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9378 salt_type = SALT_TYPE_EMBEDDED;
9379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9381 kern_type = KERN_TYPE_ANDROIDFDE;
9382 dgst_size = DGST_SIZE_4_4;
9383 parse_func = androidfde_parse_hash;
9384 sort_by_digest = sort_by_digest_4_4;
9385 opti_type = OPTI_TYPE_ZERO_BYTE;
9386 dgst_pos0 = 0;
9387 dgst_pos1 = 1;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 3;
9390 break;
9391
9392 case 8900: hash_type = HASH_TYPE_SCRYPT;
9393 salt_type = SALT_TYPE_EMBEDDED;
9394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9396 kern_type = KERN_TYPE_SCRYPT;
9397 dgst_size = DGST_SIZE_4_8;
9398 parse_func = scrypt_parse_hash;
9399 sort_by_digest = sort_by_digest_4_8;
9400 opti_type = OPTI_TYPE_ZERO_BYTE;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 1;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 3;
9405 break;
9406
9407 case 9000: hash_type = HASH_TYPE_SHA1;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE
9411 | OPTS_TYPE_ST_GENERATE_LE;
9412 kern_type = KERN_TYPE_PSAFE2;
9413 dgst_size = DGST_SIZE_4_5;
9414 parse_func = psafe2_parse_hash;
9415 sort_by_digest = sort_by_digest_4_5;
9416 opti_type = OPTI_TYPE_ZERO_BYTE;
9417 dgst_pos0 = 0;
9418 dgst_pos1 = 1;
9419 dgst_pos2 = 2;
9420 dgst_pos3 = 3;
9421 break;
9422
9423 case 9100: hash_type = HASH_TYPE_LOTUS8;
9424 salt_type = SALT_TYPE_EMBEDDED;
9425 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9427 kern_type = KERN_TYPE_LOTUS8;
9428 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9429 parse_func = lotus8_parse_hash;
9430 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9431 opti_type = OPTI_TYPE_ZERO_BYTE;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 9200: hash_type = HASH_TYPE_SHA256;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9442 kern_type = KERN_TYPE_PBKDF2_SHA256;
9443 dgst_size = DGST_SIZE_4_32;
9444 parse_func = cisco8_parse_hash;
9445 sort_by_digest = sort_by_digest_4_32;
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 9300: hash_type = HASH_TYPE_SCRYPT;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9457 kern_type = KERN_TYPE_SCRYPT;
9458 dgst_size = DGST_SIZE_4_8;
9459 parse_func = cisco9_parse_hash;
9460 sort_by_digest = sort_by_digest_4_8;
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9472 kern_type = KERN_TYPE_OFFICE2007;
9473 dgst_size = DGST_SIZE_4_4;
9474 parse_func = office2007_parse_hash;
9475 sort_by_digest = sort_by_digest_4_4;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9487 kern_type = KERN_TYPE_OFFICE2010;
9488 dgst_size = DGST_SIZE_4_4;
9489 parse_func = office2010_parse_hash;
9490 sort_by_digest = sort_by_digest_4_4;
9491 opti_type = OPTI_TYPE_ZERO_BYTE;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9502 kern_type = KERN_TYPE_OFFICE2013;
9503 dgst_size = DGST_SIZE_4_4;
9504 parse_func = office2013_parse_hash;
9505 sort_by_digest = sort_by_digest_4_4;
9506 opti_type = OPTI_TYPE_ZERO_BYTE;
9507 dgst_pos0 = 0;
9508 dgst_pos1 = 1;
9509 dgst_pos2 = 2;
9510 dgst_pos3 = 3;
9511 break;
9512
9513 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9514 salt_type = SALT_TYPE_EMBEDDED;
9515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9516 opts_type = OPTS_TYPE_PT_GENERATE_LE
9517 | OPTS_TYPE_PT_ADD80
9518 | OPTS_TYPE_PT_UNICODE;
9519 kern_type = KERN_TYPE_OLDOFFICE01;
9520 dgst_size = DGST_SIZE_4_4;
9521 parse_func = oldoffice01_parse_hash;
9522 sort_by_digest = sort_by_digest_4_4;
9523 opti_type = OPTI_TYPE_ZERO_BYTE
9524 | OPTI_TYPE_PRECOMPUTE_INIT
9525 | OPTI_TYPE_NOT_ITERATED;
9526 dgst_pos0 = 0;
9527 dgst_pos1 = 1;
9528 dgst_pos2 = 2;
9529 dgst_pos3 = 3;
9530 break;
9531
9532 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9533 salt_type = SALT_TYPE_EMBEDDED;
9534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9535 opts_type = OPTS_TYPE_PT_GENERATE_LE
9536 | OPTS_TYPE_PT_ADD80;
9537 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = oldoffice01cm1_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE
9542 | OPTI_TYPE_PRECOMPUTE_INIT
9543 | OPTI_TYPE_NOT_ITERATED;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_PT_ADD80
9555 | OPTS_TYPE_PT_UNICODE
9556 | OPTS_TYPE_PT_NEVERCRACK;
9557 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9558 dgst_size = DGST_SIZE_4_4;
9559 parse_func = oldoffice01cm2_parse_hash;
9560 sort_by_digest = sort_by_digest_4_4;
9561 opti_type = OPTI_TYPE_ZERO_BYTE
9562 | OPTI_TYPE_PRECOMPUTE_INIT
9563 | OPTI_TYPE_NOT_ITERATED;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_BE
9574 | OPTS_TYPE_PT_ADD80
9575 | OPTS_TYPE_PT_UNICODE;
9576 kern_type = KERN_TYPE_OLDOFFICE34;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = oldoffice34_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_ZERO_BYTE
9581 | OPTI_TYPE_PRECOMPUTE_INIT
9582 | OPTI_TYPE_NOT_ITERATED;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9593 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9594 dgst_size = DGST_SIZE_4_4;
9595 parse_func = oldoffice34cm1_parse_hash;
9596 sort_by_digest = sort_by_digest_4_4;
9597 opti_type = OPTI_TYPE_ZERO_BYTE
9598 | OPTI_TYPE_PRECOMPUTE_INIT
9599 | OPTI_TYPE_NOT_ITERATED;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_BE
9610 | OPTS_TYPE_PT_ADD80
9611 | OPTS_TYPE_PT_UNICODE
9612 | OPTS_TYPE_PT_NEVERCRACK;
9613 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice34cm2_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9900: hash_type = HASH_TYPE_MD5;
9627 salt_type = SALT_TYPE_NONE;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9630 kern_type = KERN_TYPE_RADMIN2;
9631 dgst_size = DGST_SIZE_4_4;
9632 parse_func = radmin2_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4;
9634 opti_type = OPTI_TYPE_ZERO_BYTE
9635 | OPTI_TYPE_PRECOMPUTE_INIT
9636 | OPTI_TYPE_EARLY_SKIP
9637 | OPTI_TYPE_NOT_ITERATED
9638 | OPTI_TYPE_NOT_SALTED;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 3;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 1;
9643 break;
9644
9645 case 10000: hash_type = HASH_TYPE_SHA256;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9649 kern_type = KERN_TYPE_PBKDF2_SHA256;
9650 dgst_size = DGST_SIZE_4_32;
9651 parse_func = djangopbkdf2_parse_hash;
9652 sort_by_digest = sort_by_digest_4_32;
9653 opti_type = OPTI_TYPE_ZERO_BYTE;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 10100: hash_type = HASH_TYPE_SIPHASH;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9664 kern_type = KERN_TYPE_SIPHASH;
9665 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9666 parse_func = siphash_parse_hash;
9667 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_NOT_ITERATED
9670 | OPTI_TYPE_RAW_HASH;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 10200: hash_type = HASH_TYPE_MD5;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_LE
9681 | OPTS_TYPE_ST_ADD80
9682 | OPTS_TYPE_ST_ADDBITS14;
9683 kern_type = KERN_TYPE_HMACMD5_PW;
9684 dgst_size = DGST_SIZE_4_4;
9685 parse_func = crammd5_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4;
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_NOT_ITERATED;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 3;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 10300: hash_type = HASH_TYPE_SHA1;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9699 kern_type = KERN_TYPE_SAPH_SHA1;
9700 dgst_size = DGST_SIZE_4_5;
9701 parse_func = saph_sha1_parse_hash;
9702 sort_by_digest = sort_by_digest_4_5;
9703 opti_type = OPTI_TYPE_ZERO_BYTE;
9704 dgst_pos0 = 0;
9705 dgst_pos1 = 1;
9706 dgst_pos2 = 2;
9707 dgst_pos3 = 3;
9708 break;
9709
9710 case 10400: hash_type = HASH_TYPE_PDFU16;
9711 salt_type = SALT_TYPE_EMBEDDED;
9712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9714 kern_type = KERN_TYPE_PDF11;
9715 dgst_size = DGST_SIZE_4_4;
9716 parse_func = pdf11_parse_hash;
9717 sort_by_digest = sort_by_digest_4_4;
9718 opti_type = OPTI_TYPE_ZERO_BYTE
9719 | OPTI_TYPE_NOT_ITERATED;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 10410: hash_type = HASH_TYPE_PDFU16;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9730 kern_type = KERN_TYPE_PDF11CM1;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = pdf11cm1_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_NOT_ITERATED;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 10420: hash_type = HASH_TYPE_PDFU16;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9746 kern_type = KERN_TYPE_PDF11CM2;
9747 dgst_size = DGST_SIZE_4_4;
9748 parse_func = pdf11cm2_parse_hash;
9749 sort_by_digest = sort_by_digest_4_4;
9750 opti_type = OPTI_TYPE_ZERO_BYTE
9751 | OPTI_TYPE_NOT_ITERATED;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 1;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 3;
9756 break;
9757
9758 case 10500: hash_type = HASH_TYPE_PDFU16;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9762 kern_type = KERN_TYPE_PDF14;
9763 dgst_size = DGST_SIZE_4_4;
9764 parse_func = pdf14_parse_hash;
9765 sort_by_digest = sort_by_digest_4_4;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_NOT_ITERATED;
9768 dgst_pos0 = 0;
9769 dgst_pos1 = 1;
9770 dgst_pos2 = 2;
9771 dgst_pos3 = 3;
9772 break;
9773
9774 case 10600: hash_type = HASH_TYPE_SHA256;
9775 salt_type = SALT_TYPE_EMBEDDED;
9776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9777 opts_type = OPTS_TYPE_PT_GENERATE_BE
9778 | OPTS_TYPE_ST_ADD80
9779 | OPTS_TYPE_ST_ADDBITS15
9780 | OPTS_TYPE_HASH_COPY;
9781 kern_type = KERN_TYPE_SHA256_PWSLT;
9782 dgst_size = DGST_SIZE_4_8;
9783 parse_func = pdf17l3_parse_hash;
9784 sort_by_digest = sort_by_digest_4_8;
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_PRECOMPUTE_INIT
9787 | OPTI_TYPE_PRECOMPUTE_MERKLE
9788 | OPTI_TYPE_EARLY_SKIP
9789 | OPTI_TYPE_NOT_ITERATED
9790 | OPTI_TYPE_APPENDED_SALT
9791 | OPTI_TYPE_RAW_HASH;
9792 dgst_pos0 = 3;
9793 dgst_pos1 = 7;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 6;
9796 break;
9797
9798 case 10700: hash_type = HASH_TYPE_PDFU32;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE
9802 | OPTS_TYPE_HASH_COPY;
9803 kern_type = KERN_TYPE_PDF17L8;
9804 dgst_size = DGST_SIZE_4_8;
9805 parse_func = pdf17l8_parse_hash;
9806 sort_by_digest = sort_by_digest_4_8;
9807 opti_type = OPTI_TYPE_ZERO_BYTE
9808 | OPTI_TYPE_NOT_ITERATED;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 10800: hash_type = HASH_TYPE_SHA384;
9816 salt_type = SALT_TYPE_NONE;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_BE
9819 | OPTS_TYPE_PT_ADD80
9820 | OPTS_TYPE_PT_ADDBITS15;
9821 kern_type = KERN_TYPE_SHA384;
9822 dgst_size = DGST_SIZE_8_8;
9823 parse_func = sha384_parse_hash;
9824 sort_by_digest = sort_by_digest_8_8;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_PRECOMPUTE_INIT
9827 | OPTI_TYPE_PRECOMPUTE_MERKLE
9828 | OPTI_TYPE_EARLY_SKIP
9829 | OPTI_TYPE_NOT_ITERATED
9830 | OPTI_TYPE_NOT_SALTED
9831 | OPTI_TYPE_USES_BITS_64
9832 | OPTI_TYPE_RAW_HASH;
9833 dgst_pos0 = 6;
9834 dgst_pos1 = 7;
9835 dgst_pos2 = 4;
9836 dgst_pos3 = 5;
9837 break;
9838
9839 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9840 salt_type = SALT_TYPE_EMBEDDED;
9841 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9842 opts_type = OPTS_TYPE_PT_GENERATE_LE
9843 | OPTS_TYPE_ST_BASE64
9844 | OPTS_TYPE_HASH_COPY;
9845 kern_type = KERN_TYPE_PBKDF2_SHA256;
9846 dgst_size = DGST_SIZE_4_32;
9847 parse_func = pbkdf2_sha256_parse_hash;
9848 sort_by_digest = sort_by_digest_4_32;
9849 opti_type = OPTI_TYPE_ZERO_BYTE;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 1;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 3;
9854 break;
9855
9856 case 11000: hash_type = HASH_TYPE_MD5;
9857 salt_type = SALT_TYPE_INTERN;
9858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE
9860 | OPTS_TYPE_PT_ADD80;
9861 kern_type = KERN_TYPE_PRESTASHOP;
9862 dgst_size = DGST_SIZE_4_4;
9863 parse_func = prestashop_parse_hash;
9864 sort_by_digest = sort_by_digest_4_4;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_PRECOMPUTE_INIT
9867 | OPTI_TYPE_NOT_ITERATED
9868 | OPTI_TYPE_PREPENDED_SALT;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 3;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 1;
9873 break;
9874
9875 case 11100: hash_type = HASH_TYPE_MD5;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE
9879 | OPTS_TYPE_ST_ADD80;
9880 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9881 dgst_size = DGST_SIZE_4_4;
9882 parse_func = postgresql_auth_parse_hash;
9883 sort_by_digest = sort_by_digest_4_4;
9884 opti_type = OPTI_TYPE_ZERO_BYTE
9885 | OPTI_TYPE_PRECOMPUTE_INIT
9886 | OPTI_TYPE_PRECOMPUTE_MERKLE
9887 | OPTI_TYPE_EARLY_SKIP;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 3;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 1;
9892 break;
9893
9894 case 11200: hash_type = HASH_TYPE_SHA1;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_BE
9898 | OPTS_TYPE_PT_ADD80
9899 | OPTS_TYPE_ST_HEX;
9900 kern_type = KERN_TYPE_MYSQL_AUTH;
9901 dgst_size = DGST_SIZE_4_5;
9902 parse_func = mysql_auth_parse_hash;
9903 sort_by_digest = sort_by_digest_4_5;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_EARLY_SKIP;
9906 dgst_pos0 = 3;
9907 dgst_pos1 = 4;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE
9916 | OPTS_TYPE_ST_HEX
9917 | OPTS_TYPE_ST_ADD80;
9918 kern_type = KERN_TYPE_BITCOIN_WALLET;
9919 dgst_size = DGST_SIZE_4_4;
9920 parse_func = bitcoin_wallet_parse_hash;
9921 sort_by_digest = sort_by_digest_4_4;
9922 opti_type = OPTI_TYPE_ZERO_BYTE;
9923 dgst_pos0 = 0;
9924 dgst_pos1 = 1;
9925 dgst_pos2 = 2;
9926 dgst_pos3 = 3;
9927 break;
9928
9929 case 11400: hash_type = HASH_TYPE_MD5;
9930 salt_type = SALT_TYPE_EMBEDDED;
9931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9932 opts_type = OPTS_TYPE_PT_GENERATE_LE
9933 | OPTS_TYPE_PT_ADD80
9934 | OPTS_TYPE_HASH_COPY;
9935 kern_type = KERN_TYPE_SIP_AUTH;
9936 dgst_size = DGST_SIZE_4_4;
9937 parse_func = sip_auth_parse_hash;
9938 sort_by_digest = sort_by_digest_4_4;
9939 opti_type = OPTI_TYPE_ZERO_BYTE;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 3;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 1;
9944 break;
9945
9946 case 11500: hash_type = HASH_TYPE_CRC32;
9947 salt_type = SALT_TYPE_INTERN;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_LE
9950 | OPTS_TYPE_ST_GENERATE_LE
9951 | OPTS_TYPE_ST_HEX;
9952 kern_type = KERN_TYPE_CRC32;
9953 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9954 parse_func = crc32_parse_hash;
9955 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9956 opti_type = OPTI_TYPE_ZERO_BYTE;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 11600: hash_type = HASH_TYPE_AES;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE
9967 | OPTS_TYPE_PT_NEVERCRACK;
9968 kern_type = KERN_TYPE_SEVEN_ZIP;
9969 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9970 parse_func = seven_zip_parse_hash;
9971 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9972 opti_type = OPTI_TYPE_ZERO_BYTE;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9980 salt_type = SALT_TYPE_NONE;
9981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE
9983 | OPTS_TYPE_PT_ADD01;
9984 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9985 dgst_size = DGST_SIZE_4_8;
9986 parse_func = gost2012sbog_256_parse_hash;
9987 sort_by_digest = sort_by_digest_4_8;
9988 opti_type = OPTI_TYPE_ZERO_BYTE;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9996 salt_type = SALT_TYPE_NONE;
9997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE
9999 | OPTS_TYPE_PT_ADD01;
10000 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10001 dgst_size = DGST_SIZE_4_16;
10002 parse_func = gost2012sbog_512_parse_hash;
10003 sort_by_digest = sort_by_digest_4_16;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE
10015 | OPTS_TYPE_ST_BASE64
10016 | OPTS_TYPE_HASH_COPY;
10017 kern_type = KERN_TYPE_PBKDF2_MD5;
10018 dgst_size = DGST_SIZE_4_32;
10019 parse_func = pbkdf2_md5_parse_hash;
10020 sort_by_digest = sort_by_digest_4_32;
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE
10032 | OPTS_TYPE_ST_BASE64
10033 | OPTS_TYPE_HASH_COPY;
10034 kern_type = KERN_TYPE_PBKDF2_SHA1;
10035 dgst_size = DGST_SIZE_4_32;
10036 parse_func = pbkdf2_sha1_parse_hash;
10037 sort_by_digest = sort_by_digest_4_32;
10038 opti_type = OPTI_TYPE_ZERO_BYTE;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10046 salt_type = SALT_TYPE_EMBEDDED;
10047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_LE
10049 | OPTS_TYPE_ST_BASE64
10050 | OPTS_TYPE_HASH_COPY;
10051 kern_type = KERN_TYPE_PBKDF2_SHA512;
10052 dgst_size = DGST_SIZE_8_16;
10053 parse_func = pbkdf2_sha512_parse_hash;
10054 sort_by_digest = sort_by_digest_8_16;
10055 opti_type = OPTI_TYPE_ZERO_BYTE
10056 | OPTI_TYPE_USES_BITS_64;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10067 kern_type = KERN_TYPE_ECRYPTFS;
10068 dgst_size = DGST_SIZE_8_8;
10069 parse_func = ecryptfs_parse_hash;
10070 sort_by_digest = sort_by_digest_8_8;
10071 opti_type = OPTI_TYPE_ZERO_BYTE
10072 | OPTI_TYPE_USES_BITS_64;
10073 dgst_pos0 = 0;
10074 dgst_pos1 = 1;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 3;
10077 break;
10078
10079 case 12300: hash_type = HASH_TYPE_ORACLET;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10083 kern_type = KERN_TYPE_ORACLET;
10084 dgst_size = DGST_SIZE_8_16;
10085 parse_func = oraclet_parse_hash;
10086 sort_by_digest = sort_by_digest_8_16;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_USES_BITS_64;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10099 kern_type = KERN_TYPE_BSDICRYPT;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = bsdicrypt_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10105 dgst_pos0 = 0;
10106 dgst_pos1 = 1;
10107 dgst_pos2 = 2;
10108 dgst_pos3 = 3;
10109 break;
10110
10111 case 12500: hash_type = HASH_TYPE_RAR3HP;
10112 salt_type = SALT_TYPE_EMBEDDED;
10113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10114 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10115 kern_type = KERN_TYPE_RAR3;
10116 dgst_size = DGST_SIZE_4_4;
10117 parse_func = rar3hp_parse_hash;
10118 sort_by_digest = sort_by_digest_4_4;
10119 opti_type = OPTI_TYPE_ZERO_BYTE;
10120 dgst_pos0 = 0;
10121 dgst_pos1 = 1;
10122 dgst_pos2 = 2;
10123 dgst_pos3 = 3;
10124 break;
10125
10126 case 12600: hash_type = HASH_TYPE_SHA256;
10127 salt_type = SALT_TYPE_INTERN;
10128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10129 opts_type = OPTS_TYPE_PT_GENERATE_BE
10130 | OPTS_TYPE_PT_ADD80;
10131 kern_type = KERN_TYPE_CF10;
10132 dgst_size = DGST_SIZE_4_8;
10133 parse_func = cf10_parse_hash;
10134 sort_by_digest = sort_by_digest_4_8;
10135 opti_type = OPTI_TYPE_ZERO_BYTE
10136 | OPTI_TYPE_PRECOMPUTE_INIT
10137 | OPTI_TYPE_EARLY_SKIP
10138 | OPTI_TYPE_NOT_ITERATED;
10139 dgst_pos0 = 3;
10140 dgst_pos1 = 7;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 6;
10143 break;
10144
10145 case 12700: hash_type = HASH_TYPE_AES;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE
10149 | OPTS_TYPE_HASH_COPY;
10150 kern_type = KERN_TYPE_MYWALLET;
10151 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10152 parse_func = mywallet_parse_hash;
10153 sort_by_digest = sort_by_digest_4_5;
10154 opti_type = OPTI_TYPE_ZERO_BYTE;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10165 kern_type = KERN_TYPE_MS_DRSR;
10166 dgst_size = DGST_SIZE_4_8;
10167 parse_func = ms_drsr_parse_hash;
10168 sort_by_digest = sort_by_digest_4_8;
10169 opti_type = OPTI_TYPE_ZERO_BYTE;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10180 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10181 dgst_size = DGST_SIZE_4_8;
10182 parse_func = androidfde_samsung_parse_hash;
10183 sort_by_digest = sort_by_digest_4_8;
10184 opti_type = OPTI_TYPE_ZERO_BYTE;
10185 dgst_pos0 = 0;
10186 dgst_pos1 = 1;
10187 dgst_pos2 = 2;
10188 dgst_pos3 = 3;
10189 break;
10190
10191 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10192 salt_type = SALT_TYPE_EMBEDDED;
10193 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10194 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10195 kern_type = KERN_TYPE_RAR5;
10196 dgst_size = DGST_SIZE_4_4;
10197 parse_func = rar5_parse_hash;
10198 sort_by_digest = sort_by_digest_4_4;
10199 opti_type = OPTI_TYPE_ZERO_BYTE;
10200 dgst_pos0 = 0;
10201 dgst_pos1 = 1;
10202 dgst_pos2 = 2;
10203 dgst_pos3 = 3;
10204 break;
10205
10206 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10207 salt_type = SALT_TYPE_EMBEDDED;
10208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10210 kern_type = KERN_TYPE_KRB5TGS;
10211 dgst_size = DGST_SIZE_4_4;
10212 parse_func = krb5tgs_parse_hash;
10213 sort_by_digest = sort_by_digest_4_4;
10214 opti_type = OPTI_TYPE_ZERO_BYTE
10215 | OPTI_TYPE_NOT_ITERATED;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 1;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 3;
10220 break;
10221
10222 case 13200: hash_type = HASH_TYPE_AES;
10223 salt_type = SALT_TYPE_EMBEDDED;
10224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10226 kern_type = KERN_TYPE_AXCRYPT;
10227 dgst_size = DGST_SIZE_4_4;
10228 parse_func = axcrypt_parse_hash;
10229 sort_by_digest = sort_by_digest_4_4;
10230 opti_type = OPTI_TYPE_ZERO_BYTE;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 13300: hash_type = HASH_TYPE_SHA1;
10238 salt_type = SALT_TYPE_NONE;
10239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_BE
10241 | OPTS_TYPE_PT_ADD80
10242 | OPTS_TYPE_PT_ADDBITS15;
10243 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10244 dgst_size = DGST_SIZE_4_5;
10245 parse_func = sha1axcrypt_parse_hash;
10246 sort_by_digest = sort_by_digest_4_5;
10247 opti_type = OPTI_TYPE_ZERO_BYTE
10248 | OPTI_TYPE_PRECOMPUTE_INIT
10249 | OPTI_TYPE_EARLY_SKIP
10250 | OPTI_TYPE_NOT_ITERATED
10251 | OPTI_TYPE_NOT_SALTED;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 4;
10254 dgst_pos2 = 3;
10255 dgst_pos3 = 2;
10256 break;
10257
10258 default: usage_mini_print (PROGNAME); return (-1);
10259 }
10260
10261 /**
10262 * parser
10263 */
10264
10265 data.parse_func = parse_func;
10266
10267 /**
10268 * misc stuff
10269 */
10270
10271 if (hex_salt)
10272 {
10273 if (salt_type == SALT_TYPE_INTERN)
10274 {
10275 opts_type |= OPTS_TYPE_ST_HEX;
10276 }
10277 else
10278 {
10279 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10280
10281 return (-1);
10282 }
10283 }
10284
10285 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10286 | (salt_type == SALT_TYPE_EXTERN)
10287 | (salt_type == SALT_TYPE_EMBEDDED)
10288 | (salt_type == SALT_TYPE_VIRTUAL));
10289
10290 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10291
10292 data.hash_type = hash_type;
10293 data.attack_mode = attack_mode;
10294 data.attack_kern = attack_kern;
10295 data.attack_exec = attack_exec;
10296 data.kern_type = kern_type;
10297 data.opts_type = opts_type;
10298 data.dgst_size = dgst_size;
10299 data.salt_type = salt_type;
10300 data.isSalted = isSalted;
10301 data.sort_by_digest = sort_by_digest;
10302 data.dgst_pos0 = dgst_pos0;
10303 data.dgst_pos1 = dgst_pos1;
10304 data.dgst_pos2 = dgst_pos2;
10305 data.dgst_pos3 = dgst_pos3;
10306
10307 esalt_size = 0;
10308
10309 switch (hash_mode)
10310 {
10311 case 2500: esalt_size = sizeof (wpa_t); break;
10312 case 5300: esalt_size = sizeof (ikepsk_t); break;
10313 case 5400: esalt_size = sizeof (ikepsk_t); break;
10314 case 5500: esalt_size = sizeof (netntlm_t); break;
10315 case 5600: esalt_size = sizeof (netntlm_t); break;
10316 case 6211: esalt_size = sizeof (tc_t); break;
10317 case 6212: esalt_size = sizeof (tc_t); break;
10318 case 6213: esalt_size = sizeof (tc_t); break;
10319 case 6221: esalt_size = sizeof (tc_t); break;
10320 case 6222: esalt_size = sizeof (tc_t); break;
10321 case 6223: esalt_size = sizeof (tc_t); break;
10322 case 6231: esalt_size = sizeof (tc_t); break;
10323 case 6232: esalt_size = sizeof (tc_t); break;
10324 case 6233: esalt_size = sizeof (tc_t); break;
10325 case 6241: esalt_size = sizeof (tc_t); break;
10326 case 6242: esalt_size = sizeof (tc_t); break;
10327 case 6243: esalt_size = sizeof (tc_t); break;
10328 case 6600: esalt_size = sizeof (agilekey_t); break;
10329 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10330 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10331 case 7300: esalt_size = sizeof (rakp_t); break;
10332 case 7500: esalt_size = sizeof (krb5pa_t); break;
10333 case 8200: esalt_size = sizeof (cloudkey_t); break;
10334 case 8800: esalt_size = sizeof (androidfde_t); break;
10335 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10336 case 9400: esalt_size = sizeof (office2007_t); break;
10337 case 9500: esalt_size = sizeof (office2010_t); break;
10338 case 9600: esalt_size = sizeof (office2013_t); break;
10339 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10340 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10341 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10342 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10343 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10344 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10345 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10346 case 10200: esalt_size = sizeof (cram_md5_t); break;
10347 case 10400: esalt_size = sizeof (pdf_t); break;
10348 case 10410: esalt_size = sizeof (pdf_t); break;
10349 case 10420: esalt_size = sizeof (pdf_t); break;
10350 case 10500: esalt_size = sizeof (pdf_t); break;
10351 case 10600: esalt_size = sizeof (pdf_t); break;
10352 case 10700: esalt_size = sizeof (pdf_t); break;
10353 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10354 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10355 case 11400: esalt_size = sizeof (sip_t); break;
10356 case 11600: esalt_size = sizeof (seven_zip_t); break;
10357 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10358 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10359 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10360 case 13000: esalt_size = sizeof (rar5_t); break;
10361 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10362 }
10363
10364 data.esalt_size = esalt_size;
10365
10366 /**
10367 * choose dictionary parser
10368 */
10369
10370 if (hash_type == HASH_TYPE_LM)
10371 {
10372 get_next_word_func = get_next_word_lm;
10373 }
10374 else if (opts_type & OPTS_TYPE_PT_UPPER)
10375 {
10376 get_next_word_func = get_next_word_uc;
10377 }
10378 else
10379 {
10380 get_next_word_func = get_next_word_std;
10381 }
10382
10383 /**
10384 * dictstat
10385 */
10386
10387 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10388
10389 #ifdef _POSIX
10390 size_t dictstat_nmemb = 0;
10391 #endif
10392
10393 #ifdef _WIN
10394 uint dictstat_nmemb = 0;
10395 #endif
10396
10397 char dictstat[256] = { 0 };
10398
10399 FILE *dictstat_fp = NULL;
10400
10401 if (keyspace == 0)
10402 {
10403 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10404
10405 dictstat_fp = fopen (dictstat, "rb");
10406
10407 if (dictstat_fp)
10408 {
10409 #ifdef _POSIX
10410 struct stat tmpstat;
10411
10412 fstat (fileno (dictstat_fp), &tmpstat);
10413 #endif
10414
10415 #ifdef _WIN
10416 struct stat64 tmpstat;
10417
10418 _fstat64 (fileno (dictstat_fp), &tmpstat);
10419 #endif
10420
10421 if (tmpstat.st_mtime < COMPTIME)
10422 {
10423 /* with v0.15 the format changed so we have to ensure user is using a good version
10424 since there is no version-header in the dictstat file */
10425
10426 fclose (dictstat_fp);
10427
10428 unlink (dictstat);
10429 }
10430 else
10431 {
10432 while (!feof (dictstat_fp))
10433 {
10434 dictstat_t d;
10435
10436 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10437
10438 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10439
10440 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10441 {
10442 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10443
10444 return -1;
10445 }
10446 }
10447
10448 fclose (dictstat_fp);
10449 }
10450 }
10451 }
10452
10453 /**
10454 * potfile
10455 */
10456
10457 char potfile[256] = { 0 };
10458
10459 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10460
10461 data.pot_fp = NULL;
10462
10463 FILE *out_fp = NULL;
10464 FILE *pot_fp = NULL;
10465
10466 if (show == 1 || left == 1)
10467 {
10468 pot_fp = fopen (potfile, "rb");
10469
10470 if (pot_fp == NULL)
10471 {
10472 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10473
10474 return (-1);
10475 }
10476
10477 if (outfile != NULL)
10478 {
10479 if ((out_fp = fopen (outfile, "ab")) == NULL)
10480 {
10481 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10482
10483 fclose (pot_fp);
10484
10485 return (-1);
10486 }
10487 }
10488 else
10489 {
10490 out_fp = stdout;
10491 }
10492 }
10493 else
10494 {
10495 if (potfile_disable == 0)
10496 {
10497 pot_fp = fopen (potfile, "ab");
10498
10499 if (pot_fp == NULL)
10500 {
10501 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10502
10503 return (-1);
10504 }
10505
10506 data.pot_fp = pot_fp;
10507 }
10508 }
10509
10510 pot_t *pot = NULL;
10511
10512 uint pot_cnt = 0;
10513 uint pot_avail = 0;
10514
10515 if (show == 1 || left == 1)
10516 {
10517 SUPPRESS_OUTPUT = 1;
10518
10519 pot_avail = count_lines (pot_fp);
10520
10521 rewind (pot_fp);
10522
10523 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10524
10525 uint pot_hashes_avail = 0;
10526
10527 uint line_num = 0;
10528
10529 while (!feof (pot_fp))
10530 {
10531 line_num++;
10532
10533 char line_buf[BUFSIZ] = { 0 };
10534
10535 int line_len = fgetl (pot_fp, line_buf);
10536
10537 if (line_len == 0) continue;
10538
10539 char *plain_buf = line_buf + line_len;
10540
10541 pot_t *pot_ptr = &pot[pot_cnt];
10542
10543 hash_t *hashes_buf = &pot_ptr->hash;
10544
10545 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10546 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10547
10548 if (pot_cnt == pot_hashes_avail)
10549 {
10550 uint pos = 0;
10551
10552 for (pos = 0; pos < INCR_POT; pos++)
10553 {
10554 if ((pot_cnt + pos) >= pot_avail) break;
10555
10556 pot_t *tmp_pot = &pot[pot_cnt + pos];
10557
10558 hash_t *tmp_hash = &tmp_pot->hash;
10559
10560 tmp_hash->digest = mymalloc (dgst_size);
10561
10562 if (isSalted)
10563 {
10564 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10565 }
10566
10567 if (esalt_size)
10568 {
10569 tmp_hash->esalt = mymalloc (esalt_size);
10570 }
10571
10572 pot_hashes_avail++;
10573 }
10574 }
10575
10576 int plain_len = 0;
10577
10578 int parser_status;
10579
10580 int iter = MAX_CUT_TRIES;
10581
10582 do
10583 {
10584 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10585 {
10586 if (line_buf[i] == ':')
10587 {
10588 line_len--;
10589
10590 break;
10591 }
10592 }
10593
10594 if (data.hash_mode != 2500)
10595 {
10596 parser_status = parse_func (line_buf, line_len, hashes_buf);
10597 }
10598 else
10599 {
10600 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10601
10602 if (line_len > max_salt_size)
10603 {
10604 parser_status = PARSER_GLOBAL_LENGTH;
10605 }
10606 else
10607 {
10608 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10609
10610 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10611
10612 hashes_buf->salt->salt_len = line_len;
10613
10614 parser_status = PARSER_OK;
10615 }
10616 }
10617
10618 // if NOT parsed without error, we add the ":" to the plain
10619
10620 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10621 {
10622 plain_len++;
10623 plain_buf--;
10624 }
10625
10626 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10627
10628 if (parser_status < PARSER_GLOBAL_ZERO)
10629 {
10630 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10631
10632 continue;
10633 }
10634
10635 if (plain_len >= 255) continue;
10636
10637 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10638
10639 pot_ptr->plain_len = plain_len;
10640
10641 pot_cnt++;
10642 }
10643
10644 fclose (pot_fp);
10645
10646 SUPPRESS_OUTPUT = 0;
10647
10648 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10649 }
10650
10651 /**
10652 * word len
10653 */
10654
10655 uint pw_min = PW_MIN;
10656 uint pw_max = PW_MAX;
10657
10658 switch (hash_mode)
10659 {
10660 case 400: if (pw_max > 40) pw_max = 40;
10661 break;
10662 case 500: if (pw_max > 16) pw_max = 16;
10663 break;
10664 case 1500: if (pw_max > 8) pw_max = 8;
10665 break;
10666 case 1600: if (pw_max > 16) pw_max = 16;
10667 break;
10668 case 1800: if (pw_max > 16) pw_max = 16;
10669 break;
10670 case 2100: if (pw_max > 16) pw_max = 16;
10671 break;
10672 case 2500: if (pw_min < 8) pw_min = 8;
10673 break;
10674 case 3000: if (pw_max > 7) pw_max = 7;
10675 break;
10676 case 5200: if (pw_max > 24) pw_max = 24;
10677 break;
10678 case 5800: if (pw_max > 16) pw_max = 16;
10679 break;
10680 case 6300: if (pw_max > 16) pw_max = 16;
10681 break;
10682 case 7400: if (pw_max > 16) pw_max = 16;
10683 break;
10684 case 7900: if (pw_max > 48) pw_max = 48;
10685 break;
10686 case 8500: if (pw_max > 8) pw_max = 8;
10687 break;
10688 case 8600: if (pw_max > 16) pw_max = 16;
10689 break;
10690 case 9710: pw_min = 5;
10691 pw_max = 5;
10692 break;
10693 case 9810: pw_min = 5;
10694 pw_max = 5;
10695 break;
10696 case 10410: pw_min = 5;
10697 pw_max = 5;
10698 break;
10699 case 10300: if (pw_max < 3) pw_min = 3;
10700 if (pw_max > 40) pw_max = 40;
10701 break;
10702 case 10500: if (pw_max < 3) pw_min = 3;
10703 if (pw_max > 40) pw_max = 40;
10704 break;
10705 case 10700: if (pw_max > 16) pw_max = 16;
10706 break;
10707 case 11300: if (pw_max > 40) pw_max = 40;
10708 break;
10709 case 12500: if (pw_max > 20) pw_max = 20;
10710 break;
10711 case 12800: if (pw_max > 24) pw_max = 24;
10712 break;
10713 }
10714
10715 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10716 {
10717 switch (attack_kern)
10718 {
10719 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10720 break;
10721 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10722 break;
10723 }
10724 }
10725
10726 /**
10727 * charsets : keep them together for more easy maintainnce
10728 */
10729
10730 cs_t mp_sys[6] = { { { 0 }, 0 } };
10731 cs_t mp_usr[4] = { { { 0 }, 0 } };
10732
10733 mp_setup_sys (mp_sys);
10734
10735 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10736 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10737 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10738 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10739
10740 /**
10741 * load hashes, part I: find input mode, count hashes
10742 */
10743
10744 uint hashlist_mode = 0;
10745 uint hashlist_format = HLFMT_HASHCAT;
10746
10747 uint hashes_avail = 0;
10748
10749 if (benchmark == 0)
10750 {
10751 struct stat f;
10752
10753 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10754
10755 if ((hash_mode == 2500) ||
10756 (hash_mode == 5200) ||
10757 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10758 (hash_mode == 9000))
10759 {
10760 hashlist_mode = HL_MODE_ARG;
10761
10762 char *hashfile = myargv[optind];
10763
10764 data.hashfile = hashfile;
10765
10766 logfile_top_var_string ("target", hashfile);
10767 }
10768
10769 if (hashlist_mode == HL_MODE_ARG)
10770 {
10771 if (hash_mode == 2500)
10772 {
10773 struct stat st;
10774
10775 if (stat (data.hashfile, &st) == -1)
10776 {
10777 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10778
10779 return (-1);
10780 }
10781
10782 hashes_avail = st.st_size / sizeof (hccap_t);
10783 }
10784 else
10785 {
10786 hashes_avail = 1;
10787 }
10788 }
10789 else if (hashlist_mode == HL_MODE_FILE)
10790 {
10791 char *hashfile = myargv[optind];
10792
10793 data.hashfile = hashfile;
10794
10795 logfile_top_var_string ("target", hashfile);
10796
10797 FILE *fp = NULL;
10798
10799 if ((fp = fopen (hashfile, "rb")) == NULL)
10800 {
10801 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10802
10803 return (-1);
10804 }
10805
10806 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10807
10808 hashes_avail = count_lines (fp);
10809
10810 rewind (fp);
10811
10812 if (hashes_avail == 0)
10813 {
10814 log_error ("ERROR: hashfile is empty or corrupt");
10815
10816 fclose (fp);
10817
10818 return (-1);
10819 }
10820
10821 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10822
10823 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10824 {
10825 log_error ("ERROR: remove not supported in native hashfile-format mode");
10826
10827 fclose (fp);
10828
10829 return (-1);
10830 }
10831
10832 fclose (fp);
10833 }
10834 }
10835 else
10836 {
10837 hashlist_mode = HL_MODE_ARG;
10838
10839 hashes_avail = 1;
10840 }
10841
10842 if (hash_mode == 3000) hashes_avail *= 2;
10843
10844 data.hashlist_mode = hashlist_mode;
10845 data.hashlist_format = hashlist_format;
10846
10847 logfile_top_uint (hashlist_mode);
10848 logfile_top_uint (hashlist_format);
10849
10850 /**
10851 * load hashes, part II: allocate required memory, set pointers
10852 */
10853
10854 hash_t *hashes_buf = NULL;
10855 void *digests_buf = NULL;
10856 salt_t *salts_buf = NULL;
10857 void *esalts_buf = NULL;
10858
10859 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10860
10861 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10862
10863 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10864 {
10865 u32 hash_pos;
10866
10867 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10868 {
10869 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10870
10871 hashes_buf[hash_pos].hash_info = hash_info;
10872
10873 if (username && (remove || show || left))
10874 {
10875 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10876 }
10877
10878 if (benchmark)
10879 {
10880 hash_info->orighash = (char *) mymalloc (256);
10881 }
10882 }
10883 }
10884
10885 if (isSalted)
10886 {
10887 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10888
10889 if (esalt_size)
10890 {
10891 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10892 }
10893 }
10894 else
10895 {
10896 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10897 }
10898
10899 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10900 {
10901 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10902
10903 if (isSalted)
10904 {
10905 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10906
10907 if (esalt_size)
10908 {
10909 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10910 }
10911 }
10912 else
10913 {
10914 hashes_buf[hash_pos].salt = &salts_buf[0];
10915 }
10916 }
10917
10918 /**
10919 * load hashes, part III: parse hashes or generate them if benchmark
10920 */
10921
10922 uint hashes_cnt = 0;
10923
10924 if (benchmark == 0)
10925 {
10926 if (keyspace == 1)
10927 {
10928 // useless to read hash file for keyspace, cheat a little bit w/ optind
10929 }
10930 else if (hashes_avail == 0)
10931 {
10932 }
10933 else if (hashlist_mode == HL_MODE_ARG)
10934 {
10935 char *input_buf = myargv[optind];
10936
10937 uint input_len = strlen (input_buf);
10938
10939 logfile_top_var_string ("target", input_buf);
10940
10941 char *hash_buf = NULL;
10942 int hash_len = 0;
10943
10944 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10945
10946 if (hash_len)
10947 {
10948 if (opts_type & OPTS_TYPE_HASH_COPY)
10949 {
10950 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10951
10952 hash_info_tmp->orighash = mystrdup (hash_buf);
10953 }
10954
10955 if (isSalted)
10956 {
10957 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10958 }
10959
10960 int parser_status = PARSER_OK;
10961
10962 if (hash_mode == 2500)
10963 {
10964 if (hash_len == 0)
10965 {
10966 log_error ("ERROR: hccap file not specified");
10967
10968 return (-1);
10969 }
10970
10971 hashlist_mode = HL_MODE_FILE;
10972
10973 data.hashlist_mode = hashlist_mode;
10974
10975 FILE *fp = fopen (hash_buf, "rb");
10976
10977 if (fp == NULL)
10978 {
10979 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10980
10981 return (-1);
10982 }
10983
10984 if (hashes_avail < 1)
10985 {
10986 log_error ("ERROR: hccap file is empty or corrupt");
10987
10988 fclose (fp);
10989
10990 return (-1);
10991 }
10992
10993 uint hccap_size = sizeof (hccap_t);
10994
10995 char *in = (char *) mymalloc (hccap_size);
10996
10997 while (!feof (fp))
10998 {
10999 int n = fread (in, hccap_size, 1, fp);
11000
11001 if (n != 1)
11002 {
11003 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11004
11005 break;
11006 }
11007
11008 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11009
11010 if (parser_status != PARSER_OK)
11011 {
11012 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11013
11014 continue;
11015 }
11016
11017 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11018
11019 if ((show == 1) || (left == 1))
11020 {
11021 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11022
11023 char *salt_ptr = (char *) tmp_salt->salt_buf;
11024
11025 int cur_pos = tmp_salt->salt_len;
11026 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11027
11028 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11029
11030 u8 *pke_ptr = (u8 *) wpa->pke;
11031
11032 // do the appending task
11033
11034 snprintf (salt_ptr + cur_pos,
11035 rem_len,
11036 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11037 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11038 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11039
11040
11041 // memset () the remaining part of the salt
11042
11043 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11044 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11045
11046 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11047
11048 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11049 }
11050
11051 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);
11052 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);
11053
11054 hashes_cnt++;
11055 }
11056
11057 fclose (fp);
11058
11059 myfree (in);
11060 }
11061 else if (hash_mode == 3000)
11062 {
11063 if (hash_len == 32)
11064 {
11065 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11066
11067 hash_t *lm_hash_left = NULL;
11068
11069 if (parser_status == PARSER_OK)
11070 {
11071 lm_hash_left = &hashes_buf[hashes_cnt];
11072
11073 hashes_cnt++;
11074 }
11075 else
11076 {
11077 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11078 }
11079
11080 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11081
11082 hash_t *lm_hash_right = NULL;
11083
11084 if (parser_status == PARSER_OK)
11085 {
11086 lm_hash_right = &hashes_buf[hashes_cnt];
11087
11088 hashes_cnt++;
11089 }
11090 else
11091 {
11092 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11093 }
11094
11095 // show / left
11096
11097 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11098 {
11099 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);
11100 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);
11101 }
11102 }
11103 else
11104 {
11105 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11106
11107 if (parser_status == PARSER_OK)
11108 {
11109 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11110 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11111 }
11112
11113 if (parser_status == PARSER_OK)
11114 {
11115 hashes_cnt++;
11116 }
11117 else
11118 {
11119 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11120 }
11121 }
11122 }
11123 else
11124 {
11125 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11126
11127 if (parser_status == PARSER_OK)
11128 {
11129 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11130 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11131 }
11132
11133 if (parser_status == PARSER_OK)
11134 {
11135 hashes_cnt++;
11136 }
11137 else
11138 {
11139 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11140 }
11141 }
11142 }
11143 }
11144 else if (hashlist_mode == HL_MODE_FILE)
11145 {
11146 char *hashfile = data.hashfile;
11147
11148 FILE *fp;
11149
11150 if ((fp = fopen (hashfile, "rb")) == NULL)
11151 {
11152 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11153
11154 return (-1);
11155 }
11156
11157 uint line_num = 0;
11158
11159 while (!feof (fp))
11160 {
11161 line_num++;
11162
11163 char line_buf[BUFSIZ] = { 0 };
11164
11165 int line_len = fgetl (fp, line_buf);
11166
11167 if (line_len == 0) continue;
11168
11169 char *hash_buf = NULL;
11170 int hash_len = 0;
11171
11172 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11173
11174 if (username)
11175 {
11176 char *user_buf = NULL;
11177 int user_len = 0;
11178
11179 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11180
11181 if (remove || show)
11182 {
11183 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11184
11185 *user = (user_t *) mymalloc (sizeof (user_t));
11186
11187 user_t *user_ptr = *user;
11188
11189 if (user_buf != NULL)
11190 {
11191 user_ptr->user_name = mystrdup (user_buf);
11192 }
11193 else
11194 {
11195 user_ptr->user_name = mystrdup ("");
11196 }
11197
11198 user_ptr->user_len = user_len;
11199 }
11200 }
11201
11202 if (opts_type & OPTS_TYPE_HASH_COPY)
11203 {
11204 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11205
11206 hash_info_tmp->orighash = mystrdup (hash_buf);
11207 }
11208
11209 if (isSalted)
11210 {
11211 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11212 }
11213
11214 if (hash_mode == 3000)
11215 {
11216 if (hash_len == 32)
11217 {
11218 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11219
11220 if (parser_status < PARSER_GLOBAL_ZERO)
11221 {
11222 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11223
11224 continue;
11225 }
11226
11227 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11228
11229 hashes_cnt++;
11230
11231 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11232
11233 if (parser_status < PARSER_GLOBAL_ZERO)
11234 {
11235 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11236
11237 continue;
11238 }
11239
11240 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11241
11242 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);
11243
11244 hashes_cnt++;
11245
11246 // show / left
11247
11248 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);
11249 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);
11250 }
11251 else
11252 {
11253 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11254
11255 if (parser_status < PARSER_GLOBAL_ZERO)
11256 {
11257 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11258
11259 continue;
11260 }
11261
11262 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);
11263
11264 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11265 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11266
11267 hashes_cnt++;
11268 }
11269 }
11270 else
11271 {
11272 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11273
11274 if (parser_status < PARSER_GLOBAL_ZERO)
11275 {
11276 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11277
11278 continue;
11279 }
11280
11281 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);
11282
11283 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11284 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11285
11286 hashes_cnt++;
11287 }
11288 }
11289
11290 fclose (fp);
11291
11292 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11293
11294 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11295 }
11296 }
11297 else
11298 {
11299 if (isSalted)
11300 {
11301 hashes_buf[0].salt->salt_len = 8;
11302
11303 // special salt handling
11304
11305 switch (hash_mode)
11306 {
11307 case 1500: hashes_buf[0].salt->salt_len = 2;
11308 break;
11309 case 1731: hashes_buf[0].salt->salt_len = 4;
11310 break;
11311 case 2410: hashes_buf[0].salt->salt_len = 4;
11312 break;
11313 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11314 break;
11315 case 3100: hashes_buf[0].salt->salt_len = 1;
11316 break;
11317 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11318 break;
11319 case 5800: hashes_buf[0].salt->salt_len = 16;
11320 break;
11321 case 6800: hashes_buf[0].salt->salt_len = 32;
11322 break;
11323 case 8400: hashes_buf[0].salt->salt_len = 40;
11324 break;
11325 case 8800: hashes_buf[0].salt->salt_len = 16;
11326 break;
11327 case 8900: hashes_buf[0].salt->salt_len = 16;
11328 hashes_buf[0].salt->scrypt_N = 1024;
11329 hashes_buf[0].salt->scrypt_r = 1;
11330 hashes_buf[0].salt->scrypt_p = 1;
11331 break;
11332 case 9100: hashes_buf[0].salt->salt_len = 16;
11333 break;
11334 case 9300: hashes_buf[0].salt->salt_len = 14;
11335 hashes_buf[0].salt->scrypt_N = 16384;
11336 hashes_buf[0].salt->scrypt_r = 1;
11337 hashes_buf[0].salt->scrypt_p = 1;
11338 break;
11339 case 9400: hashes_buf[0].salt->salt_len = 16;
11340 break;
11341 case 9500: hashes_buf[0].salt->salt_len = 16;
11342 break;
11343 case 9600: hashes_buf[0].salt->salt_len = 16;
11344 break;
11345 case 9700: hashes_buf[0].salt->salt_len = 16;
11346 break;
11347 case 9710: hashes_buf[0].salt->salt_len = 16;
11348 break;
11349 case 9720: hashes_buf[0].salt->salt_len = 16;
11350 break;
11351 case 9800: hashes_buf[0].salt->salt_len = 16;
11352 break;
11353 case 9810: hashes_buf[0].salt->salt_len = 16;
11354 break;
11355 case 9820: hashes_buf[0].salt->salt_len = 16;
11356 break;
11357 case 10300: hashes_buf[0].salt->salt_len = 12;
11358 break;
11359 case 11500: hashes_buf[0].salt->salt_len = 4;
11360 break;
11361 case 11600: hashes_buf[0].salt->salt_len = 4;
11362 break;
11363 case 12400: hashes_buf[0].salt->salt_len = 4;
11364 break;
11365 case 12500: hashes_buf[0].salt->salt_len = 8;
11366 break;
11367 case 12600: hashes_buf[0].salt->salt_len = 64;
11368 break;
11369 }
11370
11371 // special esalt handling
11372
11373 switch (hash_mode)
11374 {
11375 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11376 break;
11377 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11378 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11379 break;
11380 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11381 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11382 break;
11383 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11384 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11385 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11386 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11387 break;
11388 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11389 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11390 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11391 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11392 break;
11393 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11394 break;
11395 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11396 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11397 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11398 break;
11399 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11400 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11401 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11402 break;
11403 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11404 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11405 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11406 break;
11407 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11408 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11409 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11410 break;
11411 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11412 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11413 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11414 break;
11415 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11416 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11417 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11418 break;
11419 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11420 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11421 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11422 break;
11423 }
11424 }
11425
11426 // set hashfile
11427
11428 switch (hash_mode)
11429 {
11430 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11431 break;
11432 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11433 break;
11434 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11435 break;
11436 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11437 break;
11438 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11439 break;
11440 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11441 break;
11442 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11443 break;
11444 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11445 break;
11446 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11447 break;
11448 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11449 break;
11450 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11451 break;
11452 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11453 break;
11454 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11455 break;
11456 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11457 break;
11458 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11459 break;
11460 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11461 break;
11462 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11463 break;
11464 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11465 break;
11466 }
11467
11468 // set default iterations
11469
11470 switch (hash_mode)
11471 {
11472 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11473 break;
11474 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11475 break;
11476 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11477 break;
11478 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11479 break;
11480 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11481 break;
11482 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11483 break;
11484 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11485 break;
11486 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11487 break;
11488 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11489 break;
11490 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11491 break;
11492 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11493 break;
11494 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11495 break;
11496 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11497 break;
11498 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11499 break;
11500 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11501 break;
11502 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11503 break;
11504 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11505 break;
11506 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11507 break;
11508 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11509 break;
11510 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11511 break;
11512 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11513 break;
11514 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11515 break;
11516 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11517 break;
11518 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11519 break;
11520 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11521 break;
11522 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11523 break;
11524 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11525 break;
11526 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11527 break;
11528 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11529 break;
11530 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11531 break;
11532 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11533 break;
11534 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11535 break;
11536 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11537 break;
11538 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11539 break;
11540 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11541 break;
11542 case 8900: hashes_buf[0].salt->salt_iter = 1;
11543 break;
11544 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11545 break;
11546 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11547 break;
11548 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11549 break;
11550 case 9300: hashes_buf[0].salt->salt_iter = 1;
11551 break;
11552 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11553 break;
11554 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11555 break;
11556 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11557 break;
11558 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11559 break;
11560 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11561 break;
11562 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11563 break;
11564 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11565 break;
11566 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11567 break;
11568 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11569 break;
11570 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11571 break;
11572 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11573 break;
11574 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11575 break;
11576 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11577 break;
11578 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11579 break;
11580 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11581 break;
11582 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11583 break;
11584 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11585 break;
11586 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11587 break;
11588 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11589 break;
11590 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11591 break;
11592 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11593 break;
11594 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11595 break;
11596 }
11597
11598 hashes_cnt = 1;
11599 }
11600
11601 if (show == 1 || left == 1)
11602 {
11603 for (uint i = 0; i < pot_cnt; i++)
11604 {
11605 pot_t *pot_ptr = &pot[i];
11606
11607 hash_t *hashes_buf = &pot_ptr->hash;
11608
11609 local_free (hashes_buf->digest);
11610
11611 if (isSalted)
11612 {
11613 local_free (hashes_buf->salt);
11614 }
11615 }
11616
11617 local_free (pot);
11618
11619 if (data.quiet == 0) log_info_nn ("");
11620
11621 return (0);
11622 }
11623
11624 if (keyspace == 0)
11625 {
11626 if (hashes_cnt == 0)
11627 {
11628 log_error ("ERROR: No hashes loaded");
11629
11630 return (-1);
11631 }
11632 }
11633
11634 /**
11635 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11636 */
11637
11638 if (data.outfile != NULL)
11639 {
11640 if (data.hashfile != NULL)
11641 {
11642 #ifdef _POSIX
11643 struct stat tmpstat_outfile;
11644 struct stat tmpstat_hashfile;
11645 #endif
11646
11647 #ifdef _WIN
11648 struct stat64 tmpstat_outfile;
11649 struct stat64 tmpstat_hashfile;
11650 #endif
11651
11652 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11653
11654 if (tmp_outfile_fp)
11655 {
11656 #ifdef _POSIX
11657 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11658 #endif
11659
11660 #ifdef _WIN
11661 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11662 #endif
11663
11664 fclose (tmp_outfile_fp);
11665 }
11666
11667 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11668
11669 if (tmp_hashfile_fp)
11670 {
11671 #ifdef _POSIX
11672 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11673 #endif
11674
11675 #ifdef _WIN
11676 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11677 #endif
11678
11679 fclose (tmp_hashfile_fp);
11680 }
11681
11682 if (tmp_outfile_fp && tmp_outfile_fp)
11683 {
11684 tmpstat_outfile.st_mode = 0;
11685 tmpstat_outfile.st_nlink = 0;
11686 tmpstat_outfile.st_uid = 0;
11687 tmpstat_outfile.st_gid = 0;
11688 tmpstat_outfile.st_rdev = 0;
11689 tmpstat_outfile.st_atime = 0;
11690
11691 tmpstat_hashfile.st_mode = 0;
11692 tmpstat_hashfile.st_nlink = 0;
11693 tmpstat_hashfile.st_uid = 0;
11694 tmpstat_hashfile.st_gid = 0;
11695 tmpstat_hashfile.st_rdev = 0;
11696 tmpstat_hashfile.st_atime = 0;
11697
11698 #ifdef _POSIX
11699 tmpstat_outfile.st_blksize = 0;
11700 tmpstat_outfile.st_blocks = 0;
11701
11702 tmpstat_hashfile.st_blksize = 0;
11703 tmpstat_hashfile.st_blocks = 0;
11704 #endif
11705
11706 #ifdef _POSIX
11707 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11708 {
11709 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11710
11711 return (-1);
11712 }
11713 #endif
11714
11715 #ifdef _WIN
11716 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11717 {
11718 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11719
11720 return (-1);
11721 }
11722 #endif
11723 }
11724 }
11725 }
11726
11727 /**
11728 * Remove duplicates
11729 */
11730
11731 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11732
11733 if (isSalted)
11734 {
11735 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11736 }
11737 else
11738 {
11739 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11740 }
11741
11742 uint hashes_cnt_orig = hashes_cnt;
11743
11744 hashes_cnt = 1;
11745
11746 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11747 {
11748 if (isSalted)
11749 {
11750 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11751 {
11752 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11753 }
11754 }
11755 else
11756 {
11757 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11758 }
11759
11760 if (hashes_pos > hashes_cnt)
11761 {
11762 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11763 }
11764
11765 hashes_cnt++;
11766 }
11767
11768 /**
11769 * Potfile removes
11770 */
11771
11772 uint potfile_remove_cracks = 0;
11773
11774 if (potfile_disable == 0)
11775 {
11776 hash_t hash_buf;
11777
11778 hash_buf.digest = mymalloc (dgst_size);
11779 hash_buf.salt = NULL;
11780 hash_buf.esalt = NULL;
11781 hash_buf.hash_info = NULL;
11782 hash_buf.cracked = 0;
11783
11784 if (isSalted)
11785 {
11786 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11787 }
11788
11789 if (esalt_size)
11790 {
11791 hash_buf.esalt = mymalloc (esalt_size);
11792 }
11793
11794 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11795
11796 // no solution for these special hash types (for instane because they use hashfile in output etc)
11797 if ((hash_mode != 5200) &&
11798 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11799 (hash_mode != 9000))
11800 {
11801 FILE *fp = fopen (potfile, "rb");
11802
11803 if (fp != NULL)
11804 {
11805 while (!feof (fp))
11806 {
11807 char line_buf[BUFSIZ] = { 0 };
11808
11809 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11810
11811 if (ptr == NULL) break;
11812
11813 int line_len = strlen (line_buf);
11814
11815 if (line_len == 0) continue;
11816
11817 int iter = MAX_CUT_TRIES;
11818
11819 for (int i = line_len - 1; i && iter; i--, line_len--)
11820 {
11821 if (line_buf[i] != ':') continue;
11822
11823 if (isSalted)
11824 {
11825 memset (hash_buf.salt, 0, sizeof (salt_t));
11826 }
11827
11828 hash_t *found = NULL;
11829
11830 if (hash_mode == 6800)
11831 {
11832 if (i < 64) // 64 = 16 * uint in salt_buf[]
11833 {
11834 // manipulate salt_buf
11835 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11836
11837 hash_buf.salt->salt_len = i;
11838
11839 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11840 }
11841 }
11842 else if (hash_mode == 2500)
11843 {
11844 if (i < 64) // 64 = 16 * uint in salt_buf[]
11845 {
11846 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11847 // manipulate salt_buf
11848
11849 // to be safe work with a copy (because of line_len loop, i etc)
11850
11851 char line_buf_cpy[BUFSIZ] = { 0 };
11852
11853 memcpy (line_buf_cpy, line_buf, i);
11854
11855 char *mac2_pos = strrchr (line_buf_cpy, ':');
11856
11857 if (mac2_pos == NULL) continue;
11858
11859 mac2_pos[0] = 0;
11860 mac2_pos++;
11861
11862 if (strlen (mac2_pos) != 12) continue;
11863
11864 char *mac1_pos = strrchr (line_buf_cpy, ':');
11865
11866 if (mac1_pos == NULL) continue;
11867
11868 mac1_pos[0] = 0;
11869 mac1_pos++;
11870
11871 if (strlen (mac1_pos) != 12) continue;
11872
11873 uint essid_length = mac1_pos - line_buf_cpy - 1;
11874
11875 // here we need the ESSID
11876 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11877
11878 hash_buf.salt->salt_len = essid_length;
11879
11880 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11881
11882 if (found)
11883 {
11884 wpa_t *wpa = (wpa_t *) found->esalt;
11885
11886 uint pke[25] = { 0 };
11887
11888 char *pke_ptr = (char *) pke;
11889
11890 for (uint i = 0; i < 25; i++)
11891 {
11892 pke[i] = byte_swap_32 (wpa->pke[i]);
11893 }
11894
11895 u8 mac1[6] = { 0 };
11896 u8 mac2[6] = { 0 };
11897
11898 memcpy (mac1, pke_ptr + 23, 6);
11899 memcpy (mac2, pke_ptr + 29, 6);
11900
11901 // compare hex string(s) vs binary MAC address(es)
11902
11903 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11904 {
11905 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11906 {
11907 found = NULL;
11908 break;
11909 }
11910 }
11911
11912 // early skip ;)
11913 if (!found) continue;
11914
11915 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11916 {
11917 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11918 {
11919 found = NULL;
11920 break;
11921 }
11922 }
11923 }
11924 }
11925 }
11926 else
11927 {
11928 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11929
11930 if (parser_status == PARSER_OK)
11931 {
11932 if (isSalted)
11933 {
11934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11935 }
11936 else
11937 {
11938 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11939 }
11940 }
11941 }
11942
11943 if (found == NULL) continue;
11944
11945 if (!found->cracked) potfile_remove_cracks++;
11946
11947 found->cracked = 1;
11948
11949 if (found) break;
11950
11951 iter--;
11952 }
11953 }
11954
11955 fclose (fp);
11956 }
11957 }
11958
11959 if (esalt_size)
11960 {
11961 local_free (hash_buf.esalt);
11962 }
11963
11964 if (isSalted)
11965 {
11966 local_free (hash_buf.salt);
11967 }
11968
11969 local_free (hash_buf.digest);
11970 }
11971
11972 /**
11973 * Now generate all the buffers required for later
11974 */
11975
11976 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11977
11978 salt_t *salts_buf_new = NULL;
11979 void *esalts_buf_new = NULL;
11980
11981 if (isSalted)
11982 {
11983 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11984
11985 if (esalt_size)
11986 {
11987 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11988 }
11989 }
11990 else
11991 {
11992 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11993 }
11994
11995 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11996
11997 uint digests_cnt = hashes_cnt;
11998 uint digests_done = 0;
11999
12000 uint size_digests = digests_cnt * dgst_size;
12001 uint size_shown = digests_cnt * sizeof (uint);
12002
12003 uint *digests_shown = (uint *) mymalloc (size_shown);
12004 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12005
12006 uint salts_cnt = 0;
12007 uint salts_done = 0;
12008
12009 hashinfo_t **hash_info = NULL;
12010
12011 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12012 {
12013 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12014
12015 if (username && (remove || show))
12016 {
12017 uint user_pos;
12018
12019 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12020 {
12021 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12022
12023 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12024 }
12025 }
12026 }
12027
12028 uint *salts_shown = (uint *) mymalloc (size_shown);
12029
12030 salt_t *salt_buf;
12031
12032 {
12033 // copied from inner loop
12034
12035 salt_buf = &salts_buf_new[salts_cnt];
12036
12037 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12038
12039 if (esalt_size)
12040 {
12041 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12042 }
12043
12044 salt_buf->digests_cnt = 0;
12045 salt_buf->digests_done = 0;
12046 salt_buf->digests_offset = 0;
12047
12048 salts_cnt++;
12049 }
12050
12051 if (hashes_buf[0].cracked == 1)
12052 {
12053 digests_shown[0] = 1;
12054
12055 digests_done++;
12056
12057 salt_buf->digests_done++;
12058 }
12059
12060 salt_buf->digests_cnt++;
12061
12062 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12063
12064 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12065 {
12066 hash_info[0] = hashes_buf[0].hash_info;
12067 }
12068
12069 // copy from inner loop
12070
12071 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12072 {
12073 if (isSalted)
12074 {
12075 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12076 {
12077 salt_buf = &salts_buf_new[salts_cnt];
12078
12079 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12080
12081 if (esalt_size)
12082 {
12083 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12084 }
12085
12086 salt_buf->digests_cnt = 0;
12087 salt_buf->digests_done = 0;
12088 salt_buf->digests_offset = hashes_pos;
12089
12090 salts_cnt++;
12091 }
12092 }
12093
12094 if (hashes_buf[hashes_pos].cracked == 1)
12095 {
12096 digests_shown[hashes_pos] = 1;
12097
12098 digests_done++;
12099
12100 salt_buf->digests_done++;
12101 }
12102
12103 salt_buf->digests_cnt++;
12104
12105 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12106
12107 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12108 {
12109 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12110 }
12111 }
12112
12113 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12114 {
12115 salt_t *salt_buf = &salts_buf_new[salt_pos];
12116
12117 if (salt_buf->digests_done == salt_buf->digests_cnt)
12118 {
12119 salts_shown[salt_pos] = 1;
12120
12121 salts_done++;
12122 }
12123
12124 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12125 }
12126
12127 local_free (digests_buf);
12128 local_free (salts_buf);
12129 local_free (esalts_buf);
12130
12131 digests_buf = digests_buf_new;
12132 salts_buf = salts_buf_new;
12133 esalts_buf = esalts_buf_new;
12134
12135 local_free (hashes_buf);
12136
12137 /**
12138 * special modification not set from parser
12139 */
12140
12141 switch (hash_mode)
12142 {
12143 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12144 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12145 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12146 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12147 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12148 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12149 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12150 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12151 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12152 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12153 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12154 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12155 }
12156
12157 if (truecrypt_keyfiles)
12158 {
12159 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12160
12161 char *keyfiles = strdup (truecrypt_keyfiles);
12162
12163 char *keyfile = strtok (keyfiles, ",");
12164
12165 do
12166 {
12167 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12168
12169 } while ((keyfile = strtok (NULL, ",")) != NULL);
12170
12171 free (keyfiles);
12172 }
12173
12174 data.digests_cnt = digests_cnt;
12175 data.digests_done = digests_done;
12176 data.digests_buf = digests_buf;
12177 data.digests_shown = digests_shown;
12178 data.digests_shown_tmp = digests_shown_tmp;
12179
12180 data.salts_cnt = salts_cnt;
12181 data.salts_done = salts_done;
12182 data.salts_buf = salts_buf;
12183 data.salts_shown = salts_shown;
12184
12185 data.esalts_buf = esalts_buf;
12186 data.hash_info = hash_info;
12187
12188 /**
12189 * Automatic Optimizers
12190 */
12191
12192 if (salts_cnt == 1)
12193 opti_type |= OPTI_TYPE_SINGLE_SALT;
12194
12195 if (digests_cnt == 1)
12196 opti_type |= OPTI_TYPE_SINGLE_HASH;
12197
12198 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12199 opti_type |= OPTI_TYPE_NOT_ITERATED;
12200
12201 if (attack_mode == ATTACK_MODE_BF)
12202 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12203
12204 data.opti_type = opti_type;
12205
12206 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12207 {
12208 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12209 {
12210 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12211 {
12212 if (opts_type & OPTS_TYPE_ST_ADD80)
12213 {
12214 opts_type &= ~OPTS_TYPE_ST_ADD80;
12215 opts_type |= OPTS_TYPE_PT_ADD80;
12216 }
12217
12218 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12219 {
12220 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12221 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12222 }
12223
12224 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12225 {
12226 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12227 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12228 }
12229 }
12230 }
12231 }
12232
12233 /**
12234 * Some algorithm, like descrypt, can benefit from JIT compilation
12235 */
12236
12237 int force_jit_compilation = -1;
12238
12239 if (hash_mode == 8900)
12240 {
12241 force_jit_compilation = 8900;
12242 }
12243 else if (hash_mode == 9300)
12244 {
12245 force_jit_compilation = 8900;
12246 }
12247 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12248 {
12249 force_jit_compilation = 1500;
12250 }
12251
12252 /**
12253 * generate bitmap tables
12254 */
12255
12256 const uint bitmap_shift1 = 5;
12257 const uint bitmap_shift2 = 13;
12258
12259 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12260
12261 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12262 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12263 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12264 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12265 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12266 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12267 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12268 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12269
12270 uint bitmap_bits;
12271 uint bitmap_nums;
12272 uint bitmap_mask;
12273 uint bitmap_size;
12274
12275 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12276 {
12277 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12278
12279 bitmap_nums = 1 << bitmap_bits;
12280
12281 bitmap_mask = bitmap_nums - 1;
12282
12283 bitmap_size = bitmap_nums * sizeof (uint);
12284
12285 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12286
12287 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;
12288 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;
12289
12290 break;
12291 }
12292
12293 bitmap_nums = 1 << bitmap_bits;
12294
12295 bitmap_mask = bitmap_nums - 1;
12296
12297 bitmap_size = bitmap_nums * sizeof (uint);
12298
12299 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);
12300 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);
12301
12302 /**
12303 * prepare quick rule
12304 */
12305
12306 data.rule_buf_l = rule_buf_l;
12307 data.rule_buf_r = rule_buf_r;
12308
12309 int rule_len_l = (int) strlen (rule_buf_l);
12310 int rule_len_r = (int) strlen (rule_buf_r);
12311
12312 data.rule_len_l = rule_len_l;
12313 data.rule_len_r = rule_len_r;
12314
12315 /**
12316 * load rules
12317 */
12318
12319 uint *all_kernel_rules_cnt = NULL;
12320
12321 kernel_rule_t **all_kernel_rules_buf = NULL;
12322
12323 if (rp_files_cnt)
12324 {
12325 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12326
12327 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12328 }
12329
12330 char rule_buf[BUFSIZ] = { 0 };
12331
12332 int rule_len = 0;
12333
12334 for (uint i = 0; i < rp_files_cnt; i++)
12335 {
12336 uint kernel_rules_avail = 0;
12337
12338 uint kernel_rules_cnt = 0;
12339
12340 kernel_rule_t *kernel_rules_buf = NULL;
12341
12342 char *rp_file = rp_files[i];
12343
12344 char in[BLOCK_SIZE] = { 0 };
12345 char out[BLOCK_SIZE] = { 0 };
12346
12347 FILE *fp = NULL;
12348
12349 uint rule_line = 0;
12350
12351 if ((fp = fopen (rp_file, "rb")) == NULL)
12352 {
12353 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12354
12355 return (-1);
12356 }
12357
12358 while (!feof (fp))
12359 {
12360 memset (rule_buf, 0, BUFSIZ);
12361
12362 rule_len = fgetl (fp, rule_buf);
12363
12364 rule_line++;
12365
12366 if (rule_len == 0) continue;
12367
12368 if (rule_buf[0] == '#') continue;
12369
12370 if (kernel_rules_avail == kernel_rules_cnt)
12371 {
12372 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12373
12374 kernel_rules_avail += INCR_RULES;
12375 }
12376
12377 memset (in, 0, BLOCK_SIZE);
12378 memset (out, 0, BLOCK_SIZE);
12379
12380 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12381
12382 if (result == -1)
12383 {
12384 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12385
12386 continue;
12387 }
12388
12389 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12390 {
12391 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12392
12393 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12394
12395 continue;
12396 }
12397
12398 /* its so slow
12399 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12400 {
12401 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12402
12403 continue;
12404 }
12405 */
12406
12407 kernel_rules_cnt++;
12408 }
12409
12410 fclose (fp);
12411
12412 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12413
12414 all_kernel_rules_buf[i] = kernel_rules_buf;
12415 }
12416
12417 /**
12418 * merge rules or automatic rule generator
12419 */
12420
12421 uint kernel_rules_cnt = 0;
12422
12423 kernel_rule_t *kernel_rules_buf = NULL;
12424
12425 if (attack_mode == ATTACK_MODE_STRAIGHT)
12426 {
12427 if (rp_files_cnt)
12428 {
12429 kernel_rules_cnt = 1;
12430
12431 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12432
12433 repeats[0] = kernel_rules_cnt;
12434
12435 for (uint i = 0; i < rp_files_cnt; i++)
12436 {
12437 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12438
12439 repeats[i + 1] = kernel_rules_cnt;
12440 }
12441
12442 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12443
12444 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12445
12446 for (uint i = 0; i < kernel_rules_cnt; i++)
12447 {
12448 uint out_pos = 0;
12449
12450 kernel_rule_t *out = &kernel_rules_buf[i];
12451
12452 for (uint j = 0; j < rp_files_cnt; j++)
12453 {
12454 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12455 uint in_pos;
12456
12457 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12458
12459 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12460 {
12461 if (out_pos == RULES_MAX - 1)
12462 {
12463 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12464
12465 break;
12466 }
12467
12468 out->cmds[out_pos] = in->cmds[in_pos];
12469 }
12470 }
12471 }
12472
12473 local_free (repeats);
12474 }
12475 else if (rp_gen)
12476 {
12477 uint kernel_rules_avail = 0;
12478
12479 while (kernel_rules_cnt < rp_gen)
12480 {
12481 if (kernel_rules_avail == kernel_rules_cnt)
12482 {
12483 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12484
12485 kernel_rules_avail += INCR_RULES;
12486 }
12487
12488 memset (rule_buf, 0, BLOCK_SIZE);
12489
12490 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12491
12492 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12493
12494 kernel_rules_cnt++;
12495 }
12496 }
12497 }
12498
12499 /**
12500 * generate NOP rules
12501 */
12502
12503 if (kernel_rules_cnt == 0)
12504 {
12505 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12506
12507 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12508
12509 kernel_rules_cnt++;
12510 }
12511
12512 data.kernel_rules_cnt = kernel_rules_cnt;
12513 data.kernel_rules_buf = kernel_rules_buf;
12514
12515 /**
12516 * OpenCL platforms: detect
12517 */
12518
12519 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12520 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12521
12522 cl_uint platforms_cnt = 0;
12523 cl_uint platform_devices_cnt = 0;
12524
12525 if (keyspace == 0)
12526 {
12527 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12528
12529 if (platforms_cnt == 0)
12530 {
12531 log_error ("ERROR: No OpenCL compatible platform found");
12532
12533 return (-1);
12534 }
12535
12536 if (opencl_platforms_filter != (uint) -1)
12537 {
12538 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12539
12540 if (opencl_platforms_filter > platform_cnt_mask)
12541 {
12542 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12543
12544 return (-1);
12545 }
12546 }
12547 }
12548
12549 /**
12550 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12551 */
12552
12553 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12554 {
12555 cl_platform_id platform = platforms[platform_id];
12556
12557 char platform_vendor[INFOSZ] = { 0 };
12558
12559 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12560
12561 #ifdef HAVE_HWMON
12562 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12563 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12564 {
12565 // make sure that we do not directly control the fan for NVidia
12566
12567 gpu_temp_retain = 0;
12568
12569 data.gpu_temp_retain = gpu_temp_retain;
12570 }
12571 #endif // HAVE_NVML || HAVE_NVAPI
12572 #endif
12573 }
12574
12575 /**
12576 * OpenCL devices: simply push all devices from all platforms into the same device array
12577 */
12578
12579 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12580
12581 data.devices_param = devices_param;
12582
12583 uint devices_cnt = 0;
12584
12585 uint devices_active = 0;
12586
12587 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12588 {
12589 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12590
12591 cl_platform_id platform = platforms[platform_id];
12592
12593 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12594
12595 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12596 {
12597 size_t param_value_size = 0;
12598
12599 const uint device_id = devices_cnt;
12600
12601 hc_device_param_t *device_param = &data.devices_param[device_id];
12602
12603 device_param->device = platform_devices[platform_devices_id];
12604
12605 device_param->device_id = device_id;
12606
12607 device_param->platform_devices_id = platform_devices_id;
12608
12609 // device_type
12610
12611 cl_device_type device_type;
12612
12613 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12614
12615 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12616
12617 device_param->device_type = device_type;
12618
12619 // vendor_id
12620
12621 cl_uint vendor_id = 0;
12622
12623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12624
12625 device_param->vendor_id = vendor_id;
12626
12627 // device_name
12628
12629 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12630
12631 char *device_name = (char *) mymalloc (param_value_size);
12632
12633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12634
12635 device_param->device_name = device_name;
12636
12637 // tuning db
12638
12639 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12640
12641 // device_version
12642
12643 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12644
12645 char *device_version = (char *) mymalloc (param_value_size);
12646
12647 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12648
12649 device_param->device_version = device_version;
12650
12651 // device_opencl_version
12652
12653 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12654
12655 char *device_opencl_version = (char *) mymalloc (param_value_size);
12656
12657 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12658
12659 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12660
12661 myfree (device_opencl_version);
12662
12663 if (strstr (device_version, "pocl"))
12664 {
12665 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12666 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12667
12668 cl_uint vendor_id = VENDOR_ID_GENERIC;
12669
12670 device_param->vendor_id = vendor_id;
12671 }
12672
12673 // vector_width
12674
12675 cl_uint vector_width;
12676
12677 if (opencl_vector_width_chgd == 0)
12678 {
12679 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12680 {
12681 if (opti_type & OPTI_TYPE_USES_BITS_64)
12682 {
12683 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12684 }
12685 else
12686 {
12687 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12688 }
12689 }
12690 else
12691 {
12692 vector_width = (cl_uint) tuningdb_entry->vector_width;
12693 }
12694 }
12695 else
12696 {
12697 vector_width = opencl_vector_width;
12698 }
12699
12700 if (vector_width > 16) vector_width = 16;
12701
12702 device_param->vector_width = vector_width;
12703
12704 // max_compute_units
12705
12706 cl_uint device_processors;
12707
12708 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12709
12710 device_param->device_processors = device_processors;
12711
12712 // max_mem_alloc_size
12713
12714 cl_ulong device_maxmem_alloc;
12715
12716 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12717
12718 device_param->device_maxmem_alloc = device_maxmem_alloc;
12719
12720 // max_mem_alloc_size
12721
12722 cl_ulong device_global_mem;
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12725
12726 device_param->device_global_mem = device_global_mem;
12727
12728 // max_clock_frequency
12729
12730 cl_uint device_maxclock_frequency;
12731
12732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12733
12734 device_param->device_maxclock_frequency = device_maxclock_frequency;
12735
12736 // skipped
12737
12738 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12739 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12740
12741 device_param->skipped = (skipped1 || skipped2);
12742
12743 // driver_version
12744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12745
12746 char *driver_version = (char *) mymalloc (param_value_size);
12747
12748 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12749
12750 device_param->driver_version = driver_version;
12751
12752 // device_name_chksum
12753
12754 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12755
12756 #if __x86_64__
12757 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);
12758 #else
12759 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);
12760 #endif
12761
12762 uint device_name_digest[4] = { 0 };
12763
12764 md5_64 ((uint *) device_name_chksum, device_name_digest);
12765
12766 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12767
12768 device_param->device_name_chksum = device_name_chksum;
12769
12770 // device_processor_cores
12771
12772 if (device_type & CL_DEVICE_TYPE_CPU)
12773 {
12774 cl_uint device_processor_cores = 1;
12775
12776 device_param->device_processor_cores = device_processor_cores;
12777 }
12778
12779 if (device_type & CL_DEVICE_TYPE_GPU)
12780 {
12781 if (vendor_id == VENDOR_ID_AMD)
12782 {
12783 cl_uint device_processor_cores = 0;
12784
12785 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12786
12787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12788
12789 device_param->device_processor_cores = device_processor_cores;
12790 }
12791 else if (vendor_id == VENDOR_ID_NV)
12792 {
12793 cl_uint kernel_exec_timeout = 0;
12794
12795 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12796
12797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12798
12799 device_param->kernel_exec_timeout = kernel_exec_timeout;
12800
12801 cl_uint device_processor_cores = 0;
12802
12803 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12804
12805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12806
12807 device_param->device_processor_cores = device_processor_cores;
12808
12809 cl_uint sm_minor = 0;
12810 cl_uint sm_major = 0;
12811
12812 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12813 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12816 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12817
12818 device_param->sm_minor = sm_minor;
12819 device_param->sm_major = sm_major;
12820 }
12821 else
12822 {
12823 cl_uint device_processor_cores = 1;
12824
12825 device_param->device_processor_cores = device_processor_cores;
12826 }
12827 }
12828
12829 // display results
12830
12831 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12832 {
12833 if (device_param->skipped == 0)
12834 {
12835 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12836 device_id + 1,
12837 device_name,
12838 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12839 (unsigned int) (device_global_mem / 1024 / 1024),
12840 (unsigned int) (device_maxclock_frequency),
12841 (unsigned int) device_processors);
12842 }
12843 else
12844 {
12845 log_info ("Device #%u: %s, skipped",
12846 device_id + 1,
12847 device_name);
12848 }
12849 }
12850
12851 // common driver check
12852
12853 if (device_param->skipped == 0)
12854 {
12855 if (strstr (device_version, "pocl"))
12856 {
12857 if (force == 0)
12858 {
12859 log_info ("");
12860 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12861 log_info ("You are STRONGLY encouraged not to use it");
12862 log_info ("You can use --force to override this but do not post error reports if you do so");
12863 log_info ("");
12864
12865 return (-1);
12866 }
12867 }
12868
12869 if (device_type & CL_DEVICE_TYPE_GPU)
12870 {
12871 if (vendor_id == VENDOR_ID_NV)
12872 {
12873 if (device_param->kernel_exec_timeout != 0)
12874 {
12875 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);
12876 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12877 }
12878 }
12879 else if (vendor_id == VENDOR_ID_AMD)
12880 {
12881 int catalyst_check = (force == 1) ? 0 : 1;
12882
12883 int catalyst_warn = 0;
12884
12885 int catalyst_broken = 0;
12886
12887 if (catalyst_check == 1)
12888 {
12889 catalyst_warn = 1;
12890
12891 // v14.9 and higher
12892 if (atoi (device_param->driver_version) >= 1573)
12893 {
12894 catalyst_warn = 0;
12895 }
12896
12897 catalyst_check = 0;
12898 }
12899
12900 if (catalyst_broken == 1)
12901 {
12902 log_info ("");
12903 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12904 log_info ("It will pass over cracked hashes and does not report them as cracked");
12905 log_info ("You are STRONGLY encouraged not to use it");
12906 log_info ("You can use --force to override this but do not post error reports if you do so");
12907 log_info ("");
12908
12909 return (-1);
12910 }
12911
12912 if (catalyst_warn == 1)
12913 {
12914 log_info ("");
12915 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12916 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12917 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12918 #ifdef _WIN
12919 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12920 #endif
12921 log_info ("You can use --force to override this but do not post error reports if you do so");
12922 log_info ("");
12923
12924 return (-1);
12925 }
12926 }
12927 }
12928
12929 /**
12930 * kernel accel and loops tuning db adjustment
12931 */
12932
12933 device_param->kernel_accel_min = 1;
12934 device_param->kernel_accel_max = 1024;
12935
12936 device_param->kernel_loops_min = 1;
12937 device_param->kernel_loops_max = 1024;
12938
12939 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12940
12941 if (tuningdb_entry)
12942 {
12943 u32 _kernel_accel = tuningdb_entry->kernel_accel;
12944 u32 _kernel_loops = tuningdb_entry->kernel_loops;
12945
12946 if (_kernel_accel)
12947 {
12948 device_param->kernel_accel_min = _kernel_accel;
12949 device_param->kernel_accel_max = _kernel_accel;
12950 }
12951
12952 if (_kernel_loops)
12953 {
12954 if (workload_profile == 1)
12955 {
12956 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12957 }
12958 else if (workload_profile == 2)
12959 {
12960 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12961 }
12962
12963 device_param->kernel_loops_min = _kernel_loops;
12964 device_param->kernel_loops_max = _kernel_loops;
12965 }
12966 }
12967
12968 // commandline parameters overwrite tuningdb entries
12969
12970 if (kernel_accel)
12971 {
12972 device_param->kernel_accel_min = kernel_accel;
12973 device_param->kernel_accel_max = kernel_accel;
12974 }
12975
12976 if (kernel_loops)
12977 {
12978 device_param->kernel_loops_min = kernel_loops;
12979 device_param->kernel_loops_max = kernel_loops;
12980 }
12981
12982 /**
12983 * activate device
12984 */
12985
12986 devices_active++;
12987 }
12988
12989 // next please
12990
12991 devices_cnt++;
12992 }
12993 }
12994
12995 if (keyspace == 0 && devices_active == 0)
12996 {
12997 log_error ("ERROR: No devices found/left");
12998
12999 return (-1);
13000 }
13001
13002 // 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)
13003
13004 if (devices_filter != (uint) -1)
13005 {
13006 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13007
13008 if (devices_filter > devices_cnt_mask)
13009 {
13010 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13011
13012 return (-1);
13013 }
13014 }
13015
13016 data.devices_cnt = devices_cnt;
13017
13018 data.devices_active = devices_active;
13019
13020 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13021 {
13022 log_info ("");
13023 }
13024
13025 /**
13026 * HM devices: init
13027 */
13028
13029 #ifdef HAVE_HWMON
13030 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13031 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13032 #endif
13033
13034 #ifdef HAVE_ADL
13035 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13036 #endif
13037
13038 if (gpu_temp_disable == 0)
13039 {
13040 #if defined(WIN) && defined(HAVE_NVAPI)
13041 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13042
13043 if (nvapi_init (nvapi) == 0)
13044 data.hm_nv = nvapi;
13045
13046 if (data.hm_nv)
13047 {
13048 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13049 {
13050 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13051
13052 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13053
13054 int tmp_out = 0;
13055
13056 for (int i = 0; i < tmp_in; i++)
13057 {
13058 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13059 }
13060
13061 for (int i = 0; i < tmp_out; i++)
13062 {
13063 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13064
13065 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13066
13067 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;
13068 }
13069 }
13070 }
13071 #endif // WIN && HAVE_NVAPI
13072
13073 #if defined(LINUX) && defined(HAVE_NVML)
13074 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13075
13076 if (nvml_init (nvml) == 0)
13077 data.hm_nv = nvml;
13078
13079 if (data.hm_nv)
13080 {
13081 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13082 {
13083 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13084
13085 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13086
13087 int tmp_out = 0;
13088
13089 for (int i = 0; i < tmp_in; i++)
13090 {
13091 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13092 }
13093
13094 for (int i = 0; i < tmp_out; i++)
13095 {
13096 unsigned int speed;
13097
13098 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;
13099 }
13100 }
13101 }
13102 #endif // LINUX && HAVE_NVML
13103
13104 data.hm_amd = NULL;
13105
13106 #ifdef HAVE_ADL
13107 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13108
13109 if (adl_init (adl) == 0)
13110 data.hm_amd = adl;
13111
13112 if (data.hm_amd)
13113 {
13114 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13115 {
13116 // total number of adapters
13117
13118 int hm_adapters_num;
13119
13120 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13121
13122 // adapter info
13123
13124 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13125
13126 if (lpAdapterInfo == NULL) return (-1);
13127
13128 // get a list (of ids of) valid/usable adapters
13129
13130 int num_adl_adapters = 0;
13131
13132 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13133
13134 if (num_adl_adapters > 0)
13135 {
13136 hc_thread_mutex_lock (mux_adl);
13137
13138 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13139
13140 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13141
13142 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13143 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13144
13145 hc_thread_mutex_unlock (mux_adl);
13146 }
13147
13148 myfree (valid_adl_device_list);
13149 myfree (lpAdapterInfo);
13150 }
13151 }
13152 #endif // HAVE_ADL
13153
13154 if (data.hm_amd == NULL && data.hm_nv == NULL)
13155 {
13156 gpu_temp_disable = 1;
13157 }
13158 }
13159
13160 /**
13161 * OpenCL devices: allocate buffer for device specific information
13162 */
13163
13164 #ifdef HAVE_HWMON
13165 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13166
13167 #ifdef HAVE_ADL
13168 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13169
13170 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13171 #endif // ADL
13172 #endif
13173
13174 /**
13175 * enable custom signal handler(s)
13176 */
13177
13178 if (benchmark == 0)
13179 {
13180 hc_signal (sigHandler_default);
13181 }
13182 else
13183 {
13184 hc_signal (sigHandler_benchmark);
13185 }
13186
13187 /**
13188 * User-defined GPU temp handling
13189 */
13190
13191 #ifdef HAVE_HWMON
13192 if (gpu_temp_disable == 1)
13193 {
13194 gpu_temp_abort = 0;
13195 gpu_temp_retain = 0;
13196 }
13197
13198 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13199 {
13200 if (gpu_temp_abort < gpu_temp_retain)
13201 {
13202 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13203
13204 return (-1);
13205 }
13206 }
13207
13208 data.gpu_temp_disable = gpu_temp_disable;
13209 data.gpu_temp_abort = gpu_temp_abort;
13210 data.gpu_temp_retain = gpu_temp_retain;
13211 #endif
13212
13213 /**
13214 * inform the user
13215 */
13216
13217 if (data.quiet == 0)
13218 {
13219 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13220
13221 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);
13222
13223 if (attack_mode == ATTACK_MODE_STRAIGHT)
13224 {
13225 log_info ("Rules: %u", kernel_rules_cnt);
13226 }
13227
13228 if (opti_type)
13229 {
13230 log_info ("Applicable Optimizers:");
13231
13232 for (uint i = 0; i < 32; i++)
13233 {
13234 const uint opti_bit = 1u << i;
13235
13236 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13237 }
13238 }
13239
13240 /**
13241 * Watchdog and Temperature balance
13242 */
13243
13244 #ifdef HAVE_HWMON
13245 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13246 {
13247 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13248 }
13249
13250 if (gpu_temp_abort == 0)
13251 {
13252 log_info ("Watchdog: Temperature abort trigger disabled");
13253 }
13254 else
13255 {
13256 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13257 }
13258
13259 if (gpu_temp_retain == 0)
13260 {
13261 log_info ("Watchdog: Temperature retain trigger disabled");
13262 }
13263 else
13264 {
13265 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13266 }
13267 #endif
13268 }
13269
13270 if (data.quiet == 0) log_info ("");
13271
13272 /**
13273 * HM devices: copy
13274 */
13275
13276 if (gpu_temp_disable == 0)
13277 {
13278 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13279 {
13280 hc_device_param_t *device_param = &data.devices_param[device_id];
13281
13282 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13283
13284 if (device_param->skipped) continue;
13285
13286 const uint platform_devices_id = device_param->platform_devices_id;
13287
13288 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13289 if (device_param->vendor_id == VENDOR_ID_NV)
13290 {
13291 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13292 }
13293 #endif
13294
13295 #ifdef HAVE_ADL
13296 if (device_param->vendor_id == VENDOR_ID_AMD)
13297 {
13298 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13299 }
13300 #endif
13301 }
13302 }
13303
13304 /*
13305 * Temporary fix:
13306 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13307 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13308 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13309 * Driver / ADL bug?
13310 */
13311
13312 #ifdef HAVE_ADL
13313 if (powertune_enable == 1)
13314 {
13315 hc_thread_mutex_lock (mux_adl);
13316
13317 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13318 {
13319 hc_device_param_t *device_param = &data.devices_param[device_id];
13320
13321 if (device_param->skipped) continue;
13322
13323 if (data.hm_device[device_id].od_version == 6)
13324 {
13325 // set powertune value only
13326
13327 int powertune_supported = 0;
13328
13329 int ADL_rc = 0;
13330
13331 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13332 {
13333 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13334
13335 return (-1);
13336 }
13337
13338 if (powertune_supported != 0)
13339 {
13340 // powertune set
13341 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13342
13343 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13344 {
13345 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13346
13347 return (-1);
13348 }
13349
13350 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13351 {
13352 log_error ("ERROR: Failed to set new ADL PowerControl values");
13353
13354 return (-1);
13355 }
13356 }
13357 }
13358 }
13359
13360 hc_thread_mutex_unlock (mux_adl);
13361 }
13362 #endif // HAVE_ADK
13363 #endif // HAVE_HWMON
13364
13365 #ifdef DEBUG
13366 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13367 #endif
13368
13369 uint kernel_power_all = 0;
13370
13371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13372 {
13373 /**
13374 * host buffer
13375 */
13376
13377 hc_device_param_t *device_param = &data.devices_param[device_id];
13378
13379 if (device_param->skipped) continue;
13380
13381 /**
13382 * device properties
13383 */
13384
13385 const char *device_name_chksum = device_param->device_name_chksum;
13386 const u32 device_processors = device_param->device_processors;
13387 const u32 device_processor_cores = device_param->device_processor_cores;
13388
13389 /**
13390 * create context for each device
13391 */
13392
13393 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13394
13395 /**
13396 * create command-queue
13397 */
13398
13399 // not supported with NV
13400 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13401
13402 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13403
13404 /**
13405 * create input buffers on device : calculate size of fixed memory buffers
13406 */
13407
13408 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13409 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13410
13411 device_param->size_root_css = size_root_css;
13412 device_param->size_markov_css = size_markov_css;
13413
13414 uint size_results = KERNEL_THREADS * sizeof (uint);
13415
13416 device_param->size_results = size_results;
13417
13418 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13419 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13420
13421 uint size_plains = digests_cnt * sizeof (plain_t);
13422 uint size_salts = salts_cnt * sizeof (salt_t);
13423 uint size_esalts = salts_cnt * esalt_size;
13424
13425 device_param->size_plains = size_plains;
13426 device_param->size_digests = size_digests;
13427 device_param->size_shown = size_shown;
13428 device_param->size_salts = size_salts;
13429
13430 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13431 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13432 uint size_tm = 32 * sizeof (bs_word_t);
13433
13434 // scryptV stuff
13435
13436 u64 size_scryptV = 1;
13437
13438 if ((hash_mode == 8900) || (hash_mode == 9300))
13439 {
13440 uint tmto_start = 0;
13441 uint tmto_stop = 10;
13442
13443 if (scrypt_tmto)
13444 {
13445 tmto_start = scrypt_tmto;
13446 }
13447 else
13448 {
13449 // in case the user did not specify the tmto manually
13450 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13451 // but set the lower end only in case the user has a device with too less memory
13452
13453 if (hash_mode == 8900)
13454 {
13455 if (device_param->vendor_id == VENDOR_ID_AMD)
13456 {
13457 tmto_start = 1;
13458 }
13459 else if (device_param->vendor_id == VENDOR_ID_NV)
13460 {
13461 tmto_start = 3;
13462 }
13463 }
13464 else if (hash_mode == 9300)
13465 {
13466 if (device_param->vendor_id == VENDOR_ID_AMD)
13467 {
13468 tmto_start = 3;
13469 }
13470 else if (device_param->vendor_id == VENDOR_ID_NV)
13471 {
13472 tmto_start = 5;
13473 }
13474 }
13475 }
13476
13477 if (quiet == 0) log_info ("");
13478
13479 uint shader_per_mp = 1;
13480
13481 if (device_param->vendor_id == VENDOR_ID_AMD)
13482 {
13483 shader_per_mp = 8;
13484 }
13485 else if (device_param->vendor_id == VENDOR_ID_NV)
13486 {
13487 shader_per_mp = 32;
13488 }
13489
13490 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13491 {
13492 // TODO: in theory the following calculation needs to be done per salt, not global
13493 // we assume all hashes have the same scrypt settings
13494
13495 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13496
13497 size_scryptV /= 1 << tmto;
13498
13499 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13500
13501 if (size_scryptV > device_param->device_maxmem_alloc)
13502 {
13503 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13504
13505 continue;
13506 }
13507
13508 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13509 {
13510 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13511 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13512 }
13513
13514 break;
13515 }
13516
13517 if (data.salts_buf[0].scrypt_phy == 0)
13518 {
13519 log_error ("ERROR: can't allocate enough device memory");
13520
13521 return -1;
13522 }
13523
13524 if (quiet == 0) log_info ("");
13525 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13526 }
13527
13528 /**
13529 * create input buffers on device : calculate size of dynamic size memory buffers
13530 */
13531
13532 uint kernel_threads = KERNEL_THREADS;
13533
13534 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13535
13536 if (hash_mode == 3200) kernel_threads = 8;
13537 if (hash_mode == 9000) kernel_threads = 8;
13538
13539 /**
13540 * some algorithms need a fixed kernel-loops count
13541 */
13542
13543 if (hash_mode == 1500)
13544 {
13545 const u32 kernel_loops_fixed = 1024;
13546
13547 device_param->kernel_loops_min = kernel_loops_fixed;
13548 device_param->kernel_loops_max = kernel_loops_fixed;
13549 }
13550
13551 if (hash_mode == 3000)
13552 {
13553 const u32 kernel_loops_fixed = 1024;
13554
13555 device_param->kernel_loops_min = kernel_loops_fixed;
13556 device_param->kernel_loops_max = kernel_loops_fixed;
13557 }
13558
13559 if (hash_mode == 8900)
13560 {
13561 const u32 kernel_loops_fixed = 1;
13562
13563 device_param->kernel_loops_min = kernel_loops_fixed;
13564 device_param->kernel_loops_max = kernel_loops_fixed;
13565 }
13566
13567 if (hash_mode == 9300)
13568 {
13569 const u32 kernel_loops_fixed = 1;
13570
13571 device_param->kernel_loops_min = kernel_loops_fixed;
13572 device_param->kernel_loops_max = kernel_loops_fixed;
13573 }
13574
13575 if (hash_mode == 12500)
13576 {
13577 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13578
13579 device_param->kernel_loops_min = kernel_loops_fixed;
13580 device_param->kernel_loops_max = kernel_loops_fixed;
13581 }
13582
13583 /**
13584 * some algorithms have a maximum kernel-loops count
13585 */
13586
13587 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13588 {
13589 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13590 {
13591 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13592 }
13593 }
13594
13595 /**
13596 * some algorithms need a special kernel-accel
13597 */
13598
13599 if (hash_mode == 8900)
13600 {
13601 device_param->kernel_accel_min = 1;
13602 device_param->kernel_accel_max = 64;
13603 }
13604
13605 if (hash_mode == 9300)
13606 {
13607 device_param->kernel_accel_min = 1;
13608 device_param->kernel_accel_max = 64;
13609 }
13610
13611 u32 kernel_accel_min = device_param->kernel_accel_min;
13612 u32 kernel_accel_max = device_param->kernel_accel_max;
13613
13614 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13615
13616 uint size_pws = 4;
13617 uint size_tmps = 4;
13618 uint size_hooks = 4;
13619
13620 while (kernel_accel_max >= kernel_accel_min)
13621 {
13622 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13623
13624 // size_pws
13625
13626 size_pws = kernel_power_max * sizeof (pw_t);
13627
13628 // size_tmps
13629
13630 switch (hash_mode)
13631 {
13632 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13633 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13634 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13635 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13636 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13637 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13638 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13639 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13640 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13641 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13642 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13643 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13644 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13645 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13646 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13647 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13648 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13649 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13650 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13651 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13652 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13653 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13654 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13655 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13656 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13657 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13658 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13659 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13660 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13661 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13662 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13663 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13664 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13665 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13666 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13667 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13668 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13669 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13670 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13671 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13672 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13673 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13674 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13675 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13676 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13677 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13678 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13679 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13680 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13681 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13682 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13683 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13684 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13685 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13686 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13687 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13688 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13689 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13690 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13691 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13692 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13693 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13694 };
13695
13696 // size_hooks
13697
13698 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13699 {
13700 // none yet
13701 }
13702
13703 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13704 // if not, decrease amplifier and try again
13705
13706 int skip = 0;
13707
13708 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13709 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13710 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13711
13712 if (( bitmap_size
13713 + bitmap_size
13714 + bitmap_size
13715 + bitmap_size
13716 + bitmap_size
13717 + bitmap_size
13718 + bitmap_size
13719 + bitmap_size
13720 + size_bfs
13721 + size_combs
13722 + size_digests
13723 + size_esalts
13724 + size_hooks
13725 + size_markov_css
13726 + size_plains
13727 + size_pws
13728 + size_results
13729 + size_root_css
13730 + size_rules
13731 + size_rules_c
13732 + size_salts
13733 + size_scryptV
13734 + size_shown
13735 + size_tm
13736 + size_tmps) > device_param->device_global_mem) skip = 1;
13737
13738 if (skip == 1)
13739 {
13740 kernel_accel_max--;
13741
13742 continue;
13743 }
13744
13745 break;
13746 }
13747
13748 /*
13749 if (kernel_accel_max == 0)
13750 {
13751 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13752
13753 return -1;
13754 }
13755 */
13756
13757 device_param->kernel_accel_min = kernel_accel_min;
13758 device_param->kernel_accel_max = kernel_accel_max;
13759
13760 /*
13761 if (kernel_accel_max < kernel_accel)
13762 {
13763 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13764
13765 device_param->kernel_accel = kernel_accel_max;
13766 }
13767 */
13768
13769 device_param->size_bfs = size_bfs;
13770 device_param->size_combs = size_combs;
13771 device_param->size_rules = size_rules;
13772 device_param->size_rules_c = size_rules_c;
13773 device_param->size_pws = size_pws;
13774 device_param->size_tmps = size_tmps;
13775 device_param->size_hooks = size_hooks;
13776
13777 // do not confuse kernel_accel_max with kernel_accel here
13778
13779 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13780
13781 device_param->kernel_threads = kernel_threads;
13782 device_param->kernel_power_user = kernel_power;
13783
13784 kernel_power_all += kernel_power;
13785
13786 /**
13787 * default building options
13788 */
13789
13790 char build_opts[1024] = { 0 };
13791
13792 // we don't have sm_* on vendors not NV but it doesn't matter
13793
13794 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13795
13796 /**
13797 * main kernel
13798 */
13799
13800 {
13801 /**
13802 * kernel source filename
13803 */
13804
13805 char source_file[256] = { 0 };
13806
13807 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13808
13809 struct stat sst;
13810
13811 if (stat (source_file, &sst) == -1)
13812 {
13813 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13814
13815 return -1;
13816 }
13817
13818 /**
13819 * kernel cached filename
13820 */
13821
13822 char cached_file[256] = { 0 };
13823
13824 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13825
13826 int cached = 1;
13827
13828 struct stat cst;
13829
13830 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13831 {
13832 cached = 0;
13833 }
13834
13835 /**
13836 * kernel compile or load
13837 */
13838
13839 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13840
13841 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13842
13843 if (force_jit_compilation == -1)
13844 {
13845 if (cached == 0)
13846 {
13847 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13848
13849 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13850
13851 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13852
13853 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13854
13855 #ifdef DEBUG
13856 size_t build_log_size = 0;
13857
13858 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13859
13860 if (build_log_size > 1)
13861 {
13862 char *build_log = (char *) malloc (build_log_size + 1);
13863
13864 memset (build_log, 0, build_log_size + 1);
13865
13866 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13867
13868 puts (build_log);
13869
13870 free (build_log);
13871 }
13872 #endif
13873
13874 if (rc != 0)
13875 {
13876 device_param->skipped = true;
13877 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13878 continue;
13879 }
13880
13881 size_t binary_size;
13882
13883 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13884
13885 u8 *binary = (u8 *) mymalloc (binary_size);
13886
13887 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13888
13889 writeProgramBin (cached_file, binary, binary_size);
13890
13891 local_free (binary);
13892 }
13893 else
13894 {
13895 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13896
13897 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13898
13899 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13900
13901 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13902 }
13903 }
13904 else
13905 {
13906 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13907
13908 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13909
13910 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13911
13912 char build_opts_update[1024] = { 0 };
13913
13914 if (force_jit_compilation == 1500)
13915 {
13916 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13917 }
13918 else if (force_jit_compilation == 8900)
13919 {
13920 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);
13921 }
13922 else
13923 {
13924 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13925 }
13926
13927 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13928
13929 #ifdef DEBUG
13930 size_t build_log_size = 0;
13931
13932 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13933
13934 if (build_log_size > 1)
13935 {
13936 char *build_log = (char *) malloc (build_log_size + 1);
13937
13938 memset (build_log, 0, build_log_size + 1);
13939
13940 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13941
13942 puts (build_log);
13943
13944 free (build_log);
13945 }
13946 #endif
13947
13948 if (rc != 0)
13949 {
13950 device_param->skipped = true;
13951
13952 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13953 }
13954 }
13955
13956 local_free (kernel_lengths);
13957 local_free (kernel_sources[0]);
13958 local_free (kernel_sources);
13959 }
13960
13961 /**
13962 * word generator kernel
13963 */
13964
13965 if (attack_mode != ATTACK_MODE_STRAIGHT)
13966 {
13967 /**
13968 * kernel mp source filename
13969 */
13970
13971 char source_file[256] = { 0 };
13972
13973 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13974
13975 struct stat sst;
13976
13977 if (stat (source_file, &sst) == -1)
13978 {
13979 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13980
13981 return -1;
13982 }
13983
13984 /**
13985 * kernel mp cached filename
13986 */
13987
13988 char cached_file[256] = { 0 };
13989
13990 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13991
13992 int cached = 1;
13993
13994 struct stat cst;
13995
13996 if (stat (cached_file, &cst) == -1)
13997 {
13998 cached = 0;
13999 }
14000
14001 /**
14002 * kernel compile or load
14003 */
14004
14005 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14006
14007 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14008
14009 if (cached == 0)
14010 {
14011 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14012
14013 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14014
14015 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14016
14017 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14018
14019 if (rc != 0)
14020 {
14021 device_param->skipped = true;
14022 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14023 continue;
14024 }
14025
14026 size_t binary_size;
14027
14028 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14029
14030 u8 *binary = (u8 *) mymalloc (binary_size);
14031
14032 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14033
14034 writeProgramBin (cached_file, binary, binary_size);
14035
14036 local_free (binary);
14037 }
14038 else
14039 {
14040 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14041
14042 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14043
14044 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14045
14046 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14047 }
14048
14049 local_free (kernel_lengths);
14050 local_free (kernel_sources[0]);
14051 local_free (kernel_sources);
14052 }
14053
14054 /**
14055 * amplifier kernel
14056 */
14057
14058 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14059 {
14060
14061 }
14062 else
14063 {
14064 /**
14065 * kernel amp source filename
14066 */
14067
14068 char source_file[256] = { 0 };
14069
14070 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14071
14072 struct stat sst;
14073
14074 if (stat (source_file, &sst) == -1)
14075 {
14076 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14077
14078 return -1;
14079 }
14080
14081 /**
14082 * kernel amp cached filename
14083 */
14084
14085 char cached_file[256] = { 0 };
14086
14087 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14088
14089 int cached = 1;
14090
14091 struct stat cst;
14092
14093 if (stat (cached_file, &cst) == -1)
14094 {
14095 cached = 0;
14096 }
14097
14098 /**
14099 * kernel compile or load
14100 */
14101
14102 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14103
14104 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14105
14106 if (cached == 0)
14107 {
14108 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14109
14110 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14111
14112 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14113
14114 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14115
14116 if (rc != 0)
14117 {
14118 device_param->skipped = true;
14119 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14120 continue;
14121 }
14122
14123 size_t binary_size;
14124
14125 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14126
14127 u8 *binary = (u8 *) mymalloc (binary_size);
14128
14129 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14130
14131 writeProgramBin (cached_file, binary, binary_size);
14132
14133 local_free (binary);
14134 }
14135 else
14136 {
14137 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14138
14139 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14140
14141 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14142
14143 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14144 }
14145
14146 local_free (kernel_lengths);
14147 local_free (kernel_sources[0]);
14148 local_free (kernel_sources);
14149 }
14150
14151 // some algorithm collide too fast, make that impossible
14152
14153 if (benchmark == 1)
14154 {
14155 ((uint *) digests_buf)[0] = -1;
14156 ((uint *) digests_buf)[1] = -1;
14157 ((uint *) digests_buf)[2] = -1;
14158 ((uint *) digests_buf)[3] = -1;
14159 }
14160
14161 /**
14162 * global buffers
14163 */
14164
14165 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14166 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14167 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14168 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14169 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14170 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14171 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14172 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14173 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14174 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14175 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14176 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14177 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14178 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14179 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14180 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14181 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14182 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14183
14184 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);
14185 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);
14186 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);
14187 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);
14188 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);
14189 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);
14190 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);
14191 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);
14192 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14193 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14194 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14195
14196 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14197 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14198 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14199 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14200 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14201 run_kernel_bzero (device_param, device_param->d_result, size_results);
14202
14203 /**
14204 * special buffers
14205 */
14206
14207 if (attack_kern == ATTACK_KERN_STRAIGHT)
14208 {
14209 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14210 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14211
14212 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14213
14214 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14215 }
14216 else if (attack_kern == ATTACK_KERN_COMBI)
14217 {
14218 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14219 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14220 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14221 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14222
14223 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14224 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14225 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14226 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14227 }
14228 else if (attack_kern == ATTACK_KERN_BF)
14229 {
14230 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14231 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14232 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14233 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14234 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14235
14236 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14237 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14238 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14239 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14240 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14241 }
14242
14243 if (size_esalts)
14244 {
14245 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14246
14247 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14248 }
14249
14250 /**
14251 * main host data
14252 */
14253
14254 uint *result = (uint *) mymalloc (size_results);
14255
14256 device_param->result = result;
14257
14258 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14259
14260 device_param->pws_buf = pws_buf;
14261
14262 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14263
14264 device_param->combs_buf = combs_buf;
14265
14266 void *hooks_buf = mymalloc (size_hooks);
14267
14268 device_param->hooks_buf = hooks_buf;
14269
14270 /**
14271 * kernel args
14272 */
14273
14274 device_param->kernel_params_buf32[21] = bitmap_mask;
14275 device_param->kernel_params_buf32[22] = bitmap_shift1;
14276 device_param->kernel_params_buf32[23] = bitmap_shift2;
14277 device_param->kernel_params_buf32[24] = 0; // salt_pos
14278 device_param->kernel_params_buf32[25] = 0; // loop_pos
14279 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14280 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14281 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14282 device_param->kernel_params_buf32[29] = 0; // digests_offset
14283 device_param->kernel_params_buf32[30] = 0; // combs_mode
14284 device_param->kernel_params_buf32[31] = 0; // gid_max
14285
14286 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14287 ? &device_param->d_pws_buf
14288 : &device_param->d_pws_amp_buf;
14289 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14290 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14291 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14292 device_param->kernel_params[ 4] = &device_param->d_tmps;
14293 device_param->kernel_params[ 5] = &device_param->d_hooks;
14294 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14295 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14296 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14297 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14298 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14299 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14300 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14301 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14302 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14303 device_param->kernel_params[15] = &device_param->d_digests_buf;
14304 device_param->kernel_params[16] = &device_param->d_digests_shown;
14305 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14306 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14307 device_param->kernel_params[19] = &device_param->d_result;
14308 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14309 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14310 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14311 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14312 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14313 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14314 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14315 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14316 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14317 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14318 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14319 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14320
14321 device_param->kernel_params_mp_buf64[3] = 0;
14322 device_param->kernel_params_mp_buf32[4] = 0;
14323 device_param->kernel_params_mp_buf32[5] = 0;
14324 device_param->kernel_params_mp_buf32[6] = 0;
14325 device_param->kernel_params_mp_buf32[7] = 0;
14326 device_param->kernel_params_mp_buf32[8] = 0;
14327
14328 device_param->kernel_params_mp[0] = NULL;
14329 device_param->kernel_params_mp[1] = NULL;
14330 device_param->kernel_params_mp[2] = NULL;
14331 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14332 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14333 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14334 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14335 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14336 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14337
14338 device_param->kernel_params_mp_l_buf64[3] = 0;
14339 device_param->kernel_params_mp_l_buf32[4] = 0;
14340 device_param->kernel_params_mp_l_buf32[5] = 0;
14341 device_param->kernel_params_mp_l_buf32[6] = 0;
14342 device_param->kernel_params_mp_l_buf32[7] = 0;
14343 device_param->kernel_params_mp_l_buf32[8] = 0;
14344 device_param->kernel_params_mp_l_buf32[9] = 0;
14345
14346 device_param->kernel_params_mp_l[0] = NULL;
14347 device_param->kernel_params_mp_l[1] = NULL;
14348 device_param->kernel_params_mp_l[2] = NULL;
14349 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14350 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14351 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14352 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14353 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14354 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14355 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14356
14357 device_param->kernel_params_mp_r_buf64[3] = 0;
14358 device_param->kernel_params_mp_r_buf32[4] = 0;
14359 device_param->kernel_params_mp_r_buf32[5] = 0;
14360 device_param->kernel_params_mp_r_buf32[6] = 0;
14361 device_param->kernel_params_mp_r_buf32[7] = 0;
14362 device_param->kernel_params_mp_r_buf32[8] = 0;
14363
14364 device_param->kernel_params_mp_r[0] = NULL;
14365 device_param->kernel_params_mp_r[1] = NULL;
14366 device_param->kernel_params_mp_r[2] = NULL;
14367 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14368 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14369 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14370 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14371 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14372 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14373
14374 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14375 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14376
14377 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14378 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14379 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14380 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14381 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14382 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14383 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14384
14385 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14386
14387 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14388 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14389
14390 /**
14391 * kernel name
14392 */
14393
14394 char kernel_name[64] = { 0 };
14395
14396 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14397 {
14398 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14399 {
14400 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14401
14402 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14403
14404 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14405
14406 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14407
14408 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14409
14410 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14411 }
14412 else
14413 {
14414 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14415
14416 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14417
14418 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14419
14420 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14421
14422 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14423
14424 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14425 }
14426
14427 if (data.attack_mode == ATTACK_MODE_BF)
14428 {
14429 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14430 {
14431 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14432
14433 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14434
14435 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14436
14437 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14438 }
14439 }
14440 }
14441 else
14442 {
14443 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14444
14445 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14446
14447 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14448
14449 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14450
14451 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14452
14453 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14454
14455 if (opts_type & OPTS_TYPE_HOOK12)
14456 {
14457 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14458
14459 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14460 }
14461
14462 if (opts_type & OPTS_TYPE_HOOK23)
14463 {
14464 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14465
14466 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14467 }
14468 }
14469
14470 for (uint i = 0; i <= 20; i++)
14471 {
14472 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14473 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14474 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14475
14476 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14477 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14478 }
14479
14480 for (uint i = 21; i <= 31; i++)
14481 {
14482 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14483 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14484 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14485
14486 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14487 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14488 }
14489
14490 if (attack_mode == ATTACK_MODE_BF)
14491 {
14492 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14493 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14494
14495 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14496 {
14497 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14498
14499 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14500 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14501 }
14502 }
14503 else if (attack_mode == ATTACK_MODE_HYBRID1)
14504 {
14505 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14506 }
14507 else if (attack_mode == ATTACK_MODE_HYBRID2)
14508 {
14509 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14510 }
14511
14512 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14513 {
14514 // nothing to do
14515 }
14516 else
14517 {
14518 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14519 }
14520
14521 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14522 {
14523 // nothing to do
14524 }
14525 else
14526 {
14527 for (uint i = 0; i < 5; i++)
14528 {
14529 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14530 }
14531
14532 for (uint i = 5; i < 7; i++)
14533 {
14534 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14535 }
14536 }
14537
14538 /**
14539 * Store initial fanspeed if gpu_temp_retain is enabled
14540 */
14541
14542 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14543 int gpu_temp_retain_set = 0;
14544
14545 if (gpu_temp_disable == 0)
14546 {
14547 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14548 {
14549 hc_thread_mutex_lock (mux_adl);
14550
14551 if (data.hm_device[device_id].fan_supported == 1)
14552 {
14553 if (gpu_temp_retain_chgd == 0)
14554 {
14555 uint cur_temp = 0;
14556 uint default_temp = 0;
14557
14558 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);
14559
14560 if (ADL_rc == ADL_OK)
14561 {
14562 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14563
14564 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14565
14566 // special case with multi gpu setups: always use minimum retain
14567
14568 if (gpu_temp_retain_set == 0)
14569 {
14570 gpu_temp_retain = gpu_temp_retain_target;
14571 gpu_temp_retain_set = 1;
14572 }
14573 else
14574 {
14575 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14576 }
14577
14578 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14579 }
14580 }
14581
14582 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14583
14584 temp_retain_fanspeed_value[device_id] = fan_speed;
14585
14586 if (fan_speed == -1)
14587 {
14588 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14589
14590 temp_retain_fanspeed_value[device_id] = 0;
14591 }
14592 }
14593
14594 hc_thread_mutex_unlock (mux_adl);
14595 }
14596 }
14597
14598 /**
14599 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14600 */
14601
14602 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14603 {
14604 hc_thread_mutex_lock (mux_adl);
14605
14606 if (data.hm_device[device_id].od_version == 6)
14607 {
14608 int ADL_rc;
14609
14610 // check powertune capabilities first, if not available then skip device
14611
14612 int powertune_supported = 0;
14613
14614 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14615 {
14616 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14617
14618 return (-1);
14619 }
14620
14621 if (powertune_supported != 0)
14622 {
14623 // powercontrol settings
14624
14625 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14626
14627 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14628 {
14629 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14630 }
14631
14632 if (ADL_rc != ADL_OK)
14633 {
14634 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14635
14636 return (-1);
14637 }
14638
14639 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14640 {
14641 log_error ("ERROR: Failed to set new ADL PowerControl values");
14642
14643 return (-1);
14644 }
14645
14646 // clocks
14647
14648 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14649
14650 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14651
14652 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)
14653 {
14654 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14655
14656 return (-1);
14657 }
14658
14659 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14660
14661 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14662
14663 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14664 {
14665 log_error ("ERROR: Failed to get ADL device capabilities");
14666
14667 return (-1);
14668 }
14669
14670 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14671 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14672
14673 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14674 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14675
14676 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14677 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14678
14679 // warning if profile has too low max values
14680
14681 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14682 {
14683 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14684 }
14685
14686 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14687 {
14688 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14689 }
14690
14691 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14692
14693 performance_state->iNumberOfPerformanceLevels = 2;
14694
14695 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14696 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14697 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14698 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14699
14700 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)
14701 {
14702 log_info ("ERROR: Failed to set ADL performance state");
14703
14704 return (-1);
14705 }
14706
14707 local_free (performance_state);
14708 }
14709 }
14710
14711 hc_thread_mutex_unlock (mux_adl);
14712 }
14713 #endif // HAVE_HWMON && HAVE_ADL
14714 }
14715
14716 data.kernel_power_all = kernel_power_all;
14717
14718 if (data.quiet == 0) log_info ("");
14719
14720 /**
14721 * Inform user which algorithm is checked and at which workload setting
14722 */
14723
14724 if (benchmark == 1)
14725 {
14726 quiet = 0;
14727
14728 data.quiet = quiet;
14729
14730 char *hash_type = strhashtype (data.hash_mode); // not a bug
14731
14732 log_info ("Hashtype: %s", hash_type);
14733 log_info ("");
14734 }
14735
14736 /**
14737 * keep track of the progress
14738 */
14739
14740 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14741 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14742 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14743
14744 /**
14745 * open filehandles
14746 */
14747
14748 #if _WIN
14749 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14750 {
14751 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14752
14753 return (-1);
14754 }
14755
14756 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14757 {
14758 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14759
14760 return (-1);
14761 }
14762
14763 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14764 {
14765 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14766
14767 return (-1);
14768 }
14769 #endif
14770
14771 /**
14772 * dictionary pad
14773 */
14774
14775 segment_size *= (1024 * 1024);
14776
14777 data.segment_size = segment_size;
14778
14779 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14780
14781 wl_data->buf = (char *) mymalloc (segment_size);
14782 wl_data->avail = segment_size;
14783 wl_data->incr = segment_size;
14784 wl_data->cnt = 0;
14785 wl_data->pos = 0;
14786
14787 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14788
14789 data.wordlist_mode = wordlist_mode;
14790
14791 cs_t *css_buf = NULL;
14792 uint css_cnt = 0;
14793 uint dictcnt = 0;
14794 uint maskcnt = 1;
14795 char **masks = NULL;
14796 char **dictfiles = NULL;
14797
14798 uint mask_from_file = 0;
14799
14800 if (attack_mode == ATTACK_MODE_STRAIGHT)
14801 {
14802 if (wordlist_mode == WL_MODE_FILE)
14803 {
14804 int wls_left = myargc - (optind + 1);
14805
14806 for (int i = 0; i < wls_left; i++)
14807 {
14808 char *l0_filename = myargv[optind + 1 + i];
14809
14810 struct stat l0_stat;
14811
14812 if (stat (l0_filename, &l0_stat) == -1)
14813 {
14814 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14815
14816 return (-1);
14817 }
14818
14819 uint is_dir = S_ISDIR (l0_stat.st_mode);
14820
14821 if (is_dir == 0)
14822 {
14823 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14824
14825 dictcnt++;
14826
14827 dictfiles[dictcnt - 1] = l0_filename;
14828 }
14829 else
14830 {
14831 // do not allow --keyspace w/ a directory
14832
14833 if (keyspace == 1)
14834 {
14835 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14836
14837 return (-1);
14838 }
14839
14840 char **dictionary_files = NULL;
14841
14842 dictionary_files = scan_directory (l0_filename);
14843
14844 if (dictionary_files != NULL)
14845 {
14846 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14847
14848 for (int d = 0; dictionary_files[d] != NULL; d++)
14849 {
14850 char *l1_filename = dictionary_files[d];
14851
14852 struct stat l1_stat;
14853
14854 if (stat (l1_filename, &l1_stat) == -1)
14855 {
14856 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14857
14858 return (-1);
14859 }
14860
14861 if (S_ISREG (l1_stat.st_mode))
14862 {
14863 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14864
14865 dictcnt++;
14866
14867 dictfiles[dictcnt - 1] = strdup (l1_filename);
14868 }
14869 }
14870 }
14871
14872 local_free (dictionary_files);
14873 }
14874 }
14875
14876 if (dictcnt < 1)
14877 {
14878 log_error ("ERROR: No usable dictionary file found.");
14879
14880 return (-1);
14881 }
14882 }
14883 else if (wordlist_mode == WL_MODE_STDIN)
14884 {
14885 dictcnt = 1;
14886 }
14887 }
14888 else if (attack_mode == ATTACK_MODE_COMBI)
14889 {
14890 // display
14891
14892 char *dictfile1 = myargv[optind + 1 + 0];
14893 char *dictfile2 = myargv[optind + 1 + 1];
14894
14895 // find the bigger dictionary and use as base
14896
14897 FILE *fp1 = NULL;
14898 FILE *fp2 = NULL;
14899
14900 struct stat tmp_stat;
14901
14902 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14903 {
14904 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14905
14906 return (-1);
14907 }
14908
14909 if (stat (dictfile1, &tmp_stat) == -1)
14910 {
14911 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14912
14913 fclose (fp1);
14914
14915 return (-1);
14916 }
14917
14918 if (S_ISDIR (tmp_stat.st_mode))
14919 {
14920 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14921
14922 fclose (fp1);
14923
14924 return (-1);
14925 }
14926
14927 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14928 {
14929 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14930
14931 fclose (fp1);
14932
14933 return (-1);
14934 }
14935
14936 if (stat (dictfile2, &tmp_stat) == -1)
14937 {
14938 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14939
14940 fclose (fp1);
14941 fclose (fp2);
14942
14943 return (-1);
14944 }
14945
14946 if (S_ISDIR (tmp_stat.st_mode))
14947 {
14948 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14949
14950 fclose (fp1);
14951 fclose (fp2);
14952
14953 return (-1);
14954 }
14955
14956 data.combs_cnt = 1;
14957
14958 data.quiet = 1;
14959
14960 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14961
14962 data.quiet = quiet;
14963
14964 if (words1_cnt == 0)
14965 {
14966 log_error ("ERROR: %s: empty file", dictfile1);
14967
14968 fclose (fp1);
14969 fclose (fp2);
14970
14971 return (-1);
14972 }
14973
14974 data.combs_cnt = 1;
14975
14976 data.quiet = 1;
14977
14978 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14979
14980 data.quiet = quiet;
14981
14982 if (words2_cnt == 0)
14983 {
14984 log_error ("ERROR: %s: empty file", dictfile2);
14985
14986 fclose (fp1);
14987 fclose (fp2);
14988
14989 return (-1);
14990 }
14991
14992 fclose (fp1);
14993 fclose (fp2);
14994
14995 data.dictfile = dictfile1;
14996 data.dictfile2 = dictfile2;
14997
14998 if (words1_cnt >= words2_cnt)
14999 {
15000 data.combs_cnt = words2_cnt;
15001 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15002
15003 dictfiles = &data.dictfile;
15004
15005 dictcnt = 1;
15006 }
15007 else
15008 {
15009 data.combs_cnt = words1_cnt;
15010 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15011
15012 dictfiles = &data.dictfile2;
15013
15014 dictcnt = 1;
15015
15016 // we also have to switch wordlist related rules!
15017
15018 char *tmpc = data.rule_buf_l;
15019
15020 data.rule_buf_l = data.rule_buf_r;
15021 data.rule_buf_r = tmpc;
15022
15023 int tmpi = data.rule_len_l;
15024
15025 data.rule_len_l = data.rule_len_r;
15026 data.rule_len_r = tmpi;
15027 }
15028 }
15029 else if (attack_mode == ATTACK_MODE_BF)
15030 {
15031 char *mask = NULL;
15032
15033 maskcnt = 0;
15034
15035 if (benchmark == 0)
15036 {
15037 mask = myargv[optind + 1];
15038
15039 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15040
15041 if ((optind + 2) <= myargc)
15042 {
15043 struct stat file_stat;
15044
15045 if (stat (mask, &file_stat) == -1)
15046 {
15047 maskcnt = 1;
15048
15049 masks[maskcnt - 1] = mystrdup (mask);
15050 }
15051 else
15052 {
15053 int wls_left = myargc - (optind + 1);
15054
15055 uint masks_avail = INCR_MASKS;
15056
15057 for (int i = 0; i < wls_left; i++)
15058 {
15059 if (i != 0)
15060 {
15061 mask = myargv[optind + 1 + i];
15062
15063 if (stat (mask, &file_stat) == -1)
15064 {
15065 log_error ("ERROR: %s: %s", mask, strerror (errno));
15066
15067 return (-1);
15068 }
15069 }
15070
15071 uint is_file = S_ISREG (file_stat.st_mode);
15072
15073 if (is_file == 1)
15074 {
15075 FILE *mask_fp;
15076
15077 if ((mask_fp = fopen (mask, "r")) == NULL)
15078 {
15079 log_error ("ERROR: %s: %s", mask, strerror (errno));
15080
15081 return (-1);
15082 }
15083
15084 char line_buf[BUFSIZ] = { 0 };
15085
15086 while (!feof (mask_fp))
15087 {
15088 memset (line_buf, 0, BUFSIZ);
15089
15090 int line_len = fgetl (mask_fp, line_buf);
15091
15092 if (line_len == 0) continue;
15093
15094 if (line_buf[0] == '#') continue;
15095
15096 if (masks_avail == maskcnt)
15097 {
15098 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15099
15100 masks_avail += INCR_MASKS;
15101 }
15102
15103 masks[maskcnt] = mystrdup (line_buf);
15104
15105 maskcnt++;
15106 }
15107
15108 fclose (mask_fp);
15109 }
15110 else
15111 {
15112 log_error ("ERROR: %s: unsupported file-type", mask);
15113
15114 return (-1);
15115 }
15116 }
15117
15118 mask_from_file = 1;
15119 }
15120 }
15121 else
15122 {
15123 custom_charset_1 = (char *) "?l?d?u";
15124 custom_charset_2 = (char *) "?l?d";
15125 custom_charset_3 = (char *) "?l?d*!$@_";
15126
15127 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15128 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15129 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15130
15131 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15132
15133 wordlist_mode = WL_MODE_MASK;
15134
15135 data.wordlist_mode = wordlist_mode;
15136
15137 increment = 1;
15138
15139 maskcnt = 1;
15140 }
15141 }
15142 else
15143 {
15144 /**
15145 * generate full masks and charsets
15146 */
15147
15148 masks = (char **) mymalloc (sizeof (char *));
15149
15150 switch (hash_mode)
15151 {
15152 case 1731: pw_min = 5;
15153 pw_max = 5;
15154 mask = mystrdup ("?b?b?b?b?b");
15155 break;
15156 case 12500: pw_min = 5;
15157 pw_max = 5;
15158 mask = mystrdup ("?b?b?b?b?b");
15159 break;
15160 default: pw_min = 7;
15161 pw_max = 7;
15162 mask = mystrdup ("?b?b?b?b?b?b?b");
15163 break;
15164 }
15165
15166 maskcnt = 1;
15167
15168 masks[maskcnt - 1] = mystrdup (mask);
15169
15170 wordlist_mode = WL_MODE_MASK;
15171
15172 data.wordlist_mode = wordlist_mode;
15173
15174 increment = 1;
15175 }
15176
15177 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15178
15179 if (increment)
15180 {
15181 if (increment_min > pw_min) pw_min = increment_min;
15182
15183 if (increment_max < pw_max) pw_max = increment_max;
15184 }
15185 }
15186 else if (attack_mode == ATTACK_MODE_HYBRID1)
15187 {
15188 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15189
15190 // display
15191
15192 char *mask = myargv[myargc - 1];
15193
15194 maskcnt = 0;
15195
15196 masks = (char **) mymalloc (1 * sizeof (char *));
15197
15198 // mod
15199
15200 struct stat file_stat;
15201
15202 if (stat (mask, &file_stat) == -1)
15203 {
15204 maskcnt = 1;
15205
15206 masks[maskcnt - 1] = mystrdup (mask);
15207 }
15208 else
15209 {
15210 uint is_file = S_ISREG (file_stat.st_mode);
15211
15212 if (is_file == 1)
15213 {
15214 FILE *mask_fp;
15215
15216 if ((mask_fp = fopen (mask, "r")) == NULL)
15217 {
15218 log_error ("ERROR: %s: %s", mask, strerror (errno));
15219
15220 return (-1);
15221 }
15222
15223 char line_buf[BUFSIZ] = { 0 };
15224
15225 uint masks_avail = 1;
15226
15227 while (!feof (mask_fp))
15228 {
15229 memset (line_buf, 0, BUFSIZ);
15230
15231 int line_len = fgetl (mask_fp, line_buf);
15232
15233 if (line_len == 0) continue;
15234
15235 if (line_buf[0] == '#') continue;
15236
15237 if (masks_avail == maskcnt)
15238 {
15239 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15240
15241 masks_avail += INCR_MASKS;
15242 }
15243
15244 masks[maskcnt] = mystrdup (line_buf);
15245
15246 maskcnt++;
15247 }
15248
15249 fclose (mask_fp);
15250
15251 mask_from_file = 1;
15252 }
15253 else
15254 {
15255 maskcnt = 1;
15256
15257 masks[maskcnt - 1] = mystrdup (mask);
15258 }
15259 }
15260
15261 // base
15262
15263 int wls_left = myargc - (optind + 2);
15264
15265 for (int i = 0; i < wls_left; i++)
15266 {
15267 char *filename = myargv[optind + 1 + i];
15268
15269 struct stat file_stat;
15270
15271 if (stat (filename, &file_stat) == -1)
15272 {
15273 log_error ("ERROR: %s: %s", filename, strerror (errno));
15274
15275 return (-1);
15276 }
15277
15278 uint is_dir = S_ISDIR (file_stat.st_mode);
15279
15280 if (is_dir == 0)
15281 {
15282 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15283
15284 dictcnt++;
15285
15286 dictfiles[dictcnt - 1] = filename;
15287 }
15288 else
15289 {
15290 // do not allow --keyspace w/ a directory
15291
15292 if (keyspace == 1)
15293 {
15294 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15295
15296 return (-1);
15297 }
15298
15299 char **dictionary_files = NULL;
15300
15301 dictionary_files = scan_directory (filename);
15302
15303 if (dictionary_files != NULL)
15304 {
15305 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15306
15307 for (int d = 0; dictionary_files[d] != NULL; d++)
15308 {
15309 char *l1_filename = dictionary_files[d];
15310
15311 struct stat l1_stat;
15312
15313 if (stat (l1_filename, &l1_stat) == -1)
15314 {
15315 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15316
15317 return (-1);
15318 }
15319
15320 if (S_ISREG (l1_stat.st_mode))
15321 {
15322 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15323
15324 dictcnt++;
15325
15326 dictfiles[dictcnt - 1] = strdup (l1_filename);
15327 }
15328 }
15329 }
15330
15331 local_free (dictionary_files);
15332 }
15333 }
15334
15335 if (dictcnt < 1)
15336 {
15337 log_error ("ERROR: No usable dictionary file found.");
15338
15339 return (-1);
15340 }
15341
15342 if (increment)
15343 {
15344 maskcnt = 0;
15345
15346 uint mask_min = increment_min; // we can't reject smaller masks here
15347 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15348
15349 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15350 {
15351 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15352
15353 if (cur_mask == NULL) break;
15354
15355 masks[maskcnt] = cur_mask;
15356
15357 maskcnt++;
15358
15359 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15360 }
15361 }
15362 }
15363 else if (attack_mode == ATTACK_MODE_HYBRID2)
15364 {
15365 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15366
15367 // display
15368
15369 char *mask = myargv[optind + 1 + 0];
15370
15371 maskcnt = 0;
15372
15373 masks = (char **) mymalloc (1 * sizeof (char *));
15374
15375 // mod
15376
15377 struct stat file_stat;
15378
15379 if (stat (mask, &file_stat) == -1)
15380 {
15381 maskcnt = 1;
15382
15383 masks[maskcnt - 1] = mystrdup (mask);
15384 }
15385 else
15386 {
15387 uint is_file = S_ISREG (file_stat.st_mode);
15388
15389 if (is_file == 1)
15390 {
15391 FILE *mask_fp;
15392
15393 if ((mask_fp = fopen (mask, "r")) == NULL)
15394 {
15395 log_error ("ERROR: %s: %s", mask, strerror (errno));
15396
15397 return (-1);
15398 }
15399
15400 char line_buf[BUFSIZ] = { 0 };
15401
15402 uint masks_avail = 1;
15403
15404 while (!feof (mask_fp))
15405 {
15406 memset (line_buf, 0, BUFSIZ);
15407
15408 int line_len = fgetl (mask_fp, line_buf);
15409
15410 if (line_len == 0) continue;
15411
15412 if (line_buf[0] == '#') continue;
15413
15414 if (masks_avail == maskcnt)
15415 {
15416 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15417
15418 masks_avail += INCR_MASKS;
15419 }
15420
15421 masks[maskcnt] = mystrdup (line_buf);
15422
15423 maskcnt++;
15424 }
15425
15426 fclose (mask_fp);
15427
15428 mask_from_file = 1;
15429 }
15430 else
15431 {
15432 maskcnt = 1;
15433
15434 masks[maskcnt - 1] = mystrdup (mask);
15435 }
15436 }
15437
15438 // base
15439
15440 int wls_left = myargc - (optind + 2);
15441
15442 for (int i = 0; i < wls_left; i++)
15443 {
15444 char *filename = myargv[optind + 2 + i];
15445
15446 struct stat file_stat;
15447
15448 if (stat (filename, &file_stat) == -1)
15449 {
15450 log_error ("ERROR: %s: %s", filename, strerror (errno));
15451
15452 return (-1);
15453 }
15454
15455 uint is_dir = S_ISDIR (file_stat.st_mode);
15456
15457 if (is_dir == 0)
15458 {
15459 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15460
15461 dictcnt++;
15462
15463 dictfiles[dictcnt - 1] = filename;
15464 }
15465 else
15466 {
15467 // do not allow --keyspace w/ a directory
15468
15469 if (keyspace == 1)
15470 {
15471 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15472
15473 return (-1);
15474 }
15475
15476 char **dictionary_files = NULL;
15477
15478 dictionary_files = scan_directory (filename);
15479
15480 if (dictionary_files != NULL)
15481 {
15482 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15483
15484 for (int d = 0; dictionary_files[d] != NULL; d++)
15485 {
15486 char *l1_filename = dictionary_files[d];
15487
15488 struct stat l1_stat;
15489
15490 if (stat (l1_filename, &l1_stat) == -1)
15491 {
15492 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15493
15494 return (-1);
15495 }
15496
15497 if (S_ISREG (l1_stat.st_mode))
15498 {
15499 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15500
15501 dictcnt++;
15502
15503 dictfiles[dictcnt - 1] = strdup (l1_filename);
15504 }
15505 }
15506 }
15507
15508 local_free (dictionary_files);
15509 }
15510 }
15511
15512 if (dictcnt < 1)
15513 {
15514 log_error ("ERROR: No usable dictionary file found.");
15515
15516 return (-1);
15517 }
15518
15519 if (increment)
15520 {
15521 maskcnt = 0;
15522
15523 uint mask_min = increment_min; // we can't reject smaller masks here
15524 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15525
15526 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15527 {
15528 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15529
15530 if (cur_mask == NULL) break;
15531
15532 masks[maskcnt] = cur_mask;
15533
15534 maskcnt++;
15535
15536 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15537 }
15538 }
15539 }
15540
15541 data.pw_min = pw_min;
15542 data.pw_max = pw_max;
15543
15544 /**
15545 * weak hash check
15546 */
15547
15548 if (weak_hash_threshold >= salts_cnt)
15549 {
15550 hc_device_param_t *device_param = NULL;
15551
15552 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15553 {
15554 device_param = &data.devices_param[device_id];
15555
15556 if (device_param->skipped) continue;
15557
15558 break;
15559 }
15560
15561 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15562
15563 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15564 {
15565 weak_hash_check (device_param, salt_pos);
15566 }
15567 }
15568
15569 // Display hack, guarantee that there is at least one \r before real start
15570
15571 if (data.quiet == 0) log_info_nn ("");
15572
15573 /**
15574 * status and monitor threads
15575 */
15576
15577 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15578
15579 hc_thread_t i_thread = 0;
15580
15581 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15582 {
15583 hc_thread_create (i_thread, thread_keypress, &benchmark);
15584 }
15585
15586 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15587
15588 uint ni_threads_cnt = 0;
15589
15590 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15591
15592 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15593
15594 ni_threads_cnt++;
15595
15596 /**
15597 * Outfile remove
15598 */
15599
15600 if (keyspace == 0)
15601 {
15602 if (outfile_check_timer != 0)
15603 {
15604 if (data.outfile_check_directory != NULL)
15605 {
15606 if ((hash_mode != 5200) &&
15607 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15608 (hash_mode != 9000))
15609 {
15610 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15611
15612 ni_threads_cnt++;
15613 }
15614 else
15615 {
15616 outfile_check_timer = 0;
15617 }
15618 }
15619 else
15620 {
15621 outfile_check_timer = 0;
15622 }
15623 }
15624 }
15625
15626 /**
15627 * Inform the user if we got some hashes remove because of the pot file remove feature
15628 */
15629
15630 if (data.quiet == 0)
15631 {
15632 if (potfile_remove_cracks > 0)
15633 {
15634 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15635 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15636 }
15637 }
15638
15639 data.outfile_check_timer = outfile_check_timer;
15640
15641 /**
15642 * main loop
15643 */
15644
15645 char **induction_dictionaries = NULL;
15646
15647 int induction_dictionaries_cnt = 0;
15648
15649 hcstat_table_t *root_table_buf = NULL;
15650 hcstat_table_t *markov_table_buf = NULL;
15651
15652 uint initial_restore_done = 0;
15653
15654 data.maskcnt = maskcnt;
15655
15656 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15657 {
15658 if (data.devices_status == STATUS_CRACKED) break;
15659
15660 data.devices_status = STATUS_INIT;
15661
15662 if (maskpos > rd->maskpos)
15663 {
15664 rd->dictpos = 0;
15665 }
15666
15667 rd->maskpos = maskpos;
15668 data.maskpos = maskpos;
15669
15670 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15671 {
15672 char *mask = masks[maskpos];
15673
15674 if (mask_from_file == 1)
15675 {
15676 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15677
15678 char *str_ptr;
15679 uint str_pos;
15680
15681 uint mask_offset = 0;
15682
15683 uint separator_cnt;
15684
15685 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15686 {
15687 str_ptr = strstr (mask + mask_offset, ",");
15688
15689 if (str_ptr == NULL) break;
15690
15691 str_pos = str_ptr - mask;
15692
15693 // escaped separator, i.e. "\,"
15694
15695 if (str_pos > 0)
15696 {
15697 if (mask[str_pos - 1] == '\\')
15698 {
15699 separator_cnt --;
15700
15701 mask_offset = str_pos + 1;
15702
15703 continue;
15704 }
15705 }
15706
15707 // reset the offset
15708
15709 mask_offset = 0;
15710
15711 mask[str_pos] = '\0';
15712
15713 switch (separator_cnt)
15714 {
15715 case 0:
15716 mp_reset_usr (mp_usr, 0);
15717
15718 custom_charset_1 = mask;
15719 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15720 break;
15721
15722 case 1:
15723 mp_reset_usr (mp_usr, 1);
15724
15725 custom_charset_2 = mask;
15726 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15727 break;
15728
15729 case 2:
15730 mp_reset_usr (mp_usr, 2);
15731
15732 custom_charset_3 = mask;
15733 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15734 break;
15735
15736 case 3:
15737 mp_reset_usr (mp_usr, 3);
15738
15739 custom_charset_4 = mask;
15740 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15741 break;
15742 }
15743
15744 mask = mask + str_pos + 1;
15745 }
15746 }
15747
15748 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15749 {
15750 if (maskpos > 0)
15751 {
15752 local_free (css_buf);
15753 local_free (data.root_css_buf);
15754 local_free (data.markov_css_buf);
15755
15756 local_free (masks[maskpos - 1]);
15757 }
15758
15759 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15760
15761 data.mask = mask;
15762 data.css_cnt = css_cnt;
15763 data.css_buf = css_buf;
15764
15765 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15766
15767 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15768
15769 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15770 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15771
15772 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15773
15774 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15775
15776 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15777 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15778
15779 data.root_css_buf = root_css_buf;
15780 data.markov_css_buf = markov_css_buf;
15781
15782 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15783
15784 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15785
15786 local_free (root_table_buf);
15787 local_free (markov_table_buf);
15788
15789 // args
15790
15791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15792 {
15793 hc_device_param_t *device_param = &data.devices_param[device_id];
15794
15795 if (device_param->skipped) continue;
15796
15797 device_param->kernel_params_mp[0] = &device_param->d_combs;
15798 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15799 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15800
15801 device_param->kernel_params_mp_buf64[3] = 0;
15802 device_param->kernel_params_mp_buf32[4] = css_cnt;
15803 device_param->kernel_params_mp_buf32[5] = 0;
15804 device_param->kernel_params_mp_buf32[6] = 0;
15805 device_param->kernel_params_mp_buf32[7] = 0;
15806
15807 if (attack_mode == ATTACK_MODE_HYBRID1)
15808 {
15809 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15810 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15811 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15812 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15813 }
15814 else if (attack_mode == ATTACK_MODE_HYBRID2)
15815 {
15816 device_param->kernel_params_mp_buf32[5] = 0;
15817 device_param->kernel_params_mp_buf32[6] = 0;
15818 device_param->kernel_params_mp_buf32[7] = 0;
15819 }
15820
15821 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]);
15822 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]);
15823 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]);
15824
15825 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);
15826 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);
15827 }
15828 }
15829 else if (attack_mode == ATTACK_MODE_BF)
15830 {
15831 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15832
15833 if (increment)
15834 {
15835 for (uint i = 0; i < dictcnt; i++)
15836 {
15837 local_free (dictfiles[i]);
15838 }
15839
15840 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15841 {
15842 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15843
15844 if (l1_filename == NULL) break;
15845
15846 dictcnt++;
15847
15848 dictfiles[dictcnt - 1] = l1_filename;
15849 }
15850 }
15851 else
15852 {
15853 dictcnt++;
15854
15855 dictfiles[dictcnt - 1] = mask;
15856 }
15857
15858 if (dictcnt == 0)
15859 {
15860 log_error ("ERROR: Mask is too small");
15861
15862 return (-1);
15863 }
15864 }
15865 }
15866
15867 free (induction_dictionaries);
15868
15869 // induction_dictionaries_cnt = 0; // implied
15870
15871 if (attack_mode != ATTACK_MODE_BF)
15872 {
15873 if (keyspace == 0)
15874 {
15875 induction_dictionaries = scan_directory (induction_directory);
15876
15877 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15878 }
15879 }
15880
15881 if (induction_dictionaries_cnt)
15882 {
15883 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15884 }
15885
15886 /**
15887 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15888 */
15889 if (keyspace == 1)
15890 {
15891 if ((maskcnt > 1) || (dictcnt > 1))
15892 {
15893 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15894
15895 return (-1);
15896 }
15897 }
15898
15899 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15900 {
15901 char *subid = logfile_generate_subid ();
15902
15903 data.subid = subid;
15904
15905 logfile_sub_msg ("START");
15906
15907 data.devices_status = STATUS_INIT;
15908
15909 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15910 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15911 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15912
15913 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15914
15915 data.cpt_pos = 0;
15916
15917 data.cpt_start = time (NULL);
15918
15919 data.cpt_total = 0;
15920
15921 if (data.restore == 0)
15922 {
15923 rd->words_cur = skip;
15924
15925 skip = 0;
15926
15927 data.skip = 0;
15928 }
15929
15930 data.ms_paused = 0;
15931
15932 data.words_cur = rd->words_cur;
15933
15934 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15935 {
15936 hc_device_param_t *device_param = &data.devices_param[device_id];
15937
15938 if (device_param->skipped) continue;
15939
15940 device_param->speed_pos = 0;
15941
15942 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15943 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15944 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15945
15946 device_param->exec_pos = 0;
15947
15948 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15949
15950 device_param->kernel_power = device_param->kernel_power_user;
15951
15952 device_param->outerloop_pos = 0;
15953 device_param->outerloop_left = 0;
15954 device_param->innerloop_pos = 0;
15955 device_param->innerloop_left = 0;
15956
15957 // some more resets:
15958
15959 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15960
15961 device_param->pws_cnt = 0;
15962
15963 device_param->words_off = 0;
15964 device_param->words_done = 0;
15965 }
15966
15967 data.kernel_power_div = 0;
15968
15969 // figure out some workload
15970
15971 if (attack_mode == ATTACK_MODE_STRAIGHT)
15972 {
15973 if (data.wordlist_mode == WL_MODE_FILE)
15974 {
15975 char *dictfile = NULL;
15976
15977 if (induction_dictionaries_cnt)
15978 {
15979 dictfile = induction_dictionaries[0];
15980 }
15981 else
15982 {
15983 dictfile = dictfiles[dictpos];
15984 }
15985
15986 data.dictfile = dictfile;
15987
15988 logfile_sub_string (dictfile);
15989
15990 for (uint i = 0; i < rp_files_cnt; i++)
15991 {
15992 logfile_sub_var_string ("rulefile", rp_files[i]);
15993 }
15994
15995 FILE *fd2 = fopen (dictfile, "rb");
15996
15997 if (fd2 == NULL)
15998 {
15999 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16000
16001 return (-1);
16002 }
16003
16004 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16005
16006 fclose (fd2);
16007
16008 if (data.words_cnt == 0)
16009 {
16010 if (data.devices_status == STATUS_CRACKED) break;
16011 if (data.devices_status == STATUS_ABORTED) break;
16012
16013 dictpos++;
16014
16015 continue;
16016 }
16017 }
16018 }
16019 else if (attack_mode == ATTACK_MODE_COMBI)
16020 {
16021 char *dictfile = data.dictfile;
16022 char *dictfile2 = data.dictfile2;
16023
16024 logfile_sub_string (dictfile);
16025 logfile_sub_string (dictfile2);
16026
16027 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16028 {
16029 FILE *fd2 = fopen (dictfile, "rb");
16030
16031 if (fd2 == NULL)
16032 {
16033 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16034
16035 return (-1);
16036 }
16037
16038 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16039
16040 fclose (fd2);
16041 }
16042 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16043 {
16044 FILE *fd2 = fopen (dictfile2, "rb");
16045
16046 if (fd2 == NULL)
16047 {
16048 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16049
16050 return (-1);
16051 }
16052
16053 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16054
16055 fclose (fd2);
16056 }
16057
16058 if (data.words_cnt == 0)
16059 {
16060 if (data.devices_status == STATUS_CRACKED) break;
16061 if (data.devices_status == STATUS_ABORTED) break;
16062
16063 dictpos++;
16064
16065 continue;
16066 }
16067 }
16068 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16069 {
16070 char *dictfile = NULL;
16071
16072 if (induction_dictionaries_cnt)
16073 {
16074 dictfile = induction_dictionaries[0];
16075 }
16076 else
16077 {
16078 dictfile = dictfiles[dictpos];
16079 }
16080
16081 data.dictfile = dictfile;
16082
16083 char *mask = data.mask;
16084
16085 logfile_sub_string (dictfile);
16086 logfile_sub_string (mask);
16087
16088 FILE *fd2 = fopen (dictfile, "rb");
16089
16090 if (fd2 == NULL)
16091 {
16092 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16093
16094 return (-1);
16095 }
16096
16097 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16098
16099 fclose (fd2);
16100
16101 if (data.words_cnt == 0)
16102 {
16103 if (data.devices_status == STATUS_CRACKED) break;
16104 if (data.devices_status == STATUS_ABORTED) break;
16105
16106 dictpos++;
16107
16108 continue;
16109 }
16110 }
16111 else if (attack_mode == ATTACK_MODE_BF)
16112 {
16113 local_free (css_buf);
16114 local_free (data.root_css_buf);
16115 local_free (data.markov_css_buf);
16116
16117 char *mask = dictfiles[dictpos];
16118
16119 logfile_sub_string (mask);
16120
16121 // base
16122
16123 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16124
16125 if (opts_type & OPTS_TYPE_PT_UNICODE)
16126 {
16127 uint css_cnt_unicode = css_cnt * 2;
16128
16129 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16130
16131 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16132 {
16133 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16134
16135 css_buf_unicode[j + 1].cs_buf[0] = 0;
16136 css_buf_unicode[j + 1].cs_len = 1;
16137 }
16138
16139 free (css_buf);
16140
16141 css_buf = css_buf_unicode;
16142 css_cnt = css_cnt_unicode;
16143 }
16144
16145 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16146
16147 uint mask_min = pw_min;
16148 uint mask_max = pw_max;
16149
16150 if (opts_type & OPTS_TYPE_PT_UNICODE)
16151 {
16152 mask_min *= 2;
16153 mask_max *= 2;
16154 }
16155
16156 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16157 {
16158 if (css_cnt < mask_min)
16159 {
16160 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16161 }
16162
16163 if (css_cnt > mask_max)
16164 {
16165 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16166 }
16167
16168 // skip to next mask
16169
16170 dictpos++;
16171
16172 rd->dictpos = dictpos;
16173
16174 logfile_sub_msg ("STOP");
16175
16176 continue;
16177 }
16178
16179 uint save_css_cnt = css_cnt;
16180
16181 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16182 {
16183 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16184 {
16185 uint salt_len = (uint) data.salts_buf[0].salt_len;
16186 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16187
16188 uint css_cnt_salt = css_cnt + salt_len;
16189
16190 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16191
16192 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16193
16194 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16195 {
16196 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16197 css_buf_salt[j].cs_len = 1;
16198 }
16199
16200 free (css_buf);
16201
16202 css_buf = css_buf_salt;
16203 css_cnt = css_cnt_salt;
16204 }
16205 }
16206
16207 data.mask = mask;
16208 data.css_cnt = css_cnt;
16209 data.css_buf = css_buf;
16210
16211 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16212
16213 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16214
16215 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16216
16217 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16218 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16219
16220 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16221
16222 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16223
16224 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16225 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16226
16227 data.root_css_buf = root_css_buf;
16228 data.markov_css_buf = markov_css_buf;
16229
16230 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16231
16232 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16233
16234 local_free (root_table_buf);
16235 local_free (markov_table_buf);
16236
16237 // copy + args
16238
16239 uint css_cnt_l = css_cnt;
16240 uint css_cnt_r;
16241
16242 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16243 {
16244 if (save_css_cnt < 6)
16245 {
16246 css_cnt_r = 1;
16247 }
16248 else if (save_css_cnt == 6)
16249 {
16250 css_cnt_r = 2;
16251 }
16252 else
16253 {
16254 if (opts_type & OPTS_TYPE_PT_UNICODE)
16255 {
16256 if (save_css_cnt == 8 || save_css_cnt == 10)
16257 {
16258 css_cnt_r = 2;
16259 }
16260 else
16261 {
16262 css_cnt_r = 4;
16263 }
16264 }
16265 else
16266 {
16267 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16268 {
16269 css_cnt_r = 3;
16270 }
16271 else
16272 {
16273 css_cnt_r = 4;
16274 }
16275 }
16276 }
16277 }
16278 else
16279 {
16280 css_cnt_r = 1;
16281
16282 /* unfinished code?
16283 int sum = css_buf[css_cnt_r - 1].cs_len;
16284
16285 for (uint i = 1; i < 4 && i < css_cnt; i++)
16286 {
16287 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16288
16289 css_cnt_r++;
16290
16291 sum *= css_buf[css_cnt_r - 1].cs_len;
16292 }
16293 */
16294 }
16295
16296 css_cnt_l -= css_cnt_r;
16297
16298 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16299
16300 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16301 {
16302 hc_device_param_t *device_param = &data.devices_param[device_id];
16303
16304 if (device_param->skipped) continue;
16305
16306 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16307 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16308 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16309
16310 device_param->kernel_params_mp_l_buf64[3] = 0;
16311 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16312 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16313 device_param->kernel_params_mp_l_buf32[6] = 0;
16314 device_param->kernel_params_mp_l_buf32[7] = 0;
16315 device_param->kernel_params_mp_l_buf32[8] = 0;
16316
16317 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16318 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16319 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16320 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16321
16322 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16323 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16324 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16325
16326 device_param->kernel_params_mp_r_buf64[3] = 0;
16327 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16328 device_param->kernel_params_mp_r_buf32[5] = 0;
16329 device_param->kernel_params_mp_r_buf32[6] = 0;
16330 device_param->kernel_params_mp_r_buf32[7] = 0;
16331
16332 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]);
16333 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]);
16334 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]);
16335
16336 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]);
16337 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]);
16338 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]);
16339
16340 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);
16341 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);
16342 }
16343 }
16344
16345 u64 words_base = data.words_cnt;
16346
16347 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16348 {
16349 if (data.kernel_rules_cnt)
16350 {
16351 words_base /= data.kernel_rules_cnt;
16352 }
16353 }
16354 else if (data.attack_kern == ATTACK_KERN_COMBI)
16355 {
16356 if (data.combs_cnt)
16357 {
16358 words_base /= data.combs_cnt;
16359 }
16360 }
16361 else if (data.attack_kern == ATTACK_KERN_BF)
16362 {
16363 if (data.bfs_cnt)
16364 {
16365 words_base /= data.bfs_cnt;
16366 }
16367 }
16368
16369 data.words_base = words_base;
16370
16371 if (keyspace == 1)
16372 {
16373 log_info ("%llu", (unsigned long long int) words_base);
16374
16375 return (0);
16376 }
16377
16378 if (data.words_cur > data.words_base)
16379 {
16380 log_error ("ERROR: restore value greater keyspace");
16381
16382 return (-1);
16383 }
16384
16385 if (data.words_cur)
16386 {
16387 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16388 {
16389 for (uint i = 0; i < data.salts_cnt; i++)
16390 {
16391 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16392 }
16393 }
16394 else if (data.attack_kern == ATTACK_KERN_COMBI)
16395 {
16396 for (uint i = 0; i < data.salts_cnt; i++)
16397 {
16398 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16399 }
16400 }
16401 else if (data.attack_kern == ATTACK_KERN_BF)
16402 {
16403 for (uint i = 0; i < data.salts_cnt; i++)
16404 {
16405 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16406 }
16407 }
16408 }
16409
16410 /*
16411 * Inform user about possible slow speeds
16412 */
16413
16414 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16415 {
16416 if (data.words_base < kernel_power_all)
16417 {
16418 if (quiet == 0)
16419 {
16420 log_info ("");
16421 log_info ("ATTENTION!");
16422 log_info (" The wordlist or mask you are using is too small.");
16423 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16424 log_info (" The cracking speed will drop.");
16425 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16426 log_info ("");
16427 }
16428 }
16429 }
16430
16431 /*
16432 * Update loopback file
16433 */
16434
16435 if (loopback == 1)
16436 {
16437 time_t now;
16438
16439 time (&now);
16440
16441 uint random_num = get_random_num (0, 9999);
16442
16443 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16444
16445 data.loopback_file = loopback_file;
16446 }
16447
16448 /*
16449 * Update dictionary statistic
16450 */
16451
16452 if (keyspace == 0)
16453 {
16454 dictstat_fp = fopen (dictstat, "wb");
16455
16456 if (dictstat_fp)
16457 {
16458 lock_file (dictstat_fp);
16459
16460 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16461
16462 fclose (dictstat_fp);
16463 }
16464 }
16465
16466 data.devices_status = STATUS_RUNNING;
16467
16468 if (initial_restore_done == 0)
16469 {
16470 if (data.restore_disable == 0) cycle_restore ();
16471
16472 initial_restore_done = 1;
16473 }
16474
16475 hc_timer_set (&data.timer_running);
16476
16477 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16478 {
16479 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16480 {
16481 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16482 if (quiet == 0) fflush (stdout);
16483 }
16484 }
16485 else if (wordlist_mode == WL_MODE_STDIN)
16486 {
16487 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16488 if (data.quiet == 0) log_info ("");
16489 }
16490
16491 time_t runtime_start;
16492
16493 time (&runtime_start);
16494
16495 data.runtime_start = runtime_start;
16496
16497 /**
16498 * create cracker threads
16499 */
16500
16501 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16502
16503 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16504 {
16505 hc_device_param_t *device_param = &devices_param[device_id];
16506
16507 if (wordlist_mode == WL_MODE_STDIN)
16508 {
16509 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16510 }
16511 else
16512 {
16513 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16514 }
16515 }
16516
16517 // wait for crack threads to exit
16518
16519 hc_thread_wait (data.devices_cnt, c_threads);
16520
16521 local_free (c_threads);
16522
16523 data.restore = 0;
16524
16525 // finalize task
16526
16527 logfile_sub_var_uint ("status-after-work", data.devices_status);
16528
16529 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16530
16531 if (data.devices_status == STATUS_CRACKED) break;
16532 if (data.devices_status == STATUS_ABORTED) break;
16533
16534 if (data.devices_status == STATUS_BYPASS)
16535 {
16536 data.devices_status = STATUS_RUNNING;
16537 }
16538
16539 if (induction_dictionaries_cnt)
16540 {
16541 unlink (induction_dictionaries[0]);
16542 }
16543
16544 free (induction_dictionaries);
16545
16546 if (attack_mode != ATTACK_MODE_BF)
16547 {
16548 induction_dictionaries = scan_directory (induction_directory);
16549
16550 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16551 }
16552
16553 if (benchmark == 0)
16554 {
16555 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16556 {
16557 if (quiet == 0) clear_prompt ();
16558
16559 if (quiet == 0) log_info ("");
16560
16561 if (status == 1)
16562 {
16563 status_display ();
16564 }
16565 else
16566 {
16567 if (quiet == 0) status_display ();
16568 }
16569
16570 if (quiet == 0) log_info ("");
16571 }
16572 }
16573
16574 if (attack_mode == ATTACK_MODE_BF)
16575 {
16576 dictpos++;
16577
16578 rd->dictpos = dictpos;
16579 }
16580 else
16581 {
16582 if (induction_dictionaries_cnt)
16583 {
16584 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16585 }
16586 else
16587 {
16588 dictpos++;
16589
16590 rd->dictpos = dictpos;
16591 }
16592 }
16593
16594 time_t runtime_stop;
16595
16596 time (&runtime_stop);
16597
16598 data.runtime_stop = runtime_stop;
16599
16600 logfile_sub_uint (runtime_start);
16601 logfile_sub_uint (runtime_stop);
16602
16603 logfile_sub_msg ("STOP");
16604
16605 global_free (subid);
16606 }
16607
16608 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16609
16610 if (data.devices_status == STATUS_CRACKED) break;
16611 if (data.devices_status == STATUS_ABORTED) break;
16612 if (data.devices_status == STATUS_QUIT) break;
16613
16614 if (data.devices_status == STATUS_BYPASS)
16615 {
16616 data.devices_status = STATUS_RUNNING;
16617 }
16618 }
16619
16620 // 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
16621
16622 if (attack_mode == ATTACK_MODE_STRAIGHT)
16623 {
16624 if (data.wordlist_mode == WL_MODE_FILE)
16625 {
16626 if (data.dictfile == NULL)
16627 {
16628 if (dictfiles != NULL)
16629 {
16630 data.dictfile = dictfiles[0];
16631
16632 hc_timer_set (&data.timer_running);
16633 }
16634 }
16635 }
16636 }
16637 // NOTE: combi is okay because it is already set beforehand
16638 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16639 {
16640 if (data.dictfile == NULL)
16641 {
16642 if (dictfiles != NULL)
16643 {
16644 hc_timer_set (&data.timer_running);
16645
16646 data.dictfile = dictfiles[0];
16647 }
16648 }
16649 }
16650 else if (attack_mode == ATTACK_MODE_BF)
16651 {
16652 if (data.mask == NULL)
16653 {
16654 hc_timer_set (&data.timer_running);
16655
16656 data.mask = masks[0];
16657 }
16658 }
16659
16660 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16661 {
16662 data.devices_status = STATUS_EXHAUSTED;
16663 }
16664
16665 // if cracked / aborted remove last induction dictionary
16666
16667 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16668 {
16669 struct stat induct_stat;
16670
16671 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16672 {
16673 unlink (induction_dictionaries[file_pos]);
16674 }
16675 }
16676
16677 // wait for non-interactive threads
16678
16679 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16680 {
16681 hc_thread_wait (1, &ni_threads[thread_idx]);
16682 }
16683
16684 local_free (ni_threads);
16685
16686 // wait for interactive threads
16687
16688 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16689 {
16690 hc_thread_wait (1, &i_thread);
16691 }
16692
16693 // we dont need restore file anymore
16694 if (data.restore_disable == 0)
16695 {
16696 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16697 {
16698 unlink (eff_restore_file);
16699 unlink (new_restore_file);
16700 }
16701 else
16702 {
16703 cycle_restore ();
16704 }
16705 }
16706
16707 // finally save left hashes
16708
16709 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16710 {
16711 save_hash ();
16712 }
16713
16714 /**
16715 * Clean up
16716 */
16717
16718 if (benchmark == 1)
16719 {
16720 status_benchmark ();
16721
16722 log_info ("");
16723 }
16724 else
16725 {
16726 if (quiet == 0) clear_prompt ();
16727
16728 if (quiet == 0) log_info ("");
16729
16730 if (status == 1)
16731 {
16732 status_display ();
16733 }
16734 else
16735 {
16736 if (quiet == 0) status_display ();
16737 }
16738
16739 if (quiet == 0) log_info ("");
16740 }
16741
16742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16743 {
16744 hc_device_param_t *device_param = &data.devices_param[device_id];
16745
16746 if (device_param->skipped) continue;
16747
16748 local_free (device_param->result);
16749
16750 local_free (device_param->combs_buf);
16751
16752 local_free (device_param->hooks_buf);
16753
16754 local_free (device_param->device_name);
16755
16756 local_free (device_param->device_name_chksum);
16757
16758 local_free (device_param->device_version);
16759
16760 local_free (device_param->driver_version);
16761
16762 if (device_param->pws_buf) myfree (device_param->pws_buf);
16763 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16764 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16765 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16766 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16767 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16768 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16769 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16770 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16771 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16772 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16773 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16774 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16775 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16776 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16777 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16778 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16779 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16780 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16781 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16782 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16783 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16784 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16785 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16786 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16787 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16788 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16789 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16790 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16791
16792 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16793 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16794 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16795 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16796 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16797 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16798 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16799 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16800 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16801 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16802 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16803
16804 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16805 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16806 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16807
16808 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16809 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16810 }
16811
16812 // reset default fan speed
16813
16814 #ifdef HAVE_HWMON
16815 if (gpu_temp_disable == 0)
16816 {
16817 #ifdef HAVE_ADL
16818 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16819 {
16820 hc_thread_mutex_lock (mux_adl);
16821
16822 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16823 {
16824 hc_device_param_t *device_param = &data.devices_param[device_id];
16825
16826 if (device_param->skipped) continue;
16827
16828 if (data.hm_device[device_id].fan_supported == 1)
16829 {
16830 int fanspeed = temp_retain_fanspeed_value[device_id];
16831
16832 if (fanspeed == -1) continue;
16833
16834 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16835
16836 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16837 }
16838 }
16839
16840 hc_thread_mutex_unlock (mux_adl);
16841 }
16842 #endif // HAVE_ADL
16843 }
16844
16845 #ifdef HAVE_ADL
16846 // reset power tuning
16847
16848 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16849 {
16850 hc_thread_mutex_lock (mux_adl);
16851
16852 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16853 {
16854 hc_device_param_t *device_param = &data.devices_param[device_id];
16855
16856 if (device_param->skipped) continue;
16857
16858 if (data.hm_device[device_id].od_version == 6)
16859 {
16860 // check powertune capabilities first, if not available then skip device
16861
16862 int powertune_supported = 0;
16863
16864 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16865 {
16866 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16867
16868 return (-1);
16869 }
16870
16871 if (powertune_supported != 0)
16872 {
16873 // powercontrol settings
16874
16875 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)
16876 {
16877 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16878
16879 return (-1);
16880 }
16881
16882 // clocks
16883
16884 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16885
16886 performance_state->iNumberOfPerformanceLevels = 2;
16887
16888 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16889 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16890 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16891 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16892
16893 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)
16894 {
16895 log_info ("ERROR: Failed to restore ADL performance state");
16896
16897 return (-1);
16898 }
16899
16900 local_free (performance_state);
16901 }
16902 }
16903 }
16904
16905 hc_thread_mutex_unlock (mux_adl);
16906 }
16907 #endif // HAVE_ADL
16908
16909 if (gpu_temp_disable == 0)
16910 {
16911 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16912 if (data.hm_nv)
16913 {
16914 #if defined(LINUX) && defined(HAVE_NVML)
16915
16916 hm_NVML_nvmlShutdown (data.hm_nv);
16917
16918 nvml_close (data.hm_nv);
16919
16920 #elif defined(WIN) && (HAVE_NVAPI)
16921
16922 hm_NvAPI_Unload (data.hm_nv);
16923
16924 nvapi_close (data.hm_nv);
16925
16926 #endif
16927
16928 data.hm_nv = NULL;
16929 }
16930 #endif
16931
16932 #ifdef HAVE_ADL
16933 if (data.hm_amd)
16934 {
16935 hm_ADL_Main_Control_Destroy (data.hm_amd);
16936
16937 adl_close (data.hm_amd);
16938 data.hm_amd = NULL;
16939 }
16940 #endif
16941 }
16942 #endif // HAVE_HWMON
16943
16944 // free memory
16945
16946 local_free (masks);
16947
16948 local_free (dictstat_base);
16949
16950 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16951 {
16952 pot_t *pot_ptr = &pot[pot_pos];
16953
16954 hash_t *hash = &pot_ptr->hash;
16955
16956 local_free (hash->digest);
16957
16958 if (isSalted)
16959 {
16960 local_free (hash->salt);
16961 }
16962 }
16963
16964 local_free (pot);
16965
16966 local_free (all_kernel_rules_cnt);
16967 local_free (all_kernel_rules_buf);
16968
16969 local_free (wl_data->buf);
16970 local_free (wl_data);
16971
16972 local_free (bitmap_s1_a);
16973 local_free (bitmap_s1_b);
16974 local_free (bitmap_s1_c);
16975 local_free (bitmap_s1_d);
16976 local_free (bitmap_s2_a);
16977 local_free (bitmap_s2_b);
16978 local_free (bitmap_s2_c);
16979 local_free (bitmap_s2_d);
16980
16981 #ifdef HAVE_HWMON
16982 local_free (temp_retain_fanspeed_value);
16983 #ifdef HAVE_ADL
16984 local_free (od_clock_mem_status);
16985 local_free (od_power_control_status);
16986 #endif // ADL
16987 #endif
16988
16989 global_free (devices_param);
16990
16991 global_free (kernel_rules_buf);
16992
16993 global_free (root_css_buf);
16994 global_free (markov_css_buf);
16995
16996 global_free (digests_buf);
16997 global_free (digests_shown);
16998 global_free (digests_shown_tmp);
16999
17000 global_free (salts_buf);
17001 global_free (salts_shown);
17002
17003 global_free (esalts_buf);
17004
17005 global_free (words_progress_done);
17006 global_free (words_progress_rejected);
17007 global_free (words_progress_restored);
17008
17009 if (pot_fp) fclose (pot_fp);
17010
17011 if (data.devices_status == STATUS_QUIT) break;
17012 }
17013
17014 // destroy others mutex
17015
17016 hc_thread_mutex_delete (mux_dispatcher);
17017 hc_thread_mutex_delete (mux_counter);
17018 hc_thread_mutex_delete (mux_display);
17019 hc_thread_mutex_delete (mux_adl);
17020
17021 // free memory
17022
17023 local_free (eff_restore_file);
17024 local_free (new_restore_file);
17025
17026 local_free (rd);
17027
17028 // tuning db
17029
17030 tuning_db_destroy (tuning_db);
17031
17032 // loopback
17033
17034 local_free (loopback_file);
17035
17036 if (loopback == 1) unlink (loopback_file);
17037
17038 // induction directory
17039
17040 if (induction_dir == NULL)
17041 {
17042 if (attack_mode != ATTACK_MODE_BF)
17043 {
17044 if (rmdir (induction_directory) == -1)
17045 {
17046 if (errno == ENOENT)
17047 {
17048 // good, we can ignore
17049 }
17050 else if (errno == ENOTEMPTY)
17051 {
17052 // good, we can ignore
17053 }
17054 else
17055 {
17056 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17057
17058 return (-1);
17059 }
17060 }
17061
17062 local_free (induction_directory);
17063 }
17064 }
17065
17066 // outfile-check directory
17067
17068 if (outfile_check_dir == NULL)
17069 {
17070 if (rmdir (outfile_check_directory) == -1)
17071 {
17072 if (errno == ENOENT)
17073 {
17074 // good, we can ignore
17075 }
17076 else if (errno == ENOTEMPTY)
17077 {
17078 // good, we can ignore
17079 }
17080 else
17081 {
17082 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17083
17084 return (-1);
17085 }
17086 }
17087
17088 local_free (outfile_check_directory);
17089 }
17090
17091 time_t proc_stop;
17092
17093 time (&proc_stop);
17094
17095 logfile_top_uint (proc_start);
17096 logfile_top_uint (proc_stop);
17097
17098 logfile_top_msg ("STOP");
17099
17100 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17101 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17102
17103 if (data.ocl) ocl_close (data.ocl);
17104
17105 if (data.devices_status == STATUS_ABORTED) return 2;
17106 if (data.devices_status == STATUS_QUIT) return 2;
17107 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17108 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17109 if (data.devices_status == STATUS_CRACKED) return 0;
17110
17111 return -1;
17112 }
Hashcat additions to support pwdhash