projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Prevent NV OpenCL runtime to cache kernels to ~/.nv by using an undocumented environm...
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 134
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 11600,
272 12500,
273 13000,
274 13200,
275 13300,
276 6211,
277 6221,
278 6231,
279 6241,
280 8800,
281 12900,
282 12200,
283 9700,
284 9710,
285 9800,
286 9810,
287 9400,
288 9500,
289 9600,
290 10400,
291 10410,
292 10500,
293 10600,
294 10700,
295 9000,
296 5200,
297 6800,
298 6600,
299 8200,
300 11300,
301 12700,
302 13400
303 };
304
305 /**
306 * types
307 */
308
309 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
310
311 /**
312 * globals
313 */
314
315 static unsigned int full01 = 0x01010101;
316 static unsigned int full80 = 0x80808080;
317
318 int SUPPRESS_OUTPUT = 0;
319
320 hc_thread_mutex_t mux_adl;
321 hc_thread_mutex_t mux_counter;
322 hc_thread_mutex_t mux_dispatcher;
323 hc_thread_mutex_t mux_display;
324
325 hc_global_data_t data;
326
327 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
328
329 const char *USAGE_MINI[] =
330 {
331 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
332 "",
333 "Try --help for more help.",
334 NULL
335 };
336
337 const char *USAGE_BIG[] =
338 {
339 "%s, advanced password recovery",
340 "",
341 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
342 "",
343 "=======",
344 "Options",
345 "=======",
346 "",
347 "* General:",
348 "",
349 " -m, --hash-type=NUM Hash-type, see references below",
350 " -a, --attack-mode=NUM Attack-mode, see references below",
351 " -V, --version Print version",
352 " -h, --help Print help",
353 " --quiet Suppress output",
354 "",
355 "* Misc:",
356 "",
357 " --hex-charset Assume charset is given in hex",
358 " --hex-salt Assume salt is given in hex",
359 " --hex-wordlist Assume words in wordlist is given in hex",
360 " --force Ignore warnings",
361 " --status Enable automatic update of the status-screen",
362 " --status-timer=NUM Seconds between status-screen update",
363 " --status-automat Display the status view in a machine readable format",
364 " --loopback Add new plains to induct directory",
365 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
366 "",
367 "* Markov:",
368 "",
369 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
370 " --markov-disable Disables markov-chains, emulates classic brute-force",
371 " --markov-classic Enables classic markov-chains, no per-position enhancement",
372 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
373 "",
374 "* Session:",
375 "",
376 " --runtime=NUM Abort session after NUM seconds of runtime",
377 " --session=STR Define specific session name",
378 " --restore Restore session from --session",
379 " --restore-disable Do not write restore file",
380 "",
381 "* Files:",
382 "",
383 " -o, --outfile=FILE Define outfile for recovered hash",
384 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
385 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
386 " --outfile-check-timer=NUM Seconds between outfile checks",
387 " -p, --separator=CHAR Separator char for hashlists and outfile",
388 " --show Show cracked passwords only",
389 " --left Show un-cracked passwords only",
390 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
391 " --remove Enable remove of hash once it is cracked",
392 " --remove-timer=NUM Update input hash file each NUM seconds",
393 " --potfile-disable Do not write potfile",
394 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
395 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
396 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
397 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
398 " --logfile-disable Disable the logfile",
399 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
400 "",
401 "* Resources:",
402 "",
403 " -b, --benchmark Run benchmark",
404 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
405 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
406 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
407 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
408 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
409 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
410 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
411 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
412 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
413 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
414 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
415 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
416 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
417 #ifdef HAVE_HWMON
418 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
419 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
420 #ifdef HAVE_ADL
421 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
422 #endif
423 #endif
424 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
425 "",
426 "* Distributed:",
427 "",
428 " -s, --skip=NUM Skip number of words",
429 " -l, --limit=NUM Limit number of words",
430 " --keyspace Show keyspace base:mod values and quit",
431 "",
432 "* Rules:",
433 "",
434 " -j, --rule-left=RULE Single rule applied to each word from left dict",
435 " -k, --rule-right=RULE Single rule applied to each word from right dict",
436 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
437 " -g, --generate-rules=NUM Generate NUM random rules",
438 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
439 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
440 " --generate-rules-seed=NUM Force RNG seed to NUM",
441 "",
442 "* Custom charsets:",
443 "",
444 " -1, --custom-charset1=CS User-defined charsets",
445 " -2, --custom-charset2=CS Example:",
446 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
447 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
448 "",
449 "* Increment:",
450 "",
451 " -i, --increment Enable increment mode",
452 " --increment-min=NUM Start incrementing at NUM",
453 " --increment-max=NUM Stop incrementing at NUM",
454 "",
455 "==========",
456 "References",
457 "==========",
458 "",
459 "* Workload Profile:",
460 "",
461 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
462 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
463 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
464 "",
465 "* OpenCL device-types:",
466 "",
467 " 1 = CPU devices",
468 " 2 = GPU devices",
469 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
470 "",
471 "* Outfile Formats:",
472 "",
473 " 1 = hash[:salt]",
474 " 2 = plain",
475 " 3 = hash[:salt]:plain",
476 " 4 = hex_plain",
477 " 5 = hash[:salt]:hex_plain",
478 " 6 = plain:hex_plain",
479 " 7 = hash[:salt]:plain:hex_plain",
480 " 8 = crackpos",
481 " 9 = hash[:salt]:crackpos",
482 " 10 = plain:crackpos",
483 " 11 = hash[:salt]:plain:crackpos",
484 " 12 = hex_plain:crackpos",
485 " 13 = hash[:salt]:hex_plain:crackpos",
486 " 14 = plain:hex_plain:crackpos",
487 " 15 = hash[:salt]:plain:hex_plain:crackpos",
488 "",
489 "* Debug mode output formats (for hybrid mode only, by using rules):",
490 "",
491 " 1 = save finding rule",
492 " 2 = save original word",
493 " 3 = save original word and finding rule",
494 " 4 = save original word, finding rule and modified plain",
495 "",
496 "* Built-in charsets:",
497 "",
498 " ?l = abcdefghijklmnopqrstuvwxyz",
499 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
500 " ?d = 0123456789",
501 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
502 " ?a = ?l?u?d?s",
503 " ?b = 0x00 - 0xff",
504 "",
505 "* Attack modes:",
506 "",
507 " 0 = Straight",
508 " 1 = Combination",
509 " 3 = Brute-force",
510 " 6 = Hybrid dict + mask",
511 " 7 = Hybrid mask + dict",
512 "",
513 "* Hash types:",
514 "",
515 "[[ Roll-your-own: Raw Hashes ]]",
516 "",
517 " 900 = MD4",
518 " 0 = MD5",
519 " 5100 = Half MD5",
520 " 100 = SHA1",
521 " 10800 = SHA-384",
522 " 1400 = SHA-256",
523 " 1700 = SHA-512",
524 " 5000 = SHA-3(Keccak)",
525 " 10100 = SipHash",
526 " 6000 = RipeMD160",
527 " 6100 = Whirlpool",
528 " 6900 = GOST R 34.11-94",
529 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
530 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
531 "",
532 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
533 "",
534 " 10 = md5($pass.$salt)",
535 " 20 = md5($salt.$pass)",
536 " 30 = md5(unicode($pass).$salt)",
537 " 40 = md5($salt.unicode($pass))",
538 " 3800 = md5($salt.$pass.$salt)",
539 " 3710 = md5($salt.md5($pass))",
540 " 2600 = md5(md5($pass)",
541 " 4300 = md5(strtoupper(md5($pass)))",
542 " 4400 = md5(sha1($pass))",
543 " 110 = sha1($pass.$salt)",
544 " 120 = sha1($salt.$pass)",
545 " 130 = sha1(unicode($pass).$salt)",
546 " 140 = sha1($salt.unicode($pass))",
547 " 4500 = sha1(sha1($pass)",
548 " 4700 = sha1(md5($pass))",
549 " 4900 = sha1($salt.$pass.$salt)",
550 " 1410 = sha256($pass.$salt)",
551 " 1420 = sha256($salt.$pass)",
552 " 1430 = sha256(unicode($pass).$salt)",
553 " 1440 = sha256($salt.unicode($pass))",
554 " 1710 = sha512($pass.$salt)",
555 " 1720 = sha512($salt.$pass)",
556 " 1730 = sha512(unicode($pass).$salt)",
557 " 1740 = sha512($salt.unicode($pass))",
558 "",
559 "[[ Roll-your-own: Authenticated Hashes ]]",
560 "",
561 " 50 = HMAC-MD5 (key = $pass)",
562 " 60 = HMAC-MD5 (key = $salt)",
563 " 150 = HMAC-SHA1 (key = $pass)",
564 " 160 = HMAC-SHA1 (key = $salt)",
565 " 1450 = HMAC-SHA256 (key = $pass)",
566 " 1460 = HMAC-SHA256 (key = $salt)",
567 " 1750 = HMAC-SHA512 (key = $pass)",
568 " 1760 = HMAC-SHA512 (key = $salt)",
569 "",
570 "[[ Generic KDF ]]",
571 "",
572 " 400 = phpass",
573 " 8900 = scrypt",
574 " 11900 = PBKDF2-HMAC-MD5",
575 " 12000 = PBKDF2-HMAC-SHA1",
576 " 10900 = PBKDF2-HMAC-SHA256",
577 " 12100 = PBKDF2-HMAC-SHA512",
578 "",
579 "[[ Network protocols, Challenge-Response ]]",
580 "",
581 " 23 = Skype",
582 " 2500 = WPA/WPA2",
583 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
584 " 5300 = IKE-PSK MD5",
585 " 5400 = IKE-PSK SHA1",
586 " 5500 = NetNTLMv1",
587 " 5500 = NetNTLMv1 + ESS",
588 " 5600 = NetNTLMv2",
589 " 7300 = IPMI2 RAKP HMAC-SHA1",
590 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
591 " 8300 = DNSSEC (NSEC3)",
592 " 10200 = Cram MD5",
593 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
594 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
595 " 11400 = SIP digest authentication (MD5)",
596 " 13100 = Kerberos 5 TGS-REP etype 23",
597 "",
598 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
599 "",
600 " 121 = SMF (Simple Machines Forum)",
601 " 400 = phpBB3",
602 " 2611 = vBulletin < v3.8.5",
603 " 2711 = vBulletin > v3.8.5",
604 " 2811 = MyBB",
605 " 2811 = IPB (Invison Power Board)",
606 " 8400 = WBB3 (Woltlab Burning Board)",
607 " 11 = Joomla < 2.5.18",
608 " 400 = Joomla > 2.5.18",
609 " 400 = Wordpress",
610 " 2612 = PHPS",
611 " 7900 = Drupal7",
612 " 21 = osCommerce",
613 " 21 = xt:Commerce",
614 " 11000 = PrestaShop",
615 " 124 = Django (SHA-1)",
616 " 10000 = Django (PBKDF2-SHA256)",
617 " 3711 = Mediawiki B type",
618 " 7600 = Redmine",
619 "",
620 "[[ Database Server ]]",
621 "",
622 " 12 = PostgreSQL",
623 " 131 = MSSQL(2000)",
624 " 132 = MSSQL(2005)",
625 " 1731 = MSSQL(2012)",
626 " 1731 = MSSQL(2014)",
627 " 200 = MySQL323",
628 " 300 = MySQL4.1/MySQL5",
629 " 3100 = Oracle H: Type (Oracle 7+)",
630 " 112 = Oracle S: Type (Oracle 11+)",
631 " 12300 = Oracle T: Type (Oracle 12+)",
632 " 8000 = Sybase ASE",
633 "",
634 "[[ HTTP, SMTP, LDAP Server ]]",
635 "",
636 " 141 = EPiServer 6.x < v4",
637 " 1441 = EPiServer 6.x > v4",
638 " 1600 = Apache $apr1$",
639 " 12600 = ColdFusion 10+",
640 " 1421 = hMailServer",
641 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
642 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
643 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
644 "",
645 "[[ Checksums ]]",
646 "",
647 " 11500 = CRC32",
648 "",
649 "[[ Operating-Systems ]]",
650 "",
651 " 3000 = LM",
652 " 1000 = NTLM",
653 " 1100 = Domain Cached Credentials (DCC), MS Cache",
654 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
655 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
656 " 1500 = descrypt, DES(Unix), Traditional DES",
657 " 12400 = BSDiCrypt, Extended DES",
658 " 500 = md5crypt $1$, MD5(Unix)",
659 " 3200 = bcrypt $2*$, Blowfish(Unix)",
660 " 7400 = sha256crypt $5$, SHA256(Unix)",
661 " 1800 = sha512crypt $6$, SHA512(Unix)",
662 " 122 = OSX v10.4",
663 " 122 = OSX v10.5",
664 " 122 = OSX v10.6",
665 " 1722 = OSX v10.7",
666 " 7100 = OSX v10.8",
667 " 7100 = OSX v10.9",
668 " 7100 = OSX v10.10",
669 " 6300 = AIX {smd5}",
670 " 6700 = AIX {ssha1}",
671 " 6400 = AIX {ssha256}",
672 " 6500 = AIX {ssha512}",
673 " 2400 = Cisco-PIX",
674 " 2410 = Cisco-ASA",
675 " 500 = Cisco-IOS $1$",
676 " 5700 = Cisco-IOS $4$",
677 " 9200 = Cisco-IOS $8$",
678 " 9300 = Cisco-IOS $9$",
679 " 22 = Juniper Netscreen/SSG (ScreenOS)",
680 " 501 = Juniper IVE",
681 " 5800 = Android PIN",
682 " 8100 = Citrix Netscaler",
683 " 8500 = RACF",
684 " 7200 = GRUB 2",
685 " 9900 = Radmin2",
686 "",
687 "[[ Enterprise Application Software (EAS) ]]",
688 "",
689 " 7700 = SAP CODVN B (BCODE)",
690 " 7800 = SAP CODVN F/G (PASSCODE)",
691 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
692 " 8600 = Lotus Notes/Domino 5",
693 " 8700 = Lotus Notes/Domino 6",
694 " 9100 = Lotus Notes/Domino 8",
695 " 133 = PeopleSoft",
696 "",
697 "[[ Archives ]]",
698 "",
699 " 11600 = 7-Zip",
700 " 12500 = RAR3-hp",
701 " 13000 = RAR5",
702 " 13200 = AxCrypt",
703 " 13300 = AxCrypt in memory SHA1",
704 "",
705 "[[ Full-Disk encryptions (FDE) ]]",
706 "",
707 " 62XY = TrueCrypt 5.0+",
708 " X = 1 = PBKDF2-HMAC-RipeMD160",
709 " X = 2 = PBKDF2-HMAC-SHA512",
710 " X = 3 = PBKDF2-HMAC-Whirlpool",
711 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
712 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
713 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
714 " Y = 3 = XTS 1536 bit (Ciphers: All)",
715 " 8800 = Android FDE < v4.3",
716 " 12900 = Android FDE (Samsung DEK)",
717 " 12200 = eCryptfs",
718 "",
719 "[[ Documents ]]",
720 "",
721 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
722 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
723 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
724 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
725 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
726 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
727 " 9400 = MS Office 2007",
728 " 9500 = MS Office 2010",
729 " 9600 = MS Office 2013",
730 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
731 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
732 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
733 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
734 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
735 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
736 "",
737 "[[ Password Managers ]]",
738 "",
739 " 9000 = Password Safe v2",
740 " 5200 = Password Safe v3",
741 " 6800 = Lastpass",
742 " 6600 = 1Password, agilekeychain",
743 " 8200 = 1Password, cloudkeychain",
744 " 11300 = Bitcoin/Litecoin wallet.dat",
745 " 12700 = Blockchain, My Wallet",
746 " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)",
747 "",
748 NULL
749 };
750
751 /**
752 * oclHashcat specific functions
753 */
754
755 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
756 {
757 int exec_pos = (int) device_param->exec_pos - last_num_entries;
758
759 if (exec_pos < 0) exec_pos += EXEC_CACHE;
760
761 double exec_ms_sum = 0;
762
763 int exec_ms_cnt = 0;
764
765 for (int i = 0; i < last_num_entries; i++)
766 {
767 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
768
769 if (exec_ms)
770 {
771 exec_ms_sum += exec_ms;
772
773 exec_ms_cnt++;
774 }
775 }
776
777 if (exec_ms_cnt == 0) return 0;
778
779 return exec_ms_sum / exec_ms_cnt;
780 }
781
782 void status_display_automat ()
783 {
784 FILE *out = stdout;
785
786 fprintf (out, "STATUS\t%u\t", data.devices_status);
787
788 /**
789 * speed new
790 */
791
792 fprintf (out, "SPEED\t");
793
794 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
795 {
796 hc_device_param_t *device_param = &data.devices_param[device_id];
797
798 if (device_param->skipped) continue;
799
800 u64 speed_cnt = 0;
801 float speed_ms = 0;
802
803 for (int i = 0; i < SPEED_CACHE; i++)
804 {
805 float rec_ms;
806
807 hc_timer_get (device_param->speed_rec[i], rec_ms);
808
809 if (rec_ms > SPEED_MAXAGE) continue;
810
811 speed_cnt += device_param->speed_cnt[i];
812 speed_ms += device_param->speed_ms[i];
813 }
814
815 speed_cnt /= SPEED_CACHE;
816 speed_ms /= SPEED_CACHE;
817
818 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
819 }
820
821 /**
822 * exec time
823 */
824
825 fprintf (out, "EXEC_RUNTIME\t");
826
827 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
828 {
829 hc_device_param_t *device_param = &data.devices_param[device_id];
830
831 if (device_param->skipped) continue;
832
833 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
834
835 fprintf (out, "%f\t", exec_ms_avg);
836 }
837
838 /**
839 * words_cur
840 */
841
842 u64 words_cur = get_lowest_words_done ();
843
844 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
845
846 /**
847 * counter
848 */
849
850 u64 progress_total = data.words_cnt * data.salts_cnt;
851
852 u64 all_done = 0;
853 u64 all_rejected = 0;
854 u64 all_restored = 0;
855
856 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
857 {
858 all_done += data.words_progress_done[salt_pos];
859 all_rejected += data.words_progress_rejected[salt_pos];
860 all_restored += data.words_progress_restored[salt_pos];
861 }
862
863 u64 progress_cur = all_restored + all_done + all_rejected;
864 u64 progress_end = progress_total;
865
866 u64 progress_skip = 0;
867
868 if (data.skip)
869 {
870 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
875 }
876
877 if (data.limit)
878 {
879 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
880
881 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
882 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
883 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
884 }
885
886 u64 progress_cur_relative_skip = progress_cur - progress_skip;
887 u64 progress_end_relative_skip = progress_end - progress_skip;
888
889 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
890
891 /**
892 * cracks
893 */
894
895 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
896 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
897
898 /**
899 * temperature
900 */
901
902 #ifdef HAVE_HWMON
903 if (data.gpu_temp_disable == 0)
904 {
905 fprintf (out, "TEMP\t");
906
907 hc_thread_mutex_lock (mux_adl);
908
909 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
910 {
911 hc_device_param_t *device_param = &data.devices_param[device_id];
912
913 if (device_param->skipped) continue;
914
915 int temp = hm_get_temperature_with_device_id (device_id);
916
917 fprintf (out, "%d\t", temp);
918 }
919
920 hc_thread_mutex_unlock (mux_adl);
921 }
922 #endif // HAVE_HWMON
923
924 /**
925 * flush
926 */
927
928 #ifdef _WIN
929 fputc ('\r', out);
930 fputc ('\n', out);
931 #endif
932
933 #ifdef _POSIX
934 fputc ('\n', out);
935 #endif
936
937 fflush (out);
938 }
939
940 void status_display ()
941 {
942 if (data.devices_status == STATUS_INIT) return;
943 if (data.devices_status == STATUS_STARTING) return;
944 if (data.devices_status == STATUS_BYPASS) return;
945
946 if (data.status_automat == 1)
947 {
948 status_display_automat ();
949
950 return;
951 }
952
953 char tmp_buf[1000] = { 0 };
954
955 uint tmp_len = 0;
956
957 log_info ("Session.Name...: %s", data.session);
958
959 char *status_type = strstatus (data.devices_status);
960
961 uint hash_mode = data.hash_mode;
962
963 char *hash_type = strhashtype (hash_mode); // not a bug
964
965 log_info ("Status.........: %s", status_type);
966
967 /**
968 * show rules
969 */
970
971 if (data.rp_files_cnt)
972 {
973 uint i;
974
975 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
976 {
977 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
978 }
979
980 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
981
982 log_info ("Rules.Type.....: %s", tmp_buf);
983
984 tmp_len = 0;
985 }
986
987 if (data.rp_gen)
988 {
989 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
990
991 if (data.rp_gen_seed)
992 {
993 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
994 }
995 }
996
997 /**
998 * show input
999 */
1000
1001 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1002 {
1003 if (data.wordlist_mode == WL_MODE_FILE)
1004 {
1005 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1006 }
1007 else if (data.wordlist_mode == WL_MODE_STDIN)
1008 {
1009 log_info ("Input.Mode.....: Pipe");
1010 }
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_COMBI)
1013 {
1014 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1015 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1016 }
1017 else if (data.attack_mode == ATTACK_MODE_BF)
1018 {
1019 char *mask = data.mask;
1020
1021 if (mask != NULL)
1022 {
1023 uint mask_len = data.css_cnt;
1024
1025 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1026
1027 if (mask_len > 0)
1028 {
1029 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1030 {
1031 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1032 {
1033 mask_len -= data.salts_buf[0].salt_len;
1034 }
1035 }
1036
1037 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1038
1039 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1040 }
1041
1042 if (data.maskcnt > 1)
1043 {
1044 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1045
1046 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1047 }
1048
1049 log_info ("Input.Mode.....: %s", tmp_buf);
1050 }
1051
1052 tmp_len = 0;
1053 }
1054 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1055 {
1056 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1057 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1058 }
1059 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1060 {
1061 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1062 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1063 }
1064
1065 if (data.digests_cnt == 1)
1066 {
1067 if (data.hash_mode == 2500)
1068 {
1069 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1070
1071 uint pke[25] = { 0 };
1072
1073 char *pke_ptr = (char *) pke;
1074
1075 for (uint i = 0; i < 25; i++)
1076 {
1077 pke[i] = byte_swap_32 (wpa->pke[i]);
1078 }
1079
1080 char mac1[6] = { 0 };
1081 char mac2[6] = { 0 };
1082
1083 memcpy (mac1, pke_ptr + 23, 6);
1084 memcpy (mac2, pke_ptr + 29, 6);
1085
1086 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1087 (char *) data.salts_buf[0].salt_buf,
1088 mac1[0] & 0xff,
1089 mac1[1] & 0xff,
1090 mac1[2] & 0xff,
1091 mac1[3] & 0xff,
1092 mac1[4] & 0xff,
1093 mac1[5] & 0xff,
1094 mac2[0] & 0xff,
1095 mac2[1] & 0xff,
1096 mac2[2] & 0xff,
1097 mac2[3] & 0xff,
1098 mac2[4] & 0xff,
1099 mac2[5] & 0xff);
1100 }
1101 else if (data.hash_mode == 5200)
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 else if (data.hash_mode == 9000)
1106 {
1107 log_info ("Hash.Target....: File (%s)", data.hashfile);
1108 }
1109 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1110 {
1111 log_info ("Hash.Target....: File (%s)", data.hashfile);
1112 }
1113 else
1114 {
1115 char out_buf[HCBUFSIZ] = { 0 };
1116
1117 ascii_digest (out_buf, 0, 0);
1118
1119 // limit length
1120 if (strlen (out_buf) > 40)
1121 {
1122 out_buf[41] = '.';
1123 out_buf[42] = '.';
1124 out_buf[43] = '.';
1125 out_buf[44] = 0;
1126 }
1127
1128 log_info ("Hash.Target....: %s", out_buf);
1129 }
1130 }
1131 else
1132 {
1133 if (data.hash_mode == 3000)
1134 {
1135 char out_buf1[32] = { 0 };
1136 char out_buf2[32] = { 0 };
1137
1138 ascii_digest (out_buf1, 0, 0);
1139 ascii_digest (out_buf2, 0, 1);
1140
1141 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1142 }
1143 else
1144 {
1145 log_info ("Hash.Target....: File (%s)", data.hashfile);
1146 }
1147 }
1148
1149 log_info ("Hash.Type......: %s", hash_type);
1150
1151 /**
1152 * speed new
1153 */
1154
1155 u64 speed_cnt[DEVICES_MAX] = { 0 };
1156 float speed_ms[DEVICES_MAX] = { 0 };
1157
1158 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1159 {
1160 hc_device_param_t *device_param = &data.devices_param[device_id];
1161
1162 if (device_param->skipped) continue;
1163
1164 // we need to clear values (set to 0) because in case the device does
1165 // not get new candidates it idles around but speed display would
1166 // show it as working.
1167 // if we instantly set it to 0 after reading it happens that the
1168 // speed can be shown as zero if the users refreshes too fast.
1169 // therefore, we add a timestamp when a stat was recorded and if its
1170 // too old we will not use it
1171
1172 speed_cnt[device_id] = 0;
1173 speed_ms[device_id] = 0;
1174
1175 for (int i = 0; i < SPEED_CACHE; i++)
1176 {
1177 float rec_ms;
1178
1179 hc_timer_get (device_param->speed_rec[i], rec_ms);
1180
1181 if (rec_ms > SPEED_MAXAGE) continue;
1182
1183 speed_cnt[device_id] += device_param->speed_cnt[i];
1184 speed_ms[device_id] += device_param->speed_ms[i];
1185 }
1186
1187 speed_cnt[device_id] /= SPEED_CACHE;
1188 speed_ms[device_id] /= SPEED_CACHE;
1189 }
1190
1191 float hashes_all_ms = 0;
1192
1193 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1194
1195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1196 {
1197 hc_device_param_t *device_param = &data.devices_param[device_id];
1198
1199 if (device_param->skipped) continue;
1200
1201 hashes_dev_ms[device_id] = 0;
1202
1203 if (speed_ms[device_id])
1204 {
1205 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1206
1207 hashes_all_ms += hashes_dev_ms[device_id];
1208 }
1209 }
1210
1211 /**
1212 * exec time
1213 */
1214
1215 double exec_all_ms[DEVICES_MAX] = { 0 };
1216
1217 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1218 {
1219 hc_device_param_t *device_param = &data.devices_param[device_id];
1220
1221 if (device_param->skipped) continue;
1222
1223 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1224
1225 exec_all_ms[device_id] = exec_ms_avg;
1226 }
1227
1228 /**
1229 * timers
1230 */
1231
1232 float ms_running = 0;
1233
1234 hc_timer_get (data.timer_running, ms_running);
1235
1236 float ms_paused = data.ms_paused;
1237
1238 if (data.devices_status == STATUS_PAUSED)
1239 {
1240 float ms_paused_tmp = 0;
1241
1242 hc_timer_get (data.timer_paused, ms_paused_tmp);
1243
1244 ms_paused += ms_paused_tmp;
1245 }
1246
1247 #ifdef WIN
1248
1249 __time64_t sec_run = ms_running / 1000;
1250
1251 #else
1252
1253 time_t sec_run = ms_running / 1000;
1254
1255 #endif
1256
1257 if (sec_run)
1258 {
1259 char display_run[32] = { 0 };
1260
1261 struct tm tm_run;
1262
1263 struct tm *tmp = NULL;
1264
1265 #ifdef WIN
1266
1267 tmp = _gmtime64 (&sec_run);
1268
1269 #else
1270
1271 tmp = gmtime (&sec_run);
1272
1273 #endif
1274
1275 if (tmp != NULL)
1276 {
1277 memset (&tm_run, 0, sizeof (tm_run));
1278
1279 memcpy (&tm_run, tmp, sizeof (tm_run));
1280
1281 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1282
1283 char *start = ctime (&data.proc_start);
1284
1285 size_t start_len = strlen (start);
1286
1287 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1288 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1289
1290 log_info ("Time.Started...: %s (%s)", start, display_run);
1291 }
1292 }
1293 else
1294 {
1295 log_info ("Time.Started...: 0 secs");
1296 }
1297
1298 /**
1299 * counters
1300 */
1301
1302 u64 progress_total = data.words_cnt * data.salts_cnt;
1303
1304 u64 all_done = 0;
1305 u64 all_rejected = 0;
1306 u64 all_restored = 0;
1307
1308 u64 progress_noneed = 0;
1309
1310 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1311 {
1312 all_done += data.words_progress_done[salt_pos];
1313 all_rejected += data.words_progress_rejected[salt_pos];
1314 all_restored += data.words_progress_restored[salt_pos];
1315
1316 // Important for ETA only
1317
1318 if (data.salts_shown[salt_pos] == 1)
1319 {
1320 const u64 all = data.words_progress_done[salt_pos]
1321 + data.words_progress_rejected[salt_pos]
1322 + data.words_progress_restored[salt_pos];
1323
1324 const u64 left = data.words_cnt - all;
1325
1326 progress_noneed += left;
1327 }
1328 }
1329
1330 u64 progress_cur = all_restored + all_done + all_rejected;
1331 u64 progress_end = progress_total;
1332
1333 u64 progress_skip = 0;
1334
1335 if (data.skip)
1336 {
1337 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1338
1339 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1341 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1342 }
1343
1344 if (data.limit)
1345 {
1346 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1347
1348 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1349 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1350 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1351 }
1352
1353 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1354 u64 progress_end_relative_skip = progress_end - progress_skip;
1355
1356 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1357 {
1358 if (data.devices_status != STATUS_CRACKED)
1359 {
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (hashes_all_ms)
1367 {
1368 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1369
1370 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1371
1372 sec_etc = ms_left / 1000;
1373 }
1374
1375 if (sec_etc == 0)
1376 {
1377 //log_info ("Time.Estimated.: 0 secs");
1378 }
1379 else if ((u64) sec_etc > ETC_MAX)
1380 {
1381 log_info ("Time.Estimated.: > 10 Years");
1382 }
1383 else
1384 {
1385 char display_etc[32] = { 0 };
1386
1387 struct tm tm_etc;
1388
1389 struct tm *tmp = NULL;
1390
1391 #ifdef WIN
1392
1393 tmp = _gmtime64 (&sec_etc);
1394
1395 #else
1396
1397 tmp = gmtime (&sec_etc);
1398
1399 #endif
1400
1401 if (tmp != NULL)
1402 {
1403 memset (&tm_etc, 0, sizeof (tm_etc));
1404
1405 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1406
1407 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1408
1409 time_t now;
1410
1411 time (&now);
1412
1413 now += sec_etc;
1414
1415 char *etc = ctime (&now);
1416
1417 size_t etc_len = strlen (etc);
1418
1419 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1420 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1421
1422 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1423 }
1424 }
1425 }
1426 }
1427
1428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1429 {
1430 hc_device_param_t *device_param = &data.devices_param[device_id];
1431
1432 if (device_param->skipped) continue;
1433
1434 char display_dev_cur[16] = { 0 };
1435
1436 strncpy (display_dev_cur, "0.00", 4);
1437
1438 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1439
1440 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1441 }
1442
1443 char display_all_cur[16] = { 0 };
1444
1445 strncpy (display_all_cur, "0.00", 4);
1446
1447 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1448
1449 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1450
1451 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1452 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1453
1454 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);
1455
1456 // crack-per-time
1457
1458 if (data.digests_cnt > 100)
1459 {
1460 time_t now = time (NULL);
1461
1462 int cpt_cur_min = 0;
1463 int cpt_cur_hour = 0;
1464 int cpt_cur_day = 0;
1465
1466 for (int i = 0; i < CPT_BUF; i++)
1467 {
1468 const uint cracked = data.cpt_buf[i].cracked;
1469 const time_t timestamp = data.cpt_buf[i].timestamp;
1470
1471 if ((timestamp + 60) > now)
1472 {
1473 cpt_cur_min += cracked;
1474 }
1475
1476 if ((timestamp + 3600) > now)
1477 {
1478 cpt_cur_hour += cracked;
1479 }
1480
1481 if ((timestamp + 86400) > now)
1482 {
1483 cpt_cur_day += cracked;
1484 }
1485 }
1486
1487 float ms_real = ms_running - ms_paused;
1488
1489 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1490 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1491 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1492
1493 if ((data.cpt_start + 86400) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_cur_day,
1499 cpt_avg_min,
1500 cpt_avg_hour,
1501 cpt_avg_day);
1502 }
1503 else if ((data.cpt_start + 3600) < now)
1504 {
1505 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1506 cpt_cur_min,
1507 cpt_cur_hour,
1508 cpt_avg_min,
1509 cpt_avg_hour,
1510 cpt_avg_day);
1511 }
1512 else if ((data.cpt_start + 60) < now)
1513 {
1514 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515 cpt_cur_min,
1516 cpt_avg_min,
1517 cpt_avg_hour,
1518 cpt_avg_day);
1519 }
1520 else
1521 {
1522 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1523 cpt_avg_min,
1524 cpt_avg_hour,
1525 cpt_avg_day);
1526 }
1527 }
1528
1529 // Restore point
1530
1531 u64 restore_point = get_lowest_words_done ();
1532
1533 u64 restore_total = data.words_base;
1534
1535 float percent_restore = 0;
1536
1537 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1538
1539 if (progress_end_relative_skip)
1540 {
1541 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1542 {
1543 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1544 float percent_rejected = 0.0;
1545
1546 if (progress_cur)
1547 {
1548 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1549 }
1550
1551 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);
1552 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1553
1554 if (data.restore_disable == 0)
1555 {
1556 if (percent_finished != 1)
1557 {
1558 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1559 }
1560 }
1561 }
1562 }
1563 else
1564 {
1565 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1566 {
1567 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1568 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1569
1570 if (data.restore_disable == 0)
1571 {
1572 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1573 }
1574 }
1575 else
1576 {
1577 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1578 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1579
1580 // --restore not allowed if stdin is used -- really? why?
1581
1582 //if (data.restore_disable == 0)
1583 //{
1584 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1585 //}
1586 }
1587 }
1588
1589 #ifdef HAVE_HWMON
1590 if (data.gpu_temp_disable == 0)
1591 {
1592 hc_thread_mutex_lock (mux_adl);
1593
1594 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1595 {
1596 hc_device_param_t *device_param = &data.devices_param[device_id];
1597
1598 if (device_param->skipped) continue;
1599
1600 #define HM_STR_BUF_SIZE 255
1601
1602 if (data.hm_device[device_id].fan_supported == 1)
1603 {
1604 char utilization[HM_STR_BUF_SIZE] = { 0 };
1605 char temperature[HM_STR_BUF_SIZE] = { 0 };
1606 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1607
1608 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1609 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1610
1611 if (device_param->vendor_id == VENDOR_ID_AMD)
1612 {
1613 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1614 }
1615 else if (device_param->vendor_id == VENDOR_ID_NV)
1616 {
1617 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1618 }
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1621 }
1622 else
1623 {
1624 char utilization[HM_STR_BUF_SIZE] = { 0 };
1625 char temperature[HM_STR_BUF_SIZE] = { 0 };
1626
1627 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1628 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1629
1630 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1631 }
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636 #endif // HAVE_HWMON
1637 }
1638
1639 static void status_benchmark ()
1640 {
1641 if (data.devices_status == STATUS_INIT) return;
1642 if (data.devices_status == STATUS_STARTING) return;
1643
1644 if (data.words_cnt == 0) return;
1645
1646 u64 speed_cnt[DEVICES_MAX] = { 0 };
1647 float speed_ms[DEVICES_MAX] = { 0 };
1648
1649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1650 {
1651 hc_device_param_t *device_param = &data.devices_param[device_id];
1652
1653 if (device_param->skipped) continue;
1654
1655 speed_cnt[device_id] = 0;
1656 speed_ms[device_id] = 0;
1657
1658 for (int i = 0; i < SPEED_CACHE; i++)
1659 {
1660 speed_cnt[device_id] += device_param->speed_cnt[i];
1661 speed_ms[device_id] += device_param->speed_ms[i];
1662 }
1663
1664 speed_cnt[device_id] /= SPEED_CACHE;
1665 speed_ms[device_id] /= SPEED_CACHE;
1666 }
1667
1668 float hashes_all_ms = 0;
1669
1670 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * oclHashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 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)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 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)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 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);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 ascii_digest (out_buf, salt_pos, digest_pos);
1881
1882 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1883
1884 // plain
1885
1886 plain_t plain;
1887
1888 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);
1889
1890 uint gidvid = plain.gidvid;
1891 uint il_pos = plain.il_pos;
1892
1893 u64 crackpos = device_param->words_off;
1894
1895 uint plain_buf[16] = { 0 };
1896
1897 u8 *plain_ptr = (u8 *) plain_buf;
1898 unsigned int plain_len = 0;
1899
1900 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1901 {
1902 u64 gidd = gidvid;
1903 u64 gidm = 0;
1904
1905 pw_t pw;
1906
1907 gidd_to_pw_t (device_param, gidd, &pw);
1908
1909 for (int i = 0, j = gidm; i < 16; i++, j++)
1910 {
1911 plain_buf[i] = pw.i[j];
1912 }
1913
1914 plain_len = pw.pw_len;
1915
1916 const uint off = device_param->innerloop_pos + il_pos;
1917
1918 if (debug_mode > 0)
1919 {
1920 debug_rule_len = 0;
1921
1922 // save rule
1923 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1924 {
1925 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1926
1927 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1928 }
1929
1930 // save plain
1931 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1932 {
1933 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1934
1935 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1936
1937 debug_plain_len = plain_len;
1938 }
1939 }
1940
1941 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1942
1943 crackpos += gidvid;
1944 crackpos *= data.kernel_rules_cnt;
1945 crackpos += device_param->innerloop_pos + il_pos;
1946
1947 if (plain_len > data.pw_max) plain_len = data.pw_max;
1948 }
1949 else if (data.attack_mode == ATTACK_MODE_COMBI)
1950 {
1951 u64 gidd = gidvid;
1952 u64 gidm = 0;
1953
1954 pw_t pw;
1955
1956 gidd_to_pw_t (device_param, gidd, &pw);
1957
1958 for (int i = 0, j = gidm; i < 16; i++, j++)
1959 {
1960 plain_buf[i] = pw.i[j];
1961 }
1962
1963 plain_len = pw.pw_len;
1964
1965 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1966 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1967
1968 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1969 {
1970 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1971 }
1972 else
1973 {
1974 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1975
1976 memcpy (plain_ptr, comb_buf, comb_len);
1977 }
1978
1979 plain_len += comb_len;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.combs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984
1985 if (data.pw_max != PW_DICTMAX1)
1986 {
1987 if (plain_len > data.pw_max) plain_len = data.pw_max;
1988 }
1989 }
1990 else if (data.attack_mode == ATTACK_MODE_BF)
1991 {
1992 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1993 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1994
1995 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1996 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1997
1998 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1999 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2000
2001 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2002 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2003
2004 plain_len = data.css_cnt;
2005
2006 crackpos += gidvid;
2007 crackpos *= data.bfs_cnt;
2008 crackpos += device_param->innerloop_pos + il_pos;
2009 }
2010 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2011 {
2012 u64 gidd = gidvid;
2013 u64 gidm = 0;
2014
2015 pw_t pw;
2016
2017 gidd_to_pw_t (device_param, gidd, &pw);
2018
2019 for (int i = 0, j = gidm; i < 16; i++, j++)
2020 {
2021 plain_buf[i] = pw.i[j];
2022 }
2023
2024 plain_len = pw.pw_len;
2025
2026 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2027
2028 uint start = 0;
2029 uint stop = device_param->kernel_params_mp_buf32[4];
2030
2031 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2032
2033 plain_len += start + stop;
2034
2035 crackpos += gidvid;
2036 crackpos *= data.combs_cnt;
2037 crackpos += device_param->innerloop_pos + il_pos;
2038
2039 if (data.pw_max != PW_DICTMAX1)
2040 {
2041 if (plain_len > data.pw_max) plain_len = data.pw_max;
2042 }
2043 }
2044 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2045 {
2046 u64 gidd = gidvid;
2047 u64 gidm = 0;
2048
2049 pw_t pw;
2050
2051 gidd_to_pw_t (device_param, gidd, &pw);
2052
2053 for (int i = 0, j = gidm; i < 16; i++, j++)
2054 {
2055 plain_buf[i] = pw.i[j];
2056 }
2057
2058 plain_len = pw.pw_len;
2059
2060 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2061
2062 uint start = 0;
2063 uint stop = device_param->kernel_params_mp_buf32[4];
2064
2065 memmove (plain_ptr + stop, plain_ptr, plain_len);
2066
2067 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2068
2069 plain_len += start + stop;
2070
2071 crackpos += gidvid;
2072 crackpos *= data.combs_cnt;
2073 crackpos += device_param->innerloop_pos + il_pos;
2074
2075 if (data.pw_max != PW_DICTMAX1)
2076 {
2077 if (plain_len > data.pw_max) plain_len = data.pw_max;
2078 }
2079 }
2080
2081 if (data.attack_mode == ATTACK_MODE_BF)
2082 {
2083 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2084 {
2085 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2086 {
2087 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2088 {
2089 plain_len = plain_len - data.salts_buf[0].salt_len;
2090 }
2091 }
2092
2093 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2094 {
2095 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2096 {
2097 plain_ptr[j] = plain_ptr[i];
2098 }
2099
2100 plain_len = plain_len / 2;
2101 }
2102 }
2103 }
2104
2105 // if enabled, update also the potfile
2106
2107 if (pot_fp)
2108 {
2109 lock_file (pot_fp);
2110
2111 fprintf (pot_fp, "%s:", out_buf);
2112
2113 format_plain (pot_fp, plain_ptr, plain_len, 1);
2114
2115 fputc ('\n', pot_fp);
2116
2117 fflush (pot_fp);
2118
2119 unlock_file (pot_fp);
2120 }
2121
2122 // outfile
2123
2124 FILE *out_fp = NULL;
2125
2126 if (outfile != NULL)
2127 {
2128 if ((out_fp = fopen (outfile, "ab")) == NULL)
2129 {
2130 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2131
2132 out_fp = stdout;
2133 }
2134 lock_file (out_fp);
2135 }
2136 else
2137 {
2138 out_fp = stdout;
2139
2140 if (quiet == 0) clear_prompt ();
2141 }
2142
2143 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2144
2145 if (outfile != NULL)
2146 {
2147 if (out_fp != stdout)
2148 {
2149 fclose (out_fp);
2150 }
2151 }
2152 else
2153 {
2154 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2155 {
2156 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2157 {
2158 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2159 if (quiet == 0) fflush (stdout);
2160 }
2161 }
2162 }
2163
2164 // loopback
2165
2166 if (loopback)
2167 {
2168 char *loopback_file = data.loopback_file;
2169
2170 FILE *fb_fp = NULL;
2171
2172 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2173 {
2174 lock_file (fb_fp);
2175
2176 format_plain (fb_fp, plain_ptr, plain_len, 1);
2177
2178 fputc ('\n', fb_fp);
2179
2180 fclose (fb_fp);
2181 }
2182 }
2183
2184 // (rule) debug mode
2185
2186 // the next check implies that:
2187 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2188 // - debug_mode > 0
2189
2190 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2191 {
2192 if (debug_rule_len < 0) debug_rule_len = 0;
2193
2194 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2195
2196 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2197
2198 if ((quiet == 0) && (debug_file == NULL))
2199 {
2200 fprintf (stdout, "%s", PROMPT);
2201 fflush (stdout);
2202 }
2203 }
2204 }
2205
2206 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2207 {
2208 salt_t *salt_buf = &data.salts_buf[salt_pos];
2209
2210 int found = 0;
2211
2212 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);
2213
2214 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2215
2216 if (found == 1)
2217 {
2218 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2219
2220 log_info_nn ("");
2221
2222 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);
2223
2224 uint cpt_cracked = 0;
2225
2226 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2227 {
2228 uint idx = salt_buf->digests_offset + digest_pos;
2229
2230 if (data.digests_shown_tmp[idx] == 0) continue;
2231
2232 if (data.digests_shown[idx] == 1) continue;
2233
2234 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2235 {
2236 data.digests_shown[idx] = 1;
2237
2238 data.digests_done++;
2239
2240 cpt_cracked++;
2241
2242 salt_buf->digests_done++;
2243
2244 if (salt_buf->digests_done == salt_buf->digests_cnt)
2245 {
2246 data.salts_shown[salt_pos] = 1;
2247
2248 data.salts_done++;
2249 }
2250 }
2251
2252 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2253
2254 check_hash (device_param, salt_pos, digest_pos);
2255 }
2256
2257 if (cpt_cracked > 0)
2258 {
2259 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2260 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2261
2262 data.cpt_pos++;
2263
2264 data.cpt_total += cpt_cracked;
2265
2266 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2267 }
2268
2269 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2270 {
2271 // we need to reset cracked state on the device
2272 // otherwise host thinks again and again the hash was cracked
2273 // and returns invalid password each time
2274
2275 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2276
2277 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);
2278 }
2279
2280 memset (device_param->result, 0, device_param->size_results);
2281
2282 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);
2283 }
2284 }
2285
2286 static void save_hash ()
2287 {
2288 char *hashfile = data.hashfile;
2289
2290 char new_hashfile[256] = { 0 };
2291 char old_hashfile[256] = { 0 };
2292
2293 snprintf (new_hashfile, 255, "%s.new", hashfile);
2294 snprintf (old_hashfile, 255, "%s.old", hashfile);
2295
2296 unlink (new_hashfile);
2297
2298 char separator = data.separator;
2299
2300 FILE *fp = fopen (new_hashfile, "wb");
2301
2302 if (fp == NULL)
2303 {
2304 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2305
2306 exit (-1);
2307 }
2308
2309 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2310 {
2311 if (data.salts_shown[salt_pos] == 1) continue;
2312
2313 salt_t *salt_buf = &data.salts_buf[salt_pos];
2314
2315 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2316 {
2317 uint idx = salt_buf->digests_offset + digest_pos;
2318
2319 if (data.digests_shown[idx] == 1) continue;
2320
2321 if (data.hash_mode != 2500)
2322 {
2323 char out_buf[HCBUFSIZ] = { 0 };
2324
2325 if (data.username == 1)
2326 {
2327 user_t *user = data.hash_info[idx]->user;
2328
2329 uint i;
2330
2331 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2332
2333 fputc (separator, fp);
2334 }
2335
2336 ascii_digest (out_buf, salt_pos, digest_pos);
2337
2338 fputs (out_buf, fp);
2339
2340 log_out (fp, "");
2341 }
2342 else
2343 {
2344 hccap_t hccap;
2345
2346 to_hccap_t (&hccap, salt_pos, digest_pos);
2347
2348 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2349 }
2350 }
2351 }
2352
2353 fflush (fp);
2354
2355 fclose (fp);
2356
2357 unlink (old_hashfile);
2358
2359 if (rename (hashfile, old_hashfile) != 0)
2360 {
2361 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2362
2363 exit (-1);
2364 }
2365
2366 unlink (hashfile);
2367
2368 if (rename (new_hashfile, hashfile) != 0)
2369 {
2370 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2371
2372 exit (-1);
2373 }
2374
2375 unlink (old_hashfile);
2376 }
2377
2378 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2379 {
2380 // function called only in case kernel_power_all > words_left
2381
2382 float kernel_power_div = (float) (total_left) / kernel_power_all;
2383
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387
2388 while (kernel_power_new < total_left)
2389 {
2390 kernel_power_div += kernel_power_div / 100;
2391
2392 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2393 }
2394
2395 if (data.quiet == 0)
2396 {
2397 clear_prompt ();
2398
2399 log_info ("");
2400
2401 log_info ("INFO: approaching final keyspace, workload adjusted");
2402
2403 log_info ("");
2404
2405 fprintf (stdout, "%s", PROMPT);
2406
2407 fflush (stdout);
2408 }
2409
2410 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2411
2412 return kernel_power_div;
2413 }
2414
2415 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2416 {
2417 uint num_elements = num;
2418
2419 device_param->kernel_params_buf32[30] = data.combs_mode;
2420 device_param->kernel_params_buf32[31] = num;
2421
2422 uint kernel_threads = device_param->kernel_threads;
2423
2424 while (num_elements % kernel_threads) num_elements++;
2425
2426 cl_kernel kernel = NULL;
2427
2428 switch (kern_run)
2429 {
2430 case KERN_RUN_1: kernel = device_param->kernel1; break;
2431 case KERN_RUN_12: kernel = device_param->kernel12; break;
2432 case KERN_RUN_2: kernel = device_param->kernel2; break;
2433 case KERN_RUN_23: kernel = device_param->kernel23; break;
2434 case KERN_RUN_3: kernel = device_param->kernel3; break;
2435 }
2436
2437 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2438 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2439 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2440 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2441 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2442 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2443 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2444 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2445 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2446 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2447 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2448
2449 hc_timer_t timer;
2450
2451 hc_timer_set (&timer);
2452
2453 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2454 {
2455 const size_t global_work_size[3] = { num_elements, 32, 1 };
2456 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2459 }
2460 else
2461 {
2462 size_t workgroup_size = 0;
2463
2464 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2465
2466 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2467
2468 const size_t global_work_size[3] = { num_elements, 1, 1 };
2469 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2470
2471 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2472 }
2473
2474 hc_clFlush (data.ocl, device_param->command_queue);
2475
2476 hc_clFinish (data.ocl, device_param->command_queue);
2477
2478 if (event_update)
2479 {
2480 float exec_time;
2481
2482 hc_timer_get (timer, exec_time);
2483
2484 uint exec_pos = device_param->exec_pos;
2485
2486 device_param->exec_ms[exec_pos] = exec_time;
2487
2488 exec_pos++;
2489
2490 if (exec_pos == EXEC_CACHE)
2491 {
2492 exec_pos = 0;
2493 }
2494
2495 device_param->exec_pos = exec_pos;
2496 }
2497 }
2498
2499 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2500 {
2501 uint num_elements = num;
2502
2503 switch (kern_run)
2504 {
2505 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2506 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2507 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2508 }
2509
2510 // causes problems with special threads like in bcrypt
2511 // const uint kernel_threads = device_param->kernel_threads;
2512
2513 uint kernel_threads = KERNEL_THREADS;
2514
2515 while (num_elements % kernel_threads) num_elements++;
2516
2517 cl_kernel kernel = NULL;
2518
2519 switch (kern_run)
2520 {
2521 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2522 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2523 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2524 }
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2529 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2530 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2531 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2532 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2533 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2534 break;
2535 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2536 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2537 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2538 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2539 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2540 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2541 break;
2542 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2543 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2544 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2545 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2546 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2547 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2548 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2549 break;
2550 }
2551
2552 size_t workgroup_size = 0;
2553 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2554 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2555
2556 const size_t global_work_size[3] = { num_elements, 1, 1 };
2557 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2558
2559 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2560
2561 hc_clFlush (data.ocl, device_param->command_queue);
2562
2563 hc_clFinish (data.ocl, device_param->command_queue);
2564 }
2565
2566 static void run_kernel_tm (hc_device_param_t *device_param)
2567 {
2568 const uint num_elements = 1024; // fixed
2569
2570 uint kernel_threads = 32;
2571
2572 cl_kernel kernel = device_param->kernel_tm;
2573
2574 size_t workgroup_size = 0;
2575 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2576 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2589 {
2590 uint num_elements = num;
2591
2592 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2593 device_param->kernel_params_amp_buf32[6] = num_elements;
2594
2595 // causes problems with special threads like in bcrypt
2596 // const uint kernel_threads = device_param->kernel_threads;
2597
2598 uint kernel_threads = KERNEL_THREADS;
2599
2600 while (num_elements % kernel_threads) num_elements++;
2601
2602 cl_kernel kernel = device_param->kernel_amp;
2603
2604 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2605 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2606
2607 size_t workgroup_size = 0;
2608 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2609 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2610
2611 const size_t global_work_size[3] = { num_elements, 1, 1 };
2612 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2613
2614 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2615
2616 hc_clFlush (data.ocl, device_param->command_queue);
2617
2618 hc_clFinish (data.ocl, device_param->command_queue);
2619 }
2620
2621 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2622 {
2623 int rc = -1;
2624
2625 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2626 {
2627 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2628
2629 const cl_uchar zero = 0;
2630
2631 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2632 }
2633
2634 if (rc != 0)
2635 {
2636 // NOTE: clEnqueueFillBuffer () always fails with -59
2637 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2638 // How's that possible, OpenCL 1.2 support is advertised??
2639 // We need to workaround...
2640
2641 #define FILLSZ 0x100000
2642
2643 char *tmp = (char *) mymalloc (FILLSZ);
2644
2645 for (uint i = 0; i < size; i += FILLSZ)
2646 {
2647 const int left = size - i;
2648
2649 const int fillsz = MIN (FILLSZ, left);
2650
2651 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2652 }
2653
2654 myfree (tmp);
2655 }
2656 }
2657
2658 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)
2659 {
2660 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2661 {
2662 if (attack_mode == ATTACK_MODE_BF)
2663 {
2664 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2665 {
2666 const uint size_tm = 32 * sizeof (bs_word_t);
2667
2668 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2669
2670 run_kernel_tm (device_param);
2671
2672 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);
2673 }
2674 }
2675
2676 if (highest_pw_len < 16)
2677 {
2678 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2679 }
2680 else if (highest_pw_len < 32)
2681 {
2682 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2683 }
2684 else
2685 {
2686 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2687 }
2688 }
2689 else
2690 {
2691 run_kernel_amp (device_param, pws_cnt);
2692
2693 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2694
2695 if (opts_type & OPTS_TYPE_HOOK12)
2696 {
2697 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2698 }
2699
2700 uint iter = salt_buf->salt_iter;
2701
2702 uint loop_step = device_param->kernel_loops;
2703
2704 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2705 {
2706 uint loop_left = iter - loop_pos;
2707
2708 loop_left = MIN (loop_left, loop_step);
2709
2710 device_param->kernel_params_buf32[25] = loop_pos;
2711 device_param->kernel_params_buf32[26] = loop_left;
2712
2713 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2714
2715 if (data.devices_status == STATUS_CRACKED) break;
2716 if (data.devices_status == STATUS_ABORTED) break;
2717 if (data.devices_status == STATUS_QUIT) break;
2718 }
2719
2720 if (opts_type & OPTS_TYPE_HOOK23)
2721 {
2722 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2723
2724 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2725
2726 // do something with data
2727
2728 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2729 }
2730
2731 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2732 }
2733 }
2734
2735 static int run_rule_engine (const int rule_len, const char *rule_buf)
2736 {
2737 if (rule_len == 0)
2738 {
2739 return 0;
2740 }
2741 else if (rule_len == 1)
2742 {
2743 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2744 }
2745
2746 return 1;
2747 }
2748
2749 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2750 {
2751 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2752 {
2753 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2754 }
2755 else if (data.attack_kern == ATTACK_KERN_COMBI)
2756 {
2757 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2758 {
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x01;
2768 }
2769 }
2770 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2771 {
2772 for (u32 i = 0; i < pws_cnt; i++)
2773 {
2774 const u32 pw_len = device_param->pws_buf[i].pw_len;
2775
2776 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2777
2778 ptr[pw_len] = 0x80;
2779 }
2780 }
2781 }
2782
2783 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2784 }
2785 else if (data.attack_kern == ATTACK_KERN_BF)
2786 {
2787 const u64 off = device_param->words_off;
2788
2789 device_param->kernel_params_mp_l_buf64[3] = off;
2790
2791 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2792 }
2793 }
2794
2795 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2796 {
2797 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2798
2799 device_param->kernel_params_buf32[26] = kernel_loops;
2800 device_param->kernel_params_buf32[27] = kernel_loops;
2801
2802 // init some fake words
2803
2804 for (u32 i = 0; i < kernel_power; i++)
2805 {
2806 device_param->pws_buf[i].i[0] = i;
2807 device_param->pws_buf[i].i[1] = 0x01234567;
2808 device_param->pws_buf[i].pw_len = 4 + (i & 3);
2809 }
2810
2811 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);
2812
2813 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2814 {
2815 run_kernel_amp (device_param, kernel_power);
2816 }
2817
2818 // caching run
2819
2820 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2821 {
2822 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2823 }
2824 else
2825 {
2826 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2827 }
2828
2829 // now user repeats
2830
2831 for (int i = 0; i < repeat; i++)
2832 {
2833 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2834 {
2835 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2836 }
2837 else
2838 {
2839 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2840 }
2841 }
2842
2843 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2844
2845 // reset fake words
2846
2847 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2848
2849 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);
2850 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);
2851
2852 return exec_ms_prev;
2853 }
2854
2855 static void autotune (hc_device_param_t *device_param)
2856 {
2857 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2858
2859 const u32 kernel_accel_min = device_param->kernel_accel_min;
2860 const u32 kernel_accel_max = device_param->kernel_accel_max;
2861
2862 const u32 kernel_loops_min = device_param->kernel_loops_min;
2863 const u32 kernel_loops_max = device_param->kernel_loops_max;
2864
2865 u32 kernel_accel = kernel_accel_min;
2866 u32 kernel_loops = kernel_loops_min;
2867
2868 // steps
2869
2870 #define STEPS_CNT 10
2871
2872 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2873 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2874
2875 u32 steps_accel[STEPS_ACCEL_CNT];
2876 u32 steps_loops[STEPS_LOOPS_CNT];
2877
2878 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2879 {
2880 steps_accel[i] = 1 << i;
2881 }
2882
2883 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2884 {
2885 steps_loops[i] = 1 << i;
2886 }
2887
2888 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2889 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2890
2891 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2892 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2893
2894 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2895 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2896
2897 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2898
2899 u32 kernel_loops_tmp;
2900
2901 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp > kernel_loops_min; kernel_loops_tmp >>= 1)
2902 {
2903 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2904
2905 if (exec_ms < target_ms) break;
2906 }
2907
2908 // kernel-accel
2909
2910 if (kernel_accel_min < kernel_accel_max)
2911 {
2912 double e_best = 0;
2913
2914 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2915 {
2916 const u32 kernel_accel_try = steps_accel[i];
2917
2918 if (kernel_accel_try < kernel_accel_min) continue;
2919 if (kernel_accel_try > kernel_accel_max) break;
2920
2921 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2922
2923 if (exec_ms > target_ms) break;
2924
2925 const double e = kernel_accel_try / exec_ms;
2926
2927 if (e > e_best)
2928 {
2929 kernel_accel = kernel_accel_try;
2930
2931 e_best = e;
2932 }
2933 }
2934 }
2935
2936 // kernel-loops final
2937
2938 if (kernel_loops_min < kernel_loops_max)
2939 {
2940 double e_best = 0;
2941
2942 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2943 {
2944 const u32 kernel_loops_try = steps_loops[i];
2945
2946 if (kernel_loops_try < kernel_loops_min) continue;
2947 if (kernel_loops_try > kernel_loops_max) break;
2948
2949 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2950
2951 if (exec_ms > target_ms) break;
2952
2953 const double e = kernel_loops_try / exec_ms;
2954
2955 if (e > e_best)
2956 {
2957 kernel_loops = kernel_loops_try;
2958
2959 e_best = e;
2960 }
2961 }
2962 }
2963
2964 // final balance
2965
2966 u32 kernel_accel_best = kernel_accel;
2967 u32 kernel_loops_best = kernel_loops;
2968
2969 u32 exec_best = -1;
2970
2971 if ((kernel_accel_min < kernel_accel_max) || (kernel_loops_min < kernel_loops_max))
2972 {
2973 const double exec_ms = try_run (device_param, kernel_accel_best, kernel_loops_best, 1);
2974
2975 exec_best = exec_ms;
2976 }
2977
2978 // reset
2979
2980 if (kernel_accel_min < kernel_accel_max)
2981 {
2982 u32 kernel_accel_try = kernel_accel;
2983 u32 kernel_loops_try = kernel_loops;
2984
2985 for (int i = 0; i < 2; i++)
2986 {
2987 kernel_accel_try >>= 1;
2988 kernel_loops_try <<= 1;
2989
2990 if (kernel_accel_try < kernel_accel_min) break;
2991 if (kernel_loops_try > kernel_loops_max) break;
2992
2993 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2994
2995 if (exec_ms < exec_best)
2996 {
2997 kernel_accel_best = kernel_accel_try;
2998 kernel_loops_best = kernel_loops_try;
2999
3000 exec_best = exec_ms;
3001 }
3002 }
3003 }
3004
3005 // reset
3006
3007 if (kernel_loops_min < kernel_loops_max)
3008 {
3009 u32 kernel_accel_try = kernel_accel;
3010 u32 kernel_loops_try = kernel_loops;
3011
3012 for (int i = 0; i < 2; i++)
3013 {
3014 kernel_accel_try <<= 1;
3015 kernel_loops_try >>= 1;
3016
3017 if (kernel_accel_try > kernel_accel_max) break;
3018 if (kernel_loops_try < kernel_loops_min) break;
3019
3020 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3021
3022 if (exec_ms < exec_best)
3023 {
3024 kernel_accel_best = kernel_accel_try;
3025 kernel_loops_best = kernel_loops_try;
3026
3027 exec_best = exec_ms;
3028 }
3029 }
3030 }
3031
3032 // reset timer
3033
3034 device_param->exec_pos = 0;
3035
3036 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3037
3038 // store
3039
3040 kernel_accel = kernel_accel_best;
3041 kernel_loops = kernel_loops_best;
3042
3043 device_param->kernel_accel = kernel_accel;
3044 device_param->kernel_loops = kernel_loops;
3045
3046 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3047
3048 device_param->kernel_power = kernel_power;
3049
3050 #ifdef DEBUG
3051
3052 if (data.quiet == 0)
3053 {
3054 clear_prompt ();
3055
3056 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3057 "Device #%u: autotuned kernel-loops to %u\n",
3058 device_param->device_id + 1,
3059 kernel_accel,
3060 device_param->device_id + 1,
3061 kernel_loops);
3062
3063 fprintf (stdout, "%s", PROMPT);
3064 fflush (stdout);
3065 }
3066
3067 #endif
3068 }
3069
3070 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3071 {
3072 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3073
3074 // init speed timer
3075
3076 uint speed_pos = device_param->speed_pos;
3077
3078 #ifdef _POSIX
3079 if (device_param->timer_speed.tv_sec == 0)
3080 {
3081 hc_timer_set (&device_param->timer_speed);
3082 }
3083 #endif
3084
3085 #ifdef _WIN
3086 if (device_param->timer_speed.QuadPart == 0)
3087 {
3088 hc_timer_set (&device_param->timer_speed);
3089 }
3090 #endif
3091
3092 // find higest password length, this is for optimization stuff
3093
3094 uint highest_pw_len = 0;
3095
3096 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3097 {
3098 }
3099 else if (data.attack_kern == ATTACK_KERN_COMBI)
3100 {
3101 }
3102 else if (data.attack_kern == ATTACK_KERN_BF)
3103 {
3104 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3105 + device_param->kernel_params_mp_l_buf32[5];
3106 }
3107
3108 // iteration type
3109
3110 uint innerloop_step = 0;
3111 uint innerloop_cnt = 0;
3112
3113 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3114 else innerloop_step = 1;
3115
3116 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3117 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3118 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3119
3120 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3121
3122 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3123 {
3124 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3125
3126 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3127
3128 if (data.devices_status == STATUS_CRACKED) break;
3129 if (data.devices_status == STATUS_ABORTED) break;
3130 if (data.devices_status == STATUS_QUIT) break;
3131 if (data.devices_status == STATUS_BYPASS) break;
3132
3133 salt_t *salt_buf = &data.salts_buf[salt_pos];
3134
3135 device_param->kernel_params_buf32[24] = salt_pos;
3136 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3137 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3138
3139 FILE *combs_fp = device_param->combs_fp;
3140
3141 if (data.attack_mode == ATTACK_MODE_COMBI)
3142 {
3143 rewind (combs_fp);
3144 }
3145
3146 // innerloops
3147
3148 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3149 {
3150 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3151
3152 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3153
3154 if (data.devices_status == STATUS_CRACKED) break;
3155 if (data.devices_status == STATUS_ABORTED) break;
3156 if (data.devices_status == STATUS_QUIT) break;
3157 if (data.devices_status == STATUS_BYPASS) break;
3158
3159 uint innerloop_left = innerloop_cnt - innerloop_pos;
3160
3161 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3162
3163 device_param->innerloop_pos = innerloop_pos;
3164 device_param->innerloop_left = innerloop_left;
3165
3166 device_param->kernel_params_buf32[27] = innerloop_left;
3167
3168 // i think we can get rid of this
3169 if (innerloop_left == 0)
3170 {
3171 puts ("bug, how should this happen????\n");
3172
3173 continue;
3174 }
3175
3176 if (data.salts_shown[salt_pos] == 1)
3177 {
3178 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3179
3180 continue;
3181 }
3182
3183 // initialize amplifiers
3184
3185 if (data.attack_mode == ATTACK_MODE_COMBI)
3186 {
3187 uint i = 0;
3188
3189 while (i < innerloop_left)
3190 {
3191 if (feof (combs_fp)) break;
3192
3193 int line_len = fgetl (combs_fp, line_buf);
3194
3195 if (line_len >= PW_MAX1) continue;
3196
3197 line_len = convert_from_hex (line_buf, line_len);
3198
3199 char *line_buf_new = line_buf;
3200
3201 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3202 {
3203 char rule_buf_out[BLOCK_SIZE] = { 0 };
3204
3205 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3206
3207 if (rule_len_out < 0)
3208 {
3209 data.words_progress_rejected[salt_pos] += pws_cnt;
3210
3211 continue;
3212 }
3213
3214 line_len = rule_len_out;
3215
3216 line_buf_new = rule_buf_out;
3217 }
3218
3219 line_len = MIN (line_len, PW_DICTMAX);
3220
3221 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3222
3223 memcpy (ptr, line_buf_new, line_len);
3224
3225 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3226
3227 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3228 {
3229 uppercase (ptr, line_len);
3230 }
3231
3232 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3233 {
3234 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3235 {
3236 ptr[line_len] = 0x80;
3237 }
3238
3239 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3240 {
3241 ptr[line_len] = 0x01;
3242 }
3243 }
3244
3245 device_param->combs_buf[i].pw_len = line_len;
3246
3247 i++;
3248 }
3249
3250 for (uint j = i; j < innerloop_left; j++)
3251 {
3252 device_param->combs_buf[j].i[0] = 0;
3253 device_param->combs_buf[j].i[1] = 0;
3254 device_param->combs_buf[j].i[2] = 0;
3255 device_param->combs_buf[j].i[3] = 0;
3256 device_param->combs_buf[j].i[4] = 0;
3257 device_param->combs_buf[j].i[5] = 0;
3258 device_param->combs_buf[j].i[6] = 0;
3259 device_param->combs_buf[j].i[7] = 0;
3260
3261 device_param->combs_buf[j].pw_len = 0;
3262 }
3263
3264 innerloop_left = i;
3265 }
3266 else if (data.attack_mode == ATTACK_MODE_BF)
3267 {
3268 u64 off = innerloop_pos;
3269
3270 device_param->kernel_params_mp_r_buf64[3] = off;
3271
3272 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3275 {
3276 u64 off = innerloop_pos;
3277
3278 device_param->kernel_params_mp_buf64[3] = off;
3279
3280 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3283 {
3284 u64 off = innerloop_pos;
3285
3286 device_param->kernel_params_mp_buf64[3] = off;
3287
3288 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3289 }
3290
3291 // copy amplifiers
3292
3293 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3294 {
3295 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);
3296 }
3297 else if (data.attack_mode == ATTACK_MODE_COMBI)
3298 {
3299 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);
3300 }
3301 else if (data.attack_mode == ATTACK_MODE_BF)
3302 {
3303 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);
3304 }
3305 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3306 {
3307 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);
3308 }
3309 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3310 {
3311 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);
3312 }
3313
3314 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3315
3316 if (data.benchmark == 1)
3317 {
3318 for (u32 i = 0; i < data.benchmark_repeats; i++)
3319 {
3320 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3321 }
3322 }
3323
3324 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3325
3326 if (data.devices_status == STATUS_CRACKED) break;
3327 if (data.devices_status == STATUS_ABORTED) break;
3328 if (data.devices_status == STATUS_QUIT) break;
3329
3330 /**
3331 * result
3332 */
3333
3334 hc_thread_mutex_lock (mux_display);
3335
3336 check_cracked (device_param, salt_pos);
3337
3338 hc_thread_mutex_unlock (mux_display);
3339
3340 /**
3341 * progress
3342 */
3343
3344 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3345
3346 if (data.benchmark == 1)
3347 {
3348 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3349 }
3350
3351 hc_thread_mutex_lock (mux_counter);
3352
3353 data.words_progress_done[salt_pos] += perf_sum_all;
3354
3355 hc_thread_mutex_unlock (mux_counter);
3356
3357 /**
3358 * speed
3359 */
3360
3361 float speed_ms;
3362
3363 hc_timer_get (device_param->timer_speed, speed_ms);
3364
3365 hc_timer_set (&device_param->timer_speed);
3366
3367 hc_thread_mutex_lock (mux_display);
3368
3369 device_param->speed_cnt[speed_pos] = perf_sum_all;
3370
3371 device_param->speed_ms[speed_pos] = speed_ms;
3372
3373 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3374
3375 hc_thread_mutex_unlock (mux_display);
3376
3377 speed_pos++;
3378
3379 if (speed_pos == SPEED_CACHE)
3380 {
3381 speed_pos = 0;
3382 }
3383
3384 /**
3385 * benchmark
3386 */
3387
3388 if (data.benchmark == 1) break;
3389 }
3390 }
3391
3392 device_param->speed_pos = speed_pos;
3393
3394 myfree (line_buf);
3395 }
3396
3397 static void load_segment (wl_data_t *wl_data, FILE *fd)
3398 {
3399 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3400
3401 wl_data->pos = 0;
3402
3403 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3404
3405 wl_data->buf[wl_data->cnt] = 0;
3406
3407 if (wl_data->cnt == 0) return;
3408
3409 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3410
3411 while (!feof (fd))
3412 {
3413 if (wl_data->cnt == wl_data->avail)
3414 {
3415 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3416
3417 wl_data->avail += wl_data->incr;
3418 }
3419
3420 const int c = fgetc (fd);
3421
3422 if (c == EOF) break;
3423
3424 wl_data->buf[wl_data->cnt] = (char) c;
3425
3426 wl_data->cnt++;
3427
3428 if (c == '\n') break;
3429 }
3430
3431 // ensure stream ends with a newline
3432
3433 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3434 {
3435 wl_data->cnt++;
3436
3437 wl_data->buf[wl_data->cnt - 1] = '\n';
3438 }
3439
3440 return;
3441 }
3442
3443 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3444 {
3445 char *ptr = buf;
3446
3447 for (u32 i = 0; i < sz; i++, ptr++)
3448 {
3449 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3450
3451 if (i == 7)
3452 {
3453 *off = i;
3454 *len = i;
3455
3456 return;
3457 }
3458
3459 if (*ptr != '\n') continue;
3460
3461 *off = i + 1;
3462
3463 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3464
3465 *len = i;
3466
3467 return;
3468 }
3469
3470 *off = sz;
3471 *len = sz;
3472 }
3473
3474 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3475 {
3476 char *ptr = buf;
3477
3478 for (u32 i = 0; i < sz; i++, ptr++)
3479 {
3480 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3481
3482 if (*ptr != '\n') continue;
3483
3484 *off = i + 1;
3485
3486 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3487
3488 *len = i;
3489
3490 return;
3491 }
3492
3493 *off = sz;
3494 *len = sz;
3495 }
3496
3497 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3498 {
3499 char *ptr = buf;
3500
3501 for (u32 i = 0; i < sz; i++, ptr++)
3502 {
3503 if (*ptr != '\n') continue;
3504
3505 *off = i + 1;
3506
3507 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3508
3509 *len = i;
3510
3511 return;
3512 }
3513
3514 *off = sz;
3515 *len = sz;
3516 }
3517
3518 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3519 {
3520 while (wl_data->pos < wl_data->cnt)
3521 {
3522 uint off;
3523 uint len;
3524
3525 char *ptr = wl_data->buf + wl_data->pos;
3526
3527 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3528
3529 wl_data->pos += off;
3530
3531 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3532 {
3533 char rule_buf_out[BLOCK_SIZE] = { 0 };
3534
3535 int rule_len_out = -1;
3536
3537 if (len < BLOCK_SIZE)
3538 {
3539 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3540 }
3541
3542 if (rule_len_out < 0)
3543 {
3544 continue;
3545 }
3546
3547 if (rule_len_out > PW_MAX)
3548 {
3549 continue;
3550 }
3551 }
3552 else
3553 {
3554 if (len > PW_MAX)
3555 {
3556 continue;
3557 }
3558 }
3559
3560 *out_buf = ptr;
3561 *out_len = len;
3562
3563 return;
3564 }
3565
3566 if (feof (fd))
3567 {
3568 fprintf (stderr, "BUG feof()!!\n");
3569
3570 return;
3571 }
3572
3573 load_segment (wl_data, fd);
3574
3575 get_next_word (wl_data, fd, out_buf, out_len);
3576 }
3577
3578 #ifdef _POSIX
3579 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3580 #endif
3581
3582 #ifdef _WIN
3583 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3584 #endif
3585 {
3586 hc_signal (NULL);
3587
3588 dictstat_t d;
3589
3590 d.cnt = 0;
3591
3592 #ifdef _POSIX
3593 fstat (fileno (fd), &d.stat);
3594 #endif
3595
3596 #ifdef _WIN
3597 _fstat64 (fileno (fd), &d.stat);
3598 #endif
3599
3600 d.stat.st_mode = 0;
3601 d.stat.st_nlink = 0;
3602 d.stat.st_uid = 0;
3603 d.stat.st_gid = 0;
3604 d.stat.st_rdev = 0;
3605 d.stat.st_atime = 0;
3606
3607 #ifdef _POSIX
3608 d.stat.st_blksize = 0;
3609 d.stat.st_blocks = 0;
3610 #endif
3611
3612 if (d.stat.st_size == 0) return 0;
3613
3614 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3615
3616 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3617 {
3618 if (d_cache)
3619 {
3620 u64 cnt = d_cache->cnt;
3621
3622 u64 keyspace = cnt;
3623
3624 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3625 {
3626 keyspace *= data.kernel_rules_cnt;
3627 }
3628 else if (data.attack_kern == ATTACK_KERN_COMBI)
3629 {
3630 keyspace *= data.combs_cnt;
3631 }
3632
3633 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);
3634 if (data.quiet == 0) log_info ("");
3635
3636 hc_signal (sigHandler_default);
3637
3638 return (keyspace);
3639 }
3640 }
3641
3642 time_t now = 0;
3643 time_t prev = 0;
3644
3645 u64 comp = 0;
3646 u64 cnt = 0;
3647 u64 cnt2 = 0;
3648
3649 while (!feof (fd))
3650 {
3651 load_segment (wl_data, fd);
3652
3653 comp += wl_data->cnt;
3654
3655 u32 i = 0;
3656
3657 while (i < wl_data->cnt)
3658 {
3659 u32 len;
3660 u32 off;
3661
3662 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3663
3664 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3665 {
3666 char rule_buf_out[BLOCK_SIZE] = { 0 };
3667
3668 int rule_len_out = -1;
3669
3670 if (len < BLOCK_SIZE)
3671 {
3672 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3673 }
3674
3675 if (rule_len_out < 0)
3676 {
3677 len = PW_MAX1;
3678 }
3679 else
3680 {
3681 len = rule_len_out;
3682 }
3683 }
3684
3685 if (len < PW_MAX1)
3686 {
3687 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3688 {
3689 cnt += data.kernel_rules_cnt;
3690 }
3691 else if (data.attack_kern == ATTACK_KERN_COMBI)
3692 {
3693 cnt += data.combs_cnt;
3694 }
3695
3696 d.cnt++;
3697 }
3698
3699 i += off;
3700
3701 cnt2++;
3702 }
3703
3704 time (&now);
3705
3706 if ((now - prev) == 0) continue;
3707
3708 float percent = (float) comp / (float) d.stat.st_size;
3709
3710 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);
3711
3712 time (&prev);
3713 }
3714
3715 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);
3716 if (data.quiet == 0) log_info ("");
3717
3718 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3719
3720 hc_signal (sigHandler_default);
3721
3722 return (cnt);
3723 }
3724
3725 static void *thread_monitor (void *p)
3726 {
3727 uint runtime_check = 0;
3728 uint remove_check = 0;
3729 uint status_check = 0;
3730 uint restore_check = 0;
3731
3732 uint restore_left = data.restore_timer;
3733 uint remove_left = data.remove_timer;
3734 uint status_left = data.status_timer;
3735
3736 #ifdef HAVE_HWMON
3737 uint hwmon_check = 0;
3738
3739 // these variables are mainly used for fan control (AMD only)
3740
3741 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3742
3743 // temperature controller "loopback" values
3744
3745 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3746 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3747
3748 #ifdef HAVE_ADL
3749 int temp_threshold = 1; // degrees celcius
3750
3751 int fan_speed_min = 15; // in percentage
3752 int fan_speed_max = 100;
3753 #endif // HAVE_ADL
3754
3755 time_t last_temp_check_time;
3756 #endif // HAVE_HWMON
3757
3758 uint sleep_time = 1;
3759
3760 if (data.runtime)
3761 {
3762 runtime_check = 1;
3763 }
3764
3765 if (data.restore_timer)
3766 {
3767 restore_check = 1;
3768 }
3769
3770 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3771 {
3772 remove_check = 1;
3773 }
3774
3775 if (data.status == 1)
3776 {
3777 status_check = 1;
3778 }
3779
3780 #ifdef HAVE_HWMON
3781 if (data.gpu_temp_disable == 0)
3782 {
3783 time (&last_temp_check_time);
3784
3785 hwmon_check = 1;
3786 }
3787 #endif
3788
3789 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3790 {
3791 #ifdef HAVE_HWMON
3792 if (hwmon_check == 0)
3793 #endif
3794 return (p);
3795 }
3796
3797 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3798 {
3799 hc_sleep (sleep_time);
3800
3801 if (data.devices_status != STATUS_RUNNING) continue;
3802
3803 #ifdef HAVE_HWMON
3804 if (hwmon_check == 1)
3805 {
3806 hc_thread_mutex_lock (mux_adl);
3807
3808 time_t temp_check_time;
3809
3810 time (&temp_check_time);
3811
3812 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3813
3814 if (Ta == 0) Ta = 1;
3815
3816 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3817 {
3818 hc_device_param_t *device_param = &data.devices_param[device_id];
3819
3820 if (device_param->skipped) continue;
3821
3822 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3823
3824 const int temperature = hm_get_temperature_with_device_id (device_id);
3825
3826 if (temperature > (int) data.gpu_temp_abort)
3827 {
3828 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3829
3830 if (data.devices_status != STATUS_QUIT) myabort ();
3831
3832 break;
3833 }
3834
3835 #ifdef HAVE_ADL
3836 const int gpu_temp_retain = data.gpu_temp_retain;
3837
3838 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3839 {
3840 if (data.hm_device[device_id].fan_supported == 1)
3841 {
3842 int temp_cur = temperature;
3843
3844 int temp_diff_new = gpu_temp_retain - temp_cur;
3845
3846 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3847
3848 // calculate Ta value (time difference in seconds between the last check and this check)
3849
3850 last_temp_check_time = temp_check_time;
3851
3852 float Kp = 1.8;
3853 float Ki = 0.005;
3854 float Kd = 6;
3855
3856 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3857
3858 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);
3859
3860 if (abs (fan_diff_required) >= temp_threshold)
3861 {
3862 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3863
3864 int fan_speed_level = fan_speed_cur;
3865
3866 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3867
3868 int fan_speed_new = fan_speed_level - fan_diff_required;
3869
3870 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3871 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3872
3873 if (fan_speed_new != fan_speed_cur)
3874 {
3875 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3876 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3877
3878 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3879 {
3880 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3881
3882 fan_speed_chgd[device_id] = 1;
3883 }
3884
3885 temp_diff_old[device_id] = temp_diff_new;
3886 }
3887 }
3888 }
3889 }
3890 #endif // HAVE_ADL
3891 }
3892
3893 hc_thread_mutex_unlock (mux_adl);
3894 }
3895 #endif // HAVE_HWMON
3896
3897 if (restore_check == 1)
3898 {
3899 restore_left--;
3900
3901 if (restore_left == 0)
3902 {
3903 if (data.restore_disable == 0) cycle_restore ();
3904
3905 restore_left = data.restore_timer;
3906 }
3907 }
3908
3909 if ((runtime_check == 1) && (data.runtime_start > 0))
3910 {
3911 time_t runtime_cur;
3912
3913 time (&runtime_cur);
3914
3915 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3916
3917 if (runtime_left <= 0)
3918 {
3919 if (data.benchmark == 0)
3920 {
3921 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3922 }
3923
3924 if (data.devices_status != STATUS_QUIT) myabort ();
3925 }
3926 }
3927
3928 if (remove_check == 1)
3929 {
3930 remove_left--;
3931
3932 if (remove_left == 0)
3933 {
3934 if (data.digests_saved != data.digests_done)
3935 {
3936 data.digests_saved = data.digests_done;
3937
3938 save_hash ();
3939 }
3940
3941 remove_left = data.remove_timer;
3942 }
3943 }
3944
3945 if (status_check == 1)
3946 {
3947 status_left--;
3948
3949 if (status_left == 0)
3950 {
3951 hc_thread_mutex_lock (mux_display);
3952
3953 if (data.quiet == 0) clear_prompt ();
3954
3955 if (data.quiet == 0) log_info ("");
3956
3957 status_display ();
3958
3959 if (data.quiet == 0) log_info ("");
3960
3961 hc_thread_mutex_unlock (mux_display);
3962
3963 status_left = data.status_timer;
3964 }
3965 }
3966 }
3967
3968 #ifdef HAVE_HWMON
3969 myfree (fan_speed_chgd);
3970
3971 myfree (temp_diff_old);
3972 myfree (temp_diff_sum);
3973 #endif
3974
3975 p = NULL;
3976
3977 return (p);
3978 }
3979
3980 static void *thread_outfile_remove (void *p)
3981 {
3982 // some hash-dependent constants
3983 char *outfile_dir = data.outfile_check_directory;
3984 uint dgst_size = data.dgst_size;
3985 uint isSalted = data.isSalted;
3986 uint esalt_size = data.esalt_size;
3987 uint hash_mode = data.hash_mode;
3988
3989 uint outfile_check_timer = data.outfile_check_timer;
3990
3991 char separator = data.separator;
3992
3993 // some hash-dependent functions
3994 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3995 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3996
3997 // buffers
3998 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3999
4000 hash_buf.digest = mymalloc (dgst_size);
4001
4002 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4003
4004 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4005
4006 uint digest_buf[64] = { 0 };
4007
4008 outfile_data_t *out_info = NULL;
4009
4010 char **out_files = NULL;
4011
4012 time_t folder_mtime = 0;
4013
4014 int out_cnt = 0;
4015
4016 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4017
4018 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4019 {
4020 hc_sleep (1);
4021
4022 if (data.devices_status != STATUS_RUNNING) continue;
4023
4024 check_left--;
4025
4026 if (check_left == 0)
4027 {
4028 struct stat outfile_check_stat;
4029
4030 if (stat (outfile_dir, &outfile_check_stat) == 0)
4031 {
4032 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4033
4034 if (is_dir == 1)
4035 {
4036 if (outfile_check_stat.st_mtime > folder_mtime)
4037 {
4038 char **out_files_new = scan_directory (outfile_dir);
4039
4040 int out_cnt_new = count_dictionaries (out_files_new);
4041
4042 outfile_data_t *out_info_new = NULL;
4043
4044 if (out_cnt_new > 0)
4045 {
4046 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4047
4048 for (int i = 0; i < out_cnt_new; i++)
4049 {
4050 out_info_new[i].file_name = out_files_new[i];
4051
4052 // check if there are files that we have seen/checked before (and not changed)
4053
4054 for (int j = 0; j < out_cnt; j++)
4055 {
4056 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4057 {
4058 struct stat outfile_stat;
4059
4060 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4061 {
4062 if (outfile_stat.st_ctime == out_info[j].ctime)
4063 {
4064 out_info_new[i].ctime = out_info[j].ctime;
4065 out_info_new[i].seek = out_info[j].seek;
4066 }
4067 }
4068 }
4069 }
4070 }
4071 }
4072
4073 local_free (out_info);
4074 local_free (out_files);
4075
4076 out_files = out_files_new;
4077 out_cnt = out_cnt_new;
4078 out_info = out_info_new;
4079
4080 folder_mtime = outfile_check_stat.st_mtime;
4081 }
4082
4083 for (int j = 0; j < out_cnt; j++)
4084 {
4085 FILE *fp = fopen (out_info[j].file_name, "rb");
4086
4087 if (fp != NULL)
4088 {
4089 //hc_thread_mutex_lock (mux_display);
4090
4091 #ifdef _POSIX
4092 struct stat outfile_stat;
4093
4094 fstat (fileno (fp), &outfile_stat);
4095 #endif
4096
4097 #ifdef _WIN
4098 struct stat64 outfile_stat;
4099
4100 _fstat64 (fileno (fp), &outfile_stat);
4101 #endif
4102
4103 if (outfile_stat.st_ctime > out_info[j].ctime)
4104 {
4105 out_info[j].ctime = outfile_stat.st_ctime;
4106 out_info[j].seek = 0;
4107 }
4108
4109 fseek (fp, out_info[j].seek, SEEK_SET);
4110
4111 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4112
4113 while (!feof (fp))
4114 {
4115 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4116
4117 if (ptr == NULL) break;
4118
4119 int line_len = strlen (line_buf);
4120
4121 if (line_len <= 0) continue;
4122
4123 int iter = MAX_CUT_TRIES;
4124
4125 for (uint i = line_len - 1; i && iter; i--, line_len--)
4126 {
4127 if (line_buf[i] != separator) continue;
4128
4129 int parser_status = PARSER_OK;
4130
4131 if ((hash_mode != 2500) && (hash_mode != 6800))
4132 {
4133 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4134 }
4135
4136 uint found = 0;
4137
4138 if (parser_status == PARSER_OK)
4139 {
4140 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4141 {
4142 if (data.salts_shown[salt_pos] == 1) continue;
4143
4144 salt_t *salt_buf = &data.salts_buf[salt_pos];
4145
4146 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4147 {
4148 uint idx = salt_buf->digests_offset + digest_pos;
4149
4150 if (data.digests_shown[idx] == 1) continue;
4151
4152 uint cracked = 0;
4153
4154 if (hash_mode == 6800)
4155 {
4156 if (i == salt_buf->salt_len)
4157 {
4158 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4159 }
4160 }
4161 else if (hash_mode == 2500)
4162 {
4163 // BSSID : MAC1 : MAC2 (:plain)
4164 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4165 {
4166 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4167
4168 if (!cracked) continue;
4169
4170 // now compare MAC1 and MAC2 too, since we have this additional info
4171 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4172 char *mac2_pos = mac1_pos + 12 + 1;
4173
4174 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4175 wpa_t *wpa = &wpas[salt_pos];
4176
4177 uint pke[25] = { 0 };
4178
4179 char *pke_ptr = (char *) pke;
4180
4181 for (uint i = 0; i < 25; i++)
4182 {
4183 pke[i] = byte_swap_32 (wpa->pke[i]);
4184 }
4185
4186 u8 mac1[6] = { 0 };
4187 u8 mac2[6] = { 0 };
4188
4189 memcpy (mac1, pke_ptr + 23, 6);
4190 memcpy (mac2, pke_ptr + 29, 6);
4191
4192 // compare hex string(s) vs binary MAC address(es)
4193
4194 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4195 {
4196 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4197 {
4198 cracked = 0;
4199 break;
4200 }
4201 }
4202
4203 // early skip ;)
4204 if (!cracked) continue;
4205
4206 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4207 {
4208 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4209 {
4210 cracked = 0;
4211 break;
4212 }
4213 }
4214 }
4215 }
4216 else
4217 {
4218 char *digests_buf_ptr = (char *) data.digests_buf;
4219
4220 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4221
4222 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4223 }
4224
4225 if (cracked == 1)
4226 {
4227 found = 1;
4228
4229 data.digests_shown[idx] = 1;
4230
4231 data.digests_done++;
4232
4233 salt_buf->digests_done++;
4234
4235 if (salt_buf->digests_done == salt_buf->digests_cnt)
4236 {
4237 data.salts_shown[salt_pos] = 1;
4238
4239 data.salts_done++;
4240
4241 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4242 }
4243 }
4244 }
4245
4246 if (data.devices_status == STATUS_CRACKED) break;
4247 }
4248 }
4249
4250 if (found) break;
4251
4252 if (data.devices_status == STATUS_CRACKED) break;
4253
4254 iter--;
4255 }
4256
4257 if (data.devices_status == STATUS_CRACKED) break;
4258 }
4259
4260 myfree (line_buf);
4261
4262 out_info[j].seek = ftell (fp);
4263
4264 //hc_thread_mutex_unlock (mux_display);
4265
4266 fclose (fp);
4267 }
4268 }
4269 }
4270 }
4271
4272 check_left = outfile_check_timer;
4273 }
4274 }
4275
4276 if (esalt_size) local_free (hash_buf.esalt);
4277
4278 if (isSalted) local_free (hash_buf.salt);
4279
4280 local_free (hash_buf.digest);
4281
4282 local_free (out_info);
4283
4284 local_free (out_files);
4285
4286 p = NULL;
4287
4288 return (p);
4289 }
4290
4291 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4292 {
4293 if (device_param->pws_cnt < device_param->kernel_power)
4294 {
4295 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4296
4297 u8 *ptr = (u8 *) pw->i;
4298
4299 memcpy (ptr, pw_buf, pw_len);
4300
4301 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4302
4303 pw->pw_len = pw_len;
4304
4305 device_param->pws_cnt++;
4306 }
4307 else
4308 {
4309 fprintf (stderr, "BUG pw_add()!!\n");
4310
4311 return;
4312 }
4313 }
4314
4315 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4316 {
4317 hc_thread_mutex_lock (mux_dispatcher);
4318
4319 const u64 words_cur = data.words_cur;
4320 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4321
4322 device_param->words_off = words_cur;
4323
4324 const u64 words_left = words_base - words_cur;
4325
4326 if (allow_div)
4327 {
4328 if (data.kernel_power_all > words_left)
4329 {
4330 if (data.kernel_power_div == 0)
4331 {
4332 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4333 }
4334 }
4335
4336 if (data.kernel_power_div)
4337 {
4338 if (device_param->kernel_power == device_param->kernel_power_user)
4339 {
4340 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4341
4342 if (kernel_power_new < device_param->kernel_power)
4343 {
4344 device_param->kernel_power = kernel_power_new;
4345 }
4346 }
4347 }
4348 }
4349
4350 const uint kernel_power = device_param->kernel_power;
4351
4352 uint work = MIN (words_left, kernel_power);
4353
4354 work = MIN (work, max);
4355
4356 data.words_cur += work;
4357
4358 hc_thread_mutex_unlock (mux_dispatcher);
4359
4360 return work;
4361 }
4362
4363 static void *thread_calc_stdin (void *p)
4364 {
4365 hc_device_param_t *device_param = (hc_device_param_t *) p;
4366
4367 if (device_param->skipped) return NULL;
4368
4369 autotune (device_param);
4370
4371 char *buf = (char *) mymalloc (HCBUFSIZ);
4372
4373 const uint attack_kern = data.attack_kern;
4374
4375 const uint kernel_power = device_param->kernel_power;
4376
4377 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4378 {
4379 hc_thread_mutex_lock (mux_dispatcher);
4380
4381 if (feof (stdin) != 0)
4382 {
4383 hc_thread_mutex_unlock (mux_dispatcher);
4384
4385 break;
4386 }
4387
4388 uint words_cur = 0;
4389
4390 while (words_cur < kernel_power)
4391 {
4392 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4393
4394 if (line_buf == NULL) break;
4395
4396 uint line_len = in_superchop (line_buf);
4397
4398 line_len = convert_from_hex (line_buf, line_len);
4399
4400 // post-process rule engine
4401
4402 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4403 {
4404 char rule_buf_out[BLOCK_SIZE] = { 0 };
4405
4406 int rule_len_out = -1;
4407
4408 if (line_len < BLOCK_SIZE)
4409 {
4410 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4411 }
4412
4413 if (rule_len_out < 0) continue;
4414
4415 line_buf = rule_buf_out;
4416 line_len = rule_len_out;
4417 }
4418
4419 if (line_len > PW_MAX)
4420 {
4421 continue;
4422 }
4423
4424 if (attack_kern == ATTACK_KERN_STRAIGHT)
4425 {
4426 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4427 {
4428 hc_thread_mutex_lock (mux_counter);
4429
4430 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4431 {
4432 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4433 }
4434
4435 hc_thread_mutex_unlock (mux_counter);
4436
4437 continue;
4438 }
4439 }
4440 else if (attack_kern == ATTACK_KERN_COMBI)
4441 {
4442 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4443 // since we still need to combine the plains
4444
4445 if (line_len > data.pw_max)
4446 {
4447 hc_thread_mutex_lock (mux_counter);
4448
4449 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4450 {
4451 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4452 }
4453
4454 hc_thread_mutex_unlock (mux_counter);
4455
4456 continue;
4457 }
4458 }
4459
4460 pw_add (device_param, (u8 *) line_buf, line_len);
4461
4462 words_cur++;
4463
4464 if (data.devices_status == STATUS_CRACKED) break;
4465 if (data.devices_status == STATUS_ABORTED) break;
4466 if (data.devices_status == STATUS_QUIT) break;
4467 if (data.devices_status == STATUS_BYPASS) break;
4468 }
4469
4470 hc_thread_mutex_unlock (mux_dispatcher);
4471
4472 if (data.devices_status == STATUS_CRACKED) break;
4473 if (data.devices_status == STATUS_ABORTED) break;
4474 if (data.devices_status == STATUS_QUIT) break;
4475 if (data.devices_status == STATUS_BYPASS) break;
4476
4477 // flush
4478
4479 const uint pws_cnt = device_param->pws_cnt;
4480
4481 if (pws_cnt)
4482 {
4483 run_copy (device_param, pws_cnt);
4484
4485 run_cracker (device_param, pws_cnt);
4486
4487 device_param->pws_cnt = 0;
4488
4489 if (attack_kern == ATTACK_KERN_STRAIGHT)
4490 {
4491 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4492 }
4493 else if (attack_kern == ATTACK_KERN_COMBI)
4494 {
4495 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4496 }
4497 }
4498 }
4499
4500 device_param->kernel_accel = 0;
4501 device_param->kernel_loops = 0;
4502
4503 myfree (buf);
4504
4505 return NULL;
4506 }
4507
4508 static void *thread_calc (void *p)
4509 {
4510 hc_device_param_t *device_param = (hc_device_param_t *) p;
4511
4512 if (device_param->skipped) return NULL;
4513
4514 autotune (device_param);
4515
4516 const uint attack_mode = data.attack_mode;
4517 const uint attack_kern = data.attack_kern;
4518
4519 if (attack_mode == ATTACK_MODE_BF)
4520 {
4521 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4522 {
4523 const uint work = get_work (device_param, -1, true);
4524
4525 if (work == 0) break;
4526
4527 const u64 words_off = device_param->words_off;
4528 const u64 words_fin = words_off + work;
4529
4530 const uint pws_cnt = work;
4531
4532 device_param->pws_cnt = pws_cnt;
4533
4534 if (pws_cnt)
4535 {
4536 run_copy (device_param, pws_cnt);
4537
4538 run_cracker (device_param, pws_cnt);
4539
4540 device_param->pws_cnt = 0;
4541
4542 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4543 }
4544
4545 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4546
4547 if (data.devices_status == STATUS_CRACKED) break;
4548 if (data.devices_status == STATUS_ABORTED) break;
4549 if (data.devices_status == STATUS_QUIT) break;
4550 if (data.devices_status == STATUS_BYPASS) break;
4551
4552 if (data.benchmark == 1) break;
4553
4554 device_param->words_done = words_fin;
4555 }
4556 }
4557 else
4558 {
4559 const uint segment_size = data.segment_size;
4560
4561 char *dictfile = data.dictfile;
4562
4563 if (attack_mode == ATTACK_MODE_COMBI)
4564 {
4565 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4566 {
4567 dictfile = data.dictfile2;
4568 }
4569 }
4570
4571 FILE *fd = fopen (dictfile, "rb");
4572
4573 if (fd == NULL)
4574 {
4575 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4576
4577 return NULL;
4578 }
4579
4580 if (attack_mode == ATTACK_MODE_COMBI)
4581 {
4582 const uint combs_mode = data.combs_mode;
4583
4584 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4585 {
4586 const char *dictfilec = data.dictfile2;
4587
4588 FILE *combs_fp = fopen (dictfilec, "rb");
4589
4590 if (combs_fp == NULL)
4591 {
4592 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4593
4594 fclose (fd);
4595
4596 return NULL;
4597 }
4598
4599 device_param->combs_fp = combs_fp;
4600 }
4601 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4602 {
4603 const char *dictfilec = data.dictfile;
4604
4605 FILE *combs_fp = fopen (dictfilec, "rb");
4606
4607 if (combs_fp == NULL)
4608 {
4609 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4610
4611 fclose (fd);
4612
4613 return NULL;
4614 }
4615
4616 device_param->combs_fp = combs_fp;
4617 }
4618 }
4619
4620 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4621
4622 wl_data->buf = (char *) mymalloc (segment_size);
4623 wl_data->avail = segment_size;
4624 wl_data->incr = segment_size;
4625 wl_data->cnt = 0;
4626 wl_data->pos = 0;
4627
4628 u64 words_cur = 0;
4629
4630 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4631 {
4632 u64 words_off = 0;
4633 u64 words_fin = 0;
4634
4635 bool allow_div = true;
4636
4637 u64 max = -1;
4638
4639 while (max)
4640 {
4641 const uint work = get_work (device_param, max, allow_div);
4642
4643 allow_div = false;
4644
4645 if (work == 0) break;
4646
4647 words_off = device_param->words_off;
4648 words_fin = words_off + work;
4649
4650 char *line_buf;
4651 uint line_len;
4652
4653 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4654
4655 max = 0;
4656
4657 for ( ; words_cur < words_fin; words_cur++)
4658 {
4659 get_next_word (wl_data, fd, &line_buf, &line_len);
4660
4661 line_len = convert_from_hex (line_buf, line_len);
4662
4663 // post-process rule engine
4664
4665 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4666 {
4667 char rule_buf_out[BLOCK_SIZE] = { 0 };
4668
4669 int rule_len_out = -1;
4670
4671 if (line_len < BLOCK_SIZE)
4672 {
4673 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4674 }
4675
4676 if (rule_len_out < 0) continue;
4677
4678 line_buf = rule_buf_out;
4679 line_len = rule_len_out;
4680 }
4681
4682 if (attack_kern == ATTACK_KERN_STRAIGHT)
4683 {
4684 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4685 {
4686 max++;
4687
4688 hc_thread_mutex_lock (mux_counter);
4689
4690 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4691 {
4692 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4693 }
4694
4695 hc_thread_mutex_unlock (mux_counter);
4696
4697 continue;
4698 }
4699 }
4700 else if (attack_kern == ATTACK_KERN_COMBI)
4701 {
4702 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4703 // since we still need to combine the plains
4704
4705 if (line_len > data.pw_max)
4706 {
4707 max++;
4708
4709 hc_thread_mutex_lock (mux_counter);
4710
4711 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4712 {
4713 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4714 }
4715
4716 hc_thread_mutex_unlock (mux_counter);
4717
4718 continue;
4719 }
4720 }
4721
4722 pw_add (device_param, (u8 *) line_buf, line_len);
4723
4724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4725
4726 if (data.devices_status == STATUS_CRACKED) break;
4727 if (data.devices_status == STATUS_ABORTED) break;
4728 if (data.devices_status == STATUS_QUIT) break;
4729 if (data.devices_status == STATUS_BYPASS) break;
4730 }
4731
4732 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4733
4734 if (data.devices_status == STATUS_CRACKED) break;
4735 if (data.devices_status == STATUS_ABORTED) break;
4736 if (data.devices_status == STATUS_QUIT) break;
4737 if (data.devices_status == STATUS_BYPASS) break;
4738 }
4739
4740 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4741
4742 if (data.devices_status == STATUS_CRACKED) break;
4743 if (data.devices_status == STATUS_ABORTED) break;
4744 if (data.devices_status == STATUS_QUIT) break;
4745 if (data.devices_status == STATUS_BYPASS) break;
4746
4747 //
4748 // flush
4749 //
4750
4751 const uint pws_cnt = device_param->pws_cnt;
4752
4753 if (pws_cnt)
4754 {
4755 run_copy (device_param, pws_cnt);
4756
4757 run_cracker (device_param, pws_cnt);
4758
4759 device_param->pws_cnt = 0;
4760
4761 if (attack_kern == ATTACK_KERN_STRAIGHT)
4762 {
4763 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4764 }
4765 else if (attack_kern == ATTACK_KERN_COMBI)
4766 {
4767 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4768 }
4769 }
4770
4771 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4772
4773 if (data.devices_status == STATUS_CRACKED) break;
4774 if (data.devices_status == STATUS_ABORTED) break;
4775 if (data.devices_status == STATUS_QUIT) break;
4776 if (data.devices_status == STATUS_BYPASS) break;
4777
4778 if (words_fin == 0) break;
4779
4780 device_param->words_done = words_fin;
4781 }
4782
4783 if (attack_mode == ATTACK_MODE_COMBI)
4784 {
4785 fclose (device_param->combs_fp);
4786 }
4787
4788 free (wl_data->buf);
4789 free (wl_data);
4790
4791 fclose (fd);
4792 }
4793
4794 device_param->kernel_accel = 0;
4795 device_param->kernel_loops = 0;
4796
4797 return NULL;
4798 }
4799
4800 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4801 {
4802 if (!device_param)
4803 {
4804 log_error ("ERROR: %s : Invalid argument", __func__);
4805
4806 exit (-1);
4807 }
4808
4809 salt_t *salt_buf = &data.salts_buf[salt_pos];
4810
4811 device_param->kernel_params_buf32[24] = salt_pos;
4812 device_param->kernel_params_buf32[27] = 1;
4813 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4814 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4815 device_param->kernel_params_buf32[30] = 0;
4816 device_param->kernel_params_buf32[31] = 1;
4817
4818 char *dictfile_old = data.dictfile;
4819
4820 const char *weak_hash_check = "weak-hash-check";
4821
4822 data.dictfile = (char *) weak_hash_check;
4823
4824 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4825
4826 data.kernel_rules_buf[0].cmds[0] = 0;
4827
4828 /**
4829 * run the kernel
4830 */
4831
4832 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4833 {
4834 run_kernel (KERN_RUN_1, device_param, 1, false);
4835 }
4836 else
4837 {
4838 run_kernel (KERN_RUN_1, device_param, 1, false);
4839
4840 uint loop_step = 16;
4841
4842 const uint iter = salt_buf->salt_iter;
4843
4844 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4845 {
4846 uint loop_left = iter - loop_pos;
4847
4848 loop_left = MIN (loop_left, loop_step);
4849
4850 device_param->kernel_params_buf32[25] = loop_pos;
4851 device_param->kernel_params_buf32[26] = loop_left;
4852
4853 run_kernel (KERN_RUN_2, device_param, 1, false);
4854 }
4855
4856 run_kernel (KERN_RUN_3, device_param, 1, false);
4857 }
4858
4859 /**
4860 * result
4861 */
4862
4863 check_cracked (device_param, salt_pos);
4864
4865 /**
4866 * cleanup
4867 */
4868
4869 device_param->kernel_params_buf32[24] = 0;
4870 device_param->kernel_params_buf32[25] = 0;
4871 device_param->kernel_params_buf32[26] = 0;
4872 device_param->kernel_params_buf32[27] = 0;
4873 device_param->kernel_params_buf32[28] = 0;
4874 device_param->kernel_params_buf32[29] = 0;
4875 device_param->kernel_params_buf32[30] = 0;
4876 device_param->kernel_params_buf32[31] = 0;
4877
4878 data.dictfile = dictfile_old;
4879
4880 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4881 }
4882
4883 // hlfmt hashcat
4884
4885 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4886 {
4887 if (data.username == 0)
4888 {
4889 *hashbuf_pos = line_buf;
4890 *hashbuf_len = line_len;
4891 }
4892 else
4893 {
4894 char *pos = line_buf;
4895 int len = line_len;
4896
4897 for (int i = 0; i < line_len; i++, pos++, len--)
4898 {
4899 if (line_buf[i] == data.separator)
4900 {
4901 pos++;
4902
4903 len--;
4904
4905 break;
4906 }
4907 }
4908
4909 *hashbuf_pos = pos;
4910 *hashbuf_len = len;
4911 }
4912 }
4913
4914 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4915 {
4916 char *pos = NULL;
4917 int len = 0;
4918
4919 int sep_cnt = 0;
4920
4921 for (int i = 0; i < line_len; i++)
4922 {
4923 if (line_buf[i] == data.separator)
4924 {
4925 sep_cnt++;
4926
4927 continue;
4928 }
4929
4930 if (sep_cnt == 0)
4931 {
4932 if (pos == NULL) pos = line_buf + i;
4933
4934 len++;
4935 }
4936 }
4937
4938 *userbuf_pos = pos;
4939 *userbuf_len = len;
4940 }
4941
4942 // hlfmt pwdump
4943
4944 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4945 {
4946 int sep_cnt = 0;
4947
4948 int sep2_len = 0;
4949 int sep3_len = 0;
4950
4951 for (int i = 0; i < line_len; i++)
4952 {
4953 if (line_buf[i] == ':')
4954 {
4955 sep_cnt++;
4956
4957 continue;
4958 }
4959
4960 if (sep_cnt == 2) sep2_len++;
4961 if (sep_cnt == 3) sep3_len++;
4962 }
4963
4964 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4965
4966 return 0;
4967 }
4968
4969 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4970 {
4971 char *pos = NULL;
4972 int len = 0;
4973
4974 int sep_cnt = 0;
4975
4976 for (int i = 0; i < line_len; i++)
4977 {
4978 if (line_buf[i] == ':')
4979 {
4980 sep_cnt++;
4981
4982 continue;
4983 }
4984
4985 if (data.hash_mode == 1000)
4986 {
4987 if (sep_cnt == 3)
4988 {
4989 if (pos == NULL) pos = line_buf + i;
4990
4991 len++;
4992 }
4993 }
4994 else if (data.hash_mode == 3000)
4995 {
4996 if (sep_cnt == 2)
4997 {
4998 if (pos == NULL) pos = line_buf + i;
4999
5000 len++;
5001 }
5002 }
5003 }
5004
5005 *hashbuf_pos = pos;
5006 *hashbuf_len = len;
5007 }
5008
5009 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5010 {
5011 char *pos = NULL;
5012 int len = 0;
5013
5014 int sep_cnt = 0;
5015
5016 for (int i = 0; i < line_len; i++)
5017 {
5018 if (line_buf[i] == ':')
5019 {
5020 sep_cnt++;
5021
5022 continue;
5023 }
5024
5025 if (sep_cnt == 0)
5026 {
5027 if (pos == NULL) pos = line_buf + i;
5028
5029 len++;
5030 }
5031 }
5032
5033 *userbuf_pos = pos;
5034 *userbuf_len = len;
5035 }
5036
5037 // hlfmt passwd
5038
5039 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5040 {
5041 int sep_cnt = 0;
5042
5043 char sep5_first = 0;
5044 char sep6_first = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == ':')
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5056 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5057 }
5058
5059 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5060
5061 return 0;
5062 }
5063
5064 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5065 {
5066 char *pos = NULL;
5067 int len = 0;
5068
5069 int sep_cnt = 0;
5070
5071 for (int i = 0; i < line_len; i++)
5072 {
5073 if (line_buf[i] == ':')
5074 {
5075 sep_cnt++;
5076
5077 continue;
5078 }
5079
5080 if (sep_cnt == 1)
5081 {
5082 if (pos == NULL) pos = line_buf + i;
5083
5084 len++;
5085 }
5086 }
5087
5088 *hashbuf_pos = pos;
5089 *hashbuf_len = len;
5090 }
5091
5092 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5093 {
5094 char *pos = NULL;
5095 int len = 0;
5096
5097 int sep_cnt = 0;
5098
5099 for (int i = 0; i < line_len; i++)
5100 {
5101 if (line_buf[i] == ':')
5102 {
5103 sep_cnt++;
5104
5105 continue;
5106 }
5107
5108 if (sep_cnt == 0)
5109 {
5110 if (pos == NULL) pos = line_buf + i;
5111
5112 len++;
5113 }
5114 }
5115
5116 *userbuf_pos = pos;
5117 *userbuf_len = len;
5118 }
5119
5120 // hlfmt shadow
5121
5122 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5123 {
5124 int sep_cnt = 0;
5125
5126 for (int i = 0; i < line_len; i++)
5127 {
5128 if (line_buf[i] == ':') sep_cnt++;
5129 }
5130
5131 if (sep_cnt == 8) return 1;
5132
5133 return 0;
5134 }
5135
5136 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5137 {
5138 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5139 }
5140
5141 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5142 {
5143 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5144 }
5145
5146 // hlfmt main
5147
5148 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5149 {
5150 switch (hashfile_format)
5151 {
5152 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5153 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5154 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5155 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5156 }
5157 }
5158
5159 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5160 {
5161 switch (hashfile_format)
5162 {
5163 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5164 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5165 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5166 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5167 }
5168 }
5169
5170 char *strhlfmt (const uint hashfile_format)
5171 {
5172 switch (hashfile_format)
5173 {
5174 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5175 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5176 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5177 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5178 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5179 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5180 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5181 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5182 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5183 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5184 }
5185
5186 return ((char *) "Unknown");
5187 }
5188
5189 static uint hlfmt_detect (FILE *fp, uint max_check)
5190 {
5191 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5192
5193 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5194 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5195
5196 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5197
5198 uint num_check = 0;
5199
5200 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5201
5202 while (!feof (fp))
5203 {
5204 int line_len = fgetl (fp, line_buf);
5205
5206 if (line_len == 0) continue;
5207
5208 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5209 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5210 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5211
5212 if (num_check == max_check) break;
5213
5214 num_check++;
5215 }
5216
5217 myfree (line_buf);
5218
5219 uint hashlist_format = HLFMT_HASHCAT;
5220
5221 for (int i = 1; i < HLFMTS_CNT; i++)
5222 {
5223 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5224
5225 hashlist_format = i;
5226 }
5227
5228 free (formats_cnt);
5229
5230 return hashlist_format;
5231 }
5232
5233 /**
5234 * some further helper function
5235 */
5236
5237 // wrapper around mymalloc for ADL
5238
5239 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5240 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5241 {
5242 return mymalloc (iSize);
5243 }
5244 #endif
5245
5246 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)
5247 {
5248 u64 collisions = 0;
5249
5250 const uint dgst_pos0 = data.dgst_pos0;
5251 const uint dgst_pos1 = data.dgst_pos1;
5252 const uint dgst_pos2 = data.dgst_pos2;
5253 const uint dgst_pos3 = data.dgst_pos3;
5254
5255 memset (bitmap_a, 0, bitmap_size);
5256 memset (bitmap_b, 0, bitmap_size);
5257 memset (bitmap_c, 0, bitmap_size);
5258 memset (bitmap_d, 0, bitmap_size);
5259
5260 for (uint i = 0; i < digests_cnt; i++)
5261 {
5262 uint *digest_ptr = (uint *) digests_buf_ptr;
5263
5264 digests_buf_ptr += dgst_size;
5265
5266 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5267 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5268 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5269 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5270
5271 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5272 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5273 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5274 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5275
5276 if (bitmap_a[idx0] & val0) collisions++;
5277 if (bitmap_b[idx1] & val1) collisions++;
5278 if (bitmap_c[idx2] & val2) collisions++;
5279 if (bitmap_d[idx3] & val3) collisions++;
5280
5281 bitmap_a[idx0] |= val0;
5282 bitmap_b[idx1] |= val1;
5283 bitmap_c[idx2] |= val2;
5284 bitmap_d[idx3] |= val3;
5285
5286 if (collisions >= collisions_max) return 0x7fffffff;
5287 }
5288
5289 return collisions;
5290 }
5291
5292 /**
5293 * main
5294 */
5295
5296 int main (int argc, char **argv)
5297 {
5298 /**
5299 * To help users a bit
5300 */
5301
5302 char *compute = getenv ("COMPUTE");
5303
5304 if (compute)
5305 {
5306 static char display[100];
5307
5308 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5309
5310 putenv (display);
5311 }
5312 else
5313 {
5314 if (getenv ("DISPLAY") == NULL)
5315 putenv ((char *) "DISPLAY=:0");
5316 }
5317
5318 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5319 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5320
5321 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5322 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5323
5324 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5325 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5326
5327 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5328 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5329
5330 /**
5331 * Real init
5332 */
5333
5334 memset (&data, 0, sizeof (hc_global_data_t));
5335
5336 time_t proc_start;
5337
5338 time (&proc_start);
5339
5340 data.proc_start = proc_start;
5341
5342 int myargc = argc;
5343 char **myargv = argv;
5344
5345 hc_thread_mutex_init (mux_dispatcher);
5346 hc_thread_mutex_init (mux_counter);
5347 hc_thread_mutex_init (mux_display);
5348 hc_thread_mutex_init (mux_adl);
5349
5350 /**
5351 * commandline parameters
5352 */
5353
5354 uint usage = USAGE;
5355 uint version = VERSION;
5356 uint quiet = QUIET;
5357 uint benchmark = BENCHMARK;
5358 uint benchmark_repeats = BENCHMARK_REPEATS;
5359 uint show = SHOW;
5360 uint left = LEFT;
5361 uint username = USERNAME;
5362 uint remove = REMOVE;
5363 uint remove_timer = REMOVE_TIMER;
5364 u64 skip = SKIP;
5365 u64 limit = LIMIT;
5366 uint keyspace = KEYSPACE;
5367 uint potfile_disable = POTFILE_DISABLE;
5368 uint debug_mode = DEBUG_MODE;
5369 char *debug_file = NULL;
5370 char *induction_dir = NULL;
5371 char *outfile_check_dir = NULL;
5372 uint force = FORCE;
5373 uint runtime = RUNTIME;
5374 uint hash_mode = HASH_MODE;
5375 uint attack_mode = ATTACK_MODE;
5376 uint markov_disable = MARKOV_DISABLE;
5377 uint markov_classic = MARKOV_CLASSIC;
5378 uint markov_threshold = MARKOV_THRESHOLD;
5379 char *markov_hcstat = NULL;
5380 char *outfile = NULL;
5381 uint outfile_format = OUTFILE_FORMAT;
5382 uint outfile_autohex = OUTFILE_AUTOHEX;
5383 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5384 uint restore = RESTORE;
5385 uint restore_timer = RESTORE_TIMER;
5386 uint restore_disable = RESTORE_DISABLE;
5387 uint status = STATUS;
5388 uint status_timer = STATUS_TIMER;
5389 uint status_automat = STATUS_AUTOMAT;
5390 uint loopback = LOOPBACK;
5391 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5392 char *session = NULL;
5393 uint hex_charset = HEX_CHARSET;
5394 uint hex_salt = HEX_SALT;
5395 uint hex_wordlist = HEX_WORDLIST;
5396 uint rp_gen = RP_GEN;
5397 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5398 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5399 uint rp_gen_seed = RP_GEN_SEED;
5400 char *rule_buf_l = (char *) RULE_BUF_L;
5401 char *rule_buf_r = (char *) RULE_BUF_R;
5402 uint increment = INCREMENT;
5403 uint increment_min = INCREMENT_MIN;
5404 uint increment_max = INCREMENT_MAX;
5405 char *cpu_affinity = NULL;
5406 OCL_PTR *ocl = NULL;
5407 char *opencl_devices = NULL;
5408 char *opencl_platforms = NULL;
5409 char *opencl_device_types = NULL;
5410 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5411 char *truecrypt_keyfiles = NULL;
5412 uint workload_profile = WORKLOAD_PROFILE;
5413 uint kernel_accel = KERNEL_ACCEL;
5414 uint kernel_loops = KERNEL_LOOPS;
5415 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5416 #ifdef HAVE_HWMON
5417 uint gpu_temp_abort = GPU_TEMP_ABORT;
5418 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5419 #ifdef HAVE_ADL
5420 uint powertune_enable = POWERTUNE_ENABLE;
5421 #endif
5422 #endif
5423 uint logfile_disable = LOGFILE_DISABLE;
5424 uint segment_size = SEGMENT_SIZE;
5425 uint scrypt_tmto = SCRYPT_TMTO;
5426 char separator = SEPARATOR;
5427 uint bitmap_min = BITMAP_MIN;
5428 uint bitmap_max = BITMAP_MAX;
5429 char *custom_charset_1 = NULL;
5430 char *custom_charset_2 = NULL;
5431 char *custom_charset_3 = NULL;
5432 char *custom_charset_4 = NULL;
5433
5434 #define IDX_HELP 'h'
5435 #define IDX_VERSION 'V'
5436 #define IDX_VERSION_LOWER 'v'
5437 #define IDX_QUIET 0xff02
5438 #define IDX_SHOW 0xff03
5439 #define IDX_LEFT 0xff04
5440 #define IDX_REMOVE 0xff05
5441 #define IDX_REMOVE_TIMER 0xff37
5442 #define IDX_SKIP 's'
5443 #define IDX_LIMIT 'l'
5444 #define IDX_KEYSPACE 0xff35
5445 #define IDX_POTFILE_DISABLE 0xff06
5446 #define IDX_DEBUG_MODE 0xff43
5447 #define IDX_DEBUG_FILE 0xff44
5448 #define IDX_INDUCTION_DIR 0xff46
5449 #define IDX_OUTFILE_CHECK_DIR 0xff47
5450 #define IDX_USERNAME 0xff07
5451 #define IDX_FORCE 0xff08
5452 #define IDX_RUNTIME 0xff09
5453 #define IDX_BENCHMARK 'b'
5454 #define IDX_BENCHMARK_REPEATS 0xff78
5455 #define IDX_HASH_MODE 'm'
5456 #define IDX_ATTACK_MODE 'a'
5457 #define IDX_RP_FILE 'r'
5458 #define IDX_RP_GEN 'g'
5459 #define IDX_RP_GEN_FUNC_MIN 0xff10
5460 #define IDX_RP_GEN_FUNC_MAX 0xff11
5461 #define IDX_RP_GEN_SEED 0xff34
5462 #define IDX_RULE_BUF_L 'j'
5463 #define IDX_RULE_BUF_R 'k'
5464 #define IDX_INCREMENT 'i'
5465 #define IDX_INCREMENT_MIN 0xff12
5466 #define IDX_INCREMENT_MAX 0xff13
5467 #define IDX_OUTFILE 'o'
5468 #define IDX_OUTFILE_FORMAT 0xff14
5469 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5470 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5471 #define IDX_RESTORE 0xff15
5472 #define IDX_RESTORE_DISABLE 0xff27
5473 #define IDX_STATUS 0xff17
5474 #define IDX_STATUS_TIMER 0xff18
5475 #define IDX_STATUS_AUTOMAT 0xff50
5476 #define IDX_LOOPBACK 0xff38
5477 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5478 #define IDX_SESSION 0xff19
5479 #define IDX_HEX_CHARSET 0xff20
5480 #define IDX_HEX_SALT 0xff21
5481 #define IDX_HEX_WORDLIST 0xff40
5482 #define IDX_MARKOV_DISABLE 0xff22
5483 #define IDX_MARKOV_CLASSIC 0xff23
5484 #define IDX_MARKOV_THRESHOLD 't'
5485 #define IDX_MARKOV_HCSTAT 0xff24
5486 #define IDX_CPU_AFFINITY 0xff25
5487 #define IDX_OPENCL_DEVICES 'd'
5488 #define IDX_OPENCL_PLATFORMS 0xff72
5489 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5490 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5491 #define IDX_WORKLOAD_PROFILE 'w'
5492 #define IDX_KERNEL_ACCEL 'n'
5493 #define IDX_KERNEL_LOOPS 'u'
5494 #define IDX_GPU_TEMP_DISABLE 0xff29
5495 #define IDX_GPU_TEMP_ABORT 0xff30
5496 #define IDX_GPU_TEMP_RETAIN 0xff31
5497 #define IDX_POWERTUNE_ENABLE 0xff41
5498 #define IDX_LOGFILE_DISABLE 0xff51
5499 #define IDX_TRUECRYPT_KEYFILES 0xff52
5500 #define IDX_SCRYPT_TMTO 0xff61
5501 #define IDX_SEGMENT_SIZE 'c'
5502 #define IDX_SEPARATOR 'p'
5503 #define IDX_BITMAP_MIN 0xff70
5504 #define IDX_BITMAP_MAX 0xff71
5505 #define IDX_CUSTOM_CHARSET_1 '1'
5506 #define IDX_CUSTOM_CHARSET_2 '2'
5507 #define IDX_CUSTOM_CHARSET_3 '3'
5508 #define IDX_CUSTOM_CHARSET_4 '4'
5509
5510 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5511
5512 struct option long_options[] =
5513 {
5514 {"help", no_argument, 0, IDX_HELP},
5515 {"version", no_argument, 0, IDX_VERSION},
5516 {"quiet", no_argument, 0, IDX_QUIET},
5517 {"show", no_argument, 0, IDX_SHOW},
5518 {"left", no_argument, 0, IDX_LEFT},
5519 {"username", no_argument, 0, IDX_USERNAME},
5520 {"remove", no_argument, 0, IDX_REMOVE},
5521 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5522 {"skip", required_argument, 0, IDX_SKIP},
5523 {"limit", required_argument, 0, IDX_LIMIT},
5524 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5525 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5526 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5527 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5528 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5529 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5530 {"force", no_argument, 0, IDX_FORCE},
5531 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5532 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5533 {"restore", no_argument, 0, IDX_RESTORE},
5534 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5535 {"status", no_argument, 0, IDX_STATUS},
5536 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5537 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5538 {"loopback", no_argument, 0, IDX_LOOPBACK},
5539 {"weak-hash-threshold",
5540 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5541 {"session", required_argument, 0, IDX_SESSION},
5542 {"runtime", required_argument, 0, IDX_RUNTIME},
5543 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5544 {"generate-rules-func-min",
5545 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5546 {"generate-rules-func-max",
5547 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5548 {"generate-rules-seed",
5549 required_argument, 0, IDX_RP_GEN_SEED},
5550 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5551 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5552 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5553 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5554 {"rules-file", required_argument, 0, IDX_RP_FILE},
5555 {"outfile", required_argument, 0, IDX_OUTFILE},
5556 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5557 {"outfile-autohex-disable",
5558 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5559 {"outfile-check-timer",
5560 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5561 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5562 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5563 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5564 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5565 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5566 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5567 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5568 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5569 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5570 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5571 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5572 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5573 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5574 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5575 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5576 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5577 #ifdef HAVE_HWMON
5578 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5579 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5580 #ifdef HAVE_ADL
5581 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5582 #endif
5583 #endif // HAVE_HWMON
5584 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5585 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5586 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5587 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5588 // deprecated
5589 {"seperator", required_argument, 0, IDX_SEPARATOR},
5590 {"separator", required_argument, 0, IDX_SEPARATOR},
5591 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5592 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5593 {"increment", no_argument, 0, IDX_INCREMENT},
5594 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5595 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5596 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5597 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5598 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5599 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5600
5601 {0, 0, 0, 0}
5602 };
5603
5604 uint rp_files_cnt = 0;
5605
5606 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5607
5608 int option_index = 0;
5609 int c = -1;
5610
5611 optind = 1;
5612 optopt = 0;
5613
5614 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5615 {
5616 switch (c)
5617 {
5618 case IDX_HELP: usage = 1; break;
5619 case IDX_VERSION:
5620 case IDX_VERSION_LOWER: version = 1; break;
5621 case IDX_RESTORE: restore = 1; break;
5622 case IDX_SESSION: session = optarg; break;
5623 case IDX_SHOW: show = 1; break;
5624 case IDX_LEFT: left = 1; break;
5625 case '?': return (-1);
5626 }
5627 }
5628
5629 if (optopt != 0)
5630 {
5631 log_error ("ERROR: Invalid argument specified");
5632
5633 return (-1);
5634 }
5635
5636 /**
5637 * exit functions
5638 */
5639
5640 if (version)
5641 {
5642 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5643
5644 return (0);
5645 }
5646
5647 if (usage)
5648 {
5649 usage_big_print (PROGNAME);
5650
5651 return (0);
5652 }
5653
5654 /**
5655 * session needs to be set, always!
5656 */
5657
5658 if (session == NULL) session = (char *) PROGNAME;
5659
5660 /**
5661 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5662 */
5663
5664 char *exec_path = get_exec_path ();
5665
5666 #ifdef LINUX
5667
5668 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5669 char *resolved_exec_path = realpath (exec_path, NULL);
5670
5671 char *install_dir = get_install_dir (resolved_exec_path);
5672 char *profile_dir = NULL;
5673 char *session_dir = NULL;
5674 char *shared_dir = NULL;
5675
5676 if (strcmp (install_dir, resolved_install_folder) == 0)
5677 {
5678 struct passwd *pw = getpwuid (getuid ());
5679
5680 const char *homedir = pw->pw_dir;
5681
5682 profile_dir = get_profile_dir (homedir);
5683 session_dir = get_session_dir (profile_dir);
5684 shared_dir = strdup (SHARED_FOLDER);
5685
5686 mkdir (profile_dir, 0700);
5687 mkdir (session_dir, 0700);
5688 }
5689 else
5690 {
5691 profile_dir = install_dir;
5692 session_dir = install_dir;
5693 shared_dir = install_dir;
5694 }
5695
5696 myfree (resolved_install_folder);
5697 myfree (resolved_exec_path);
5698
5699 #else
5700
5701 char *install_dir = get_install_dir (exec_path);
5702 char *profile_dir = install_dir;
5703 char *session_dir = install_dir;
5704 char *shared_dir = install_dir;
5705
5706 #endif
5707
5708 data.install_dir = install_dir;
5709 data.profile_dir = profile_dir;
5710 data.session_dir = session_dir;
5711 data.shared_dir = shared_dir;
5712
5713 myfree (exec_path);
5714
5715 /**
5716 * kernel cache, we need to make sure folder exist
5717 */
5718
5719 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5720
5721 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5722
5723 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5724
5725 mkdir (kernels_folder, 0700);
5726
5727 myfree (kernels_folder);
5728
5729 /**
5730 * session
5731 */
5732
5733 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5734
5735 data.session = session;
5736
5737 char *eff_restore_file = (char *) mymalloc (session_size);
5738 char *new_restore_file = (char *) mymalloc (session_size);
5739
5740 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5741 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5742
5743 data.eff_restore_file = eff_restore_file;
5744 data.new_restore_file = new_restore_file;
5745
5746 if (((show == 1) || (left == 1)) && (restore == 1))
5747 {
5748 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5749 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5750
5751 return (-1);
5752 }
5753
5754 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5755 if ((show == 1) || (left == 1))
5756 {
5757 restore_disable = 1;
5758
5759 restore = 0;
5760 }
5761
5762 data.restore_disable = restore_disable;
5763
5764 restore_data_t *rd = init_restore (argc, argv);
5765
5766 data.rd = rd;
5767
5768 /**
5769 * restore file
5770 */
5771
5772 if (restore == 1)
5773 {
5774 read_restore (eff_restore_file, rd);
5775
5776 if (rd->version_bin < RESTORE_MIN)
5777 {
5778 log_error ("ERROR: Incompatible restore-file version");
5779
5780 return (-1);
5781 }
5782
5783 myargc = rd->argc;
5784 myargv = rd->argv;
5785
5786 #ifdef _POSIX
5787 rd->pid = getpid ();
5788 #elif _WIN
5789 rd->pid = GetCurrentProcessId ();
5790 #endif
5791 }
5792
5793 uint hash_mode_chgd = 0;
5794 uint runtime_chgd = 0;
5795 uint kernel_loops_chgd = 0;
5796 uint kernel_accel_chgd = 0;
5797 uint attack_mode_chgd = 0;
5798 uint outfile_format_chgd = 0;
5799 uint rp_gen_seed_chgd = 0;
5800 uint remove_timer_chgd = 0;
5801 uint increment_min_chgd = 0;
5802 uint increment_max_chgd = 0;
5803 uint workload_profile_chgd = 0;
5804 uint opencl_vector_width_chgd = 0;
5805
5806 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5807 uint gpu_temp_retain_chgd = 0;
5808 uint gpu_temp_abort_chgd = 0;
5809 #endif
5810
5811 optind = 1;
5812 optopt = 0;
5813 option_index = 0;
5814
5815 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5816 {
5817 switch (c)
5818 {
5819 //case IDX_HELP: usage = 1; break;
5820 //case IDX_VERSION: version = 1; break;
5821 //case IDX_RESTORE: restore = 1; break;
5822 case IDX_QUIET: quiet = 1; break;
5823 //case IDX_SHOW: show = 1; break;
5824 case IDX_SHOW: break;
5825 //case IDX_LEFT: left = 1; break;
5826 case IDX_LEFT: break;
5827 case IDX_USERNAME: username = 1; break;
5828 case IDX_REMOVE: remove = 1; break;
5829 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5830 remove_timer_chgd = 1; break;
5831 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5832 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5833 case IDX_DEBUG_FILE: debug_file = optarg; break;
5834 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5835 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5836 case IDX_FORCE: force = 1; break;
5837 case IDX_SKIP: skip = atoll (optarg); break;
5838 case IDX_LIMIT: limit = atoll (optarg); break;
5839 case IDX_KEYSPACE: keyspace = 1; break;
5840 case IDX_BENCHMARK: benchmark = 1; break;
5841 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5842 case IDX_RESTORE: break;
5843 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5844 case IDX_STATUS: status = 1; break;
5845 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5846 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5847 case IDX_LOOPBACK: loopback = 1; break;
5848 case IDX_WEAK_HASH_THRESHOLD:
5849 weak_hash_threshold = atoi (optarg); break;
5850 //case IDX_SESSION: session = optarg; break;
5851 case IDX_SESSION: break;
5852 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5853 hash_mode_chgd = 1; break;
5854 case IDX_RUNTIME: runtime = atoi (optarg);
5855 runtime_chgd = 1; break;
5856 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5857 attack_mode_chgd = 1; break;
5858 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5859 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5860 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5861 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5862 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5863 rp_gen_seed_chgd = 1; break;
5864 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5865 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5866 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5867 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5868 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5869 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5870 case IDX_OUTFILE: outfile = optarg; break;
5871 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5872 outfile_format_chgd = 1; break;
5873 case IDX_OUTFILE_AUTOHEX_DISABLE:
5874 outfile_autohex = 0; break;
5875 case IDX_OUTFILE_CHECK_TIMER:
5876 outfile_check_timer = atoi (optarg); break;
5877 case IDX_HEX_CHARSET: hex_charset = 1; break;
5878 case IDX_HEX_SALT: hex_salt = 1; break;
5879 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5880 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5881 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5882 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5883 case IDX_OPENCL_DEVICE_TYPES:
5884 opencl_device_types = optarg; break;
5885 case IDX_OPENCL_VECTOR_WIDTH:
5886 opencl_vector_width = atoi (optarg);
5887 opencl_vector_width_chgd = 1; break;
5888 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5889 workload_profile_chgd = 1; break;
5890 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5891 kernel_accel_chgd = 1; break;
5892 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5893 kernel_loops_chgd = 1; break;
5894 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5895 #ifdef HAVE_HWMON
5896 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5897 #ifdef HAVE_ADL
5898 gpu_temp_abort_chgd = 1;
5899 #endif
5900 break;
5901 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5902 #ifdef HAVE_ADL
5903 gpu_temp_retain_chgd = 1;
5904 #endif
5905 break;
5906 #ifdef HAVE_ADL
5907 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5908 #endif
5909 #endif // HAVE_HWMON
5910 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5911 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5912 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5913 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5914 case IDX_SEPARATOR: separator = optarg[0]; break;
5915 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5916 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5917 case IDX_INCREMENT: increment = 1; break;
5918 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5919 increment_min_chgd = 1; break;
5920 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5921 increment_max_chgd = 1; break;
5922 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5923 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5924 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5925 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5926
5927 default:
5928 log_error ("ERROR: Invalid argument specified");
5929 return (-1);
5930 }
5931 }
5932
5933 if (optopt != 0)
5934 {
5935 log_error ("ERROR: Invalid argument specified");
5936
5937 return (-1);
5938 }
5939
5940 /**
5941 * Inform user things getting started,
5942 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5943 * - we do not need to check algorithm_pos
5944 */
5945
5946 if (quiet == 0)
5947 {
5948 if (benchmark == 1)
5949 {
5950 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5951
5952 log_info ("");
5953 }
5954 else if (restore == 1)
5955 {
5956 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5957
5958 log_info ("");
5959 }
5960 else
5961 {
5962 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5963
5964 log_info ("");
5965 }
5966 }
5967
5968 /**
5969 * sanity check
5970 */
5971
5972 if (attack_mode > 7)
5973 {
5974 log_error ("ERROR: Invalid attack-mode specified");
5975
5976 return (-1);
5977 }
5978
5979 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5980 {
5981 log_error ("ERROR: Invalid runtime specified");
5982
5983 return (-1);
5984 }
5985
5986 if (hash_mode_chgd && hash_mode > 13400) // just added to remove compiler warnings for hash_mode_chgd
5987 {
5988 log_error ("ERROR: Invalid hash-type specified");
5989
5990 return (-1);
5991 }
5992
5993 // renamed hash modes
5994
5995 if (hash_mode_chgd)
5996 {
5997 int n = -1;
5998
5999 switch (hash_mode)
6000 {
6001 case 123: n = 124;
6002 break;
6003 }
6004
6005 if (n >= 0)
6006 {
6007 log_error ("Old -m specified, use -m %d instead", n);
6008
6009 return (-1);
6010 }
6011 }
6012
6013 if (username == 1)
6014 {
6015 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6016 {
6017 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6018
6019 return (-1);
6020 }
6021 }
6022
6023 if (outfile_format > 16)
6024 {
6025 log_error ("ERROR: Invalid outfile-format specified");
6026
6027 return (-1);
6028 }
6029
6030 if (left == 1)
6031 {
6032 if (outfile_format_chgd == 1)
6033 {
6034 if (outfile_format > 1)
6035 {
6036 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6037
6038 return (-1);
6039 }
6040 }
6041 else
6042 {
6043 outfile_format = OUTFILE_FMT_HASH;
6044 }
6045 }
6046
6047 if (show == 1)
6048 {
6049 if (outfile_format_chgd == 1)
6050 {
6051 if ((outfile_format > 7) && (outfile_format < 16))
6052 {
6053 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6054
6055 return (-1);
6056 }
6057 }
6058 }
6059
6060 if (increment_min < INCREMENT_MIN)
6061 {
6062 log_error ("ERROR: Invalid increment-min specified");
6063
6064 return (-1);
6065 }
6066
6067 if (increment_max > INCREMENT_MAX)
6068 {
6069 log_error ("ERROR: Invalid increment-max specified");
6070
6071 return (-1);
6072 }
6073
6074 if (increment_min > increment_max)
6075 {
6076 log_error ("ERROR: Invalid increment-min specified");
6077
6078 return (-1);
6079 }
6080
6081 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6082 {
6083 log_error ("ERROR: increment is not allowed in attack-mode 0");
6084
6085 return (-1);
6086 }
6087
6088 if ((increment == 0) && (increment_min_chgd == 1))
6089 {
6090 log_error ("ERROR: increment-min is only supported together with increment switch");
6091
6092 return (-1);
6093 }
6094
6095 if ((increment == 0) && (increment_max_chgd == 1))
6096 {
6097 log_error ("ERROR: increment-max is only supported together with increment switch");
6098
6099 return (-1);
6100 }
6101
6102 if (rp_files_cnt && rp_gen)
6103 {
6104 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6105
6106 return (-1);
6107 }
6108
6109 if (rp_files_cnt || rp_gen)
6110 {
6111 if (attack_mode != ATTACK_MODE_STRAIGHT)
6112 {
6113 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6114
6115 return (-1);
6116 }
6117 }
6118
6119 if (rp_gen_func_min > rp_gen_func_max)
6120 {
6121 log_error ("ERROR: Invalid rp-gen-func-min specified");
6122
6123 return (-1);
6124 }
6125
6126 if (kernel_accel_chgd == 1)
6127 {
6128 if (kernel_accel < 1)
6129 {
6130 log_error ("ERROR: Invalid kernel-accel specified");
6131
6132 return (-1);
6133 }
6134
6135 if (kernel_accel > 1024)
6136 {
6137 log_error ("ERROR: Invalid kernel-accel specified");
6138
6139 return (-1);
6140 }
6141 }
6142
6143 if (kernel_loops_chgd == 1)
6144 {
6145 if (kernel_loops < 1)
6146 {
6147 log_error ("ERROR: Invalid kernel-loops specified");
6148
6149 return (-1);
6150 }
6151
6152 if (kernel_loops > 1024)
6153 {
6154 log_error ("ERROR: Invalid kernel-loops specified");
6155
6156 return (-1);
6157 }
6158 }
6159
6160 if ((workload_profile < 1) || (workload_profile > 3))
6161 {
6162 log_error ("ERROR: workload-profile %i not available", workload_profile);
6163
6164 return (-1);
6165 }
6166
6167 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6168 {
6169 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6170
6171 return (-1);
6172 }
6173
6174 if (show == 1 || left == 1)
6175 {
6176 attack_mode = ATTACK_MODE_NONE;
6177
6178 if (remove == 1)
6179 {
6180 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6181
6182 return (-1);
6183 }
6184
6185 if (potfile_disable == 1)
6186 {
6187 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6188
6189 return (-1);
6190 }
6191 }
6192
6193 uint attack_kern = ATTACK_KERN_NONE;
6194
6195 switch (attack_mode)
6196 {
6197 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6198 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6199 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6200 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6201 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6202 }
6203
6204 if (benchmark == 0)
6205 {
6206 if (keyspace == 1)
6207 {
6208 int num_additional_params = 1;
6209
6210 if (attack_kern == ATTACK_KERN_COMBI)
6211 {
6212 num_additional_params = 2;
6213 }
6214
6215 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6216
6217 if (keyspace_wordlist_specified == 0) optind--;
6218 }
6219
6220 if (attack_kern == ATTACK_KERN_NONE)
6221 {
6222 if ((optind + 1) != myargc)
6223 {
6224 usage_mini_print (myargv[0]);
6225
6226 return (-1);
6227 }
6228 }
6229 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6230 {
6231 if ((optind + 1) > myargc)
6232 {
6233 usage_mini_print (myargv[0]);
6234
6235 return (-1);
6236 }
6237 }
6238 else if (attack_kern == ATTACK_KERN_COMBI)
6239 {
6240 if ((optind + 3) != myargc)
6241 {
6242 usage_mini_print (myargv[0]);
6243
6244 return (-1);
6245 }
6246 }
6247 else if (attack_kern == ATTACK_KERN_BF)
6248 {
6249 if ((optind + 1) > myargc)
6250 {
6251 usage_mini_print (myargv[0]);
6252
6253 return (-1);
6254 }
6255 }
6256 else
6257 {
6258 usage_mini_print (myargv[0]);
6259
6260 return (-1);
6261 }
6262 }
6263 else
6264 {
6265 if (myargv[optind] != 0)
6266 {
6267 log_error ("ERROR: Invalid argument for benchmark mode specified");
6268
6269 return (-1);
6270 }
6271
6272 if (attack_mode_chgd == 1)
6273 {
6274 if (attack_mode != ATTACK_MODE_BF)
6275 {
6276 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6277
6278 return (-1);
6279 }
6280 }
6281 }
6282
6283 if (skip != 0 && limit != 0)
6284 {
6285 limit += skip;
6286 }
6287
6288 if (keyspace == 1)
6289 {
6290 if (show == 1)
6291 {
6292 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6293
6294 return (-1);
6295 }
6296 else if (left == 1)
6297 {
6298 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6299
6300 return (-1);
6301 }
6302
6303 potfile_disable = 1;
6304
6305 restore_disable = 1;
6306
6307 restore = 0;
6308
6309 weak_hash_threshold = 0;
6310
6311 quiet = 1;
6312 }
6313
6314 if (remove_timer_chgd == 1)
6315 {
6316 if (remove == 0)
6317 {
6318 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6319
6320 return (-1);
6321 }
6322
6323 if (remove_timer < 1)
6324 {
6325 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6326
6327 return (-1);
6328 }
6329 }
6330
6331 if (loopback == 1)
6332 {
6333 if (attack_mode == ATTACK_MODE_BF)
6334 {
6335 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6336
6337 return (-1);
6338 }
6339 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6340 {
6341 if ((rp_files_cnt == 0) && (rp_gen == 0))
6342 {
6343 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6344
6345 return (-1);
6346 }
6347 }
6348 }
6349
6350 if (debug_mode > 0)
6351 {
6352 if (attack_mode != ATTACK_MODE_STRAIGHT)
6353 {
6354 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6355
6356 return (-1);
6357 }
6358
6359 if ((rp_files_cnt == 0) && (rp_gen == 0))
6360 {
6361 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6362
6363 return (-1);
6364 }
6365 }
6366
6367 if (debug_mode > 4)
6368 {
6369 log_error ("ERROR: Invalid debug-mode specified");
6370
6371 return (-1);
6372 }
6373
6374 if (debug_file != NULL)
6375 {
6376 if (debug_mode < 1)
6377 {
6378 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6379
6380 return (-1);
6381 }
6382 }
6383
6384 if (induction_dir != NULL)
6385 {
6386 if (attack_mode == ATTACK_MODE_BF)
6387 {
6388 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6389
6390 return (-1);
6391 }
6392 }
6393
6394 if (attack_mode != ATTACK_MODE_STRAIGHT)
6395 {
6396 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6397 {
6398 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6399
6400 return (-1);
6401 }
6402
6403 weak_hash_threshold = 0;
6404 }
6405
6406 /**
6407 * induction directory
6408 */
6409
6410 char *induction_directory = NULL;
6411
6412 if (attack_mode != ATTACK_MODE_BF)
6413 {
6414 if (induction_dir == NULL)
6415 {
6416 induction_directory = (char *) mymalloc (session_size);
6417
6418 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6419
6420 // create induction folder if it does not already exist
6421
6422 if (keyspace == 0)
6423 {
6424 if (rmdir (induction_directory) == -1)
6425 {
6426 if (errno == ENOENT)
6427 {
6428 // good, we can ignore
6429 }
6430 else if (errno == ENOTEMPTY)
6431 {
6432 char *induction_directory_mv = (char *) mymalloc (session_size);
6433
6434 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6435
6436 if (rename (induction_directory, induction_directory_mv) != 0)
6437 {
6438 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6439
6440 return (-1);
6441 }
6442 }
6443 else
6444 {
6445 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6446
6447 return (-1);
6448 }
6449 }
6450
6451 if (mkdir (induction_directory, 0700) == -1)
6452 {
6453 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6454
6455 return (-1);
6456 }
6457 }
6458 }
6459 else
6460 {
6461 induction_directory = induction_dir;
6462 }
6463 }
6464
6465 data.induction_directory = induction_directory;
6466
6467 /**
6468 * loopback
6469 */
6470
6471 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6472
6473 char *loopback_file = (char *) mymalloc (loopback_size);
6474
6475 /**
6476 * tuning db
6477 */
6478
6479 char tuning_db_file[256] = { 0 };
6480
6481 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6482
6483 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6484
6485 /**
6486 * outfile-check directory
6487 */
6488
6489 char *outfile_check_directory = NULL;
6490
6491 if (outfile_check_dir == NULL)
6492 {
6493 outfile_check_directory = (char *) mymalloc (session_size);
6494
6495 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6496 }
6497 else
6498 {
6499 outfile_check_directory = outfile_check_dir;
6500 }
6501
6502 data.outfile_check_directory = outfile_check_directory;
6503
6504 if (keyspace == 0)
6505 {
6506 struct stat outfile_check_stat;
6507
6508 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6509 {
6510 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6511
6512 if (is_dir == 0)
6513 {
6514 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6515
6516 return (-1);
6517 }
6518 }
6519 else if (outfile_check_dir == NULL)
6520 {
6521 if (mkdir (outfile_check_directory, 0700) == -1)
6522 {
6523 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6524
6525 return (-1);
6526 }
6527 }
6528 }
6529
6530 /**
6531 * special other stuff
6532 */
6533
6534 if (hash_mode == 9710)
6535 {
6536 outfile_format = 5;
6537 outfile_format_chgd = 1;
6538 }
6539
6540 if (hash_mode == 9810)
6541 {
6542 outfile_format = 5;
6543 outfile_format_chgd = 1;
6544 }
6545
6546 if (hash_mode == 10410)
6547 {
6548 outfile_format = 5;
6549 outfile_format_chgd = 1;
6550 }
6551
6552 /**
6553 * store stuff
6554 */
6555
6556 data.hash_mode = hash_mode;
6557 data.restore = restore;
6558 data.restore_timer = restore_timer;
6559 data.restore_disable = restore_disable;
6560 data.status = status;
6561 data.status_timer = status_timer;
6562 data.status_automat = status_automat;
6563 data.loopback = loopback;
6564 data.runtime = runtime;
6565 data.remove = remove;
6566 data.remove_timer = remove_timer;
6567 data.debug_mode = debug_mode;
6568 data.debug_file = debug_file;
6569 data.username = username;
6570 data.quiet = quiet;
6571 data.outfile = outfile;
6572 data.outfile_format = outfile_format;
6573 data.outfile_autohex = outfile_autohex;
6574 data.hex_charset = hex_charset;
6575 data.hex_salt = hex_salt;
6576 data.hex_wordlist = hex_wordlist;
6577 data.separator = separator;
6578 data.rp_files = rp_files;
6579 data.rp_files_cnt = rp_files_cnt;
6580 data.rp_gen = rp_gen;
6581 data.rp_gen_seed = rp_gen_seed;
6582 data.force = force;
6583 data.benchmark = benchmark;
6584 data.benchmark_repeats = benchmark_repeats;
6585 data.skip = skip;
6586 data.limit = limit;
6587 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6588 data.powertune_enable = powertune_enable;
6589 #endif
6590 data.logfile_disable = logfile_disable;
6591 data.truecrypt_keyfiles = truecrypt_keyfiles;
6592 data.scrypt_tmto = scrypt_tmto;
6593 data.workload_profile = workload_profile;
6594
6595 /**
6596 * cpu affinity
6597 */
6598
6599 if (cpu_affinity)
6600 {
6601 set_cpu_affinity (cpu_affinity);
6602 }
6603
6604 if (rp_gen_seed_chgd == 0)
6605 {
6606 srand (proc_start);
6607 }
6608 else
6609 {
6610 srand (rp_gen_seed);
6611 }
6612
6613 /**
6614 * logfile init
6615 */
6616
6617 if (logfile_disable == 0)
6618 {
6619 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6620
6621 char *logfile = (char *) mymalloc (logfile_size);
6622
6623 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6624
6625 data.logfile = logfile;
6626
6627 char *topid = logfile_generate_topid ();
6628
6629 data.topid = topid;
6630 }
6631
6632 // logfile_append() checks for logfile_disable internally to make it easier from here
6633
6634 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6635 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6636 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6637 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6638 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6639 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6640 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6641 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6643 #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));
6644
6645 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6646 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6647 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6648 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6649 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6650 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6651 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6652 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6653
6654 logfile_top_msg ("START");
6655
6656 logfile_top_uint (attack_mode);
6657 logfile_top_uint (attack_kern);
6658 logfile_top_uint (benchmark);
6659 logfile_top_uint (benchmark_repeats);
6660 logfile_top_uint (bitmap_min);
6661 logfile_top_uint (bitmap_max);
6662 logfile_top_uint (debug_mode);
6663 logfile_top_uint (force);
6664 logfile_top_uint (kernel_accel);
6665 logfile_top_uint (kernel_loops);
6666 logfile_top_uint (gpu_temp_disable);
6667 #ifdef HAVE_HWMON
6668 logfile_top_uint (gpu_temp_abort);
6669 logfile_top_uint (gpu_temp_retain);
6670 #endif
6671 logfile_top_uint (hash_mode);
6672 logfile_top_uint (hex_charset);
6673 logfile_top_uint (hex_salt);
6674 logfile_top_uint (hex_wordlist);
6675 logfile_top_uint (increment);
6676 logfile_top_uint (increment_max);
6677 logfile_top_uint (increment_min);
6678 logfile_top_uint (keyspace);
6679 logfile_top_uint (left);
6680 logfile_top_uint (logfile_disable);
6681 logfile_top_uint (loopback);
6682 logfile_top_uint (markov_classic);
6683 logfile_top_uint (markov_disable);
6684 logfile_top_uint (markov_threshold);
6685 logfile_top_uint (outfile_autohex);
6686 logfile_top_uint (outfile_check_timer);
6687 logfile_top_uint (outfile_format);
6688 logfile_top_uint (potfile_disable);
6689 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6690 logfile_top_uint (powertune_enable);
6691 #endif
6692 logfile_top_uint (scrypt_tmto);
6693 logfile_top_uint (quiet);
6694 logfile_top_uint (remove);
6695 logfile_top_uint (remove_timer);
6696 logfile_top_uint (restore);
6697 logfile_top_uint (restore_disable);
6698 logfile_top_uint (restore_timer);
6699 logfile_top_uint (rp_gen);
6700 logfile_top_uint (rp_gen_func_max);
6701 logfile_top_uint (rp_gen_func_min);
6702 logfile_top_uint (rp_gen_seed);
6703 logfile_top_uint (runtime);
6704 logfile_top_uint (segment_size);
6705 logfile_top_uint (show);
6706 logfile_top_uint (status);
6707 logfile_top_uint (status_automat);
6708 logfile_top_uint (status_timer);
6709 logfile_top_uint (usage);
6710 logfile_top_uint (username);
6711 logfile_top_uint (version);
6712 logfile_top_uint (weak_hash_threshold);
6713 logfile_top_uint (workload_profile);
6714 logfile_top_uint64 (limit);
6715 logfile_top_uint64 (skip);
6716 logfile_top_char (separator);
6717 logfile_top_string (cpu_affinity);
6718 logfile_top_string (custom_charset_1);
6719 logfile_top_string (custom_charset_2);
6720 logfile_top_string (custom_charset_3);
6721 logfile_top_string (custom_charset_4);
6722 logfile_top_string (debug_file);
6723 logfile_top_string (opencl_devices);
6724 logfile_top_string (opencl_platforms);
6725 logfile_top_string (opencl_device_types);
6726 logfile_top_uint (opencl_vector_width);
6727 logfile_top_string (induction_dir);
6728 logfile_top_string (markov_hcstat);
6729 logfile_top_string (outfile);
6730 logfile_top_string (outfile_check_dir);
6731 logfile_top_string (rule_buf_l);
6732 logfile_top_string (rule_buf_r);
6733 logfile_top_string (session);
6734 logfile_top_string (truecrypt_keyfiles);
6735
6736 /**
6737 * Init OpenCL library loader
6738 */
6739
6740 if (keyspace == 0)
6741 {
6742 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6743
6744 ocl_init (ocl);
6745
6746 data.ocl = ocl;
6747 }
6748
6749 /**
6750 * OpenCL platform selection
6751 */
6752
6753 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6754
6755 /**
6756 * OpenCL device selection
6757 */
6758
6759 u32 devices_filter = setup_devices_filter (opencl_devices);
6760
6761 /**
6762 * OpenCL device type selection
6763 */
6764
6765 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6766
6767 /**
6768 * benchmark
6769 */
6770
6771 if (benchmark == 1)
6772 {
6773 /**
6774 * disable useless stuff for benchmark
6775 */
6776
6777 status_timer = 0;
6778 restore_timer = 0;
6779 restore_disable = 1;
6780 potfile_disable = 1;
6781 weak_hash_threshold = 0;
6782 gpu_temp_disable = 1;
6783
6784 data.status_timer = status_timer;
6785 data.restore_timer = restore_timer;
6786 data.restore_disable = restore_disable;
6787
6788 /**
6789 * force attack mode to be bruteforce
6790 */
6791
6792 attack_mode = ATTACK_MODE_BF;
6793 attack_kern = ATTACK_KERN_BF;
6794
6795 if (workload_profile_chgd == 0)
6796 {
6797 workload_profile = 3;
6798
6799 data.workload_profile = workload_profile;
6800 }
6801 }
6802
6803 /**
6804 * config
6805 */
6806
6807 uint hash_type = 0;
6808 uint salt_type = 0;
6809 uint attack_exec = 0;
6810 uint opts_type = 0;
6811 uint kern_type = 0;
6812 uint dgst_size = 0;
6813 uint esalt_size = 0;
6814 uint opti_type = 0;
6815 uint dgst_pos0 = -1;
6816 uint dgst_pos1 = -1;
6817 uint dgst_pos2 = -1;
6818 uint dgst_pos3 = -1;
6819
6820 int (*parse_func) (char *, uint, hash_t *);
6821 int (*sort_by_digest) (const void *, const void *);
6822
6823 uint algorithm_pos = 0;
6824 uint algorithm_max = 1;
6825
6826 uint *algorithms = default_benchmark_algorithms;
6827
6828 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6829
6830 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6831 {
6832 /*
6833 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6834 * the following algos are skipped entirely
6835 */
6836
6837 if (algorithm_pos > 0)
6838 {
6839 local_free (rd);
6840
6841 rd = init_restore (argc, argv);
6842
6843 data.rd = rd;
6844 }
6845
6846 /**
6847 * update hash_mode in case of multihash benchmark
6848 */
6849
6850 if (benchmark == 1)
6851 {
6852 if (hash_mode_chgd == 0)
6853 {
6854 hash_mode = algorithms[algorithm_pos];
6855
6856 data.hash_mode = hash_mode;
6857 }
6858
6859 quiet = 1;
6860
6861 data.quiet = quiet;
6862 }
6863
6864 switch (hash_mode)
6865 {
6866 case 0: hash_type = HASH_TYPE_MD5;
6867 salt_type = SALT_TYPE_NONE;
6868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6869 opts_type = OPTS_TYPE_PT_GENERATE_LE
6870 | OPTS_TYPE_PT_ADD80
6871 | OPTS_TYPE_PT_ADDBITS14;
6872 kern_type = KERN_TYPE_MD5;
6873 dgst_size = DGST_SIZE_4_4;
6874 parse_func = md5_parse_hash;
6875 sort_by_digest = sort_by_digest_4_4;
6876 opti_type = OPTI_TYPE_ZERO_BYTE
6877 | OPTI_TYPE_PRECOMPUTE_INIT
6878 | OPTI_TYPE_PRECOMPUTE_MERKLE
6879 | OPTI_TYPE_MEET_IN_MIDDLE
6880 | OPTI_TYPE_EARLY_SKIP
6881 | OPTI_TYPE_NOT_ITERATED
6882 | OPTI_TYPE_NOT_SALTED
6883 | OPTI_TYPE_RAW_HASH;
6884 dgst_pos0 = 0;
6885 dgst_pos1 = 3;
6886 dgst_pos2 = 2;
6887 dgst_pos3 = 1;
6888 break;
6889
6890 case 10: hash_type = HASH_TYPE_MD5;
6891 salt_type = SALT_TYPE_INTERN;
6892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6893 opts_type = OPTS_TYPE_PT_GENERATE_LE
6894 | OPTS_TYPE_ST_ADD80
6895 | OPTS_TYPE_ST_ADDBITS14;
6896 kern_type = KERN_TYPE_MD5_PWSLT;
6897 dgst_size = DGST_SIZE_4_4;
6898 parse_func = md5s_parse_hash;
6899 sort_by_digest = sort_by_digest_4_4;
6900 opti_type = OPTI_TYPE_ZERO_BYTE
6901 | OPTI_TYPE_PRECOMPUTE_INIT
6902 | OPTI_TYPE_PRECOMPUTE_MERKLE
6903 | OPTI_TYPE_MEET_IN_MIDDLE
6904 | OPTI_TYPE_EARLY_SKIP
6905 | OPTI_TYPE_NOT_ITERATED
6906 | OPTI_TYPE_APPENDED_SALT
6907 | OPTI_TYPE_RAW_HASH;
6908 dgst_pos0 = 0;
6909 dgst_pos1 = 3;
6910 dgst_pos2 = 2;
6911 dgst_pos3 = 1;
6912 break;
6913
6914 case 11: hash_type = HASH_TYPE_MD5;
6915 salt_type = SALT_TYPE_INTERN;
6916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6917 opts_type = OPTS_TYPE_PT_GENERATE_LE
6918 | OPTS_TYPE_ST_ADD80
6919 | OPTS_TYPE_ST_ADDBITS14;
6920 kern_type = KERN_TYPE_MD5_PWSLT;
6921 dgst_size = DGST_SIZE_4_4;
6922 parse_func = joomla_parse_hash;
6923 sort_by_digest = sort_by_digest_4_4;
6924 opti_type = OPTI_TYPE_ZERO_BYTE
6925 | OPTI_TYPE_PRECOMPUTE_INIT
6926 | OPTI_TYPE_PRECOMPUTE_MERKLE
6927 | OPTI_TYPE_MEET_IN_MIDDLE
6928 | OPTI_TYPE_EARLY_SKIP
6929 | OPTI_TYPE_NOT_ITERATED
6930 | OPTI_TYPE_APPENDED_SALT
6931 | OPTI_TYPE_RAW_HASH;
6932 dgst_pos0 = 0;
6933 dgst_pos1 = 3;
6934 dgst_pos2 = 2;
6935 dgst_pos3 = 1;
6936 break;
6937
6938 case 12: hash_type = HASH_TYPE_MD5;
6939 salt_type = SALT_TYPE_INTERN;
6940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6941 opts_type = OPTS_TYPE_PT_GENERATE_LE
6942 | OPTS_TYPE_ST_ADD80
6943 | OPTS_TYPE_ST_ADDBITS14;
6944 kern_type = KERN_TYPE_MD5_PWSLT;
6945 dgst_size = DGST_SIZE_4_4;
6946 parse_func = postgresql_parse_hash;
6947 sort_by_digest = sort_by_digest_4_4;
6948 opti_type = OPTI_TYPE_ZERO_BYTE
6949 | OPTI_TYPE_PRECOMPUTE_INIT
6950 | OPTI_TYPE_PRECOMPUTE_MERKLE
6951 | OPTI_TYPE_MEET_IN_MIDDLE
6952 | OPTI_TYPE_EARLY_SKIP
6953 | OPTI_TYPE_NOT_ITERATED
6954 | OPTI_TYPE_APPENDED_SALT
6955 | OPTI_TYPE_RAW_HASH;
6956 dgst_pos0 = 0;
6957 dgst_pos1 = 3;
6958 dgst_pos2 = 2;
6959 dgst_pos3 = 1;
6960 break;
6961
6962 case 20: hash_type = HASH_TYPE_MD5;
6963 salt_type = SALT_TYPE_INTERN;
6964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6965 opts_type = OPTS_TYPE_PT_GENERATE_LE
6966 | OPTS_TYPE_PT_ADD80
6967 | OPTS_TYPE_PT_ADDBITS14;
6968 kern_type = KERN_TYPE_MD5_SLTPW;
6969 dgst_size = DGST_SIZE_4_4;
6970 parse_func = md5s_parse_hash;
6971 sort_by_digest = sort_by_digest_4_4;
6972 opti_type = OPTI_TYPE_ZERO_BYTE
6973 | OPTI_TYPE_PRECOMPUTE_INIT
6974 | OPTI_TYPE_PRECOMPUTE_MERKLE
6975 | OPTI_TYPE_EARLY_SKIP
6976 | OPTI_TYPE_NOT_ITERATED
6977 | OPTI_TYPE_PREPENDED_SALT
6978 | OPTI_TYPE_RAW_HASH;
6979 dgst_pos0 = 0;
6980 dgst_pos1 = 3;
6981 dgst_pos2 = 2;
6982 dgst_pos3 = 1;
6983 break;
6984
6985 case 21: hash_type = HASH_TYPE_MD5;
6986 salt_type = SALT_TYPE_INTERN;
6987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6988 opts_type = OPTS_TYPE_PT_GENERATE_LE
6989 | OPTS_TYPE_PT_ADD80
6990 | OPTS_TYPE_PT_ADDBITS14;
6991 kern_type = KERN_TYPE_MD5_SLTPW;
6992 dgst_size = DGST_SIZE_4_4;
6993 parse_func = osc_parse_hash;
6994 sort_by_digest = sort_by_digest_4_4;
6995 opti_type = OPTI_TYPE_ZERO_BYTE
6996 | OPTI_TYPE_PRECOMPUTE_INIT
6997 | OPTI_TYPE_PRECOMPUTE_MERKLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_PREPENDED_SALT
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 0;
7003 dgst_pos1 = 3;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 22: hash_type = HASH_TYPE_MD5;
7009 salt_type = SALT_TYPE_EMBEDDED;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_LE
7012 | OPTS_TYPE_PT_ADD80
7013 | OPTS_TYPE_PT_ADDBITS14;
7014 kern_type = KERN_TYPE_MD5_SLTPW;
7015 dgst_size = DGST_SIZE_4_4;
7016 parse_func = netscreen_parse_hash;
7017 sort_by_digest = sort_by_digest_4_4;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_PRECOMPUTE_INIT
7020 | OPTI_TYPE_PRECOMPUTE_MERKLE
7021 | OPTI_TYPE_EARLY_SKIP
7022 | OPTI_TYPE_NOT_ITERATED
7023 | OPTI_TYPE_PREPENDED_SALT
7024 | OPTI_TYPE_RAW_HASH;
7025 dgst_pos0 = 0;
7026 dgst_pos1 = 3;
7027 dgst_pos2 = 2;
7028 dgst_pos3 = 1;
7029 break;
7030
7031 case 23: hash_type = HASH_TYPE_MD5;
7032 salt_type = SALT_TYPE_EMBEDDED;
7033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7034 opts_type = OPTS_TYPE_PT_GENERATE_LE
7035 | OPTS_TYPE_PT_ADD80
7036 | OPTS_TYPE_PT_ADDBITS14;
7037 kern_type = KERN_TYPE_MD5_SLTPW;
7038 dgst_size = DGST_SIZE_4_4;
7039 parse_func = skype_parse_hash;
7040 sort_by_digest = sort_by_digest_4_4;
7041 opti_type = OPTI_TYPE_ZERO_BYTE
7042 | OPTI_TYPE_PRECOMPUTE_INIT
7043 | OPTI_TYPE_PRECOMPUTE_MERKLE
7044 | OPTI_TYPE_EARLY_SKIP
7045 | OPTI_TYPE_NOT_ITERATED
7046 | OPTI_TYPE_PREPENDED_SALT
7047 | OPTI_TYPE_RAW_HASH;
7048 dgst_pos0 = 0;
7049 dgst_pos1 = 3;
7050 dgst_pos2 = 2;
7051 dgst_pos3 = 1;
7052 break;
7053
7054 case 30: hash_type = HASH_TYPE_MD5;
7055 salt_type = SALT_TYPE_INTERN;
7056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7057 opts_type = OPTS_TYPE_PT_GENERATE_LE
7058 | OPTS_TYPE_PT_UNICODE
7059 | OPTS_TYPE_ST_ADD80
7060 | OPTS_TYPE_ST_ADDBITS14;
7061 kern_type = KERN_TYPE_MD5_PWUSLT;
7062 dgst_size = DGST_SIZE_4_4;
7063 parse_func = md5s_parse_hash;
7064 sort_by_digest = sort_by_digest_4_4;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_PRECOMPUTE_INIT
7067 | OPTI_TYPE_PRECOMPUTE_MERKLE
7068 | OPTI_TYPE_MEET_IN_MIDDLE
7069 | OPTI_TYPE_EARLY_SKIP
7070 | OPTI_TYPE_NOT_ITERATED
7071 | OPTI_TYPE_APPENDED_SALT
7072 | OPTI_TYPE_RAW_HASH;
7073 dgst_pos0 = 0;
7074 dgst_pos1 = 3;
7075 dgst_pos2 = 2;
7076 dgst_pos3 = 1;
7077 break;
7078
7079 case 40: hash_type = HASH_TYPE_MD5;
7080 salt_type = SALT_TYPE_INTERN;
7081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7082 opts_type = OPTS_TYPE_PT_GENERATE_LE
7083 | OPTS_TYPE_PT_ADD80
7084 | OPTS_TYPE_PT_ADDBITS14
7085 | OPTS_TYPE_PT_UNICODE;
7086 kern_type = KERN_TYPE_MD5_SLTPWU;
7087 dgst_size = DGST_SIZE_4_4;
7088 parse_func = md5s_parse_hash;
7089 sort_by_digest = sort_by_digest_4_4;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_PRECOMPUTE_INIT
7092 | OPTI_TYPE_PRECOMPUTE_MERKLE
7093 | OPTI_TYPE_EARLY_SKIP
7094 | OPTI_TYPE_NOT_ITERATED
7095 | OPTI_TYPE_PREPENDED_SALT
7096 | OPTI_TYPE_RAW_HASH;
7097 dgst_pos0 = 0;
7098 dgst_pos1 = 3;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 50: hash_type = HASH_TYPE_MD5;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_LE
7107 | OPTS_TYPE_ST_ADD80
7108 | OPTS_TYPE_ST_ADDBITS14;
7109 kern_type = KERN_TYPE_HMACMD5_PW;
7110 dgst_size = DGST_SIZE_4_4;
7111 parse_func = hmacmd5_parse_hash;
7112 sort_by_digest = sort_by_digest_4_4;
7113 opti_type = OPTI_TYPE_ZERO_BYTE
7114 | OPTI_TYPE_NOT_ITERATED;
7115 dgst_pos0 = 0;
7116 dgst_pos1 = 3;
7117 dgst_pos2 = 2;
7118 dgst_pos3 = 1;
7119 break;
7120
7121 case 60: hash_type = HASH_TYPE_MD5;
7122 salt_type = SALT_TYPE_INTERN;
7123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7124 opts_type = OPTS_TYPE_PT_GENERATE_LE
7125 | OPTS_TYPE_PT_ADD80
7126 | OPTS_TYPE_PT_ADDBITS14;
7127 kern_type = KERN_TYPE_HMACMD5_SLT;
7128 dgst_size = DGST_SIZE_4_4;
7129 parse_func = hmacmd5_parse_hash;
7130 sort_by_digest = sort_by_digest_4_4;
7131 opti_type = OPTI_TYPE_ZERO_BYTE
7132 | OPTI_TYPE_NOT_ITERATED;
7133 dgst_pos0 = 0;
7134 dgst_pos1 = 3;
7135 dgst_pos2 = 2;
7136 dgst_pos3 = 1;
7137 break;
7138
7139 case 100: hash_type = HASH_TYPE_SHA1;
7140 salt_type = SALT_TYPE_NONE;
7141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7142 opts_type = OPTS_TYPE_PT_GENERATE_BE
7143 | OPTS_TYPE_PT_ADD80
7144 | OPTS_TYPE_PT_ADDBITS15;
7145 kern_type = KERN_TYPE_SHA1;
7146 dgst_size = DGST_SIZE_4_5;
7147 parse_func = sha1_parse_hash;
7148 sort_by_digest = sort_by_digest_4_5;
7149 opti_type = OPTI_TYPE_ZERO_BYTE
7150 | OPTI_TYPE_PRECOMPUTE_INIT
7151 | OPTI_TYPE_PRECOMPUTE_MERKLE
7152 | OPTI_TYPE_EARLY_SKIP
7153 | OPTI_TYPE_NOT_ITERATED
7154 | OPTI_TYPE_NOT_SALTED
7155 | OPTI_TYPE_RAW_HASH;
7156 dgst_pos0 = 3;
7157 dgst_pos1 = 4;
7158 dgst_pos2 = 2;
7159 dgst_pos3 = 1;
7160 break;
7161
7162 case 101: hash_type = HASH_TYPE_SHA1;
7163 salt_type = SALT_TYPE_NONE;
7164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7165 opts_type = OPTS_TYPE_PT_GENERATE_BE
7166 | OPTS_TYPE_PT_ADD80
7167 | OPTS_TYPE_PT_ADDBITS15;
7168 kern_type = KERN_TYPE_SHA1;
7169 dgst_size = DGST_SIZE_4_5;
7170 parse_func = sha1b64_parse_hash;
7171 sort_by_digest = sort_by_digest_4_5;
7172 opti_type = OPTI_TYPE_ZERO_BYTE
7173 | OPTI_TYPE_PRECOMPUTE_INIT
7174 | OPTI_TYPE_PRECOMPUTE_MERKLE
7175 | OPTI_TYPE_EARLY_SKIP
7176 | OPTI_TYPE_NOT_ITERATED
7177 | OPTI_TYPE_NOT_SALTED
7178 | OPTI_TYPE_RAW_HASH;
7179 dgst_pos0 = 3;
7180 dgst_pos1 = 4;
7181 dgst_pos2 = 2;
7182 dgst_pos3 = 1;
7183 break;
7184
7185 case 110: hash_type = HASH_TYPE_SHA1;
7186 salt_type = SALT_TYPE_INTERN;
7187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7188 opts_type = OPTS_TYPE_PT_GENERATE_BE
7189 | OPTS_TYPE_ST_ADD80
7190 | OPTS_TYPE_ST_ADDBITS15;
7191 kern_type = KERN_TYPE_SHA1_PWSLT;
7192 dgst_size = DGST_SIZE_4_5;
7193 parse_func = sha1s_parse_hash;
7194 sort_by_digest = sort_by_digest_4_5;
7195 opti_type = OPTI_TYPE_ZERO_BYTE
7196 | OPTI_TYPE_PRECOMPUTE_INIT
7197 | OPTI_TYPE_PRECOMPUTE_MERKLE
7198 | OPTI_TYPE_EARLY_SKIP
7199 | OPTI_TYPE_NOT_ITERATED
7200 | OPTI_TYPE_APPENDED_SALT
7201 | OPTI_TYPE_RAW_HASH;
7202 dgst_pos0 = 3;
7203 dgst_pos1 = 4;
7204 dgst_pos2 = 2;
7205 dgst_pos3 = 1;
7206 break;
7207
7208 case 111: hash_type = HASH_TYPE_SHA1;
7209 salt_type = SALT_TYPE_EMBEDDED;
7210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7211 opts_type = OPTS_TYPE_PT_GENERATE_BE
7212 | OPTS_TYPE_ST_ADD80
7213 | OPTS_TYPE_ST_ADDBITS15;
7214 kern_type = KERN_TYPE_SHA1_PWSLT;
7215 dgst_size = DGST_SIZE_4_5;
7216 parse_func = sha1b64s_parse_hash;
7217 sort_by_digest = sort_by_digest_4_5;
7218 opti_type = OPTI_TYPE_ZERO_BYTE
7219 | OPTI_TYPE_PRECOMPUTE_INIT
7220 | OPTI_TYPE_PRECOMPUTE_MERKLE
7221 | OPTI_TYPE_EARLY_SKIP
7222 | OPTI_TYPE_NOT_ITERATED
7223 | OPTI_TYPE_APPENDED_SALT
7224 | OPTI_TYPE_RAW_HASH;
7225 dgst_pos0 = 3;
7226 dgst_pos1 = 4;
7227 dgst_pos2 = 2;
7228 dgst_pos3 = 1;
7229 break;
7230
7231 case 112: hash_type = HASH_TYPE_SHA1;
7232 salt_type = SALT_TYPE_INTERN;
7233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7234 opts_type = OPTS_TYPE_PT_GENERATE_BE
7235 | OPTS_TYPE_ST_ADD80
7236 | OPTS_TYPE_ST_ADDBITS15
7237 | OPTS_TYPE_ST_HEX;
7238 kern_type = KERN_TYPE_SHA1_PWSLT;
7239 dgst_size = DGST_SIZE_4_5;
7240 parse_func = oracles_parse_hash;
7241 sort_by_digest = sort_by_digest_4_5;
7242 opti_type = OPTI_TYPE_ZERO_BYTE
7243 | OPTI_TYPE_PRECOMPUTE_INIT
7244 | OPTI_TYPE_PRECOMPUTE_MERKLE
7245 | OPTI_TYPE_EARLY_SKIP
7246 | OPTI_TYPE_NOT_ITERATED
7247 | OPTI_TYPE_APPENDED_SALT
7248 | OPTI_TYPE_RAW_HASH;
7249 dgst_pos0 = 3;
7250 dgst_pos1 = 4;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 1;
7253 break;
7254
7255 case 120: hash_type = HASH_TYPE_SHA1;
7256 salt_type = SALT_TYPE_INTERN;
7257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_BE
7259 | OPTS_TYPE_PT_ADD80
7260 | OPTS_TYPE_PT_ADDBITS15;
7261 kern_type = KERN_TYPE_SHA1_SLTPW;
7262 dgst_size = DGST_SIZE_4_5;
7263 parse_func = sha1s_parse_hash;
7264 sort_by_digest = sort_by_digest_4_5;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 3;
7273 dgst_pos1 = 4;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 121: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_INTERN;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15
7284 | OPTS_TYPE_ST_LOWER;
7285 kern_type = KERN_TYPE_SHA1_SLTPW;
7286 dgst_size = DGST_SIZE_4_5;
7287 parse_func = smf_parse_hash;
7288 sort_by_digest = sort_by_digest_4_5;
7289 opti_type = OPTI_TYPE_ZERO_BYTE
7290 | OPTI_TYPE_PRECOMPUTE_INIT
7291 | OPTI_TYPE_PRECOMPUTE_MERKLE
7292 | OPTI_TYPE_EARLY_SKIP
7293 | OPTI_TYPE_NOT_ITERATED
7294 | OPTI_TYPE_PREPENDED_SALT
7295 | OPTI_TYPE_RAW_HASH;
7296 dgst_pos0 = 3;
7297 dgst_pos1 = 4;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 122: hash_type = HASH_TYPE_SHA1;
7303 salt_type = SALT_TYPE_EMBEDDED;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_BE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS15
7308 | OPTS_TYPE_ST_HEX;
7309 kern_type = KERN_TYPE_SHA1_SLTPW;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = osx1_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_PRECOMPUTE_MERKLE
7316 | OPTI_TYPE_EARLY_SKIP
7317 | OPTI_TYPE_NOT_ITERATED
7318 | OPTI_TYPE_PREPENDED_SALT
7319 | OPTI_TYPE_RAW_HASH;
7320 dgst_pos0 = 3;
7321 dgst_pos1 = 4;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 124: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_EMBEDDED;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_ADD80
7331 | OPTS_TYPE_PT_ADDBITS15;
7332 kern_type = KERN_TYPE_SHA1_SLTPW;
7333 dgst_size = DGST_SIZE_4_5;
7334 parse_func = djangosha1_parse_hash;
7335 sort_by_digest = sort_by_digest_4_5;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_PREPENDED_SALT
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 4;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 1;
7347 break;
7348
7349 case 130: hash_type = HASH_TYPE_SHA1;
7350 salt_type = SALT_TYPE_INTERN;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_PT_UNICODE
7354 | OPTS_TYPE_ST_ADD80
7355 | OPTS_TYPE_ST_ADDBITS15;
7356 kern_type = KERN_TYPE_SHA1_PWUSLT;
7357 dgst_size = DGST_SIZE_4_5;
7358 parse_func = sha1s_parse_hash;
7359 sort_by_digest = sort_by_digest_4_5;
7360 opti_type = OPTI_TYPE_ZERO_BYTE
7361 | OPTI_TYPE_PRECOMPUTE_INIT
7362 | OPTI_TYPE_PRECOMPUTE_MERKLE
7363 | OPTI_TYPE_EARLY_SKIP
7364 | OPTI_TYPE_NOT_ITERATED
7365 | OPTI_TYPE_APPENDED_SALT
7366 | OPTI_TYPE_RAW_HASH;
7367 dgst_pos0 = 3;
7368 dgst_pos1 = 4;
7369 dgst_pos2 = 2;
7370 dgst_pos3 = 1;
7371 break;
7372
7373 case 131: hash_type = HASH_TYPE_SHA1;
7374 salt_type = SALT_TYPE_EMBEDDED;
7375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7376 opts_type = OPTS_TYPE_PT_GENERATE_BE
7377 | OPTS_TYPE_PT_UNICODE
7378 | OPTS_TYPE_PT_UPPER
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS15
7381 | OPTS_TYPE_ST_HEX;
7382 kern_type = KERN_TYPE_SHA1_PWUSLT;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = mssql2000_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 132: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_EMBEDDED;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_UNICODE
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15
7406 | OPTS_TYPE_ST_HEX;
7407 kern_type = KERN_TYPE_SHA1_PWUSLT;
7408 dgst_size = DGST_SIZE_4_5;
7409 parse_func = mssql2005_parse_hash;
7410 sort_by_digest = sort_by_digest_4_5;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_EARLY_SKIP
7415 | OPTI_TYPE_NOT_ITERATED
7416 | OPTI_TYPE_APPENDED_SALT
7417 | OPTI_TYPE_RAW_HASH;
7418 dgst_pos0 = 3;
7419 dgst_pos1 = 4;
7420 dgst_pos2 = 2;
7421 dgst_pos3 = 1;
7422 break;
7423
7424 case 133: hash_type = HASH_TYPE_SHA1;
7425 salt_type = SALT_TYPE_EMBEDDED;
7426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7427 opts_type = OPTS_TYPE_PT_GENERATE_BE
7428 | OPTS_TYPE_PT_UNICODE
7429 | OPTS_TYPE_ST_ADD80
7430 | OPTS_TYPE_ST_ADDBITS15;
7431 kern_type = KERN_TYPE_SHA1_PWUSLT;
7432 dgst_size = DGST_SIZE_4_5;
7433 parse_func = peoplesoft_parse_hash;
7434 sort_by_digest = sort_by_digest_4_5;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_APPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 3;
7443 dgst_pos1 = 4;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 140: hash_type = HASH_TYPE_SHA1;
7449 salt_type = SALT_TYPE_INTERN;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_BE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS15
7454 | OPTS_TYPE_PT_UNICODE;
7455 kern_type = KERN_TYPE_SHA1_SLTPWU;
7456 dgst_size = DGST_SIZE_4_5;
7457 parse_func = sha1s_parse_hash;
7458 sort_by_digest = sort_by_digest_4_5;
7459 opti_type = OPTI_TYPE_ZERO_BYTE
7460 | OPTI_TYPE_PRECOMPUTE_INIT
7461 | OPTI_TYPE_PRECOMPUTE_MERKLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_PREPENDED_SALT
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 3;
7467 dgst_pos1 = 4;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 141: hash_type = HASH_TYPE_SHA1;
7473 salt_type = SALT_TYPE_EMBEDDED;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_BE
7476 | OPTS_TYPE_PT_ADD80
7477 | OPTS_TYPE_PT_ADDBITS15
7478 | OPTS_TYPE_PT_UNICODE
7479 | OPTS_TYPE_ST_BASE64;
7480 kern_type = KERN_TYPE_SHA1_SLTPWU;
7481 dgst_size = DGST_SIZE_4_5;
7482 parse_func = episerver_parse_hash;
7483 sort_by_digest = sort_by_digest_4_5;
7484 opti_type = OPTI_TYPE_ZERO_BYTE
7485 | OPTI_TYPE_PRECOMPUTE_INIT
7486 | OPTI_TYPE_PRECOMPUTE_MERKLE
7487 | OPTI_TYPE_EARLY_SKIP
7488 | OPTI_TYPE_NOT_ITERATED
7489 | OPTI_TYPE_PREPENDED_SALT
7490 | OPTI_TYPE_RAW_HASH;
7491 dgst_pos0 = 3;
7492 dgst_pos1 = 4;
7493 dgst_pos2 = 2;
7494 dgst_pos3 = 1;
7495 break;
7496
7497 case 150: hash_type = HASH_TYPE_SHA1;
7498 salt_type = SALT_TYPE_INTERN;
7499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7500 opts_type = OPTS_TYPE_PT_GENERATE_BE
7501 | OPTS_TYPE_ST_ADD80
7502 | OPTS_TYPE_ST_ADDBITS15;
7503 kern_type = KERN_TYPE_HMACSHA1_PW;
7504 dgst_size = DGST_SIZE_4_5;
7505 parse_func = hmacsha1_parse_hash;
7506 sort_by_digest = sort_by_digest_4_5;
7507 opti_type = OPTI_TYPE_ZERO_BYTE
7508 | OPTI_TYPE_NOT_ITERATED;
7509 dgst_pos0 = 3;
7510 dgst_pos1 = 4;
7511 dgst_pos2 = 2;
7512 dgst_pos3 = 1;
7513 break;
7514
7515 case 160: hash_type = HASH_TYPE_SHA1;
7516 salt_type = SALT_TYPE_INTERN;
7517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7518 opts_type = OPTS_TYPE_PT_GENERATE_BE
7519 | OPTS_TYPE_PT_ADD80
7520 | OPTS_TYPE_PT_ADDBITS15;
7521 kern_type = KERN_TYPE_HMACSHA1_SLT;
7522 dgst_size = DGST_SIZE_4_5;
7523 parse_func = hmacsha1_parse_hash;
7524 sort_by_digest = sort_by_digest_4_5;
7525 opti_type = OPTI_TYPE_ZERO_BYTE
7526 | OPTI_TYPE_NOT_ITERATED;
7527 dgst_pos0 = 3;
7528 dgst_pos1 = 4;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 1;
7531 break;
7532
7533 case 190: hash_type = HASH_TYPE_SHA1;
7534 salt_type = SALT_TYPE_NONE;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_BE
7537 | OPTS_TYPE_PT_ADD80
7538 | OPTS_TYPE_PT_ADDBITS15;
7539 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7540 dgst_size = DGST_SIZE_4_5;
7541 parse_func = sha1linkedin_parse_hash;
7542 sort_by_digest = sort_by_digest_4_5;
7543 opti_type = OPTI_TYPE_ZERO_BYTE
7544 | OPTI_TYPE_PRECOMPUTE_INIT
7545 | OPTI_TYPE_EARLY_SKIP
7546 | OPTI_TYPE_NOT_ITERATED
7547 | OPTI_TYPE_NOT_SALTED;
7548 dgst_pos0 = 0;
7549 dgst_pos1 = 4;
7550 dgst_pos2 = 3;
7551 dgst_pos3 = 2;
7552 break;
7553
7554 case 200: hash_type = HASH_TYPE_MYSQL;
7555 salt_type = SALT_TYPE_NONE;
7556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7557 opts_type = 0;
7558 kern_type = KERN_TYPE_MYSQL;
7559 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7560 parse_func = mysql323_parse_hash;
7561 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7562 opti_type = OPTI_TYPE_ZERO_BYTE;
7563 dgst_pos0 = 0;
7564 dgst_pos1 = 1;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 3;
7567 break;
7568
7569 case 300: hash_type = HASH_TYPE_SHA1;
7570 salt_type = SALT_TYPE_NONE;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_BE
7573 | OPTS_TYPE_PT_ADD80
7574 | OPTS_TYPE_PT_ADDBITS15;
7575 kern_type = KERN_TYPE_MYSQL41;
7576 dgst_size = DGST_SIZE_4_5;
7577 parse_func = sha1_parse_hash;
7578 sort_by_digest = sort_by_digest_4_5;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_NOT_SALTED;
7585 dgst_pos0 = 3;
7586 dgst_pos1 = 4;
7587 dgst_pos2 = 2;
7588 dgst_pos3 = 1;
7589 break;
7590
7591 case 400: hash_type = HASH_TYPE_MD5;
7592 salt_type = SALT_TYPE_EMBEDDED;
7593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7595 kern_type = KERN_TYPE_PHPASS;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = phpass_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE;
7600 dgst_pos0 = 0;
7601 dgst_pos1 = 1;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 3;
7604 break;
7605
7606 case 500: hash_type = HASH_TYPE_MD5;
7607 salt_type = SALT_TYPE_EMBEDDED;
7608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7610 kern_type = KERN_TYPE_MD5CRYPT;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = md5crypt_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE;
7615 dgst_pos0 = 0;
7616 dgst_pos1 = 1;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 3;
7619 break;
7620
7621 case 501: hash_type = HASH_TYPE_MD5;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE
7625 | OPTS_TYPE_HASH_COPY;
7626 kern_type = KERN_TYPE_MD5CRYPT;
7627 dgst_size = DGST_SIZE_4_4;
7628 parse_func = juniper_parse_hash;
7629 sort_by_digest = sort_by_digest_4_4;
7630 opti_type = OPTI_TYPE_ZERO_BYTE;
7631 dgst_pos0 = 0;
7632 dgst_pos1 = 1;
7633 dgst_pos2 = 2;
7634 dgst_pos3 = 3;
7635 break;
7636
7637 case 900: hash_type = HASH_TYPE_MD4;
7638 salt_type = SALT_TYPE_NONE;
7639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7640 opts_type = OPTS_TYPE_PT_GENERATE_LE
7641 | OPTS_TYPE_PT_ADD80
7642 | OPTS_TYPE_PT_ADDBITS14;
7643 kern_type = KERN_TYPE_MD4;
7644 dgst_size = DGST_SIZE_4_4;
7645 parse_func = md4_parse_hash;
7646 sort_by_digest = sort_by_digest_4_4;
7647 opti_type = OPTI_TYPE_ZERO_BYTE
7648 | OPTI_TYPE_PRECOMPUTE_INIT
7649 | OPTI_TYPE_PRECOMPUTE_MERKLE
7650 | OPTI_TYPE_MEET_IN_MIDDLE
7651 | OPTI_TYPE_EARLY_SKIP
7652 | OPTI_TYPE_NOT_ITERATED
7653 | OPTI_TYPE_NOT_SALTED
7654 | OPTI_TYPE_RAW_HASH;
7655 dgst_pos0 = 0;
7656 dgst_pos1 = 3;
7657 dgst_pos2 = 2;
7658 dgst_pos3 = 1;
7659 break;
7660
7661 case 1000: hash_type = HASH_TYPE_MD4;
7662 salt_type = SALT_TYPE_NONE;
7663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7664 opts_type = OPTS_TYPE_PT_GENERATE_LE
7665 | OPTS_TYPE_PT_ADD80
7666 | OPTS_TYPE_PT_ADDBITS14
7667 | OPTS_TYPE_PT_UNICODE;
7668 kern_type = KERN_TYPE_MD4_PWU;
7669 dgst_size = DGST_SIZE_4_4;
7670 parse_func = md4_parse_hash;
7671 sort_by_digest = sort_by_digest_4_4;
7672 opti_type = OPTI_TYPE_ZERO_BYTE
7673 | OPTI_TYPE_PRECOMPUTE_INIT
7674 | OPTI_TYPE_PRECOMPUTE_MERKLE
7675 | OPTI_TYPE_MEET_IN_MIDDLE
7676 | OPTI_TYPE_EARLY_SKIP
7677 | OPTI_TYPE_NOT_ITERATED
7678 | OPTI_TYPE_NOT_SALTED
7679 | OPTI_TYPE_RAW_HASH;
7680 dgst_pos0 = 0;
7681 dgst_pos1 = 3;
7682 dgst_pos2 = 2;
7683 dgst_pos3 = 1;
7684 break;
7685
7686 case 1100: hash_type = HASH_TYPE_MD4;
7687 salt_type = SALT_TYPE_INTERN;
7688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7689 opts_type = OPTS_TYPE_PT_GENERATE_LE
7690 | OPTS_TYPE_PT_ADD80
7691 | OPTS_TYPE_PT_ADDBITS14
7692 | OPTS_TYPE_PT_UNICODE
7693 | OPTS_TYPE_ST_ADD80
7694 | OPTS_TYPE_ST_UNICODE
7695 | OPTS_TYPE_ST_LOWER;
7696 kern_type = KERN_TYPE_MD44_PWUSLT;
7697 dgst_size = DGST_SIZE_4_4;
7698 parse_func = dcc_parse_hash;
7699 sort_by_digest = sort_by_digest_4_4;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED;
7705 dgst_pos0 = 0;
7706 dgst_pos1 = 3;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 1;
7709 break;
7710
7711 case 1400: hash_type = HASH_TYPE_SHA256;
7712 salt_type = SALT_TYPE_NONE;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_SHA256;
7718 dgst_size = DGST_SIZE_4_8;
7719 parse_func = sha256_parse_hash;
7720 sort_by_digest = sort_by_digest_4_8;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_PRECOMPUTE_INIT
7723 | OPTI_TYPE_PRECOMPUTE_MERKLE
7724 | OPTI_TYPE_EARLY_SKIP
7725 | OPTI_TYPE_NOT_ITERATED
7726 | OPTI_TYPE_NOT_SALTED
7727 | OPTI_TYPE_RAW_HASH;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 7;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 6;
7732 break;
7733
7734 case 1410: hash_type = HASH_TYPE_SHA256;
7735 salt_type = SALT_TYPE_INTERN;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_BE
7738 | OPTS_TYPE_ST_ADD80
7739 | OPTS_TYPE_ST_ADDBITS15;
7740 kern_type = KERN_TYPE_SHA256_PWSLT;
7741 dgst_size = DGST_SIZE_4_8;
7742 parse_func = sha256s_parse_hash;
7743 sort_by_digest = sort_by_digest_4_8;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_PRECOMPUTE_INIT
7746 | OPTI_TYPE_PRECOMPUTE_MERKLE
7747 | OPTI_TYPE_EARLY_SKIP
7748 | OPTI_TYPE_NOT_ITERATED
7749 | OPTI_TYPE_APPENDED_SALT
7750 | OPTI_TYPE_RAW_HASH;
7751 dgst_pos0 = 3;
7752 dgst_pos1 = 7;
7753 dgst_pos2 = 2;
7754 dgst_pos3 = 6;
7755 break;
7756
7757 case 1420: hash_type = HASH_TYPE_SHA256;
7758 salt_type = SALT_TYPE_INTERN;
7759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7760 opts_type = OPTS_TYPE_PT_GENERATE_BE
7761 | OPTS_TYPE_PT_ADD80
7762 | OPTS_TYPE_PT_ADDBITS15;
7763 kern_type = KERN_TYPE_SHA256_SLTPW;
7764 dgst_size = DGST_SIZE_4_8;
7765 parse_func = sha256s_parse_hash;
7766 sort_by_digest = sort_by_digest_4_8;
7767 opti_type = OPTI_TYPE_ZERO_BYTE
7768 | OPTI_TYPE_PRECOMPUTE_INIT
7769 | OPTI_TYPE_PRECOMPUTE_MERKLE
7770 | OPTI_TYPE_EARLY_SKIP
7771 | OPTI_TYPE_NOT_ITERATED
7772 | OPTI_TYPE_PREPENDED_SALT
7773 | OPTI_TYPE_RAW_HASH;
7774 dgst_pos0 = 3;
7775 dgst_pos1 = 7;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 6;
7778 break;
7779
7780 case 1421: hash_type = HASH_TYPE_SHA256;
7781 salt_type = SALT_TYPE_EMBEDDED;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_BE
7784 | OPTS_TYPE_PT_ADD80
7785 | OPTS_TYPE_PT_ADDBITS15;
7786 kern_type = KERN_TYPE_SHA256_SLTPW;
7787 dgst_size = DGST_SIZE_4_8;
7788 parse_func = hmailserver_parse_hash;
7789 sort_by_digest = sort_by_digest_4_8;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_PREPENDED_SALT
7796 | OPTI_TYPE_RAW_HASH;
7797 dgst_pos0 = 3;
7798 dgst_pos1 = 7;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 6;
7801 break;
7802
7803 case 1430: hash_type = HASH_TYPE_SHA256;
7804 salt_type = SALT_TYPE_INTERN;
7805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_BE
7807 | OPTS_TYPE_PT_UNICODE
7808 | OPTS_TYPE_ST_ADD80
7809 | OPTS_TYPE_ST_ADDBITS15;
7810 kern_type = KERN_TYPE_SHA256_PWUSLT;
7811 dgst_size = DGST_SIZE_4_8;
7812 parse_func = sha256s_parse_hash;
7813 sort_by_digest = sort_by_digest_4_8;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_EARLY_SKIP
7818 | OPTI_TYPE_NOT_ITERATED
7819 | OPTI_TYPE_APPENDED_SALT
7820 | OPTI_TYPE_RAW_HASH;
7821 dgst_pos0 = 3;
7822 dgst_pos1 = 7;
7823 dgst_pos2 = 2;
7824 dgst_pos3 = 6;
7825 break;
7826
7827 case 1440: hash_type = HASH_TYPE_SHA256;
7828 salt_type = SALT_TYPE_INTERN;
7829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7830 opts_type = OPTS_TYPE_PT_GENERATE_BE
7831 | OPTS_TYPE_PT_ADD80
7832 | OPTS_TYPE_PT_ADDBITS15
7833 | OPTS_TYPE_PT_UNICODE;
7834 kern_type = KERN_TYPE_SHA256_SLTPWU;
7835 dgst_size = DGST_SIZE_4_8;
7836 parse_func = sha256s_parse_hash;
7837 sort_by_digest = sort_by_digest_4_8;
7838 opti_type = OPTI_TYPE_ZERO_BYTE
7839 | OPTI_TYPE_PRECOMPUTE_INIT
7840 | OPTI_TYPE_PRECOMPUTE_MERKLE
7841 | OPTI_TYPE_EARLY_SKIP
7842 | OPTI_TYPE_NOT_ITERATED
7843 | OPTI_TYPE_PREPENDED_SALT
7844 | OPTI_TYPE_RAW_HASH;
7845 dgst_pos0 = 3;
7846 dgst_pos1 = 7;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 6;
7849 break;
7850
7851 case 1441: hash_type = HASH_TYPE_SHA256;
7852 salt_type = SALT_TYPE_EMBEDDED;
7853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_BE
7855 | OPTS_TYPE_PT_ADD80
7856 | OPTS_TYPE_PT_ADDBITS15
7857 | OPTS_TYPE_PT_UNICODE
7858 | OPTS_TYPE_ST_BASE64;
7859 kern_type = KERN_TYPE_SHA256_SLTPWU;
7860 dgst_size = DGST_SIZE_4_8;
7861 parse_func = episerver4_parse_hash;
7862 sort_by_digest = sort_by_digest_4_8;
7863 opti_type = OPTI_TYPE_ZERO_BYTE
7864 | OPTI_TYPE_PRECOMPUTE_INIT
7865 | OPTI_TYPE_PRECOMPUTE_MERKLE
7866 | OPTI_TYPE_EARLY_SKIP
7867 | OPTI_TYPE_NOT_ITERATED
7868 | OPTI_TYPE_PREPENDED_SALT
7869 | OPTI_TYPE_RAW_HASH;
7870 dgst_pos0 = 3;
7871 dgst_pos1 = 7;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 6;
7874 break;
7875
7876 case 1450: hash_type = HASH_TYPE_SHA256;
7877 salt_type = SALT_TYPE_INTERN;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_ST_ADD80;
7881 kern_type = KERN_TYPE_HMACSHA256_PW;
7882 dgst_size = DGST_SIZE_4_8;
7883 parse_func = hmacsha256_parse_hash;
7884 sort_by_digest = sort_by_digest_4_8;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_NOT_ITERATED;
7887 dgst_pos0 = 3;
7888 dgst_pos1 = 7;
7889 dgst_pos2 = 2;
7890 dgst_pos3 = 6;
7891 break;
7892
7893 case 1460: hash_type = HASH_TYPE_SHA256;
7894 salt_type = SALT_TYPE_INTERN;
7895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7896 opts_type = OPTS_TYPE_PT_GENERATE_BE
7897 | OPTS_TYPE_PT_ADD80
7898 | OPTS_TYPE_PT_ADDBITS15;
7899 kern_type = KERN_TYPE_HMACSHA256_SLT;
7900 dgst_size = DGST_SIZE_4_8;
7901 parse_func = hmacsha256_parse_hash;
7902 sort_by_digest = sort_by_digest_4_8;
7903 opti_type = OPTI_TYPE_ZERO_BYTE
7904 | OPTI_TYPE_NOT_ITERATED;
7905 dgst_pos0 = 3;
7906 dgst_pos1 = 7;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 6;
7909 break;
7910
7911 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_LE
7915 | OPTS_TYPE_PT_BITSLICE;
7916 kern_type = KERN_TYPE_DESCRYPT;
7917 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7918 parse_func = descrypt_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 1;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 3;
7926 break;
7927
7928 case 1600: hash_type = HASH_TYPE_MD5;
7929 salt_type = SALT_TYPE_EMBEDDED;
7930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7932 kern_type = KERN_TYPE_APR1CRYPT;
7933 dgst_size = DGST_SIZE_4_4;
7934 parse_func = md5apr1_parse_hash;
7935 sort_by_digest = sort_by_digest_4_4;
7936 opti_type = OPTI_TYPE_ZERO_BYTE;
7937 dgst_pos0 = 0;
7938 dgst_pos1 = 1;
7939 dgst_pos2 = 2;
7940 dgst_pos3 = 3;
7941 break;
7942
7943 case 1700: hash_type = HASH_TYPE_SHA512;
7944 salt_type = SALT_TYPE_NONE;
7945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7946 opts_type = OPTS_TYPE_PT_GENERATE_BE
7947 | OPTS_TYPE_PT_ADD80
7948 | OPTS_TYPE_PT_ADDBITS15;
7949 kern_type = KERN_TYPE_SHA512;
7950 dgst_size = DGST_SIZE_8_8;
7951 parse_func = sha512_parse_hash;
7952 sort_by_digest = sort_by_digest_8_8;
7953 opti_type = OPTI_TYPE_ZERO_BYTE
7954 | OPTI_TYPE_PRECOMPUTE_INIT
7955 | OPTI_TYPE_PRECOMPUTE_MERKLE
7956 | OPTI_TYPE_EARLY_SKIP
7957 | OPTI_TYPE_NOT_ITERATED
7958 | OPTI_TYPE_NOT_SALTED
7959 | OPTI_TYPE_USES_BITS_64
7960 | OPTI_TYPE_RAW_HASH;
7961 dgst_pos0 = 14;
7962 dgst_pos1 = 15;
7963 dgst_pos2 = 6;
7964 dgst_pos3 = 7;
7965 break;
7966
7967 case 1710: hash_type = HASH_TYPE_SHA512;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_ST_ADD80
7972 | OPTS_TYPE_ST_ADDBITS15;
7973 kern_type = KERN_TYPE_SHA512_PWSLT;
7974 dgst_size = DGST_SIZE_8_8;
7975 parse_func = sha512s_parse_hash;
7976 sort_by_digest = sort_by_digest_8_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_APPENDED_SALT
7983 | OPTI_TYPE_USES_BITS_64
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 14;
7986 dgst_pos1 = 15;
7987 dgst_pos2 = 6;
7988 dgst_pos3 = 7;
7989 break;
7990
7991 case 1711: hash_type = HASH_TYPE_SHA512;
7992 salt_type = SALT_TYPE_EMBEDDED;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_ST_ADD80
7996 | OPTS_TYPE_ST_ADDBITS15;
7997 kern_type = KERN_TYPE_SHA512_PWSLT;
7998 dgst_size = DGST_SIZE_8_8;
7999 parse_func = sha512b64s_parse_hash;
8000 sort_by_digest = sort_by_digest_8_8;
8001 opti_type = OPTI_TYPE_ZERO_BYTE
8002 | OPTI_TYPE_PRECOMPUTE_INIT
8003 | OPTI_TYPE_PRECOMPUTE_MERKLE
8004 | OPTI_TYPE_EARLY_SKIP
8005 | OPTI_TYPE_NOT_ITERATED
8006 | OPTI_TYPE_APPENDED_SALT
8007 | OPTI_TYPE_USES_BITS_64
8008 | OPTI_TYPE_RAW_HASH;
8009 dgst_pos0 = 14;
8010 dgst_pos1 = 15;
8011 dgst_pos2 = 6;
8012 dgst_pos3 = 7;
8013 break;
8014
8015 case 1720: hash_type = HASH_TYPE_SHA512;
8016 salt_type = SALT_TYPE_INTERN;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_BE
8019 | OPTS_TYPE_PT_ADD80
8020 | OPTS_TYPE_PT_ADDBITS15;
8021 kern_type = KERN_TYPE_SHA512_SLTPW;
8022 dgst_size = DGST_SIZE_8_8;
8023 parse_func = sha512s_parse_hash;
8024 sort_by_digest = sort_by_digest_8_8;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP
8029 | OPTI_TYPE_NOT_ITERATED
8030 | OPTI_TYPE_PREPENDED_SALT
8031 | OPTI_TYPE_USES_BITS_64
8032 | OPTI_TYPE_RAW_HASH;
8033 dgst_pos0 = 14;
8034 dgst_pos1 = 15;
8035 dgst_pos2 = 6;
8036 dgst_pos3 = 7;
8037 break;
8038
8039 case 1722: hash_type = HASH_TYPE_SHA512;
8040 salt_type = SALT_TYPE_EMBEDDED;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = OPTS_TYPE_PT_GENERATE_BE
8043 | OPTS_TYPE_PT_ADD80
8044 | OPTS_TYPE_PT_ADDBITS15
8045 | OPTS_TYPE_ST_HEX;
8046 kern_type = KERN_TYPE_SHA512_SLTPW;
8047 dgst_size = DGST_SIZE_8_8;
8048 parse_func = osx512_parse_hash;
8049 sort_by_digest = sort_by_digest_8_8;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP
8054 | OPTI_TYPE_NOT_ITERATED
8055 | OPTI_TYPE_PREPENDED_SALT
8056 | OPTI_TYPE_USES_BITS_64
8057 | OPTI_TYPE_RAW_HASH;
8058 dgst_pos0 = 14;
8059 dgst_pos1 = 15;
8060 dgst_pos2 = 6;
8061 dgst_pos3 = 7;
8062 break;
8063
8064 case 1730: hash_type = HASH_TYPE_SHA512;
8065 salt_type = SALT_TYPE_INTERN;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_BE
8068 | OPTS_TYPE_PT_UNICODE
8069 | OPTS_TYPE_ST_ADD80
8070 | OPTS_TYPE_ST_ADDBITS15;
8071 kern_type = KERN_TYPE_SHA512_PWSLTU;
8072 dgst_size = DGST_SIZE_8_8;
8073 parse_func = sha512s_parse_hash;
8074 sort_by_digest = sort_by_digest_8_8;
8075 opti_type = OPTI_TYPE_ZERO_BYTE
8076 | OPTI_TYPE_PRECOMPUTE_INIT
8077 | OPTI_TYPE_PRECOMPUTE_MERKLE
8078 | OPTI_TYPE_EARLY_SKIP
8079 | OPTI_TYPE_NOT_ITERATED
8080 | OPTI_TYPE_APPENDED_SALT
8081 | OPTI_TYPE_USES_BITS_64
8082 | OPTI_TYPE_RAW_HASH;
8083 dgst_pos0 = 14;
8084 dgst_pos1 = 15;
8085 dgst_pos2 = 6;
8086 dgst_pos3 = 7;
8087 break;
8088
8089 case 1731: hash_type = HASH_TYPE_SHA512;
8090 salt_type = SALT_TYPE_EMBEDDED;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = OPTS_TYPE_PT_GENERATE_BE
8093 | OPTS_TYPE_PT_UNICODE
8094 | OPTS_TYPE_ST_ADD80
8095 | OPTS_TYPE_ST_ADDBITS15
8096 | OPTS_TYPE_ST_HEX;
8097 kern_type = KERN_TYPE_SHA512_PWSLTU;
8098 dgst_size = DGST_SIZE_8_8;
8099 parse_func = mssql2012_parse_hash;
8100 sort_by_digest = sort_by_digest_8_8;
8101 opti_type = OPTI_TYPE_ZERO_BYTE
8102 | OPTI_TYPE_PRECOMPUTE_INIT
8103 | OPTI_TYPE_PRECOMPUTE_MERKLE
8104 | OPTI_TYPE_EARLY_SKIP
8105 | OPTI_TYPE_NOT_ITERATED
8106 | OPTI_TYPE_APPENDED_SALT
8107 | OPTI_TYPE_USES_BITS_64
8108 | OPTI_TYPE_RAW_HASH;
8109 dgst_pos0 = 14;
8110 dgst_pos1 = 15;
8111 dgst_pos2 = 6;
8112 dgst_pos3 = 7;
8113 break;
8114
8115 case 1740: hash_type = HASH_TYPE_SHA512;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS15
8121 | OPTS_TYPE_PT_UNICODE;
8122 kern_type = KERN_TYPE_SHA512_SLTPWU;
8123 dgst_size = DGST_SIZE_8_8;
8124 parse_func = sha512s_parse_hash;
8125 sort_by_digest = sort_by_digest_8_8;
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_PRECOMPUTE_INIT
8128 | OPTI_TYPE_PRECOMPUTE_MERKLE
8129 | OPTI_TYPE_EARLY_SKIP
8130 | OPTI_TYPE_NOT_ITERATED
8131 | OPTI_TYPE_PREPENDED_SALT
8132 | OPTI_TYPE_USES_BITS_64
8133 | OPTI_TYPE_RAW_HASH;
8134 dgst_pos0 = 14;
8135 dgst_pos1 = 15;
8136 dgst_pos2 = 6;
8137 dgst_pos3 = 7;
8138 break;
8139
8140 case 1750: hash_type = HASH_TYPE_SHA512;
8141 salt_type = SALT_TYPE_INTERN;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_ST_ADD80;
8145 kern_type = KERN_TYPE_HMACSHA512_PW;
8146 dgst_size = DGST_SIZE_8_8;
8147 parse_func = hmacsha512_parse_hash;
8148 sort_by_digest = sort_by_digest_8_8;
8149 opti_type = OPTI_TYPE_ZERO_BYTE
8150 | OPTI_TYPE_USES_BITS_64
8151 | OPTI_TYPE_NOT_ITERATED;
8152 dgst_pos0 = 14;
8153 dgst_pos1 = 15;
8154 dgst_pos2 = 6;
8155 dgst_pos3 = 7;
8156 break;
8157
8158 case 1760: hash_type = HASH_TYPE_SHA512;
8159 salt_type = SALT_TYPE_INTERN;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_BE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS15;
8164 kern_type = KERN_TYPE_HMACSHA512_SLT;
8165 dgst_size = DGST_SIZE_8_8;
8166 parse_func = hmacsha512_parse_hash;
8167 sort_by_digest = sort_by_digest_8_8;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_USES_BITS_64
8170 | OPTI_TYPE_NOT_ITERATED;
8171 dgst_pos0 = 14;
8172 dgst_pos1 = 15;
8173 dgst_pos2 = 6;
8174 dgst_pos3 = 7;
8175 break;
8176
8177 case 1800: hash_type = HASH_TYPE_SHA512;
8178 salt_type = SALT_TYPE_EMBEDDED;
8179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8181 kern_type = KERN_TYPE_SHA512CRYPT;
8182 dgst_size = DGST_SIZE_8_8;
8183 parse_func = sha512crypt_parse_hash;
8184 sort_by_digest = sort_by_digest_8_8;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_USES_BITS_64;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 1;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 3;
8191 break;
8192
8193 case 2100: hash_type = HASH_TYPE_DCC2;
8194 salt_type = SALT_TYPE_EMBEDDED;
8195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8197 | OPTS_TYPE_ST_LOWER
8198 | OPTS_TYPE_ST_UNICODE;
8199 kern_type = KERN_TYPE_DCC2;
8200 dgst_size = DGST_SIZE_4_4;
8201 parse_func = dcc2_parse_hash;
8202 sort_by_digest = sort_by_digest_4_4;
8203 opti_type = OPTI_TYPE_ZERO_BYTE;
8204 dgst_pos0 = 0;
8205 dgst_pos1 = 1;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 3;
8208 break;
8209
8210 case 2400: hash_type = HASH_TYPE_MD5;
8211 salt_type = SALT_TYPE_NONE;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8214 kern_type = KERN_TYPE_MD5PIX;
8215 dgst_size = DGST_SIZE_4_4;
8216 parse_func = md5pix_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_NOT_SALTED;
8224 dgst_pos0 = 0;
8225 dgst_pos1 = 3;
8226 dgst_pos2 = 2;
8227 dgst_pos3 = 1;
8228 break;
8229
8230 case 2410: hash_type = HASH_TYPE_MD5;
8231 salt_type = SALT_TYPE_INTERN;
8232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8234 kern_type = KERN_TYPE_MD5ASA;
8235 dgst_size = DGST_SIZE_4_4;
8236 parse_func = md5asa_parse_hash;
8237 sort_by_digest = sort_by_digest_4_4;
8238 opti_type = OPTI_TYPE_ZERO_BYTE
8239 | OPTI_TYPE_PRECOMPUTE_INIT
8240 | OPTI_TYPE_PRECOMPUTE_MERKLE
8241 | OPTI_TYPE_EARLY_SKIP
8242 | OPTI_TYPE_NOT_ITERATED;
8243 dgst_pos0 = 0;
8244 dgst_pos1 = 3;
8245 dgst_pos2 = 2;
8246 dgst_pos3 = 1;
8247 break;
8248
8249 case 2500: hash_type = HASH_TYPE_WPA;
8250 salt_type = SALT_TYPE_EMBEDDED;
8251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8253 kern_type = KERN_TYPE_WPA;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = wpa_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 1;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 3;
8262 break;
8263
8264 case 2600: hash_type = HASH_TYPE_MD5;
8265 salt_type = SALT_TYPE_VIRTUAL;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE
8268 | OPTS_TYPE_PT_ADD80
8269 | OPTS_TYPE_PT_ADDBITS14
8270 | OPTS_TYPE_ST_ADD80;
8271 kern_type = KERN_TYPE_MD55_PWSLT1;
8272 dgst_size = DGST_SIZE_4_4;
8273 parse_func = md5md5_parse_hash;
8274 sort_by_digest = sort_by_digest_4_4;
8275 opti_type = OPTI_TYPE_ZERO_BYTE
8276 | OPTI_TYPE_PRECOMPUTE_INIT
8277 | OPTI_TYPE_PRECOMPUTE_MERKLE
8278 | OPTI_TYPE_EARLY_SKIP;
8279 dgst_pos0 = 0;
8280 dgst_pos1 = 3;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 2611: hash_type = HASH_TYPE_MD5;
8286 salt_type = SALT_TYPE_INTERN;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_LE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS14
8291 | OPTS_TYPE_ST_ADD80;
8292 kern_type = KERN_TYPE_MD55_PWSLT1;
8293 dgst_size = DGST_SIZE_4_4;
8294 parse_func = vb3_parse_hash;
8295 sort_by_digest = sort_by_digest_4_4;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP;
8300 dgst_pos0 = 0;
8301 dgst_pos1 = 3;
8302 dgst_pos2 = 2;
8303 dgst_pos3 = 1;
8304 break;
8305
8306 case 2612: hash_type = HASH_TYPE_MD5;
8307 salt_type = SALT_TYPE_EMBEDDED;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_LE
8310 | OPTS_TYPE_PT_ADD80
8311 | OPTS_TYPE_PT_ADDBITS14
8312 | OPTS_TYPE_ST_ADD80
8313 | OPTS_TYPE_ST_HEX;
8314 kern_type = KERN_TYPE_MD55_PWSLT1;
8315 dgst_size = DGST_SIZE_4_4;
8316 parse_func = phps_parse_hash;
8317 sort_by_digest = sort_by_digest_4_4;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP;
8322 dgst_pos0 = 0;
8323 dgst_pos1 = 3;
8324 dgst_pos2 = 2;
8325 dgst_pos3 = 1;
8326 break;
8327
8328 case 2711: hash_type = HASH_TYPE_MD5;
8329 salt_type = SALT_TYPE_INTERN;
8330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8331 opts_type = OPTS_TYPE_PT_GENERATE_LE
8332 | OPTS_TYPE_PT_ADD80
8333 | OPTS_TYPE_PT_ADDBITS14
8334 | OPTS_TYPE_ST_ADD80;
8335 kern_type = KERN_TYPE_MD55_PWSLT2;
8336 dgst_size = DGST_SIZE_4_4;
8337 parse_func = vb30_parse_hash;
8338 sort_by_digest = sort_by_digest_4_4;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_EARLY_SKIP;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 3;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 1;
8346 break;
8347
8348 case 2811: hash_type = HASH_TYPE_MD5;
8349 salt_type = SALT_TYPE_INTERN;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_LE
8352 | OPTS_TYPE_PT_ADD80
8353 | OPTS_TYPE_PT_ADDBITS14;
8354 kern_type = KERN_TYPE_MD55_SLTPW;
8355 dgst_size = DGST_SIZE_4_4;
8356 parse_func = ipb2_parse_hash;
8357 sort_by_digest = sort_by_digest_4_4;
8358 opti_type = OPTI_TYPE_ZERO_BYTE
8359 | OPTI_TYPE_PRECOMPUTE_INIT
8360 | OPTI_TYPE_EARLY_SKIP;
8361 dgst_pos0 = 0;
8362 dgst_pos1 = 3;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 1;
8365 break;
8366
8367 case 3000: hash_type = HASH_TYPE_LM;
8368 salt_type = SALT_TYPE_NONE;
8369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE
8371 | OPTS_TYPE_PT_UPPER
8372 | OPTS_TYPE_PT_BITSLICE;
8373 kern_type = KERN_TYPE_LM;
8374 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8375 parse_func = lm_parse_hash;
8376 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8377 opti_type = OPTI_TYPE_ZERO_BYTE
8378 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 3100: hash_type = HASH_TYPE_ORACLEH;
8386 salt_type = SALT_TYPE_INTERN;
8387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE
8389 | OPTS_TYPE_PT_UPPER
8390 | OPTS_TYPE_ST_UPPER;
8391 kern_type = KERN_TYPE_ORACLEH;
8392 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8393 parse_func = oracleh_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8395 opti_type = OPTI_TYPE_ZERO_BYTE;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 1;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 3;
8400 break;
8401
8402 case 3200: hash_type = HASH_TYPE_BCRYPT;
8403 salt_type = SALT_TYPE_EMBEDDED;
8404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_LE
8406 | OPTS_TYPE_ST_GENERATE_LE;
8407 kern_type = KERN_TYPE_BCRYPT;
8408 dgst_size = DGST_SIZE_4_6;
8409 parse_func = bcrypt_parse_hash;
8410 sort_by_digest = sort_by_digest_4_6;
8411 opti_type = OPTI_TYPE_ZERO_BYTE;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 3710: hash_type = HASH_TYPE_MD5;
8419 salt_type = SALT_TYPE_INTERN;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE
8422 | OPTS_TYPE_PT_ADD80
8423 | OPTS_TYPE_PT_ADDBITS14;
8424 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8425 dgst_size = DGST_SIZE_4_4;
8426 parse_func = md5s_parse_hash;
8427 sort_by_digest = sort_by_digest_4_4;
8428 opti_type = OPTI_TYPE_ZERO_BYTE
8429 | OPTI_TYPE_PRECOMPUTE_INIT
8430 | OPTI_TYPE_PRECOMPUTE_MERKLE
8431 | OPTI_TYPE_EARLY_SKIP;
8432 dgst_pos0 = 0;
8433 dgst_pos1 = 3;
8434 dgst_pos2 = 2;
8435 dgst_pos3 = 1;
8436 break;
8437
8438 case 3711: hash_type = HASH_TYPE_MD5;
8439 salt_type = SALT_TYPE_EMBEDDED;
8440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8441 opts_type = OPTS_TYPE_PT_GENERATE_LE
8442 | OPTS_TYPE_PT_ADD80
8443 | OPTS_TYPE_PT_ADDBITS14;
8444 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8445 dgst_size = DGST_SIZE_4_4;
8446 parse_func = mediawiki_b_parse_hash;
8447 sort_by_digest = sort_by_digest_4_4;
8448 opti_type = OPTI_TYPE_ZERO_BYTE
8449 | OPTI_TYPE_PRECOMPUTE_INIT
8450 | OPTI_TYPE_PRECOMPUTE_MERKLE
8451 | OPTI_TYPE_EARLY_SKIP;
8452 dgst_pos0 = 0;
8453 dgst_pos1 = 3;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 1;
8456 break;
8457
8458 case 3800: hash_type = HASH_TYPE_MD5;
8459 salt_type = SALT_TYPE_INTERN;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_LE
8462 | OPTS_TYPE_ST_ADDBITS14;
8463 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8464 dgst_size = DGST_SIZE_4_4;
8465 parse_func = md5s_parse_hash;
8466 sort_by_digest = sort_by_digest_4_4;
8467 opti_type = OPTI_TYPE_ZERO_BYTE
8468 | OPTI_TYPE_PRECOMPUTE_INIT
8469 | OPTI_TYPE_PRECOMPUTE_MERKLE
8470 | OPTI_TYPE_EARLY_SKIP
8471 | OPTI_TYPE_NOT_ITERATED
8472 | OPTI_TYPE_RAW_HASH;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 3;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 1;
8477 break;
8478
8479 case 4300: hash_type = HASH_TYPE_MD5;
8480 salt_type = SALT_TYPE_VIRTUAL;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS14
8485 | OPTS_TYPE_ST_ADD80;
8486 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8487 dgst_size = DGST_SIZE_4_4;
8488 parse_func = md5md5_parse_hash;
8489 sort_by_digest = sort_by_digest_4_4;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 3;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 1;
8498 break;
8499
8500
8501 case 4400: hash_type = HASH_TYPE_MD5;
8502 salt_type = SALT_TYPE_NONE;
8503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8504 opts_type = OPTS_TYPE_PT_GENERATE_BE
8505 | OPTS_TYPE_PT_ADD80
8506 | OPTS_TYPE_PT_ADDBITS15;
8507 kern_type = KERN_TYPE_MD5_SHA1;
8508 dgst_size = DGST_SIZE_4_4;
8509 parse_func = md5_parse_hash;
8510 sort_by_digest = sort_by_digest_4_4;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_NOT_SALTED
8517 | OPTI_TYPE_RAW_HASH;
8518 dgst_pos0 = 0;
8519 dgst_pos1 = 3;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 1;
8522 break;
8523
8524 case 4500: hash_type = HASH_TYPE_SHA1;
8525 salt_type = SALT_TYPE_NONE;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_BE
8528 | OPTS_TYPE_PT_ADD80
8529 | OPTS_TYPE_PT_ADDBITS15;
8530 kern_type = KERN_TYPE_SHA11;
8531 dgst_size = DGST_SIZE_4_5;
8532 parse_func = sha1_parse_hash;
8533 sort_by_digest = sort_by_digest_4_5;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_EARLY_SKIP
8538 | OPTI_TYPE_NOT_SALTED;
8539 dgst_pos0 = 3;
8540 dgst_pos1 = 4;
8541 dgst_pos2 = 2;
8542 dgst_pos3 = 1;
8543 break;
8544
8545 case 4700: hash_type = HASH_TYPE_SHA1;
8546 salt_type = SALT_TYPE_NONE;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_LE
8549 | OPTS_TYPE_PT_ADD80
8550 | OPTS_TYPE_PT_ADDBITS14;
8551 kern_type = KERN_TYPE_SHA1_MD5;
8552 dgst_size = DGST_SIZE_4_5;
8553 parse_func = sha1_parse_hash;
8554 sort_by_digest = sort_by_digest_4_5;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_PRECOMPUTE_MERKLE
8558 | OPTI_TYPE_EARLY_SKIP
8559 | OPTI_TYPE_NOT_ITERATED
8560 | OPTI_TYPE_NOT_SALTED
8561 | OPTI_TYPE_RAW_HASH;
8562 dgst_pos0 = 3;
8563 dgst_pos1 = 4;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 1;
8566 break;
8567
8568 case 4800: hash_type = HASH_TYPE_MD5;
8569 salt_type = SALT_TYPE_EMBEDDED;
8570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_LE
8572 | OPTS_TYPE_PT_ADDBITS14;
8573 kern_type = KERN_TYPE_MD5_CHAP;
8574 dgst_size = DGST_SIZE_4_4;
8575 parse_func = chap_parse_hash;
8576 sort_by_digest = sort_by_digest_4_4;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_PRECOMPUTE_MERKLE
8580 | OPTI_TYPE_MEET_IN_MIDDLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_ITERATED
8583 | OPTI_TYPE_RAW_HASH;
8584 dgst_pos0 = 0;
8585 dgst_pos1 = 3;
8586 dgst_pos2 = 2;
8587 dgst_pos3 = 1;
8588 break;
8589
8590 case 4900: hash_type = HASH_TYPE_SHA1;
8591 salt_type = SALT_TYPE_INTERN;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8594 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8595 dgst_size = DGST_SIZE_4_5;
8596 parse_func = sha1s_parse_hash;
8597 sort_by_digest = sort_by_digest_4_5;
8598 opti_type = OPTI_TYPE_ZERO_BYTE
8599 | OPTI_TYPE_PRECOMPUTE_INIT
8600 | OPTI_TYPE_PRECOMPUTE_MERKLE
8601 | OPTI_TYPE_EARLY_SKIP;
8602 dgst_pos0 = 3;
8603 dgst_pos1 = 4;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 1;
8606 break;
8607
8608 case 5000: hash_type = HASH_TYPE_KECCAK;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE
8612 | OPTS_TYPE_PT_ADD01;
8613 kern_type = KERN_TYPE_KECCAK;
8614 dgst_size = DGST_SIZE_8_25;
8615 parse_func = keccak_parse_hash;
8616 sort_by_digest = sort_by_digest_8_25;
8617 opti_type = OPTI_TYPE_ZERO_BYTE
8618 | OPTI_TYPE_USES_BITS_64
8619 | OPTI_TYPE_RAW_HASH;
8620 dgst_pos0 = 2;
8621 dgst_pos1 = 3;
8622 dgst_pos2 = 4;
8623 dgst_pos3 = 5;
8624 break;
8625
8626 case 5100: hash_type = HASH_TYPE_MD5H;
8627 salt_type = SALT_TYPE_NONE;
8628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8629 opts_type = OPTS_TYPE_PT_GENERATE_LE
8630 | OPTS_TYPE_PT_ADD80
8631 | OPTS_TYPE_PT_ADDBITS14;
8632 kern_type = KERN_TYPE_MD5H;
8633 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8634 parse_func = md5half_parse_hash;
8635 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8636 opti_type = OPTI_TYPE_ZERO_BYTE
8637 | OPTI_TYPE_RAW_HASH;
8638 dgst_pos0 = 0;
8639 dgst_pos1 = 1;
8640 dgst_pos2 = 2;
8641 dgst_pos3 = 3;
8642 break;
8643
8644 case 5200: hash_type = HASH_TYPE_SHA256;
8645 salt_type = SALT_TYPE_EMBEDDED;
8646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8647 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8648 kern_type = KERN_TYPE_PSAFE3;
8649 dgst_size = DGST_SIZE_4_8;
8650 parse_func = psafe3_parse_hash;
8651 sort_by_digest = sort_by_digest_4_8;
8652 opti_type = OPTI_TYPE_ZERO_BYTE;
8653 dgst_pos0 = 0;
8654 dgst_pos1 = 1;
8655 dgst_pos2 = 2;
8656 dgst_pos3 = 3;
8657 break;
8658
8659 case 5300: hash_type = HASH_TYPE_MD5;
8660 salt_type = SALT_TYPE_EMBEDDED;
8661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_LE
8663 | OPTS_TYPE_ST_ADD80;
8664 kern_type = KERN_TYPE_IKEPSK_MD5;
8665 dgst_size = DGST_SIZE_4_4;
8666 parse_func = ikepsk_md5_parse_hash;
8667 sort_by_digest = sort_by_digest_4_4;
8668 opti_type = OPTI_TYPE_ZERO_BYTE;
8669 dgst_pos0 = 0;
8670 dgst_pos1 = 3;
8671 dgst_pos2 = 2;
8672 dgst_pos3 = 1;
8673 break;
8674
8675 case 5400: hash_type = HASH_TYPE_SHA1;
8676 salt_type = SALT_TYPE_EMBEDDED;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_BE
8679 | OPTS_TYPE_ST_ADD80;
8680 kern_type = KERN_TYPE_IKEPSK_SHA1;
8681 dgst_size = DGST_SIZE_4_5;
8682 parse_func = ikepsk_sha1_parse_hash;
8683 sort_by_digest = sort_by_digest_4_5;
8684 opti_type = OPTI_TYPE_ZERO_BYTE;
8685 dgst_pos0 = 3;
8686 dgst_pos1 = 4;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 1;
8689 break;
8690
8691 case 5500: hash_type = HASH_TYPE_NETNTLM;
8692 salt_type = SALT_TYPE_EMBEDDED;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_LE
8695 | OPTS_TYPE_PT_ADD80
8696 | OPTS_TYPE_PT_ADDBITS14
8697 | OPTS_TYPE_PT_UNICODE
8698 | OPTS_TYPE_ST_HEX;
8699 kern_type = KERN_TYPE_NETNTLMv1;
8700 dgst_size = DGST_SIZE_4_4;
8701 parse_func = netntlmv1_parse_hash;
8702 sort_by_digest = sort_by_digest_4_4;
8703 opti_type = OPTI_TYPE_ZERO_BYTE
8704 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 1;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 3;
8709 break;
8710
8711 case 5600: hash_type = HASH_TYPE_MD5;
8712 salt_type = SALT_TYPE_EMBEDDED;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE
8715 | OPTS_TYPE_PT_ADD80
8716 | OPTS_TYPE_PT_ADDBITS14
8717 | OPTS_TYPE_PT_UNICODE;
8718 kern_type = KERN_TYPE_NETNTLMv2;
8719 dgst_size = DGST_SIZE_4_4;
8720 parse_func = netntlmv2_parse_hash;
8721 sort_by_digest = sort_by_digest_4_4;
8722 opti_type = OPTI_TYPE_ZERO_BYTE;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 3;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 1;
8727 break;
8728
8729 case 5700: hash_type = HASH_TYPE_SHA256;
8730 salt_type = SALT_TYPE_NONE;
8731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_BE
8733 | OPTS_TYPE_PT_ADD80
8734 | OPTS_TYPE_PT_ADDBITS15;
8735 kern_type = KERN_TYPE_SHA256;
8736 dgst_size = DGST_SIZE_4_8;
8737 parse_func = cisco4_parse_hash;
8738 sort_by_digest = sort_by_digest_4_8;
8739 opti_type = OPTI_TYPE_ZERO_BYTE
8740 | OPTI_TYPE_PRECOMPUTE_INIT
8741 | OPTI_TYPE_PRECOMPUTE_MERKLE
8742 | OPTI_TYPE_EARLY_SKIP
8743 | OPTI_TYPE_NOT_ITERATED
8744 | OPTI_TYPE_NOT_SALTED
8745 | OPTI_TYPE_RAW_HASH;
8746 dgst_pos0 = 3;
8747 dgst_pos1 = 7;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 6;
8750 break;
8751
8752 case 5800: hash_type = HASH_TYPE_SHA1;
8753 salt_type = SALT_TYPE_INTERN;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8756 | OPTS_TYPE_ST_ADD80;
8757 kern_type = KERN_TYPE_ANDROIDPIN;
8758 dgst_size = DGST_SIZE_4_5;
8759 parse_func = androidpin_parse_hash;
8760 sort_by_digest = sort_by_digest_4_5;
8761 opti_type = OPTI_TYPE_ZERO_BYTE;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 1;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 3;
8766 break;
8767
8768 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8769 salt_type = SALT_TYPE_NONE;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE
8772 | OPTS_TYPE_PT_ADD80;
8773 kern_type = KERN_TYPE_RIPEMD160;
8774 dgst_size = DGST_SIZE_4_5;
8775 parse_func = ripemd160_parse_hash;
8776 sort_by_digest = sort_by_digest_4_5;
8777 opti_type = OPTI_TYPE_ZERO_BYTE;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 1;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 3;
8782 break;
8783
8784 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8785 salt_type = SALT_TYPE_NONE;
8786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_BE
8788 | OPTS_TYPE_PT_ADD80;
8789 kern_type = KERN_TYPE_WHIRLPOOL;
8790 dgst_size = DGST_SIZE_4_16;
8791 parse_func = whirlpool_parse_hash;
8792 sort_by_digest = sort_by_digest_4_16;
8793 opti_type = OPTI_TYPE_ZERO_BYTE;
8794 dgst_pos0 = 0;
8795 dgst_pos1 = 1;
8796 dgst_pos2 = 2;
8797 dgst_pos3 = 3;
8798 break;
8799
8800 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8801 salt_type = SALT_TYPE_EMBEDDED;
8802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8804 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8805 dgst_size = DGST_SIZE_4_5;
8806 parse_func = truecrypt_parse_hash_2k;
8807 sort_by_digest = sort_by_digest_4_5;
8808 opti_type = OPTI_TYPE_ZERO_BYTE;
8809 dgst_pos0 = 0;
8810 dgst_pos1 = 1;
8811 dgst_pos2 = 2;
8812 dgst_pos3 = 3;
8813 break;
8814
8815 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8816 salt_type = SALT_TYPE_EMBEDDED;
8817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8819 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8820 dgst_size = DGST_SIZE_4_5;
8821 parse_func = truecrypt_parse_hash_2k;
8822 sort_by_digest = sort_by_digest_4_5;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8834 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8835 dgst_size = DGST_SIZE_4_5;
8836 parse_func = truecrypt_parse_hash_2k;
8837 sort_by_digest = sort_by_digest_4_5;
8838 opti_type = OPTI_TYPE_ZERO_BYTE;
8839 dgst_pos0 = 0;
8840 dgst_pos1 = 1;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 3;
8843 break;
8844
8845 case 6221: hash_type = HASH_TYPE_SHA512;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_TCSHA512_XTS512;
8850 dgst_size = DGST_SIZE_8_8;
8851 parse_func = truecrypt_parse_hash_1k;
8852 sort_by_digest = sort_by_digest_8_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE
8854 | OPTI_TYPE_USES_BITS_64;
8855 dgst_pos0 = 0;
8856 dgst_pos1 = 1;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 3;
8859 break;
8860
8861 case 6222: hash_type = HASH_TYPE_SHA512;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8865 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8866 dgst_size = DGST_SIZE_8_8;
8867 parse_func = truecrypt_parse_hash_1k;
8868 sort_by_digest = sort_by_digest_8_8;
8869 opti_type = OPTI_TYPE_ZERO_BYTE
8870 | OPTI_TYPE_USES_BITS_64;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 6223: hash_type = HASH_TYPE_SHA512;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8881 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8882 dgst_size = DGST_SIZE_8_8;
8883 parse_func = truecrypt_parse_hash_1k;
8884 sort_by_digest = sort_by_digest_8_8;
8885 opti_type = OPTI_TYPE_ZERO_BYTE
8886 | OPTI_TYPE_USES_BITS_64;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 1;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 3;
8891 break;
8892
8893 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8894 salt_type = SALT_TYPE_EMBEDDED;
8895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8897 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8898 dgst_size = DGST_SIZE_4_8;
8899 parse_func = truecrypt_parse_hash_1k;
8900 sort_by_digest = sort_by_digest_4_8;
8901 opti_type = OPTI_TYPE_ZERO_BYTE;
8902 dgst_pos0 = 0;
8903 dgst_pos1 = 1;
8904 dgst_pos2 = 2;
8905 dgst_pos3 = 3;
8906 break;
8907
8908 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8909 salt_type = SALT_TYPE_EMBEDDED;
8910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8911 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8912 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8913 dgst_size = DGST_SIZE_4_8;
8914 parse_func = truecrypt_parse_hash_1k;
8915 sort_by_digest = sort_by_digest_4_8;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8927 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8928 dgst_size = DGST_SIZE_4_8;
8929 parse_func = truecrypt_parse_hash_1k;
8930 sort_by_digest = sort_by_digest_4_8;
8931 opti_type = OPTI_TYPE_ZERO_BYTE;
8932 dgst_pos0 = 0;
8933 dgst_pos1 = 1;
8934 dgst_pos2 = 2;
8935 dgst_pos3 = 3;
8936 break;
8937
8938 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8939 salt_type = SALT_TYPE_EMBEDDED;
8940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8942 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8943 dgst_size = DGST_SIZE_4_5;
8944 parse_func = truecrypt_parse_hash_1k;
8945 sort_by_digest = sort_by_digest_4_5;
8946 opti_type = OPTI_TYPE_ZERO_BYTE;
8947 dgst_pos0 = 0;
8948 dgst_pos1 = 1;
8949 dgst_pos2 = 2;
8950 dgst_pos3 = 3;
8951 break;
8952
8953 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8954 salt_type = SALT_TYPE_EMBEDDED;
8955 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8956 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8957 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8958 dgst_size = DGST_SIZE_4_5;
8959 parse_func = truecrypt_parse_hash_1k;
8960 sort_by_digest = sort_by_digest_4_5;
8961 opti_type = OPTI_TYPE_ZERO_BYTE;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 1;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 3;
8966 break;
8967
8968 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8969 salt_type = SALT_TYPE_EMBEDDED;
8970 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8972 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8973 dgst_size = DGST_SIZE_4_5;
8974 parse_func = truecrypt_parse_hash_1k;
8975 sort_by_digest = sort_by_digest_4_5;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6300: hash_type = HASH_TYPE_MD5;
8984 salt_type = SALT_TYPE_EMBEDDED;
8985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8987 kern_type = KERN_TYPE_MD5AIX;
8988 dgst_size = DGST_SIZE_4_4;
8989 parse_func = md5aix_parse_hash;
8990 sort_by_digest = sort_by_digest_4_4;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 6400: hash_type = HASH_TYPE_SHA256;
8999 salt_type = SALT_TYPE_EMBEDDED;
9000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9002 kern_type = KERN_TYPE_SHA256AIX;
9003 dgst_size = DGST_SIZE_4_8;
9004 parse_func = sha256aix_parse_hash;
9005 sort_by_digest = sort_by_digest_4_8;
9006 opti_type = OPTI_TYPE_ZERO_BYTE;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 6500: hash_type = HASH_TYPE_SHA512;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9017 kern_type = KERN_TYPE_SHA512AIX;
9018 dgst_size = DGST_SIZE_8_8;
9019 parse_func = sha512aix_parse_hash;
9020 sort_by_digest = sort_by_digest_8_8;
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_USES_BITS_64;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6600: hash_type = HASH_TYPE_AES;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9033 kern_type = KERN_TYPE_AGILEKEY;
9034 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9035 parse_func = agilekey_parse_hash;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6700: hash_type = HASH_TYPE_SHA1;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9048 kern_type = KERN_TYPE_SHA1AIX;
9049 dgst_size = DGST_SIZE_4_5;
9050 parse_func = sha1aix_parse_hash;
9051 sort_by_digest = sort_by_digest_4_5;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6800: hash_type = HASH_TYPE_AES;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_LASTPASS;
9064 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9065 parse_func = lastpass_parse_hash;
9066 sort_by_digest = sort_by_digest_4_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6900: hash_type = HASH_TYPE_GOST;
9075 salt_type = SALT_TYPE_NONE;
9076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9078 kern_type = KERN_TYPE_GOST;
9079 dgst_size = DGST_SIZE_4_8;
9080 parse_func = gost_parse_hash;
9081 sort_by_digest = sort_by_digest_4_8;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 7100: hash_type = HASH_TYPE_SHA512;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9093 kern_type = KERN_TYPE_PBKDF2_SHA512;
9094 dgst_size = DGST_SIZE_8_16;
9095 parse_func = sha512osx_parse_hash;
9096 sort_by_digest = sort_by_digest_8_16;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_USES_BITS_64;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 7200: hash_type = HASH_TYPE_SHA512;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9109 kern_type = KERN_TYPE_PBKDF2_SHA512;
9110 dgst_size = DGST_SIZE_8_16;
9111 parse_func = sha512grub_parse_hash;
9112 sort_by_digest = sort_by_digest_8_16;
9113 opti_type = OPTI_TYPE_ZERO_BYTE
9114 | OPTI_TYPE_USES_BITS_64;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 7300: hash_type = HASH_TYPE_SHA1;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_BE
9125 | OPTS_TYPE_ST_ADD80
9126 | OPTS_TYPE_ST_ADDBITS15;
9127 kern_type = KERN_TYPE_RAKP;
9128 dgst_size = DGST_SIZE_4_5;
9129 parse_func = rakp_parse_hash;
9130 sort_by_digest = sort_by_digest_4_5;
9131 opti_type = OPTI_TYPE_ZERO_BYTE
9132 | OPTI_TYPE_NOT_ITERATED;
9133 dgst_pos0 = 3;
9134 dgst_pos1 = 4;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 1;
9137 break;
9138
9139 case 7400: hash_type = HASH_TYPE_SHA256;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9143 kern_type = KERN_TYPE_SHA256CRYPT;
9144 dgst_size = DGST_SIZE_4_8;
9145 parse_func = sha256crypt_parse_hash;
9146 sort_by_digest = sort_by_digest_4_8;
9147 opti_type = OPTI_TYPE_ZERO_BYTE;
9148 dgst_pos0 = 0;
9149 dgst_pos1 = 1;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 3;
9152 break;
9153
9154 case 7500: hash_type = HASH_TYPE_KRB5PA;
9155 salt_type = SALT_TYPE_EMBEDDED;
9156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9157 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9158 kern_type = KERN_TYPE_KRB5PA;
9159 dgst_size = DGST_SIZE_4_4;
9160 parse_func = krb5pa_parse_hash;
9161 sort_by_digest = sort_by_digest_4_4;
9162 opti_type = OPTI_TYPE_ZERO_BYTE
9163 | OPTI_TYPE_NOT_ITERATED;
9164 dgst_pos0 = 0;
9165 dgst_pos1 = 1;
9166 dgst_pos2 = 2;
9167 dgst_pos3 = 3;
9168 break;
9169
9170 case 7600: hash_type = HASH_TYPE_SHA1;
9171 salt_type = SALT_TYPE_INTERN;
9172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9173 opts_type = OPTS_TYPE_PT_GENERATE_BE
9174 | OPTS_TYPE_PT_ADD80
9175 | OPTS_TYPE_PT_ADDBITS15;
9176 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = redmine_parse_hash;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE
9181 | OPTI_TYPE_PRECOMPUTE_INIT
9182 | OPTI_TYPE_EARLY_SKIP
9183 | OPTI_TYPE_NOT_ITERATED
9184 | OPTI_TYPE_PREPENDED_SALT;
9185 dgst_pos0 = 3;
9186 dgst_pos1 = 4;
9187 dgst_pos2 = 2;
9188 dgst_pos3 = 1;
9189 break;
9190
9191 case 7700: hash_type = HASH_TYPE_SAPB;
9192 salt_type = SALT_TYPE_EMBEDDED;
9193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9194 opts_type = OPTS_TYPE_PT_GENERATE_LE
9195 | OPTS_TYPE_PT_UPPER
9196 | OPTS_TYPE_ST_UPPER;
9197 kern_type = KERN_TYPE_SAPB;
9198 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9199 parse_func = sapb_parse_hash;
9200 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9201 opti_type = OPTI_TYPE_ZERO_BYTE
9202 | OPTI_TYPE_PRECOMPUTE_INIT
9203 | OPTI_TYPE_NOT_ITERATED;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 7800: hash_type = HASH_TYPE_SAPG;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_BE
9214 | OPTS_TYPE_ST_ADD80
9215 | OPTS_TYPE_ST_UPPER;
9216 kern_type = KERN_TYPE_SAPG;
9217 dgst_size = DGST_SIZE_4_5;
9218 parse_func = sapg_parse_hash;
9219 sort_by_digest = sort_by_digest_4_5;
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_PRECOMPUTE_INIT
9222 | OPTI_TYPE_NOT_ITERATED;
9223 dgst_pos0 = 3;
9224 dgst_pos1 = 4;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 1;
9227 break;
9228
9229 case 7900: hash_type = HASH_TYPE_SHA512;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9233 kern_type = KERN_TYPE_DRUPAL7;
9234 dgst_size = DGST_SIZE_8_8;
9235 parse_func = drupal7_parse_hash;
9236 sort_by_digest = sort_by_digest_8_8;
9237 opti_type = OPTI_TYPE_ZERO_BYTE
9238 | OPTI_TYPE_USES_BITS_64;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 1;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 3;
9243 break;
9244
9245 case 8000: hash_type = HASH_TYPE_SHA256;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_BE
9249 | OPTS_TYPE_PT_UNICODE
9250 | OPTS_TYPE_ST_ADD80
9251 | OPTS_TYPE_ST_HEX;
9252 kern_type = KERN_TYPE_SYBASEASE;
9253 dgst_size = DGST_SIZE_4_8;
9254 parse_func = sybasease_parse_hash;
9255 sort_by_digest = sort_by_digest_4_8;
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_PRECOMPUTE_INIT
9258 | OPTI_TYPE_EARLY_SKIP
9259 | OPTI_TYPE_NOT_ITERATED
9260 | OPTI_TYPE_RAW_HASH;
9261 dgst_pos0 = 3;
9262 dgst_pos1 = 7;
9263 dgst_pos2 = 2;
9264 dgst_pos3 = 6;
9265 break;
9266
9267 case 8100: hash_type = HASH_TYPE_SHA1;
9268 salt_type = SALT_TYPE_EMBEDDED;
9269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9270 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9271 kern_type = KERN_TYPE_NETSCALER;
9272 dgst_size = DGST_SIZE_4_5;
9273 parse_func = netscaler_parse_hash;
9274 sort_by_digest = sort_by_digest_4_5;
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_PRECOMPUTE_INIT
9277 | OPTI_TYPE_PRECOMPUTE_MERKLE
9278 | OPTI_TYPE_EARLY_SKIP
9279 | OPTI_TYPE_NOT_ITERATED
9280 | OPTI_TYPE_PREPENDED_SALT
9281 | OPTI_TYPE_RAW_HASH;
9282 dgst_pos0 = 3;
9283 dgst_pos1 = 4;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 1;
9286 break;
9287
9288 case 8200: hash_type = HASH_TYPE_SHA256;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9292 kern_type = KERN_TYPE_CLOUDKEY;
9293 dgst_size = DGST_SIZE_4_8;
9294 parse_func = cloudkey_parse_hash;
9295 sort_by_digest = sort_by_digest_4_8;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 8300: hash_type = HASH_TYPE_SHA1;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE
9307 | OPTS_TYPE_ST_HEX
9308 | OPTS_TYPE_ST_ADD80;
9309 kern_type = KERN_TYPE_NSEC3;
9310 dgst_size = DGST_SIZE_4_5;
9311 parse_func = nsec3_parse_hash;
9312 sort_by_digest = sort_by_digest_4_5;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 3;
9315 dgst_pos1 = 4;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 1;
9318 break;
9319
9320 case 8400: hash_type = HASH_TYPE_SHA1;
9321 salt_type = SALT_TYPE_INTERN;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_BE
9324 | OPTS_TYPE_PT_ADD80
9325 | OPTS_TYPE_PT_ADDBITS15;
9326 kern_type = KERN_TYPE_WBB3;
9327 dgst_size = DGST_SIZE_4_5;
9328 parse_func = wbb3_parse_hash;
9329 sort_by_digest = sort_by_digest_4_5;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_PRECOMPUTE_INIT
9332 | OPTI_TYPE_NOT_ITERATED;
9333 dgst_pos0 = 3;
9334 dgst_pos1 = 4;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 1;
9337 break;
9338
9339 case 8500: hash_type = HASH_TYPE_DESRACF;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE
9343 | OPTS_TYPE_ST_UPPER;
9344 kern_type = KERN_TYPE_RACF;
9345 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9346 parse_func = racf_parse_hash;
9347 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9348 opti_type = OPTI_TYPE_ZERO_BYTE
9349 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 8600: hash_type = HASH_TYPE_LOTUS5;
9357 salt_type = SALT_TYPE_NONE;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9360 kern_type = KERN_TYPE_LOTUS5;
9361 dgst_size = DGST_SIZE_4_4;
9362 parse_func = lotus5_parse_hash;
9363 sort_by_digest = sort_by_digest_4_4;
9364 opti_type = OPTI_TYPE_EARLY_SKIP
9365 | OPTI_TYPE_NOT_ITERATED
9366 | OPTI_TYPE_NOT_SALTED
9367 | OPTI_TYPE_RAW_HASH;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 8700: hash_type = HASH_TYPE_LOTUS6;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9378 kern_type = KERN_TYPE_LOTUS6;
9379 dgst_size = DGST_SIZE_4_4;
9380 parse_func = lotus6_parse_hash;
9381 sort_by_digest = sort_by_digest_4_4;
9382 opti_type = OPTI_TYPE_EARLY_SKIP
9383 | OPTI_TYPE_NOT_ITERATED
9384 | OPTI_TYPE_RAW_HASH;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9392 salt_type = SALT_TYPE_EMBEDDED;
9393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_ANDROIDFDE;
9396 dgst_size = DGST_SIZE_4_4;
9397 parse_func = androidfde_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4;
9399 opti_type = OPTI_TYPE_ZERO_BYTE;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 8900: hash_type = HASH_TYPE_SCRYPT;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9410 kern_type = KERN_TYPE_SCRYPT;
9411 dgst_size = DGST_SIZE_4_8;
9412 parse_func = scrypt_parse_hash;
9413 sort_by_digest = sort_by_digest_4_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE;
9415 dgst_pos0 = 0;
9416 dgst_pos1 = 1;
9417 dgst_pos2 = 2;
9418 dgst_pos3 = 3;
9419 break;
9420
9421 case 9000: hash_type = HASH_TYPE_SHA1;
9422 salt_type = SALT_TYPE_EMBEDDED;
9423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9424 opts_type = OPTS_TYPE_PT_GENERATE_LE
9425 | OPTS_TYPE_ST_GENERATE_LE;
9426 kern_type = KERN_TYPE_PSAFE2;
9427 dgst_size = DGST_SIZE_4_5;
9428 parse_func = psafe2_parse_hash;
9429 sort_by_digest = sort_by_digest_4_5;
9430 opti_type = OPTI_TYPE_ZERO_BYTE;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 9100: hash_type = HASH_TYPE_LOTUS8;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_LOTUS8;
9442 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9443 parse_func = lotus8_parse_hash;
9444 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 9200: hash_type = HASH_TYPE_SHA256;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9456 kern_type = KERN_TYPE_PBKDF2_SHA256;
9457 dgst_size = DGST_SIZE_4_32;
9458 parse_func = cisco8_parse_hash;
9459 sort_by_digest = sort_by_digest_4_32;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9300: hash_type = HASH_TYPE_SCRYPT;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9471 kern_type = KERN_TYPE_SCRYPT;
9472 dgst_size = DGST_SIZE_4_8;
9473 parse_func = cisco9_parse_hash;
9474 sort_by_digest = sort_by_digest_4_8;
9475 opti_type = OPTI_TYPE_ZERO_BYTE;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 1;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 3;
9480 break;
9481
9482 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9486 kern_type = KERN_TYPE_OFFICE2007;
9487 dgst_size = DGST_SIZE_4_4;
9488 parse_func = office2007_parse_hash;
9489 sort_by_digest = sort_by_digest_4_4;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_OFFICE2010;
9502 dgst_size = DGST_SIZE_4_4;
9503 parse_func = office2010_parse_hash;
9504 sort_by_digest = sort_by_digest_4_4;
9505 opti_type = OPTI_TYPE_ZERO_BYTE;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_OFFICE2013;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = office2013_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE;
9521 dgst_pos0 = 0;
9522 dgst_pos1 = 1;
9523 dgst_pos2 = 2;
9524 dgst_pos3 = 3;
9525 break;
9526
9527 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9528 salt_type = SALT_TYPE_EMBEDDED;
9529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9530 opts_type = OPTS_TYPE_PT_GENERATE_LE
9531 | OPTS_TYPE_PT_ADD80
9532 | OPTS_TYPE_PT_UNICODE;
9533 kern_type = KERN_TYPE_OLDOFFICE01;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = oldoffice01_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE
9538 | OPTI_TYPE_PRECOMPUTE_INIT
9539 | OPTI_TYPE_NOT_ITERATED;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE
9550 | OPTS_TYPE_PT_ADD80;
9551 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9552 dgst_size = DGST_SIZE_4_4;
9553 parse_func = oldoffice01cm1_parse_hash;
9554 sort_by_digest = sort_by_digest_4_4;
9555 opti_type = OPTI_TYPE_ZERO_BYTE
9556 | OPTI_TYPE_PRECOMPUTE_INIT
9557 | OPTI_TYPE_NOT_ITERATED;
9558 dgst_pos0 = 0;
9559 dgst_pos1 = 1;
9560 dgst_pos2 = 2;
9561 dgst_pos3 = 3;
9562 break;
9563
9564 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9565 salt_type = SALT_TYPE_EMBEDDED;
9566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9567 opts_type = OPTS_TYPE_PT_GENERATE_LE
9568 | OPTS_TYPE_PT_ADD80
9569 | OPTS_TYPE_PT_UNICODE
9570 | OPTS_TYPE_PT_NEVERCRACK;
9571 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9572 dgst_size = DGST_SIZE_4_4;
9573 parse_func = oldoffice01cm2_parse_hash;
9574 sort_by_digest = sort_by_digest_4_4;
9575 opti_type = OPTI_TYPE_ZERO_BYTE
9576 | OPTI_TYPE_PRECOMPUTE_INIT
9577 | OPTI_TYPE_NOT_ITERATED;
9578 dgst_pos0 = 0;
9579 dgst_pos1 = 1;
9580 dgst_pos2 = 2;
9581 dgst_pos3 = 3;
9582 break;
9583
9584 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9585 salt_type = SALT_TYPE_EMBEDDED;
9586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9587 opts_type = OPTS_TYPE_PT_GENERATE_BE
9588 | OPTS_TYPE_PT_ADD80
9589 | OPTS_TYPE_PT_UNICODE;
9590 kern_type = KERN_TYPE_OLDOFFICE34;
9591 dgst_size = DGST_SIZE_4_4;
9592 parse_func = oldoffice34_parse_hash;
9593 sort_by_digest = sort_by_digest_4_4;
9594 opti_type = OPTI_TYPE_ZERO_BYTE
9595 | OPTI_TYPE_PRECOMPUTE_INIT
9596 | OPTI_TYPE_NOT_ITERATED;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9608 dgst_size = DGST_SIZE_4_4;
9609 parse_func = oldoffice34cm1_parse_hash;
9610 sort_by_digest = sort_by_digest_4_4;
9611 opti_type = OPTI_TYPE_ZERO_BYTE
9612 | OPTI_TYPE_PRECOMPUTE_INIT
9613 | OPTI_TYPE_NOT_ITERATED;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_BE
9624 | OPTS_TYPE_PT_ADD80
9625 | OPTS_TYPE_PT_UNICODE
9626 | OPTS_TYPE_PT_NEVERCRACK;
9627 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9628 dgst_size = DGST_SIZE_4_4;
9629 parse_func = oldoffice34cm2_parse_hash;
9630 sort_by_digest = sort_by_digest_4_4;
9631 opti_type = OPTI_TYPE_ZERO_BYTE
9632 | OPTI_TYPE_PRECOMPUTE_INIT
9633 | OPTI_TYPE_NOT_ITERATED;
9634 dgst_pos0 = 0;
9635 dgst_pos1 = 1;
9636 dgst_pos2 = 2;
9637 dgst_pos3 = 3;
9638 break;
9639
9640 case 9900: hash_type = HASH_TYPE_MD5;
9641 salt_type = SALT_TYPE_NONE;
9642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9643 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9644 kern_type = KERN_TYPE_RADMIN2;
9645 dgst_size = DGST_SIZE_4_4;
9646 parse_func = radmin2_parse_hash;
9647 sort_by_digest = sort_by_digest_4_4;
9648 opti_type = OPTI_TYPE_ZERO_BYTE
9649 | OPTI_TYPE_PRECOMPUTE_INIT
9650 | OPTI_TYPE_EARLY_SKIP
9651 | OPTI_TYPE_NOT_ITERATED
9652 | OPTI_TYPE_NOT_SALTED;
9653 dgst_pos0 = 0;
9654 dgst_pos1 = 3;
9655 dgst_pos2 = 2;
9656 dgst_pos3 = 1;
9657 break;
9658
9659 case 10000: hash_type = HASH_TYPE_SHA256;
9660 salt_type = SALT_TYPE_EMBEDDED;
9661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9662 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9663 kern_type = KERN_TYPE_PBKDF2_SHA256;
9664 dgst_size = DGST_SIZE_4_32;
9665 parse_func = djangopbkdf2_parse_hash;
9666 sort_by_digest = sort_by_digest_4_32;
9667 opti_type = OPTI_TYPE_ZERO_BYTE;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 10100: hash_type = HASH_TYPE_SIPHASH;
9675 salt_type = SALT_TYPE_EMBEDDED;
9676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9678 kern_type = KERN_TYPE_SIPHASH;
9679 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9680 parse_func = siphash_parse_hash;
9681 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9682 opti_type = OPTI_TYPE_ZERO_BYTE
9683 | OPTI_TYPE_NOT_ITERATED
9684 | OPTI_TYPE_RAW_HASH;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 1;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 3;
9689 break;
9690
9691 case 10200: hash_type = HASH_TYPE_MD5;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE
9695 | OPTS_TYPE_ST_ADD80
9696 | OPTS_TYPE_ST_ADDBITS14;
9697 kern_type = KERN_TYPE_HMACMD5_PW;
9698 dgst_size = DGST_SIZE_4_4;
9699 parse_func = crammd5_parse_hash;
9700 sort_by_digest = sort_by_digest_4_4;
9701 opti_type = OPTI_TYPE_ZERO_BYTE
9702 | OPTI_TYPE_NOT_ITERATED;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 3;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 1;
9707 break;
9708
9709 case 10300: hash_type = HASH_TYPE_SHA1;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9713 kern_type = KERN_TYPE_SAPH_SHA1;
9714 dgst_size = DGST_SIZE_4_5;
9715 parse_func = saph_sha1_parse_hash;
9716 sort_by_digest = sort_by_digest_4_5;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 10400: hash_type = HASH_TYPE_PDFU16;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9728 kern_type = KERN_TYPE_PDF11;
9729 dgst_size = DGST_SIZE_4_4;
9730 parse_func = pdf11_parse_hash;
9731 sort_by_digest = sort_by_digest_4_4;
9732 opti_type = OPTI_TYPE_ZERO_BYTE
9733 | OPTI_TYPE_NOT_ITERATED;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 10410: hash_type = HASH_TYPE_PDFU16;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9744 kern_type = KERN_TYPE_PDF11CM1;
9745 dgst_size = DGST_SIZE_4_4;
9746 parse_func = pdf11cm1_parse_hash;
9747 sort_by_digest = sort_by_digest_4_4;
9748 opti_type = OPTI_TYPE_ZERO_BYTE
9749 | OPTI_TYPE_NOT_ITERATED;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 10420: hash_type = HASH_TYPE_PDFU16;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9760 kern_type = KERN_TYPE_PDF11CM2;
9761 dgst_size = DGST_SIZE_4_4;
9762 parse_func = pdf11cm2_parse_hash;
9763 sort_by_digest = sort_by_digest_4_4;
9764 opti_type = OPTI_TYPE_ZERO_BYTE
9765 | OPTI_TYPE_NOT_ITERATED;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 10500: hash_type = HASH_TYPE_PDFU16;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_PDF14;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = pdf14_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_NOT_ITERATED;
9782 dgst_pos0 = 0;
9783 dgst_pos1 = 1;
9784 dgst_pos2 = 2;
9785 dgst_pos3 = 3;
9786 break;
9787
9788 case 10600: hash_type = HASH_TYPE_SHA256;
9789 salt_type = SALT_TYPE_EMBEDDED;
9790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791 opts_type = OPTS_TYPE_PT_GENERATE_BE
9792 | OPTS_TYPE_ST_ADD80
9793 | OPTS_TYPE_ST_ADDBITS15
9794 | OPTS_TYPE_HASH_COPY;
9795 kern_type = KERN_TYPE_SHA256_PWSLT;
9796 dgst_size = DGST_SIZE_4_8;
9797 parse_func = pdf17l3_parse_hash;
9798 sort_by_digest = sort_by_digest_4_8;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_PRECOMPUTE_INIT
9801 | OPTI_TYPE_PRECOMPUTE_MERKLE
9802 | OPTI_TYPE_EARLY_SKIP
9803 | OPTI_TYPE_NOT_ITERATED
9804 | OPTI_TYPE_APPENDED_SALT
9805 | OPTI_TYPE_RAW_HASH;
9806 dgst_pos0 = 3;
9807 dgst_pos1 = 7;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 6;
9810 break;
9811
9812 case 10700: hash_type = HASH_TYPE_PDFU32;
9813 salt_type = SALT_TYPE_EMBEDDED;
9814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9815 opts_type = OPTS_TYPE_PT_GENERATE_LE
9816 | OPTS_TYPE_HASH_COPY;
9817 kern_type = KERN_TYPE_PDF17L8;
9818 dgst_size = DGST_SIZE_4_8;
9819 parse_func = pdf17l8_parse_hash;
9820 sort_by_digest = sort_by_digest_4_8;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_NOT_ITERATED;
9823 dgst_pos0 = 0;
9824 dgst_pos1 = 1;
9825 dgst_pos2 = 2;
9826 dgst_pos3 = 3;
9827 break;
9828
9829 case 10800: hash_type = HASH_TYPE_SHA384;
9830 salt_type = SALT_TYPE_NONE;
9831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9832 opts_type = OPTS_TYPE_PT_GENERATE_BE
9833 | OPTS_TYPE_PT_ADD80
9834 | OPTS_TYPE_PT_ADDBITS15;
9835 kern_type = KERN_TYPE_SHA384;
9836 dgst_size = DGST_SIZE_8_8;
9837 parse_func = sha384_parse_hash;
9838 sort_by_digest = sort_by_digest_8_8;
9839 opti_type = OPTI_TYPE_ZERO_BYTE
9840 | OPTI_TYPE_PRECOMPUTE_INIT
9841 | OPTI_TYPE_PRECOMPUTE_MERKLE
9842 | OPTI_TYPE_EARLY_SKIP
9843 | OPTI_TYPE_NOT_ITERATED
9844 | OPTI_TYPE_NOT_SALTED
9845 | OPTI_TYPE_USES_BITS_64
9846 | OPTI_TYPE_RAW_HASH;
9847 dgst_pos0 = 6;
9848 dgst_pos1 = 7;
9849 dgst_pos2 = 4;
9850 dgst_pos3 = 5;
9851 break;
9852
9853 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9854 salt_type = SALT_TYPE_EMBEDDED;
9855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_LE
9857 | OPTS_TYPE_ST_BASE64
9858 | OPTS_TYPE_HASH_COPY;
9859 kern_type = KERN_TYPE_PBKDF2_SHA256;
9860 dgst_size = DGST_SIZE_4_32;
9861 parse_func = pbkdf2_sha256_parse_hash;
9862 sort_by_digest = sort_by_digest_4_32;
9863 opti_type = OPTI_TYPE_ZERO_BYTE;
9864 dgst_pos0 = 0;
9865 dgst_pos1 = 1;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 3;
9868 break;
9869
9870 case 11000: hash_type = HASH_TYPE_MD5;
9871 salt_type = SALT_TYPE_INTERN;
9872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE
9874 | OPTS_TYPE_PT_ADD80;
9875 kern_type = KERN_TYPE_PRESTASHOP;
9876 dgst_size = DGST_SIZE_4_4;
9877 parse_func = prestashop_parse_hash;
9878 sort_by_digest = sort_by_digest_4_4;
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_PRECOMPUTE_INIT
9881 | OPTI_TYPE_NOT_ITERATED
9882 | OPTI_TYPE_PREPENDED_SALT;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 3;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 1;
9887 break;
9888
9889 case 11100: hash_type = HASH_TYPE_MD5;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE
9893 | OPTS_TYPE_ST_ADD80;
9894 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9895 dgst_size = DGST_SIZE_4_4;
9896 parse_func = postgresql_auth_parse_hash;
9897 sort_by_digest = sort_by_digest_4_4;
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_PRECOMPUTE_INIT
9900 | OPTI_TYPE_PRECOMPUTE_MERKLE
9901 | OPTI_TYPE_EARLY_SKIP;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 3;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 1;
9906 break;
9907
9908 case 11200: hash_type = HASH_TYPE_SHA1;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_BE
9912 | OPTS_TYPE_PT_ADD80
9913 | OPTS_TYPE_ST_HEX;
9914 kern_type = KERN_TYPE_MYSQL_AUTH;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = mysql_auth_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_EARLY_SKIP;
9920 dgst_pos0 = 3;
9921 dgst_pos1 = 4;
9922 dgst_pos2 = 2;
9923 dgst_pos3 = 1;
9924 break;
9925
9926 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9927 salt_type = SALT_TYPE_EMBEDDED;
9928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9929 opts_type = OPTS_TYPE_PT_GENERATE_LE
9930 | OPTS_TYPE_ST_HEX
9931 | OPTS_TYPE_ST_ADD80;
9932 kern_type = KERN_TYPE_BITCOIN_WALLET;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = bitcoin_wallet_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 11400: hash_type = HASH_TYPE_MD5;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE
9947 | OPTS_TYPE_PT_ADD80
9948 | OPTS_TYPE_HASH_COPY;
9949 kern_type = KERN_TYPE_SIP_AUTH;
9950 dgst_size = DGST_SIZE_4_4;
9951 parse_func = sip_auth_parse_hash;
9952 sort_by_digest = sort_by_digest_4_4;
9953 opti_type = OPTI_TYPE_ZERO_BYTE;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 3;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 1;
9958 break;
9959
9960 case 11500: hash_type = HASH_TYPE_CRC32;
9961 salt_type = SALT_TYPE_INTERN;
9962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_ST_GENERATE_LE
9965 | OPTS_TYPE_ST_HEX;
9966 kern_type = KERN_TYPE_CRC32;
9967 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9968 parse_func = crc32_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11600: hash_type = HASH_TYPE_AES;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_PT_NEVERCRACK;
9982 kern_type = KERN_TYPE_SEVEN_ZIP;
9983 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9984 parse_func = seven_zip_parse_hash;
9985 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9986 opti_type = OPTI_TYPE_ZERO_BYTE;
9987 dgst_pos0 = 0;
9988 dgst_pos1 = 1;
9989 dgst_pos2 = 2;
9990 dgst_pos3 = 3;
9991 break;
9992
9993 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9994 salt_type = SALT_TYPE_NONE;
9995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE
9997 | OPTS_TYPE_PT_ADD01;
9998 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9999 dgst_size = DGST_SIZE_4_8;
10000 parse_func = gost2012sbog_256_parse_hash;
10001 sort_by_digest = sort_by_digest_4_8;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10010 salt_type = SALT_TYPE_NONE;
10011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_PT_ADD01;
10014 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10015 dgst_size = DGST_SIZE_4_16;
10016 parse_func = gost2012sbog_512_parse_hash;
10017 sort_by_digest = sort_by_digest_4_16;
10018 opti_type = OPTI_TYPE_ZERO_BYTE;
10019 dgst_pos0 = 0;
10020 dgst_pos1 = 1;
10021 dgst_pos2 = 2;
10022 dgst_pos3 = 3;
10023 break;
10024
10025 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10026 salt_type = SALT_TYPE_EMBEDDED;
10027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10028 opts_type = OPTS_TYPE_PT_GENERATE_LE
10029 | OPTS_TYPE_ST_BASE64
10030 | OPTS_TYPE_HASH_COPY;
10031 kern_type = KERN_TYPE_PBKDF2_MD5;
10032 dgst_size = DGST_SIZE_4_32;
10033 parse_func = pbkdf2_md5_parse_hash;
10034 sort_by_digest = sort_by_digest_4_32;
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_ST_BASE64
10047 | OPTS_TYPE_HASH_COPY;
10048 kern_type = KERN_TYPE_PBKDF2_SHA1;
10049 dgst_size = DGST_SIZE_4_32;
10050 parse_func = pbkdf2_sha1_parse_hash;
10051 sort_by_digest = sort_by_digest_4_32;
10052 opti_type = OPTI_TYPE_ZERO_BYTE;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_ST_BASE64
10064 | OPTS_TYPE_HASH_COPY;
10065 kern_type = KERN_TYPE_PBKDF2_SHA512;
10066 dgst_size = DGST_SIZE_8_16;
10067 parse_func = pbkdf2_sha512_parse_hash;
10068 sort_by_digest = sort_by_digest_8_16;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_USES_BITS_64;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10081 kern_type = KERN_TYPE_ECRYPTFS;
10082 dgst_size = DGST_SIZE_8_8;
10083 parse_func = ecryptfs_parse_hash;
10084 sort_by_digest = sort_by_digest_8_8;
10085 opti_type = OPTI_TYPE_ZERO_BYTE
10086 | OPTI_TYPE_USES_BITS_64;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 1;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 3;
10091 break;
10092
10093 case 12300: hash_type = HASH_TYPE_ORACLET;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10097 kern_type = KERN_TYPE_ORACLET;
10098 dgst_size = DGST_SIZE_8_16;
10099 parse_func = oraclet_parse_hash;
10100 sort_by_digest = sort_by_digest_8_16;
10101 opti_type = OPTI_TYPE_ZERO_BYTE
10102 | OPTI_TYPE_USES_BITS_64;
10103 dgst_pos0 = 0;
10104 dgst_pos1 = 1;
10105 dgst_pos2 = 2;
10106 dgst_pos3 = 3;
10107 break;
10108
10109 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10110 salt_type = SALT_TYPE_EMBEDDED;
10111 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10112 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10113 kern_type = KERN_TYPE_BSDICRYPT;
10114 dgst_size = DGST_SIZE_4_4;
10115 parse_func = bsdicrypt_parse_hash;
10116 sort_by_digest = sort_by_digest_4_4;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 12500: hash_type = HASH_TYPE_RAR3HP;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_RAR3;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = rar3hp_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE;
10134 dgst_pos0 = 0;
10135 dgst_pos1 = 1;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 3;
10138 break;
10139
10140 case 12600: hash_type = HASH_TYPE_SHA256;
10141 salt_type = SALT_TYPE_INTERN;
10142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10143 opts_type = OPTS_TYPE_PT_GENERATE_BE
10144 | OPTS_TYPE_PT_ADD80;
10145 kern_type = KERN_TYPE_CF10;
10146 dgst_size = DGST_SIZE_4_8;
10147 parse_func = cf10_parse_hash;
10148 sort_by_digest = sort_by_digest_4_8;
10149 opti_type = OPTI_TYPE_ZERO_BYTE
10150 | OPTI_TYPE_PRECOMPUTE_INIT
10151 | OPTI_TYPE_EARLY_SKIP
10152 | OPTI_TYPE_NOT_ITERATED;
10153 dgst_pos0 = 3;
10154 dgst_pos1 = 7;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 6;
10157 break;
10158
10159 case 12700: hash_type = HASH_TYPE_AES;
10160 salt_type = SALT_TYPE_EMBEDDED;
10161 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE
10163 | OPTS_TYPE_HASH_COPY;
10164 kern_type = KERN_TYPE_MYWALLET;
10165 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10166 parse_func = mywallet_parse_hash;
10167 sort_by_digest = sort_by_digest_4_5;
10168 opti_type = OPTI_TYPE_ZERO_BYTE;
10169 dgst_pos0 = 0;
10170 dgst_pos1 = 1;
10171 dgst_pos2 = 2;
10172 dgst_pos3 = 3;
10173 break;
10174
10175 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10176 salt_type = SALT_TYPE_EMBEDDED;
10177 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10178 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10179 kern_type = KERN_TYPE_MS_DRSR;
10180 dgst_size = DGST_SIZE_4_8;
10181 parse_func = ms_drsr_parse_hash;
10182 sort_by_digest = sort_by_digest_4_8;
10183 opti_type = OPTI_TYPE_ZERO_BYTE;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 1;
10186 dgst_pos2 = 2;
10187 dgst_pos3 = 3;
10188 break;
10189
10190 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10194 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10195 dgst_size = DGST_SIZE_4_8;
10196 parse_func = androidfde_samsung_parse_hash;
10197 sort_by_digest = sort_by_digest_4_8;
10198 opti_type = OPTI_TYPE_ZERO_BYTE;
10199 dgst_pos0 = 0;
10200 dgst_pos1 = 1;
10201 dgst_pos2 = 2;
10202 dgst_pos3 = 3;
10203 break;
10204
10205 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10206 salt_type = SALT_TYPE_EMBEDDED;
10207 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10208 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10209 kern_type = KERN_TYPE_RAR5;
10210 dgst_size = DGST_SIZE_4_4;
10211 parse_func = rar5_parse_hash;
10212 sort_by_digest = sort_by_digest_4_4;
10213 opti_type = OPTI_TYPE_ZERO_BYTE;
10214 dgst_pos0 = 0;
10215 dgst_pos1 = 1;
10216 dgst_pos2 = 2;
10217 dgst_pos3 = 3;
10218 break;
10219
10220 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10221 salt_type = SALT_TYPE_EMBEDDED;
10222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10223 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10224 kern_type = KERN_TYPE_KRB5TGS;
10225 dgst_size = DGST_SIZE_4_4;
10226 parse_func = krb5tgs_parse_hash;
10227 sort_by_digest = sort_by_digest_4_4;
10228 opti_type = OPTI_TYPE_ZERO_BYTE
10229 | OPTI_TYPE_NOT_ITERATED;
10230 dgst_pos0 = 0;
10231 dgst_pos1 = 1;
10232 dgst_pos2 = 2;
10233 dgst_pos3 = 3;
10234 break;
10235
10236 case 13200: hash_type = HASH_TYPE_AES;
10237 salt_type = SALT_TYPE_EMBEDDED;
10238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10239 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10240 kern_type = KERN_TYPE_AXCRYPT;
10241 dgst_size = DGST_SIZE_4_4;
10242 parse_func = axcrypt_parse_hash;
10243 sort_by_digest = sort_by_digest_4_4;
10244 opti_type = OPTI_TYPE_ZERO_BYTE;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 1;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 3;
10249 break;
10250
10251 case 13300: hash_type = HASH_TYPE_SHA1;
10252 salt_type = SALT_TYPE_NONE;
10253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_BE
10255 | OPTS_TYPE_PT_ADD80
10256 | OPTS_TYPE_PT_ADDBITS15;
10257 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10258 dgst_size = DGST_SIZE_4_5;
10259 parse_func = sha1axcrypt_parse_hash;
10260 sort_by_digest = sort_by_digest_4_5;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_PRECOMPUTE_INIT
10263 | OPTI_TYPE_EARLY_SKIP
10264 | OPTI_TYPE_NOT_ITERATED
10265 | OPTI_TYPE_NOT_SALTED;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 4;
10268 dgst_pos2 = 3;
10269 dgst_pos3 = 2;
10270 break;
10271
10272 case 13400: hash_type = HASH_TYPE_AES;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10276 kern_type = KERN_TYPE_KEEPASS;
10277 dgst_size = DGST_SIZE_4_4;
10278 parse_func = keepass_parse_hash;
10279 sort_by_digest = sort_by_digest_4_4;
10280 opti_type = OPTI_TYPE_ZERO_BYTE;
10281 dgst_pos0 = 0;
10282 dgst_pos1 = 1;
10283 dgst_pos2 = 2;
10284 dgst_pos3 = 3;
10285 break;
10286
10287 default: usage_mini_print (PROGNAME); return (-1);
10288 }
10289
10290 /**
10291 * parser
10292 */
10293
10294 data.parse_func = parse_func;
10295
10296 /**
10297 * misc stuff
10298 */
10299
10300 if (hex_salt)
10301 {
10302 if (salt_type == SALT_TYPE_INTERN)
10303 {
10304 opts_type |= OPTS_TYPE_ST_HEX;
10305 }
10306 else
10307 {
10308 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10309
10310 return (-1);
10311 }
10312 }
10313
10314 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10315 | (salt_type == SALT_TYPE_EXTERN)
10316 | (salt_type == SALT_TYPE_EMBEDDED)
10317 | (salt_type == SALT_TYPE_VIRTUAL));
10318
10319 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10320
10321 data.hash_type = hash_type;
10322 data.attack_mode = attack_mode;
10323 data.attack_kern = attack_kern;
10324 data.attack_exec = attack_exec;
10325 data.kern_type = kern_type;
10326 data.opts_type = opts_type;
10327 data.dgst_size = dgst_size;
10328 data.salt_type = salt_type;
10329 data.isSalted = isSalted;
10330 data.sort_by_digest = sort_by_digest;
10331 data.dgst_pos0 = dgst_pos0;
10332 data.dgst_pos1 = dgst_pos1;
10333 data.dgst_pos2 = dgst_pos2;
10334 data.dgst_pos3 = dgst_pos3;
10335
10336 esalt_size = 0;
10337
10338 switch (hash_mode)
10339 {
10340 case 2500: esalt_size = sizeof (wpa_t); break;
10341 case 5300: esalt_size = sizeof (ikepsk_t); break;
10342 case 5400: esalt_size = sizeof (ikepsk_t); break;
10343 case 5500: esalt_size = sizeof (netntlm_t); break;
10344 case 5600: esalt_size = sizeof (netntlm_t); break;
10345 case 6211: esalt_size = sizeof (tc_t); break;
10346 case 6212: esalt_size = sizeof (tc_t); break;
10347 case 6213: esalt_size = sizeof (tc_t); break;
10348 case 6221: esalt_size = sizeof (tc_t); break;
10349 case 6222: esalt_size = sizeof (tc_t); break;
10350 case 6223: esalt_size = sizeof (tc_t); break;
10351 case 6231: esalt_size = sizeof (tc_t); break;
10352 case 6232: esalt_size = sizeof (tc_t); break;
10353 case 6233: esalt_size = sizeof (tc_t); break;
10354 case 6241: esalt_size = sizeof (tc_t); break;
10355 case 6242: esalt_size = sizeof (tc_t); break;
10356 case 6243: esalt_size = sizeof (tc_t); break;
10357 case 6600: esalt_size = sizeof (agilekey_t); break;
10358 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10359 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10360 case 7300: esalt_size = sizeof (rakp_t); break;
10361 case 7500: esalt_size = sizeof (krb5pa_t); break;
10362 case 8200: esalt_size = sizeof (cloudkey_t); break;
10363 case 8800: esalt_size = sizeof (androidfde_t); break;
10364 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10365 case 9400: esalt_size = sizeof (office2007_t); break;
10366 case 9500: esalt_size = sizeof (office2010_t); break;
10367 case 9600: esalt_size = sizeof (office2013_t); break;
10368 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10369 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10370 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10371 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10372 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10373 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10374 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10375 case 10200: esalt_size = sizeof (cram_md5_t); break;
10376 case 10400: esalt_size = sizeof (pdf_t); break;
10377 case 10410: esalt_size = sizeof (pdf_t); break;
10378 case 10420: esalt_size = sizeof (pdf_t); break;
10379 case 10500: esalt_size = sizeof (pdf_t); break;
10380 case 10600: esalt_size = sizeof (pdf_t); break;
10381 case 10700: esalt_size = sizeof (pdf_t); break;
10382 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10383 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10384 case 11400: esalt_size = sizeof (sip_t); break;
10385 case 11600: esalt_size = sizeof (seven_zip_t); break;
10386 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10387 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10388 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10389 case 13000: esalt_size = sizeof (rar5_t); break;
10390 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10391 case 13400: esalt_size = sizeof (keepass_t); break;
10392 }
10393
10394 data.esalt_size = esalt_size;
10395
10396 /**
10397 * choose dictionary parser
10398 */
10399
10400 if (hash_type == HASH_TYPE_LM)
10401 {
10402 get_next_word_func = get_next_word_lm;
10403 }
10404 else if (opts_type & OPTS_TYPE_PT_UPPER)
10405 {
10406 get_next_word_func = get_next_word_uc;
10407 }
10408 else
10409 {
10410 get_next_word_func = get_next_word_std;
10411 }
10412
10413 /**
10414 * dictstat
10415 */
10416
10417 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10418
10419 #ifdef _POSIX
10420 size_t dictstat_nmemb = 0;
10421 #endif
10422
10423 #ifdef _WIN
10424 uint dictstat_nmemb = 0;
10425 #endif
10426
10427 char dictstat[256] = { 0 };
10428
10429 FILE *dictstat_fp = NULL;
10430
10431 if (keyspace == 0)
10432 {
10433 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10434
10435 dictstat_fp = fopen (dictstat, "rb");
10436
10437 if (dictstat_fp)
10438 {
10439 #ifdef _POSIX
10440 struct stat tmpstat;
10441
10442 fstat (fileno (dictstat_fp), &tmpstat);
10443 #endif
10444
10445 #ifdef _WIN
10446 struct stat64 tmpstat;
10447
10448 _fstat64 (fileno (dictstat_fp), &tmpstat);
10449 #endif
10450
10451 if (tmpstat.st_mtime < COMPTIME)
10452 {
10453 /* with v0.15 the format changed so we have to ensure user is using a good version
10454 since there is no version-header in the dictstat file */
10455
10456 fclose (dictstat_fp);
10457
10458 unlink (dictstat);
10459 }
10460 else
10461 {
10462 while (!feof (dictstat_fp))
10463 {
10464 dictstat_t d;
10465
10466 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10467
10468 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10469
10470 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10471 {
10472 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10473
10474 return -1;
10475 }
10476 }
10477
10478 fclose (dictstat_fp);
10479 }
10480 }
10481 }
10482
10483 /**
10484 * potfile
10485 */
10486
10487 char potfile[256] = { 0 };
10488
10489 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10490
10491 data.pot_fp = NULL;
10492
10493 FILE *out_fp = NULL;
10494 FILE *pot_fp = NULL;
10495
10496 if (show == 1 || left == 1)
10497 {
10498 pot_fp = fopen (potfile, "rb");
10499
10500 if (pot_fp == NULL)
10501 {
10502 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10503
10504 return (-1);
10505 }
10506
10507 if (outfile != NULL)
10508 {
10509 if ((out_fp = fopen (outfile, "ab")) == NULL)
10510 {
10511 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10512
10513 fclose (pot_fp);
10514
10515 return (-1);
10516 }
10517 }
10518 else
10519 {
10520 out_fp = stdout;
10521 }
10522 }
10523 else
10524 {
10525 if (potfile_disable == 0)
10526 {
10527 pot_fp = fopen (potfile, "ab");
10528
10529 if (pot_fp == NULL)
10530 {
10531 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10532
10533 return (-1);
10534 }
10535
10536 data.pot_fp = pot_fp;
10537 }
10538 }
10539
10540 pot_t *pot = NULL;
10541
10542 uint pot_cnt = 0;
10543 uint pot_avail = 0;
10544
10545 if (show == 1 || left == 1)
10546 {
10547 SUPPRESS_OUTPUT = 1;
10548
10549 pot_avail = count_lines (pot_fp);
10550
10551 rewind (pot_fp);
10552
10553 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10554
10555 uint pot_hashes_avail = 0;
10556
10557 uint line_num = 0;
10558
10559 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10560
10561 while (!feof (pot_fp))
10562 {
10563 line_num++;
10564
10565 int line_len = fgetl (pot_fp, line_buf);
10566
10567 if (line_len == 0) continue;
10568
10569 char *plain_buf = line_buf + line_len;
10570
10571 pot_t *pot_ptr = &pot[pot_cnt];
10572
10573 hash_t *hashes_buf = &pot_ptr->hash;
10574
10575 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10576 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10577
10578 if (pot_cnt == pot_hashes_avail)
10579 {
10580 uint pos = 0;
10581
10582 for (pos = 0; pos < INCR_POT; pos++)
10583 {
10584 if ((pot_cnt + pos) >= pot_avail) break;
10585
10586 pot_t *tmp_pot = &pot[pot_cnt + pos];
10587
10588 hash_t *tmp_hash = &tmp_pot->hash;
10589
10590 tmp_hash->digest = mymalloc (dgst_size);
10591
10592 if (isSalted)
10593 {
10594 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10595 }
10596
10597 if (esalt_size)
10598 {
10599 tmp_hash->esalt = mymalloc (esalt_size);
10600 }
10601
10602 pot_hashes_avail++;
10603 }
10604 }
10605
10606 int plain_len = 0;
10607
10608 int parser_status;
10609
10610 int iter = MAX_CUT_TRIES;
10611
10612 do
10613 {
10614 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10615 {
10616 if (line_buf[i] == ':')
10617 {
10618 line_len--;
10619
10620 break;
10621 }
10622 }
10623
10624 if (data.hash_mode != 2500)
10625 {
10626 parser_status = parse_func (line_buf, line_len, hashes_buf);
10627 }
10628 else
10629 {
10630 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10631
10632 if (line_len > max_salt_size)
10633 {
10634 parser_status = PARSER_GLOBAL_LENGTH;
10635 }
10636 else
10637 {
10638 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10639
10640 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10641
10642 hashes_buf->salt->salt_len = line_len;
10643
10644 parser_status = PARSER_OK;
10645 }
10646 }
10647
10648 // if NOT parsed without error, we add the ":" to the plain
10649
10650 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10651 {
10652 plain_len++;
10653 plain_buf--;
10654 }
10655
10656 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10657
10658 if (parser_status < PARSER_GLOBAL_ZERO)
10659 {
10660 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10661
10662 continue;
10663 }
10664
10665 if (plain_len >= 255) continue;
10666
10667 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10668
10669 pot_ptr->plain_len = plain_len;
10670
10671 pot_cnt++;
10672 }
10673
10674 myfree (line_buf);
10675
10676 fclose (pot_fp);
10677
10678 SUPPRESS_OUTPUT = 0;
10679
10680 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10681 }
10682
10683 /**
10684 * word len
10685 */
10686
10687 uint pw_min = PW_MIN;
10688 uint pw_max = PW_MAX;
10689
10690 switch (hash_mode)
10691 {
10692 case 400: if (pw_max > 40) pw_max = 40;
10693 break;
10694 case 500: if (pw_max > 16) pw_max = 16;
10695 break;
10696 case 1500: if (pw_max > 8) pw_max = 8;
10697 break;
10698 case 1600: if (pw_max > 16) pw_max = 16;
10699 break;
10700 case 1800: if (pw_max > 16) pw_max = 16;
10701 break;
10702 case 2100: if (pw_max > 16) pw_max = 16;
10703 break;
10704 case 2500: if (pw_min < 8) pw_min = 8;
10705 break;
10706 case 3000: if (pw_max > 7) pw_max = 7;
10707 break;
10708 case 5200: if (pw_max > 24) pw_max = 24;
10709 break;
10710 case 5800: if (pw_max > 16) pw_max = 16;
10711 break;
10712 case 6300: if (pw_max > 16) pw_max = 16;
10713 break;
10714 case 7400: if (pw_max > 16) pw_max = 16;
10715 break;
10716 case 7900: if (pw_max > 48) pw_max = 48;
10717 break;
10718 case 8500: if (pw_max > 8) pw_max = 8;
10719 break;
10720 case 8600: if (pw_max > 16) pw_max = 16;
10721 break;
10722 case 9710: pw_min = 5;
10723 pw_max = 5;
10724 break;
10725 case 9810: pw_min = 5;
10726 pw_max = 5;
10727 break;
10728 case 10410: pw_min = 5;
10729 pw_max = 5;
10730 break;
10731 case 10300: if (pw_max < 3) pw_min = 3;
10732 if (pw_max > 40) pw_max = 40;
10733 break;
10734 case 10500: if (pw_max < 3) pw_min = 3;
10735 if (pw_max > 40) pw_max = 40;
10736 break;
10737 case 10700: if (pw_max > 16) pw_max = 16;
10738 break;
10739 case 11300: if (pw_max > 40) pw_max = 40;
10740 break;
10741 case 12500: if (pw_max > 20) pw_max = 20;
10742 break;
10743 case 12800: if (pw_max > 24) pw_max = 24;
10744 break;
10745 }
10746
10747 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10748 {
10749 switch (attack_kern)
10750 {
10751 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10752 break;
10753 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10754 break;
10755 }
10756 }
10757
10758 /**
10759 * charsets : keep them together for more easy maintainnce
10760 */
10761
10762 cs_t mp_sys[6] = { { { 0 }, 0 } };
10763 cs_t mp_usr[4] = { { { 0 }, 0 } };
10764
10765 mp_setup_sys (mp_sys);
10766
10767 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10768 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10769 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10770 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10771
10772 /**
10773 * load hashes, part I: find input mode, count hashes
10774 */
10775
10776 uint hashlist_mode = 0;
10777 uint hashlist_format = HLFMT_HASHCAT;
10778
10779 uint hashes_avail = 0;
10780
10781 if (benchmark == 0)
10782 {
10783 struct stat f;
10784
10785 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10786
10787 if ((hash_mode == 2500) ||
10788 (hash_mode == 5200) ||
10789 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10790 (hash_mode == 9000))
10791 {
10792 hashlist_mode = HL_MODE_ARG;
10793
10794 char *hashfile = myargv[optind];
10795
10796 data.hashfile = hashfile;
10797
10798 logfile_top_var_string ("target", hashfile);
10799 }
10800
10801 if (hashlist_mode == HL_MODE_ARG)
10802 {
10803 if (hash_mode == 2500)
10804 {
10805 struct stat st;
10806
10807 if (stat (data.hashfile, &st) == -1)
10808 {
10809 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10810
10811 return (-1);
10812 }
10813
10814 hashes_avail = st.st_size / sizeof (hccap_t);
10815 }
10816 else
10817 {
10818 hashes_avail = 1;
10819 }
10820 }
10821 else if (hashlist_mode == HL_MODE_FILE)
10822 {
10823 char *hashfile = myargv[optind];
10824
10825 data.hashfile = hashfile;
10826
10827 logfile_top_var_string ("target", hashfile);
10828
10829 FILE *fp = NULL;
10830
10831 if ((fp = fopen (hashfile, "rb")) == NULL)
10832 {
10833 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10834
10835 return (-1);
10836 }
10837
10838 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10839
10840 hashes_avail = count_lines (fp);
10841
10842 rewind (fp);
10843
10844 if (hashes_avail == 0)
10845 {
10846 log_error ("ERROR: hashfile is empty or corrupt");
10847
10848 fclose (fp);
10849
10850 return (-1);
10851 }
10852
10853 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10854
10855 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10856 {
10857 log_error ("ERROR: remove not supported in native hashfile-format mode");
10858
10859 fclose (fp);
10860
10861 return (-1);
10862 }
10863
10864 fclose (fp);
10865 }
10866 }
10867 else
10868 {
10869 hashlist_mode = HL_MODE_ARG;
10870
10871 hashes_avail = 1;
10872 }
10873
10874 if (hash_mode == 3000) hashes_avail *= 2;
10875
10876 data.hashlist_mode = hashlist_mode;
10877 data.hashlist_format = hashlist_format;
10878
10879 logfile_top_uint (hashlist_mode);
10880 logfile_top_uint (hashlist_format);
10881
10882 /**
10883 * load hashes, part II: allocate required memory, set pointers
10884 */
10885
10886 hash_t *hashes_buf = NULL;
10887 void *digests_buf = NULL;
10888 salt_t *salts_buf = NULL;
10889 void *esalts_buf = NULL;
10890
10891 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10892
10893 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10894
10895 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10896 {
10897 u32 hash_pos;
10898
10899 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10900 {
10901 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10902
10903 hashes_buf[hash_pos].hash_info = hash_info;
10904
10905 if (username && (remove || show || left))
10906 {
10907 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10908 }
10909
10910 if (benchmark)
10911 {
10912 hash_info->orighash = (char *) mymalloc (256);
10913 }
10914 }
10915 }
10916
10917 if (isSalted)
10918 {
10919 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10920
10921 if (esalt_size)
10922 {
10923 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10924 }
10925 }
10926 else
10927 {
10928 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10929 }
10930
10931 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10932 {
10933 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10934
10935 if (isSalted)
10936 {
10937 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10938
10939 if (esalt_size)
10940 {
10941 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10942 }
10943 }
10944 else
10945 {
10946 hashes_buf[hash_pos].salt = &salts_buf[0];
10947 }
10948 }
10949
10950 /**
10951 * load hashes, part III: parse hashes or generate them if benchmark
10952 */
10953
10954 uint hashes_cnt = 0;
10955
10956 if (benchmark == 0)
10957 {
10958 if (keyspace == 1)
10959 {
10960 // useless to read hash file for keyspace, cheat a little bit w/ optind
10961 }
10962 else if (hashes_avail == 0)
10963 {
10964 }
10965 else if (hashlist_mode == HL_MODE_ARG)
10966 {
10967 char *input_buf = myargv[optind];
10968
10969 uint input_len = strlen (input_buf);
10970
10971 logfile_top_var_string ("target", input_buf);
10972
10973 char *hash_buf = NULL;
10974 int hash_len = 0;
10975
10976 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10977
10978 bool hash_fmt_error = 0;
10979
10980 if (hash_len < 1) hash_fmt_error = 1;
10981 if (hash_buf == NULL) hash_fmt_error = 1;
10982
10983 if (hash_fmt_error)
10984 {
10985 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
10986 }
10987 else
10988 {
10989 if (opts_type & OPTS_TYPE_HASH_COPY)
10990 {
10991 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10992
10993 hash_info_tmp->orighash = mystrdup (hash_buf);
10994 }
10995
10996 if (isSalted)
10997 {
10998 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10999 }
11000
11001 int parser_status = PARSER_OK;
11002
11003 if (hash_mode == 2500)
11004 {
11005 if (hash_len == 0)
11006 {
11007 log_error ("ERROR: hccap file not specified");
11008
11009 return (-1);
11010 }
11011
11012 hashlist_mode = HL_MODE_FILE;
11013
11014 data.hashlist_mode = hashlist_mode;
11015
11016 FILE *fp = fopen (hash_buf, "rb");
11017
11018 if (fp == NULL)
11019 {
11020 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11021
11022 return (-1);
11023 }
11024
11025 if (hashes_avail < 1)
11026 {
11027 log_error ("ERROR: hccap file is empty or corrupt");
11028
11029 fclose (fp);
11030
11031 return (-1);
11032 }
11033
11034 uint hccap_size = sizeof (hccap_t);
11035
11036 char *in = (char *) mymalloc (hccap_size);
11037
11038 while (!feof (fp))
11039 {
11040 int n = fread (in, hccap_size, 1, fp);
11041
11042 if (n != 1)
11043 {
11044 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11045
11046 break;
11047 }
11048
11049 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11050
11051 if (parser_status != PARSER_OK)
11052 {
11053 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11054
11055 continue;
11056 }
11057
11058 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11059
11060 if ((show == 1) || (left == 1))
11061 {
11062 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11063
11064 char *salt_ptr = (char *) tmp_salt->salt_buf;
11065
11066 int cur_pos = tmp_salt->salt_len;
11067 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11068
11069 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11070
11071 u8 *pke_ptr = (u8 *) wpa->pke;
11072
11073 // do the appending task
11074
11075 snprintf (salt_ptr + cur_pos,
11076 rem_len,
11077 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11078 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11079 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11080
11081
11082 // memset () the remaining part of the salt
11083
11084 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11085 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11086
11087 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11088
11089 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11090 }
11091
11092 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);
11093 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);
11094
11095 hashes_cnt++;
11096 }
11097
11098 fclose (fp);
11099
11100 myfree (in);
11101 }
11102 else if (hash_mode == 3000)
11103 {
11104 if (hash_len == 32)
11105 {
11106 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11107
11108 hash_t *lm_hash_left = NULL;
11109
11110 if (parser_status == PARSER_OK)
11111 {
11112 lm_hash_left = &hashes_buf[hashes_cnt];
11113
11114 hashes_cnt++;
11115 }
11116 else
11117 {
11118 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11119 }
11120
11121 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11122
11123 hash_t *lm_hash_right = NULL;
11124
11125 if (parser_status == PARSER_OK)
11126 {
11127 lm_hash_right = &hashes_buf[hashes_cnt];
11128
11129 hashes_cnt++;
11130 }
11131 else
11132 {
11133 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11134 }
11135
11136 // show / left
11137
11138 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11139 {
11140 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);
11141 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);
11142 }
11143 }
11144 else
11145 {
11146 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11147
11148 if (parser_status == PARSER_OK)
11149 {
11150 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11151 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11152 }
11153
11154 if (parser_status == PARSER_OK)
11155 {
11156 hashes_cnt++;
11157 }
11158 else
11159 {
11160 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11161 }
11162 }
11163 }
11164 else
11165 {
11166 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11167
11168 if (parser_status == PARSER_OK)
11169 {
11170 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11171 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11172 }
11173
11174 if (parser_status == PARSER_OK)
11175 {
11176 hashes_cnt++;
11177 }
11178 else
11179 {
11180 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11181 }
11182 }
11183 }
11184 }
11185 else if (hashlist_mode == HL_MODE_FILE)
11186 {
11187 char *hashfile = data.hashfile;
11188
11189 FILE *fp;
11190
11191 if ((fp = fopen (hashfile, "rb")) == NULL)
11192 {
11193 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11194
11195 return (-1);
11196 }
11197
11198 uint line_num = 0;
11199
11200 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11201
11202 while (!feof (fp))
11203 {
11204 line_num++;
11205
11206 int line_len = fgetl (fp, line_buf);
11207
11208 if (line_len == 0) continue;
11209
11210 char *hash_buf = NULL;
11211 int hash_len = 0;
11212
11213 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11214
11215 bool hash_fmt_error = 0;
11216
11217 if (hash_len < 1) hash_fmt_error = 1;
11218 if (hash_buf == NULL) hash_fmt_error = 1;
11219
11220 if (hash_fmt_error)
11221 {
11222 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11223
11224 continue;
11225 }
11226
11227 if (username)
11228 {
11229 char *user_buf = NULL;
11230 int user_len = 0;
11231
11232 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11233
11234 if (remove || show)
11235 {
11236 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11237
11238 *user = (user_t *) mymalloc (sizeof (user_t));
11239
11240 user_t *user_ptr = *user;
11241
11242 if (user_buf != NULL)
11243 {
11244 user_ptr->user_name = mystrdup (user_buf);
11245 }
11246 else
11247 {
11248 user_ptr->user_name = mystrdup ("");
11249 }
11250
11251 user_ptr->user_len = user_len;
11252 }
11253 }
11254
11255 if (opts_type & OPTS_TYPE_HASH_COPY)
11256 {
11257 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11258
11259 hash_info_tmp->orighash = mystrdup (hash_buf);
11260 }
11261
11262 if (isSalted)
11263 {
11264 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11265 }
11266
11267 if (hash_mode == 3000)
11268 {
11269 if (hash_len == 32)
11270 {
11271 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11272
11273 if (parser_status < PARSER_GLOBAL_ZERO)
11274 {
11275 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11276
11277 continue;
11278 }
11279
11280 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11281
11282 hashes_cnt++;
11283
11284 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11285
11286 if (parser_status < PARSER_GLOBAL_ZERO)
11287 {
11288 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11289
11290 continue;
11291 }
11292
11293 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11294
11295 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);
11296
11297 hashes_cnt++;
11298
11299 // show / left
11300
11301 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);
11302 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);
11303 }
11304 else
11305 {
11306 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11307
11308 if (parser_status < PARSER_GLOBAL_ZERO)
11309 {
11310 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11311
11312 continue;
11313 }
11314
11315 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);
11316
11317 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11318 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11319
11320 hashes_cnt++;
11321 }
11322 }
11323 else
11324 {
11325 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11326
11327 if (parser_status < PARSER_GLOBAL_ZERO)
11328 {
11329 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11330
11331 continue;
11332 }
11333
11334 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);
11335
11336 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11337 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11338
11339 hashes_cnt++;
11340 }
11341 }
11342
11343 myfree (line_buf);
11344
11345 fclose (fp);
11346
11347 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11348
11349 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11350 }
11351 }
11352 else
11353 {
11354 if (isSalted)
11355 {
11356 hashes_buf[0].salt->salt_len = 8;
11357
11358 // special salt handling
11359
11360 switch (hash_mode)
11361 {
11362 case 1500: hashes_buf[0].salt->salt_len = 2;
11363 break;
11364 case 1731: hashes_buf[0].salt->salt_len = 4;
11365 break;
11366 case 2410: hashes_buf[0].salt->salt_len = 4;
11367 break;
11368 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11369 break;
11370 case 3100: hashes_buf[0].salt->salt_len = 1;
11371 break;
11372 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11373 break;
11374 case 5800: hashes_buf[0].salt->salt_len = 16;
11375 break;
11376 case 6800: hashes_buf[0].salt->salt_len = 32;
11377 break;
11378 case 8400: hashes_buf[0].salt->salt_len = 40;
11379 break;
11380 case 8800: hashes_buf[0].salt->salt_len = 16;
11381 break;
11382 case 8900: hashes_buf[0].salt->salt_len = 16;
11383 hashes_buf[0].salt->scrypt_N = 1024;
11384 hashes_buf[0].salt->scrypt_r = 1;
11385 hashes_buf[0].salt->scrypt_p = 1;
11386 break;
11387 case 9100: hashes_buf[0].salt->salt_len = 16;
11388 break;
11389 case 9300: hashes_buf[0].salt->salt_len = 14;
11390 hashes_buf[0].salt->scrypt_N = 16384;
11391 hashes_buf[0].salt->scrypt_r = 1;
11392 hashes_buf[0].salt->scrypt_p = 1;
11393 break;
11394 case 9400: hashes_buf[0].salt->salt_len = 16;
11395 break;
11396 case 9500: hashes_buf[0].salt->salt_len = 16;
11397 break;
11398 case 9600: hashes_buf[0].salt->salt_len = 16;
11399 break;
11400 case 9700: hashes_buf[0].salt->salt_len = 16;
11401 break;
11402 case 9710: hashes_buf[0].salt->salt_len = 16;
11403 break;
11404 case 9720: hashes_buf[0].salt->salt_len = 16;
11405 break;
11406 case 9800: hashes_buf[0].salt->salt_len = 16;
11407 break;
11408 case 9810: hashes_buf[0].salt->salt_len = 16;
11409 break;
11410 case 9820: hashes_buf[0].salt->salt_len = 16;
11411 break;
11412 case 10300: hashes_buf[0].salt->salt_len = 12;
11413 break;
11414 case 11500: hashes_buf[0].salt->salt_len = 4;
11415 break;
11416 case 11600: hashes_buf[0].salt->salt_len = 4;
11417 break;
11418 case 12400: hashes_buf[0].salt->salt_len = 4;
11419 break;
11420 case 12500: hashes_buf[0].salt->salt_len = 8;
11421 break;
11422 case 12600: hashes_buf[0].salt->salt_len = 64;
11423 break;
11424 }
11425
11426 // special esalt handling
11427
11428 switch (hash_mode)
11429 {
11430 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11431 break;
11432 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11433 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11434 break;
11435 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11436 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11437 break;
11438 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11439 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11440 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11441 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11442 break;
11443 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11444 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11445 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11446 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11447 break;
11448 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11449 break;
11450 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11451 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11452 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11453 break;
11454 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11455 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11456 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11457 break;
11458 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11459 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11460 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11461 break;
11462 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11463 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11464 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11465 break;
11466 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11467 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11468 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11469 break;
11470 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11471 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11472 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11473 break;
11474 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11475 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11476 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11477 break;
11478 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11479 break;
11480 }
11481 }
11482
11483 // set hashfile
11484
11485 switch (hash_mode)
11486 {
11487 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11488 break;
11489 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11490 break;
11491 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11492 break;
11493 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11494 break;
11495 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11496 break;
11497 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11498 break;
11499 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11500 break;
11501 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11502 break;
11503 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11504 break;
11505 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11506 break;
11507 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11508 break;
11509 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11510 break;
11511 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11512 break;
11513 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11514 break;
11515 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11516 break;
11517 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11518 break;
11519 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11520 break;
11521 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11522 break;
11523 }
11524
11525 // set default iterations
11526
11527 switch (hash_mode)
11528 {
11529 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11530 break;
11531 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11532 break;
11533 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11534 break;
11535 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11536 break;
11537 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11538 break;
11539 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11540 break;
11541 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11542 break;
11543 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11544 break;
11545 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11546 break;
11547 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11548 break;
11549 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11550 break;
11551 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11552 break;
11553 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11554 break;
11555 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11556 break;
11557 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11558 break;
11559 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11560 break;
11561 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11562 break;
11563 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11564 break;
11565 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11566 break;
11567 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11568 break;
11569 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11570 break;
11571 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11572 break;
11573 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11574 break;
11575 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11576 break;
11577 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11578 break;
11579 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11580 break;
11581 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11582 break;
11583 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11584 break;
11585 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11586 break;
11587 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11588 break;
11589 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11590 break;
11591 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11592 break;
11593 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11594 break;
11595 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11596 break;
11597 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11598 break;
11599 case 8900: hashes_buf[0].salt->salt_iter = 1;
11600 break;
11601 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11602 break;
11603 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11604 break;
11605 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11606 break;
11607 case 9300: hashes_buf[0].salt->salt_iter = 1;
11608 break;
11609 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11610 break;
11611 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11612 break;
11613 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11614 break;
11615 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11616 break;
11617 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11618 break;
11619 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11620 break;
11621 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11622 break;
11623 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11624 break;
11625 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11626 break;
11627 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11628 break;
11629 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11630 break;
11631 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11632 break;
11633 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11634 break;
11635 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11636 break;
11637 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11638 break;
11639 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11640 break;
11641 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11642 break;
11643 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11644 break;
11645 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11646 break;
11647 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11648 break;
11649 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11650 break;
11651 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
11652 break;
11653 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
11654 break;
11655 }
11656
11657 hashes_cnt = 1;
11658 }
11659
11660 if (show == 1 || left == 1)
11661 {
11662 for (uint i = 0; i < pot_cnt; i++)
11663 {
11664 pot_t *pot_ptr = &pot[i];
11665
11666 hash_t *hashes_buf = &pot_ptr->hash;
11667
11668 local_free (hashes_buf->digest);
11669
11670 if (isSalted)
11671 {
11672 local_free (hashes_buf->salt);
11673 }
11674 }
11675
11676 local_free (pot);
11677
11678 if (data.quiet == 0) log_info_nn ("");
11679
11680 return (0);
11681 }
11682
11683 if (keyspace == 0)
11684 {
11685 if (hashes_cnt == 0)
11686 {
11687 log_error ("ERROR: No hashes loaded");
11688
11689 return (-1);
11690 }
11691 }
11692
11693 /**
11694 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11695 */
11696
11697 if (data.outfile != NULL)
11698 {
11699 if (data.hashfile != NULL)
11700 {
11701 #ifdef _POSIX
11702 struct stat tmpstat_outfile;
11703 struct stat tmpstat_hashfile;
11704 #endif
11705
11706 #ifdef _WIN
11707 struct stat64 tmpstat_outfile;
11708 struct stat64 tmpstat_hashfile;
11709 #endif
11710
11711 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11712
11713 if (tmp_outfile_fp)
11714 {
11715 #ifdef _POSIX
11716 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11717 #endif
11718
11719 #ifdef _WIN
11720 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11721 #endif
11722
11723 fclose (tmp_outfile_fp);
11724 }
11725
11726 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11727
11728 if (tmp_hashfile_fp)
11729 {
11730 #ifdef _POSIX
11731 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11732 #endif
11733
11734 #ifdef _WIN
11735 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11736 #endif
11737
11738 fclose (tmp_hashfile_fp);
11739 }
11740
11741 if (tmp_outfile_fp && tmp_outfile_fp)
11742 {
11743 tmpstat_outfile.st_mode = 0;
11744 tmpstat_outfile.st_nlink = 0;
11745 tmpstat_outfile.st_uid = 0;
11746 tmpstat_outfile.st_gid = 0;
11747 tmpstat_outfile.st_rdev = 0;
11748 tmpstat_outfile.st_atime = 0;
11749
11750 tmpstat_hashfile.st_mode = 0;
11751 tmpstat_hashfile.st_nlink = 0;
11752 tmpstat_hashfile.st_uid = 0;
11753 tmpstat_hashfile.st_gid = 0;
11754 tmpstat_hashfile.st_rdev = 0;
11755 tmpstat_hashfile.st_atime = 0;
11756
11757 #ifdef _POSIX
11758 tmpstat_outfile.st_blksize = 0;
11759 tmpstat_outfile.st_blocks = 0;
11760
11761 tmpstat_hashfile.st_blksize = 0;
11762 tmpstat_hashfile.st_blocks = 0;
11763 #endif
11764
11765 #ifdef _POSIX
11766 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11767 {
11768 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11769
11770 return (-1);
11771 }
11772 #endif
11773
11774 #ifdef _WIN
11775 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11776 {
11777 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11778
11779 return (-1);
11780 }
11781 #endif
11782 }
11783 }
11784 }
11785
11786 /**
11787 * Remove duplicates
11788 */
11789
11790 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11791
11792 if (isSalted)
11793 {
11794 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11795 }
11796 else
11797 {
11798 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11799 }
11800
11801 uint hashes_cnt_orig = hashes_cnt;
11802
11803 hashes_cnt = 1;
11804
11805 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11806 {
11807 if (isSalted)
11808 {
11809 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11810 {
11811 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11812 }
11813 }
11814 else
11815 {
11816 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11817 }
11818
11819 if (hashes_pos > hashes_cnt)
11820 {
11821 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11822 }
11823
11824 hashes_cnt++;
11825 }
11826
11827 /**
11828 * Potfile removes
11829 */
11830
11831 uint potfile_remove_cracks = 0;
11832
11833 if (potfile_disable == 0)
11834 {
11835 hash_t hash_buf;
11836
11837 hash_buf.digest = mymalloc (dgst_size);
11838 hash_buf.salt = NULL;
11839 hash_buf.esalt = NULL;
11840 hash_buf.hash_info = NULL;
11841 hash_buf.cracked = 0;
11842
11843 if (isSalted)
11844 {
11845 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11846 }
11847
11848 if (esalt_size)
11849 {
11850 hash_buf.esalt = mymalloc (esalt_size);
11851 }
11852
11853 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11854
11855 // no solution for these special hash types (for instane because they use hashfile in output etc)
11856 if ((hash_mode != 5200) &&
11857 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11858 (hash_mode != 9000))
11859 {
11860 FILE *fp = fopen (potfile, "rb");
11861
11862 if (fp != NULL)
11863 {
11864 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11865
11866 // to be safe work with a copy (because of line_len loop, i etc)
11867 // moved up here because it's easier to handle continue case
11868 // it's just 64kb
11869
11870 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
11871
11872 while (!feof (fp))
11873 {
11874 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
11875
11876 if (ptr == NULL) break;
11877
11878 int line_len = strlen (line_buf);
11879
11880 if (line_len == 0) continue;
11881
11882 int iter = MAX_CUT_TRIES;
11883
11884 for (int i = line_len - 1; i && iter; i--, line_len--)
11885 {
11886 if (line_buf[i] != ':') continue;
11887
11888 if (isSalted)
11889 {
11890 memset (hash_buf.salt, 0, sizeof (salt_t));
11891 }
11892
11893 hash_t *found = NULL;
11894
11895 if (hash_mode == 6800)
11896 {
11897 if (i < 64) // 64 = 16 * uint in salt_buf[]
11898 {
11899 // manipulate salt_buf
11900 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11901
11902 hash_buf.salt->salt_len = i;
11903
11904 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11905 }
11906 }
11907 else if (hash_mode == 2500)
11908 {
11909 if (i < 64) // 64 = 16 * uint in salt_buf[]
11910 {
11911 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11912 // manipulate salt_buf
11913
11914 memcpy (line_buf_cpy, line_buf, i);
11915
11916 char *mac2_pos = strrchr (line_buf_cpy, ':');
11917
11918 if (mac2_pos == NULL) continue;
11919
11920 mac2_pos[0] = 0;
11921 mac2_pos++;
11922
11923 if (strlen (mac2_pos) != 12) continue;
11924
11925 char *mac1_pos = strrchr (line_buf_cpy, ':');
11926
11927 if (mac1_pos == NULL) continue;
11928
11929 mac1_pos[0] = 0;
11930 mac1_pos++;
11931
11932 if (strlen (mac1_pos) != 12) continue;
11933
11934 uint essid_length = mac1_pos - line_buf_cpy - 1;
11935
11936 // here we need the ESSID
11937 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11938
11939 hash_buf.salt->salt_len = essid_length;
11940
11941 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11942
11943 if (found)
11944 {
11945 wpa_t *wpa = (wpa_t *) found->esalt;
11946
11947 uint pke[25] = { 0 };
11948
11949 char *pke_ptr = (char *) pke;
11950
11951 for (uint i = 0; i < 25; i++)
11952 {
11953 pke[i] = byte_swap_32 (wpa->pke[i]);
11954 }
11955
11956 u8 mac1[6] = { 0 };
11957 u8 mac2[6] = { 0 };
11958
11959 memcpy (mac1, pke_ptr + 23, 6);
11960 memcpy (mac2, pke_ptr + 29, 6);
11961
11962 // compare hex string(s) vs binary MAC address(es)
11963
11964 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11965 {
11966 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11967 {
11968 found = NULL;
11969 break;
11970 }
11971 }
11972
11973 // early skip ;)
11974 if (!found) continue;
11975
11976 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11977 {
11978 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11979 {
11980 found = NULL;
11981 break;
11982 }
11983 }
11984 }
11985 }
11986 }
11987 else
11988 {
11989 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11990
11991 if (parser_status == PARSER_OK)
11992 {
11993 if (isSalted)
11994 {
11995 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11996 }
11997 else
11998 {
11999 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12000 }
12001 }
12002 }
12003
12004 if (found == NULL) continue;
12005
12006 if (!found->cracked) potfile_remove_cracks++;
12007
12008 found->cracked = 1;
12009
12010 if (found) break;
12011
12012 iter--;
12013 }
12014 }
12015
12016 myfree (line_buf_cpy);
12017
12018 myfree (line_buf);
12019
12020 fclose (fp);
12021 }
12022 }
12023
12024 if (esalt_size)
12025 {
12026 local_free (hash_buf.esalt);
12027 }
12028
12029 if (isSalted)
12030 {
12031 local_free (hash_buf.salt);
12032 }
12033
12034 local_free (hash_buf.digest);
12035 }
12036
12037 /**
12038 * Now generate all the buffers required for later
12039 */
12040
12041 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12042
12043 salt_t *salts_buf_new = NULL;
12044 void *esalts_buf_new = NULL;
12045
12046 if (isSalted)
12047 {
12048 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12049
12050 if (esalt_size)
12051 {
12052 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12053 }
12054 }
12055 else
12056 {
12057 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12058 }
12059
12060 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12061
12062 uint digests_cnt = hashes_cnt;
12063 uint digests_done = 0;
12064
12065 uint size_digests = digests_cnt * dgst_size;
12066 uint size_shown = digests_cnt * sizeof (uint);
12067
12068 uint *digests_shown = (uint *) mymalloc (size_shown);
12069 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12070
12071 uint salts_cnt = 0;
12072 uint salts_done = 0;
12073
12074 hashinfo_t **hash_info = NULL;
12075
12076 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12077 {
12078 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12079
12080 if (username && (remove || show))
12081 {
12082 uint user_pos;
12083
12084 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12085 {
12086 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12087
12088 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12089 }
12090 }
12091 }
12092
12093 uint *salts_shown = (uint *) mymalloc (size_shown);
12094
12095 salt_t *salt_buf;
12096
12097 {
12098 // copied from inner loop
12099
12100 salt_buf = &salts_buf_new[salts_cnt];
12101
12102 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12103
12104 if (esalt_size)
12105 {
12106 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12107 }
12108
12109 salt_buf->digests_cnt = 0;
12110 salt_buf->digests_done = 0;
12111 salt_buf->digests_offset = 0;
12112
12113 salts_cnt++;
12114 }
12115
12116 if (hashes_buf[0].cracked == 1)
12117 {
12118 digests_shown[0] = 1;
12119
12120 digests_done++;
12121
12122 salt_buf->digests_done++;
12123 }
12124
12125 salt_buf->digests_cnt++;
12126
12127 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12128
12129 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12130 {
12131 hash_info[0] = hashes_buf[0].hash_info;
12132 }
12133
12134 // copy from inner loop
12135
12136 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12137 {
12138 if (isSalted)
12139 {
12140 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12141 {
12142 salt_buf = &salts_buf_new[salts_cnt];
12143
12144 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12145
12146 if (esalt_size)
12147 {
12148 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12149 }
12150
12151 salt_buf->digests_cnt = 0;
12152 salt_buf->digests_done = 0;
12153 salt_buf->digests_offset = hashes_pos;
12154
12155 salts_cnt++;
12156 }
12157 }
12158
12159 if (hashes_buf[hashes_pos].cracked == 1)
12160 {
12161 digests_shown[hashes_pos] = 1;
12162
12163 digests_done++;
12164
12165 salt_buf->digests_done++;
12166 }
12167
12168 salt_buf->digests_cnt++;
12169
12170 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12171
12172 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12173 {
12174 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12175 }
12176 }
12177
12178 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12179 {
12180 salt_t *salt_buf = &salts_buf_new[salt_pos];
12181
12182 if (salt_buf->digests_done == salt_buf->digests_cnt)
12183 {
12184 salts_shown[salt_pos] = 1;
12185
12186 salts_done++;
12187 }
12188
12189 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12190 }
12191
12192 local_free (digests_buf);
12193 local_free (salts_buf);
12194 local_free (esalts_buf);
12195
12196 digests_buf = digests_buf_new;
12197 salts_buf = salts_buf_new;
12198 esalts_buf = esalts_buf_new;
12199
12200 local_free (hashes_buf);
12201
12202 /**
12203 * special modification not set from parser
12204 */
12205
12206 switch (hash_mode)
12207 {
12208 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12209 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12210 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12211 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12212 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12213 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12214 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12215 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12216 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12217 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12218 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12219 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12220 }
12221
12222 if (truecrypt_keyfiles)
12223 {
12224 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12225
12226 char *keyfiles = strdup (truecrypt_keyfiles);
12227
12228 char *keyfile = strtok (keyfiles, ",");
12229
12230 do
12231 {
12232 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12233
12234 } while ((keyfile = strtok (NULL, ",")) != NULL);
12235
12236 free (keyfiles);
12237 }
12238
12239 data.digests_cnt = digests_cnt;
12240 data.digests_done = digests_done;
12241 data.digests_buf = digests_buf;
12242 data.digests_shown = digests_shown;
12243 data.digests_shown_tmp = digests_shown_tmp;
12244
12245 data.salts_cnt = salts_cnt;
12246 data.salts_done = salts_done;
12247 data.salts_buf = salts_buf;
12248 data.salts_shown = salts_shown;
12249
12250 data.esalts_buf = esalts_buf;
12251 data.hash_info = hash_info;
12252
12253 /**
12254 * Automatic Optimizers
12255 */
12256
12257 if (salts_cnt == 1)
12258 opti_type |= OPTI_TYPE_SINGLE_SALT;
12259
12260 if (digests_cnt == 1)
12261 opti_type |= OPTI_TYPE_SINGLE_HASH;
12262
12263 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12264 opti_type |= OPTI_TYPE_NOT_ITERATED;
12265
12266 if (attack_mode == ATTACK_MODE_BF)
12267 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12268
12269 data.opti_type = opti_type;
12270
12271 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12272 {
12273 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12274 {
12275 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12276 {
12277 if (opts_type & OPTS_TYPE_ST_ADD80)
12278 {
12279 opts_type &= ~OPTS_TYPE_ST_ADD80;
12280 opts_type |= OPTS_TYPE_PT_ADD80;
12281 }
12282
12283 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12284 {
12285 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12286 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12287 }
12288
12289 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12290 {
12291 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12292 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12293 }
12294 }
12295 }
12296 }
12297
12298 /**
12299 * Some algorithm, like descrypt, can benefit from JIT compilation
12300 */
12301
12302 int force_jit_compilation = -1;
12303
12304 if (hash_mode == 8900)
12305 {
12306 force_jit_compilation = 8900;
12307 }
12308 else if (hash_mode == 9300)
12309 {
12310 force_jit_compilation = 8900;
12311 }
12312 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12313 {
12314 force_jit_compilation = 1500;
12315 }
12316
12317 /**
12318 * generate bitmap tables
12319 */
12320
12321 const uint bitmap_shift1 = 5;
12322 const uint bitmap_shift2 = 13;
12323
12324 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12325
12326 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12327 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12328 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12329 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12330 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12331 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12332 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12333 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12334
12335 uint bitmap_bits;
12336 uint bitmap_nums;
12337 uint bitmap_mask;
12338 uint bitmap_size;
12339
12340 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12341 {
12342 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12343
12344 bitmap_nums = 1 << bitmap_bits;
12345
12346 bitmap_mask = bitmap_nums - 1;
12347
12348 bitmap_size = bitmap_nums * sizeof (uint);
12349
12350 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12351
12352 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;
12353 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;
12354
12355 break;
12356 }
12357
12358 bitmap_nums = 1 << bitmap_bits;
12359
12360 bitmap_mask = bitmap_nums - 1;
12361
12362 bitmap_size = bitmap_nums * sizeof (uint);
12363
12364 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);
12365 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);
12366
12367 /**
12368 * prepare quick rule
12369 */
12370
12371 data.rule_buf_l = rule_buf_l;
12372 data.rule_buf_r = rule_buf_r;
12373
12374 int rule_len_l = (int) strlen (rule_buf_l);
12375 int rule_len_r = (int) strlen (rule_buf_r);
12376
12377 data.rule_len_l = rule_len_l;
12378 data.rule_len_r = rule_len_r;
12379
12380 /**
12381 * load rules
12382 */
12383
12384 uint *all_kernel_rules_cnt = NULL;
12385
12386 kernel_rule_t **all_kernel_rules_buf = NULL;
12387
12388 if (rp_files_cnt)
12389 {
12390 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12391
12392 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12393 }
12394
12395 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12396
12397 int rule_len = 0;
12398
12399 for (uint i = 0; i < rp_files_cnt; i++)
12400 {
12401 uint kernel_rules_avail = 0;
12402
12403 uint kernel_rules_cnt = 0;
12404
12405 kernel_rule_t *kernel_rules_buf = NULL;
12406
12407 char *rp_file = rp_files[i];
12408
12409 char in[BLOCK_SIZE] = { 0 };
12410 char out[BLOCK_SIZE] = { 0 };
12411
12412 FILE *fp = NULL;
12413
12414 uint rule_line = 0;
12415
12416 if ((fp = fopen (rp_file, "rb")) == NULL)
12417 {
12418 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12419
12420 return (-1);
12421 }
12422
12423 while (!feof (fp))
12424 {
12425 memset (rule_buf, 0, HCBUFSIZ);
12426
12427 rule_len = fgetl (fp, rule_buf);
12428
12429 rule_line++;
12430
12431 if (rule_len == 0) continue;
12432
12433 if (rule_buf[0] == '#') continue;
12434
12435 if (kernel_rules_avail == kernel_rules_cnt)
12436 {
12437 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12438
12439 kernel_rules_avail += INCR_RULES;
12440 }
12441
12442 memset (in, 0, BLOCK_SIZE);
12443 memset (out, 0, BLOCK_SIZE);
12444
12445 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12446
12447 if (result == -1)
12448 {
12449 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12450
12451 continue;
12452 }
12453
12454 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12455 {
12456 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12457
12458 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12459
12460 continue;
12461 }
12462
12463 /* its so slow
12464 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12465 {
12466 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12467
12468 continue;
12469 }
12470 */
12471
12472 kernel_rules_cnt++;
12473 }
12474
12475 fclose (fp);
12476
12477 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12478
12479 all_kernel_rules_buf[i] = kernel_rules_buf;
12480 }
12481
12482 /**
12483 * merge rules or automatic rule generator
12484 */
12485
12486 uint kernel_rules_cnt = 0;
12487
12488 kernel_rule_t *kernel_rules_buf = NULL;
12489
12490 if (attack_mode == ATTACK_MODE_STRAIGHT)
12491 {
12492 if (rp_files_cnt)
12493 {
12494 kernel_rules_cnt = 1;
12495
12496 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12497
12498 repeats[0] = kernel_rules_cnt;
12499
12500 for (uint i = 0; i < rp_files_cnt; i++)
12501 {
12502 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12503
12504 repeats[i + 1] = kernel_rules_cnt;
12505 }
12506
12507 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12508
12509 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12510
12511 for (uint i = 0; i < kernel_rules_cnt; i++)
12512 {
12513 uint out_pos = 0;
12514
12515 kernel_rule_t *out = &kernel_rules_buf[i];
12516
12517 for (uint j = 0; j < rp_files_cnt; j++)
12518 {
12519 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12520 uint in_pos;
12521
12522 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12523
12524 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12525 {
12526 if (out_pos == RULES_MAX - 1)
12527 {
12528 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12529
12530 break;
12531 }
12532
12533 out->cmds[out_pos] = in->cmds[in_pos];
12534 }
12535 }
12536 }
12537
12538 local_free (repeats);
12539 }
12540 else if (rp_gen)
12541 {
12542 uint kernel_rules_avail = 0;
12543
12544 while (kernel_rules_cnt < rp_gen)
12545 {
12546 if (kernel_rules_avail == kernel_rules_cnt)
12547 {
12548 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12549
12550 kernel_rules_avail += INCR_RULES;
12551 }
12552
12553 memset (rule_buf, 0, HCBUFSIZ);
12554
12555 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12556
12557 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12558
12559 kernel_rules_cnt++;
12560 }
12561 }
12562 }
12563
12564 myfree (rule_buf);
12565
12566 /**
12567 * generate NOP rules
12568 */
12569
12570 if (kernel_rules_cnt == 0)
12571 {
12572 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12573
12574 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12575
12576 kernel_rules_cnt++;
12577 }
12578
12579 data.kernel_rules_cnt = kernel_rules_cnt;
12580 data.kernel_rules_buf = kernel_rules_buf;
12581
12582 /**
12583 * OpenCL platforms: detect
12584 */
12585
12586 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12587 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12588
12589 cl_uint platforms_cnt = 0;
12590 cl_uint platform_devices_cnt = 0;
12591
12592 if (keyspace == 0)
12593 {
12594 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12595
12596 if (platforms_cnt == 0)
12597 {
12598 log_error ("ERROR: No OpenCL compatible platform found");
12599
12600 return (-1);
12601 }
12602
12603 if (opencl_platforms_filter != (uint) -1)
12604 {
12605 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
12606
12607 if (opencl_platforms_filter > platform_cnt_mask)
12608 {
12609 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
12610
12611 return (-1);
12612 }
12613 }
12614 }
12615
12616 /**
12617 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12618 */
12619
12620 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12621 {
12622 cl_platform_id platform = platforms[platform_id];
12623
12624 char platform_vendor[INFOSZ] = { 0 };
12625
12626 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12627
12628 #ifdef HAVE_HWMON
12629 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12630 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12631 {
12632 // make sure that we do not directly control the fan for NVidia
12633
12634 gpu_temp_retain = 0;
12635
12636 data.gpu_temp_retain = gpu_temp_retain;
12637 }
12638 #endif // HAVE_NVML || HAVE_NVAPI
12639 #endif
12640 }
12641
12642 /**
12643 * OpenCL devices: simply push all devices from all platforms into the same device array
12644 */
12645
12646 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12647
12648 data.devices_param = devices_param;
12649
12650 uint devices_cnt = 0;
12651
12652 uint devices_active = 0;
12653
12654 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12655 {
12656 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12657
12658 cl_platform_id platform = platforms[platform_id];
12659
12660 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12661
12662 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12663 {
12664 size_t param_value_size = 0;
12665
12666 const uint device_id = devices_cnt;
12667
12668 hc_device_param_t *device_param = &data.devices_param[device_id];
12669
12670 device_param->device = platform_devices[platform_devices_id];
12671
12672 device_param->device_id = device_id;
12673
12674 device_param->platform_devices_id = platform_devices_id;
12675
12676 // device_type
12677
12678 cl_device_type device_type;
12679
12680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12681
12682 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12683
12684 device_param->device_type = device_type;
12685
12686 // vendor_id
12687
12688 cl_uint vendor_id = 0;
12689
12690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12691
12692 device_param->vendor_id = vendor_id;
12693
12694 // device_name
12695
12696 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12697
12698 char *device_name = (char *) mymalloc (param_value_size);
12699
12700 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12701
12702 device_param->device_name = device_name;
12703
12704 // tuning db
12705
12706 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
12707
12708 // device_version
12709
12710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12711
12712 char *device_version = (char *) mymalloc (param_value_size);
12713
12714 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12715
12716 device_param->device_version = device_version;
12717
12718 // device_opencl_version
12719
12720 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12721
12722 char *device_opencl_version = (char *) mymalloc (param_value_size);
12723
12724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12725
12726 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12727
12728 myfree (device_opencl_version);
12729
12730 if (strstr (device_version, "pocl"))
12731 {
12732 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12733 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12734
12735 cl_uint vendor_id = VENDOR_ID_GENERIC;
12736
12737 device_param->vendor_id = vendor_id;
12738 }
12739
12740 // vector_width
12741
12742 cl_uint vector_width;
12743
12744 if (opencl_vector_width_chgd == 0)
12745 {
12746 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12747 {
12748 if (opti_type & OPTI_TYPE_USES_BITS_64)
12749 {
12750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12751 }
12752 else
12753 {
12754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12755 }
12756 }
12757 else
12758 {
12759 vector_width = (cl_uint) tuningdb_entry->vector_width;
12760 }
12761 }
12762 else
12763 {
12764 vector_width = opencl_vector_width;
12765 }
12766
12767 if (vector_width > 16) vector_width = 16;
12768
12769 device_param->vector_width = vector_width;
12770
12771 // max_compute_units
12772
12773 cl_uint device_processors;
12774
12775 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12776
12777 device_param->device_processors = device_processors;
12778
12779 // max_mem_alloc_size
12780
12781 cl_ulong device_maxmem_alloc;
12782
12783 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12784
12785 device_param->device_maxmem_alloc = device_maxmem_alloc;
12786
12787 // max_mem_alloc_size
12788
12789 cl_ulong device_global_mem;
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12792
12793 device_param->device_global_mem = device_global_mem;
12794
12795 // max_clock_frequency
12796
12797 cl_uint device_maxclock_frequency;
12798
12799 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12800
12801 device_param->device_maxclock_frequency = device_maxclock_frequency;
12802
12803 // skipped
12804
12805 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12806 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12807
12808 device_param->skipped = (skipped1 || skipped2);
12809
12810 // driver_version
12811 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12812
12813 char *driver_version = (char *) mymalloc (param_value_size);
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12816
12817 device_param->driver_version = driver_version;
12818
12819 // device_name_chksum
12820
12821 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12822
12823 #if __x86_64__
12824 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);
12825 #else
12826 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);
12827 #endif
12828
12829 uint device_name_digest[4] = { 0 };
12830
12831 md5_64 ((uint *) device_name_chksum, device_name_digest);
12832
12833 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12834
12835 device_param->device_name_chksum = device_name_chksum;
12836
12837 // device_processor_cores
12838
12839 if (device_type & CL_DEVICE_TYPE_CPU)
12840 {
12841 cl_uint device_processor_cores = 1;
12842
12843 device_param->device_processor_cores = device_processor_cores;
12844 }
12845
12846 if (device_type & CL_DEVICE_TYPE_GPU)
12847 {
12848 if (vendor_id == VENDOR_ID_AMD)
12849 {
12850 cl_uint device_processor_cores = 0;
12851
12852 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12853
12854 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12855
12856 device_param->device_processor_cores = device_processor_cores;
12857 }
12858 else if (vendor_id == VENDOR_ID_NV)
12859 {
12860 cl_uint kernel_exec_timeout = 0;
12861
12862 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12863
12864 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12865
12866 device_param->kernel_exec_timeout = kernel_exec_timeout;
12867
12868 cl_uint device_processor_cores = 0;
12869
12870 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12871
12872 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12873
12874 device_param->device_processor_cores = device_processor_cores;
12875
12876 cl_uint sm_minor = 0;
12877 cl_uint sm_major = 0;
12878
12879 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12880 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12881
12882 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12883 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12884
12885 device_param->sm_minor = sm_minor;
12886 device_param->sm_major = sm_major;
12887 }
12888 else
12889 {
12890 cl_uint device_processor_cores = 1;
12891
12892 device_param->device_processor_cores = device_processor_cores;
12893 }
12894 }
12895
12896 // display results
12897
12898 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12899 {
12900 if (device_param->skipped == 0)
12901 {
12902 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12903 device_id + 1,
12904 device_name,
12905 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12906 (unsigned int) (device_global_mem / 1024 / 1024),
12907 (unsigned int) (device_maxclock_frequency),
12908 (unsigned int) device_processors);
12909 }
12910 else
12911 {
12912 log_info ("Device #%u: %s, skipped",
12913 device_id + 1,
12914 device_name);
12915 }
12916 }
12917
12918 // common driver check
12919
12920 if (device_param->skipped == 0)
12921 {
12922 if (strstr (device_version, "pocl"))
12923 {
12924 if (force == 0)
12925 {
12926 log_info ("");
12927 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12928 log_info ("You are STRONGLY encouraged not to use it");
12929 log_info ("You can use --force to override this but do not post error reports if you do so");
12930 log_info ("");
12931
12932 return (-1);
12933 }
12934 }
12935
12936 if (device_type & CL_DEVICE_TYPE_GPU)
12937 {
12938 if (vendor_id == VENDOR_ID_NV)
12939 {
12940 if (device_param->kernel_exec_timeout != 0)
12941 {
12942 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);
12943 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12944 }
12945 }
12946 else if (vendor_id == VENDOR_ID_AMD)
12947 {
12948 int catalyst_check = (force == 1) ? 0 : 1;
12949
12950 int catalyst_warn = 0;
12951
12952 int catalyst_broken = 0;
12953
12954 if (catalyst_check == 1)
12955 {
12956 catalyst_warn = 1;
12957
12958 // v14.9 and higher
12959 if (atoi (device_param->driver_version) >= 1573)
12960 {
12961 catalyst_warn = 0;
12962 }
12963
12964 catalyst_check = 0;
12965 }
12966
12967 if (catalyst_broken == 1)
12968 {
12969 log_info ("");
12970 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12971 log_info ("It will pass over cracked hashes and does not report them as cracked");
12972 log_info ("You are STRONGLY encouraged not to use it");
12973 log_info ("You can use --force to override this but do not post error reports if you do so");
12974 log_info ("");
12975
12976 return (-1);
12977 }
12978
12979 if (catalyst_warn == 1)
12980 {
12981 log_info ("");
12982 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12983 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12984 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12985 #ifdef _WIN
12986 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12987 #endif
12988 log_info ("You can use --force to override this but do not post error reports if you do so");
12989 log_info ("");
12990
12991 return (-1);
12992 }
12993 }
12994 }
12995
12996 /**
12997 * kernel accel and loops tuning db adjustment
12998 */
12999
13000 device_param->kernel_accel_min = 1;
13001 device_param->kernel_accel_max = 1024;
13002
13003 device_param->kernel_loops_min = 1;
13004 device_param->kernel_loops_max = 1024;
13005
13006 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13007
13008 if (tuningdb_entry)
13009 {
13010 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13011 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13012
13013 if (_kernel_accel)
13014 {
13015 device_param->kernel_accel_min = _kernel_accel;
13016 device_param->kernel_accel_max = _kernel_accel;
13017 }
13018
13019 if (_kernel_loops)
13020 {
13021 if (workload_profile == 1)
13022 {
13023 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13024 }
13025 else if (workload_profile == 2)
13026 {
13027 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13028 }
13029
13030 device_param->kernel_loops_min = _kernel_loops;
13031 device_param->kernel_loops_max = _kernel_loops;
13032 }
13033 }
13034
13035 // commandline parameters overwrite tuningdb entries
13036
13037 if (kernel_accel)
13038 {
13039 device_param->kernel_accel_min = kernel_accel;
13040 device_param->kernel_accel_max = kernel_accel;
13041 }
13042
13043 if (kernel_loops)
13044 {
13045 device_param->kernel_loops_min = kernel_loops;
13046 device_param->kernel_loops_max = kernel_loops;
13047 }
13048
13049 /**
13050 * activate device
13051 */
13052
13053 devices_active++;
13054 }
13055
13056 // next please
13057
13058 devices_cnt++;
13059 }
13060 }
13061
13062 if (keyspace == 0 && devices_active == 0)
13063 {
13064 log_error ("ERROR: No devices found/left");
13065
13066 return (-1);
13067 }
13068
13069 // 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)
13070
13071 if (devices_filter != (uint) -1)
13072 {
13073 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13074
13075 if (devices_filter > devices_cnt_mask)
13076 {
13077 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13078
13079 return (-1);
13080 }
13081 }
13082
13083 data.devices_cnt = devices_cnt;
13084
13085 data.devices_active = devices_active;
13086
13087 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13088 {
13089 log_info ("");
13090 }
13091
13092 /**
13093 * HM devices: init
13094 */
13095
13096 #ifdef HAVE_HWMON
13097 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13098 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13099 #endif
13100
13101 #ifdef HAVE_ADL
13102 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13103 #endif
13104
13105 if (gpu_temp_disable == 0)
13106 {
13107 #if defined(WIN) && defined(HAVE_NVAPI)
13108 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13109
13110 if (nvapi_init (nvapi) == 0)
13111 data.hm_nv = nvapi;
13112
13113 if (data.hm_nv)
13114 {
13115 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13116 {
13117 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13118
13119 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13120
13121 int tmp_out = 0;
13122
13123 for (int i = 0; i < tmp_in; i++)
13124 {
13125 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13126 }
13127
13128 for (int i = 0; i < tmp_out; i++)
13129 {
13130 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13131
13132 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13133
13134 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;
13135 }
13136 }
13137 }
13138 #endif // WIN && HAVE_NVAPI
13139
13140 #if defined(LINUX) && defined(HAVE_NVML)
13141 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13142
13143 if (nvml_init (nvml) == 0)
13144 data.hm_nv = nvml;
13145
13146 if (data.hm_nv)
13147 {
13148 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13149 {
13150 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13151
13152 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13153
13154 int tmp_out = 0;
13155
13156 for (int i = 0; i < tmp_in; i++)
13157 {
13158 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13159 }
13160
13161 for (int i = 0; i < tmp_out; i++)
13162 {
13163 unsigned int speed;
13164
13165 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;
13166 }
13167 }
13168 }
13169 #endif // LINUX && HAVE_NVML
13170
13171 data.hm_amd = NULL;
13172
13173 #ifdef HAVE_ADL
13174 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13175
13176 if (adl_init (adl) == 0)
13177 data.hm_amd = adl;
13178
13179 if (data.hm_amd)
13180 {
13181 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13182 {
13183 // total number of adapters
13184
13185 int hm_adapters_num;
13186
13187 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13188
13189 // adapter info
13190
13191 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13192
13193 if (lpAdapterInfo == NULL) return (-1);
13194
13195 // get a list (of ids of) valid/usable adapters
13196
13197 int num_adl_adapters = 0;
13198
13199 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13200
13201 if (num_adl_adapters > 0)
13202 {
13203 hc_thread_mutex_lock (mux_adl);
13204
13205 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13206
13207 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13208
13209 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13210 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13211
13212 hc_thread_mutex_unlock (mux_adl);
13213 }
13214
13215 myfree (valid_adl_device_list);
13216 myfree (lpAdapterInfo);
13217 }
13218 }
13219 #endif // HAVE_ADL
13220
13221 if (data.hm_amd == NULL && data.hm_nv == NULL)
13222 {
13223 gpu_temp_disable = 1;
13224 }
13225 }
13226
13227 /**
13228 * OpenCL devices: allocate buffer for device specific information
13229 */
13230
13231 #ifdef HAVE_HWMON
13232 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13233
13234 #ifdef HAVE_ADL
13235 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13236
13237 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13238 #endif // ADL
13239 #endif
13240
13241 /**
13242 * enable custom signal handler(s)
13243 */
13244
13245 if (benchmark == 0)
13246 {
13247 hc_signal (sigHandler_default);
13248 }
13249 else
13250 {
13251 hc_signal (sigHandler_benchmark);
13252 }
13253
13254 /**
13255 * User-defined GPU temp handling
13256 */
13257
13258 #ifdef HAVE_HWMON
13259 if (gpu_temp_disable == 1)
13260 {
13261 gpu_temp_abort = 0;
13262 gpu_temp_retain = 0;
13263 }
13264
13265 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13266 {
13267 if (gpu_temp_abort < gpu_temp_retain)
13268 {
13269 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13270
13271 return (-1);
13272 }
13273 }
13274
13275 data.gpu_temp_disable = gpu_temp_disable;
13276 data.gpu_temp_abort = gpu_temp_abort;
13277 data.gpu_temp_retain = gpu_temp_retain;
13278 #endif
13279
13280 /**
13281 * inform the user
13282 */
13283
13284 if (data.quiet == 0)
13285 {
13286 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13287
13288 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);
13289
13290 if (attack_mode == ATTACK_MODE_STRAIGHT)
13291 {
13292 log_info ("Rules: %u", kernel_rules_cnt);
13293 }
13294
13295 if (opti_type)
13296 {
13297 log_info ("Applicable Optimizers:");
13298
13299 for (uint i = 0; i < 32; i++)
13300 {
13301 const uint opti_bit = 1u << i;
13302
13303 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13304 }
13305 }
13306
13307 /**
13308 * Watchdog and Temperature balance
13309 */
13310
13311 #ifdef HAVE_HWMON
13312 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13313 {
13314 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13315 }
13316
13317 if (gpu_temp_abort == 0)
13318 {
13319 log_info ("Watchdog: Temperature abort trigger disabled");
13320 }
13321 else
13322 {
13323 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13324 }
13325
13326 if (gpu_temp_retain == 0)
13327 {
13328 log_info ("Watchdog: Temperature retain trigger disabled");
13329 }
13330 else
13331 {
13332 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13333 }
13334 #endif
13335 }
13336
13337 if (data.quiet == 0) log_info ("");
13338
13339 /**
13340 * HM devices: copy
13341 */
13342
13343 if (gpu_temp_disable == 0)
13344 {
13345 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13346 {
13347 hc_device_param_t *device_param = &data.devices_param[device_id];
13348
13349 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13350
13351 if (device_param->skipped) continue;
13352
13353 const uint platform_devices_id = device_param->platform_devices_id;
13354
13355 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13356 if (device_param->vendor_id == VENDOR_ID_NV)
13357 {
13358 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13359 }
13360 #endif
13361
13362 #ifdef HAVE_ADL
13363 if (device_param->vendor_id == VENDOR_ID_AMD)
13364 {
13365 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13366 }
13367 #endif
13368 }
13369 }
13370
13371 /*
13372 * Temporary fix:
13373 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13374 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13375 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13376 * Driver / ADL bug?
13377 */
13378
13379 #ifdef HAVE_ADL
13380 if (powertune_enable == 1)
13381 {
13382 hc_thread_mutex_lock (mux_adl);
13383
13384 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13385 {
13386 hc_device_param_t *device_param = &data.devices_param[device_id];
13387
13388 if (device_param->skipped) continue;
13389
13390 if (data.hm_device[device_id].od_version == 6)
13391 {
13392 // set powertune value only
13393
13394 int powertune_supported = 0;
13395
13396 int ADL_rc = 0;
13397
13398 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13399 {
13400 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13401
13402 return (-1);
13403 }
13404
13405 if (powertune_supported != 0)
13406 {
13407 // powertune set
13408 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13409
13410 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13411 {
13412 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13413
13414 return (-1);
13415 }
13416
13417 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13418 {
13419 log_error ("ERROR: Failed to set new ADL PowerControl values");
13420
13421 return (-1);
13422 }
13423 }
13424 }
13425 }
13426
13427 hc_thread_mutex_unlock (mux_adl);
13428 }
13429 #endif // HAVE_ADK
13430 #endif // HAVE_HWMON
13431
13432 #ifdef DEBUG
13433 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13434 #endif
13435
13436 uint kernel_power_all = 0;
13437
13438 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13439 {
13440 /**
13441 * host buffer
13442 */
13443
13444 hc_device_param_t *device_param = &data.devices_param[device_id];
13445
13446 if (device_param->skipped) continue;
13447
13448 /**
13449 * device properties
13450 */
13451
13452 const char *device_name_chksum = device_param->device_name_chksum;
13453 const u32 device_processors = device_param->device_processors;
13454 const u32 device_processor_cores = device_param->device_processor_cores;
13455
13456 /**
13457 * create context for each device
13458 */
13459
13460 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13461
13462 /**
13463 * create command-queue
13464 */
13465
13466 // not supported with NV
13467 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13468
13469 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13470
13471 /**
13472 * create input buffers on device : calculate size of fixed memory buffers
13473 */
13474
13475 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13476 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13477
13478 device_param->size_root_css = size_root_css;
13479 device_param->size_markov_css = size_markov_css;
13480
13481 uint size_results = KERNEL_THREADS * sizeof (uint);
13482
13483 device_param->size_results = size_results;
13484
13485 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13486 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13487
13488 uint size_plains = digests_cnt * sizeof (plain_t);
13489 uint size_salts = salts_cnt * sizeof (salt_t);
13490 uint size_esalts = salts_cnt * esalt_size;
13491
13492 device_param->size_plains = size_plains;
13493 device_param->size_digests = size_digests;
13494 device_param->size_shown = size_shown;
13495 device_param->size_salts = size_salts;
13496
13497 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13498 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13499 uint size_tm = 32 * sizeof (bs_word_t);
13500
13501 // scryptV stuff
13502
13503 u64 size_scryptV = 1;
13504
13505 if ((hash_mode == 8900) || (hash_mode == 9300))
13506 {
13507 uint tmto_start = 0;
13508 uint tmto_stop = 10;
13509
13510 if (scrypt_tmto)
13511 {
13512 tmto_start = scrypt_tmto;
13513 }
13514 else
13515 {
13516 // in case the user did not specify the tmto manually
13517 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13518 // but set the lower end only in case the user has a device with too less memory
13519
13520 if (hash_mode == 8900)
13521 {
13522 if (device_param->vendor_id == VENDOR_ID_AMD)
13523 {
13524 tmto_start = 1;
13525 }
13526 else if (device_param->vendor_id == VENDOR_ID_NV)
13527 {
13528 tmto_start = 3;
13529 }
13530 }
13531 else if (hash_mode == 9300)
13532 {
13533 if (device_param->vendor_id == VENDOR_ID_AMD)
13534 {
13535 tmto_start = 3;
13536 }
13537 else if (device_param->vendor_id == VENDOR_ID_NV)
13538 {
13539 tmto_start = 5;
13540 }
13541 }
13542 }
13543
13544 if (quiet == 0) log_info ("");
13545
13546 uint shader_per_mp = 1;
13547
13548 if (device_param->vendor_id == VENDOR_ID_AMD)
13549 {
13550 shader_per_mp = 8;
13551 }
13552 else if (device_param->vendor_id == VENDOR_ID_NV)
13553 {
13554 shader_per_mp = 32;
13555 }
13556
13557 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13558 {
13559 // TODO: in theory the following calculation needs to be done per salt, not global
13560 // we assume all hashes have the same scrypt settings
13561
13562 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13563
13564 size_scryptV /= 1 << tmto;
13565
13566 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13567
13568 if (size_scryptV > device_param->device_maxmem_alloc)
13569 {
13570 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13571
13572 continue;
13573 }
13574
13575 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13576 {
13577 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13578 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13579 }
13580
13581 break;
13582 }
13583
13584 if (data.salts_buf[0].scrypt_phy == 0)
13585 {
13586 log_error ("ERROR: can't allocate enough device memory");
13587
13588 return -1;
13589 }
13590
13591 if (quiet == 0) log_info ("");
13592 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13593 }
13594
13595 /**
13596 * create input buffers on device : calculate size of dynamic size memory buffers
13597 */
13598
13599 uint kernel_threads = KERNEL_THREADS;
13600
13601 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13602
13603 if (hash_mode == 3200) kernel_threads = 8;
13604 if (hash_mode == 9000) kernel_threads = 8;
13605
13606 /**
13607 * some algorithms need a fixed kernel-loops count
13608 */
13609
13610 if (hash_mode == 1500)
13611 {
13612 const u32 kernel_loops_fixed = 1024;
13613
13614 device_param->kernel_loops_min = kernel_loops_fixed;
13615 device_param->kernel_loops_max = kernel_loops_fixed;
13616 }
13617
13618 if (hash_mode == 3000)
13619 {
13620 const u32 kernel_loops_fixed = 1024;
13621
13622 device_param->kernel_loops_min = kernel_loops_fixed;
13623 device_param->kernel_loops_max = kernel_loops_fixed;
13624 }
13625
13626 if (hash_mode == 8900)
13627 {
13628 const u32 kernel_loops_fixed = 1;
13629
13630 device_param->kernel_loops_min = kernel_loops_fixed;
13631 device_param->kernel_loops_max = kernel_loops_fixed;
13632 }
13633
13634 if (hash_mode == 9300)
13635 {
13636 const u32 kernel_loops_fixed = 1;
13637
13638 device_param->kernel_loops_min = kernel_loops_fixed;
13639 device_param->kernel_loops_max = kernel_loops_fixed;
13640 }
13641
13642 if (hash_mode == 12500)
13643 {
13644 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13645
13646 device_param->kernel_loops_min = kernel_loops_fixed;
13647 device_param->kernel_loops_max = kernel_loops_fixed;
13648 }
13649
13650 /**
13651 * some algorithms have a maximum kernel-loops count
13652 */
13653
13654 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13655 {
13656 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13657 {
13658 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13659 }
13660 }
13661
13662 /**
13663 * some algorithms need a special kernel-accel
13664 */
13665
13666 if (hash_mode == 8900)
13667 {
13668 device_param->kernel_accel_min = 1;
13669 device_param->kernel_accel_max = 64;
13670 }
13671
13672 if (hash_mode == 9300)
13673 {
13674 device_param->kernel_accel_min = 1;
13675 device_param->kernel_accel_max = 64;
13676 }
13677
13678 u32 kernel_accel_min = device_param->kernel_accel_min;
13679 u32 kernel_accel_max = device_param->kernel_accel_max;
13680
13681 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13682
13683 uint size_pws = 4;
13684 uint size_tmps = 4;
13685 uint size_hooks = 4;
13686
13687 while (kernel_accel_max >= kernel_accel_min)
13688 {
13689 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13690
13691 // size_pws
13692
13693 size_pws = kernel_power_max * sizeof (pw_t);
13694
13695 // size_tmps
13696
13697 switch (hash_mode)
13698 {
13699 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13700 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13701 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13702 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13703 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13704 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13705 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13706 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13707 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13708 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13709 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13710 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13711 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13712 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13713 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13714 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13715 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13716 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13717 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13718 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13719 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13720 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13721 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13722 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13723 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13724 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13725 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13726 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13727 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13728 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13729 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13730 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13731 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13732 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13733 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13734 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13735 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13736 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13737 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13738 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13739 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13740 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13741 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13742 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13743 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13744 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13745 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13746 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13747 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13748 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13749 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13750 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13751 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13752 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13753 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13754 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13755 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13756 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13757 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13758 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13759 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13760 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
13761 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
13762 };
13763
13764 // size_hooks
13765
13766 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13767 {
13768 // none yet
13769 }
13770
13771 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13772 // if not, decrease amplifier and try again
13773
13774 int skip = 0;
13775
13776 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13777 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13778 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13779
13780 if (( bitmap_size
13781 + bitmap_size
13782 + bitmap_size
13783 + bitmap_size
13784 + bitmap_size
13785 + bitmap_size
13786 + bitmap_size
13787 + bitmap_size
13788 + size_bfs
13789 + size_combs
13790 + size_digests
13791 + size_esalts
13792 + size_hooks
13793 + size_markov_css
13794 + size_plains
13795 + size_pws
13796 + size_results
13797 + size_root_css
13798 + size_rules
13799 + size_rules_c
13800 + size_salts
13801 + size_scryptV
13802 + size_shown
13803 + size_tm
13804 + size_tmps) > device_param->device_global_mem) skip = 1;
13805
13806 if (skip == 1)
13807 {
13808 kernel_accel_max--;
13809
13810 continue;
13811 }
13812
13813 break;
13814 }
13815
13816 /*
13817 if (kernel_accel_max == 0)
13818 {
13819 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13820
13821 return -1;
13822 }
13823 */
13824
13825 device_param->kernel_accel_min = kernel_accel_min;
13826 device_param->kernel_accel_max = kernel_accel_max;
13827
13828 /*
13829 if (kernel_accel_max < kernel_accel)
13830 {
13831 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13832
13833 device_param->kernel_accel = kernel_accel_max;
13834 }
13835 */
13836
13837 device_param->size_bfs = size_bfs;
13838 device_param->size_combs = size_combs;
13839 device_param->size_rules = size_rules;
13840 device_param->size_rules_c = size_rules_c;
13841 device_param->size_pws = size_pws;
13842 device_param->size_tmps = size_tmps;
13843 device_param->size_hooks = size_hooks;
13844
13845 // do not confuse kernel_accel_max with kernel_accel here
13846
13847 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13848
13849 device_param->kernel_threads = kernel_threads;
13850 device_param->kernel_power_user = kernel_power;
13851
13852 kernel_power_all += kernel_power;
13853
13854 /**
13855 * default building options
13856 */
13857
13858 char build_opts[1024] = { 0 };
13859
13860 // we don't have sm_* on vendors not NV but it doesn't matter
13861
13862 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);
13863
13864 /**
13865 * main kernel
13866 */
13867
13868 {
13869 /**
13870 * kernel source filename
13871 */
13872
13873 char source_file[256] = { 0 };
13874
13875 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13876
13877 struct stat sst;
13878
13879 if (stat (source_file, &sst) == -1)
13880 {
13881 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13882
13883 return -1;
13884 }
13885
13886 /**
13887 * kernel cached filename
13888 */
13889
13890 char cached_file[256] = { 0 };
13891
13892 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13893
13894 int cached = 1;
13895
13896 struct stat cst;
13897
13898 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13899 {
13900 cached = 0;
13901 }
13902
13903 /**
13904 * kernel compile or load
13905 */
13906
13907 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13908
13909 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13910
13911 if (force_jit_compilation == -1)
13912 {
13913 if (cached == 0)
13914 {
13915 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13916
13917 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13918
13919 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13920
13921 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13922
13923 #ifdef DEBUG
13924 size_t build_log_size = 0;
13925
13926 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
13927
13928 if (build_log_size > 1)
13929 {
13930 char *build_log = (char *) malloc (build_log_size + 1);
13931
13932 memset (build_log, 0, build_log_size + 1);
13933
13934 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
13935
13936 puts (build_log);
13937
13938 free (build_log);
13939 }
13940 #endif
13941
13942 if (rc != 0)
13943 {
13944 device_param->skipped = true;
13945 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13946 continue;
13947 }
13948
13949 size_t binary_size;
13950
13951 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13952
13953 u8 *binary = (u8 *) mymalloc (binary_size);
13954
13955 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13956
13957 writeProgramBin (cached_file, binary, binary_size);
13958
13959 local_free (binary);
13960 }
13961 else
13962 {
13963 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13964
13965 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13966
13967 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13968
13969 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13970 }
13971 }
13972 else
13973 {
13974 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13975
13976 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13977
13978 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13979
13980 char build_opts_update[1024] = { 0 };
13981
13982 if (force_jit_compilation == 1500)
13983 {
13984 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13985 }
13986 else if (force_jit_compilation == 8900)
13987 {
13988 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);
13989 }
13990 else
13991 {
13992 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
13993 }
13994
13995 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13996
13997 #ifdef DEBUG
13998 size_t build_log_size = 0;
13999
14000 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14001
14002 if (build_log_size > 1)
14003 {
14004 char *build_log = (char *) malloc (build_log_size + 1);
14005
14006 memset (build_log, 0, build_log_size + 1);
14007
14008 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14009
14010 puts (build_log);
14011
14012 free (build_log);
14013 }
14014 #endif
14015
14016 if (rc != 0)
14017 {
14018 device_param->skipped = true;
14019
14020 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14021 }
14022 }
14023
14024 local_free (kernel_lengths);
14025 local_free (kernel_sources[0]);
14026 local_free (kernel_sources);
14027 }
14028
14029 /**
14030 * word generator kernel
14031 */
14032
14033 if (attack_mode != ATTACK_MODE_STRAIGHT)
14034 {
14035 /**
14036 * kernel mp source filename
14037 */
14038
14039 char source_file[256] = { 0 };
14040
14041 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14042
14043 struct stat sst;
14044
14045 if (stat (source_file, &sst) == -1)
14046 {
14047 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14048
14049 return -1;
14050 }
14051
14052 /**
14053 * kernel mp cached filename
14054 */
14055
14056 char cached_file[256] = { 0 };
14057
14058 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14059
14060 int cached = 1;
14061
14062 struct stat cst;
14063
14064 if (stat (cached_file, &cst) == -1)
14065 {
14066 cached = 0;
14067 }
14068
14069 /**
14070 * kernel compile or load
14071 */
14072
14073 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14074
14075 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14076
14077 if (cached == 0)
14078 {
14079 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14080
14081 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14082
14083 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14084
14085 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14086
14087 if (rc != 0)
14088 {
14089 device_param->skipped = true;
14090 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14091 continue;
14092 }
14093
14094 size_t binary_size;
14095
14096 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14097
14098 u8 *binary = (u8 *) mymalloc (binary_size);
14099
14100 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14101
14102 writeProgramBin (cached_file, binary, binary_size);
14103
14104 local_free (binary);
14105 }
14106 else
14107 {
14108 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14109
14110 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14111
14112 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14113
14114 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14115 }
14116
14117 local_free (kernel_lengths);
14118 local_free (kernel_sources[0]);
14119 local_free (kernel_sources);
14120 }
14121
14122 /**
14123 * amplifier kernel
14124 */
14125
14126 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14127 {
14128
14129 }
14130 else
14131 {
14132 /**
14133 * kernel amp source filename
14134 */
14135
14136 char source_file[256] = { 0 };
14137
14138 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14139
14140 struct stat sst;
14141
14142 if (stat (source_file, &sst) == -1)
14143 {
14144 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14145
14146 return -1;
14147 }
14148
14149 /**
14150 * kernel amp cached filename
14151 */
14152
14153 char cached_file[256] = { 0 };
14154
14155 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14156
14157 int cached = 1;
14158
14159 struct stat cst;
14160
14161 if (stat (cached_file, &cst) == -1)
14162 {
14163 cached = 0;
14164 }
14165
14166 /**
14167 * kernel compile or load
14168 */
14169
14170 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14171
14172 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14173
14174 if (cached == 0)
14175 {
14176 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14177
14178 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14179
14180 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14181
14182 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14183
14184 if (rc != 0)
14185 {
14186 device_param->skipped = true;
14187 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14188 continue;
14189 }
14190
14191 size_t binary_size;
14192
14193 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14194
14195 u8 *binary = (u8 *) mymalloc (binary_size);
14196
14197 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14198
14199 writeProgramBin (cached_file, binary, binary_size);
14200
14201 local_free (binary);
14202 }
14203 else
14204 {
14205 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14206
14207 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14208
14209 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14210
14211 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14212 }
14213
14214 local_free (kernel_lengths);
14215 local_free (kernel_sources[0]);
14216 local_free (kernel_sources);
14217 }
14218
14219 // some algorithm collide too fast, make that impossible
14220
14221 if (benchmark == 1)
14222 {
14223 ((uint *) digests_buf)[0] = -1;
14224 ((uint *) digests_buf)[1] = -1;
14225 ((uint *) digests_buf)[2] = -1;
14226 ((uint *) digests_buf)[3] = -1;
14227 }
14228
14229 /**
14230 * global buffers
14231 */
14232
14233 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14234 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14235 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14236 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14237 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14238 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14239 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14240 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14241 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14242 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14243 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14244 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14245 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14246 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14247 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14248 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14249 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14250 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14251
14252 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);
14253 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);
14254 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);
14255 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);
14256 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);
14257 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);
14258 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);
14259 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);
14260 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14261 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14262 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14263
14264 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14265 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14266 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14267 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14268 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14269 run_kernel_bzero (device_param, device_param->d_result, size_results);
14270
14271 /**
14272 * special buffers
14273 */
14274
14275 if (attack_kern == ATTACK_KERN_STRAIGHT)
14276 {
14277 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14278 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14279
14280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14281
14282 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14283 }
14284 else if (attack_kern == ATTACK_KERN_COMBI)
14285 {
14286 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14287 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14288 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14289 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14290
14291 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14292 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14293 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14294 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14295 }
14296 else if (attack_kern == ATTACK_KERN_BF)
14297 {
14298 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14299 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14300 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14301 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14302 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14303
14304 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14305 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14306 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14307 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14308 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14309 }
14310
14311 if (size_esalts)
14312 {
14313 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14314
14315 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14316 }
14317
14318 /**
14319 * main host data
14320 */
14321
14322 uint *result = (uint *) mymalloc (size_results);
14323
14324 device_param->result = result;
14325
14326 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14327
14328 device_param->pws_buf = pws_buf;
14329
14330 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14331
14332 device_param->combs_buf = combs_buf;
14333
14334 void *hooks_buf = mymalloc (size_hooks);
14335
14336 device_param->hooks_buf = hooks_buf;
14337
14338 /**
14339 * kernel args
14340 */
14341
14342 device_param->kernel_params_buf32[21] = bitmap_mask;
14343 device_param->kernel_params_buf32[22] = bitmap_shift1;
14344 device_param->kernel_params_buf32[23] = bitmap_shift2;
14345 device_param->kernel_params_buf32[24] = 0; // salt_pos
14346 device_param->kernel_params_buf32[25] = 0; // loop_pos
14347 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14348 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14349 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14350 device_param->kernel_params_buf32[29] = 0; // digests_offset
14351 device_param->kernel_params_buf32[30] = 0; // combs_mode
14352 device_param->kernel_params_buf32[31] = 0; // gid_max
14353
14354 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14355 ? &device_param->d_pws_buf
14356 : &device_param->d_pws_amp_buf;
14357 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14358 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14359 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14360 device_param->kernel_params[ 4] = &device_param->d_tmps;
14361 device_param->kernel_params[ 5] = &device_param->d_hooks;
14362 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14363 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14364 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14365 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14366 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14367 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14368 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14369 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14370 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14371 device_param->kernel_params[15] = &device_param->d_digests_buf;
14372 device_param->kernel_params[16] = &device_param->d_digests_shown;
14373 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14374 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14375 device_param->kernel_params[19] = &device_param->d_result;
14376 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14377 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14378 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14379 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14380 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14381 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14382 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14383 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14384 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14385 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14386 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14387 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14388
14389 device_param->kernel_params_mp_buf64[3] = 0;
14390 device_param->kernel_params_mp_buf32[4] = 0;
14391 device_param->kernel_params_mp_buf32[5] = 0;
14392 device_param->kernel_params_mp_buf32[6] = 0;
14393 device_param->kernel_params_mp_buf32[7] = 0;
14394 device_param->kernel_params_mp_buf32[8] = 0;
14395
14396 device_param->kernel_params_mp[0] = NULL;
14397 device_param->kernel_params_mp[1] = NULL;
14398 device_param->kernel_params_mp[2] = NULL;
14399 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14400 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14401 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14402 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14403 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14404 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14405
14406 device_param->kernel_params_mp_l_buf64[3] = 0;
14407 device_param->kernel_params_mp_l_buf32[4] = 0;
14408 device_param->kernel_params_mp_l_buf32[5] = 0;
14409 device_param->kernel_params_mp_l_buf32[6] = 0;
14410 device_param->kernel_params_mp_l_buf32[7] = 0;
14411 device_param->kernel_params_mp_l_buf32[8] = 0;
14412 device_param->kernel_params_mp_l_buf32[9] = 0;
14413
14414 device_param->kernel_params_mp_l[0] = NULL;
14415 device_param->kernel_params_mp_l[1] = NULL;
14416 device_param->kernel_params_mp_l[2] = NULL;
14417 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14418 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14419 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14420 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14421 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14422 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14423 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14424
14425 device_param->kernel_params_mp_r_buf64[3] = 0;
14426 device_param->kernel_params_mp_r_buf32[4] = 0;
14427 device_param->kernel_params_mp_r_buf32[5] = 0;
14428 device_param->kernel_params_mp_r_buf32[6] = 0;
14429 device_param->kernel_params_mp_r_buf32[7] = 0;
14430 device_param->kernel_params_mp_r_buf32[8] = 0;
14431
14432 device_param->kernel_params_mp_r[0] = NULL;
14433 device_param->kernel_params_mp_r[1] = NULL;
14434 device_param->kernel_params_mp_r[2] = NULL;
14435 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14436 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14437 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14438 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14439 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14440 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14441
14442 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14443 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14444
14445 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14446 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14447 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14448 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14449 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14450 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14451 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14452
14453 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14454 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14455
14456 /**
14457 * kernel name
14458 */
14459
14460 char kernel_name[64] = { 0 };
14461
14462 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14463 {
14464 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14465 {
14466 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14467
14468 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14469
14470 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14471
14472 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14473
14474 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14475
14476 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14477 }
14478 else
14479 {
14480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14481
14482 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14483
14484 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14485
14486 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14487
14488 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14489
14490 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14491 }
14492
14493 if (data.attack_mode == ATTACK_MODE_BF)
14494 {
14495 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14496 {
14497 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14498
14499 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14500 }
14501 }
14502 }
14503 else
14504 {
14505 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14506
14507 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14508
14509 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14510
14511 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14512
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14514
14515 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516
14517 if (opts_type & OPTS_TYPE_HOOK12)
14518 {
14519 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14520
14521 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14522 }
14523
14524 if (opts_type & OPTS_TYPE_HOOK23)
14525 {
14526 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14527
14528 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14529 }
14530 }
14531
14532 for (uint i = 0; i <= 20; i++)
14533 {
14534 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14535 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14536 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14537
14538 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14539 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14540 }
14541
14542 for (uint i = 21; i <= 31; i++)
14543 {
14544 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14545 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14546 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14547
14548 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14549 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14550 }
14551
14552 if (attack_mode == ATTACK_MODE_BF)
14553 {
14554 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14555 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14556
14557 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14558 {
14559 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14560 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14561 }
14562 }
14563 else if (attack_mode == ATTACK_MODE_HYBRID1)
14564 {
14565 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14566 }
14567 else if (attack_mode == ATTACK_MODE_HYBRID2)
14568 {
14569 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14570 }
14571
14572 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14573 {
14574 // nothing to do
14575 }
14576 else
14577 {
14578 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14579 }
14580
14581 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14582 {
14583 // nothing to do
14584 }
14585 else
14586 {
14587 for (uint i = 0; i < 5; i++)
14588 {
14589 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14590 }
14591
14592 for (uint i = 5; i < 7; i++)
14593 {
14594 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14595 }
14596 }
14597
14598 /**
14599 * Store initial fanspeed if gpu_temp_retain is enabled
14600 */
14601
14602 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14603 int gpu_temp_retain_set = 0;
14604
14605 if (gpu_temp_disable == 0)
14606 {
14607 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14608 {
14609 hc_thread_mutex_lock (mux_adl);
14610
14611 if (data.hm_device[device_id].fan_supported == 1)
14612 {
14613 if (gpu_temp_retain_chgd == 0)
14614 {
14615 uint cur_temp = 0;
14616 uint default_temp = 0;
14617
14618 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);
14619
14620 if (ADL_rc == ADL_OK)
14621 {
14622 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14623
14624 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14625
14626 // special case with multi gpu setups: always use minimum retain
14627
14628 if (gpu_temp_retain_set == 0)
14629 {
14630 gpu_temp_retain = gpu_temp_retain_target;
14631 gpu_temp_retain_set = 1;
14632 }
14633 else
14634 {
14635 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14636 }
14637
14638 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14639 }
14640 }
14641
14642 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14643
14644 temp_retain_fanspeed_value[device_id] = fan_speed;
14645
14646 if (fan_speed == -1)
14647 {
14648 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14649
14650 temp_retain_fanspeed_value[device_id] = 0;
14651 }
14652 }
14653
14654 hc_thread_mutex_unlock (mux_adl);
14655 }
14656 }
14657
14658 /**
14659 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14660 */
14661
14662 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14663 {
14664 hc_thread_mutex_lock (mux_adl);
14665
14666 if (data.hm_device[device_id].od_version == 6)
14667 {
14668 int ADL_rc;
14669
14670 // check powertune capabilities first, if not available then skip device
14671
14672 int powertune_supported = 0;
14673
14674 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14675 {
14676 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14677
14678 return (-1);
14679 }
14680
14681 if (powertune_supported != 0)
14682 {
14683 // powercontrol settings
14684
14685 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14686
14687 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14688 {
14689 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14690 }
14691
14692 if (ADL_rc != ADL_OK)
14693 {
14694 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14695
14696 return (-1);
14697 }
14698
14699 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14700 {
14701 log_error ("ERROR: Failed to set new ADL PowerControl values");
14702
14703 return (-1);
14704 }
14705
14706 // clocks
14707
14708 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14709
14710 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14711
14712 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)
14713 {
14714 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14715
14716 return (-1);
14717 }
14718
14719 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14720
14721 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14722
14723 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14724 {
14725 log_error ("ERROR: Failed to get ADL device capabilities");
14726
14727 return (-1);
14728 }
14729
14730 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14731 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14732
14733 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14734 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14735
14736 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14737 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14738
14739 // warning if profile has too low max values
14740
14741 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14742 {
14743 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14744 }
14745
14746 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14747 {
14748 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14749 }
14750
14751 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14752
14753 performance_state->iNumberOfPerformanceLevels = 2;
14754
14755 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14756 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14757 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14758 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14759
14760 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)
14761 {
14762 log_info ("ERROR: Failed to set ADL performance state");
14763
14764 return (-1);
14765 }
14766
14767 local_free (performance_state);
14768 }
14769 }
14770
14771 hc_thread_mutex_unlock (mux_adl);
14772 }
14773 #endif // HAVE_HWMON && HAVE_ADL
14774 }
14775
14776 data.kernel_power_all = kernel_power_all;
14777
14778 if (data.quiet == 0) log_info ("");
14779
14780 /**
14781 * Inform user which algorithm is checked and at which workload setting
14782 */
14783
14784 if (benchmark == 1)
14785 {
14786 quiet = 0;
14787
14788 data.quiet = quiet;
14789
14790 char *hash_type = strhashtype (data.hash_mode); // not a bug
14791
14792 log_info ("Hashtype: %s", hash_type);
14793 log_info ("");
14794 }
14795
14796 /**
14797 * keep track of the progress
14798 */
14799
14800 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14801 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14802 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14803
14804 /**
14805 * open filehandles
14806 */
14807
14808 #if _WIN
14809 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14810 {
14811 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14812
14813 return (-1);
14814 }
14815
14816 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14817 {
14818 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14819
14820 return (-1);
14821 }
14822
14823 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14824 {
14825 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14826
14827 return (-1);
14828 }
14829 #endif
14830
14831 /**
14832 * dictionary pad
14833 */
14834
14835 segment_size *= (1024 * 1024);
14836
14837 data.segment_size = segment_size;
14838
14839 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14840
14841 wl_data->buf = (char *) mymalloc (segment_size);
14842 wl_data->avail = segment_size;
14843 wl_data->incr = segment_size;
14844 wl_data->cnt = 0;
14845 wl_data->pos = 0;
14846
14847 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14848
14849 data.wordlist_mode = wordlist_mode;
14850
14851 cs_t *css_buf = NULL;
14852 uint css_cnt = 0;
14853 uint dictcnt = 0;
14854 uint maskcnt = 1;
14855 char **masks = NULL;
14856 char **dictfiles = NULL;
14857
14858 uint mask_from_file = 0;
14859
14860 if (attack_mode == ATTACK_MODE_STRAIGHT)
14861 {
14862 if (wordlist_mode == WL_MODE_FILE)
14863 {
14864 int wls_left = myargc - (optind + 1);
14865
14866 for (int i = 0; i < wls_left; i++)
14867 {
14868 char *l0_filename = myargv[optind + 1 + i];
14869
14870 struct stat l0_stat;
14871
14872 if (stat (l0_filename, &l0_stat) == -1)
14873 {
14874 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14875
14876 return (-1);
14877 }
14878
14879 uint is_dir = S_ISDIR (l0_stat.st_mode);
14880
14881 if (is_dir == 0)
14882 {
14883 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14884
14885 dictcnt++;
14886
14887 dictfiles[dictcnt - 1] = l0_filename;
14888 }
14889 else
14890 {
14891 // do not allow --keyspace w/ a directory
14892
14893 if (keyspace == 1)
14894 {
14895 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14896
14897 return (-1);
14898 }
14899
14900 char **dictionary_files = NULL;
14901
14902 dictionary_files = scan_directory (l0_filename);
14903
14904 if (dictionary_files != NULL)
14905 {
14906 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14907
14908 for (int d = 0; dictionary_files[d] != NULL; d++)
14909 {
14910 char *l1_filename = dictionary_files[d];
14911
14912 struct stat l1_stat;
14913
14914 if (stat (l1_filename, &l1_stat) == -1)
14915 {
14916 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14917
14918 return (-1);
14919 }
14920
14921 if (S_ISREG (l1_stat.st_mode))
14922 {
14923 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14924
14925 dictcnt++;
14926
14927 dictfiles[dictcnt - 1] = strdup (l1_filename);
14928 }
14929 }
14930 }
14931
14932 local_free (dictionary_files);
14933 }
14934 }
14935
14936 if (dictcnt < 1)
14937 {
14938 log_error ("ERROR: No usable dictionary file found.");
14939
14940 return (-1);
14941 }
14942 }
14943 else if (wordlist_mode == WL_MODE_STDIN)
14944 {
14945 dictcnt = 1;
14946 }
14947 }
14948 else if (attack_mode == ATTACK_MODE_COMBI)
14949 {
14950 // display
14951
14952 char *dictfile1 = myargv[optind + 1 + 0];
14953 char *dictfile2 = myargv[optind + 1 + 1];
14954
14955 // find the bigger dictionary and use as base
14956
14957 FILE *fp1 = NULL;
14958 FILE *fp2 = NULL;
14959
14960 struct stat tmp_stat;
14961
14962 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14963 {
14964 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14965
14966 return (-1);
14967 }
14968
14969 if (stat (dictfile1, &tmp_stat) == -1)
14970 {
14971 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14972
14973 fclose (fp1);
14974
14975 return (-1);
14976 }
14977
14978 if (S_ISDIR (tmp_stat.st_mode))
14979 {
14980 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14981
14982 fclose (fp1);
14983
14984 return (-1);
14985 }
14986
14987 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14988 {
14989 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14990
14991 fclose (fp1);
14992
14993 return (-1);
14994 }
14995
14996 if (stat (dictfile2, &tmp_stat) == -1)
14997 {
14998 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14999
15000 fclose (fp1);
15001 fclose (fp2);
15002
15003 return (-1);
15004 }
15005
15006 if (S_ISDIR (tmp_stat.st_mode))
15007 {
15008 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15009
15010 fclose (fp1);
15011 fclose (fp2);
15012
15013 return (-1);
15014 }
15015
15016 data.combs_cnt = 1;
15017
15018 data.quiet = 1;
15019
15020 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15021
15022 data.quiet = quiet;
15023
15024 if (words1_cnt == 0)
15025 {
15026 log_error ("ERROR: %s: empty file", dictfile1);
15027
15028 fclose (fp1);
15029 fclose (fp2);
15030
15031 return (-1);
15032 }
15033
15034 data.combs_cnt = 1;
15035
15036 data.quiet = 1;
15037
15038 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15039
15040 data.quiet = quiet;
15041
15042 if (words2_cnt == 0)
15043 {
15044 log_error ("ERROR: %s: empty file", dictfile2);
15045
15046 fclose (fp1);
15047 fclose (fp2);
15048
15049 return (-1);
15050 }
15051
15052 fclose (fp1);
15053 fclose (fp2);
15054
15055 data.dictfile = dictfile1;
15056 data.dictfile2 = dictfile2;
15057
15058 if (words1_cnt >= words2_cnt)
15059 {
15060 data.combs_cnt = words2_cnt;
15061 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15062
15063 dictfiles = &data.dictfile;
15064
15065 dictcnt = 1;
15066 }
15067 else
15068 {
15069 data.combs_cnt = words1_cnt;
15070 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15071
15072 dictfiles = &data.dictfile2;
15073
15074 dictcnt = 1;
15075
15076 // we also have to switch wordlist related rules!
15077
15078 char *tmpc = data.rule_buf_l;
15079
15080 data.rule_buf_l = data.rule_buf_r;
15081 data.rule_buf_r = tmpc;
15082
15083 int tmpi = data.rule_len_l;
15084
15085 data.rule_len_l = data.rule_len_r;
15086 data.rule_len_r = tmpi;
15087 }
15088 }
15089 else if (attack_mode == ATTACK_MODE_BF)
15090 {
15091 char *mask = NULL;
15092
15093 maskcnt = 0;
15094
15095 if (benchmark == 0)
15096 {
15097 mask = myargv[optind + 1];
15098
15099 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15100
15101 if ((optind + 2) <= myargc)
15102 {
15103 struct stat file_stat;
15104
15105 if (stat (mask, &file_stat) == -1)
15106 {
15107 maskcnt = 1;
15108
15109 masks[maskcnt - 1] = mystrdup (mask);
15110 }
15111 else
15112 {
15113 int wls_left = myargc - (optind + 1);
15114
15115 uint masks_avail = INCR_MASKS;
15116
15117 for (int i = 0; i < wls_left; i++)
15118 {
15119 if (i != 0)
15120 {
15121 mask = myargv[optind + 1 + i];
15122
15123 if (stat (mask, &file_stat) == -1)
15124 {
15125 log_error ("ERROR: %s: %s", mask, strerror (errno));
15126
15127 return (-1);
15128 }
15129 }
15130
15131 uint is_file = S_ISREG (file_stat.st_mode);
15132
15133 if (is_file == 1)
15134 {
15135 FILE *mask_fp;
15136
15137 if ((mask_fp = fopen (mask, "r")) == NULL)
15138 {
15139 log_error ("ERROR: %s: %s", mask, strerror (errno));
15140
15141 return (-1);
15142 }
15143
15144 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15145
15146 while (!feof (mask_fp))
15147 {
15148 memset (line_buf, 0, HCBUFSIZ);
15149
15150 int line_len = fgetl (mask_fp, line_buf);
15151
15152 if (line_len == 0) continue;
15153
15154 if (line_buf[0] == '#') continue;
15155
15156 if (masks_avail == maskcnt)
15157 {
15158 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15159
15160 masks_avail += INCR_MASKS;
15161 }
15162
15163 masks[maskcnt] = mystrdup (line_buf);
15164
15165 maskcnt++;
15166 }
15167
15168 myfree (line_buf);
15169
15170 fclose (mask_fp);
15171 }
15172 else
15173 {
15174 log_error ("ERROR: %s: unsupported file-type", mask);
15175
15176 return (-1);
15177 }
15178 }
15179
15180 mask_from_file = 1;
15181 }
15182 }
15183 else
15184 {
15185 custom_charset_1 = (char *) "?l?d?u";
15186 custom_charset_2 = (char *) "?l?d";
15187 custom_charset_3 = (char *) "?l?d*!$@_";
15188
15189 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15190 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15191 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15192
15193 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15194
15195 wordlist_mode = WL_MODE_MASK;
15196
15197 data.wordlist_mode = wordlist_mode;
15198
15199 increment = 1;
15200
15201 maskcnt = 1;
15202 }
15203 }
15204 else
15205 {
15206 /**
15207 * generate full masks and charsets
15208 */
15209
15210 masks = (char **) mymalloc (sizeof (char *));
15211
15212 switch (hash_mode)
15213 {
15214 case 1731: pw_min = 5;
15215 pw_max = 5;
15216 mask = mystrdup ("?b?b?b?b?b");
15217 break;
15218 case 12500: pw_min = 5;
15219 pw_max = 5;
15220 mask = mystrdup ("?b?b?b?b?b");
15221 break;
15222 default: pw_min = 7;
15223 pw_max = 7;
15224 mask = mystrdup ("?b?b?b?b?b?b?b");
15225 break;
15226 }
15227
15228 maskcnt = 1;
15229
15230 masks[maskcnt - 1] = mystrdup (mask);
15231
15232 wordlist_mode = WL_MODE_MASK;
15233
15234 data.wordlist_mode = wordlist_mode;
15235
15236 increment = 1;
15237 }
15238
15239 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15240
15241 if (increment)
15242 {
15243 if (increment_min > pw_min) pw_min = increment_min;
15244
15245 if (increment_max < pw_max) pw_max = increment_max;
15246 }
15247 }
15248 else if (attack_mode == ATTACK_MODE_HYBRID1)
15249 {
15250 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15251
15252 // display
15253
15254 char *mask = myargv[myargc - 1];
15255
15256 maskcnt = 0;
15257
15258 masks = (char **) mymalloc (1 * sizeof (char *));
15259
15260 // mod
15261
15262 struct stat file_stat;
15263
15264 if (stat (mask, &file_stat) == -1)
15265 {
15266 maskcnt = 1;
15267
15268 masks[maskcnt - 1] = mystrdup (mask);
15269 }
15270 else
15271 {
15272 uint is_file = S_ISREG (file_stat.st_mode);
15273
15274 if (is_file == 1)
15275 {
15276 FILE *mask_fp;
15277
15278 if ((mask_fp = fopen (mask, "r")) == NULL)
15279 {
15280 log_error ("ERROR: %s: %s", mask, strerror (errno));
15281
15282 return (-1);
15283 }
15284
15285 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15286
15287 uint masks_avail = 1;
15288
15289 while (!feof (mask_fp))
15290 {
15291 memset (line_buf, 0, HCBUFSIZ);
15292
15293 int line_len = fgetl (mask_fp, line_buf);
15294
15295 if (line_len == 0) continue;
15296
15297 if (line_buf[0] == '#') continue;
15298
15299 if (masks_avail == maskcnt)
15300 {
15301 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15302
15303 masks_avail += INCR_MASKS;
15304 }
15305
15306 masks[maskcnt] = mystrdup (line_buf);
15307
15308 maskcnt++;
15309 }
15310
15311 myfree (line_buf);
15312
15313 fclose (mask_fp);
15314
15315 mask_from_file = 1;
15316 }
15317 else
15318 {
15319 maskcnt = 1;
15320
15321 masks[maskcnt - 1] = mystrdup (mask);
15322 }
15323 }
15324
15325 // base
15326
15327 int wls_left = myargc - (optind + 2);
15328
15329 for (int i = 0; i < wls_left; i++)
15330 {
15331 char *filename = myargv[optind + 1 + i];
15332
15333 struct stat file_stat;
15334
15335 if (stat (filename, &file_stat) == -1)
15336 {
15337 log_error ("ERROR: %s: %s", filename, strerror (errno));
15338
15339 return (-1);
15340 }
15341
15342 uint is_dir = S_ISDIR (file_stat.st_mode);
15343
15344 if (is_dir == 0)
15345 {
15346 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15347
15348 dictcnt++;
15349
15350 dictfiles[dictcnt - 1] = filename;
15351 }
15352 else
15353 {
15354 // do not allow --keyspace w/ a directory
15355
15356 if (keyspace == 1)
15357 {
15358 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15359
15360 return (-1);
15361 }
15362
15363 char **dictionary_files = NULL;
15364
15365 dictionary_files = scan_directory (filename);
15366
15367 if (dictionary_files != NULL)
15368 {
15369 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15370
15371 for (int d = 0; dictionary_files[d] != NULL; d++)
15372 {
15373 char *l1_filename = dictionary_files[d];
15374
15375 struct stat l1_stat;
15376
15377 if (stat (l1_filename, &l1_stat) == -1)
15378 {
15379 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15380
15381 return (-1);
15382 }
15383
15384 if (S_ISREG (l1_stat.st_mode))
15385 {
15386 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15387
15388 dictcnt++;
15389
15390 dictfiles[dictcnt - 1] = strdup (l1_filename);
15391 }
15392 }
15393 }
15394
15395 local_free (dictionary_files);
15396 }
15397 }
15398
15399 if (dictcnt < 1)
15400 {
15401 log_error ("ERROR: No usable dictionary file found.");
15402
15403 return (-1);
15404 }
15405
15406 if (increment)
15407 {
15408 maskcnt = 0;
15409
15410 uint mask_min = increment_min; // we can't reject smaller masks here
15411 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15412
15413 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15414 {
15415 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15416
15417 if (cur_mask == NULL) break;
15418
15419 masks[maskcnt] = cur_mask;
15420
15421 maskcnt++;
15422
15423 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15424 }
15425 }
15426 }
15427 else if (attack_mode == ATTACK_MODE_HYBRID2)
15428 {
15429 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15430
15431 // display
15432
15433 char *mask = myargv[optind + 1 + 0];
15434
15435 maskcnt = 0;
15436
15437 masks = (char **) mymalloc (1 * sizeof (char *));
15438
15439 // mod
15440
15441 struct stat file_stat;
15442
15443 if (stat (mask, &file_stat) == -1)
15444 {
15445 maskcnt = 1;
15446
15447 masks[maskcnt - 1] = mystrdup (mask);
15448 }
15449 else
15450 {
15451 uint is_file = S_ISREG (file_stat.st_mode);
15452
15453 if (is_file == 1)
15454 {
15455 FILE *mask_fp;
15456
15457 if ((mask_fp = fopen (mask, "r")) == NULL)
15458 {
15459 log_error ("ERROR: %s: %s", mask, strerror (errno));
15460
15461 return (-1);
15462 }
15463
15464 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15465
15466 uint masks_avail = 1;
15467
15468 while (!feof (mask_fp))
15469 {
15470 memset (line_buf, 0, HCBUFSIZ);
15471
15472 int line_len = fgetl (mask_fp, line_buf);
15473
15474 if (line_len == 0) continue;
15475
15476 if (line_buf[0] == '#') continue;
15477
15478 if (masks_avail == maskcnt)
15479 {
15480 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15481
15482 masks_avail += INCR_MASKS;
15483 }
15484
15485 masks[maskcnt] = mystrdup (line_buf);
15486
15487 maskcnt++;
15488 }
15489
15490 myfree (line_buf);
15491
15492 fclose (mask_fp);
15493
15494 mask_from_file = 1;
15495 }
15496 else
15497 {
15498 maskcnt = 1;
15499
15500 masks[maskcnt - 1] = mystrdup (mask);
15501 }
15502 }
15503
15504 // base
15505
15506 int wls_left = myargc - (optind + 2);
15507
15508 for (int i = 0; i < wls_left; i++)
15509 {
15510 char *filename = myargv[optind + 2 + i];
15511
15512 struct stat file_stat;
15513
15514 if (stat (filename, &file_stat) == -1)
15515 {
15516 log_error ("ERROR: %s: %s", filename, strerror (errno));
15517
15518 return (-1);
15519 }
15520
15521 uint is_dir = S_ISDIR (file_stat.st_mode);
15522
15523 if (is_dir == 0)
15524 {
15525 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15526
15527 dictcnt++;
15528
15529 dictfiles[dictcnt - 1] = filename;
15530 }
15531 else
15532 {
15533 // do not allow --keyspace w/ a directory
15534
15535 if (keyspace == 1)
15536 {
15537 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15538
15539 return (-1);
15540 }
15541
15542 char **dictionary_files = NULL;
15543
15544 dictionary_files = scan_directory (filename);
15545
15546 if (dictionary_files != NULL)
15547 {
15548 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15549
15550 for (int d = 0; dictionary_files[d] != NULL; d++)
15551 {
15552 char *l1_filename = dictionary_files[d];
15553
15554 struct stat l1_stat;
15555
15556 if (stat (l1_filename, &l1_stat) == -1)
15557 {
15558 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15559
15560 return (-1);
15561 }
15562
15563 if (S_ISREG (l1_stat.st_mode))
15564 {
15565 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15566
15567 dictcnt++;
15568
15569 dictfiles[dictcnt - 1] = strdup (l1_filename);
15570 }
15571 }
15572 }
15573
15574 local_free (dictionary_files);
15575 }
15576 }
15577
15578 if (dictcnt < 1)
15579 {
15580 log_error ("ERROR: No usable dictionary file found.");
15581
15582 return (-1);
15583 }
15584
15585 if (increment)
15586 {
15587 maskcnt = 0;
15588
15589 uint mask_min = increment_min; // we can't reject smaller masks here
15590 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15591
15592 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15593 {
15594 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15595
15596 if (cur_mask == NULL) break;
15597
15598 masks[maskcnt] = cur_mask;
15599
15600 maskcnt++;
15601
15602 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15603 }
15604 }
15605 }
15606
15607 data.pw_min = pw_min;
15608 data.pw_max = pw_max;
15609
15610 /**
15611 * weak hash check
15612 */
15613
15614 if (weak_hash_threshold >= salts_cnt)
15615 {
15616 hc_device_param_t *device_param = NULL;
15617
15618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15619 {
15620 device_param = &data.devices_param[device_id];
15621
15622 if (device_param->skipped) continue;
15623
15624 break;
15625 }
15626
15627 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15628
15629 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15630 {
15631 weak_hash_check (device_param, salt_pos);
15632 }
15633 }
15634
15635 // Display hack, guarantee that there is at least one \r before real start
15636
15637 if (data.quiet == 0) log_info_nn ("");
15638
15639 /**
15640 * status and monitor threads
15641 */
15642
15643 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15644
15645 hc_thread_t i_thread = 0;
15646
15647 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15648 {
15649 hc_thread_create (i_thread, thread_keypress, &benchmark);
15650 }
15651
15652 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15653
15654 uint ni_threads_cnt = 0;
15655
15656 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15657
15658 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15659
15660 ni_threads_cnt++;
15661
15662 /**
15663 * Outfile remove
15664 */
15665
15666 if (keyspace == 0)
15667 {
15668 if (outfile_check_timer != 0)
15669 {
15670 if (data.outfile_check_directory != NULL)
15671 {
15672 if ((hash_mode != 5200) &&
15673 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15674 (hash_mode != 9000))
15675 {
15676 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15677
15678 ni_threads_cnt++;
15679 }
15680 else
15681 {
15682 outfile_check_timer = 0;
15683 }
15684 }
15685 else
15686 {
15687 outfile_check_timer = 0;
15688 }
15689 }
15690 }
15691
15692 /**
15693 * Inform the user if we got some hashes remove because of the pot file remove feature
15694 */
15695
15696 if (data.quiet == 0)
15697 {
15698 if (potfile_remove_cracks > 0)
15699 {
15700 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15701 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15702 }
15703 }
15704
15705 data.outfile_check_timer = outfile_check_timer;
15706
15707 /**
15708 * main loop
15709 */
15710
15711 char **induction_dictionaries = NULL;
15712
15713 int induction_dictionaries_cnt = 0;
15714
15715 hcstat_table_t *root_table_buf = NULL;
15716 hcstat_table_t *markov_table_buf = NULL;
15717
15718 uint initial_restore_done = 0;
15719
15720 data.maskcnt = maskcnt;
15721
15722 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15723 {
15724 if (data.devices_status == STATUS_CRACKED) break;
15725
15726 data.devices_status = STATUS_INIT;
15727
15728 if (maskpos > rd->maskpos)
15729 {
15730 rd->dictpos = 0;
15731 }
15732
15733 rd->maskpos = maskpos;
15734 data.maskpos = maskpos;
15735
15736 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15737 {
15738 char *mask = masks[maskpos];
15739
15740 if (mask_from_file == 1)
15741 {
15742 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15743
15744 char *str_ptr;
15745 uint str_pos;
15746
15747 uint mask_offset = 0;
15748
15749 uint separator_cnt;
15750
15751 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15752 {
15753 str_ptr = strstr (mask + mask_offset, ",");
15754
15755 if (str_ptr == NULL) break;
15756
15757 str_pos = str_ptr - mask;
15758
15759 // escaped separator, i.e. "\,"
15760
15761 if (str_pos > 0)
15762 {
15763 if (mask[str_pos - 1] == '\\')
15764 {
15765 separator_cnt --;
15766
15767 mask_offset = str_pos + 1;
15768
15769 continue;
15770 }
15771 }
15772
15773 // reset the offset
15774
15775 mask_offset = 0;
15776
15777 mask[str_pos] = '\0';
15778
15779 switch (separator_cnt)
15780 {
15781 case 0:
15782 mp_reset_usr (mp_usr, 0);
15783
15784 custom_charset_1 = mask;
15785 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15786 break;
15787
15788 case 1:
15789 mp_reset_usr (mp_usr, 1);
15790
15791 custom_charset_2 = mask;
15792 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15793 break;
15794
15795 case 2:
15796 mp_reset_usr (mp_usr, 2);
15797
15798 custom_charset_3 = mask;
15799 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15800 break;
15801
15802 case 3:
15803 mp_reset_usr (mp_usr, 3);
15804
15805 custom_charset_4 = mask;
15806 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15807 break;
15808 }
15809
15810 mask = mask + str_pos + 1;
15811 }
15812 }
15813
15814 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15815 {
15816 if (maskpos > 0)
15817 {
15818 local_free (css_buf);
15819 local_free (data.root_css_buf);
15820 local_free (data.markov_css_buf);
15821
15822 local_free (masks[maskpos - 1]);
15823 }
15824
15825 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15826
15827 data.mask = mask;
15828 data.css_cnt = css_cnt;
15829 data.css_buf = css_buf;
15830
15831 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15832
15833 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15834
15835 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15836 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15837
15838 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15839
15840 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15841
15842 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15843 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15844
15845 data.root_css_buf = root_css_buf;
15846 data.markov_css_buf = markov_css_buf;
15847
15848 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15849
15850 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15851
15852 local_free (root_table_buf);
15853 local_free (markov_table_buf);
15854
15855 // args
15856
15857 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15858 {
15859 hc_device_param_t *device_param = &data.devices_param[device_id];
15860
15861 if (device_param->skipped) continue;
15862
15863 device_param->kernel_params_mp[0] = &device_param->d_combs;
15864 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15865 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15866
15867 device_param->kernel_params_mp_buf64[3] = 0;
15868 device_param->kernel_params_mp_buf32[4] = css_cnt;
15869 device_param->kernel_params_mp_buf32[5] = 0;
15870 device_param->kernel_params_mp_buf32[6] = 0;
15871 device_param->kernel_params_mp_buf32[7] = 0;
15872
15873 if (attack_mode == ATTACK_MODE_HYBRID1)
15874 {
15875 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15876 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15877 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15878 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15879 }
15880 else if (attack_mode == ATTACK_MODE_HYBRID2)
15881 {
15882 device_param->kernel_params_mp_buf32[5] = 0;
15883 device_param->kernel_params_mp_buf32[6] = 0;
15884 device_param->kernel_params_mp_buf32[7] = 0;
15885 }
15886
15887 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]);
15888 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]);
15889 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]);
15890
15891 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);
15892 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);
15893 }
15894 }
15895 else if (attack_mode == ATTACK_MODE_BF)
15896 {
15897 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15898
15899 if (increment)
15900 {
15901 for (uint i = 0; i < dictcnt; i++)
15902 {
15903 local_free (dictfiles[i]);
15904 }
15905
15906 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15907 {
15908 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15909
15910 if (l1_filename == NULL) break;
15911
15912 dictcnt++;
15913
15914 dictfiles[dictcnt - 1] = l1_filename;
15915 }
15916 }
15917 else
15918 {
15919 dictcnt++;
15920
15921 dictfiles[dictcnt - 1] = mask;
15922 }
15923
15924 if (dictcnt == 0)
15925 {
15926 log_error ("ERROR: Mask is too small");
15927
15928 return (-1);
15929 }
15930 }
15931 }
15932
15933 free (induction_dictionaries);
15934
15935 // induction_dictionaries_cnt = 0; // implied
15936
15937 if (attack_mode != ATTACK_MODE_BF)
15938 {
15939 if (keyspace == 0)
15940 {
15941 induction_dictionaries = scan_directory (induction_directory);
15942
15943 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15944 }
15945 }
15946
15947 if (induction_dictionaries_cnt)
15948 {
15949 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15950 }
15951
15952 /**
15953 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15954 */
15955 if (keyspace == 1)
15956 {
15957 if ((maskcnt > 1) || (dictcnt > 1))
15958 {
15959 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15960
15961 return (-1);
15962 }
15963 }
15964
15965 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15966 {
15967 char *subid = logfile_generate_subid ();
15968
15969 data.subid = subid;
15970
15971 logfile_sub_msg ("START");
15972
15973 data.devices_status = STATUS_INIT;
15974
15975 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15976 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15977 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15978
15979 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15980
15981 data.cpt_pos = 0;
15982
15983 data.cpt_start = time (NULL);
15984
15985 data.cpt_total = 0;
15986
15987 if (data.restore == 0)
15988 {
15989 rd->words_cur = skip;
15990
15991 skip = 0;
15992
15993 data.skip = 0;
15994 }
15995
15996 data.ms_paused = 0;
15997
15998 data.words_cur = rd->words_cur;
15999
16000 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16001 {
16002 hc_device_param_t *device_param = &data.devices_param[device_id];
16003
16004 if (device_param->skipped) continue;
16005
16006 device_param->speed_pos = 0;
16007
16008 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16009 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
16010 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
16011
16012 device_param->exec_pos = 0;
16013
16014 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16015
16016 device_param->kernel_power = device_param->kernel_power_user;
16017
16018 device_param->outerloop_pos = 0;
16019 device_param->outerloop_left = 0;
16020 device_param->innerloop_pos = 0;
16021 device_param->innerloop_left = 0;
16022
16023 // some more resets:
16024
16025 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16026
16027 device_param->pws_cnt = 0;
16028
16029 device_param->words_off = 0;
16030 device_param->words_done = 0;
16031 }
16032
16033 data.kernel_power_div = 0;
16034
16035 // figure out some workload
16036
16037 if (attack_mode == ATTACK_MODE_STRAIGHT)
16038 {
16039 if (data.wordlist_mode == WL_MODE_FILE)
16040 {
16041 char *dictfile = NULL;
16042
16043 if (induction_dictionaries_cnt)
16044 {
16045 dictfile = induction_dictionaries[0];
16046 }
16047 else
16048 {
16049 dictfile = dictfiles[dictpos];
16050 }
16051
16052 data.dictfile = dictfile;
16053
16054 logfile_sub_string (dictfile);
16055
16056 for (uint i = 0; i < rp_files_cnt; i++)
16057 {
16058 logfile_sub_var_string ("rulefile", rp_files[i]);
16059 }
16060
16061 FILE *fd2 = fopen (dictfile, "rb");
16062
16063 if (fd2 == NULL)
16064 {
16065 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16066
16067 return (-1);
16068 }
16069
16070 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16071
16072 fclose (fd2);
16073
16074 if (data.words_cnt == 0)
16075 {
16076 if (data.devices_status == STATUS_CRACKED) break;
16077 if (data.devices_status == STATUS_ABORTED) break;
16078
16079 dictpos++;
16080
16081 continue;
16082 }
16083 }
16084 }
16085 else if (attack_mode == ATTACK_MODE_COMBI)
16086 {
16087 char *dictfile = data.dictfile;
16088 char *dictfile2 = data.dictfile2;
16089
16090 logfile_sub_string (dictfile);
16091 logfile_sub_string (dictfile2);
16092
16093 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16094 {
16095 FILE *fd2 = fopen (dictfile, "rb");
16096
16097 if (fd2 == NULL)
16098 {
16099 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16100
16101 return (-1);
16102 }
16103
16104 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16105
16106 fclose (fd2);
16107 }
16108 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16109 {
16110 FILE *fd2 = fopen (dictfile2, "rb");
16111
16112 if (fd2 == NULL)
16113 {
16114 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16115
16116 return (-1);
16117 }
16118
16119 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16120
16121 fclose (fd2);
16122 }
16123
16124 if (data.words_cnt == 0)
16125 {
16126 if (data.devices_status == STATUS_CRACKED) break;
16127 if (data.devices_status == STATUS_ABORTED) break;
16128
16129 dictpos++;
16130
16131 continue;
16132 }
16133 }
16134 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16135 {
16136 char *dictfile = NULL;
16137
16138 if (induction_dictionaries_cnt)
16139 {
16140 dictfile = induction_dictionaries[0];
16141 }
16142 else
16143 {
16144 dictfile = dictfiles[dictpos];
16145 }
16146
16147 data.dictfile = dictfile;
16148
16149 char *mask = data.mask;
16150
16151 logfile_sub_string (dictfile);
16152 logfile_sub_string (mask);
16153
16154 FILE *fd2 = fopen (dictfile, "rb");
16155
16156 if (fd2 == NULL)
16157 {
16158 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16159
16160 return (-1);
16161 }
16162
16163 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16164
16165 fclose (fd2);
16166
16167 if (data.words_cnt == 0)
16168 {
16169 if (data.devices_status == STATUS_CRACKED) break;
16170 if (data.devices_status == STATUS_ABORTED) break;
16171
16172 dictpos++;
16173
16174 continue;
16175 }
16176 }
16177 else if (attack_mode == ATTACK_MODE_BF)
16178 {
16179 local_free (css_buf);
16180 local_free (data.root_css_buf);
16181 local_free (data.markov_css_buf);
16182
16183 char *mask = dictfiles[dictpos];
16184
16185 logfile_sub_string (mask);
16186
16187 // base
16188
16189 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16190
16191 if (opts_type & OPTS_TYPE_PT_UNICODE)
16192 {
16193 uint css_cnt_unicode = css_cnt * 2;
16194
16195 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16196
16197 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16198 {
16199 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16200
16201 css_buf_unicode[j + 1].cs_buf[0] = 0;
16202 css_buf_unicode[j + 1].cs_len = 1;
16203 }
16204
16205 free (css_buf);
16206
16207 css_buf = css_buf_unicode;
16208 css_cnt = css_cnt_unicode;
16209 }
16210
16211 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16212
16213 uint mask_min = pw_min;
16214 uint mask_max = pw_max;
16215
16216 if (opts_type & OPTS_TYPE_PT_UNICODE)
16217 {
16218 mask_min *= 2;
16219 mask_max *= 2;
16220 }
16221
16222 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16223 {
16224 if (css_cnt < mask_min)
16225 {
16226 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16227 }
16228
16229 if (css_cnt > mask_max)
16230 {
16231 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16232 }
16233
16234 // skip to next mask
16235
16236 dictpos++;
16237
16238 rd->dictpos = dictpos;
16239
16240 logfile_sub_msg ("STOP");
16241
16242 continue;
16243 }
16244
16245 uint save_css_cnt = css_cnt;
16246
16247 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16248 {
16249 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16250 {
16251 uint salt_len = (uint) data.salts_buf[0].salt_len;
16252 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16253
16254 uint css_cnt_salt = css_cnt + salt_len;
16255
16256 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16257
16258 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16259
16260 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16261 {
16262 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16263 css_buf_salt[j].cs_len = 1;
16264 }
16265
16266 free (css_buf);
16267
16268 css_buf = css_buf_salt;
16269 css_cnt = css_cnt_salt;
16270 }
16271 }
16272
16273 data.mask = mask;
16274 data.css_cnt = css_cnt;
16275 data.css_buf = css_buf;
16276
16277 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16278
16279 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16280
16281 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16282
16283 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16284 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16285
16286 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16287
16288 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16289
16290 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16291 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16292
16293 data.root_css_buf = root_css_buf;
16294 data.markov_css_buf = markov_css_buf;
16295
16296 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16297
16298 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16299
16300 local_free (root_table_buf);
16301 local_free (markov_table_buf);
16302
16303 // copy + args
16304
16305 uint css_cnt_l = css_cnt;
16306 uint css_cnt_r;
16307
16308 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16309 {
16310 if (save_css_cnt < 6)
16311 {
16312 css_cnt_r = 1;
16313 }
16314 else if (save_css_cnt == 6)
16315 {
16316 css_cnt_r = 2;
16317 }
16318 else
16319 {
16320 if (opts_type & OPTS_TYPE_PT_UNICODE)
16321 {
16322 if (save_css_cnt == 8 || save_css_cnt == 10)
16323 {
16324 css_cnt_r = 2;
16325 }
16326 else
16327 {
16328 css_cnt_r = 4;
16329 }
16330 }
16331 else
16332 {
16333 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16334 {
16335 css_cnt_r = 3;
16336 }
16337 else
16338 {
16339 css_cnt_r = 4;
16340 }
16341 }
16342 }
16343 }
16344 else
16345 {
16346 css_cnt_r = 1;
16347
16348 /* unfinished code?
16349 int sum = css_buf[css_cnt_r - 1].cs_len;
16350
16351 for (uint i = 1; i < 4 && i < css_cnt; i++)
16352 {
16353 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16354
16355 css_cnt_r++;
16356
16357 sum *= css_buf[css_cnt_r - 1].cs_len;
16358 }
16359 */
16360 }
16361
16362 css_cnt_l -= css_cnt_r;
16363
16364 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16365
16366 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16367 {
16368 hc_device_param_t *device_param = &data.devices_param[device_id];
16369
16370 if (device_param->skipped) continue;
16371
16372 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16373 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16374 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16375
16376 device_param->kernel_params_mp_l_buf64[3] = 0;
16377 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16378 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16379 device_param->kernel_params_mp_l_buf32[6] = 0;
16380 device_param->kernel_params_mp_l_buf32[7] = 0;
16381 device_param->kernel_params_mp_l_buf32[8] = 0;
16382
16383 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16384 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16385 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16386 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16387
16388 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16389 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16390 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16391
16392 device_param->kernel_params_mp_r_buf64[3] = 0;
16393 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16394 device_param->kernel_params_mp_r_buf32[5] = 0;
16395 device_param->kernel_params_mp_r_buf32[6] = 0;
16396 device_param->kernel_params_mp_r_buf32[7] = 0;
16397
16398 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]);
16399 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]);
16400 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]);
16401
16402 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]);
16403 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]);
16404 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]);
16405
16406 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);
16407 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);
16408 }
16409 }
16410
16411 u64 words_base = data.words_cnt;
16412
16413 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16414 {
16415 if (data.kernel_rules_cnt)
16416 {
16417 words_base /= data.kernel_rules_cnt;
16418 }
16419 }
16420 else if (data.attack_kern == ATTACK_KERN_COMBI)
16421 {
16422 if (data.combs_cnt)
16423 {
16424 words_base /= data.combs_cnt;
16425 }
16426 }
16427 else if (data.attack_kern == ATTACK_KERN_BF)
16428 {
16429 if (data.bfs_cnt)
16430 {
16431 words_base /= data.bfs_cnt;
16432 }
16433 }
16434
16435 data.words_base = words_base;
16436
16437 if (keyspace == 1)
16438 {
16439 log_info ("%llu", (unsigned long long int) words_base);
16440
16441 return (0);
16442 }
16443
16444 if (data.words_cur > data.words_base)
16445 {
16446 log_error ("ERROR: restore value greater keyspace");
16447
16448 return (-1);
16449 }
16450
16451 if (data.words_cur)
16452 {
16453 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16454 {
16455 for (uint i = 0; i < data.salts_cnt; i++)
16456 {
16457 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16458 }
16459 }
16460 else if (data.attack_kern == ATTACK_KERN_COMBI)
16461 {
16462 for (uint i = 0; i < data.salts_cnt; i++)
16463 {
16464 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16465 }
16466 }
16467 else if (data.attack_kern == ATTACK_KERN_BF)
16468 {
16469 for (uint i = 0; i < data.salts_cnt; i++)
16470 {
16471 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16472 }
16473 }
16474 }
16475
16476 /*
16477 * Inform user about possible slow speeds
16478 */
16479
16480 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16481 {
16482 if (data.words_base < kernel_power_all)
16483 {
16484 if (quiet == 0)
16485 {
16486 log_info ("");
16487 log_info ("ATTENTION!");
16488 log_info (" The wordlist or mask you are using is too small.");
16489 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16490 log_info (" The cracking speed will drop.");
16491 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16492 log_info ("");
16493 }
16494 }
16495 }
16496
16497 /*
16498 * Update loopback file
16499 */
16500
16501 if (loopback == 1)
16502 {
16503 time_t now;
16504
16505 time (&now);
16506
16507 uint random_num = get_random_num (0, 9999);
16508
16509 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16510
16511 data.loopback_file = loopback_file;
16512 }
16513
16514 /*
16515 * Update dictionary statistic
16516 */
16517
16518 if (keyspace == 0)
16519 {
16520 dictstat_fp = fopen (dictstat, "wb");
16521
16522 if (dictstat_fp)
16523 {
16524 lock_file (dictstat_fp);
16525
16526 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16527
16528 fclose (dictstat_fp);
16529 }
16530 }
16531
16532 data.devices_status = STATUS_RUNNING;
16533
16534 if (initial_restore_done == 0)
16535 {
16536 if (data.restore_disable == 0) cycle_restore ();
16537
16538 initial_restore_done = 1;
16539 }
16540
16541 hc_timer_set (&data.timer_running);
16542
16543 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16544 {
16545 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16546 {
16547 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16548 if (quiet == 0) fflush (stdout);
16549 }
16550 }
16551 else if (wordlist_mode == WL_MODE_STDIN)
16552 {
16553 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16554 if (data.quiet == 0) log_info ("");
16555 }
16556
16557 time_t runtime_start;
16558
16559 time (&runtime_start);
16560
16561 data.runtime_start = runtime_start;
16562
16563 /**
16564 * create cracker threads
16565 */
16566
16567 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16568
16569 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16570 {
16571 hc_device_param_t *device_param = &devices_param[device_id];
16572
16573 if (wordlist_mode == WL_MODE_STDIN)
16574 {
16575 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16576 }
16577 else
16578 {
16579 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16580 }
16581 }
16582
16583 // wait for crack threads to exit
16584
16585 hc_thread_wait (data.devices_cnt, c_threads);
16586
16587 local_free (c_threads);
16588
16589 data.restore = 0;
16590
16591 // finalize task
16592
16593 logfile_sub_var_uint ("status-after-work", data.devices_status);
16594
16595 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16596
16597 if (data.devices_status == STATUS_CRACKED) break;
16598 if (data.devices_status == STATUS_ABORTED) break;
16599
16600 if (data.devices_status == STATUS_BYPASS)
16601 {
16602 data.devices_status = STATUS_RUNNING;
16603 }
16604
16605 if (induction_dictionaries_cnt)
16606 {
16607 unlink (induction_dictionaries[0]);
16608 }
16609
16610 free (induction_dictionaries);
16611
16612 if (attack_mode != ATTACK_MODE_BF)
16613 {
16614 induction_dictionaries = scan_directory (induction_directory);
16615
16616 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16617 }
16618
16619 if (benchmark == 0)
16620 {
16621 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16622 {
16623 if (quiet == 0) clear_prompt ();
16624
16625 if (quiet == 0) log_info ("");
16626
16627 if (status == 1)
16628 {
16629 status_display ();
16630 }
16631 else
16632 {
16633 if (quiet == 0) status_display ();
16634 }
16635
16636 if (quiet == 0) log_info ("");
16637 }
16638 }
16639
16640 if (attack_mode == ATTACK_MODE_BF)
16641 {
16642 dictpos++;
16643
16644 rd->dictpos = dictpos;
16645 }
16646 else
16647 {
16648 if (induction_dictionaries_cnt)
16649 {
16650 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16651 }
16652 else
16653 {
16654 dictpos++;
16655
16656 rd->dictpos = dictpos;
16657 }
16658 }
16659
16660 time_t runtime_stop;
16661
16662 time (&runtime_stop);
16663
16664 data.runtime_stop = runtime_stop;
16665
16666 logfile_sub_uint (runtime_start);
16667 logfile_sub_uint (runtime_stop);
16668
16669 logfile_sub_msg ("STOP");
16670
16671 global_free (subid);
16672 }
16673
16674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16675
16676 if (data.devices_status == STATUS_CRACKED) break;
16677 if (data.devices_status == STATUS_ABORTED) break;
16678 if (data.devices_status == STATUS_QUIT) break;
16679
16680 if (data.devices_status == STATUS_BYPASS)
16681 {
16682 data.devices_status = STATUS_RUNNING;
16683 }
16684 }
16685
16686 // 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
16687
16688 if (attack_mode == ATTACK_MODE_STRAIGHT)
16689 {
16690 if (data.wordlist_mode == WL_MODE_FILE)
16691 {
16692 if (data.dictfile == NULL)
16693 {
16694 if (dictfiles != NULL)
16695 {
16696 data.dictfile = dictfiles[0];
16697
16698 hc_timer_set (&data.timer_running);
16699 }
16700 }
16701 }
16702 }
16703 // NOTE: combi is okay because it is already set beforehand
16704 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16705 {
16706 if (data.dictfile == NULL)
16707 {
16708 if (dictfiles != NULL)
16709 {
16710 hc_timer_set (&data.timer_running);
16711
16712 data.dictfile = dictfiles[0];
16713 }
16714 }
16715 }
16716 else if (attack_mode == ATTACK_MODE_BF)
16717 {
16718 if (data.mask == NULL)
16719 {
16720 hc_timer_set (&data.timer_running);
16721
16722 data.mask = masks[0];
16723 }
16724 }
16725
16726 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16727 {
16728 data.devices_status = STATUS_EXHAUSTED;
16729 }
16730
16731 // if cracked / aborted remove last induction dictionary
16732
16733 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16734 {
16735 struct stat induct_stat;
16736
16737 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16738 {
16739 unlink (induction_dictionaries[file_pos]);
16740 }
16741 }
16742
16743 // wait for non-interactive threads
16744
16745 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16746 {
16747 hc_thread_wait (1, &ni_threads[thread_idx]);
16748 }
16749
16750 local_free (ni_threads);
16751
16752 // wait for interactive threads
16753
16754 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16755 {
16756 hc_thread_wait (1, &i_thread);
16757 }
16758
16759 // we dont need restore file anymore
16760 if (data.restore_disable == 0)
16761 {
16762 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16763 {
16764 unlink (eff_restore_file);
16765 unlink (new_restore_file);
16766 }
16767 else
16768 {
16769 cycle_restore ();
16770 }
16771 }
16772
16773 // finally save left hashes
16774
16775 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16776 {
16777 save_hash ();
16778 }
16779
16780 /**
16781 * Clean up
16782 */
16783
16784 if (benchmark == 1)
16785 {
16786 status_benchmark ();
16787
16788 log_info ("");
16789 }
16790 else
16791 {
16792 if (quiet == 0) clear_prompt ();
16793
16794 if (quiet == 0) log_info ("");
16795
16796 if (status == 1)
16797 {
16798 status_display ();
16799 }
16800 else
16801 {
16802 if (quiet == 0) status_display ();
16803 }
16804
16805 if (quiet == 0) log_info ("");
16806 }
16807
16808 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16809 {
16810 hc_device_param_t *device_param = &data.devices_param[device_id];
16811
16812 if (device_param->skipped) continue;
16813
16814 local_free (device_param->result);
16815
16816 local_free (device_param->combs_buf);
16817
16818 local_free (device_param->hooks_buf);
16819
16820 local_free (device_param->device_name);
16821
16822 local_free (device_param->device_name_chksum);
16823
16824 local_free (device_param->device_version);
16825
16826 local_free (device_param->driver_version);
16827
16828 if (device_param->pws_buf) myfree (device_param->pws_buf);
16829 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16830 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16831 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16832 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16833 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16834 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16835 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16836 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16837 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16838 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16839 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16840 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16841 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16842 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16843 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16844 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16845 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16846 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16847 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16848 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16849 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16850 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16851 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16852 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16853 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16854 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16855 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16856 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16857
16858 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16859 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16860 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16861 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16862 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16863 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16864 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16865 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16866 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16867 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16868
16869 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16870 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16871 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16872
16873 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16874 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16875 }
16876
16877 // reset default fan speed
16878
16879 #ifdef HAVE_HWMON
16880 if (gpu_temp_disable == 0)
16881 {
16882 #ifdef HAVE_ADL
16883 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16884 {
16885 hc_thread_mutex_lock (mux_adl);
16886
16887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16888 {
16889 hc_device_param_t *device_param = &data.devices_param[device_id];
16890
16891 if (device_param->skipped) continue;
16892
16893 if (data.hm_device[device_id].fan_supported == 1)
16894 {
16895 int fanspeed = temp_retain_fanspeed_value[device_id];
16896
16897 if (fanspeed == -1) continue;
16898
16899 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16900
16901 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16902 }
16903 }
16904
16905 hc_thread_mutex_unlock (mux_adl);
16906 }
16907 #endif // HAVE_ADL
16908 }
16909
16910 #ifdef HAVE_ADL
16911 // reset power tuning
16912
16913 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16914 {
16915 hc_thread_mutex_lock (mux_adl);
16916
16917 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16918 {
16919 hc_device_param_t *device_param = &data.devices_param[device_id];
16920
16921 if (device_param->skipped) continue;
16922
16923 if (data.hm_device[device_id].od_version == 6)
16924 {
16925 // check powertune capabilities first, if not available then skip device
16926
16927 int powertune_supported = 0;
16928
16929 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16930 {
16931 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16932
16933 return (-1);
16934 }
16935
16936 if (powertune_supported != 0)
16937 {
16938 // powercontrol settings
16939
16940 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)
16941 {
16942 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16943
16944 return (-1);
16945 }
16946
16947 // clocks
16948
16949 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16950
16951 performance_state->iNumberOfPerformanceLevels = 2;
16952
16953 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16954 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16955 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16956 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16957
16958 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)
16959 {
16960 log_info ("ERROR: Failed to restore ADL performance state");
16961
16962 return (-1);
16963 }
16964
16965 local_free (performance_state);
16966 }
16967 }
16968 }
16969
16970 hc_thread_mutex_unlock (mux_adl);
16971 }
16972 #endif // HAVE_ADL
16973
16974 if (gpu_temp_disable == 0)
16975 {
16976 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16977 if (data.hm_nv)
16978 {
16979 #if defined(LINUX) && defined(HAVE_NVML)
16980
16981 hm_NVML_nvmlShutdown (data.hm_nv);
16982
16983 nvml_close (data.hm_nv);
16984
16985 #elif defined(WIN) && (HAVE_NVAPI)
16986
16987 hm_NvAPI_Unload (data.hm_nv);
16988
16989 nvapi_close (data.hm_nv);
16990
16991 #endif
16992
16993 data.hm_nv = NULL;
16994 }
16995 #endif
16996
16997 #ifdef HAVE_ADL
16998 if (data.hm_amd)
16999 {
17000 hm_ADL_Main_Control_Destroy (data.hm_amd);
17001
17002 adl_close (data.hm_amd);
17003 data.hm_amd = NULL;
17004 }
17005 #endif
17006 }
17007 #endif // HAVE_HWMON
17008
17009 // free memory
17010
17011 local_free (masks);
17012
17013 local_free (dictstat_base);
17014
17015 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17016 {
17017 pot_t *pot_ptr = &pot[pot_pos];
17018
17019 hash_t *hash = &pot_ptr->hash;
17020
17021 local_free (hash->digest);
17022
17023 if (isSalted)
17024 {
17025 local_free (hash->salt);
17026 }
17027 }
17028
17029 local_free (pot);
17030
17031 local_free (all_kernel_rules_cnt);
17032 local_free (all_kernel_rules_buf);
17033
17034 local_free (wl_data->buf);
17035 local_free (wl_data);
17036
17037 local_free (bitmap_s1_a);
17038 local_free (bitmap_s1_b);
17039 local_free (bitmap_s1_c);
17040 local_free (bitmap_s1_d);
17041 local_free (bitmap_s2_a);
17042 local_free (bitmap_s2_b);
17043 local_free (bitmap_s2_c);
17044 local_free (bitmap_s2_d);
17045
17046 #ifdef HAVE_HWMON
17047 local_free (temp_retain_fanspeed_value);
17048 #ifdef HAVE_ADL
17049 local_free (od_clock_mem_status);
17050 local_free (od_power_control_status);
17051 #endif // ADL
17052 #endif
17053
17054 global_free (devices_param);
17055
17056 global_free (kernel_rules_buf);
17057
17058 global_free (root_css_buf);
17059 global_free (markov_css_buf);
17060
17061 global_free (digests_buf);
17062 global_free (digests_shown);
17063 global_free (digests_shown_tmp);
17064
17065 global_free (salts_buf);
17066 global_free (salts_shown);
17067
17068 global_free (esalts_buf);
17069
17070 global_free (words_progress_done);
17071 global_free (words_progress_rejected);
17072 global_free (words_progress_restored);
17073
17074 if (pot_fp) fclose (pot_fp);
17075
17076 if (data.devices_status == STATUS_QUIT) break;
17077 }
17078
17079 // destroy others mutex
17080
17081 hc_thread_mutex_delete (mux_dispatcher);
17082 hc_thread_mutex_delete (mux_counter);
17083 hc_thread_mutex_delete (mux_display);
17084 hc_thread_mutex_delete (mux_adl);
17085
17086 // free memory
17087
17088 local_free (eff_restore_file);
17089 local_free (new_restore_file);
17090
17091 local_free (rd);
17092
17093 // tuning db
17094
17095 tuning_db_destroy (tuning_db);
17096
17097 // loopback
17098
17099 local_free (loopback_file);
17100
17101 if (loopback == 1) unlink (loopback_file);
17102
17103 // induction directory
17104
17105 if (induction_dir == NULL)
17106 {
17107 if (attack_mode != ATTACK_MODE_BF)
17108 {
17109 if (rmdir (induction_directory) == -1)
17110 {
17111 if (errno == ENOENT)
17112 {
17113 // good, we can ignore
17114 }
17115 else if (errno == ENOTEMPTY)
17116 {
17117 // good, we can ignore
17118 }
17119 else
17120 {
17121 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17122
17123 return (-1);
17124 }
17125 }
17126
17127 local_free (induction_directory);
17128 }
17129 }
17130
17131 // outfile-check directory
17132
17133 if (outfile_check_dir == NULL)
17134 {
17135 if (rmdir (outfile_check_directory) == -1)
17136 {
17137 if (errno == ENOENT)
17138 {
17139 // good, we can ignore
17140 }
17141 else if (errno == ENOTEMPTY)
17142 {
17143 // good, we can ignore
17144 }
17145 else
17146 {
17147 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17148
17149 return (-1);
17150 }
17151 }
17152
17153 local_free (outfile_check_directory);
17154 }
17155
17156 time_t proc_stop;
17157
17158 time (&proc_stop);
17159
17160 logfile_top_uint (proc_start);
17161 logfile_top_uint (proc_stop);
17162
17163 logfile_top_msg ("STOP");
17164
17165 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17166 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17167
17168 if (data.ocl) ocl_close (data.ocl);
17169
17170 if (data.devices_status == STATUS_ABORTED) return 2;
17171 if (data.devices_status == STATUS_QUIT) return 2;
17172 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17173 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17174 if (data.devices_status == STATUS_CRACKED) return 0;
17175
17176 return -1;
17177 }
Hashcat additions to support pwdhash