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