projects / hashcat.git / blob
? search:


7bb62ce1e01240029042e0d67fedeb94e754a6e5
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "oclHashcat";
19 const uint VERSION_BIN = 210;
20 const uint RESTORE_MIN = 210;
21
22 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define BENCHMARK_REPEATS 2
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define STATUS_AUTOMAT 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 80
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS 64
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMT_HASHCAT 0
101 #define HLFMT_PWDUMP 1
102 #define HLFMT_PASSWD 2
103 #define HLFMT_SHADOW 3
104 #define HLFMT_DCC 4
105 #define HLFMT_DCC2 5
106 #define HLFMT_NETNTLM1 7
107 #define HLFMT_NETNTLM2 8
108 #define HLFMT_NSLDAP 9
109 #define HLFMT_NSLDAPS 10
110 #define HLFMTS_CNT 11
111
112 #define ATTACK_MODE_STRAIGHT 0
113 #define ATTACK_MODE_COMBI 1
114 #define ATTACK_MODE_TOGGLE 2
115 #define ATTACK_MODE_BF 3
116 #define ATTACK_MODE_PERM 4
117 #define ATTACK_MODE_TABLE 5
118 #define ATTACK_MODE_HYBRID1 6
119 #define ATTACK_MODE_HYBRID2 7
120 #define ATTACK_MODE_NONE 100
121
122 #define ATTACK_KERN_STRAIGHT 0
123 #define ATTACK_KERN_COMBI 1
124 #define ATTACK_KERN_BF 3
125 #define ATTACK_KERN_NONE 100
126
127 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
128 #define ATTACK_EXEC_INSIDE_KERNEL 11
129
130 #define COMBINATOR_MODE_BASE_LEFT 10001
131 #define COMBINATOR_MODE_BASE_RIGHT 10002
132
133 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
134 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
135
136 #define MAX_CUT_TRIES 4
137
138 #define MAX_DICTSTAT 10000
139
140 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 131
141
142 #define global_free(attr) \
143 { \
144 myfree ((void *) data.attr); \
145 \
146 data.attr = NULL; \
147 }
148
149 #define local_free(attr) \
150 { \
151 myfree ((void *) attr); \
152 \
153 attr = NULL; \
154 }
155
156 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
157 {
158 900,
159 0,
160 5100,
161 100,
162 1400,
163 10800,
164 1700,
165 5000,
166 10100,
167 6000,
168 6100,
169 6900,
170 11700,
171 11800,
172 400,
173 8900,
174 11900,
175 12000,
176 10900,
177 12100,
178 23,
179 2500,
180 5300,
181 5400,
182 5500,
183 5600,
184 7300,
185 7500,
186 13100,
187 8300,
188 11100,
189 11200,
190 11400,
191 121,
192 2611,
193 2711,
194 2811,
195 8400,
196 11,
197 2612,
198 7900,
199 21,
200 11000,
201 124,
202 10000,
203 3711,
204 7600,
205 12,
206 131,
207 132,
208 1731,
209 200,
210 300,
211 3100,
212 112,
213 12300,
214 8000,
215 141,
216 1441,
217 1600,
218 12600,
219 1421,
220 101,
221 111,
222 1711,
223 3000, // broken in osx
224 1000,
225 1100,
226 2100,
227 12800,
228 1500, // broken in osx
229 12400,
230 500,
231 3200,
232 7400,
233 1800,
234 122,
235 1722,
236 7100,
237 6300,
238 6700,
239 6400,
240 6500,
241 2400,
242 2410,
243 5700,
244 9200,
245 9300,
246 22,
247 501,
248 5800,
249 8100,
250 8500,
251 7200,
252 9900,
253 7700,
254 7800,
255 10300,
256 8600,
257 8700,
258 9100,
259 133,
260 11600,
261 12500,
262 13000,
263 6211,
264 6221,
265 6231,
266 6241,
267 8800,
268 12900,
269 12200,
270 9700,
271 9710,
272 9800,
273 9810,
274 9400,
275 9500,
276 9600,
277 10400,
278 10410,
279 10500,
280 10600,
281 10700, // broken in osx
282 9000,
283 5200,
284 6800,
285 6600,
286 8200,
287 11300,
288 12700
289 };
290
291 /**
292 * types
293 */
294
295 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
296
297 /**
298 * globals
299 */
300
301 static unsigned int full01 = 0x01010101;
302 static unsigned int full80 = 0x80808080;
303
304 int SUPPRESS_OUTPUT = 0;
305
306 hc_thread_mutex_t mux_adl;
307 hc_thread_mutex_t mux_counter;
308 hc_thread_mutex_t mux_dispatcher;
309 hc_thread_mutex_t mux_display;
310
311 hc_global_data_t data;
312
313 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
314
315 const char *USAGE_MINI[] =
316 {
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "Try --help for more help.",
320 NULL
321 };
322
323 const char *USAGE_BIG[] =
324 {
325 "%s, advanced password recovery",
326 "",
327 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
328 "",
329 "=======",
330 "Options",
331 "=======",
332 "",
333 "* General:",
334 "",
335 " -m, --hash-type=NUM Hash-type, see references below",
336 " -a, --attack-mode=NUM Attack-mode, see references below",
337 " -V, --version Print version",
338 " -h, --help Print help",
339 " --quiet Suppress output",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -b, --benchmark Run benchmark",
390 " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy",
391 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
392 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
393 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
396 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
397 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
398 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query",
399 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
400 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
401 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
402 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
405 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
406 #ifdef HAVE_ADL
407 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
408 #endif
409 #endif
410 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
411 "",
412 "* Distributed:",
413 "",
414 " -s, --skip=NUM Skip number of words",
415 " -l, --limit=NUM Limit number of words",
416 " --keyspace Show keyspace base:mod values and quit",
417 "",
418 "* Rules:",
419 "",
420 " -j, --rule-left=RULE Single rule applied to each word from left dict",
421 " -k, --rule-right=RULE Single rule applied to each word from right dict",
422 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
423 " -g, --generate-rules=NUM Generate NUM random rules",
424 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
425 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
426 " --generate-rules-seed=NUM Force RNG seed to NUM",
427 "",
428 "* Custom charsets:",
429 "",
430 " -1, --custom-charset1=CS User-defined charsets",
431 " -2, --custom-charset2=CS Example:",
432 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
433 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
434 "",
435 "* Increment:",
436 "",
437 " -i, --increment Enable increment mode",
438 " --increment-min=NUM Start incrementing at NUM",
439 " --increment-max=NUM Stop incrementing at NUM",
440 "",
441 "==========",
442 "References",
443 "==========",
444 "",
445 "* Workload Profile:",
446 "",
447 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
448 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
449 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
450 "",
451 "* OpenCL device-types:",
452 "",
453 " 1 = CPU devices",
454 " 2 = GPU devices",
455 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
456 "",
457 "* Outfile Formats:",
458 "",
459 " 1 = hash[:salt]",
460 " 2 = plain",
461 " 3 = hash[:salt]:plain",
462 " 4 = hex_plain",
463 " 5 = hash[:salt]:hex_plain",
464 " 6 = plain:hex_plain",
465 " 7 = hash[:salt]:plain:hex_plain",
466 " 8 = crackpos",
467 " 9 = hash[:salt]:crackpos",
468 " 10 = plain:crackpos",
469 " 11 = hash[:salt]:plain:crackpos",
470 " 12 = hex_plain:crackpos",
471 " 13 = hash[:salt]:hex_plain:crackpos",
472 " 14 = plain:hex_plain:crackpos",
473 " 15 = hash[:salt]:plain:hex_plain:crackpos",
474 "",
475 "* Debug mode output formats (for hybrid mode only, by using rules):",
476 "",
477 " 1 = save finding rule",
478 " 2 = save original word",
479 " 3 = save original word and finding rule",
480 " 4 = save original word, finding rule and modified plain",
481 "",
482 "* Built-in charsets:",
483 "",
484 " ?l = abcdefghijklmnopqrstuvwxyz",
485 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
486 " ?d = 0123456789",
487 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
488 " ?a = ?l?u?d?s",
489 " ?b = 0x00 - 0xff",
490 "",
491 "* Attack modes:",
492 "",
493 " 0 = Straight",
494 " 1 = Combination",
495 " 3 = Brute-force",
496 " 6 = Hybrid dict + mask",
497 " 7 = Hybrid mask + dict",
498 "",
499 "* Hash types:",
500 "",
501 "[[ Roll-your-own: Raw Hashes ]]",
502 "",
503 " 900 = MD4",
504 " 0 = MD5",
505 " 5100 = Half MD5",
506 " 100 = SHA1",
507 " 10800 = SHA-384",
508 " 1400 = SHA-256",
509 " 1700 = SHA-512",
510 " 5000 = SHA-3(Keccak)",
511 " 10100 = SipHash",
512 " 6000 = RipeMD160",
513 " 6100 = Whirlpool",
514 " 6900 = GOST R 34.11-94",
515 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
516 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
517 "",
518 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
519 "",
520 " 10 = md5($pass.$salt)",
521 " 20 = md5($salt.$pass)",
522 " 30 = md5(unicode($pass).$salt)",
523 " 40 = md5($salt.unicode($pass))",
524 " 3800 = md5($salt.$pass.$salt)",
525 " 3710 = md5($salt.md5($pass))",
526 " 2600 = md5(md5($pass)",
527 " 4300 = md5(strtoupper(md5($pass)))",
528 " 4400 = md5(sha1($pass))",
529 " 110 = sha1($pass.$salt)",
530 " 120 = sha1($salt.$pass)",
531 " 130 = sha1(unicode($pass).$salt)",
532 " 140 = sha1($salt.unicode($pass))",
533 " 4500 = sha1(sha1($pass)",
534 " 4700 = sha1(md5($pass))",
535 " 4900 = sha1($salt.$pass.$salt)",
536 " 1410 = sha256($pass.$salt)",
537 " 1420 = sha256($salt.$pass)",
538 " 1430 = sha256(unicode($pass).$salt)",
539 " 1440 = sha256($salt.unicode($pass))",
540 " 1710 = sha512($pass.$salt)",
541 " 1720 = sha512($salt.$pass)",
542 " 1730 = sha512(unicode($pass).$salt)",
543 " 1740 = sha512($salt.unicode($pass))",
544 "",
545 "[[ Roll-your-own: Authenticated Hashes ]]",
546 "",
547 " 50 = HMAC-MD5 (key = $pass)",
548 " 60 = HMAC-MD5 (key = $salt)",
549 " 150 = HMAC-SHA1 (key = $pass)",
550 " 160 = HMAC-SHA1 (key = $salt)",
551 " 1450 = HMAC-SHA256 (key = $pass)",
552 " 1460 = HMAC-SHA256 (key = $salt)",
553 " 1750 = HMAC-SHA512 (key = $pass)",
554 " 1760 = HMAC-SHA512 (key = $salt)",
555 "",
556 "[[ Generic KDF ]]",
557 "",
558 " 400 = phpass",
559 " 8900 = scrypt",
560 " 11900 = PBKDF2-HMAC-MD5",
561 " 12000 = PBKDF2-HMAC-SHA1",
562 " 10900 = PBKDF2-HMAC-SHA256",
563 " 12100 = PBKDF2-HMAC-SHA512",
564 "",
565 "[[ Network protocols, Challenge-Response ]]",
566 "",
567 " 23 = Skype",
568 " 2500 = WPA/WPA2",
569 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
570 " 5300 = IKE-PSK MD5",
571 " 5400 = IKE-PSK SHA1",
572 " 5500 = NetNTLMv1",
573 " 5500 = NetNTLMv1 + ESS",
574 " 5600 = NetNTLMv2",
575 " 7300 = IPMI2 RAKP HMAC-SHA1",
576 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
577 " 8300 = DNSSEC (NSEC3)",
578 " 10200 = Cram MD5",
579 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
580 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
581 " 11400 = SIP digest authentication (MD5)",
582 " 13100 = Kerberos 5 TGS-REP etype 23",
583 "",
584 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
585 "",
586 " 121 = SMF (Simple Machines Forum)",
587 " 400 = phpBB3",
588 " 2611 = vBulletin < v3.8.5",
589 " 2711 = vBulletin > v3.8.5",
590 " 2811 = MyBB",
591 " 2811 = IPB (Invison Power Board)",
592 " 8400 = WBB3 (Woltlab Burning Board)",
593 " 11 = Joomla < 2.5.18",
594 " 400 = Joomla > 2.5.18",
595 " 400 = Wordpress",
596 " 2612 = PHPS",
597 " 7900 = Drupal7",
598 " 21 = osCommerce",
599 " 21 = xt:Commerce",
600 " 11000 = PrestaShop",
601 " 124 = Django (SHA-1)",
602 " 10000 = Django (PBKDF2-SHA256)",
603 " 3711 = Mediawiki B type",
604 " 7600 = Redmine",
605 "",
606 "[[ Database Server ]]",
607 "",
608 " 12 = PostgreSQL",
609 " 131 = MSSQL(2000)",
610 " 132 = MSSQL(2005)",
611 " 1731 = MSSQL(2012)",
612 " 1731 = MSSQL(2014)",
613 " 200 = MySQL323",
614 " 300 = MySQL4.1/MySQL5",
615 " 3100 = Oracle H: Type (Oracle 7+)",
616 " 112 = Oracle S: Type (Oracle 11+)",
617 " 12300 = Oracle T: Type (Oracle 12+)",
618 " 8000 = Sybase ASE",
619 "",
620 "[[ HTTP, SMTP, LDAP Server ]]",
621 "",
622 " 141 = EPiServer 6.x < v4",
623 " 1441 = EPiServer 6.x > v4",
624 " 1600 = Apache $apr1$",
625 " 12600 = ColdFusion 10+",
626 " 1421 = hMailServer",
627 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
628 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
629 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
630 "",
631 "[[ Checksums ]]",
632 "",
633 " 11500 = CRC32",
634 "",
635 "[[ Operating-Systems ]]",
636 "",
637 " 3000 = LM",
638 " 1000 = NTLM",
639 " 1100 = Domain Cached Credentials (DCC), MS Cache",
640 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
641 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
642 " 1500 = descrypt, DES(Unix), Traditional DES",
643 " 12400 = BSDiCrypt, Extended DES",
644 " 500 = md5crypt $1$, MD5(Unix)",
645 " 3200 = bcrypt $2*$, Blowfish(Unix)",
646 " 7400 = sha256crypt $5$, SHA256(Unix)",
647 " 1800 = sha512crypt $6$, SHA512(Unix)",
648 " 122 = OSX v10.4",
649 " 122 = OSX v10.5",
650 " 122 = OSX v10.6",
651 " 1722 = OSX v10.7",
652 " 7100 = OSX v10.8",
653 " 7100 = OSX v10.9",
654 " 7100 = OSX v10.10",
655 " 6300 = AIX {smd5}",
656 " 6700 = AIX {ssha1}",
657 " 6400 = AIX {ssha256}",
658 " 6500 = AIX {ssha512}",
659 " 2400 = Cisco-PIX",
660 " 2410 = Cisco-ASA",
661 " 500 = Cisco-IOS $1$",
662 " 5700 = Cisco-IOS $4$",
663 " 9200 = Cisco-IOS $8$",
664 " 9300 = Cisco-IOS $9$",
665 " 22 = Juniper Netscreen/SSG (ScreenOS)",
666 " 501 = Juniper IVE",
667 " 5800 = Android PIN",
668 " 8100 = Citrix Netscaler",
669 " 8500 = RACF",
670 " 7200 = GRUB 2",
671 " 9900 = Radmin2",
672 "",
673 "[[ Enterprise Application Software (EAS) ]]",
674 "",
675 " 7700 = SAP CODVN B (BCODE)",
676 " 7800 = SAP CODVN F/G (PASSCODE)",
677 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
678 " 8600 = Lotus Notes/Domino 5",
679 " 8700 = Lotus Notes/Domino 6",
680 " 9100 = Lotus Notes/Domino 8",
681 " 133 = PeopleSoft",
682 "",
683 "[[ Archives ]]",
684 "",
685 " 11600 = 7-Zip",
686 " 12500 = RAR3-hp",
687 " 13000 = RAR5",
688 "",
689 "[[ Full-Disk encryptions (FDE) ]]",
690 "",
691 " 62XY = TrueCrypt 5.0+",
692 " X = 1 = PBKDF2-HMAC-RipeMD160",
693 " X = 2 = PBKDF2-HMAC-SHA512",
694 " X = 3 = PBKDF2-HMAC-Whirlpool",
695 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
696 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
697 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
698 " Y = 3 = XTS 1536 bit (Ciphers: All)",
699 " 8800 = Android FDE < v4.3",
700 " 12900 = Android FDE (Samsung DEK)",
701 " 12200 = eCryptfs",
702 "",
703 "[[ Documents ]]",
704 "",
705 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
706 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
707 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
708 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
709 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
710 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
711 " 9400 = MS Office 2007",
712 " 9500 = MS Office 2010",
713 " 9600 = MS Office 2013",
714 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
715 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
716 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
717 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
718 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
719 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
720 "",
721 "[[ Password Managers ]]",
722 "",
723 " 9000 = Password Safe v2",
724 " 5200 = Password Safe v3",
725 " 6800 = Lastpass",
726 " 6600 = 1Password, agilekeychain",
727 " 8200 = 1Password, cloudkeychain",
728 " 11300 = Bitcoin/Litecoin wallet.dat",
729 " 12700 = Blockchain, My Wallet",
730 "",
731 NULL
732 };
733
734 /**
735 * oclHashcat specific functions
736 */
737
738 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
739 {
740 int exec_pos = (int) device_param->exec_pos - last_num_entries;
741
742 if (exec_pos < 0) exec_pos += EXEC_CACHE;
743
744 double exec_ms_sum = 0;
745
746 int exec_ms_cnt = 0;
747
748 for (int i = 0; i < last_num_entries; i++)
749 {
750 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
751
752 if (exec_ms)
753 {
754 exec_ms_sum += exec_ms;
755
756 exec_ms_cnt++;
757 }
758 }
759
760 if (exec_ms_cnt == 0) return 0;
761
762 return exec_ms_sum / exec_ms_cnt;
763 }
764
765 void status_display_automat ()
766 {
767 FILE *out = stdout;
768
769 fprintf (out, "STATUS\t%u\t", data.devices_status);
770
771 /**
772 * speed new
773 */
774
775 fprintf (out, "SPEED\t");
776
777 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
778 {
779 hc_device_param_t *device_param = &data.devices_param[device_id];
780
781 if (device_param->skipped) continue;
782
783 u64 speed_cnt = 0;
784 float speed_ms = 0;
785
786 for (int i = 0; i < SPEED_CACHE; i++)
787 {
788 float rec_ms;
789
790 hc_timer_get (device_param->speed_rec[i], rec_ms);
791
792 if (rec_ms > SPEED_MAXAGE) continue;
793
794 speed_cnt += device_param->speed_cnt[i];
795 speed_ms += device_param->speed_ms[i];
796 }
797
798 speed_cnt /= SPEED_CACHE;
799 speed_ms /= SPEED_CACHE;
800
801 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
802 }
803
804 /**
805 * exec time
806 */
807
808 fprintf (out, "EXEC_RUNTIME\t");
809
810 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
811 {
812 hc_device_param_t *device_param = &data.devices_param[device_id];
813
814 if (device_param->skipped) continue;
815
816 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
817
818 fprintf (out, "%f\t", exec_ms_avg);
819 }
820
821 /**
822 * words_cur
823 */
824
825 u64 words_cur = get_lowest_words_done ();
826
827 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
828
829 /**
830 * counter
831 */
832
833 uint salts_left = data.salts_cnt - data.salts_done;
834
835 if (salts_left == 0) salts_left = 1;
836
837 u64 progress_total = data.words_cnt * salts_left;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 if (salts_left > 1)
846 {
847 // otherwise the final cracked status shows 0/XXX progress
848
849 if (data.salts_shown[salt_pos] == 1) continue;
850 }
851
852 all_done += data.words_progress_done[salt_pos];
853 all_rejected += data.words_progress_rejected[salt_pos];
854 all_restored += data.words_progress_restored[salt_pos];
855 }
856
857 u64 progress_cur = all_restored + all_done + all_rejected;
858 u64 progress_end = progress_total;
859
860 u64 progress_skip = 0;
861
862 if (data.skip)
863 {
864 progress_skip = MIN (data.skip, data.words_base) * salts_left;
865
866 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
867 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
868 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
869 }
870
871 if (data.limit)
872 {
873 progress_end = MIN (data.limit, data.words_base) * salts_left;
874
875 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
876 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
877 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
878 }
879
880 u64 progress_cur_relative_skip = progress_cur - progress_skip;
881 u64 progress_end_relative_skip = progress_end - progress_skip;
882
883 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
884
885 /**
886 * cracks
887 */
888
889 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
890 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
891
892 /**
893 * temperature
894 */
895
896 #ifdef HAVE_HWMON
897 if (data.gpu_temp_disable == 0)
898 {
899 fprintf (out, "TEMP\t");
900
901 hc_thread_mutex_lock (mux_adl);
902
903 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
904 {
905 hc_device_param_t *device_param = &data.devices_param[device_id];
906
907 if (device_param->skipped) continue;
908
909 int temp = hm_get_temperature_with_device_id (device_id);
910
911 fprintf (out, "%d\t", temp);
912 }
913
914 hc_thread_mutex_unlock (mux_adl);
915 }
916 #endif // HAVE_HWMON
917
918 /**
919 * flush
920 */
921
922 #ifdef _WIN
923 fputc ('\r', out);
924 fputc ('\n', out);
925 #endif
926
927 #ifdef _POSIX
928 fputc ('\n', out);
929 #endif
930
931 fflush (out);
932 }
933
934 void status_display ()
935 {
936 if (data.devices_status == STATUS_INIT) return;
937 if (data.devices_status == STATUS_STARTING) return;
938 if (data.devices_status == STATUS_BYPASS) return;
939
940 if (data.status_automat == 1)
941 {
942 status_display_automat ();
943
944 return;
945 }
946
947 char tmp_buf[1000] = { 0 };
948
949 uint tmp_len = 0;
950
951 log_info ("Session.Name...: %s", data.session);
952
953 char *status_type = strstatus (data.devices_status);
954
955 uint hash_mode = data.hash_mode;
956
957 char *hash_type = strhashtype (hash_mode); // not a bug
958
959 log_info ("Status.........: %s", status_type);
960
961 /**
962 * show rules
963 */
964
965 if (data.rp_files_cnt)
966 {
967 uint i;
968
969 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
970 {
971 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
972 }
973
974 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
975
976 log_info ("Rules.Type.....: %s", tmp_buf);
977
978 tmp_len = 0;
979 }
980
981 if (data.rp_gen)
982 {
983 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
984
985 if (data.rp_gen_seed)
986 {
987 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
988 }
989 }
990
991 /**
992 * show input
993 */
994
995 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
996 {
997 if (data.wordlist_mode == WL_MODE_FILE)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
1000 }
1001 else if (data.wordlist_mode == WL_MODE_STDIN)
1002 {
1003 log_info ("Input.Mode.....: Pipe");
1004 }
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_COMBI)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_BF)
1012 {
1013 char *mask = data.mask;
1014
1015 if (mask != NULL)
1016 {
1017 uint mask_len = data.css_cnt;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1020
1021 if (mask_len > 0)
1022 {
1023 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1024 {
1025 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1026 {
1027 mask_len -= data.salts_buf[0].salt_len;
1028 }
1029 }
1030
1031 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1034 }
1035
1036 if (data.maskcnt > 1)
1037 {
1038 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1039
1040 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1041 }
1042
1043 log_info ("Input.Mode.....: %s", tmp_buf);
1044 }
1045
1046 tmp_len = 0;
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1049 {
1050 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1051 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1052 }
1053 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1054 {
1055 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1056 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1057 }
1058
1059 if (data.digests_cnt == 1)
1060 {
1061 if (data.hash_mode == 2500)
1062 {
1063 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1064
1065 uint pke[25] = { 0 };
1066
1067 char *pke_ptr = (char *) pke;
1068
1069 for (uint i = 0; i < 25; i++)
1070 {
1071 pke[i] = byte_swap_32 (wpa->pke[i]);
1072 }
1073
1074 char mac1[6] = { 0 };
1075 char mac2[6] = { 0 };
1076
1077 memcpy (mac1, pke_ptr + 23, 6);
1078 memcpy (mac2, pke_ptr + 29, 6);
1079
1080 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1081 (char *) data.salts_buf[0].salt_buf,
1082 mac1[0] & 0xff,
1083 mac1[1] & 0xff,
1084 mac1[2] & 0xff,
1085 mac1[3] & 0xff,
1086 mac1[4] & 0xff,
1087 mac1[5] & 0xff,
1088 mac2[0] & 0xff,
1089 mac2[1] & 0xff,
1090 mac2[2] & 0xff,
1091 mac2[3] & 0xff,
1092 mac2[4] & 0xff,
1093 mac2[5] & 0xff);
1094 }
1095 else if (data.hash_mode == 5200)
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 else if (data.hash_mode == 9000)
1100 {
1101 log_info ("Hash.Target....: File (%s)", data.hashfile);
1102 }
1103 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 else
1108 {
1109 char out_buf[4096] = { 0 };
1110
1111 ascii_digest (out_buf, 0, 0);
1112
1113 // limit length
1114 if (strlen (out_buf) > 40)
1115 {
1116 out_buf[41] = '.';
1117 out_buf[42] = '.';
1118 out_buf[43] = '.';
1119 out_buf[44] = 0;
1120 }
1121
1122 log_info ("Hash.Target....: %s", out_buf);
1123 }
1124 }
1125 else
1126 {
1127 if (data.hash_mode == 3000)
1128 {
1129 char out_buf1[4096] = { 0 };
1130 char out_buf2[4096] = { 0 };
1131
1132 ascii_digest (out_buf1, 0, 0);
1133 ascii_digest (out_buf2, 0, 1);
1134
1135 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1136 }
1137 else
1138 {
1139 log_info ("Hash.Target....: File (%s)", data.hashfile);
1140 }
1141 }
1142
1143 log_info ("Hash.Type......: %s", hash_type);
1144
1145 /**
1146 * speed new
1147 */
1148
1149 u64 speed_cnt[DEVICES_MAX] = { 0 };
1150 float speed_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 // we need to clear values (set to 0) because in case the device does
1159 // not get new candidates it idles around but speed display would
1160 // show it as working.
1161 // if we instantly set it to 0 after reading it happens that the
1162 // speed can be shown as zero if the users refreshes too fast.
1163 // therefore, we add a timestamp when a stat was recorded and if its
1164 // too old we will not use it
1165
1166 speed_cnt[device_id] = 0;
1167 speed_ms[device_id] = 0;
1168
1169 for (int i = 0; i < SPEED_CACHE; i++)
1170 {
1171 float rec_ms;
1172
1173 hc_timer_get (device_param->speed_rec[i], rec_ms);
1174
1175 if (rec_ms > SPEED_MAXAGE) continue;
1176
1177 speed_cnt[device_id] += device_param->speed_cnt[i];
1178 speed_ms[device_id] += device_param->speed_ms[i];
1179 }
1180
1181 speed_cnt[device_id] /= SPEED_CACHE;
1182 speed_ms[device_id] /= SPEED_CACHE;
1183 }
1184
1185 float hashes_all_ms = 0;
1186
1187 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1188
1189 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1190 {
1191 hc_device_param_t *device_param = &data.devices_param[device_id];
1192
1193 if (device_param->skipped) continue;
1194
1195 hashes_dev_ms[device_id] = 0;
1196
1197 if (speed_ms[device_id])
1198 {
1199 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1200
1201 hashes_all_ms += hashes_dev_ms[device_id];
1202 }
1203 }
1204
1205 /**
1206 * exec time
1207 */
1208
1209 double exec_all_ms[DEVICES_MAX] = { 0 };
1210
1211 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1212 {
1213 hc_device_param_t *device_param = &data.devices_param[device_id];
1214
1215 if (device_param->skipped) continue;
1216
1217 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1218
1219 exec_all_ms[device_id] = exec_ms_avg;
1220 }
1221
1222 /**
1223 * timers
1224 */
1225
1226 float ms_running = 0;
1227
1228 hc_timer_get (data.timer_running, ms_running);
1229
1230 float ms_paused = data.ms_paused;
1231
1232 if (data.devices_status == STATUS_PAUSED)
1233 {
1234 float ms_paused_tmp = 0;
1235
1236 hc_timer_get (data.timer_paused, ms_paused_tmp);
1237
1238 ms_paused += ms_paused_tmp;
1239 }
1240
1241 #ifdef WIN
1242
1243 __time64_t sec_run = ms_running / 1000;
1244
1245 #else
1246
1247 time_t sec_run = ms_running / 1000;
1248
1249 #endif
1250
1251 if (sec_run)
1252 {
1253 char display_run[32] = { 0 };
1254
1255 struct tm tm_run;
1256
1257 struct tm *tmp = NULL;
1258
1259 #ifdef WIN
1260
1261 tmp = _gmtime64 (&sec_run);
1262
1263 #else
1264
1265 tmp = gmtime (&sec_run);
1266
1267 #endif
1268
1269 if (tmp != NULL)
1270 {
1271 memset (&tm_run, 0, sizeof (tm_run));
1272
1273 memcpy (&tm_run, tmp, sizeof (tm_run));
1274
1275 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1276
1277 char *start = ctime (&data.proc_start);
1278
1279 size_t start_len = strlen (start);
1280
1281 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1282 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1283
1284 log_info ("Time.Started...: %s (%s)", start, display_run);
1285 }
1286 }
1287 else
1288 {
1289 log_info ("Time.Started...: 0 secs");
1290 }
1291
1292 /**
1293 * counters
1294 */
1295
1296 uint salts_left = data.salts_cnt - data.salts_done;
1297
1298 if (salts_left == 0) salts_left = 1;
1299
1300 u64 progress_total = data.words_cnt * salts_left;
1301
1302 u64 all_done = 0;
1303 u64 all_rejected = 0;
1304 u64 all_restored = 0;
1305
1306 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1307 {
1308 if (salts_left > 1)
1309 {
1310 // otherwise the final cracked status shows 0/XXX progress
1311
1312 if (data.salts_shown[salt_pos] == 1) continue;
1313 }
1314
1315 all_done += data.words_progress_done[salt_pos];
1316 all_rejected += data.words_progress_rejected[salt_pos];
1317 all_restored += data.words_progress_restored[salt_pos];
1318 }
1319
1320 u64 progress_cur = all_restored + all_done + all_rejected;
1321 u64 progress_end = progress_total;
1322
1323 u64 progress_skip = 0;
1324
1325 if (data.skip)
1326 {
1327 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1328
1329 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1330 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1332 }
1333
1334 if (data.limit)
1335 {
1336 progress_end = MIN (data.limit, data.words_base) * salts_left;
1337
1338 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1339 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1340 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1341 }
1342
1343 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1344 u64 progress_end_relative_skip = progress_end - progress_skip;
1345
1346 float speed_ms_real = ms_running - ms_paused;
1347 u64 speed_plains_real = all_done;
1348
1349 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1350 {
1351 if (data.devices_status != STATUS_CRACKED)
1352 {
1353 u64 words_per_ms = 0;
1354
1355 if (speed_plains_real && speed_ms_real)
1356 {
1357 words_per_ms = speed_plains_real / speed_ms_real;
1358 }
1359
1360 #ifdef WIN
1361 __time64_t sec_etc = 0;
1362 #else
1363 time_t sec_etc = 0;
1364 #endif
1365
1366 if (words_per_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 / words_per_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 cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1488 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1489 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1490
1491 if ((data.cpt_start + 86400) < now)
1492 {
1493 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1494 cpt_cur_min,
1495 cpt_cur_hour,
1496 cpt_cur_day,
1497 cpt_avg_min,
1498 cpt_avg_hour,
1499 cpt_avg_day);
1500 }
1501 else if ((data.cpt_start + 3600) < now)
1502 {
1503 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1504 cpt_cur_min,
1505 cpt_cur_hour,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else if ((data.cpt_start + 60) < now)
1511 {
1512 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_cur_min,
1514 cpt_avg_min,
1515 cpt_avg_hour,
1516 cpt_avg_day);
1517 }
1518 else
1519 {
1520 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1521 cpt_avg_min,
1522 cpt_avg_hour,
1523 cpt_avg_day);
1524 }
1525 }
1526
1527 // Restore point
1528
1529 u64 restore_point = get_lowest_words_done ();
1530
1531 u64 restore_total = data.words_base;
1532
1533 float percent_restore = 0;
1534
1535 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1536
1537 if (progress_end_relative_skip)
1538 {
1539 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1540 {
1541 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1542 float percent_rejected = 0.0;
1543
1544 if (progress_cur)
1545 {
1546 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1547 }
1548
1549 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);
1550 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1551
1552 if (data.restore_disable == 0)
1553 {
1554 if (percent_finished != 1)
1555 {
1556 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1557 }
1558 }
1559 }
1560 }
1561 else
1562 {
1563 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1564 {
1565 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1567
1568 if (data.restore_disable == 0)
1569 {
1570 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1571 }
1572 }
1573 else
1574 {
1575 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1576 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1577
1578 // --restore not allowed if stdin is used -- really? why?
1579
1580 //if (data.restore_disable == 0)
1581 //{
1582 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1583 //}
1584 }
1585 }
1586
1587 #ifdef HAVE_HWMON
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 #define HM_STR_BUF_SIZE 255
1599
1600 if (data.hm_device[device_id].fan_supported == 1)
1601 {
1602 char utilization[HM_STR_BUF_SIZE] = { 0 };
1603 char temperature[HM_STR_BUF_SIZE] = { 0 };
1604 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1605
1606 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1607 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1608
1609 if (device_param->vendor_id == VENDOR_ID_AMD)
1610 {
1611 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1612 }
1613 else if (device_param->vendor_id == VENDOR_ID_NV)
1614 {
1615 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1616 }
1617
1618 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1619 }
1620 else
1621 {
1622 char utilization[HM_STR_BUF_SIZE] = { 0 };
1623 char temperature[HM_STR_BUF_SIZE] = { 0 };
1624
1625 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1626 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1627
1628 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1629 }
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634 #endif // HAVE_HWMON
1635 }
1636
1637 static void status_benchmark ()
1638 {
1639 if (data.devices_status == STATUS_INIT) return;
1640 if (data.devices_status == STATUS_STARTING) return;
1641
1642 if (data.words_cnt == 0) return;
1643
1644 u64 speed_cnt[DEVICES_MAX] = { 0 };
1645 float speed_ms[DEVICES_MAX] = { 0 };
1646
1647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1648 {
1649 hc_device_param_t *device_param = &data.devices_param[device_id];
1650
1651 if (device_param->skipped) continue;
1652
1653 speed_cnt[device_id] = 0;
1654 speed_ms[device_id] = 0;
1655
1656 for (int i = 0; i < SPEED_CACHE; i++)
1657 {
1658 speed_cnt[device_id] += device_param->speed_cnt[i];
1659 speed_ms[device_id] += device_param->speed_ms[i];
1660 }
1661
1662 speed_cnt[device_id] /= SPEED_CACHE;
1663 speed_ms[device_id] /= SPEED_CACHE;
1664 }
1665
1666 float hashes_all_ms = 0;
1667
1668 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1669
1670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1671 {
1672 hc_device_param_t *device_param = &data.devices_param[device_id];
1673
1674 if (device_param->skipped) continue;
1675
1676 hashes_dev_ms[device_id] = 0;
1677
1678 if (speed_ms[device_id])
1679 {
1680 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1681
1682 hashes_all_ms += hashes_dev_ms[device_id];
1683 }
1684 }
1685
1686 /**
1687 * exec time
1688 */
1689
1690 double exec_all_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1699
1700 exec_all_ms[device_id] = exec_ms_avg;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 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)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 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)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 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);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 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);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.h.hi1[0][j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.h.hi1[0][j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.h.hi1[0][j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.h.hi1[0][j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 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);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 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);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 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);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 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);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2377 {
2378 // function called only in case kernel_power_all > words_left
2379
2380 float kernel_power_div = (float) (total_left) / kernel_power_all;
2381
2382 kernel_power_div += kernel_power_div / 100;
2383
2384 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2385
2386 while (kernel_power_new < total_left)
2387 {
2388 kernel_power_div += kernel_power_div / 100;
2389
2390 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2409
2410 return kernel_power_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 hc_timer_t timer;
2448
2449 hc_timer_set (&timer);
2450
2451 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2452 {
2453 const size_t global_work_size[3] = { num_elements, 32, 1 };
2454 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2455
2456 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2457 }
2458 else
2459 {
2460 size_t workgroup_size = 0;
2461
2462 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2463
2464 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2465
2466 const size_t global_work_size[3] = { num_elements, 1, 1 };
2467 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2470 }
2471
2472 hc_clFlush (data.ocl, device_param->command_queue);
2473
2474 hc_clFinish (data.ocl, device_param->command_queue);
2475
2476 if (event_update)
2477 {
2478 float exec_time;
2479
2480 hc_timer_get (timer, exec_time);
2481
2482 uint exec_pos = device_param->exec_pos;
2483
2484 device_param->exec_ms[exec_pos] = exec_time;
2485
2486 exec_pos++;
2487
2488 if (exec_pos == EXEC_CACHE)
2489 {
2490 exec_pos = 0;
2491 }
2492
2493 device_param->exec_pos = exec_pos;
2494 }
2495 }
2496
2497 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2498 {
2499 uint num_elements = num;
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2504 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2505 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2506 }
2507
2508 // causes problems with special threads like in bcrypt
2509 // const uint kernel_threads = device_param->kernel_threads;
2510
2511 uint kernel_threads = KERNEL_THREADS;
2512
2513 while (num_elements % kernel_threads) num_elements++;
2514
2515 cl_kernel kernel = NULL;
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2520 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2521 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2522 }
2523
2524 switch (kern_run)
2525 {
2526 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2532 break;
2533 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2539 break;
2540 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2541 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2542 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2543 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2544 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2545 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2546 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2547 break;
2548 }
2549
2550 size_t workgroup_size = 0;
2551 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof(size_t), &workgroup_size, NULL);
2552 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2553
2554 const size_t global_work_size[3] = { num_elements, 1, 1 };
2555 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2558
2559 hc_clFlush (data.ocl, device_param->command_queue);
2560
2561 hc_clFinish (data.ocl, device_param->command_queue);
2562 }
2563
2564 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2565 {
2566 uint num_elements = num;
2567
2568 uint kernel_threads = device_param->kernel_threads;
2569
2570 while (num_elements % kernel_threads) num_elements++;
2571
2572 cl_kernel kernel = device_param->kernel_tb;
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_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 size_t workgroup_size = 0;
2597 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2598 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2611 {
2612 uint num_elements = num;
2613
2614 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2615 device_param->kernel_params_amp_buf32[6] = num_elements;
2616
2617 // causes problems with special threads like in bcrypt
2618 // const uint kernel_threads = device_param->kernel_threads;
2619
2620 uint kernel_threads = KERNEL_THREADS;
2621
2622 while (num_elements % kernel_threads) num_elements++;
2623
2624 cl_kernel kernel = device_param->kernel_amp;
2625
2626 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2627 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2628
2629 size_t workgroup_size = 0;
2630 hc_clGetKernelWorkGroupInfo (data.ocl, kernel, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &workgroup_size, NULL);
2631 if (kernel_threads > workgroup_size) kernel_threads = workgroup_size;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2637
2638 hc_clFlush (data.ocl, device_param->command_queue);
2639
2640 hc_clFinish (data.ocl, device_param->command_queue);
2641 }
2642
2643 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2644 {
2645 int rc = -1;
2646
2647 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2648 {
2649 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2650
2651 const cl_uchar zero = 0;
2652
2653 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2654 }
2655
2656 if (rc != 0)
2657 {
2658 // NOTE: clEnqueueFillBuffer () always fails with -59
2659 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2660 // How's that possible, OpenCL 1.2 support is advertised??
2661 // We need to workaround...
2662
2663 #define FILLSZ 0x100000
2664
2665 char *tmp = (char *) mymalloc (FILLSZ);
2666
2667 for (uint i = 0; i < size; i += FILLSZ)
2668 {
2669 const int left = size - i;
2670
2671 const int fillsz = MIN (FILLSZ, left);
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2674 }
2675
2676 myfree (tmp);
2677 }
2678 }
2679
2680 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)
2681 {
2682 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2683 {
2684 if (attack_mode == ATTACK_MODE_BF)
2685 {
2686 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2687 {
2688 const uint size_tm = 32 * sizeof (bs_word_t);
2689
2690 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2691
2692 run_kernel_tm (device_param);
2693
2694 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);
2695 }
2696 }
2697
2698 if (highest_pw_len < 16)
2699 {
2700 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2701 }
2702 else if (highest_pw_len < 32)
2703 {
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705 }
2706 else
2707 {
2708 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2709 }
2710 }
2711 else
2712 {
2713 run_kernel_amp (device_param, pws_cnt);
2714
2715 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2716
2717 if (opts_type & OPTS_TYPE_HOOK12)
2718 {
2719 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2720 }
2721
2722 uint iter = salt_buf->salt_iter;
2723
2724 uint loop_step = device_param->kernel_loops;
2725
2726 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2727 {
2728 uint loop_left = iter - loop_pos;
2729
2730 loop_left = MIN (loop_left, loop_step);
2731
2732 device_param->kernel_params_buf32[25] = loop_pos;
2733 device_param->kernel_params_buf32[26] = loop_left;
2734
2735 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2736
2737 if (data.devices_status == STATUS_CRACKED) break;
2738 if (data.devices_status == STATUS_ABORTED) break;
2739 if (data.devices_status == STATUS_QUIT) break;
2740 }
2741
2742 if (opts_type & OPTS_TYPE_HOOK23)
2743 {
2744 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2745
2746 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);
2747
2748 // do something with data
2749
2750 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);
2751 }
2752
2753 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2754 }
2755 }
2756
2757 static int run_rule_engine (const int rule_len, const char *rule_buf)
2758 {
2759 if (rule_len == 0)
2760 {
2761 return 0;
2762 }
2763 else if (rule_len == 1)
2764 {
2765 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2766 }
2767
2768 return 1;
2769 }
2770
2771 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2772 {
2773 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2774 {
2775 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);
2776 }
2777 else if (data.attack_kern == ATTACK_KERN_COMBI)
2778 {
2779 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2780 }
2781 else if (data.attack_kern == ATTACK_KERN_BF)
2782 {
2783 const u64 off = device_param->words_off;
2784
2785 device_param->kernel_params_mp_l_buf64[3] = off;
2786
2787 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2788 }
2789 }
2790
2791 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2792 {
2793 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2794
2795 device_param->kernel_params_buf32[26] = kernel_loops;
2796 device_param->kernel_params_buf32[27] = kernel_loops;
2797
2798 // init some fake words
2799
2800 if (data.attack_kern == ATTACK_KERN_BF)
2801 {
2802 run_kernel_mp (KERN_RUN_MP_L, device_param, kernel_power);
2803 run_kernel_mp (KERN_RUN_MP_R, device_param, kernel_loops);
2804 }
2805 else
2806 {
2807 for (u32 i = 0; i < kernel_power; i++)
2808 {
2809 device_param->pws_buf[i].pw_len = i & 7;
2810 }
2811
2812 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);
2813
2814 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2815 {
2816 run_kernel_amp (device_param, kernel_power);
2817 }
2818 }
2819
2820 // caching run
2821
2822 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2823 {
2824 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2825 }
2826 else
2827 {
2828 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2829 }
2830
2831 // now user repeats
2832
2833 for (int i = 0; i < repeat; i++)
2834 {
2835 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2836 {
2837 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2838 }
2839 else
2840 {
2841 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2842 }
2843 }
2844
2845 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2846
2847 // reset fake words
2848
2849 memset (device_param->pws_buf, 0, kernel_power * sizeof (pw_t));
2850
2851 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);
2852 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);
2853
2854 return exec_ms_prev;
2855 }
2856
2857 static void autotune (hc_device_param_t *device_param)
2858 {
2859 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2860
2861 const u32 kernel_accel_min = device_param->kernel_accel_min;
2862 const u32 kernel_accel_max = device_param->kernel_accel_max;
2863
2864 const u32 kernel_loops_min = device_param->kernel_loops_min;
2865 const u32 kernel_loops_max = device_param->kernel_loops_max;
2866
2867 u32 kernel_accel = kernel_accel_min;
2868 u32 kernel_loops = kernel_loops_min;
2869
2870 // steps
2871
2872 #define STEPS_CNT 10
2873
2874 #define STEPS_ACCEL_CNT (STEPS_CNT + 2)
2875 #define STEPS_LOOPS_CNT (STEPS_CNT + 2)
2876
2877 u32 steps_accel[STEPS_ACCEL_CNT];
2878 u32 steps_loops[STEPS_LOOPS_CNT];
2879
2880 for (int i = 1; i < STEPS_ACCEL_CNT; i++)
2881 {
2882 steps_accel[i] = 1 << i;
2883 }
2884
2885 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2886 {
2887 steps_loops[i] = 1 << i;
2888 }
2889
2890 steps_accel[STEPS_CNT + 0] = kernel_accel_min;
2891 steps_accel[STEPS_CNT + 1] = kernel_accel_max;
2892
2893 steps_loops[STEPS_CNT + 0] = kernel_loops_min;
2894 steps_loops[STEPS_CNT + 1] = kernel_loops_max;
2895
2896 qsort (steps_accel, STEPS_ACCEL_CNT, sizeof (u32), sort_by_u32);
2897 qsort (steps_loops, STEPS_LOOPS_CNT, sizeof (u32), sort_by_u32);
2898
2899 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2900
2901 u32 kernel_loops_tmp;
2902
2903 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2904 {
2905 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2906
2907 if (exec_ms < target_ms) break;
2908
2909 if (kernel_loops_tmp == kernel_loops_min) break;
2910 }
2911
2912 // kernel-accel
2913
2914 double e_best = 0;
2915
2916 for (int i = 0; i < STEPS_ACCEL_CNT; i++)
2917 {
2918 const u32 kernel_accel_try = steps_accel[i];
2919
2920 if (kernel_accel_try < kernel_accel_min) continue;
2921 if (kernel_accel_try > kernel_accel_max) break;
2922
2923 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2924
2925 if (exec_ms > target_ms) break;
2926
2927 const double e = kernel_accel_try / exec_ms;
2928
2929 if (e > e_best)
2930 {
2931 kernel_accel = kernel_accel_try;
2932
2933 e_best = e;
2934 }
2935 }
2936
2937 // kernel-loops final
2938
2939 e_best = 0;
2940
2941 for (int i = 0; i < STEPS_LOOPS_CNT; i++)
2942 {
2943 const u32 kernel_loops_try = steps_loops[i];
2944
2945 if (kernel_loops_try < kernel_loops_min) continue;
2946 if (kernel_loops_try > kernel_loops_max) break;
2947
2948 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2949
2950 if (exec_ms > target_ms) break;
2951
2952 const double e = kernel_loops_try / exec_ms;
2953
2954 if (e > e_best)
2955 {
2956 kernel_loops = kernel_loops_try;
2957
2958 e_best = e;
2959 }
2960 }
2961
2962 // final balance
2963
2964 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops, 1);
2965
2966 u32 kernel_accel_best = kernel_accel;
2967 u32 kernel_loops_best = kernel_loops;
2968
2969 u32 exec_best = exec_ms;
2970
2971 // reset
2972
2973 u32 kernel_accel_try = kernel_accel;
2974 u32 kernel_loops_try = kernel_loops;
2975
2976 for (int i = 0; i < 2; i++)
2977 {
2978 kernel_accel_try >>= 1;
2979 kernel_loops_try <<= 1;
2980
2981 if (kernel_accel_try < kernel_accel_min) break;
2982 if (kernel_loops_try > kernel_loops_max) break;
2983
2984 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
2985
2986 if (exec_ms < exec_best)
2987 {
2988 kernel_accel_best = kernel_accel_try;
2989 kernel_loops_best = kernel_loops_try;
2990
2991 exec_best = exec_ms;
2992 }
2993 }
2994
2995 // reset
2996
2997 kernel_accel_try = kernel_accel;
2998 kernel_loops_try = kernel_loops;
2999
3000 for (int i = 0; i < 2; i++)
3001 {
3002 kernel_accel_try <<= 1;
3003 kernel_loops_try >>= 1;
3004
3005 if (kernel_accel_try > kernel_accel_max) break;
3006 if (kernel_loops_try < kernel_loops_min) break;
3007
3008 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try, 1);
3009
3010 if (exec_ms < exec_best)
3011 {
3012 kernel_accel_best = kernel_accel_try;
3013 kernel_loops_best = kernel_loops_try;
3014
3015 exec_best = exec_ms;
3016 }
3017 }
3018
3019 kernel_accel = kernel_accel_best;
3020 kernel_loops = kernel_loops_best;
3021
3022 // reset timer
3023
3024 device_param->exec_pos = 0;
3025
3026 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3027
3028 // store
3029
3030 device_param->kernel_loops = kernel_loops;
3031 device_param->kernel_accel = kernel_accel;
3032
3033 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3034
3035 device_param->kernel_power = kernel_power;
3036
3037 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
3038 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
3039 log_info ("");
3040 }
3041
3042 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
3043 {
3044 // init speed timer
3045
3046 uint speed_pos = device_param->speed_pos;
3047
3048 #ifdef _POSIX
3049 if (device_param->timer_speed.tv_sec == 0)
3050 {
3051 hc_timer_set (&device_param->timer_speed);
3052 }
3053 #endif
3054
3055 #ifdef _WIN
3056 if (device_param->timer_speed.QuadPart == 0)
3057 {
3058 hc_timer_set (&device_param->timer_speed);
3059 }
3060 #endif
3061
3062 // find higest password length, this is for optimization stuff
3063
3064 uint highest_pw_len = 0;
3065
3066 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3067 {
3068 }
3069 else if (data.attack_kern == ATTACK_KERN_COMBI)
3070 {
3071 }
3072 else if (data.attack_kern == ATTACK_KERN_BF)
3073 {
3074 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3075 + device_param->kernel_params_mp_l_buf32[5];
3076 }
3077
3078 // bitslice optimization stuff
3079
3080 if (data.attack_mode == ATTACK_MODE_BF)
3081 {
3082 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3083 {
3084 run_kernel_tb (device_param, pws_cnt);
3085 }
3086 }
3087
3088 // iteration type
3089
3090 uint innerloop_step = 0;
3091 uint innerloop_cnt = 0;
3092
3093 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3094 else innerloop_step = 1;
3095
3096 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3097 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3098 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3099
3100 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3101
3102 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3103 {
3104 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3105
3106 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3107
3108 if (data.devices_status == STATUS_CRACKED) break;
3109 if (data.devices_status == STATUS_ABORTED) break;
3110 if (data.devices_status == STATUS_QUIT) break;
3111 if (data.devices_status == STATUS_BYPASS) break;
3112
3113 if (data.salts_shown[salt_pos] == 1) continue;
3114
3115 salt_t *salt_buf = &data.salts_buf[salt_pos];
3116
3117 device_param->kernel_params_buf32[24] = salt_pos;
3118 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3119 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3120
3121 FILE *combs_fp = device_param->combs_fp;
3122
3123 if (data.attack_mode == ATTACK_MODE_COMBI)
3124 {
3125 rewind (combs_fp);
3126 }
3127
3128 // innerloops
3129
3130 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3131 {
3132 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3133
3134 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3135
3136 if (data.devices_status == STATUS_CRACKED) break;
3137 if (data.devices_status == STATUS_ABORTED) break;
3138 if (data.devices_status == STATUS_QUIT) break;
3139 if (data.devices_status == STATUS_BYPASS) break;
3140
3141 uint innerloop_left = innerloop_cnt - innerloop_pos;
3142
3143 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3144
3145 device_param->innerloop_pos = innerloop_pos;
3146 device_param->innerloop_left = innerloop_left;
3147
3148 device_param->kernel_params_buf32[27] = innerloop_left;
3149
3150 // i think we can get rid of this
3151 if (innerloop_left == 0)
3152 {
3153 puts ("bug, how should this happen????\n");
3154
3155 continue;
3156 }
3157
3158 // initialize amplifiers
3159
3160 if (data.attack_mode == ATTACK_MODE_COMBI)
3161 {
3162 char line_buf[BUFSIZ] = { 0 };
3163
3164 uint i = 0;
3165
3166 while (i < innerloop_left)
3167 {
3168 if (feof (combs_fp)) break;
3169
3170 int line_len = fgetl (combs_fp, line_buf);
3171
3172 if (line_len >= PW_MAX1) continue;
3173
3174 line_len = convert_from_hex (line_buf, line_len);
3175
3176 char *line_buf_new = line_buf;
3177
3178 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3179 {
3180 char rule_buf_out[BLOCK_SIZE] = { 0 };
3181
3182 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3183
3184 if (rule_len_out < 0)
3185 {
3186 data.words_progress_rejected[salt_pos] += pw_cnt;
3187
3188 continue;
3189 }
3190
3191 line_len = rule_len_out;
3192
3193 line_buf_new = rule_buf_out;
3194 }
3195
3196 line_len = MIN (line_len, PW_DICTMAX);
3197
3198 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3199
3200 memcpy (ptr, line_buf_new, line_len);
3201
3202 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3203
3204 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3205 {
3206 uppercase (ptr, line_len);
3207 }
3208
3209 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3210 {
3211 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3212 {
3213 ptr[line_len] = 0x80;
3214 }
3215
3216 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3217 {
3218 ptr[line_len] = 0x01;
3219 }
3220 }
3221
3222 device_param->combs_buf[i].pw_len = line_len;
3223
3224 i++;
3225 }
3226
3227 for (uint j = i; j < innerloop_left; j++)
3228 {
3229 device_param->combs_buf[j].i[0] = 0;
3230 device_param->combs_buf[j].i[1] = 0;
3231 device_param->combs_buf[j].i[2] = 0;
3232 device_param->combs_buf[j].i[3] = 0;
3233 device_param->combs_buf[j].i[4] = 0;
3234 device_param->combs_buf[j].i[5] = 0;
3235 device_param->combs_buf[j].i[6] = 0;
3236 device_param->combs_buf[j].i[7] = 0;
3237
3238 device_param->combs_buf[j].pw_len = 0;
3239 }
3240
3241 innerloop_left = i;
3242 }
3243 else if (data.attack_mode == ATTACK_MODE_BF)
3244 {
3245 u64 off = innerloop_pos;
3246
3247 device_param->kernel_params_mp_r_buf64[3] = off;
3248
3249 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3250 }
3251 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3252 {
3253 u64 off = innerloop_pos;
3254
3255 device_param->kernel_params_mp_buf64[3] = off;
3256
3257 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3258 }
3259 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3260 {
3261 u64 off = innerloop_pos;
3262
3263 device_param->kernel_params_mp_buf64[3] = off;
3264
3265 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3266 }
3267
3268 // copy amplifiers
3269
3270 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3271 {
3272 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);
3273 }
3274 else if (data.attack_mode == ATTACK_MODE_COMBI)
3275 {
3276 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);
3277 }
3278 else if (data.attack_mode == ATTACK_MODE_BF)
3279 {
3280 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);
3281 }
3282 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3283 {
3284 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);
3285 }
3286 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3287 {
3288 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);
3289 }
3290
3291 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3292
3293 if (data.benchmark == 1)
3294 {
3295 for (u32 i = 0; i < data.benchmark_repeats; i++)
3296 {
3297 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3298 }
3299 }
3300
3301 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3302
3303 if (data.devices_status == STATUS_CRACKED) break;
3304 if (data.devices_status == STATUS_ABORTED) break;
3305 if (data.devices_status == STATUS_QUIT) break;
3306
3307 /**
3308 * result
3309 */
3310
3311 hc_thread_mutex_lock (mux_display);
3312
3313 check_cracked (device_param, salt_pos);
3314
3315 hc_thread_mutex_unlock (mux_display);
3316
3317 /**
3318 * progress
3319 */
3320
3321 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3322
3323 if (data.benchmark == 1)
3324 {
3325 perf_sum_all = (perf_sum_all * data.benchmark_repeats) + perf_sum_all;
3326 }
3327
3328 hc_thread_mutex_lock (mux_counter);
3329
3330 data.words_progress_done[salt_pos] += perf_sum_all;
3331
3332 hc_thread_mutex_unlock (mux_counter);
3333
3334 /**
3335 * speed
3336 */
3337
3338 float speed_ms;
3339
3340 hc_timer_get (device_param->timer_speed, speed_ms);
3341
3342 hc_timer_set (&device_param->timer_speed);
3343
3344 hc_thread_mutex_lock (mux_display);
3345
3346 device_param->speed_cnt[speed_pos] = perf_sum_all;
3347
3348 device_param->speed_ms[speed_pos] = speed_ms;
3349
3350 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3351
3352 hc_thread_mutex_unlock (mux_display);
3353
3354 speed_pos++;
3355
3356 if (speed_pos == SPEED_CACHE)
3357 {
3358 speed_pos = 0;
3359 }
3360
3361 /**
3362 * benchmark
3363 */
3364
3365 if (data.benchmark == 1) break;
3366 }
3367 }
3368
3369 device_param->speed_pos = speed_pos;
3370 }
3371
3372 static void load_segment (wl_data_t *wl_data, FILE *fd)
3373 {
3374 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3375
3376 wl_data->pos = 0;
3377
3378 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3379
3380 wl_data->buf[wl_data->cnt] = 0;
3381
3382 if (wl_data->cnt == 0) return;
3383
3384 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3385
3386 while (!feof (fd))
3387 {
3388 if (wl_data->cnt == wl_data->avail)
3389 {
3390 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3391
3392 wl_data->avail += wl_data->incr;
3393 }
3394
3395 const int c = fgetc (fd);
3396
3397 if (c == EOF) break;
3398
3399 wl_data->buf[wl_data->cnt] = (char) c;
3400
3401 wl_data->cnt++;
3402
3403 if (c == '\n') break;
3404 }
3405
3406 // ensure stream ends with a newline
3407
3408 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3409 {
3410 wl_data->cnt++;
3411
3412 wl_data->buf[wl_data->cnt - 1] = '\n';
3413 }
3414
3415 return;
3416 }
3417
3418 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3419 {
3420 char *ptr = buf;
3421
3422 for (u32 i = 0; i < sz; i++, ptr++)
3423 {
3424 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3425
3426 if (i == 7)
3427 {
3428 *off = i;
3429 *len = i;
3430
3431 return;
3432 }
3433
3434 if (*ptr != '\n') continue;
3435
3436 *off = i + 1;
3437
3438 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3439
3440 *len = i;
3441
3442 return;
3443 }
3444
3445 *off = sz;
3446 *len = sz;
3447 }
3448
3449 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3450 {
3451 char *ptr = buf;
3452
3453 for (u32 i = 0; i < sz; i++, ptr++)
3454 {
3455 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3456
3457 if (*ptr != '\n') continue;
3458
3459 *off = i + 1;
3460
3461 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3462
3463 *len = i;
3464
3465 return;
3466 }
3467
3468 *off = sz;
3469 *len = sz;
3470 }
3471
3472 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3473 {
3474 char *ptr = buf;
3475
3476 for (u32 i = 0; i < sz; i++, ptr++)
3477 {
3478 if (*ptr != '\n') continue;
3479
3480 *off = i + 1;
3481
3482 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3483
3484 *len = i;
3485
3486 return;
3487 }
3488
3489 *off = sz;
3490 *len = sz;
3491 }
3492
3493 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3494 {
3495 while (wl_data->pos < wl_data->cnt)
3496 {
3497 uint off;
3498 uint len;
3499
3500 char *ptr = wl_data->buf + wl_data->pos;
3501
3502 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3503
3504 wl_data->pos += off;
3505
3506 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3507 {
3508 char rule_buf_out[BLOCK_SIZE] = { 0 };
3509
3510 int rule_len_out = -1;
3511
3512 if (len < BLOCK_SIZE)
3513 {
3514 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3515 }
3516
3517 if (rule_len_out < 0)
3518 {
3519 continue;
3520 }
3521
3522 if (rule_len_out > PW_MAX)
3523 {
3524 continue;
3525 }
3526 }
3527 else
3528 {
3529 if (len > PW_MAX)
3530 {
3531 continue;
3532 }
3533 }
3534
3535 *out_buf = ptr;
3536 *out_len = len;
3537
3538 return;
3539 }
3540
3541 if (feof (fd))
3542 {
3543 fprintf (stderr, "bug!!\n");
3544
3545 return;
3546 }
3547
3548 load_segment (wl_data, fd);
3549
3550 get_next_word (wl_data, fd, out_buf, out_len);
3551 }
3552
3553 #ifdef _POSIX
3554 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3555 #endif
3556
3557 #ifdef _WIN
3558 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3559 #endif
3560 {
3561 hc_signal (NULL);
3562
3563 dictstat_t d;
3564
3565 d.cnt = 0;
3566
3567 #ifdef _POSIX
3568 fstat (fileno (fd), &d.stat);
3569 #endif
3570
3571 #ifdef _WIN
3572 _fstat64 (fileno (fd), &d.stat);
3573 #endif
3574
3575 d.stat.st_mode = 0;
3576 d.stat.st_nlink = 0;
3577 d.stat.st_uid = 0;
3578 d.stat.st_gid = 0;
3579 d.stat.st_rdev = 0;
3580 d.stat.st_atime = 0;
3581
3582 #ifdef _POSIX
3583 d.stat.st_blksize = 0;
3584 d.stat.st_blocks = 0;
3585 #endif
3586
3587 if (d.stat.st_size == 0) return 0;
3588
3589 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3590
3591 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3592 {
3593 if (d_cache)
3594 {
3595 u64 cnt = d_cache->cnt;
3596
3597 u64 keyspace = cnt;
3598
3599 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3600 {
3601 keyspace *= data.kernel_rules_cnt;
3602 }
3603 else if (data.attack_kern == ATTACK_KERN_COMBI)
3604 {
3605 keyspace *= data.combs_cnt;
3606 }
3607
3608 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);
3609 if (data.quiet == 0) log_info ("");
3610
3611 hc_signal (sigHandler_default);
3612
3613 return (keyspace);
3614 }
3615 }
3616
3617 time_t now = 0;
3618 time_t prev = 0;
3619
3620 u64 comp = 0;
3621 u64 cnt = 0;
3622 u64 cnt2 = 0;
3623
3624 while (!feof (fd))
3625 {
3626 load_segment (wl_data, fd);
3627
3628 comp += wl_data->cnt;
3629
3630 u32 i = 0;
3631
3632 while (i < wl_data->cnt)
3633 {
3634 u32 len;
3635 u32 off;
3636
3637 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3638
3639 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3640 {
3641 char rule_buf_out[BLOCK_SIZE] = { 0 };
3642
3643 int rule_len_out = -1;
3644
3645 if (len < BLOCK_SIZE)
3646 {
3647 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3648 }
3649
3650 if (rule_len_out < 0)
3651 {
3652 len = PW_MAX1;
3653 }
3654 else
3655 {
3656 len = rule_len_out;
3657 }
3658 }
3659
3660 if (len < PW_MAX1)
3661 {
3662 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3663 {
3664 cnt += data.kernel_rules_cnt;
3665 }
3666 else if (data.attack_kern == ATTACK_KERN_COMBI)
3667 {
3668 cnt += data.combs_cnt;
3669 }
3670
3671 d.cnt++;
3672 }
3673
3674 i += off;
3675
3676 cnt2++;
3677 }
3678
3679 time (&now);
3680
3681 if ((now - prev) == 0) continue;
3682
3683 float percent = (float) comp / (float) d.stat.st_size;
3684
3685 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);
3686
3687 time (&prev);
3688 }
3689
3690 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);
3691 if (data.quiet == 0) log_info ("");
3692
3693 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3694
3695 hc_signal (sigHandler_default);
3696
3697 return (cnt);
3698 }
3699
3700 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3701 {
3702 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3703 }
3704
3705 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3706 {
3707 if (data.devices_status == STATUS_BYPASS) return 0;
3708
3709 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3710
3711 uint cache_cnt = pw_cache->cnt;
3712
3713 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3714
3715 memcpy (pw_hc1, pw_buf, pw_len);
3716
3717 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3718
3719 uint pws_cnt = device_param->pws_cnt;
3720
3721 cache_cnt++;
3722
3723 pw_t *pw = device_param->pws_buf + pws_cnt;
3724
3725 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3726
3727 pw->pw_len = pw_len;
3728
3729 pws_cnt++;
3730
3731 device_param->pws_cnt = pws_cnt;
3732 device_param->pw_cnt = pws_cnt * 1;
3733
3734 cache_cnt = 0;
3735
3736 pw_cache->cnt = cache_cnt;
3737
3738 return pws_cnt;
3739 }
3740
3741 static void *thread_monitor (void *p)
3742 {
3743 uint runtime_check = 0;
3744 uint remove_check = 0;
3745 uint status_check = 0;
3746 uint restore_check = 0;
3747
3748 uint restore_left = data.restore_timer;
3749 uint remove_left = data.remove_timer;
3750 uint status_left = data.status_timer;
3751
3752 #ifdef HAVE_HWMON
3753 uint hwmon_check = 0;
3754
3755 // these variables are mainly used for fan control (AMD only)
3756
3757 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3758
3759 // temperature controller "loopback" values
3760
3761 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3762 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3763
3764 #ifdef HAVE_ADL
3765 int temp_threshold = 1; // degrees celcius
3766
3767 int fan_speed_min = 15; // in percentage
3768 int fan_speed_max = 100;
3769 #endif // HAVE_ADL
3770
3771 time_t last_temp_check_time;
3772 #endif // HAVE_HWMON
3773
3774 uint sleep_time = 1;
3775
3776 if (data.runtime)
3777 {
3778 runtime_check = 1;
3779 }
3780
3781 if (data.restore_timer)
3782 {
3783 restore_check = 1;
3784 }
3785
3786 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3787 {
3788 remove_check = 1;
3789 }
3790
3791 if (data.status == 1)
3792 {
3793 status_check = 1;
3794 }
3795
3796 #ifdef HAVE_HWMON
3797 if (data.gpu_temp_disable == 0)
3798 {
3799 time (&last_temp_check_time);
3800
3801 hwmon_check = 1;
3802 }
3803 #endif
3804
3805 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3806 {
3807 #ifdef HAVE_HWMON
3808 if (hwmon_check == 0)
3809 #endif
3810 return (p);
3811 }
3812
3813 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3814 {
3815 hc_sleep (sleep_time);
3816
3817 if (data.devices_status != STATUS_RUNNING) continue;
3818
3819 #ifdef HAVE_HWMON
3820 if (hwmon_check == 1)
3821 {
3822 hc_thread_mutex_lock (mux_adl);
3823
3824 time_t temp_check_time;
3825
3826 time (&temp_check_time);
3827
3828 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3829
3830 if (Ta == 0) Ta = 1;
3831
3832 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3833 {
3834 hc_device_param_t *device_param = &data.devices_param[device_id];
3835
3836 if (device_param->skipped) continue;
3837
3838 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3839
3840 const int temperature = hm_get_temperature_with_device_id (device_id);
3841
3842 if (temperature > (int) data.gpu_temp_abort)
3843 {
3844 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3845
3846 if (data.devices_status != STATUS_QUIT) myabort ();
3847
3848 break;
3849 }
3850
3851 #ifdef HAVE_ADL
3852 const int gpu_temp_retain = data.gpu_temp_retain;
3853
3854 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3855 {
3856 if (data.hm_device[device_id].fan_supported == 1)
3857 {
3858 int temp_cur = temperature;
3859
3860 int temp_diff_new = gpu_temp_retain - temp_cur;
3861
3862 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3863
3864 // calculate Ta value (time difference in seconds between the last check and this check)
3865
3866 last_temp_check_time = temp_check_time;
3867
3868 float Kp = 1.8;
3869 float Ki = 0.005;
3870 float Kd = 6;
3871
3872 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3873
3874 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);
3875
3876 if (abs (fan_diff_required) >= temp_threshold)
3877 {
3878 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3879
3880 int fan_speed_level = fan_speed_cur;
3881
3882 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3883
3884 int fan_speed_new = fan_speed_level - fan_diff_required;
3885
3886 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3887 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3888
3889 if (fan_speed_new != fan_speed_cur)
3890 {
3891 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3892 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3893
3894 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3895 {
3896 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3897
3898 fan_speed_chgd[device_id] = 1;
3899 }
3900
3901 temp_diff_old[device_id] = temp_diff_new;
3902 }
3903 }
3904 }
3905 }
3906 #endif // HAVE_ADL
3907 }
3908
3909 hc_thread_mutex_unlock (mux_adl);
3910 }
3911 #endif // HAVE_HWMON
3912
3913 if (restore_check == 1)
3914 {
3915 restore_left--;
3916
3917 if (restore_left == 0)
3918 {
3919 if (data.restore_disable == 0) cycle_restore ();
3920
3921 restore_left = data.restore_timer;
3922 }
3923 }
3924
3925 if ((runtime_check == 1) && (data.runtime_start > 0))
3926 {
3927 time_t runtime_cur;
3928
3929 time (&runtime_cur);
3930
3931 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3932
3933 if (runtime_left <= 0)
3934 {
3935 if (data.benchmark == 0)
3936 {
3937 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3938 }
3939
3940 if (data.devices_status != STATUS_QUIT) myabort ();
3941 }
3942 }
3943
3944 if (remove_check == 1)
3945 {
3946 remove_left--;
3947
3948 if (remove_left == 0)
3949 {
3950 if (data.digests_saved != data.digests_done)
3951 {
3952 data.digests_saved = data.digests_done;
3953
3954 save_hash ();
3955 }
3956
3957 remove_left = data.remove_timer;
3958 }
3959 }
3960
3961 if (status_check == 1)
3962 {
3963 status_left--;
3964
3965 if (status_left == 0)
3966 {
3967 hc_thread_mutex_lock (mux_display);
3968
3969 if (data.quiet == 0) clear_prompt ();
3970
3971 if (data.quiet == 0) log_info ("");
3972
3973 status_display ();
3974
3975 if (data.quiet == 0) log_info ("");
3976
3977 hc_thread_mutex_unlock (mux_display);
3978
3979 status_left = data.status_timer;
3980 }
3981 }
3982 }
3983
3984 #ifdef HAVE_HWMON
3985 myfree (fan_speed_chgd);
3986
3987 myfree (temp_diff_old);
3988 myfree (temp_diff_sum);
3989 #endif
3990
3991 p = NULL;
3992
3993 return (p);
3994 }
3995
3996 static void *thread_outfile_remove (void *p)
3997 {
3998 // some hash-dependent constants
3999 char *outfile_dir = data.outfile_check_directory;
4000 uint dgst_size = data.dgst_size;
4001 uint isSalted = data.isSalted;
4002 uint esalt_size = data.esalt_size;
4003 uint hash_mode = data.hash_mode;
4004
4005 uint outfile_check_timer = data.outfile_check_timer;
4006
4007 char separator = data.separator;
4008
4009 // some hash-dependent functions
4010 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4011 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4012
4013 // buffers
4014 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4015
4016 hash_buf.digest = mymalloc (dgst_size);
4017
4018 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4019
4020 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4021
4022 uint digest_buf[64] = { 0 };
4023
4024 outfile_data_t *out_info = NULL;
4025
4026 char **out_files = NULL;
4027
4028 time_t folder_mtime = 0;
4029
4030 int out_cnt = 0;
4031
4032 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4033
4034 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4035 {
4036 hc_sleep (1);
4037
4038 if (data.devices_status != STATUS_RUNNING) continue;
4039
4040 check_left--;
4041
4042 if (check_left == 0)
4043 {
4044 struct stat outfile_check_stat;
4045
4046 if (stat (outfile_dir, &outfile_check_stat) == 0)
4047 {
4048 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4049
4050 if (is_dir == 1)
4051 {
4052 if (outfile_check_stat.st_mtime > folder_mtime)
4053 {
4054 char **out_files_new = scan_directory (outfile_dir);
4055
4056 int out_cnt_new = count_dictionaries (out_files_new);
4057
4058 outfile_data_t *out_info_new = NULL;
4059
4060 if (out_cnt_new > 0)
4061 {
4062 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4063
4064 for (int i = 0; i < out_cnt_new; i++)
4065 {
4066 out_info_new[i].file_name = out_files_new[i];
4067
4068 // check if there are files that we have seen/checked before (and not changed)
4069
4070 for (int j = 0; j < out_cnt; j++)
4071 {
4072 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4073 {
4074 struct stat outfile_stat;
4075
4076 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4077 {
4078 if (outfile_stat.st_ctime == out_info[j].ctime)
4079 {
4080 out_info_new[i].ctime = out_info[j].ctime;
4081 out_info_new[i].seek = out_info[j].seek;
4082 }
4083 }
4084 }
4085 }
4086 }
4087 }
4088
4089 local_free (out_info);
4090 local_free (out_files);
4091
4092 out_files = out_files_new;
4093 out_cnt = out_cnt_new;
4094 out_info = out_info_new;
4095
4096 folder_mtime = outfile_check_stat.st_mtime;
4097 }
4098
4099 for (int j = 0; j < out_cnt; j++)
4100 {
4101 FILE *fp = fopen (out_info[j].file_name, "rb");
4102
4103 if (fp != NULL)
4104 {
4105 //hc_thread_mutex_lock (mux_display);
4106
4107 #ifdef _POSIX
4108 struct stat outfile_stat;
4109
4110 fstat (fileno (fp), &outfile_stat);
4111 #endif
4112
4113 #ifdef _WIN
4114 struct stat64 outfile_stat;
4115
4116 _fstat64 (fileno (fp), &outfile_stat);
4117 #endif
4118
4119 if (outfile_stat.st_ctime > out_info[j].ctime)
4120 {
4121 out_info[j].ctime = outfile_stat.st_ctime;
4122 out_info[j].seek = 0;
4123 }
4124
4125 fseek (fp, out_info[j].seek, SEEK_SET);
4126
4127 while (!feof (fp))
4128 {
4129 char line_buf[BUFSIZ] = { 0 };
4130
4131 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4132
4133 if (ptr == NULL) break;
4134
4135 int line_len = strlen (line_buf);
4136
4137 if (line_len <= 0) continue;
4138
4139 int iter = MAX_CUT_TRIES;
4140
4141 for (uint i = line_len - 1; i && iter; i--, line_len--)
4142 {
4143 if (line_buf[i] != separator) continue;
4144
4145 int parser_status = PARSER_OK;
4146
4147 if ((hash_mode != 2500) && (hash_mode != 6800))
4148 {
4149 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4150 }
4151
4152 uint found = 0;
4153
4154 if (parser_status == PARSER_OK)
4155 {
4156 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4157 {
4158 if (data.salts_shown[salt_pos] == 1) continue;
4159
4160 salt_t *salt_buf = &data.salts_buf[salt_pos];
4161
4162 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4163 {
4164 uint idx = salt_buf->digests_offset + digest_pos;
4165
4166 if (data.digests_shown[idx] == 1) continue;
4167
4168 uint cracked = 0;
4169
4170 if (hash_mode == 6800)
4171 {
4172 if (i == salt_buf->salt_len)
4173 {
4174 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4175 }
4176 }
4177 else if (hash_mode == 2500)
4178 {
4179 // BSSID : MAC1 : MAC2 (:plain)
4180 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4181 {
4182 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4183
4184 if (!cracked) continue;
4185
4186 // now compare MAC1 and MAC2 too, since we have this additional info
4187 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4188 char *mac2_pos = mac1_pos + 12 + 1;
4189
4190 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4191 wpa_t *wpa = &wpas[salt_pos];
4192
4193 uint pke[25] = { 0 };
4194
4195 char *pke_ptr = (char *) pke;
4196
4197 for (uint i = 0; i < 25; i++)
4198 {
4199 pke[i] = byte_swap_32 (wpa->pke[i]);
4200 }
4201
4202 u8 mac1[6] = { 0 };
4203 u8 mac2[6] = { 0 };
4204
4205 memcpy (mac1, pke_ptr + 23, 6);
4206 memcpy (mac2, pke_ptr + 29, 6);
4207
4208 // compare hex string(s) vs binary MAC address(es)
4209
4210 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4211 {
4212 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4213 {
4214 cracked = 0;
4215 break;
4216 }
4217 }
4218
4219 // early skip ;)
4220 if (!cracked) continue;
4221
4222 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4223 {
4224 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4225 {
4226 cracked = 0;
4227 break;
4228 }
4229 }
4230 }
4231 }
4232 else
4233 {
4234 char *digests_buf_ptr = (char *) data.digests_buf;
4235
4236 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4237
4238 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4239 }
4240
4241 if (cracked == 1)
4242 {
4243 found = 1;
4244
4245 data.digests_shown[idx] = 1;
4246
4247 data.digests_done++;
4248
4249 salt_buf->digests_done++;
4250
4251 if (salt_buf->digests_done == salt_buf->digests_cnt)
4252 {
4253 data.salts_shown[salt_pos] = 1;
4254
4255 data.salts_done++;
4256
4257 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4258 }
4259 }
4260 }
4261
4262 if (data.devices_status == STATUS_CRACKED) break;
4263 }
4264 }
4265
4266 if (found) break;
4267
4268 if (data.devices_status == STATUS_CRACKED) break;
4269
4270 iter--;
4271 }
4272
4273 if (data.devices_status == STATUS_CRACKED) break;
4274 }
4275
4276 out_info[j].seek = ftell (fp);
4277
4278 //hc_thread_mutex_unlock (mux_display);
4279
4280 fclose (fp);
4281 }
4282 }
4283 }
4284 }
4285
4286 check_left = outfile_check_timer;
4287 }
4288 }
4289
4290 if (esalt_size) local_free (hash_buf.esalt);
4291
4292 if (isSalted) local_free (hash_buf.salt);
4293
4294 local_free (hash_buf.digest);
4295
4296 local_free (out_info);
4297
4298 local_free (out_files);
4299
4300 p = NULL;
4301
4302 return (p);
4303 }
4304
4305 static uint get_work (hc_device_param_t *device_param, const u64 max)
4306 {
4307 hc_thread_mutex_lock (mux_dispatcher);
4308
4309 const u64 words_cur = data.words_cur;
4310 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4311
4312 device_param->words_off = words_cur;
4313
4314 const u64 words_left = words_base - words_cur;
4315
4316 if (data.kernel_power_all > words_left)
4317 {
4318 if (data.kernel_power_div == 0)
4319 {
4320 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4321 }
4322 }
4323
4324 if (data.kernel_power_div)
4325 {
4326 if (device_param->kernel_power == device_param->kernel_power_user)
4327 {
4328 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4329
4330 if (kernel_power_new < device_param->kernel_power)
4331 {
4332 device_param->kernel_power = kernel_power_new;
4333 }
4334 }
4335 }
4336
4337 const uint kernel_power = device_param->kernel_power;
4338
4339 uint work = MIN (words_left, kernel_power);
4340
4341 work = MIN (work, max);
4342
4343 data.words_cur += work;
4344
4345 hc_thread_mutex_unlock (mux_dispatcher);
4346
4347 return work;
4348 }
4349
4350 static void *thread_calc_stdin (void *p)
4351 {
4352 hc_device_param_t *device_param = (hc_device_param_t *) p;
4353
4354 if (device_param->skipped) return NULL;
4355
4356 autotune (device_param);
4357
4358 const uint attack_kern = data.attack_kern;
4359
4360 const uint kernel_power = device_param->kernel_power;
4361
4362 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4363 {
4364 hc_thread_mutex_lock (mux_dispatcher);
4365
4366 if (feof (stdin) != 0)
4367 {
4368 hc_thread_mutex_unlock (mux_dispatcher);
4369
4370 break;
4371 }
4372
4373 uint words_cur = 0;
4374
4375 while (words_cur < kernel_power)
4376 {
4377 char buf[BUFSIZ] = { 0 };
4378
4379 char *line_buf = fgets (buf, sizeof (buf), stdin);
4380
4381 if (line_buf == NULL) break;
4382
4383 uint line_len = in_superchop (line_buf);
4384
4385 line_len = convert_from_hex (line_buf, line_len);
4386
4387 // post-process rule engine
4388
4389 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4390 {
4391 char rule_buf_out[BLOCK_SIZE] = { 0 };
4392
4393 int rule_len_out = -1;
4394
4395 if (line_len < BLOCK_SIZE)
4396 {
4397 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4398 }
4399
4400 if (rule_len_out < 0) continue;
4401
4402 line_buf = rule_buf_out;
4403 line_len = rule_len_out;
4404 }
4405
4406 if (line_len > PW_MAX)
4407 {
4408 continue;
4409 }
4410
4411 if (attack_kern == ATTACK_KERN_STRAIGHT)
4412 {
4413 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4414 {
4415 hc_thread_mutex_lock (mux_counter);
4416
4417 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4418 {
4419 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4420 }
4421
4422 hc_thread_mutex_unlock (mux_counter);
4423
4424 continue;
4425 }
4426 }
4427 else if (attack_kern == ATTACK_KERN_COMBI)
4428 {
4429 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4430 // since we still need to combine the plains
4431
4432 if (line_len > data.pw_max)
4433 {
4434 hc_thread_mutex_lock (mux_counter);
4435
4436 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4437 {
4438 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4439 }
4440
4441 hc_thread_mutex_unlock (mux_counter);
4442
4443 continue;
4444 }
4445 }
4446
4447 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4448
4449 words_cur++;
4450
4451 if (data.devices_status == STATUS_CRACKED) break;
4452 if (data.devices_status == STATUS_ABORTED) break;
4453 if (data.devices_status == STATUS_QUIT) break;
4454 if (data.devices_status == STATUS_BYPASS) break;
4455 }
4456
4457 hc_thread_mutex_unlock (mux_dispatcher);
4458
4459 if (data.devices_status == STATUS_CRACKED) break;
4460 if (data.devices_status == STATUS_ABORTED) break;
4461 if (data.devices_status == STATUS_QUIT) break;
4462 if (data.devices_status == STATUS_BYPASS) break;
4463
4464 // we need 2 flushing because we have two independant caches and it can occur
4465 // that one buffer is already at threshold plus for that length also exists
4466 // more data in the 2nd buffer so it would overflow
4467
4468 // flush session 1
4469
4470 {
4471 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4472 {
4473 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4474
4475 const uint pw_cache_cnt = pw_cache->cnt;
4476
4477 if (pw_cache_cnt == 0) continue;
4478
4479 pw_cache->cnt = 0;
4480
4481 uint pws_cnt = device_param->pws_cnt;
4482
4483 pw_t *pw = device_param->pws_buf + pws_cnt;
4484
4485 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4486
4487 pw->pw_len = pw_len;
4488
4489 uint pw_cnt = device_param->pw_cnt;
4490
4491 pw_cnt += pw_cache_cnt;
4492
4493 device_param->pw_cnt = pw_cnt;
4494
4495 pws_cnt++;
4496
4497 device_param->pws_cnt = pws_cnt;
4498
4499 if (pws_cnt == device_param->kernel_power_user) break;
4500 }
4501
4502 const uint pw_cnt = device_param->pw_cnt;
4503 const uint pws_cnt = device_param->pws_cnt;
4504
4505 if (pws_cnt)
4506 {
4507 run_copy (device_param, pws_cnt);
4508
4509 run_cracker (device_param, pw_cnt, pws_cnt);
4510
4511 device_param->pw_cnt = 0;
4512 device_param->pws_cnt = 0;
4513 }
4514 }
4515
4516 // flush session 2
4517
4518 {
4519 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4520 {
4521 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4522
4523 const uint pw_cache_cnt = pw_cache->cnt;
4524
4525 if (pw_cache_cnt == 0) continue;
4526
4527 pw_cache->cnt = 0;
4528
4529 uint pws_cnt = device_param->pws_cnt;
4530
4531 pw_t *pw = device_param->pws_buf + pws_cnt;
4532
4533 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4534
4535 pw->pw_len = pw_len;
4536
4537 uint pw_cnt = device_param->pw_cnt;
4538
4539 pw_cnt += pw_cache_cnt;
4540
4541 device_param->pw_cnt = pw_cnt;
4542
4543 pws_cnt++;
4544
4545 device_param->pws_cnt = pws_cnt;
4546 }
4547
4548 const uint pw_cnt = device_param->pw_cnt;
4549 const uint pws_cnt = device_param->pws_cnt;
4550
4551 if (pws_cnt)
4552 {
4553 run_copy (device_param, pws_cnt);
4554
4555 run_cracker (device_param, pw_cnt, pws_cnt);
4556
4557 device_param->pw_cnt = 0;
4558 device_param->pws_cnt = 0;
4559 }
4560 }
4561 }
4562
4563 device_param->kernel_accel = 0;
4564 device_param->kernel_loops = 0;
4565
4566 return NULL;
4567 }
4568
4569 static void *thread_calc (void *p)
4570 {
4571 hc_device_param_t *device_param = (hc_device_param_t *) p;
4572
4573 if (device_param->skipped) return NULL;
4574
4575 autotune (device_param);
4576
4577 const uint attack_mode = data.attack_mode;
4578 const uint attack_kern = data.attack_kern;
4579
4580 if (attack_mode == ATTACK_MODE_BF)
4581 {
4582 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4583 {
4584 const uint work = get_work (device_param, -1);
4585
4586 if (work == 0) break;
4587
4588 const u64 words_off = device_param->words_off;
4589 const u64 words_fin = words_off + work;
4590
4591 const uint pw_cnt = work;
4592 const uint pws_cnt = work;
4593
4594 device_param->pw_cnt = pw_cnt;
4595 device_param->pws_cnt = pws_cnt;
4596
4597 if (pws_cnt)
4598 {
4599 run_copy (device_param, pws_cnt);
4600
4601 run_cracker (device_param, pw_cnt, pws_cnt);
4602
4603 device_param->pw_cnt = 0;
4604 device_param->pws_cnt = 0;
4605 }
4606
4607 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4608
4609 if (data.devices_status == STATUS_CRACKED) break;
4610 if (data.devices_status == STATUS_ABORTED) break;
4611 if (data.devices_status == STATUS_QUIT) break;
4612 if (data.devices_status == STATUS_BYPASS) break;
4613
4614 if (data.benchmark == 1) break;
4615
4616 device_param->words_done = words_fin;
4617 }
4618 }
4619 else
4620 {
4621 const uint segment_size = data.segment_size;
4622
4623 char *dictfile = data.dictfile;
4624
4625 if (attack_mode == ATTACK_MODE_COMBI)
4626 {
4627 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4628 {
4629 dictfile = data.dictfile2;
4630 }
4631 }
4632
4633 FILE *fd = fopen (dictfile, "rb");
4634
4635 if (fd == NULL)
4636 {
4637 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4638
4639 return NULL;
4640 }
4641
4642 if (attack_mode == ATTACK_MODE_COMBI)
4643 {
4644 const uint combs_mode = data.combs_mode;
4645
4646 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4647 {
4648 const char *dictfilec = data.dictfile2;
4649
4650 FILE *combs_fp = fopen (dictfilec, "rb");
4651
4652 if (combs_fp == NULL)
4653 {
4654 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4655
4656 fclose (fd);
4657
4658 return NULL;
4659 }
4660
4661 device_param->combs_fp = combs_fp;
4662 }
4663 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4664 {
4665 const char *dictfilec = data.dictfile;
4666
4667 FILE *combs_fp = fopen (dictfilec, "rb");
4668
4669 if (combs_fp == NULL)
4670 {
4671 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4672
4673 fclose (fd);
4674
4675 return NULL;
4676 }
4677
4678 device_param->combs_fp = combs_fp;
4679 }
4680 }
4681
4682 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4683
4684 wl_data->buf = (char *) mymalloc (segment_size);
4685 wl_data->avail = segment_size;
4686 wl_data->incr = segment_size;
4687 wl_data->cnt = 0;
4688 wl_data->pos = 0;
4689
4690 u64 words_cur = 0;
4691
4692 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4693 {
4694 u64 words_off = 0;
4695 u64 words_fin = 0;
4696
4697 u64 max = -1;
4698
4699 while (max)
4700 {
4701 const uint work = get_work (device_param, max);
4702
4703 if (work == 0) break;
4704
4705 words_off = device_param->words_off;
4706 words_fin = words_off + work;
4707
4708 char *line_buf;
4709 uint line_len;
4710
4711 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4712
4713 max = 0;
4714
4715 for ( ; words_cur < words_fin; words_cur++)
4716 {
4717 get_next_word (wl_data, fd, &line_buf, &line_len);
4718
4719 line_len = convert_from_hex (line_buf, line_len);
4720
4721 // post-process rule engine
4722
4723 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4724 {
4725 char rule_buf_out[BLOCK_SIZE] = { 0 };
4726
4727 int rule_len_out = -1;
4728
4729 if (line_len < BLOCK_SIZE)
4730 {
4731 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4732 }
4733
4734 if (rule_len_out < 0) continue;
4735
4736 line_buf = rule_buf_out;
4737 line_len = rule_len_out;
4738 }
4739
4740 if (attack_kern == ATTACK_KERN_STRAIGHT)
4741 {
4742 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4743 {
4744 max++;
4745
4746 hc_thread_mutex_lock (mux_counter);
4747
4748 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4749 {
4750 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4751 }
4752
4753 hc_thread_mutex_unlock (mux_counter);
4754
4755 continue;
4756 }
4757 }
4758 else if (attack_kern == ATTACK_KERN_COMBI)
4759 {
4760 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4761 // since we still need to combine the plains
4762
4763 if (line_len > data.pw_max)
4764 {
4765 max++;
4766
4767 hc_thread_mutex_lock (mux_counter);
4768
4769 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4770 {
4771 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4772 }
4773
4774 hc_thread_mutex_unlock (mux_counter);
4775
4776 continue;
4777 }
4778 }
4779
4780 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4781
4782 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4783
4784 if (data.devices_status == STATUS_CRACKED) break;
4785 if (data.devices_status == STATUS_ABORTED) break;
4786 if (data.devices_status == STATUS_QUIT) break;
4787 if (data.devices_status == STATUS_BYPASS) break;
4788 }
4789
4790 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4791
4792 if (data.devices_status == STATUS_CRACKED) break;
4793 if (data.devices_status == STATUS_ABORTED) break;
4794 if (data.devices_status == STATUS_QUIT) break;
4795 if (data.devices_status == STATUS_BYPASS) break;
4796 }
4797
4798 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4799
4800 if (data.devices_status == STATUS_CRACKED) break;
4801 if (data.devices_status == STATUS_ABORTED) break;
4802 if (data.devices_status == STATUS_QUIT) break;
4803 if (data.devices_status == STATUS_BYPASS) break;
4804
4805 // we need 2 flushing because we have two independant caches and it can occur
4806 // that one buffer is already at threshold plus for that length also exists
4807 // more data in the 2nd buffer so it would overflow
4808
4809 //
4810 // flush session 1
4811 //
4812
4813 {
4814 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4815 {
4816 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4817
4818 const uint pw_cache_cnt = pw_cache->cnt;
4819
4820 if (pw_cache_cnt == 0) continue;
4821
4822 pw_cache->cnt = 0;
4823
4824 uint pws_cnt = device_param->pws_cnt;
4825
4826 pw_t *pw = device_param->pws_buf + pws_cnt;
4827
4828 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4829
4830 pw->pw_len = pw_len;
4831
4832 uint pw_cnt = device_param->pw_cnt;
4833
4834 pw_cnt += pw_cache_cnt;
4835
4836 device_param->pw_cnt = pw_cnt;
4837
4838 pws_cnt++;
4839
4840 device_param->pws_cnt = pws_cnt;
4841
4842 if (pws_cnt == device_param->kernel_power_user) break;
4843 }
4844
4845 const uint pw_cnt = device_param->pw_cnt;
4846 const uint pws_cnt = device_param->pws_cnt;
4847
4848 if (pws_cnt)
4849 {
4850 run_copy (device_param, pws_cnt);
4851
4852 run_cracker (device_param, pw_cnt, pws_cnt);
4853
4854 device_param->pw_cnt = 0;
4855 device_param->pws_cnt = 0;
4856 }
4857
4858 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4859
4860 if (data.devices_status == STATUS_CRACKED) break;
4861 if (data.devices_status == STATUS_ABORTED) break;
4862 if (data.devices_status == STATUS_QUIT) break;
4863 if (data.devices_status == STATUS_BYPASS) break;
4864 }
4865
4866 //
4867 // flush session 2
4868 //
4869
4870 {
4871 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4872 {
4873 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4874
4875 const uint pw_cache_cnt = pw_cache->cnt;
4876
4877 if (pw_cache_cnt == 0) continue;
4878
4879 pw_cache->cnt = 0;
4880
4881 uint pws_cnt = device_param->pws_cnt;
4882
4883 pw_t *pw = device_param->pws_buf + pws_cnt;
4884
4885 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4886
4887 pw->pw_len = pw_len;
4888
4889 uint pw_cnt = device_param->pw_cnt;
4890
4891 pw_cnt += pw_cache_cnt;
4892
4893 device_param->pw_cnt = pw_cnt;
4894
4895 pws_cnt++;
4896
4897 device_param->pws_cnt = pws_cnt;
4898 }
4899
4900 const uint pw_cnt = device_param->pw_cnt;
4901 const uint pws_cnt = device_param->pws_cnt;
4902
4903 if (pws_cnt)
4904 {
4905 run_copy (device_param, pws_cnt);
4906
4907 run_cracker (device_param, pw_cnt, pws_cnt);
4908
4909 device_param->pw_cnt = 0;
4910 device_param->pws_cnt = 0;
4911 }
4912
4913 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4914
4915 if (data.devices_status == STATUS_CRACKED) break;
4916 if (data.devices_status == STATUS_ABORTED) break;
4917 if (data.devices_status == STATUS_QUIT) break;
4918 if (data.devices_status == STATUS_BYPASS) break;
4919 }
4920
4921 if (words_fin == 0) break;
4922
4923 device_param->words_done = words_fin;
4924 }
4925
4926 if (attack_mode == ATTACK_MODE_COMBI)
4927 {
4928 fclose (device_param->combs_fp);
4929 }
4930
4931 free (wl_data->buf);
4932 free (wl_data);
4933
4934 fclose (fd);
4935 }
4936
4937 device_param->kernel_accel = 0;
4938 device_param->kernel_loops = 0;
4939
4940 return NULL;
4941 }
4942
4943 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4944 {
4945 if (!device_param)
4946 {
4947 log_error ("ERROR: %s : Invalid argument", __func__);
4948
4949 exit (-1);
4950 }
4951
4952 salt_t *salt_buf = &data.salts_buf[salt_pos];
4953
4954 device_param->kernel_params_buf32[24] = salt_pos;
4955 device_param->kernel_params_buf32[27] = 1;
4956 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4957 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4958 device_param->kernel_params_buf32[30] = 0;
4959 device_param->kernel_params_buf32[31] = 1;
4960
4961 char *dictfile_old = data.dictfile;
4962
4963 const char *weak_hash_check = "weak-hash-check";
4964
4965 data.dictfile = (char *) weak_hash_check;
4966
4967 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4968
4969 data.kernel_rules_buf[0].cmds[0] = 0;
4970
4971 /**
4972 * run the kernel
4973 */
4974
4975 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4976 {
4977 run_kernel (KERN_RUN_1, device_param, 1, false);
4978 }
4979 else
4980 {
4981 run_kernel (KERN_RUN_1, device_param, 1, false);
4982
4983 uint loop_step = 16;
4984
4985 const uint iter = salt_buf->salt_iter;
4986
4987 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4988 {
4989 uint loop_left = iter - loop_pos;
4990
4991 loop_left = MIN (loop_left, loop_step);
4992
4993 device_param->kernel_params_buf32[25] = loop_pos;
4994 device_param->kernel_params_buf32[26] = loop_left;
4995
4996 run_kernel (KERN_RUN_2, device_param, 1, false);
4997 }
4998
4999 run_kernel (KERN_RUN_3, device_param, 1, false);
5000 }
5001
5002 /**
5003 * result
5004 */
5005
5006 check_cracked (device_param, salt_pos);
5007
5008 /**
5009 * cleanup
5010 */
5011
5012 device_param->kernel_params_buf32[24] = 0;
5013 device_param->kernel_params_buf32[25] = 0;
5014 device_param->kernel_params_buf32[26] = 0;
5015 device_param->kernel_params_buf32[27] = 0;
5016 device_param->kernel_params_buf32[28] = 0;
5017 device_param->kernel_params_buf32[29] = 0;
5018 device_param->kernel_params_buf32[30] = 0;
5019 device_param->kernel_params_buf32[31] = 0;
5020
5021 data.dictfile = dictfile_old;
5022
5023 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5024 }
5025
5026 // hlfmt hashcat
5027
5028 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5029 {
5030 if (data.username == 0)
5031 {
5032 *hashbuf_pos = line_buf;
5033 *hashbuf_len = line_len;
5034 }
5035 else
5036 {
5037 char *pos = line_buf;
5038 int len = line_len;
5039
5040 for (int i = 0; i < line_len; i++, pos++, len--)
5041 {
5042 if (line_buf[i] == data.separator)
5043 {
5044 pos++;
5045
5046 len--;
5047
5048 break;
5049 }
5050 }
5051
5052 *hashbuf_pos = pos;
5053 *hashbuf_len = len;
5054 }
5055 }
5056
5057 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5058 {
5059 char *pos = NULL;
5060 int len = 0;
5061
5062 int sep_cnt = 0;
5063
5064 for (int i = 0; i < line_len; i++)
5065 {
5066 if (line_buf[i] == data.separator)
5067 {
5068 sep_cnt++;
5069
5070 continue;
5071 }
5072
5073 if (sep_cnt == 0)
5074 {
5075 if (pos == NULL) pos = line_buf + i;
5076
5077 len++;
5078 }
5079 }
5080
5081 *userbuf_pos = pos;
5082 *userbuf_len = len;
5083 }
5084
5085 // hlfmt pwdump
5086
5087 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5088 {
5089 int sep_cnt = 0;
5090
5091 int sep2_len = 0;
5092 int sep3_len = 0;
5093
5094 for (int i = 0; i < line_len; i++)
5095 {
5096 if (line_buf[i] == ':')
5097 {
5098 sep_cnt++;
5099
5100 continue;
5101 }
5102
5103 if (sep_cnt == 2) sep2_len++;
5104 if (sep_cnt == 3) sep3_len++;
5105 }
5106
5107 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5108
5109 return 0;
5110 }
5111
5112 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5113 {
5114 char *pos = NULL;
5115 int len = 0;
5116
5117 int sep_cnt = 0;
5118
5119 for (int i = 0; i < line_len; i++)
5120 {
5121 if (line_buf[i] == ':')
5122 {
5123 sep_cnt++;
5124
5125 continue;
5126 }
5127
5128 if (data.hash_mode == 1000)
5129 {
5130 if (sep_cnt == 3)
5131 {
5132 if (pos == NULL) pos = line_buf + i;
5133
5134 len++;
5135 }
5136 }
5137 else if (data.hash_mode == 3000)
5138 {
5139 if (sep_cnt == 2)
5140 {
5141 if (pos == NULL) pos = line_buf + i;
5142
5143 len++;
5144 }
5145 }
5146 }
5147
5148 *hashbuf_pos = pos;
5149 *hashbuf_len = len;
5150 }
5151
5152 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5153 {
5154 char *pos = NULL;
5155 int len = 0;
5156
5157 int sep_cnt = 0;
5158
5159 for (int i = 0; i < line_len; i++)
5160 {
5161 if (line_buf[i] == ':')
5162 {
5163 sep_cnt++;
5164
5165 continue;
5166 }
5167
5168 if (sep_cnt == 0)
5169 {
5170 if (pos == NULL) pos = line_buf + i;
5171
5172 len++;
5173 }
5174 }
5175
5176 *userbuf_pos = pos;
5177 *userbuf_len = len;
5178 }
5179
5180 // hlfmt passwd
5181
5182 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5183 {
5184 int sep_cnt = 0;
5185
5186 char sep5_first = 0;
5187 char sep6_first = 0;
5188
5189 for (int i = 0; i < line_len; i++)
5190 {
5191 if (line_buf[i] == ':')
5192 {
5193 sep_cnt++;
5194
5195 continue;
5196 }
5197
5198 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5199 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5200 }
5201
5202 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5203
5204 return 0;
5205 }
5206
5207 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5208 {
5209 char *pos = NULL;
5210 int len = 0;
5211
5212 int sep_cnt = 0;
5213
5214 for (int i = 0; i < line_len; i++)
5215 {
5216 if (line_buf[i] == ':')
5217 {
5218 sep_cnt++;
5219
5220 continue;
5221 }
5222
5223 if (sep_cnt == 1)
5224 {
5225 if (pos == NULL) pos = line_buf + i;
5226
5227 len++;
5228 }
5229 }
5230
5231 *hashbuf_pos = pos;
5232 *hashbuf_len = len;
5233 }
5234
5235 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5236 {
5237 char *pos = NULL;
5238 int len = 0;
5239
5240 int sep_cnt = 0;
5241
5242 for (int i = 0; i < line_len; i++)
5243 {
5244 if (line_buf[i] == ':')
5245 {
5246 sep_cnt++;
5247
5248 continue;
5249 }
5250
5251 if (sep_cnt == 0)
5252 {
5253 if (pos == NULL) pos = line_buf + i;
5254
5255 len++;
5256 }
5257 }
5258
5259 *userbuf_pos = pos;
5260 *userbuf_len = len;
5261 }
5262
5263 // hlfmt shadow
5264
5265 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5266 {
5267 int sep_cnt = 0;
5268
5269 for (int i = 0; i < line_len; i++)
5270 {
5271 if (line_buf[i] == ':') sep_cnt++;
5272 }
5273
5274 if (sep_cnt == 8) return 1;
5275
5276 return 0;
5277 }
5278
5279 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5280 {
5281 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5282 }
5283
5284 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5285 {
5286 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5287 }
5288
5289 // hlfmt main
5290
5291 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5292 {
5293 switch (hashfile_format)
5294 {
5295 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5296 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5297 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5298 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5299 }
5300 }
5301
5302 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5303 {
5304 switch (hashfile_format)
5305 {
5306 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5307 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5308 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5309 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5310 }
5311 }
5312
5313 static uint hlfmt_detect (FILE *fp, uint max_check)
5314 {
5315 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5316
5317 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5318 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5319
5320 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5321
5322 uint num_check = 0;
5323
5324 while (!feof (fp))
5325 {
5326 char line_buf[BUFSIZ] = { 0 };
5327
5328 int line_len = fgetl (fp, line_buf);
5329
5330 if (line_len == 0) continue;
5331
5332 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5333 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5334 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5335
5336 if (num_check == max_check) break;
5337
5338 num_check++;
5339 }
5340
5341 uint hashlist_format = HLFMT_HASHCAT;
5342
5343 for (int i = 1; i < HLFMTS_CNT; i++)
5344 {
5345 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5346
5347 hashlist_format = i;
5348 }
5349
5350 free (formats_cnt);
5351
5352 return hashlist_format;
5353 }
5354
5355 /**
5356 * some further helper function
5357 */
5358
5359 // wrapper around mymalloc for ADL
5360
5361 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5362 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5363 {
5364 return mymalloc (iSize);
5365 }
5366 #endif
5367
5368 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)
5369 {
5370 u64 collisions = 0;
5371
5372 const uint dgst_pos0 = data.dgst_pos0;
5373 const uint dgst_pos1 = data.dgst_pos1;
5374 const uint dgst_pos2 = data.dgst_pos2;
5375 const uint dgst_pos3 = data.dgst_pos3;
5376
5377 memset (bitmap_a, 0, bitmap_size);
5378 memset (bitmap_b, 0, bitmap_size);
5379 memset (bitmap_c, 0, bitmap_size);
5380 memset (bitmap_d, 0, bitmap_size);
5381
5382 for (uint i = 0; i < digests_cnt; i++)
5383 {
5384 uint *digest_ptr = (uint *) digests_buf_ptr;
5385
5386 digests_buf_ptr += dgst_size;
5387
5388 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5389 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5390 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5391 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5392
5393 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5394 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5395 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5396 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5397
5398 if (bitmap_a[idx0] & val0) collisions++;
5399 if (bitmap_b[idx1] & val1) collisions++;
5400 if (bitmap_c[idx2] & val2) collisions++;
5401 if (bitmap_d[idx3] & val3) collisions++;
5402
5403 bitmap_a[idx0] |= val0;
5404 bitmap_b[idx1] |= val1;
5405 bitmap_c[idx2] |= val2;
5406 bitmap_d[idx3] |= val3;
5407
5408 if (collisions >= collisions_max) return 0x7fffffff;
5409 }
5410
5411 return collisions;
5412 }
5413
5414 /**
5415 * main
5416 */
5417
5418 int main (int argc, char **argv)
5419 {
5420 /**
5421 * To help users a bit
5422 */
5423
5424 char *compute = getenv ("COMPUTE");
5425
5426 if (compute)
5427 {
5428 static char display[100];
5429
5430 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5431
5432 putenv (display);
5433 }
5434 else
5435 {
5436 if (getenv ("DISPLAY") == NULL)
5437 putenv ((char *) "DISPLAY=:0");
5438 }
5439
5440 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5441 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5442
5443 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5444 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5445
5446 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5447 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5448
5449 /**
5450 * Real init
5451 */
5452
5453 memset (&data, 0, sizeof (hc_global_data_t));
5454
5455 time_t proc_start;
5456
5457 time (&proc_start);
5458
5459 data.proc_start = proc_start;
5460
5461 int myargc = argc;
5462 char **myargv = argv;
5463
5464 hc_thread_mutex_init (mux_dispatcher);
5465 hc_thread_mutex_init (mux_counter);
5466 hc_thread_mutex_init (mux_display);
5467 hc_thread_mutex_init (mux_adl);
5468
5469 /**
5470 * commandline parameters
5471 */
5472
5473 uint usage = USAGE;
5474 uint version = VERSION;
5475 uint quiet = QUIET;
5476 uint benchmark = BENCHMARK;
5477 uint benchmark_repeats = BENCHMARK_REPEATS;
5478 uint show = SHOW;
5479 uint left = LEFT;
5480 uint username = USERNAME;
5481 uint remove = REMOVE;
5482 uint remove_timer = REMOVE_TIMER;
5483 u64 skip = SKIP;
5484 u64 limit = LIMIT;
5485 uint keyspace = KEYSPACE;
5486 uint potfile_disable = POTFILE_DISABLE;
5487 uint debug_mode = DEBUG_MODE;
5488 char *debug_file = NULL;
5489 char *induction_dir = NULL;
5490 char *outfile_check_dir = NULL;
5491 uint force = FORCE;
5492 uint runtime = RUNTIME;
5493 uint hash_mode = HASH_MODE;
5494 uint attack_mode = ATTACK_MODE;
5495 uint markov_disable = MARKOV_DISABLE;
5496 uint markov_classic = MARKOV_CLASSIC;
5497 uint markov_threshold = MARKOV_THRESHOLD;
5498 char *markov_hcstat = NULL;
5499 char *outfile = NULL;
5500 uint outfile_format = OUTFILE_FORMAT;
5501 uint outfile_autohex = OUTFILE_AUTOHEX;
5502 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5503 uint restore = RESTORE;
5504 uint restore_timer = RESTORE_TIMER;
5505 uint restore_disable = RESTORE_DISABLE;
5506 uint status = STATUS;
5507 uint status_timer = STATUS_TIMER;
5508 uint status_automat = STATUS_AUTOMAT;
5509 uint loopback = LOOPBACK;
5510 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5511 char *session = NULL;
5512 uint hex_charset = HEX_CHARSET;
5513 uint hex_salt = HEX_SALT;
5514 uint hex_wordlist = HEX_WORDLIST;
5515 uint rp_gen = RP_GEN;
5516 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5517 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5518 uint rp_gen_seed = RP_GEN_SEED;
5519 char *rule_buf_l = (char *) RULE_BUF_L;
5520 char *rule_buf_r = (char *) RULE_BUF_R;
5521 uint increment = INCREMENT;
5522 uint increment_min = INCREMENT_MIN;
5523 uint increment_max = INCREMENT_MAX;
5524 char *cpu_affinity = NULL;
5525 OCL_PTR *ocl = NULL;
5526 char *opencl_devices = NULL;
5527 char *opencl_platforms = NULL;
5528 char *opencl_device_types = NULL;
5529 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5530 char *truecrypt_keyfiles = NULL;
5531 uint workload_profile = WORKLOAD_PROFILE;
5532 uint kernel_accel = KERNEL_ACCEL;
5533 uint kernel_loops = KERNEL_LOOPS;
5534 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5535 #ifdef HAVE_HWMON
5536 uint gpu_temp_abort = GPU_TEMP_ABORT;
5537 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5538 #ifdef HAVE_ADL
5539 uint powertune_enable = POWERTUNE_ENABLE;
5540 #endif
5541 #endif
5542 uint logfile_disable = LOGFILE_DISABLE;
5543 uint segment_size = SEGMENT_SIZE;
5544 uint scrypt_tmto = SCRYPT_TMTO;
5545 char separator = SEPARATOR;
5546 uint bitmap_min = BITMAP_MIN;
5547 uint bitmap_max = BITMAP_MAX;
5548 char *custom_charset_1 = NULL;
5549 char *custom_charset_2 = NULL;
5550 char *custom_charset_3 = NULL;
5551 char *custom_charset_4 = NULL;
5552
5553 #define IDX_HELP 'h'
5554 #define IDX_VERSION 'V'
5555 #define IDX_VERSION_LOWER 'v'
5556 #define IDX_QUIET 0xff02
5557 #define IDX_SHOW 0xff03
5558 #define IDX_LEFT 0xff04
5559 #define IDX_REMOVE 0xff05
5560 #define IDX_REMOVE_TIMER 0xff37
5561 #define IDX_SKIP 's'
5562 #define IDX_LIMIT 'l'
5563 #define IDX_KEYSPACE 0xff35
5564 #define IDX_POTFILE_DISABLE 0xff06
5565 #define IDX_DEBUG_MODE 0xff43
5566 #define IDX_DEBUG_FILE 0xff44
5567 #define IDX_INDUCTION_DIR 0xff46
5568 #define IDX_OUTFILE_CHECK_DIR 0xff47
5569 #define IDX_USERNAME 0xff07
5570 #define IDX_FORCE 0xff08
5571 #define IDX_RUNTIME 0xff09
5572 #define IDX_BENCHMARK 'b'
5573 #define IDX_BENCHMARK_REPEATS 0xff78
5574 #define IDX_HASH_MODE 'm'
5575 #define IDX_ATTACK_MODE 'a'
5576 #define IDX_RP_FILE 'r'
5577 #define IDX_RP_GEN 'g'
5578 #define IDX_RP_GEN_FUNC_MIN 0xff10
5579 #define IDX_RP_GEN_FUNC_MAX 0xff11
5580 #define IDX_RP_GEN_SEED 0xff34
5581 #define IDX_RULE_BUF_L 'j'
5582 #define IDX_RULE_BUF_R 'k'
5583 #define IDX_INCREMENT 'i'
5584 #define IDX_INCREMENT_MIN 0xff12
5585 #define IDX_INCREMENT_MAX 0xff13
5586 #define IDX_OUTFILE 'o'
5587 #define IDX_OUTFILE_FORMAT 0xff14
5588 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5589 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5590 #define IDX_RESTORE 0xff15
5591 #define IDX_RESTORE_DISABLE 0xff27
5592 #define IDX_STATUS 0xff17
5593 #define IDX_STATUS_TIMER 0xff18
5594 #define IDX_STATUS_AUTOMAT 0xff50
5595 #define IDX_LOOPBACK 0xff38
5596 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5597 #define IDX_SESSION 0xff19
5598 #define IDX_HEX_CHARSET 0xff20
5599 #define IDX_HEX_SALT 0xff21
5600 #define IDX_HEX_WORDLIST 0xff40
5601 #define IDX_MARKOV_DISABLE 0xff22
5602 #define IDX_MARKOV_CLASSIC 0xff23
5603 #define IDX_MARKOV_THRESHOLD 't'
5604 #define IDX_MARKOV_HCSTAT 0xff24
5605 #define IDX_CPU_AFFINITY 0xff25
5606 #define IDX_OPENCL_DEVICES 'd'
5607 #define IDX_OPENCL_PLATFORMS 0xff72
5608 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5609 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5610 #define IDX_WORKLOAD_PROFILE 'w'
5611 #define IDX_KERNEL_ACCEL 'n'
5612 #define IDX_KERNEL_LOOPS 'u'
5613 #define IDX_GPU_TEMP_DISABLE 0xff29
5614 #define IDX_GPU_TEMP_ABORT 0xff30
5615 #define IDX_GPU_TEMP_RETAIN 0xff31
5616 #define IDX_POWERTUNE_ENABLE 0xff41
5617 #define IDX_LOGFILE_DISABLE 0xff51
5618 #define IDX_TRUECRYPT_KEYFILES 0xff52
5619 #define IDX_SCRYPT_TMTO 0xff61
5620 #define IDX_SEGMENT_SIZE 'c'
5621 #define IDX_SEPARATOR 'p'
5622 #define IDX_BITMAP_MIN 0xff70
5623 #define IDX_BITMAP_MAX 0xff71
5624 #define IDX_CUSTOM_CHARSET_1 '1'
5625 #define IDX_CUSTOM_CHARSET_2 '2'
5626 #define IDX_CUSTOM_CHARSET_3 '3'
5627 #define IDX_CUSTOM_CHARSET_4 '4'
5628
5629 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5630
5631 struct option long_options[] =
5632 {
5633 {"help", no_argument, 0, IDX_HELP},
5634 {"version", no_argument, 0, IDX_VERSION},
5635 {"quiet", no_argument, 0, IDX_QUIET},
5636 {"show", no_argument, 0, IDX_SHOW},
5637 {"left", no_argument, 0, IDX_LEFT},
5638 {"username", no_argument, 0, IDX_USERNAME},
5639 {"remove", no_argument, 0, IDX_REMOVE},
5640 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5641 {"skip", required_argument, 0, IDX_SKIP},
5642 {"limit", required_argument, 0, IDX_LIMIT},
5643 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5644 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5645 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5646 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5647 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5648 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5649 {"force", no_argument, 0, IDX_FORCE},
5650 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5651 {"benchmark-repeats", required_argument, 0, IDX_BENCHMARK_REPEATS},
5652 {"restore", no_argument, 0, IDX_RESTORE},
5653 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5654 {"status", no_argument, 0, IDX_STATUS},
5655 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5656 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5657 {"loopback", no_argument, 0, IDX_LOOPBACK},
5658 {"weak-hash-threshold",
5659 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5660 {"session", required_argument, 0, IDX_SESSION},
5661 {"runtime", required_argument, 0, IDX_RUNTIME},
5662 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5663 {"generate-rules-func-min",
5664 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5665 {"generate-rules-func-max",
5666 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5667 {"generate-rules-seed",
5668 required_argument, 0, IDX_RP_GEN_SEED},
5669 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5670 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5671 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5672 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5673 {"rules-file", required_argument, 0, IDX_RP_FILE},
5674 {"outfile", required_argument, 0, IDX_OUTFILE},
5675 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5676 {"outfile-autohex-disable",
5677 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5678 {"outfile-check-timer",
5679 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5680 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5681 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5682 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5683 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5684 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5685 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5686 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5687 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5688 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5689 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5690 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5691 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5692 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5693 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5694 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5695 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5696 #ifdef HAVE_HWMON
5697 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5698 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5699 #ifdef HAVE_ADL
5700 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5701 #endif
5702 #endif // HAVE_HWMON
5703 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5704 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5705 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5706 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5707 // deprecated
5708 {"seperator", required_argument, 0, IDX_SEPARATOR},
5709 {"separator", required_argument, 0, IDX_SEPARATOR},
5710 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5711 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5712 {"increment", no_argument, 0, IDX_INCREMENT},
5713 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5714 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5715 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5716 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5717 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5718 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5719
5720 {0, 0, 0, 0}
5721 };
5722
5723 uint rp_files_cnt = 0;
5724
5725 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5726
5727 int option_index = 0;
5728 int c = -1;
5729
5730 optind = 1;
5731 optopt = 0;
5732
5733 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5734 {
5735 switch (c)
5736 {
5737 case IDX_HELP: usage = 1; break;
5738 case IDX_VERSION:
5739 case IDX_VERSION_LOWER: version = 1; break;
5740 case IDX_RESTORE: restore = 1; break;
5741 case IDX_SESSION: session = optarg; break;
5742 case IDX_SHOW: show = 1; break;
5743 case IDX_LEFT: left = 1; break;
5744 case '?': return (-1);
5745 }
5746 }
5747
5748 if (optopt != 0)
5749 {
5750 log_error ("ERROR: Invalid argument specified");
5751
5752 return (-1);
5753 }
5754
5755 /**
5756 * exit functions
5757 */
5758
5759 if (version)
5760 {
5761 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5762
5763 return (0);
5764 }
5765
5766 if (usage)
5767 {
5768 usage_big_print (PROGNAME);
5769
5770 return (0);
5771 }
5772
5773 /**
5774 * session needs to be set, always!
5775 */
5776
5777 if (session == NULL) session = (char *) PROGNAME;
5778
5779 /**
5780 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5781 */
5782
5783 char *exec_path = get_exec_path ();
5784
5785 #ifdef LINUX
5786
5787 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5788 char *resolved_exec_path = realpath (exec_path, NULL);
5789
5790 char *install_dir = get_install_dir (resolved_exec_path);
5791 char *profile_dir = NULL;
5792 char *session_dir = NULL;
5793 char *shared_dir = NULL;
5794
5795 if (strcmp (install_dir, resolved_install_folder) == 0)
5796 {
5797 struct passwd *pw = getpwuid (getuid ());
5798
5799 const char *homedir = pw->pw_dir;
5800
5801 profile_dir = get_profile_dir (homedir);
5802 session_dir = get_session_dir (profile_dir);
5803 shared_dir = strdup (SHARED_FOLDER);
5804
5805 mkdir (profile_dir, 0700);
5806 mkdir (session_dir, 0700);
5807 }
5808 else
5809 {
5810 profile_dir = install_dir;
5811 session_dir = install_dir;
5812 shared_dir = install_dir;
5813 }
5814
5815 myfree (resolved_install_folder);
5816 myfree (resolved_exec_path);
5817
5818 #else
5819
5820 char *install_dir = get_install_dir (exec_path);
5821 char *profile_dir = install_dir;
5822 char *session_dir = install_dir;
5823 char *shared_dir = install_dir;
5824
5825 #endif
5826
5827 data.install_dir = install_dir;
5828 data.profile_dir = profile_dir;
5829 data.session_dir = session_dir;
5830 data.shared_dir = shared_dir;
5831
5832 myfree (exec_path);
5833
5834 /**
5835 * kernel cache, we need to make sure folder exist
5836 */
5837
5838 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5839
5840 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5841
5842 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5843
5844 mkdir (kernels_folder, 0700);
5845
5846 myfree (kernels_folder);
5847
5848 /**
5849 * session
5850 */
5851
5852 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5853
5854 data.session = session;
5855
5856 char *eff_restore_file = (char *) mymalloc (session_size);
5857 char *new_restore_file = (char *) mymalloc (session_size);
5858
5859 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5860 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5861
5862 data.eff_restore_file = eff_restore_file;
5863 data.new_restore_file = new_restore_file;
5864
5865 if (((show == 1) || (left == 1)) && (restore == 1))
5866 {
5867 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5868 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5869
5870 return (-1);
5871 }
5872
5873 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5874 if ((show == 1) || (left == 1))
5875 {
5876 restore_disable = 1;
5877
5878 restore = 0;
5879 }
5880
5881 data.restore_disable = restore_disable;
5882
5883 restore_data_t *rd = init_restore (argc, argv);
5884
5885 data.rd = rd;
5886
5887 /**
5888 * restore file
5889 */
5890
5891 if (restore == 1)
5892 {
5893 read_restore (eff_restore_file, rd);
5894
5895 if (rd->version_bin < RESTORE_MIN)
5896 {
5897 log_error ("ERROR: Incompatible restore-file version");
5898
5899 return (-1);
5900 }
5901
5902 myargc = rd->argc;
5903 myargv = rd->argv;
5904
5905 #ifdef _POSIX
5906 rd->pid = getpid ();
5907 #elif _WIN
5908 rd->pid = GetCurrentProcessId ();
5909 #endif
5910 }
5911
5912 uint hash_mode_chgd = 0;
5913 uint runtime_chgd = 0;
5914 uint kernel_loops_chgd = 0;
5915 uint kernel_accel_chgd = 0;
5916 uint attack_mode_chgd = 0;
5917 uint outfile_format_chgd = 0;
5918 uint rp_gen_seed_chgd = 0;
5919 uint remove_timer_chgd = 0;
5920 uint increment_min_chgd = 0;
5921 uint increment_max_chgd = 0;
5922 uint workload_profile_chgd = 0;
5923 uint opencl_vector_width_chgd = 0;
5924
5925 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5926 uint gpu_temp_retain_chgd = 0;
5927 uint gpu_temp_abort_chgd = 0;
5928 #endif
5929
5930 optind = 1;
5931 optopt = 0;
5932 option_index = 0;
5933
5934 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5935 {
5936 switch (c)
5937 {
5938 //case IDX_HELP: usage = 1; break;
5939 //case IDX_VERSION: version = 1; break;
5940 //case IDX_RESTORE: restore = 1; break;
5941 case IDX_QUIET: quiet = 1; break;
5942 //case IDX_SHOW: show = 1; break;
5943 case IDX_SHOW: break;
5944 //case IDX_LEFT: left = 1; break;
5945 case IDX_LEFT: break;
5946 case IDX_USERNAME: username = 1; break;
5947 case IDX_REMOVE: remove = 1; break;
5948 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5949 remove_timer_chgd = 1; break;
5950 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5951 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5952 case IDX_DEBUG_FILE: debug_file = optarg; break;
5953 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5954 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5955 case IDX_FORCE: force = 1; break;
5956 case IDX_SKIP: skip = atoll (optarg); break;
5957 case IDX_LIMIT: limit = atoll (optarg); break;
5958 case IDX_KEYSPACE: keyspace = 1; break;
5959 case IDX_BENCHMARK: benchmark = 1; break;
5960 case IDX_BENCHMARK_REPEATS: benchmark_repeats = atoi (optarg); break;
5961 case IDX_RESTORE: break;
5962 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5963 case IDX_STATUS: status = 1; break;
5964 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5965 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5966 case IDX_LOOPBACK: loopback = 1; break;
5967 case IDX_WEAK_HASH_THRESHOLD:
5968 weak_hash_threshold = atoi (optarg); break;
5969 //case IDX_SESSION: session = optarg; break;
5970 case IDX_SESSION: break;
5971 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5972 hash_mode_chgd = 1; break;
5973 case IDX_RUNTIME: runtime = atoi (optarg);
5974 runtime_chgd = 1; break;
5975 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5976 attack_mode_chgd = 1; break;
5977 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5978 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5979 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5980 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5981 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5982 rp_gen_seed_chgd = 1; break;
5983 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5984 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5985 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5986 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5987 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5988 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5989 case IDX_OUTFILE: outfile = optarg; break;
5990 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5991 outfile_format_chgd = 1; break;
5992 case IDX_OUTFILE_AUTOHEX_DISABLE:
5993 outfile_autohex = 0; break;
5994 case IDX_OUTFILE_CHECK_TIMER:
5995 outfile_check_timer = atoi (optarg); break;
5996 case IDX_HEX_CHARSET: hex_charset = 1; break;
5997 case IDX_HEX_SALT: hex_salt = 1; break;
5998 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5999 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6000 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6001 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6002 case IDX_OPENCL_DEVICE_TYPES:
6003 opencl_device_types = optarg; break;
6004 case IDX_OPENCL_VECTOR_WIDTH:
6005 opencl_vector_width = atoi (optarg);
6006 opencl_vector_width_chgd = 1; break;
6007 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6008 workload_profile_chgd = 1; break;
6009 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6010 kernel_accel_chgd = 1; break;
6011 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6012 kernel_loops_chgd = 1; break;
6013 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6014 #ifdef HAVE_HWMON
6015 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6016 #ifdef HAVE_ADL
6017 gpu_temp_abort_chgd = 1;
6018 #endif
6019 break;
6020 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6021 #ifdef HAVE_ADL
6022 gpu_temp_retain_chgd = 1;
6023 #endif
6024 break;
6025 #ifdef HAVE_ADL
6026 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6027 #endif
6028 #endif // HAVE_HWMON
6029 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6030 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6031 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6032 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6033 case IDX_SEPARATOR: separator = optarg[0]; break;
6034 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6035 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6036 case IDX_INCREMENT: increment = 1; break;
6037 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6038 increment_min_chgd = 1; break;
6039 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6040 increment_max_chgd = 1; break;
6041 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6042 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6043 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6044 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6045
6046 default:
6047 log_error ("ERROR: Invalid argument specified");
6048 return (-1);
6049 }
6050 }
6051
6052 if (optopt != 0)
6053 {
6054 log_error ("ERROR: Invalid argument specified");
6055
6056 return (-1);
6057 }
6058
6059 /**
6060 * Inform user things getting started,
6061 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6062 * - we do not need to check algorithm_pos
6063 */
6064
6065 if (quiet == 0)
6066 {
6067 if (benchmark == 1)
6068 {
6069 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6070
6071 log_info ("");
6072 }
6073 else if (restore == 1)
6074 {
6075 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6076
6077 log_info ("");
6078 }
6079 else
6080 {
6081 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6082
6083 log_info ("");
6084 }
6085 }
6086
6087 /**
6088 * sanity check
6089 */
6090
6091 if (attack_mode > 7)
6092 {
6093 log_error ("ERROR: Invalid attack-mode specified");
6094
6095 return (-1);
6096 }
6097
6098 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6099 {
6100 log_error ("ERROR: Invalid runtime specified");
6101
6102 return (-1);
6103 }
6104
6105 if (hash_mode_chgd && hash_mode > 13100) // just added to remove compiler warnings for hash_mode_chgd
6106 {
6107 log_error ("ERROR: Invalid hash-type specified");
6108
6109 return (-1);
6110 }
6111
6112 // renamed hash modes
6113
6114 if (hash_mode_chgd)
6115 {
6116 int n = -1;
6117
6118 switch (hash_mode)
6119 {
6120 case 123: n = 124;
6121 break;
6122 }
6123
6124 if (n >= 0)
6125 {
6126 log_error ("Old -m specified, use -m %d instead", n);
6127
6128 return (-1);
6129 }
6130 }
6131
6132 if (username == 1)
6133 {
6134 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6135 {
6136 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6137
6138 return (-1);
6139 }
6140 }
6141
6142 if (outfile_format > 16)
6143 {
6144 log_error ("ERROR: Invalid outfile-format specified");
6145
6146 return (-1);
6147 }
6148
6149 if (left == 1)
6150 {
6151 if (outfile_format_chgd == 1)
6152 {
6153 if (outfile_format > 1)
6154 {
6155 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6156
6157 return (-1);
6158 }
6159 }
6160 else
6161 {
6162 outfile_format = OUTFILE_FMT_HASH;
6163 }
6164 }
6165
6166 if (show == 1)
6167 {
6168 if (outfile_format_chgd == 1)
6169 {
6170 if ((outfile_format > 7) && (outfile_format < 16))
6171 {
6172 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6173
6174 return (-1);
6175 }
6176 }
6177 }
6178
6179 if (increment_min < INCREMENT_MIN)
6180 {
6181 log_error ("ERROR: Invalid increment-min specified");
6182
6183 return (-1);
6184 }
6185
6186 if (increment_max > INCREMENT_MAX)
6187 {
6188 log_error ("ERROR: Invalid increment-max specified");
6189
6190 return (-1);
6191 }
6192
6193 if (increment_min > increment_max)
6194 {
6195 log_error ("ERROR: Invalid increment-min specified");
6196
6197 return (-1);
6198 }
6199
6200 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6201 {
6202 log_error ("ERROR: increment is not allowed in attack-mode 0");
6203
6204 return (-1);
6205 }
6206
6207 if ((increment == 0) && (increment_min_chgd == 1))
6208 {
6209 log_error ("ERROR: increment-min is only supported together with increment switch");
6210
6211 return (-1);
6212 }
6213
6214 if ((increment == 0) && (increment_max_chgd == 1))
6215 {
6216 log_error ("ERROR: increment-max is only supported together with increment switch");
6217
6218 return (-1);
6219 }
6220
6221 if (rp_files_cnt && rp_gen)
6222 {
6223 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6224
6225 return (-1);
6226 }
6227
6228 if (rp_files_cnt || rp_gen)
6229 {
6230 if (attack_mode != ATTACK_MODE_STRAIGHT)
6231 {
6232 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6233
6234 return (-1);
6235 }
6236 }
6237
6238 if (rp_gen_func_min > rp_gen_func_max)
6239 {
6240 log_error ("ERROR: Invalid rp-gen-func-min specified");
6241
6242 return (-1);
6243 }
6244
6245 if (kernel_accel_chgd == 1)
6246 {
6247 if (kernel_accel < 1)
6248 {
6249 log_error ("ERROR: Invalid kernel-accel specified");
6250
6251 return (-1);
6252 }
6253
6254 if (kernel_accel > 1024)
6255 {
6256 log_error ("ERROR: Invalid kernel-accel specified");
6257
6258 return (-1);
6259 }
6260 }
6261
6262 if (kernel_loops_chgd == 1)
6263 {
6264 if (kernel_loops < 1)
6265 {
6266 log_error ("ERROR: Invalid kernel-loops specified");
6267
6268 return (-1);
6269 }
6270
6271 if (kernel_loops > 1024)
6272 {
6273 log_error ("ERROR: Invalid kernel-loops specified");
6274
6275 return (-1);
6276 }
6277 }
6278
6279 if ((workload_profile < 1) || (workload_profile > 3))
6280 {
6281 log_error ("ERROR: workload-profile %i not available", workload_profile);
6282
6283 return (-1);
6284 }
6285
6286 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6287 {
6288 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6289
6290 return (-1);
6291 }
6292
6293 if (show == 1 || left == 1)
6294 {
6295 attack_mode = ATTACK_MODE_NONE;
6296
6297 if (remove == 1)
6298 {
6299 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6300
6301 return (-1);
6302 }
6303
6304 if (potfile_disable == 1)
6305 {
6306 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6307
6308 return (-1);
6309 }
6310 }
6311
6312 uint attack_kern = ATTACK_KERN_NONE;
6313
6314 switch (attack_mode)
6315 {
6316 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6317 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6318 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6319 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6320 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6321 }
6322
6323 if (benchmark == 0)
6324 {
6325 if (keyspace == 1)
6326 {
6327 int num_additional_params = 1;
6328
6329 if (attack_kern == ATTACK_KERN_COMBI)
6330 {
6331 num_additional_params = 2;
6332 }
6333
6334 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6335
6336 if (keyspace_wordlist_specified == 0) optind--;
6337 }
6338
6339 if (attack_kern == ATTACK_KERN_NONE)
6340 {
6341 if ((optind + 1) != myargc)
6342 {
6343 usage_mini_print (myargv[0]);
6344
6345 return (-1);
6346 }
6347 }
6348 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6349 {
6350 if ((optind + 1) > myargc)
6351 {
6352 usage_mini_print (myargv[0]);
6353
6354 return (-1);
6355 }
6356 }
6357 else if (attack_kern == ATTACK_KERN_COMBI)
6358 {
6359 if ((optind + 3) != myargc)
6360 {
6361 usage_mini_print (myargv[0]);
6362
6363 return (-1);
6364 }
6365 }
6366 else if (attack_kern == ATTACK_KERN_BF)
6367 {
6368 if ((optind + 1) > myargc)
6369 {
6370 usage_mini_print (myargv[0]);
6371
6372 return (-1);
6373 }
6374 }
6375 else
6376 {
6377 usage_mini_print (myargv[0]);
6378
6379 return (-1);
6380 }
6381 }
6382 else
6383 {
6384 if (myargv[optind] != 0)
6385 {
6386 log_error ("ERROR: Invalid argument for benchmark mode specified");
6387
6388 return (-1);
6389 }
6390
6391 if (attack_mode_chgd == 1)
6392 {
6393 if (attack_mode != ATTACK_MODE_BF)
6394 {
6395 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6396
6397 return (-1);
6398 }
6399 }
6400 }
6401
6402 if (skip != 0 && limit != 0)
6403 {
6404 limit += skip;
6405 }
6406
6407 if (keyspace == 1)
6408 {
6409 if (show == 1)
6410 {
6411 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6412
6413 return (-1);
6414 }
6415 else if (left == 1)
6416 {
6417 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6418
6419 return (-1);
6420 }
6421
6422 potfile_disable = 1;
6423
6424 restore_disable = 1;
6425
6426 restore = 0;
6427
6428 weak_hash_threshold = 0;
6429
6430 quiet = 1;
6431 }
6432
6433 if (remove_timer_chgd == 1)
6434 {
6435 if (remove == 0)
6436 {
6437 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6438
6439 return (-1);
6440 }
6441
6442 if (remove_timer < 1)
6443 {
6444 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6445
6446 return (-1);
6447 }
6448 }
6449
6450 if (loopback == 1)
6451 {
6452 if (attack_mode == ATTACK_MODE_BF)
6453 {
6454 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6455
6456 return (-1);
6457 }
6458 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6459 {
6460 if ((rp_files_cnt == 0) && (rp_gen == 0))
6461 {
6462 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6463
6464 return (-1);
6465 }
6466 }
6467 }
6468
6469 if (debug_mode > 0)
6470 {
6471 if (attack_mode != ATTACK_MODE_STRAIGHT)
6472 {
6473 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6474
6475 return (-1);
6476 }
6477
6478 if ((rp_files_cnt == 0) && (rp_gen == 0))
6479 {
6480 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6481
6482 return (-1);
6483 }
6484 }
6485
6486 if (debug_mode > 4)
6487 {
6488 log_error ("ERROR: Invalid debug-mode specified");
6489
6490 return (-1);
6491 }
6492
6493 if (debug_file != NULL)
6494 {
6495 if (debug_mode < 1)
6496 {
6497 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6498
6499 return (-1);
6500 }
6501 }
6502
6503 if (induction_dir != NULL)
6504 {
6505 if (attack_mode == ATTACK_MODE_BF)
6506 {
6507 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6508
6509 return (-1);
6510 }
6511 }
6512
6513 if (attack_mode != ATTACK_MODE_STRAIGHT)
6514 {
6515 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6516 {
6517 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6518
6519 return (-1);
6520 }
6521
6522 weak_hash_threshold = 0;
6523 }
6524
6525 /**
6526 * induction directory
6527 */
6528
6529 char *induction_directory = NULL;
6530
6531 if (attack_mode != ATTACK_MODE_BF)
6532 {
6533 if (induction_dir == NULL)
6534 {
6535 induction_directory = (char *) mymalloc (session_size);
6536
6537 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6538
6539 // create induction folder if it does not already exist
6540
6541 if (keyspace == 0)
6542 {
6543 if (rmdir (induction_directory) == -1)
6544 {
6545 if (errno == ENOENT)
6546 {
6547 // good, we can ignore
6548 }
6549 else if (errno == ENOTEMPTY)
6550 {
6551 char *induction_directory_mv = (char *) mymalloc (session_size);
6552
6553 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6554
6555 if (rename (induction_directory, induction_directory_mv) != 0)
6556 {
6557 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6558
6559 return (-1);
6560 }
6561 }
6562 else
6563 {
6564 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6565
6566 return (-1);
6567 }
6568 }
6569
6570 if (mkdir (induction_directory, 0700) == -1)
6571 {
6572 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6573
6574 return (-1);
6575 }
6576 }
6577 }
6578 else
6579 {
6580 induction_directory = induction_dir;
6581 }
6582 }
6583
6584 data.induction_directory = induction_directory;
6585
6586 /**
6587 * loopback
6588 */
6589
6590 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6591
6592 char *loopback_file = (char *) mymalloc (loopback_size);
6593
6594 /**
6595 * tuning db
6596 */
6597
6598 char tuning_db_file[256] = { 0 };
6599
6600 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6601
6602 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6603
6604 /**
6605 * outfile-check directory
6606 */
6607
6608 char *outfile_check_directory = NULL;
6609
6610 if (outfile_check_dir == NULL)
6611 {
6612 outfile_check_directory = (char *) mymalloc (session_size);
6613
6614 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6615 }
6616 else
6617 {
6618 outfile_check_directory = outfile_check_dir;
6619 }
6620
6621 data.outfile_check_directory = outfile_check_directory;
6622
6623 if (keyspace == 0)
6624 {
6625 struct stat outfile_check_stat;
6626
6627 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6628 {
6629 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6630
6631 if (is_dir == 0)
6632 {
6633 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6634
6635 return (-1);
6636 }
6637 }
6638 else if (outfile_check_dir == NULL)
6639 {
6640 if (mkdir (outfile_check_directory, 0700) == -1)
6641 {
6642 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6643
6644 return (-1);
6645 }
6646 }
6647 }
6648
6649 /**
6650 * special other stuff
6651 */
6652
6653 if (hash_mode == 9710)
6654 {
6655 outfile_format = 5;
6656 outfile_format_chgd = 1;
6657 }
6658
6659 if (hash_mode == 9810)
6660 {
6661 outfile_format = 5;
6662 outfile_format_chgd = 1;
6663 }
6664
6665 if (hash_mode == 10410)
6666 {
6667 outfile_format = 5;
6668 outfile_format_chgd = 1;
6669 }
6670
6671 /**
6672 * store stuff
6673 */
6674
6675 data.hash_mode = hash_mode;
6676 data.restore = restore;
6677 data.restore_timer = restore_timer;
6678 data.restore_disable = restore_disable;
6679 data.status = status;
6680 data.status_timer = status_timer;
6681 data.status_automat = status_automat;
6682 data.loopback = loopback;
6683 data.runtime = runtime;
6684 data.remove = remove;
6685 data.remove_timer = remove_timer;
6686 data.debug_mode = debug_mode;
6687 data.debug_file = debug_file;
6688 data.username = username;
6689 data.quiet = quiet;
6690 data.outfile = outfile;
6691 data.outfile_format = outfile_format;
6692 data.outfile_autohex = outfile_autohex;
6693 data.hex_charset = hex_charset;
6694 data.hex_salt = hex_salt;
6695 data.hex_wordlist = hex_wordlist;
6696 data.separator = separator;
6697 data.rp_files = rp_files;
6698 data.rp_files_cnt = rp_files_cnt;
6699 data.rp_gen = rp_gen;
6700 data.rp_gen_seed = rp_gen_seed;
6701 data.force = force;
6702 data.benchmark = benchmark;
6703 data.benchmark_repeats = benchmark_repeats;
6704 data.skip = skip;
6705 data.limit = limit;
6706 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6707 data.powertune_enable = powertune_enable;
6708 #endif
6709 data.logfile_disable = logfile_disable;
6710 data.truecrypt_keyfiles = truecrypt_keyfiles;
6711 data.scrypt_tmto = scrypt_tmto;
6712 data.workload_profile = workload_profile;
6713
6714 /**
6715 * cpu affinity
6716 */
6717
6718 if (cpu_affinity)
6719 {
6720 set_cpu_affinity (cpu_affinity);
6721 }
6722
6723 if (rp_gen_seed_chgd == 0)
6724 {
6725 srand (proc_start);
6726 }
6727 else
6728 {
6729 srand (rp_gen_seed);
6730 }
6731
6732 /**
6733 * logfile init
6734 */
6735
6736 if (logfile_disable == 0)
6737 {
6738 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6739
6740 char *logfile = (char *) mymalloc (logfile_size);
6741
6742 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6743
6744 data.logfile = logfile;
6745
6746 char *topid = logfile_generate_topid ();
6747
6748 data.topid = topid;
6749 }
6750
6751 // logfile_append() checks for logfile_disable internally to make it easier from here
6752
6753 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6754 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6755 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6756 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6757 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6758 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6759 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6760 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6761 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6762 #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));
6763
6764 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6765 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6766 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6767 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6768 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6769 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6770 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6771 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6772
6773 logfile_top_msg ("START");
6774
6775 logfile_top_uint (attack_mode);
6776 logfile_top_uint (attack_kern);
6777 logfile_top_uint (benchmark);
6778 logfile_top_uint (benchmark_repeats);
6779 logfile_top_uint (bitmap_min);
6780 logfile_top_uint (bitmap_max);
6781 logfile_top_uint (debug_mode);
6782 logfile_top_uint (force);
6783 logfile_top_uint (kernel_accel);
6784 logfile_top_uint (kernel_loops);
6785 logfile_top_uint (gpu_temp_disable);
6786 #ifdef HAVE_HWMON
6787 logfile_top_uint (gpu_temp_abort);
6788 logfile_top_uint (gpu_temp_retain);
6789 #endif
6790 logfile_top_uint (hash_mode);
6791 logfile_top_uint (hex_charset);
6792 logfile_top_uint (hex_salt);
6793 logfile_top_uint (hex_wordlist);
6794 logfile_top_uint (increment);
6795 logfile_top_uint (increment_max);
6796 logfile_top_uint (increment_min);
6797 logfile_top_uint (keyspace);
6798 logfile_top_uint (left);
6799 logfile_top_uint (logfile_disable);
6800 logfile_top_uint (loopback);
6801 logfile_top_uint (markov_classic);
6802 logfile_top_uint (markov_disable);
6803 logfile_top_uint (markov_threshold);
6804 logfile_top_uint (outfile_autohex);
6805 logfile_top_uint (outfile_check_timer);
6806 logfile_top_uint (outfile_format);
6807 logfile_top_uint (potfile_disable);
6808 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6809 logfile_top_uint (powertune_enable);
6810 #endif
6811 logfile_top_uint (scrypt_tmto);
6812 logfile_top_uint (quiet);
6813 logfile_top_uint (remove);
6814 logfile_top_uint (remove_timer);
6815 logfile_top_uint (restore);
6816 logfile_top_uint (restore_disable);
6817 logfile_top_uint (restore_timer);
6818 logfile_top_uint (rp_gen);
6819 logfile_top_uint (rp_gen_func_max);
6820 logfile_top_uint (rp_gen_func_min);
6821 logfile_top_uint (rp_gen_seed);
6822 logfile_top_uint (runtime);
6823 logfile_top_uint (segment_size);
6824 logfile_top_uint (show);
6825 logfile_top_uint (status);
6826 logfile_top_uint (status_automat);
6827 logfile_top_uint (status_timer);
6828 logfile_top_uint (usage);
6829 logfile_top_uint (username);
6830 logfile_top_uint (version);
6831 logfile_top_uint (weak_hash_threshold);
6832 logfile_top_uint (workload_profile);
6833 logfile_top_uint64 (limit);
6834 logfile_top_uint64 (skip);
6835 logfile_top_char (separator);
6836 logfile_top_string (cpu_affinity);
6837 logfile_top_string (custom_charset_1);
6838 logfile_top_string (custom_charset_2);
6839 logfile_top_string (custom_charset_3);
6840 logfile_top_string (custom_charset_4);
6841 logfile_top_string (debug_file);
6842 logfile_top_string (opencl_devices);
6843 logfile_top_string (opencl_platforms);
6844 logfile_top_string (opencl_device_types);
6845 logfile_top_uint (opencl_vector_width);
6846 logfile_top_string (induction_dir);
6847 logfile_top_string (markov_hcstat);
6848 logfile_top_string (outfile);
6849 logfile_top_string (outfile_check_dir);
6850 logfile_top_string (rule_buf_l);
6851 logfile_top_string (rule_buf_r);
6852 logfile_top_string (session);
6853 logfile_top_string (truecrypt_keyfiles);
6854
6855 /**
6856 * Init OpenCL library loader
6857 */
6858
6859 if (keyspace == 0)
6860 {
6861 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6862
6863 ocl_init (ocl);
6864
6865 data.ocl = ocl;
6866 }
6867
6868 /**
6869 * OpenCL platform selection
6870 */
6871
6872 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6873
6874 /**
6875 * OpenCL device selection
6876 */
6877
6878 u32 devices_filter = setup_devices_filter (opencl_devices);
6879
6880 /**
6881 * OpenCL device type selection
6882 */
6883
6884 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6885
6886 /**
6887 * benchmark
6888 */
6889
6890 if (benchmark == 1)
6891 {
6892 /**
6893 * disable useless stuff for benchmark
6894 */
6895
6896 status_timer = 0;
6897 restore_timer = 0;
6898 restore_disable = 1;
6899 potfile_disable = 1;
6900 weak_hash_threshold = 0;
6901 gpu_temp_disable = 1;
6902
6903 data.status_timer = status_timer;
6904 data.restore_timer = restore_timer;
6905 data.restore_disable = restore_disable;
6906
6907 /**
6908 * force attack mode to be bruteforce
6909 */
6910
6911 attack_mode = ATTACK_MODE_BF;
6912 attack_kern = ATTACK_KERN_BF;
6913
6914 if (workload_profile_chgd == 0)
6915 {
6916 workload_profile = 3;
6917
6918 data.workload_profile = workload_profile;
6919 }
6920 }
6921
6922 /**
6923 * config
6924 */
6925
6926 uint hash_type = 0;
6927 uint salt_type = 0;
6928 uint attack_exec = 0;
6929 uint opts_type = 0;
6930 uint kern_type = 0;
6931 uint dgst_size = 0;
6932 uint esalt_size = 0;
6933 uint opti_type = 0;
6934 uint dgst_pos0 = -1;
6935 uint dgst_pos1 = -1;
6936 uint dgst_pos2 = -1;
6937 uint dgst_pos3 = -1;
6938
6939 int (*parse_func) (char *, uint, hash_t *);
6940 int (*sort_by_digest) (const void *, const void *);
6941
6942 uint algorithm_pos = 0;
6943 uint algorithm_max = 1;
6944
6945 uint *algorithms = default_benchmark_algorithms;
6946
6947 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6948
6949 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6950 {
6951 /*
6952 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6953 * the following algos are skipped entirely
6954 */
6955
6956 if (algorithm_pos > 0)
6957 {
6958 local_free (rd);
6959
6960 rd = init_restore (argc, argv);
6961
6962 data.rd = rd;
6963 }
6964
6965 /**
6966 * update hash_mode in case of multihash benchmark
6967 */
6968
6969 if (benchmark == 1)
6970 {
6971 if (hash_mode_chgd == 0)
6972 {
6973 hash_mode = algorithms[algorithm_pos];
6974
6975 data.hash_mode = hash_mode;
6976 }
6977
6978 quiet = 1;
6979
6980 data.quiet = quiet;
6981 }
6982
6983 switch (hash_mode)
6984 {
6985 case 0: hash_type = HASH_TYPE_MD5;
6986 salt_type = SALT_TYPE_NONE;
6987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6988 opts_type = OPTS_TYPE_PT_GENERATE_LE
6989 | OPTS_TYPE_PT_ADD80
6990 | OPTS_TYPE_PT_ADDBITS14;
6991 kern_type = KERN_TYPE_MD5;
6992 dgst_size = DGST_SIZE_4_4;
6993 parse_func = md5_parse_hash;
6994 sort_by_digest = sort_by_digest_4_4;
6995 opti_type = OPTI_TYPE_ZERO_BYTE
6996 | OPTI_TYPE_PRECOMPUTE_INIT
6997 | OPTI_TYPE_PRECOMPUTE_MERKLE
6998 | OPTI_TYPE_MEET_IN_MIDDLE
6999 | OPTI_TYPE_EARLY_SKIP
7000 | OPTI_TYPE_NOT_ITERATED
7001 | OPTI_TYPE_NOT_SALTED
7002 | OPTI_TYPE_RAW_HASH;
7003 dgst_pos0 = 0;
7004 dgst_pos1 = 3;
7005 dgst_pos2 = 2;
7006 dgst_pos3 = 1;
7007 break;
7008
7009 case 10: hash_type = HASH_TYPE_MD5;
7010 salt_type = SALT_TYPE_INTERN;
7011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7012 opts_type = OPTS_TYPE_PT_GENERATE_LE
7013 | OPTS_TYPE_ST_ADD80
7014 | OPTS_TYPE_ST_ADDBITS14;
7015 kern_type = KERN_TYPE_MD5_PWSLT;
7016 dgst_size = DGST_SIZE_4_4;
7017 parse_func = md5s_parse_hash;
7018 sort_by_digest = sort_by_digest_4_4;
7019 opti_type = OPTI_TYPE_ZERO_BYTE
7020 | OPTI_TYPE_PRECOMPUTE_INIT
7021 | OPTI_TYPE_PRECOMPUTE_MERKLE
7022 | OPTI_TYPE_MEET_IN_MIDDLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_APPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 0;
7028 dgst_pos1 = 3;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 11: hash_type = HASH_TYPE_MD5;
7034 salt_type = SALT_TYPE_INTERN;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_LE
7037 | OPTS_TYPE_ST_ADD80
7038 | OPTS_TYPE_ST_ADDBITS14;
7039 kern_type = KERN_TYPE_MD5_PWSLT;
7040 dgst_size = DGST_SIZE_4_4;
7041 parse_func = joomla_parse_hash;
7042 sort_by_digest = sort_by_digest_4_4;
7043 opti_type = OPTI_TYPE_ZERO_BYTE
7044 | OPTI_TYPE_PRECOMPUTE_INIT
7045 | OPTI_TYPE_PRECOMPUTE_MERKLE
7046 | OPTI_TYPE_MEET_IN_MIDDLE
7047 | OPTI_TYPE_EARLY_SKIP
7048 | OPTI_TYPE_NOT_ITERATED
7049 | OPTI_TYPE_APPENDED_SALT
7050 | OPTI_TYPE_RAW_HASH;
7051 dgst_pos0 = 0;
7052 dgst_pos1 = 3;
7053 dgst_pos2 = 2;
7054 dgst_pos3 = 1;
7055 break;
7056
7057 case 12: hash_type = HASH_TYPE_MD5;
7058 salt_type = SALT_TYPE_INTERN;
7059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7060 opts_type = OPTS_TYPE_PT_GENERATE_LE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS14;
7063 kern_type = KERN_TYPE_MD5_PWSLT;
7064 dgst_size = DGST_SIZE_4_4;
7065 parse_func = postgresql_parse_hash;
7066 sort_by_digest = sort_by_digest_4_4;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_MEET_IN_MIDDLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 0;
7076 dgst_pos1 = 3;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 20: hash_type = HASH_TYPE_MD5;
7082 salt_type = SALT_TYPE_INTERN;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_LE
7085 | OPTS_TYPE_PT_ADD80
7086 | OPTS_TYPE_PT_ADDBITS14;
7087 kern_type = KERN_TYPE_MD5_SLTPW;
7088 dgst_size = DGST_SIZE_4_4;
7089 parse_func = md5s_parse_hash;
7090 sort_by_digest = sort_by_digest_4_4;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_EARLY_SKIP
7095 | OPTI_TYPE_NOT_ITERATED
7096 | OPTI_TYPE_PREPENDED_SALT
7097 | OPTI_TYPE_RAW_HASH;
7098 dgst_pos0 = 0;
7099 dgst_pos1 = 3;
7100 dgst_pos2 = 2;
7101 dgst_pos3 = 1;
7102 break;
7103
7104 case 21: hash_type = HASH_TYPE_MD5;
7105 salt_type = SALT_TYPE_INTERN;
7106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7107 opts_type = OPTS_TYPE_PT_GENERATE_LE
7108 | OPTS_TYPE_PT_ADD80
7109 | OPTS_TYPE_PT_ADDBITS14;
7110 kern_type = KERN_TYPE_MD5_SLTPW;
7111 dgst_size = DGST_SIZE_4_4;
7112 parse_func = osc_parse_hash;
7113 sort_by_digest = sort_by_digest_4_4;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_PRECOMPUTE_INIT
7116 | OPTI_TYPE_PRECOMPUTE_MERKLE
7117 | OPTI_TYPE_EARLY_SKIP
7118 | OPTI_TYPE_NOT_ITERATED
7119 | OPTI_TYPE_PREPENDED_SALT
7120 | OPTI_TYPE_RAW_HASH;
7121 dgst_pos0 = 0;
7122 dgst_pos1 = 3;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 22: hash_type = HASH_TYPE_MD5;
7128 salt_type = SALT_TYPE_EMBEDDED;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_LE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS14;
7133 kern_type = KERN_TYPE_MD5_SLTPW;
7134 dgst_size = DGST_SIZE_4_4;
7135 parse_func = netscreen_parse_hash;
7136 sort_by_digest = sort_by_digest_4_4;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_PRECOMPUTE_MERKLE
7140 | OPTI_TYPE_EARLY_SKIP
7141 | OPTI_TYPE_NOT_ITERATED
7142 | OPTI_TYPE_PREPENDED_SALT
7143 | OPTI_TYPE_RAW_HASH;
7144 dgst_pos0 = 0;
7145 dgst_pos1 = 3;
7146 dgst_pos2 = 2;
7147 dgst_pos3 = 1;
7148 break;
7149
7150 case 23: hash_type = HASH_TYPE_MD5;
7151 salt_type = SALT_TYPE_EMBEDDED;
7152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7153 opts_type = OPTS_TYPE_PT_GENERATE_LE
7154 | OPTS_TYPE_PT_ADD80
7155 | OPTS_TYPE_PT_ADDBITS14;
7156 kern_type = KERN_TYPE_MD5_SLTPW;
7157 dgst_size = DGST_SIZE_4_4;
7158 parse_func = skype_parse_hash;
7159 sort_by_digest = sort_by_digest_4_4;
7160 opti_type = OPTI_TYPE_ZERO_BYTE
7161 | OPTI_TYPE_PRECOMPUTE_INIT
7162 | OPTI_TYPE_PRECOMPUTE_MERKLE
7163 | OPTI_TYPE_EARLY_SKIP
7164 | OPTI_TYPE_NOT_ITERATED
7165 | OPTI_TYPE_PREPENDED_SALT
7166 | OPTI_TYPE_RAW_HASH;
7167 dgst_pos0 = 0;
7168 dgst_pos1 = 3;
7169 dgst_pos2 = 2;
7170 dgst_pos3 = 1;
7171 break;
7172
7173 case 30: hash_type = HASH_TYPE_MD5;
7174 salt_type = SALT_TYPE_INTERN;
7175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7176 opts_type = OPTS_TYPE_PT_GENERATE_LE
7177 | OPTS_TYPE_PT_UNICODE
7178 | OPTS_TYPE_ST_ADD80
7179 | OPTS_TYPE_ST_ADDBITS14;
7180 kern_type = KERN_TYPE_MD5_PWUSLT;
7181 dgst_size = DGST_SIZE_4_4;
7182 parse_func = md5s_parse_hash;
7183 sort_by_digest = sort_by_digest_4_4;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_MEET_IN_MIDDLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_APPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 0;
7193 dgst_pos1 = 3;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 40: hash_type = HASH_TYPE_MD5;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_LE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS14
7204 | OPTS_TYPE_PT_UNICODE;
7205 kern_type = KERN_TYPE_MD5_SLTPWU;
7206 dgst_size = DGST_SIZE_4_4;
7207 parse_func = md5s_parse_hash;
7208 sort_by_digest = sort_by_digest_4_4;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_EARLY_SKIP
7213 | OPTI_TYPE_NOT_ITERATED
7214 | OPTI_TYPE_PREPENDED_SALT
7215 | OPTI_TYPE_RAW_HASH;
7216 dgst_pos0 = 0;
7217 dgst_pos1 = 3;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 50: hash_type = HASH_TYPE_MD5;
7223 salt_type = SALT_TYPE_INTERN;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_LE
7226 | OPTS_TYPE_ST_ADD80
7227 | OPTS_TYPE_ST_ADDBITS14;
7228 kern_type = KERN_TYPE_HMACMD5_PW;
7229 dgst_size = DGST_SIZE_4_4;
7230 parse_func = hmacmd5_parse_hash;
7231 sort_by_digest = sort_by_digest_4_4;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_NOT_ITERATED;
7234 dgst_pos0 = 0;
7235 dgst_pos1 = 3;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 1;
7238 break;
7239
7240 case 60: hash_type = HASH_TYPE_MD5;
7241 salt_type = SALT_TYPE_INTERN;
7242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_LE
7244 | OPTS_TYPE_PT_ADD80
7245 | OPTS_TYPE_PT_ADDBITS14;
7246 kern_type = KERN_TYPE_HMACMD5_SLT;
7247 dgst_size = DGST_SIZE_4_4;
7248 parse_func = hmacmd5_parse_hash;
7249 sort_by_digest = sort_by_digest_4_4;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_NOT_ITERATED;
7252 dgst_pos0 = 0;
7253 dgst_pos1 = 3;
7254 dgst_pos2 = 2;
7255 dgst_pos3 = 1;
7256 break;
7257
7258 case 100: hash_type = HASH_TYPE_SHA1;
7259 salt_type = SALT_TYPE_NONE;
7260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7261 opts_type = OPTS_TYPE_PT_GENERATE_BE
7262 | OPTS_TYPE_PT_ADD80
7263 | OPTS_TYPE_PT_ADDBITS15;
7264 kern_type = KERN_TYPE_SHA1;
7265 dgst_size = DGST_SIZE_4_5;
7266 parse_func = sha1_parse_hash;
7267 sort_by_digest = sort_by_digest_4_5;
7268 opti_type = OPTI_TYPE_ZERO_BYTE
7269 | OPTI_TYPE_PRECOMPUTE_INIT
7270 | OPTI_TYPE_PRECOMPUTE_MERKLE
7271 | OPTI_TYPE_EARLY_SKIP
7272 | OPTI_TYPE_NOT_ITERATED
7273 | OPTI_TYPE_NOT_SALTED
7274 | OPTI_TYPE_RAW_HASH;
7275 dgst_pos0 = 3;
7276 dgst_pos1 = 4;
7277 dgst_pos2 = 2;
7278 dgst_pos3 = 1;
7279 break;
7280
7281 case 101: hash_type = HASH_TYPE_SHA1;
7282 salt_type = SALT_TYPE_NONE;
7283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7284 opts_type = OPTS_TYPE_PT_GENERATE_BE
7285 | OPTS_TYPE_PT_ADD80
7286 | OPTS_TYPE_PT_ADDBITS15;
7287 kern_type = KERN_TYPE_SHA1;
7288 dgst_size = DGST_SIZE_4_5;
7289 parse_func = sha1b64_parse_hash;
7290 sort_by_digest = sort_by_digest_4_5;
7291 opti_type = OPTI_TYPE_ZERO_BYTE
7292 | OPTI_TYPE_PRECOMPUTE_INIT
7293 | OPTI_TYPE_PRECOMPUTE_MERKLE
7294 | OPTI_TYPE_EARLY_SKIP
7295 | OPTI_TYPE_NOT_ITERATED
7296 | OPTI_TYPE_NOT_SALTED
7297 | OPTI_TYPE_RAW_HASH;
7298 dgst_pos0 = 3;
7299 dgst_pos1 = 4;
7300 dgst_pos2 = 2;
7301 dgst_pos3 = 1;
7302 break;
7303
7304 case 110: hash_type = HASH_TYPE_SHA1;
7305 salt_type = SALT_TYPE_INTERN;
7306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7307 opts_type = OPTS_TYPE_PT_GENERATE_BE
7308 | OPTS_TYPE_ST_ADD80
7309 | OPTS_TYPE_ST_ADDBITS15;
7310 kern_type = KERN_TYPE_SHA1_PWSLT;
7311 dgst_size = DGST_SIZE_4_5;
7312 parse_func = sha1s_parse_hash;
7313 sort_by_digest = sort_by_digest_4_5;
7314 opti_type = OPTI_TYPE_ZERO_BYTE
7315 | OPTI_TYPE_PRECOMPUTE_INIT
7316 | OPTI_TYPE_PRECOMPUTE_MERKLE
7317 | OPTI_TYPE_EARLY_SKIP
7318 | OPTI_TYPE_NOT_ITERATED
7319 | OPTI_TYPE_APPENDED_SALT
7320 | OPTI_TYPE_RAW_HASH;
7321 dgst_pos0 = 3;
7322 dgst_pos1 = 4;
7323 dgst_pos2 = 2;
7324 dgst_pos3 = 1;
7325 break;
7326
7327 case 111: hash_type = HASH_TYPE_SHA1;
7328 salt_type = SALT_TYPE_EMBEDDED;
7329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7330 opts_type = OPTS_TYPE_PT_GENERATE_BE
7331 | OPTS_TYPE_ST_ADD80
7332 | OPTS_TYPE_ST_ADDBITS15;
7333 kern_type = KERN_TYPE_SHA1_PWSLT;
7334 dgst_size = DGST_SIZE_4_5;
7335 parse_func = sha1b64s_parse_hash;
7336 sort_by_digest = sort_by_digest_4_5;
7337 opti_type = OPTI_TYPE_ZERO_BYTE
7338 | OPTI_TYPE_PRECOMPUTE_INIT
7339 | OPTI_TYPE_PRECOMPUTE_MERKLE
7340 | OPTI_TYPE_EARLY_SKIP
7341 | OPTI_TYPE_NOT_ITERATED
7342 | OPTI_TYPE_APPENDED_SALT
7343 | OPTI_TYPE_RAW_HASH;
7344 dgst_pos0 = 3;
7345 dgst_pos1 = 4;
7346 dgst_pos2 = 2;
7347 dgst_pos3 = 1;
7348 break;
7349
7350 case 112: hash_type = HASH_TYPE_SHA1;
7351 salt_type = SALT_TYPE_INTERN;
7352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7353 opts_type = OPTS_TYPE_PT_GENERATE_BE
7354 | OPTS_TYPE_ST_ADD80
7355 | OPTS_TYPE_ST_ADDBITS15
7356 | OPTS_TYPE_ST_HEX;
7357 kern_type = KERN_TYPE_SHA1_PWSLT;
7358 dgst_size = DGST_SIZE_4_5;
7359 parse_func = oracles_parse_hash;
7360 sort_by_digest = sort_by_digest_4_5;
7361 opti_type = OPTI_TYPE_ZERO_BYTE
7362 | OPTI_TYPE_PRECOMPUTE_INIT
7363 | OPTI_TYPE_PRECOMPUTE_MERKLE
7364 | OPTI_TYPE_EARLY_SKIP
7365 | OPTI_TYPE_NOT_ITERATED
7366 | OPTI_TYPE_APPENDED_SALT
7367 | OPTI_TYPE_RAW_HASH;
7368 dgst_pos0 = 3;
7369 dgst_pos1 = 4;
7370 dgst_pos2 = 2;
7371 dgst_pos3 = 1;
7372 break;
7373
7374 case 120: hash_type = HASH_TYPE_SHA1;
7375 salt_type = SALT_TYPE_INTERN;
7376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7377 opts_type = OPTS_TYPE_PT_GENERATE_BE
7378 | OPTS_TYPE_PT_ADD80
7379 | OPTS_TYPE_PT_ADDBITS15;
7380 kern_type = KERN_TYPE_SHA1_SLTPW;
7381 dgst_size = DGST_SIZE_4_5;
7382 parse_func = sha1s_parse_hash;
7383 sort_by_digest = sort_by_digest_4_5;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_PREPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 121: hash_type = HASH_TYPE_SHA1;
7398 salt_type = SALT_TYPE_INTERN;
7399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_ADD80
7402 | OPTS_TYPE_PT_ADDBITS15
7403 | OPTS_TYPE_ST_LOWER;
7404 kern_type = KERN_TYPE_SHA1_SLTPW;
7405 dgst_size = DGST_SIZE_4_5;
7406 parse_func = smf_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_PREPENDED_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 122: 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_ADD80
7426 | OPTS_TYPE_PT_ADDBITS15
7427 | OPTS_TYPE_ST_HEX;
7428 kern_type = KERN_TYPE_SHA1_SLTPW;
7429 dgst_size = DGST_SIZE_4_5;
7430 parse_func = osx1_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_PREPENDED_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 124: hash_type = HASH_TYPE_SHA1;
7446 salt_type = SALT_TYPE_EMBEDDED;
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 kern_type = KERN_TYPE_SHA1_SLTPW;
7452 dgst_size = DGST_SIZE_4_5;
7453 parse_func = djangosha1_parse_hash;
7454 sort_by_digest = sort_by_digest_4_5;
7455 opti_type = OPTI_TYPE_ZERO_BYTE
7456 | OPTI_TYPE_PRECOMPUTE_INIT
7457 | OPTI_TYPE_PRECOMPUTE_MERKLE
7458 | OPTI_TYPE_EARLY_SKIP
7459 | OPTI_TYPE_NOT_ITERATED
7460 | OPTI_TYPE_PREPENDED_SALT
7461 | OPTI_TYPE_RAW_HASH;
7462 dgst_pos0 = 3;
7463 dgst_pos1 = 4;
7464 dgst_pos2 = 2;
7465 dgst_pos3 = 1;
7466 break;
7467
7468 case 130: hash_type = HASH_TYPE_SHA1;
7469 salt_type = SALT_TYPE_INTERN;
7470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7471 opts_type = OPTS_TYPE_PT_GENERATE_BE
7472 | OPTS_TYPE_PT_UNICODE
7473 | OPTS_TYPE_ST_ADD80
7474 | OPTS_TYPE_ST_ADDBITS15;
7475 kern_type = KERN_TYPE_SHA1_PWUSLT;
7476 dgst_size = DGST_SIZE_4_5;
7477 parse_func = sha1s_parse_hash;
7478 sort_by_digest = sort_by_digest_4_5;
7479 opti_type = OPTI_TYPE_ZERO_BYTE
7480 | OPTI_TYPE_PRECOMPUTE_INIT
7481 | OPTI_TYPE_PRECOMPUTE_MERKLE
7482 | OPTI_TYPE_EARLY_SKIP
7483 | OPTI_TYPE_NOT_ITERATED
7484 | OPTI_TYPE_APPENDED_SALT
7485 | OPTI_TYPE_RAW_HASH;
7486 dgst_pos0 = 3;
7487 dgst_pos1 = 4;
7488 dgst_pos2 = 2;
7489 dgst_pos3 = 1;
7490 break;
7491
7492 case 131: hash_type = HASH_TYPE_SHA1;
7493 salt_type = SALT_TYPE_EMBEDDED;
7494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7495 opts_type = OPTS_TYPE_PT_GENERATE_BE
7496 | OPTS_TYPE_PT_UNICODE
7497 | OPTS_TYPE_PT_UPPER
7498 | OPTS_TYPE_ST_ADD80
7499 | OPTS_TYPE_ST_ADDBITS15
7500 | OPTS_TYPE_ST_HEX;
7501 kern_type = KERN_TYPE_SHA1_PWUSLT;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = mssql2000_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_APPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 132: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_UNICODE
7523 | OPTS_TYPE_ST_ADD80
7524 | OPTS_TYPE_ST_ADDBITS15
7525 | OPTS_TYPE_ST_HEX;
7526 kern_type = KERN_TYPE_SHA1_PWUSLT;
7527 dgst_size = DGST_SIZE_4_5;
7528 parse_func = mssql2005_parse_hash;
7529 sort_by_digest = sort_by_digest_4_5;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_APPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 3;
7538 dgst_pos1 = 4;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 133: hash_type = HASH_TYPE_SHA1;
7544 salt_type = SALT_TYPE_EMBEDDED;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_BE
7547 | OPTS_TYPE_PT_UNICODE
7548 | OPTS_TYPE_ST_ADD80
7549 | OPTS_TYPE_ST_ADDBITS15;
7550 kern_type = KERN_TYPE_SHA1_PWUSLT;
7551 dgst_size = DGST_SIZE_4_5;
7552 parse_func = peoplesoft_parse_hash;
7553 sort_by_digest = sort_by_digest_4_5;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_EARLY_SKIP
7558 | OPTI_TYPE_NOT_ITERATED
7559 | OPTI_TYPE_APPENDED_SALT
7560 | OPTI_TYPE_RAW_HASH;
7561 dgst_pos0 = 3;
7562 dgst_pos1 = 4;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 1;
7565 break;
7566
7567 case 140: hash_type = HASH_TYPE_SHA1;
7568 salt_type = SALT_TYPE_INTERN;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_BE
7571 | OPTS_TYPE_PT_ADD80
7572 | OPTS_TYPE_PT_ADDBITS15
7573 | OPTS_TYPE_PT_UNICODE;
7574 kern_type = KERN_TYPE_SHA1_SLTPWU;
7575 dgst_size = DGST_SIZE_4_5;
7576 parse_func = sha1s_parse_hash;
7577 sort_by_digest = sort_by_digest_4_5;
7578 opti_type = OPTI_TYPE_ZERO_BYTE
7579 | OPTI_TYPE_PRECOMPUTE_INIT
7580 | OPTI_TYPE_PRECOMPUTE_MERKLE
7581 | OPTI_TYPE_EARLY_SKIP
7582 | OPTI_TYPE_NOT_ITERATED
7583 | OPTI_TYPE_PREPENDED_SALT
7584 | OPTI_TYPE_RAW_HASH;
7585 dgst_pos0 = 3;
7586 dgst_pos1 = 4;
7587 dgst_pos2 = 2;
7588 dgst_pos3 = 1;
7589 break;
7590
7591 case 141: hash_type = HASH_TYPE_SHA1;
7592 salt_type = SALT_TYPE_EMBEDDED;
7593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7594 opts_type = OPTS_TYPE_PT_GENERATE_BE
7595 | OPTS_TYPE_PT_ADD80
7596 | OPTS_TYPE_PT_ADDBITS15
7597 | OPTS_TYPE_PT_UNICODE
7598 | OPTS_TYPE_ST_BASE64;
7599 kern_type = KERN_TYPE_SHA1_SLTPWU;
7600 dgst_size = DGST_SIZE_4_5;
7601 parse_func = episerver_parse_hash;
7602 sort_by_digest = sort_by_digest_4_5;
7603 opti_type = OPTI_TYPE_ZERO_BYTE
7604 | OPTI_TYPE_PRECOMPUTE_INIT
7605 | OPTI_TYPE_PRECOMPUTE_MERKLE
7606 | OPTI_TYPE_EARLY_SKIP
7607 | OPTI_TYPE_NOT_ITERATED
7608 | OPTI_TYPE_PREPENDED_SALT
7609 | OPTI_TYPE_RAW_HASH;
7610 dgst_pos0 = 3;
7611 dgst_pos1 = 4;
7612 dgst_pos2 = 2;
7613 dgst_pos3 = 1;
7614 break;
7615
7616 case 150: hash_type = HASH_TYPE_SHA1;
7617 salt_type = SALT_TYPE_INTERN;
7618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7619 opts_type = OPTS_TYPE_PT_GENERATE_BE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15;
7622 kern_type = KERN_TYPE_HMACSHA1_PW;
7623 dgst_size = DGST_SIZE_4_5;
7624 parse_func = hmacsha1_parse_hash;
7625 sort_by_digest = sort_by_digest_4_5;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_NOT_ITERATED;
7628 dgst_pos0 = 3;
7629 dgst_pos1 = 4;
7630 dgst_pos2 = 2;
7631 dgst_pos3 = 1;
7632 break;
7633
7634 case 160: hash_type = HASH_TYPE_SHA1;
7635 salt_type = SALT_TYPE_INTERN;
7636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7637 opts_type = OPTS_TYPE_PT_GENERATE_BE
7638 | OPTS_TYPE_PT_ADD80
7639 | OPTS_TYPE_PT_ADDBITS15;
7640 kern_type = KERN_TYPE_HMACSHA1_SLT;
7641 dgst_size = DGST_SIZE_4_5;
7642 parse_func = hmacsha1_parse_hash;
7643 sort_by_digest = sort_by_digest_4_5;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_NOT_ITERATED;
7646 dgst_pos0 = 3;
7647 dgst_pos1 = 4;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 1;
7650 break;
7651
7652 case 190: hash_type = HASH_TYPE_SHA1;
7653 salt_type = SALT_TYPE_NONE;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_PT_ADD80
7657 | OPTS_TYPE_PT_ADDBITS15;
7658 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7659 dgst_size = DGST_SIZE_4_5;
7660 parse_func = sha1linkedin_parse_hash;
7661 sort_by_digest = sort_by_digest_4_5;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED;
7667 dgst_pos0 = 0;
7668 dgst_pos1 = 4;
7669 dgst_pos2 = 3;
7670 dgst_pos3 = 2;
7671 break;
7672
7673 case 200: hash_type = HASH_TYPE_MYSQL;
7674 salt_type = SALT_TYPE_NONE;
7675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7676 opts_type = 0;
7677 kern_type = KERN_TYPE_MYSQL;
7678 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7679 parse_func = mysql323_parse_hash;
7680 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7681 opti_type = OPTI_TYPE_ZERO_BYTE;
7682 dgst_pos0 = 0;
7683 dgst_pos1 = 1;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 3;
7686 break;
7687
7688 case 300: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_NONE;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15;
7694 kern_type = KERN_TYPE_MYSQL41;
7695 dgst_size = DGST_SIZE_4_5;
7696 parse_func = sha1_parse_hash;
7697 sort_by_digest = sort_by_digest_4_5;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_EARLY_SKIP
7702 | OPTI_TYPE_NOT_ITERATED
7703 | OPTI_TYPE_NOT_SALTED;
7704 dgst_pos0 = 3;
7705 dgst_pos1 = 4;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 1;
7708 break;
7709
7710 case 400: hash_type = HASH_TYPE_MD5;
7711 salt_type = SALT_TYPE_EMBEDDED;
7712 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7714 kern_type = KERN_TYPE_PHPASS;
7715 dgst_size = DGST_SIZE_4_4;
7716 parse_func = phpass_parse_hash;
7717 sort_by_digest = sort_by_digest_4_4;
7718 opti_type = OPTI_TYPE_ZERO_BYTE;
7719 dgst_pos0 = 0;
7720 dgst_pos1 = 1;
7721 dgst_pos2 = 2;
7722 dgst_pos3 = 3;
7723 break;
7724
7725 case 500: hash_type = HASH_TYPE_MD5;
7726 salt_type = SALT_TYPE_EMBEDDED;
7727 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7728 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7729 kern_type = KERN_TYPE_MD5CRYPT;
7730 dgst_size = DGST_SIZE_4_4;
7731 parse_func = md5crypt_parse_hash;
7732 sort_by_digest = sort_by_digest_4_4;
7733 opti_type = OPTI_TYPE_ZERO_BYTE;
7734 dgst_pos0 = 0;
7735 dgst_pos1 = 1;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 3;
7738 break;
7739
7740 case 501: hash_type = HASH_TYPE_MD5;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_LE
7744 | OPTS_TYPE_HASH_COPY;
7745 kern_type = KERN_TYPE_MD5CRYPT;
7746 dgst_size = DGST_SIZE_4_4;
7747 parse_func = juniper_parse_hash;
7748 sort_by_digest = sort_by_digest_4_4;
7749 opti_type = OPTI_TYPE_ZERO_BYTE;
7750 dgst_pos0 = 0;
7751 dgst_pos1 = 1;
7752 dgst_pos2 = 2;
7753 dgst_pos3 = 3;
7754 break;
7755
7756 case 900: hash_type = HASH_TYPE_MD4;
7757 salt_type = SALT_TYPE_NONE;
7758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7759 opts_type = OPTS_TYPE_PT_GENERATE_LE
7760 | OPTS_TYPE_PT_ADD80
7761 | OPTS_TYPE_PT_ADDBITS14;
7762 kern_type = KERN_TYPE_MD4;
7763 dgst_size = DGST_SIZE_4_4;
7764 parse_func = md4_parse_hash;
7765 sort_by_digest = sort_by_digest_4_4;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_PRECOMPUTE_INIT
7768 | OPTI_TYPE_PRECOMPUTE_MERKLE
7769 | OPTI_TYPE_MEET_IN_MIDDLE
7770 | OPTI_TYPE_EARLY_SKIP
7771 | OPTI_TYPE_NOT_ITERATED
7772 | OPTI_TYPE_NOT_SALTED
7773 | OPTI_TYPE_RAW_HASH;
7774 dgst_pos0 = 0;
7775 dgst_pos1 = 3;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 1;
7778 break;
7779
7780 case 1000: hash_type = HASH_TYPE_MD4;
7781 salt_type = SALT_TYPE_NONE;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_LE
7784 | OPTS_TYPE_PT_ADD80
7785 | OPTS_TYPE_PT_ADDBITS14
7786 | OPTS_TYPE_PT_UNICODE;
7787 kern_type = KERN_TYPE_MD4_PWU;
7788 dgst_size = DGST_SIZE_4_4;
7789 parse_func = md4_parse_hash;
7790 sort_by_digest = sort_by_digest_4_4;
7791 opti_type = OPTI_TYPE_ZERO_BYTE
7792 | OPTI_TYPE_PRECOMPUTE_INIT
7793 | OPTI_TYPE_PRECOMPUTE_MERKLE
7794 | OPTI_TYPE_MEET_IN_MIDDLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_NOT_SALTED
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 0;
7800 dgst_pos1 = 3;
7801 dgst_pos2 = 2;
7802 dgst_pos3 = 1;
7803 break;
7804
7805 case 1100: hash_type = HASH_TYPE_MD4;
7806 salt_type = SALT_TYPE_INTERN;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_LE
7809 | OPTS_TYPE_PT_ADD80
7810 | OPTS_TYPE_PT_ADDBITS14
7811 | OPTS_TYPE_PT_UNICODE
7812 | OPTS_TYPE_ST_ADD80
7813 | OPTS_TYPE_ST_UNICODE
7814 | OPTS_TYPE_ST_LOWER;
7815 kern_type = KERN_TYPE_MD44_PWUSLT;
7816 dgst_size = DGST_SIZE_4_4;
7817 parse_func = dcc_parse_hash;
7818 sort_by_digest = sort_by_digest_4_4;
7819 opti_type = OPTI_TYPE_ZERO_BYTE
7820 | OPTI_TYPE_PRECOMPUTE_INIT
7821 | OPTI_TYPE_PRECOMPUTE_MERKLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED;
7824 dgst_pos0 = 0;
7825 dgst_pos1 = 3;
7826 dgst_pos2 = 2;
7827 dgst_pos3 = 1;
7828 break;
7829
7830 case 1400: hash_type = HASH_TYPE_SHA256;
7831 salt_type = SALT_TYPE_NONE;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_BE
7834 | OPTS_TYPE_PT_ADD80
7835 | OPTS_TYPE_PT_ADDBITS15;
7836 kern_type = KERN_TYPE_SHA256;
7837 dgst_size = DGST_SIZE_4_8;
7838 parse_func = sha256_parse_hash;
7839 sort_by_digest = sort_by_digest_4_8;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_NOT_SALTED
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 3;
7848 dgst_pos1 = 7;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 6;
7851 break;
7852
7853 case 1410: hash_type = HASH_TYPE_SHA256;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_BE
7857 | OPTS_TYPE_ST_ADD80
7858 | OPTS_TYPE_ST_ADDBITS15;
7859 kern_type = KERN_TYPE_SHA256_PWSLT;
7860 dgst_size = DGST_SIZE_4_8;
7861 parse_func = sha256s_parse_hash;
7862 sort_by_digest = sort_by_digest_4_8;
7863 opti_type = OPTI_TYPE_ZERO_BYTE
7864 | OPTI_TYPE_PRECOMPUTE_INIT
7865 | OPTI_TYPE_PRECOMPUTE_MERKLE
7866 | OPTI_TYPE_EARLY_SKIP
7867 | OPTI_TYPE_NOT_ITERATED
7868 | OPTI_TYPE_APPENDED_SALT
7869 | OPTI_TYPE_RAW_HASH;
7870 dgst_pos0 = 3;
7871 dgst_pos1 = 7;
7872 dgst_pos2 = 2;
7873 dgst_pos3 = 6;
7874 break;
7875
7876 case 1420: hash_type = HASH_TYPE_SHA256;
7877 salt_type = SALT_TYPE_INTERN;
7878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7879 opts_type = OPTS_TYPE_PT_GENERATE_BE
7880 | OPTS_TYPE_PT_ADD80
7881 | OPTS_TYPE_PT_ADDBITS15;
7882 kern_type = KERN_TYPE_SHA256_SLTPW;
7883 dgst_size = DGST_SIZE_4_8;
7884 parse_func = sha256s_parse_hash;
7885 sort_by_digest = sort_by_digest_4_8;
7886 opti_type = OPTI_TYPE_ZERO_BYTE
7887 | OPTI_TYPE_PRECOMPUTE_INIT
7888 | OPTI_TYPE_PRECOMPUTE_MERKLE
7889 | OPTI_TYPE_EARLY_SKIP
7890 | OPTI_TYPE_NOT_ITERATED
7891 | OPTI_TYPE_PREPENDED_SALT
7892 | OPTI_TYPE_RAW_HASH;
7893 dgst_pos0 = 3;
7894 dgst_pos1 = 7;
7895 dgst_pos2 = 2;
7896 dgst_pos3 = 6;
7897 break;
7898
7899 case 1421: hash_type = HASH_TYPE_SHA256;
7900 salt_type = SALT_TYPE_EMBEDDED;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_PT_ADD80
7904 | OPTS_TYPE_PT_ADDBITS15;
7905 kern_type = KERN_TYPE_SHA256_SLTPW;
7906 dgst_size = DGST_SIZE_4_8;
7907 parse_func = hmailserver_parse_hash;
7908 sort_by_digest = sort_by_digest_4_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_PRECOMPUTE_INIT
7911 | OPTI_TYPE_PRECOMPUTE_MERKLE
7912 | OPTI_TYPE_EARLY_SKIP
7913 | OPTI_TYPE_NOT_ITERATED
7914 | OPTI_TYPE_PREPENDED_SALT
7915 | OPTI_TYPE_RAW_HASH;
7916 dgst_pos0 = 3;
7917 dgst_pos1 = 7;
7918 dgst_pos2 = 2;
7919 dgst_pos3 = 6;
7920 break;
7921
7922 case 1430: hash_type = HASH_TYPE_SHA256;
7923 salt_type = SALT_TYPE_INTERN;
7924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7925 opts_type = OPTS_TYPE_PT_GENERATE_BE
7926 | OPTS_TYPE_PT_UNICODE
7927 | OPTS_TYPE_ST_ADD80
7928 | OPTS_TYPE_ST_ADDBITS15;
7929 kern_type = KERN_TYPE_SHA256_PWUSLT;
7930 dgst_size = DGST_SIZE_4_8;
7931 parse_func = sha256s_parse_hash;
7932 sort_by_digest = sort_by_digest_4_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_INIT
7935 | OPTI_TYPE_PRECOMPUTE_MERKLE
7936 | OPTI_TYPE_EARLY_SKIP
7937 | OPTI_TYPE_NOT_ITERATED
7938 | OPTI_TYPE_APPENDED_SALT
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 3;
7941 dgst_pos1 = 7;
7942 dgst_pos2 = 2;
7943 dgst_pos3 = 6;
7944 break;
7945
7946 case 1440: hash_type = HASH_TYPE_SHA256;
7947 salt_type = SALT_TYPE_INTERN;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_PT_ADD80
7951 | OPTS_TYPE_PT_ADDBITS15
7952 | OPTS_TYPE_PT_UNICODE;
7953 kern_type = KERN_TYPE_SHA256_SLTPWU;
7954 dgst_size = DGST_SIZE_4_8;
7955 parse_func = sha256s_parse_hash;
7956 sort_by_digest = sort_by_digest_4_8;
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_INIT
7959 | OPTI_TYPE_PRECOMPUTE_MERKLE
7960 | OPTI_TYPE_EARLY_SKIP
7961 | OPTI_TYPE_NOT_ITERATED
7962 | OPTI_TYPE_PREPENDED_SALT
7963 | OPTI_TYPE_RAW_HASH;
7964 dgst_pos0 = 3;
7965 dgst_pos1 = 7;
7966 dgst_pos2 = 2;
7967 dgst_pos3 = 6;
7968 break;
7969
7970 case 1441: hash_type = HASH_TYPE_SHA256;
7971 salt_type = SALT_TYPE_EMBEDDED;
7972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7973 opts_type = OPTS_TYPE_PT_GENERATE_BE
7974 | OPTS_TYPE_PT_ADD80
7975 | OPTS_TYPE_PT_ADDBITS15
7976 | OPTS_TYPE_PT_UNICODE
7977 | OPTS_TYPE_ST_BASE64;
7978 kern_type = KERN_TYPE_SHA256_SLTPWU;
7979 dgst_size = DGST_SIZE_4_8;
7980 parse_func = episerver4_parse_hash;
7981 sort_by_digest = sort_by_digest_4_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_PREPENDED_SALT
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 7;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 6;
7993 break;
7994
7995 case 1450: hash_type = HASH_TYPE_SHA256;
7996 salt_type = SALT_TYPE_INTERN;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_ST_ADD80;
8000 kern_type = KERN_TYPE_HMACSHA256_PW;
8001 dgst_size = DGST_SIZE_4_8;
8002 parse_func = hmacsha256_parse_hash;
8003 sort_by_digest = sort_by_digest_4_8;
8004 opti_type = OPTI_TYPE_ZERO_BYTE
8005 | OPTI_TYPE_NOT_ITERATED;
8006 dgst_pos0 = 3;
8007 dgst_pos1 = 7;
8008 dgst_pos2 = 2;
8009 dgst_pos3 = 6;
8010 break;
8011
8012 case 1460: hash_type = HASH_TYPE_SHA256;
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_HMACSHA256_SLT;
8019 dgst_size = DGST_SIZE_4_8;
8020 parse_func = hmacsha256_parse_hash;
8021 sort_by_digest = sort_by_digest_4_8;
8022 opti_type = OPTI_TYPE_ZERO_BYTE
8023 | OPTI_TYPE_NOT_ITERATED;
8024 dgst_pos0 = 3;
8025 dgst_pos1 = 7;
8026 dgst_pos2 = 2;
8027 dgst_pos3 = 6;
8028 break;
8029
8030 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8031 salt_type = SALT_TYPE_EMBEDDED;
8032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8033 opts_type = OPTS_TYPE_PT_GENERATE_LE
8034 | OPTS_TYPE_PT_BITSLICE;
8035 kern_type = KERN_TYPE_DESCRYPT;
8036 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8037 parse_func = descrypt_parse_hash;
8038 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8039 opti_type = OPTI_TYPE_ZERO_BYTE
8040 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8041 dgst_pos0 = 0;
8042 dgst_pos1 = 1;
8043 dgst_pos2 = 2;
8044 dgst_pos3 = 3;
8045 break;
8046
8047 case 1600: hash_type = HASH_TYPE_MD5;
8048 salt_type = SALT_TYPE_EMBEDDED;
8049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8050 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8051 kern_type = KERN_TYPE_APR1CRYPT;
8052 dgst_size = DGST_SIZE_4_4;
8053 parse_func = md5apr1_parse_hash;
8054 sort_by_digest = sort_by_digest_4_4;
8055 opti_type = OPTI_TYPE_ZERO_BYTE;
8056 dgst_pos0 = 0;
8057 dgst_pos1 = 1;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 3;
8060 break;
8061
8062 case 1700: hash_type = HASH_TYPE_SHA512;
8063 salt_type = SALT_TYPE_NONE;
8064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_BE
8066 | OPTS_TYPE_PT_ADD80
8067 | OPTS_TYPE_PT_ADDBITS15;
8068 kern_type = KERN_TYPE_SHA512;
8069 dgst_size = DGST_SIZE_8_8;
8070 parse_func = sha512_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_NOT_SALTED
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 1710: hash_type = HASH_TYPE_SHA512;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_BE
8090 | OPTS_TYPE_ST_ADD80
8091 | OPTS_TYPE_ST_ADDBITS15;
8092 kern_type = KERN_TYPE_SHA512_PWSLT;
8093 dgst_size = DGST_SIZE_8_8;
8094 parse_func = sha512s_parse_hash;
8095 sort_by_digest = sort_by_digest_8_8;
8096 opti_type = OPTI_TYPE_ZERO_BYTE
8097 | OPTI_TYPE_PRECOMPUTE_INIT
8098 | OPTI_TYPE_PRECOMPUTE_MERKLE
8099 | OPTI_TYPE_EARLY_SKIP
8100 | OPTI_TYPE_NOT_ITERATED
8101 | OPTI_TYPE_APPENDED_SALT
8102 | OPTI_TYPE_USES_BITS_64
8103 | OPTI_TYPE_RAW_HASH;
8104 dgst_pos0 = 14;
8105 dgst_pos1 = 15;
8106 dgst_pos2 = 6;
8107 dgst_pos3 = 7;
8108 break;
8109
8110 case 1711: hash_type = HASH_TYPE_SHA512;
8111 salt_type = SALT_TYPE_EMBEDDED;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_ST_ADD80
8115 | OPTS_TYPE_ST_ADDBITS15;
8116 kern_type = KERN_TYPE_SHA512_PWSLT;
8117 dgst_size = DGST_SIZE_8_8;
8118 parse_func = sha512b64s_parse_hash;
8119 sort_by_digest = sort_by_digest_8_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_PRECOMPUTE_INIT
8122 | OPTI_TYPE_PRECOMPUTE_MERKLE
8123 | OPTI_TYPE_EARLY_SKIP
8124 | OPTI_TYPE_NOT_ITERATED
8125 | OPTI_TYPE_APPENDED_SALT
8126 | OPTI_TYPE_USES_BITS_64
8127 | OPTI_TYPE_RAW_HASH;
8128 dgst_pos0 = 14;
8129 dgst_pos1 = 15;
8130 dgst_pos2 = 6;
8131 dgst_pos3 = 7;
8132 break;
8133
8134 case 1720: hash_type = HASH_TYPE_SHA512;
8135 salt_type = SALT_TYPE_INTERN;
8136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8137 opts_type = OPTS_TYPE_PT_GENERATE_BE
8138 | OPTS_TYPE_PT_ADD80
8139 | OPTS_TYPE_PT_ADDBITS15;
8140 kern_type = KERN_TYPE_SHA512_SLTPW;
8141 dgst_size = DGST_SIZE_8_8;
8142 parse_func = sha512s_parse_hash;
8143 sort_by_digest = sort_by_digest_8_8;
8144 opti_type = OPTI_TYPE_ZERO_BYTE
8145 | OPTI_TYPE_PRECOMPUTE_INIT
8146 | OPTI_TYPE_PRECOMPUTE_MERKLE
8147 | OPTI_TYPE_EARLY_SKIP
8148 | OPTI_TYPE_NOT_ITERATED
8149 | OPTI_TYPE_PREPENDED_SALT
8150 | OPTI_TYPE_USES_BITS_64
8151 | OPTI_TYPE_RAW_HASH;
8152 dgst_pos0 = 14;
8153 dgst_pos1 = 15;
8154 dgst_pos2 = 6;
8155 dgst_pos3 = 7;
8156 break;
8157
8158 case 1722: hash_type = HASH_TYPE_SHA512;
8159 salt_type = SALT_TYPE_EMBEDDED;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_BE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS15
8164 | OPTS_TYPE_ST_HEX;
8165 kern_type = KERN_TYPE_SHA512_SLTPW;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = osx512_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_INIT
8171 | OPTI_TYPE_PRECOMPUTE_MERKLE
8172 | OPTI_TYPE_EARLY_SKIP
8173 | OPTI_TYPE_NOT_ITERATED
8174 | OPTI_TYPE_PREPENDED_SALT
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1730: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_INTERN;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_PT_UNICODE
8188 | OPTS_TYPE_ST_ADD80
8189 | OPTS_TYPE_ST_ADDBITS15;
8190 kern_type = KERN_TYPE_SHA512_PWSLTU;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = sha512s_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED
8199 | OPTI_TYPE_APPENDED_SALT
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1731: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_PT_UNICODE
8213 | OPTS_TYPE_ST_ADD80
8214 | OPTS_TYPE_ST_ADDBITS15
8215 | OPTS_TYPE_ST_HEX;
8216 kern_type = KERN_TYPE_SHA512_PWSLTU;
8217 dgst_size = DGST_SIZE_8_8;
8218 parse_func = mssql2012_parse_hash;
8219 sort_by_digest = sort_by_digest_8_8;
8220 opti_type = OPTI_TYPE_ZERO_BYTE
8221 | OPTI_TYPE_PRECOMPUTE_INIT
8222 | OPTI_TYPE_PRECOMPUTE_MERKLE
8223 | OPTI_TYPE_EARLY_SKIP
8224 | OPTI_TYPE_NOT_ITERATED
8225 | OPTI_TYPE_APPENDED_SALT
8226 | OPTI_TYPE_USES_BITS_64
8227 | OPTI_TYPE_RAW_HASH;
8228 dgst_pos0 = 14;
8229 dgst_pos1 = 15;
8230 dgst_pos2 = 6;
8231 dgst_pos3 = 7;
8232 break;
8233
8234 case 1740: hash_type = HASH_TYPE_SHA512;
8235 salt_type = SALT_TYPE_INTERN;
8236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8237 opts_type = OPTS_TYPE_PT_GENERATE_BE
8238 | OPTS_TYPE_PT_ADD80
8239 | OPTS_TYPE_PT_ADDBITS15
8240 | OPTS_TYPE_PT_UNICODE;
8241 kern_type = KERN_TYPE_SHA512_SLTPWU;
8242 dgst_size = DGST_SIZE_8_8;
8243 parse_func = sha512s_parse_hash;
8244 sort_by_digest = sort_by_digest_8_8;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_PREPENDED_SALT
8251 | OPTI_TYPE_USES_BITS_64
8252 | OPTI_TYPE_RAW_HASH;
8253 dgst_pos0 = 14;
8254 dgst_pos1 = 15;
8255 dgst_pos2 = 6;
8256 dgst_pos3 = 7;
8257 break;
8258
8259 case 1750: hash_type = HASH_TYPE_SHA512;
8260 salt_type = SALT_TYPE_INTERN;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_ST_ADD80;
8264 kern_type = KERN_TYPE_HMACSHA512_PW;
8265 dgst_size = DGST_SIZE_8_8;
8266 parse_func = hmacsha512_parse_hash;
8267 sort_by_digest = sort_by_digest_8_8;
8268 opti_type = OPTI_TYPE_ZERO_BYTE
8269 | OPTI_TYPE_USES_BITS_64
8270 | OPTI_TYPE_NOT_ITERATED;
8271 dgst_pos0 = 14;
8272 dgst_pos1 = 15;
8273 dgst_pos2 = 6;
8274 dgst_pos3 = 7;
8275 break;
8276
8277 case 1760: hash_type = HASH_TYPE_SHA512;
8278 salt_type = SALT_TYPE_INTERN;
8279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_BE
8281 | OPTS_TYPE_PT_ADD80
8282 | OPTS_TYPE_PT_ADDBITS15;
8283 kern_type = KERN_TYPE_HMACSHA512_SLT;
8284 dgst_size = DGST_SIZE_8_8;
8285 parse_func = hmacsha512_parse_hash;
8286 sort_by_digest = sort_by_digest_8_8;
8287 opti_type = OPTI_TYPE_ZERO_BYTE
8288 | OPTI_TYPE_USES_BITS_64
8289 | OPTI_TYPE_NOT_ITERATED;
8290 dgst_pos0 = 14;
8291 dgst_pos1 = 15;
8292 dgst_pos2 = 6;
8293 dgst_pos3 = 7;
8294 break;
8295
8296 case 1800: hash_type = HASH_TYPE_SHA512;
8297 salt_type = SALT_TYPE_EMBEDDED;
8298 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8299 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8300 kern_type = KERN_TYPE_SHA512CRYPT;
8301 dgst_size = DGST_SIZE_8_8;
8302 parse_func = sha512crypt_parse_hash;
8303 sort_by_digest = sort_by_digest_8_8;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_USES_BITS_64;
8306 dgst_pos0 = 0;
8307 dgst_pos1 = 1;
8308 dgst_pos2 = 2;
8309 dgst_pos3 = 3;
8310 break;
8311
8312 case 2100: hash_type = HASH_TYPE_DCC2;
8313 salt_type = SALT_TYPE_EMBEDDED;
8314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8316 | OPTS_TYPE_ST_LOWER
8317 | OPTS_TYPE_ST_UNICODE;
8318 kern_type = KERN_TYPE_DCC2;
8319 dgst_size = DGST_SIZE_4_4;
8320 parse_func = dcc2_parse_hash;
8321 sort_by_digest = sort_by_digest_4_4;
8322 opti_type = OPTI_TYPE_ZERO_BYTE;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 1;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 3;
8327 break;
8328
8329 case 2400: hash_type = HASH_TYPE_MD5;
8330 salt_type = SALT_TYPE_NONE;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8333 kern_type = KERN_TYPE_MD5PIX;
8334 dgst_size = DGST_SIZE_4_4;
8335 parse_func = md5pix_parse_hash;
8336 sort_by_digest = sort_by_digest_4_4;
8337 opti_type = OPTI_TYPE_ZERO_BYTE
8338 | OPTI_TYPE_PRECOMPUTE_INIT
8339 | OPTI_TYPE_PRECOMPUTE_MERKLE
8340 | OPTI_TYPE_EARLY_SKIP
8341 | OPTI_TYPE_NOT_ITERATED
8342 | OPTI_TYPE_NOT_SALTED;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 3;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 2410: hash_type = HASH_TYPE_MD5;
8350 salt_type = SALT_TYPE_INTERN;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8353 kern_type = KERN_TYPE_MD5ASA;
8354 dgst_size = DGST_SIZE_4_4;
8355 parse_func = md5asa_parse_hash;
8356 sort_by_digest = sort_by_digest_4_4;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_PRECOMPUTE_INIT
8359 | OPTI_TYPE_PRECOMPUTE_MERKLE
8360 | OPTI_TYPE_EARLY_SKIP
8361 | OPTI_TYPE_NOT_ITERATED;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 3;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 1;
8366 break;
8367
8368 case 2500: hash_type = HASH_TYPE_WPA;
8369 salt_type = SALT_TYPE_EMBEDDED;
8370 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8372 kern_type = KERN_TYPE_WPA;
8373 dgst_size = DGST_SIZE_4_4;
8374 parse_func = wpa_parse_hash;
8375 sort_by_digest = sort_by_digest_4_4;
8376 opti_type = OPTI_TYPE_ZERO_BYTE;
8377 dgst_pos0 = 0;
8378 dgst_pos1 = 1;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 3;
8381 break;
8382
8383 case 2600: hash_type = HASH_TYPE_MD5;
8384 salt_type = SALT_TYPE_VIRTUAL;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE
8387 | OPTS_TYPE_PT_ADD80
8388 | OPTS_TYPE_PT_ADDBITS14
8389 | OPTS_TYPE_ST_ADD80;
8390 kern_type = KERN_TYPE_MD55_PWSLT1;
8391 dgst_size = DGST_SIZE_4_4;
8392 parse_func = md5md5_parse_hash;
8393 sort_by_digest = sort_by_digest_4_4;
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_PRECOMPUTE_INIT
8396 | OPTI_TYPE_PRECOMPUTE_MERKLE
8397 | OPTI_TYPE_EARLY_SKIP;
8398 dgst_pos0 = 0;
8399 dgst_pos1 = 3;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 1;
8402 break;
8403
8404 case 2611: hash_type = HASH_TYPE_MD5;
8405 salt_type = SALT_TYPE_INTERN;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_LE
8408 | OPTS_TYPE_PT_ADD80
8409 | OPTS_TYPE_PT_ADDBITS14
8410 | OPTS_TYPE_ST_ADD80;
8411 kern_type = KERN_TYPE_MD55_PWSLT1;
8412 dgst_size = DGST_SIZE_4_4;
8413 parse_func = vb3_parse_hash;
8414 sort_by_digest = sort_by_digest_4_4;
8415 opti_type = OPTI_TYPE_ZERO_BYTE
8416 | OPTI_TYPE_PRECOMPUTE_INIT
8417 | OPTI_TYPE_PRECOMPUTE_MERKLE
8418 | OPTI_TYPE_EARLY_SKIP;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 3;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 1;
8423 break;
8424
8425 case 2612: hash_type = HASH_TYPE_MD5;
8426 salt_type = SALT_TYPE_EMBEDDED;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE
8429 | OPTS_TYPE_PT_ADD80
8430 | OPTS_TYPE_PT_ADDBITS14
8431 | OPTS_TYPE_ST_ADD80
8432 | OPTS_TYPE_ST_HEX;
8433 kern_type = KERN_TYPE_MD55_PWSLT1;
8434 dgst_size = DGST_SIZE_4_4;
8435 parse_func = phps_parse_hash;
8436 sort_by_digest = sort_by_digest_4_4;
8437 opti_type = OPTI_TYPE_ZERO_BYTE
8438 | OPTI_TYPE_PRECOMPUTE_INIT
8439 | OPTI_TYPE_PRECOMPUTE_MERKLE
8440 | OPTI_TYPE_EARLY_SKIP;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 3;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 1;
8445 break;
8446
8447 case 2711: hash_type = HASH_TYPE_MD5;
8448 salt_type = SALT_TYPE_INTERN;
8449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE
8451 | OPTS_TYPE_PT_ADD80
8452 | OPTS_TYPE_PT_ADDBITS14
8453 | OPTS_TYPE_ST_ADD80;
8454 kern_type = KERN_TYPE_MD55_PWSLT2;
8455 dgst_size = DGST_SIZE_4_4;
8456 parse_func = vb30_parse_hash;
8457 sort_by_digest = sort_by_digest_4_4;
8458 opti_type = OPTI_TYPE_ZERO_BYTE
8459 | OPTI_TYPE_PRECOMPUTE_INIT
8460 | OPTI_TYPE_EARLY_SKIP;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 2811: hash_type = HASH_TYPE_MD5;
8468 salt_type = SALT_TYPE_INTERN;
8469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE
8471 | OPTS_TYPE_PT_ADD80
8472 | OPTS_TYPE_PT_ADDBITS14;
8473 kern_type = KERN_TYPE_MD55_SLTPW;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = ipb2_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_EARLY_SKIP;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 3;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486 case 3000: hash_type = HASH_TYPE_LM;
8487 salt_type = SALT_TYPE_NONE;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_LE
8490 | OPTS_TYPE_PT_UPPER
8491 | OPTS_TYPE_PT_BITSLICE;
8492 kern_type = KERN_TYPE_LM;
8493 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8494 parse_func = lm_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 1;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 3;
8502 break;
8503
8504 case 3100: hash_type = HASH_TYPE_ORACLEH;
8505 salt_type = SALT_TYPE_INTERN;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE
8508 | OPTS_TYPE_PT_UPPER
8509 | OPTS_TYPE_ST_UPPER;
8510 kern_type = KERN_TYPE_ORACLEH;
8511 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8512 parse_func = oracleh_parse_hash;
8513 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8514 opti_type = OPTI_TYPE_ZERO_BYTE;
8515 dgst_pos0 = 0;
8516 dgst_pos1 = 1;
8517 dgst_pos2 = 2;
8518 dgst_pos3 = 3;
8519 break;
8520
8521 case 3200: hash_type = HASH_TYPE_BCRYPT;
8522 salt_type = SALT_TYPE_EMBEDDED;
8523 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8524 opts_type = OPTS_TYPE_PT_GENERATE_LE
8525 | OPTS_TYPE_ST_GENERATE_LE;
8526 kern_type = KERN_TYPE_BCRYPT;
8527 dgst_size = DGST_SIZE_4_6;
8528 parse_func = bcrypt_parse_hash;
8529 sort_by_digest = sort_by_digest_4_6;
8530 opti_type = OPTI_TYPE_ZERO_BYTE;
8531 dgst_pos0 = 0;
8532 dgst_pos1 = 1;
8533 dgst_pos2 = 2;
8534 dgst_pos3 = 3;
8535 break;
8536
8537 case 3710: hash_type = HASH_TYPE_MD5;
8538 salt_type = SALT_TYPE_INTERN;
8539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8540 opts_type = OPTS_TYPE_PT_GENERATE_LE
8541 | OPTS_TYPE_PT_ADD80
8542 | OPTS_TYPE_PT_ADDBITS14;
8543 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8544 dgst_size = DGST_SIZE_4_4;
8545 parse_func = md5s_parse_hash;
8546 sort_by_digest = sort_by_digest_4_4;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_PRECOMPUTE_MERKLE
8550 | OPTI_TYPE_EARLY_SKIP;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 3;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 1;
8555 break;
8556
8557 case 3711: hash_type = HASH_TYPE_MD5;
8558 salt_type = SALT_TYPE_EMBEDDED;
8559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE
8561 | OPTS_TYPE_PT_ADD80
8562 | OPTS_TYPE_PT_ADDBITS14;
8563 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8564 dgst_size = DGST_SIZE_4_4;
8565 parse_func = mediawiki_b_parse_hash;
8566 sort_by_digest = sort_by_digest_4_4;
8567 opti_type = OPTI_TYPE_ZERO_BYTE
8568 | OPTI_TYPE_PRECOMPUTE_INIT
8569 | OPTI_TYPE_PRECOMPUTE_MERKLE
8570 | OPTI_TYPE_EARLY_SKIP;
8571 dgst_pos0 = 0;
8572 dgst_pos1 = 3;
8573 dgst_pos2 = 2;
8574 dgst_pos3 = 1;
8575 break;
8576
8577 case 3800: hash_type = HASH_TYPE_MD5;
8578 salt_type = SALT_TYPE_INTERN;
8579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8580 opts_type = OPTS_TYPE_PT_GENERATE_LE
8581 | OPTS_TYPE_ST_ADDBITS14;
8582 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8583 dgst_size = DGST_SIZE_4_4;
8584 parse_func = md5s_parse_hash;
8585 sort_by_digest = sort_by_digest_4_4;
8586 opti_type = OPTI_TYPE_ZERO_BYTE
8587 | OPTI_TYPE_PRECOMPUTE_INIT
8588 | OPTI_TYPE_PRECOMPUTE_MERKLE
8589 | OPTI_TYPE_EARLY_SKIP
8590 | OPTI_TYPE_NOT_ITERATED
8591 | OPTI_TYPE_RAW_HASH;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 3;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 1;
8596 break;
8597
8598 case 4300: hash_type = HASH_TYPE_MD5;
8599 salt_type = SALT_TYPE_VIRTUAL;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_PT_ADD80
8603 | OPTS_TYPE_PT_ADDBITS14
8604 | OPTS_TYPE_ST_ADD80;
8605 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8606 dgst_size = DGST_SIZE_4_4;
8607 parse_func = md5md5_parse_hash;
8608 sort_by_digest = sort_by_digest_4_4;
8609 opti_type = OPTI_TYPE_ZERO_BYTE
8610 | OPTI_TYPE_PRECOMPUTE_INIT
8611 | OPTI_TYPE_PRECOMPUTE_MERKLE
8612 | OPTI_TYPE_EARLY_SKIP;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 3;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 1;
8617 break;
8618
8619
8620 case 4400: hash_type = HASH_TYPE_MD5;
8621 salt_type = SALT_TYPE_NONE;
8622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8623 opts_type = OPTS_TYPE_PT_GENERATE_BE
8624 | OPTS_TYPE_PT_ADD80
8625 | OPTS_TYPE_PT_ADDBITS15;
8626 kern_type = KERN_TYPE_MD5_SHA1;
8627 dgst_size = DGST_SIZE_4_4;
8628 parse_func = md5_parse_hash;
8629 sort_by_digest = sort_by_digest_4_4;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_PRECOMPUTE_INIT
8632 | OPTI_TYPE_PRECOMPUTE_MERKLE
8633 | OPTI_TYPE_EARLY_SKIP
8634 | OPTI_TYPE_NOT_ITERATED
8635 | OPTI_TYPE_NOT_SALTED
8636 | OPTI_TYPE_RAW_HASH;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 3;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 1;
8641 break;
8642
8643 case 4500: hash_type = HASH_TYPE_SHA1;
8644 salt_type = SALT_TYPE_NONE;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_BE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS15;
8649 kern_type = KERN_TYPE_SHA11;
8650 dgst_size = DGST_SIZE_4_5;
8651 parse_func = sha1_parse_hash;
8652 sort_by_digest = sort_by_digest_4_5;
8653 opti_type = OPTI_TYPE_ZERO_BYTE
8654 | OPTI_TYPE_PRECOMPUTE_INIT
8655 | OPTI_TYPE_PRECOMPUTE_MERKLE
8656 | OPTI_TYPE_EARLY_SKIP
8657 | OPTI_TYPE_NOT_SALTED;
8658 dgst_pos0 = 3;
8659 dgst_pos1 = 4;
8660 dgst_pos2 = 2;
8661 dgst_pos3 = 1;
8662 break;
8663
8664 case 4700: hash_type = HASH_TYPE_SHA1;
8665 salt_type = SALT_TYPE_NONE;
8666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8667 opts_type = OPTS_TYPE_PT_GENERATE_LE
8668 | OPTS_TYPE_PT_ADD80
8669 | OPTS_TYPE_PT_ADDBITS14;
8670 kern_type = KERN_TYPE_SHA1_MD5;
8671 dgst_size = DGST_SIZE_4_5;
8672 parse_func = sha1_parse_hash;
8673 sort_by_digest = sort_by_digest_4_5;
8674 opti_type = OPTI_TYPE_ZERO_BYTE
8675 | OPTI_TYPE_PRECOMPUTE_INIT
8676 | OPTI_TYPE_PRECOMPUTE_MERKLE
8677 | OPTI_TYPE_EARLY_SKIP
8678 | OPTI_TYPE_NOT_ITERATED
8679 | OPTI_TYPE_NOT_SALTED
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 3;
8682 dgst_pos1 = 4;
8683 dgst_pos2 = 2;
8684 dgst_pos3 = 1;
8685 break;
8686
8687 case 4800: hash_type = HASH_TYPE_MD5;
8688 salt_type = SALT_TYPE_EMBEDDED;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_LE
8691 | OPTS_TYPE_PT_ADDBITS14;
8692 kern_type = KERN_TYPE_MD5_CHAP;
8693 dgst_size = DGST_SIZE_4_4;
8694 parse_func = chap_parse_hash;
8695 sort_by_digest = sort_by_digest_4_4;
8696 opti_type = OPTI_TYPE_ZERO_BYTE
8697 | OPTI_TYPE_PRECOMPUTE_INIT
8698 | OPTI_TYPE_PRECOMPUTE_MERKLE
8699 | OPTI_TYPE_MEET_IN_MIDDLE
8700 | OPTI_TYPE_EARLY_SKIP
8701 | OPTI_TYPE_NOT_ITERATED
8702 | OPTI_TYPE_RAW_HASH;
8703 dgst_pos0 = 0;
8704 dgst_pos1 = 3;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 1;
8707 break;
8708
8709 case 4900: hash_type = HASH_TYPE_SHA1;
8710 salt_type = SALT_TYPE_INTERN;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8713 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8714 dgst_size = DGST_SIZE_4_5;
8715 parse_func = sha1s_parse_hash;
8716 sort_by_digest = sort_by_digest_4_5;
8717 opti_type = OPTI_TYPE_ZERO_BYTE
8718 | OPTI_TYPE_PRECOMPUTE_INIT
8719 | OPTI_TYPE_PRECOMPUTE_MERKLE
8720 | OPTI_TYPE_EARLY_SKIP;
8721 dgst_pos0 = 3;
8722 dgst_pos1 = 4;
8723 dgst_pos2 = 2;
8724 dgst_pos3 = 1;
8725 break;
8726
8727 case 5000: hash_type = HASH_TYPE_KECCAK;
8728 salt_type = SALT_TYPE_EMBEDDED;
8729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8730 opts_type = OPTS_TYPE_PT_GENERATE_LE
8731 | OPTS_TYPE_PT_ADD01;
8732 kern_type = KERN_TYPE_KECCAK;
8733 dgst_size = DGST_SIZE_8_25;
8734 parse_func = keccak_parse_hash;
8735 sort_by_digest = sort_by_digest_8_25;
8736 opti_type = OPTI_TYPE_ZERO_BYTE
8737 | OPTI_TYPE_USES_BITS_64
8738 | OPTI_TYPE_RAW_HASH;
8739 dgst_pos0 = 2;
8740 dgst_pos1 = 3;
8741 dgst_pos2 = 4;
8742 dgst_pos3 = 5;
8743 break;
8744
8745 case 5100: hash_type = HASH_TYPE_MD5H;
8746 salt_type = SALT_TYPE_NONE;
8747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_LE
8749 | OPTS_TYPE_PT_ADD80
8750 | OPTS_TYPE_PT_ADDBITS14;
8751 kern_type = KERN_TYPE_MD5H;
8752 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8753 parse_func = md5half_parse_hash;
8754 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8755 opti_type = OPTI_TYPE_ZERO_BYTE
8756 | OPTI_TYPE_RAW_HASH;
8757 dgst_pos0 = 0;
8758 dgst_pos1 = 1;
8759 dgst_pos2 = 2;
8760 dgst_pos3 = 3;
8761 break;
8762
8763 case 5200: hash_type = HASH_TYPE_SHA256;
8764 salt_type = SALT_TYPE_EMBEDDED;
8765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8767 kern_type = KERN_TYPE_PSAFE3;
8768 dgst_size = DGST_SIZE_4_8;
8769 parse_func = psafe3_parse_hash;
8770 sort_by_digest = sort_by_digest_4_8;
8771 opti_type = OPTI_TYPE_ZERO_BYTE;
8772 dgst_pos0 = 0;
8773 dgst_pos1 = 1;
8774 dgst_pos2 = 2;
8775 dgst_pos3 = 3;
8776 break;
8777
8778 case 5300: hash_type = HASH_TYPE_MD5;
8779 salt_type = SALT_TYPE_EMBEDDED;
8780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8781 opts_type = OPTS_TYPE_PT_GENERATE_LE
8782 | OPTS_TYPE_ST_ADD80;
8783 kern_type = KERN_TYPE_IKEPSK_MD5;
8784 dgst_size = DGST_SIZE_4_4;
8785 parse_func = ikepsk_md5_parse_hash;
8786 sort_by_digest = sort_by_digest_4_4;
8787 opti_type = OPTI_TYPE_ZERO_BYTE;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 3;
8790 dgst_pos2 = 2;
8791 dgst_pos3 = 1;
8792 break;
8793
8794 case 5400: hash_type = HASH_TYPE_SHA1;
8795 salt_type = SALT_TYPE_EMBEDDED;
8796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_BE
8798 | OPTS_TYPE_ST_ADD80;
8799 kern_type = KERN_TYPE_IKEPSK_SHA1;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = ikepsk_sha1_parse_hash;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 3;
8805 dgst_pos1 = 4;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 1;
8808 break;
8809
8810 case 5500: hash_type = HASH_TYPE_NETNTLM;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE
8814 | OPTS_TYPE_PT_ADD80
8815 | OPTS_TYPE_PT_ADDBITS14
8816 | OPTS_TYPE_PT_UNICODE
8817 | OPTS_TYPE_ST_HEX;
8818 kern_type = KERN_TYPE_NETNTLMv1;
8819 dgst_size = DGST_SIZE_4_4;
8820 parse_func = netntlmv1_parse_hash;
8821 sort_by_digest = sort_by_digest_4_4;
8822 opti_type = OPTI_TYPE_ZERO_BYTE
8823 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 5600: hash_type = HASH_TYPE_MD5;
8831 salt_type = SALT_TYPE_EMBEDDED;
8832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_PT_ADD80
8835 | OPTS_TYPE_PT_ADDBITS14
8836 | OPTS_TYPE_PT_UNICODE;
8837 kern_type = KERN_TYPE_NETNTLMv2;
8838 dgst_size = DGST_SIZE_4_4;
8839 parse_func = netntlmv2_parse_hash;
8840 sort_by_digest = sort_by_digest_4_4;
8841 opti_type = OPTI_TYPE_ZERO_BYTE;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 3;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 1;
8846 break;
8847
8848 case 5700: hash_type = HASH_TYPE_SHA256;
8849 salt_type = SALT_TYPE_NONE;
8850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_BE
8852 | OPTS_TYPE_PT_ADD80
8853 | OPTS_TYPE_PT_ADDBITS15;
8854 kern_type = KERN_TYPE_SHA256;
8855 dgst_size = DGST_SIZE_4_8;
8856 parse_func = cisco4_parse_hash;
8857 sort_by_digest = sort_by_digest_4_8;
8858 opti_type = OPTI_TYPE_ZERO_BYTE
8859 | OPTI_TYPE_PRECOMPUTE_INIT
8860 | OPTI_TYPE_PRECOMPUTE_MERKLE
8861 | OPTI_TYPE_EARLY_SKIP
8862 | OPTI_TYPE_NOT_ITERATED
8863 | OPTI_TYPE_NOT_SALTED
8864 | OPTI_TYPE_RAW_HASH;
8865 dgst_pos0 = 3;
8866 dgst_pos1 = 7;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 6;
8869 break;
8870
8871 case 5800: hash_type = HASH_TYPE_SHA1;
8872 salt_type = SALT_TYPE_INTERN;
8873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8875 | OPTS_TYPE_ST_ADD80;
8876 kern_type = KERN_TYPE_ANDROIDPIN;
8877 dgst_size = DGST_SIZE_4_5;
8878 parse_func = androidpin_parse_hash;
8879 sort_by_digest = sort_by_digest_4_5;
8880 opti_type = OPTI_TYPE_ZERO_BYTE;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 1;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 3;
8885 break;
8886
8887 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8888 salt_type = SALT_TYPE_NONE;
8889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE
8891 | OPTS_TYPE_PT_ADD80;
8892 kern_type = KERN_TYPE_RIPEMD160;
8893 dgst_size = DGST_SIZE_4_5;
8894 parse_func = ripemd160_parse_hash;
8895 sort_by_digest = sort_by_digest_4_5;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8904 salt_type = SALT_TYPE_NONE;
8905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_BE
8907 | OPTS_TYPE_PT_ADD80;
8908 kern_type = KERN_TYPE_WHIRLPOOL;
8909 dgst_size = DGST_SIZE_4_16;
8910 parse_func = whirlpool_parse_hash;
8911 sort_by_digest = sort_by_digest_4_16;
8912 opti_type = OPTI_TYPE_ZERO_BYTE;
8913 dgst_pos0 = 0;
8914 dgst_pos1 = 1;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 3;
8917 break;
8918
8919 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8923 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8924 dgst_size = DGST_SIZE_4_5;
8925 parse_func = truecrypt_parse_hash_2k;
8926 sort_by_digest = sort_by_digest_4_5;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8935 salt_type = SALT_TYPE_EMBEDDED;
8936 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8938 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8939 dgst_size = DGST_SIZE_4_5;
8940 parse_func = truecrypt_parse_hash_2k;
8941 sort_by_digest = sort_by_digest_4_5;
8942 opti_type = OPTI_TYPE_ZERO_BYTE;
8943 dgst_pos0 = 0;
8944 dgst_pos1 = 1;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 3;
8947 break;
8948
8949 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8953 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8954 dgst_size = DGST_SIZE_4_5;
8955 parse_func = truecrypt_parse_hash_2k;
8956 sort_by_digest = sort_by_digest_4_5;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6221: hash_type = HASH_TYPE_SHA512;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8968 kern_type = KERN_TYPE_TCSHA512_XTS512;
8969 dgst_size = DGST_SIZE_8_8;
8970 parse_func = truecrypt_parse_hash_1k;
8971 sort_by_digest = sort_by_digest_8_8;
8972 opti_type = OPTI_TYPE_ZERO_BYTE
8973 | OPTI_TYPE_USES_BITS_64;
8974 dgst_pos0 = 0;
8975 dgst_pos1 = 1;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 3;
8978 break;
8979
8980 case 6222: hash_type = HASH_TYPE_SHA512;
8981 salt_type = SALT_TYPE_EMBEDDED;
8982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8984 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8985 dgst_size = DGST_SIZE_8_8;
8986 parse_func = truecrypt_parse_hash_1k;
8987 sort_by_digest = sort_by_digest_8_8;
8988 opti_type = OPTI_TYPE_ZERO_BYTE
8989 | OPTI_TYPE_USES_BITS_64;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6223: hash_type = HASH_TYPE_SHA512;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9000 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9001 dgst_size = DGST_SIZE_8_8;
9002 parse_func = truecrypt_parse_hash_1k;
9003 sort_by_digest = sort_by_digest_8_8;
9004 opti_type = OPTI_TYPE_ZERO_BYTE
9005 | OPTI_TYPE_USES_BITS_64;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9017 dgst_size = DGST_SIZE_4_8;
9018 parse_func = truecrypt_parse_hash_1k;
9019 sort_by_digest = sort_by_digest_4_8;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9032 dgst_size = DGST_SIZE_4_8;
9033 parse_func = truecrypt_parse_hash_1k;
9034 sort_by_digest = sort_by_digest_4_8;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9047 dgst_size = DGST_SIZE_4_8;
9048 parse_func = truecrypt_parse_hash_1k;
9049 sort_by_digest = sort_by_digest_4_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9062 dgst_size = DGST_SIZE_4_5;
9063 parse_func = truecrypt_parse_hash_1k;
9064 sort_by_digest = sort_by_digest_4_5;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9077 dgst_size = DGST_SIZE_4_5;
9078 parse_func = truecrypt_parse_hash_1k;
9079 sort_by_digest = sort_by_digest_4_5;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9092 dgst_size = DGST_SIZE_4_5;
9093 parse_func = truecrypt_parse_hash_1k;
9094 sort_by_digest = sort_by_digest_4_5;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 6300: hash_type = HASH_TYPE_MD5;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9106 kern_type = KERN_TYPE_MD5AIX;
9107 dgst_size = DGST_SIZE_4_4;
9108 parse_func = md5aix_parse_hash;
9109 sort_by_digest = sort_by_digest_4_4;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6400: hash_type = HASH_TYPE_SHA256;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9121 kern_type = KERN_TYPE_SHA256AIX;
9122 dgst_size = DGST_SIZE_4_8;
9123 parse_func = sha256aix_parse_hash;
9124 sort_by_digest = sort_by_digest_4_8;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 6500: hash_type = HASH_TYPE_SHA512;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9136 kern_type = KERN_TYPE_SHA512AIX;
9137 dgst_size = DGST_SIZE_8_8;
9138 parse_func = sha512aix_parse_hash;
9139 sort_by_digest = sort_by_digest_8_8;
9140 opti_type = OPTI_TYPE_ZERO_BYTE
9141 | OPTI_TYPE_USES_BITS_64;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 6600: hash_type = HASH_TYPE_AES;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9152 kern_type = KERN_TYPE_AGILEKEY;
9153 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9154 parse_func = agilekey_parse_hash;
9155 sort_by_digest = sort_by_digest_4_5;
9156 opti_type = OPTI_TYPE_ZERO_BYTE;
9157 dgst_pos0 = 0;
9158 dgst_pos1 = 1;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 3;
9161 break;
9162
9163 case 6700: hash_type = HASH_TYPE_SHA1;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9167 kern_type = KERN_TYPE_SHA1AIX;
9168 dgst_size = DGST_SIZE_4_5;
9169 parse_func = sha1aix_parse_hash;
9170 sort_by_digest = sort_by_digest_4_5;
9171 opti_type = OPTI_TYPE_ZERO_BYTE;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 6800: hash_type = HASH_TYPE_AES;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_LASTPASS;
9183 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9184 parse_func = lastpass_parse_hash;
9185 sort_by_digest = sort_by_digest_4_8;
9186 opti_type = OPTI_TYPE_ZERO_BYTE;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 6900: hash_type = HASH_TYPE_GOST;
9194 salt_type = SALT_TYPE_NONE;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9197 kern_type = KERN_TYPE_GOST;
9198 dgst_size = DGST_SIZE_4_8;
9199 parse_func = gost_parse_hash;
9200 sort_by_digest = sort_by_digest_4_8;
9201 opti_type = OPTI_TYPE_ZERO_BYTE;
9202 dgst_pos0 = 0;
9203 dgst_pos1 = 1;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 3;
9206 break;
9207
9208 case 7100: hash_type = HASH_TYPE_SHA512;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9212 kern_type = KERN_TYPE_PBKDF2_SHA512;
9213 dgst_size = DGST_SIZE_8_16;
9214 parse_func = sha512osx_parse_hash;
9215 sort_by_digest = sort_by_digest_8_16;
9216 opti_type = OPTI_TYPE_ZERO_BYTE
9217 | OPTI_TYPE_USES_BITS_64;
9218 dgst_pos0 = 0;
9219 dgst_pos1 = 1;
9220 dgst_pos2 = 2;
9221 dgst_pos3 = 3;
9222 break;
9223
9224 case 7200: hash_type = HASH_TYPE_SHA512;
9225 salt_type = SALT_TYPE_EMBEDDED;
9226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9227 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9228 kern_type = KERN_TYPE_PBKDF2_SHA512;
9229 dgst_size = DGST_SIZE_8_16;
9230 parse_func = sha512grub_parse_hash;
9231 sort_by_digest = sort_by_digest_8_16;
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_USES_BITS_64;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 7300: hash_type = HASH_TYPE_SHA1;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_BE
9244 | OPTS_TYPE_ST_ADD80
9245 | OPTS_TYPE_ST_ADDBITS15;
9246 kern_type = KERN_TYPE_RAKP;
9247 dgst_size = DGST_SIZE_4_5;
9248 parse_func = rakp_parse_hash;
9249 sort_by_digest = sort_by_digest_4_5;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_NOT_ITERATED;
9252 dgst_pos0 = 3;
9253 dgst_pos1 = 4;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 1;
9256 break;
9257
9258 case 7400: hash_type = HASH_TYPE_SHA256;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9262 kern_type = KERN_TYPE_SHA256CRYPT;
9263 dgst_size = DGST_SIZE_4_8;
9264 parse_func = sha256crypt_parse_hash;
9265 sort_by_digest = sort_by_digest_4_8;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 7500: hash_type = HASH_TYPE_KRB5PA;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_KRB5PA;
9278 dgst_size = DGST_SIZE_4_4;
9279 parse_func = krb5pa_parse_hash;
9280 sort_by_digest = sort_by_digest_4_4;
9281 opti_type = OPTI_TYPE_ZERO_BYTE
9282 | OPTI_TYPE_NOT_ITERATED;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 7600: hash_type = HASH_TYPE_SHA1;
9290 salt_type = SALT_TYPE_INTERN;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_BE
9293 | OPTS_TYPE_PT_ADD80
9294 | OPTS_TYPE_PT_ADDBITS15;
9295 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9296 dgst_size = DGST_SIZE_4_5;
9297 parse_func = redmine_parse_hash;
9298 sort_by_digest = sort_by_digest_4_5;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_PRECOMPUTE_INIT
9301 | OPTI_TYPE_EARLY_SKIP
9302 | OPTI_TYPE_NOT_ITERATED
9303 | OPTI_TYPE_PREPENDED_SALT;
9304 dgst_pos0 = 3;
9305 dgst_pos1 = 4;
9306 dgst_pos2 = 2;
9307 dgst_pos3 = 1;
9308 break;
9309
9310 case 7700: hash_type = HASH_TYPE_SAPB;
9311 salt_type = SALT_TYPE_EMBEDDED;
9312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9313 opts_type = OPTS_TYPE_PT_GENERATE_LE
9314 | OPTS_TYPE_PT_UPPER
9315 | OPTS_TYPE_ST_UPPER;
9316 kern_type = KERN_TYPE_SAPB;
9317 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9318 parse_func = sapb_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9320 opti_type = OPTI_TYPE_ZERO_BYTE
9321 | OPTI_TYPE_PRECOMPUTE_INIT
9322 | OPTI_TYPE_NOT_ITERATED;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 7800: hash_type = HASH_TYPE_SAPG;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_BE
9333 | OPTS_TYPE_ST_ADD80
9334 | OPTS_TYPE_ST_UPPER;
9335 kern_type = KERN_TYPE_SAPG;
9336 dgst_size = DGST_SIZE_4_5;
9337 parse_func = sapg_parse_hash;
9338 sort_by_digest = sort_by_digest_4_5;
9339 opti_type = OPTI_TYPE_ZERO_BYTE
9340 | OPTI_TYPE_PRECOMPUTE_INIT
9341 | OPTI_TYPE_NOT_ITERATED;
9342 dgst_pos0 = 3;
9343 dgst_pos1 = 4;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 1;
9346 break;
9347
9348 case 7900: hash_type = HASH_TYPE_SHA512;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9352 kern_type = KERN_TYPE_DRUPAL7;
9353 dgst_size = DGST_SIZE_8_8;
9354 parse_func = drupal7_parse_hash;
9355 sort_by_digest = sort_by_digest_8_8;
9356 opti_type = OPTI_TYPE_ZERO_BYTE
9357 | OPTI_TYPE_USES_BITS_64;
9358 dgst_pos0 = 0;
9359 dgst_pos1 = 1;
9360 dgst_pos2 = 2;
9361 dgst_pos3 = 3;
9362 break;
9363
9364 case 8000: hash_type = HASH_TYPE_SHA256;
9365 salt_type = SALT_TYPE_EMBEDDED;
9366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9367 opts_type = OPTS_TYPE_PT_GENERATE_BE
9368 | OPTS_TYPE_PT_UNICODE
9369 | OPTS_TYPE_ST_ADD80
9370 | OPTS_TYPE_ST_HEX;
9371 kern_type = KERN_TYPE_SYBASEASE;
9372 dgst_size = DGST_SIZE_4_8;
9373 parse_func = sybasease_parse_hash;
9374 sort_by_digest = sort_by_digest_4_8;
9375 opti_type = OPTI_TYPE_ZERO_BYTE
9376 | OPTI_TYPE_PRECOMPUTE_INIT
9377 | OPTI_TYPE_EARLY_SKIP
9378 | OPTI_TYPE_NOT_ITERATED
9379 | OPTI_TYPE_RAW_HASH;
9380 dgst_pos0 = 3;
9381 dgst_pos1 = 7;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 6;
9384 break;
9385
9386 case 8100: hash_type = HASH_TYPE_SHA1;
9387 salt_type = SALT_TYPE_EMBEDDED;
9388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9390 kern_type = KERN_TYPE_NETSCALER;
9391 dgst_size = DGST_SIZE_4_5;
9392 parse_func = netscaler_parse_hash;
9393 sort_by_digest = sort_by_digest_4_5;
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_PRECOMPUTE_INIT
9396 | OPTI_TYPE_PRECOMPUTE_MERKLE
9397 | OPTI_TYPE_EARLY_SKIP
9398 | OPTI_TYPE_NOT_ITERATED
9399 | OPTI_TYPE_PREPENDED_SALT
9400 | OPTI_TYPE_RAW_HASH;
9401 dgst_pos0 = 3;
9402 dgst_pos1 = 4;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 1;
9405 break;
9406
9407 case 8200: hash_type = HASH_TYPE_SHA256;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9411 kern_type = KERN_TYPE_CLOUDKEY;
9412 dgst_size = DGST_SIZE_4_8;
9413 parse_func = cloudkey_parse_hash;
9414 sort_by_digest = sort_by_digest_4_8;
9415 opti_type = OPTI_TYPE_ZERO_BYTE;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 8300: hash_type = HASH_TYPE_SHA1;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE
9426 | OPTS_TYPE_ST_HEX
9427 | OPTS_TYPE_ST_ADD80;
9428 kern_type = KERN_TYPE_NSEC3;
9429 dgst_size = DGST_SIZE_4_5;
9430 parse_func = nsec3_parse_hash;
9431 sort_by_digest = sort_by_digest_4_5;
9432 opti_type = OPTI_TYPE_ZERO_BYTE;
9433 dgst_pos0 = 3;
9434 dgst_pos1 = 4;
9435 dgst_pos2 = 2;
9436 dgst_pos3 = 1;
9437 break;
9438
9439 case 8400: hash_type = HASH_TYPE_SHA1;
9440 salt_type = SALT_TYPE_INTERN;
9441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9442 opts_type = OPTS_TYPE_PT_GENERATE_BE
9443 | OPTS_TYPE_PT_ADD80
9444 | OPTS_TYPE_PT_ADDBITS15;
9445 kern_type = KERN_TYPE_WBB3;
9446 dgst_size = DGST_SIZE_4_5;
9447 parse_func = wbb3_parse_hash;
9448 sort_by_digest = sort_by_digest_4_5;
9449 opti_type = OPTI_TYPE_ZERO_BYTE
9450 | OPTI_TYPE_PRECOMPUTE_INIT
9451 | OPTI_TYPE_NOT_ITERATED;
9452 dgst_pos0 = 3;
9453 dgst_pos1 = 4;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 1;
9456 break;
9457
9458 case 8500: hash_type = HASH_TYPE_DESRACF;
9459 salt_type = SALT_TYPE_EMBEDDED;
9460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_LE
9462 | OPTS_TYPE_ST_UPPER;
9463 kern_type = KERN_TYPE_RACF;
9464 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9465 parse_func = racf_parse_hash;
9466 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9467 opti_type = OPTI_TYPE_ZERO_BYTE
9468 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 8600: hash_type = HASH_TYPE_LOTUS5;
9476 salt_type = SALT_TYPE_NONE;
9477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_LOTUS5;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = lotus5_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_EARLY_SKIP
9484 | OPTI_TYPE_NOT_ITERATED
9485 | OPTI_TYPE_NOT_SALTED
9486 | OPTI_TYPE_RAW_HASH;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 8700: hash_type = HASH_TYPE_LOTUS6;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9497 kern_type = KERN_TYPE_LOTUS6;
9498 dgst_size = DGST_SIZE_4_4;
9499 parse_func = lotus6_parse_hash;
9500 sort_by_digest = sort_by_digest_4_4;
9501 opti_type = OPTI_TYPE_EARLY_SKIP
9502 | OPTI_TYPE_NOT_ITERATED
9503 | OPTI_TYPE_RAW_HASH;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_ANDROIDFDE;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = androidfde_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 8900: hash_type = HASH_TYPE_SCRYPT;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9529 kern_type = KERN_TYPE_SCRYPT;
9530 dgst_size = DGST_SIZE_4_8;
9531 parse_func = scrypt_parse_hash;
9532 sort_by_digest = sort_by_digest_4_8;
9533 opti_type = OPTI_TYPE_ZERO_BYTE;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 9000: hash_type = HASH_TYPE_SHA1;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_GENERATE_LE;
9545 kern_type = KERN_TYPE_PSAFE2;
9546 dgst_size = DGST_SIZE_4_5;
9547 parse_func = psafe2_parse_hash;
9548 sort_by_digest = sort_by_digest_4_5;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 9100: hash_type = HASH_TYPE_LOTUS8;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9560 kern_type = KERN_TYPE_LOTUS8;
9561 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9562 parse_func = lotus8_parse_hash;
9563 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9564 opti_type = OPTI_TYPE_ZERO_BYTE;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 9200: hash_type = HASH_TYPE_SHA256;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9575 kern_type = KERN_TYPE_PBKDF2_SHA256;
9576 dgst_size = DGST_SIZE_4_32;
9577 parse_func = cisco8_parse_hash;
9578 sort_by_digest = sort_by_digest_4_32;
9579 opti_type = OPTI_TYPE_ZERO_BYTE;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 9300: hash_type = HASH_TYPE_SCRYPT;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9590 kern_type = KERN_TYPE_SCRYPT;
9591 dgst_size = DGST_SIZE_4_8;
9592 parse_func = cisco9_parse_hash;
9593 sort_by_digest = sort_by_digest_4_8;
9594 opti_type = OPTI_TYPE_ZERO_BYTE;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_OFFICE2007;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = office2007_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_OFFICE2010;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = office2010_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9635 kern_type = KERN_TYPE_OFFICE2013;
9636 dgst_size = DGST_SIZE_4_4;
9637 parse_func = office2013_parse_hash;
9638 sort_by_digest = sort_by_digest_4_4;
9639 opti_type = OPTI_TYPE_ZERO_BYTE;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE
9650 | OPTS_TYPE_PT_ADD80
9651 | OPTS_TYPE_PT_UNICODE;
9652 kern_type = KERN_TYPE_OLDOFFICE01;
9653 dgst_size = DGST_SIZE_4_4;
9654 parse_func = oldoffice01_parse_hash;
9655 sort_by_digest = sort_by_digest_4_4;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_PRECOMPUTE_INIT
9658 | OPTI_TYPE_NOT_ITERATED;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 1;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 3;
9663 break;
9664
9665 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE
9669 | OPTS_TYPE_PT_ADD80;
9670 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9671 dgst_size = DGST_SIZE_4_4;
9672 parse_func = oldoffice01cm1_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4;
9674 opti_type = OPTI_TYPE_ZERO_BYTE
9675 | OPTI_TYPE_PRECOMPUTE_INIT
9676 | OPTI_TYPE_NOT_ITERATED;
9677 dgst_pos0 = 0;
9678 dgst_pos1 = 1;
9679 dgst_pos2 = 2;
9680 dgst_pos3 = 3;
9681 break;
9682
9683 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9684 salt_type = SALT_TYPE_EMBEDDED;
9685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9686 opts_type = OPTS_TYPE_PT_GENERATE_LE
9687 | OPTS_TYPE_PT_ADD80
9688 | OPTS_TYPE_PT_UNICODE
9689 | OPTS_TYPE_PT_NEVERCRACK;
9690 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9691 dgst_size = DGST_SIZE_4_4;
9692 parse_func = oldoffice01cm2_parse_hash;
9693 sort_by_digest = sort_by_digest_4_4;
9694 opti_type = OPTI_TYPE_ZERO_BYTE
9695 | OPTI_TYPE_PRECOMPUTE_INIT
9696 | OPTI_TYPE_NOT_ITERATED;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_BE
9707 | OPTS_TYPE_PT_ADD80
9708 | OPTS_TYPE_PT_UNICODE;
9709 kern_type = KERN_TYPE_OLDOFFICE34;
9710 dgst_size = DGST_SIZE_4_4;
9711 parse_func = oldoffice34_parse_hash;
9712 sort_by_digest = sort_by_digest_4_4;
9713 opti_type = OPTI_TYPE_ZERO_BYTE
9714 | OPTI_TYPE_PRECOMPUTE_INIT
9715 | OPTI_TYPE_NOT_ITERATED;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9727 dgst_size = DGST_SIZE_4_4;
9728 parse_func = oldoffice34cm1_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4;
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_PRECOMPUTE_INIT
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_BE
9743 | OPTS_TYPE_PT_ADD80
9744 | OPTS_TYPE_PT_UNICODE
9745 | OPTS_TYPE_PT_NEVERCRACK;
9746 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9747 dgst_size = DGST_SIZE_4_4;
9748 parse_func = oldoffice34cm2_parse_hash;
9749 sort_by_digest = sort_by_digest_4_4;
9750 opti_type = OPTI_TYPE_ZERO_BYTE
9751 | OPTI_TYPE_PRECOMPUTE_INIT
9752 | OPTI_TYPE_NOT_ITERATED;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 9900: hash_type = HASH_TYPE_MD5;
9760 salt_type = SALT_TYPE_NONE;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9763 kern_type = KERN_TYPE_RADMIN2;
9764 dgst_size = DGST_SIZE_4_4;
9765 parse_func = radmin2_parse_hash;
9766 sort_by_digest = sort_by_digest_4_4;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_PRECOMPUTE_INIT
9769 | OPTI_TYPE_EARLY_SKIP
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_NOT_SALTED;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 3;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 1;
9776 break;
9777
9778 case 10000: hash_type = HASH_TYPE_SHA256;
9779 salt_type = SALT_TYPE_EMBEDDED;
9780 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9782 kern_type = KERN_TYPE_PBKDF2_SHA256;
9783 dgst_size = DGST_SIZE_4_32;
9784 parse_func = djangopbkdf2_parse_hash;
9785 sort_by_digest = sort_by_digest_4_32;
9786 opti_type = OPTI_TYPE_ZERO_BYTE;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 10100: hash_type = HASH_TYPE_SIPHASH;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9797 kern_type = KERN_TYPE_SIPHASH;
9798 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9799 parse_func = siphash_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9801 opti_type = OPTI_TYPE_ZERO_BYTE
9802 | OPTI_TYPE_NOT_ITERATED
9803 | OPTI_TYPE_RAW_HASH;
9804 dgst_pos0 = 0;
9805 dgst_pos1 = 1;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 3;
9808 break;
9809
9810 case 10200: hash_type = HASH_TYPE_MD5;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_LE
9814 | OPTS_TYPE_ST_ADD80
9815 | OPTS_TYPE_ST_ADDBITS14;
9816 kern_type = KERN_TYPE_HMACMD5_PW;
9817 dgst_size = DGST_SIZE_4_4;
9818 parse_func = crammd5_parse_hash;
9819 sort_by_digest = sort_by_digest_4_4;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_NOT_ITERATED;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 3;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 10300: hash_type = HASH_TYPE_SHA1;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9832 kern_type = KERN_TYPE_SAPH_SHA1;
9833 dgst_size = DGST_SIZE_4_5;
9834 parse_func = saph_sha1_parse_hash;
9835 sort_by_digest = sort_by_digest_4_5;
9836 opti_type = OPTI_TYPE_ZERO_BYTE;
9837 dgst_pos0 = 0;
9838 dgst_pos1 = 1;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 3;
9841 break;
9842
9843 case 10400: hash_type = HASH_TYPE_PDFU16;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9847 kern_type = KERN_TYPE_PDF11;
9848 dgst_size = DGST_SIZE_4_4;
9849 parse_func = pdf11_parse_hash;
9850 sort_by_digest = sort_by_digest_4_4;
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_NOT_ITERATED;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 1;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 3;
9857 break;
9858
9859 case 10410: hash_type = HASH_TYPE_PDFU16;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9863 kern_type = KERN_TYPE_PDF11CM1;
9864 dgst_size = DGST_SIZE_4_4;
9865 parse_func = pdf11cm1_parse_hash;
9866 sort_by_digest = sort_by_digest_4_4;
9867 opti_type = OPTI_TYPE_ZERO_BYTE
9868 | OPTI_TYPE_NOT_ITERATED;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 10420: hash_type = HASH_TYPE_PDFU16;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9879 kern_type = KERN_TYPE_PDF11CM2;
9880 dgst_size = DGST_SIZE_4_4;
9881 parse_func = pdf11cm2_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4;
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_NOT_ITERATED;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 1;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 3;
9889 break;
9890
9891 case 10500: hash_type = HASH_TYPE_PDFU16;
9892 salt_type = SALT_TYPE_EMBEDDED;
9893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9895 kern_type = KERN_TYPE_PDF14;
9896 dgst_size = DGST_SIZE_4_4;
9897 parse_func = pdf14_parse_hash;
9898 sort_by_digest = sort_by_digest_4_4;
9899 opti_type = OPTI_TYPE_ZERO_BYTE
9900 | OPTI_TYPE_NOT_ITERATED;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 1;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 3;
9905 break;
9906
9907 case 10600: hash_type = HASH_TYPE_SHA256;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_BE
9911 | OPTS_TYPE_ST_ADD80
9912 | OPTS_TYPE_ST_ADDBITS15
9913 | OPTS_TYPE_HASH_COPY;
9914 kern_type = KERN_TYPE_SHA256_PWSLT;
9915 dgst_size = DGST_SIZE_4_8;
9916 parse_func = pdf17l3_parse_hash;
9917 sort_by_digest = sort_by_digest_4_8;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_PRECOMPUTE_INIT
9920 | OPTI_TYPE_PRECOMPUTE_MERKLE
9921 | OPTI_TYPE_EARLY_SKIP
9922 | OPTI_TYPE_NOT_ITERATED
9923 | OPTI_TYPE_APPENDED_SALT
9924 | OPTI_TYPE_RAW_HASH;
9925 dgst_pos0 = 3;
9926 dgst_pos1 = 7;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 6;
9929 break;
9930
9931 case 10700: hash_type = HASH_TYPE_PDFU32;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE
9935 | OPTS_TYPE_HASH_COPY;
9936 kern_type = KERN_TYPE_PDF17L8;
9937 dgst_size = DGST_SIZE_4_8;
9938 parse_func = pdf17l8_parse_hash;
9939 sort_by_digest = sort_by_digest_4_8;
9940 opti_type = OPTI_TYPE_ZERO_BYTE
9941 | OPTI_TYPE_NOT_ITERATED;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 10800: hash_type = HASH_TYPE_SHA384;
9949 salt_type = SALT_TYPE_NONE;
9950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_BE
9952 | OPTS_TYPE_PT_ADD80
9953 | OPTS_TYPE_PT_ADDBITS15;
9954 kern_type = KERN_TYPE_SHA384;
9955 dgst_size = DGST_SIZE_8_8;
9956 parse_func = sha384_parse_hash;
9957 sort_by_digest = sort_by_digest_8_8;
9958 opti_type = OPTI_TYPE_ZERO_BYTE
9959 | OPTI_TYPE_PRECOMPUTE_INIT
9960 | OPTI_TYPE_PRECOMPUTE_MERKLE
9961 | OPTI_TYPE_EARLY_SKIP
9962 | OPTI_TYPE_NOT_ITERATED
9963 | OPTI_TYPE_NOT_SALTED
9964 | OPTI_TYPE_USES_BITS_64
9965 | OPTI_TYPE_RAW_HASH;
9966 dgst_pos0 = 6;
9967 dgst_pos1 = 7;
9968 dgst_pos2 = 4;
9969 dgst_pos3 = 5;
9970 break;
9971
9972 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE
9976 | OPTS_TYPE_ST_BASE64
9977 | OPTS_TYPE_HASH_COPY;
9978 kern_type = KERN_TYPE_PBKDF2_SHA256;
9979 dgst_size = DGST_SIZE_4_32;
9980 parse_func = pbkdf2_sha256_parse_hash;
9981 sort_by_digest = sort_by_digest_4_32;
9982 opti_type = OPTI_TYPE_ZERO_BYTE;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 11000: hash_type = HASH_TYPE_MD5;
9990 salt_type = SALT_TYPE_INTERN;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_LE
9993 | OPTS_TYPE_PT_ADD80;
9994 kern_type = KERN_TYPE_PRESTASHOP;
9995 dgst_size = DGST_SIZE_4_4;
9996 parse_func = prestashop_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4;
9998 opti_type = OPTI_TYPE_ZERO_BYTE
9999 | OPTI_TYPE_PRECOMPUTE_INIT
10000 | OPTI_TYPE_NOT_ITERATED
10001 | OPTI_TYPE_PREPENDED_SALT;
10002 dgst_pos0 = 0;
10003 dgst_pos1 = 3;
10004 dgst_pos2 = 2;
10005 dgst_pos3 = 1;
10006 break;
10007
10008 case 11100: hash_type = HASH_TYPE_MD5;
10009 salt_type = SALT_TYPE_EMBEDDED;
10010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10011 opts_type = OPTS_TYPE_PT_GENERATE_LE
10012 | OPTS_TYPE_ST_ADD80;
10013 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10014 dgst_size = DGST_SIZE_4_4;
10015 parse_func = postgresql_auth_parse_hash;
10016 sort_by_digest = sort_by_digest_4_4;
10017 opti_type = OPTI_TYPE_ZERO_BYTE
10018 | OPTI_TYPE_PRECOMPUTE_INIT
10019 | OPTI_TYPE_PRECOMPUTE_MERKLE
10020 | OPTI_TYPE_EARLY_SKIP;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 3;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 1;
10025 break;
10026
10027 case 11200: hash_type = HASH_TYPE_SHA1;
10028 salt_type = SALT_TYPE_EMBEDDED;
10029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_BE
10031 | OPTS_TYPE_PT_ADD80
10032 | OPTS_TYPE_ST_HEX;
10033 kern_type = KERN_TYPE_MYSQL_AUTH;
10034 dgst_size = DGST_SIZE_4_5;
10035 parse_func = mysql_auth_parse_hash;
10036 sort_by_digest = sort_by_digest_4_5;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_EARLY_SKIP;
10039 dgst_pos0 = 3;
10040 dgst_pos1 = 4;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 1;
10043 break;
10044
10045 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10046 salt_type = SALT_TYPE_EMBEDDED;
10047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_LE
10049 | OPTS_TYPE_ST_HEX
10050 | OPTS_TYPE_ST_ADD80;
10051 kern_type = KERN_TYPE_BITCOIN_WALLET;
10052 dgst_size = DGST_SIZE_4_4;
10053 parse_func = bitcoin_wallet_parse_hash;
10054 sort_by_digest = sort_by_digest_4_4;
10055 opti_type = OPTI_TYPE_ZERO_BYTE;
10056 dgst_pos0 = 0;
10057 dgst_pos1 = 1;
10058 dgst_pos2 = 2;
10059 dgst_pos3 = 3;
10060 break;
10061
10062 case 11400: hash_type = HASH_TYPE_MD5;
10063 salt_type = SALT_TYPE_EMBEDDED;
10064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10065 opts_type = OPTS_TYPE_PT_GENERATE_LE
10066 | OPTS_TYPE_PT_ADD80
10067 | OPTS_TYPE_HASH_COPY;
10068 kern_type = KERN_TYPE_SIP_AUTH;
10069 dgst_size = DGST_SIZE_4_4;
10070 parse_func = sip_auth_parse_hash;
10071 sort_by_digest = sort_by_digest_4_4;
10072 opti_type = OPTI_TYPE_ZERO_BYTE;
10073 dgst_pos0 = 0;
10074 dgst_pos1 = 3;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 1;
10077 break;
10078
10079 case 11500: hash_type = HASH_TYPE_CRC32;
10080 salt_type = SALT_TYPE_INTERN;
10081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE
10083 | OPTS_TYPE_ST_GENERATE_LE
10084 | OPTS_TYPE_ST_HEX;
10085 kern_type = KERN_TYPE_CRC32;
10086 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10087 parse_func = crc32_parse_hash;
10088 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10089 opti_type = OPTI_TYPE_ZERO_BYTE;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 11600: hash_type = HASH_TYPE_AES;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE
10100 | OPTS_TYPE_PT_NEVERCRACK;
10101 kern_type = KERN_TYPE_SEVEN_ZIP;
10102 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10103 parse_func = seven_zip_parse_hash;
10104 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10113 salt_type = SALT_TYPE_NONE;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE
10116 | OPTS_TYPE_PT_ADD01;
10117 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10118 dgst_size = DGST_SIZE_4_8;
10119 parse_func = gost2012sbog_256_parse_hash;
10120 sort_by_digest = sort_by_digest_4_8;
10121 opti_type = OPTI_TYPE_ZERO_BYTE;
10122 dgst_pos0 = 0;
10123 dgst_pos1 = 1;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 3;
10126 break;
10127
10128 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10129 salt_type = SALT_TYPE_NONE;
10130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_LE
10132 | OPTS_TYPE_PT_ADD01;
10133 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10134 dgst_size = DGST_SIZE_4_16;
10135 parse_func = gost2012sbog_512_parse_hash;
10136 sort_by_digest = sort_by_digest_4_16;
10137 opti_type = OPTI_TYPE_ZERO_BYTE;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 1;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 3;
10142 break;
10143
10144 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE
10148 | OPTS_TYPE_ST_BASE64
10149 | OPTS_TYPE_HASH_COPY;
10150 kern_type = KERN_TYPE_PBKDF2_MD5;
10151 dgst_size = DGST_SIZE_4_32;
10152 parse_func = pbkdf2_md5_parse_hash;
10153 sort_by_digest = sort_by_digest_4_32;
10154 opti_type = OPTI_TYPE_ZERO_BYTE;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE
10165 | OPTS_TYPE_ST_BASE64
10166 | OPTS_TYPE_HASH_COPY;
10167 kern_type = KERN_TYPE_PBKDF2_SHA1;
10168 dgst_size = DGST_SIZE_4_32;
10169 parse_func = pbkdf2_sha1_parse_hash;
10170 sort_by_digest = sort_by_digest_4_32;
10171 opti_type = OPTI_TYPE_ZERO_BYTE;
10172 dgst_pos0 = 0;
10173 dgst_pos1 = 1;
10174 dgst_pos2 = 2;
10175 dgst_pos3 = 3;
10176 break;
10177
10178 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE
10182 | OPTS_TYPE_ST_BASE64
10183 | OPTS_TYPE_HASH_COPY;
10184 kern_type = KERN_TYPE_PBKDF2_SHA512;
10185 dgst_size = DGST_SIZE_8_16;
10186 parse_func = pbkdf2_sha512_parse_hash;
10187 sort_by_digest = sort_by_digest_8_16;
10188 opti_type = OPTI_TYPE_ZERO_BYTE
10189 | OPTI_TYPE_USES_BITS_64;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10200 kern_type = KERN_TYPE_ECRYPTFS;
10201 dgst_size = DGST_SIZE_8_8;
10202 parse_func = ecryptfs_parse_hash;
10203 sort_by_digest = sort_by_digest_8_8;
10204 opti_type = OPTI_TYPE_ZERO_BYTE
10205 | OPTI_TYPE_USES_BITS_64;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 12300: hash_type = HASH_TYPE_ORACLET;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10216 kern_type = KERN_TYPE_ORACLET;
10217 dgst_size = DGST_SIZE_8_16;
10218 parse_func = oraclet_parse_hash;
10219 sort_by_digest = sort_by_digest_8_16;
10220 opti_type = OPTI_TYPE_ZERO_BYTE
10221 | OPTI_TYPE_USES_BITS_64;
10222 dgst_pos0 = 0;
10223 dgst_pos1 = 1;
10224 dgst_pos2 = 2;
10225 dgst_pos3 = 3;
10226 break;
10227
10228 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10229 salt_type = SALT_TYPE_EMBEDDED;
10230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10232 kern_type = KERN_TYPE_BSDICRYPT;
10233 dgst_size = DGST_SIZE_4_4;
10234 parse_func = bsdicrypt_parse_hash;
10235 sort_by_digest = sort_by_digest_4_4;
10236 opti_type = OPTI_TYPE_ZERO_BYTE
10237 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 1;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 3;
10242 break;
10243
10244 case 12500: hash_type = HASH_TYPE_RAR3HP;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10248 kern_type = KERN_TYPE_RAR3;
10249 dgst_size = DGST_SIZE_4_4;
10250 parse_func = rar3hp_parse_hash;
10251 sort_by_digest = sort_by_digest_4_4;
10252 opti_type = OPTI_TYPE_ZERO_BYTE;
10253 dgst_pos0 = 0;
10254 dgst_pos1 = 1;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 3;
10257 break;
10258
10259 case 12600: hash_type = HASH_TYPE_SHA256;
10260 salt_type = SALT_TYPE_INTERN;
10261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_BE
10263 | OPTS_TYPE_PT_ADD80;
10264 kern_type = KERN_TYPE_CF10;
10265 dgst_size = DGST_SIZE_4_8;
10266 parse_func = cf10_parse_hash;
10267 sort_by_digest = sort_by_digest_4_8;
10268 opti_type = OPTI_TYPE_ZERO_BYTE
10269 | OPTI_TYPE_PRECOMPUTE_INIT
10270 | OPTI_TYPE_EARLY_SKIP
10271 | OPTI_TYPE_NOT_ITERATED;
10272 dgst_pos0 = 3;
10273 dgst_pos1 = 7;
10274 dgst_pos2 = 2;
10275 dgst_pos3 = 6;
10276 break;
10277
10278 case 12700: hash_type = HASH_TYPE_AES;
10279 salt_type = SALT_TYPE_EMBEDDED;
10280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE
10282 | OPTS_TYPE_HASH_COPY;
10283 kern_type = KERN_TYPE_MYWALLET;
10284 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10285 parse_func = mywallet_parse_hash;
10286 sort_by_digest = sort_by_digest_4_5;
10287 opti_type = OPTI_TYPE_ZERO_BYTE;
10288 dgst_pos0 = 0;
10289 dgst_pos1 = 1;
10290 dgst_pos2 = 2;
10291 dgst_pos3 = 3;
10292 break;
10293
10294 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10295 salt_type = SALT_TYPE_EMBEDDED;
10296 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10297 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10298 kern_type = KERN_TYPE_MS_DRSR;
10299 dgst_size = DGST_SIZE_4_8;
10300 parse_func = ms_drsr_parse_hash;
10301 sort_by_digest = sort_by_digest_4_8;
10302 opti_type = OPTI_TYPE_ZERO_BYTE;
10303 dgst_pos0 = 0;
10304 dgst_pos1 = 1;
10305 dgst_pos2 = 2;
10306 dgst_pos3 = 3;
10307 break;
10308
10309 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10310 salt_type = SALT_TYPE_EMBEDDED;
10311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10313 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10314 dgst_size = DGST_SIZE_4_8;
10315 parse_func = androidfde_samsung_parse_hash;
10316 sort_by_digest = sort_by_digest_4_8;
10317 opti_type = OPTI_TYPE_ZERO_BYTE;
10318 dgst_pos0 = 0;
10319 dgst_pos1 = 1;
10320 dgst_pos2 = 2;
10321 dgst_pos3 = 3;
10322 break;
10323
10324 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10325 salt_type = SALT_TYPE_EMBEDDED;
10326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10328 kern_type = KERN_TYPE_RAR5;
10329 dgst_size = DGST_SIZE_4_4;
10330 parse_func = rar5_parse_hash;
10331 sort_by_digest = sort_by_digest_4_4;
10332 opti_type = OPTI_TYPE_ZERO_BYTE;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10343 kern_type = KERN_TYPE_KRB5TGS;
10344 dgst_size = DGST_SIZE_4_4;
10345 parse_func = krb5tgs_parse_hash;
10346 sort_by_digest = sort_by_digest_4_4;
10347 opti_type = OPTI_TYPE_ZERO_BYTE
10348 | OPTI_TYPE_NOT_ITERATED;
10349 dgst_pos0 = 0;
10350 dgst_pos1 = 1;
10351 dgst_pos2 = 2;
10352 dgst_pos3 = 3;
10353 break;
10354
10355 default: usage_mini_print (PROGNAME); return (-1);
10356 }
10357
10358 /**
10359 * transpose
10360 */
10361
10362 data.parse_func = parse_func;
10363
10364 /**
10365 * misc stuff
10366 */
10367
10368 if (hex_salt)
10369 {
10370 if (salt_type == SALT_TYPE_INTERN)
10371 {
10372 opts_type |= OPTS_TYPE_ST_HEX;
10373 }
10374 else
10375 {
10376 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10377
10378 return (-1);
10379 }
10380 }
10381
10382 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10383 | (salt_type == SALT_TYPE_EXTERN)
10384 | (salt_type == SALT_TYPE_EMBEDDED)
10385 | (salt_type == SALT_TYPE_VIRTUAL));
10386
10387 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10388
10389 data.hash_type = hash_type;
10390 data.attack_mode = attack_mode;
10391 data.attack_kern = attack_kern;
10392 data.attack_exec = attack_exec;
10393 data.kern_type = kern_type;
10394 data.opts_type = opts_type;
10395 data.dgst_size = dgst_size;
10396 data.salt_type = salt_type;
10397 data.isSalted = isSalted;
10398 data.sort_by_digest = sort_by_digest;
10399 data.dgst_pos0 = dgst_pos0;
10400 data.dgst_pos1 = dgst_pos1;
10401 data.dgst_pos2 = dgst_pos2;
10402 data.dgst_pos3 = dgst_pos3;
10403
10404 esalt_size = 0;
10405
10406 switch (hash_mode)
10407 {
10408 case 2500: esalt_size = sizeof (wpa_t); break;
10409 case 5300: esalt_size = sizeof (ikepsk_t); break;
10410 case 5400: esalt_size = sizeof (ikepsk_t); break;
10411 case 5500: esalt_size = sizeof (netntlm_t); break;
10412 case 5600: esalt_size = sizeof (netntlm_t); break;
10413 case 6211: esalt_size = sizeof (tc_t); break;
10414 case 6212: esalt_size = sizeof (tc_t); break;
10415 case 6213: esalt_size = sizeof (tc_t); break;
10416 case 6221: esalt_size = sizeof (tc_t); break;
10417 case 6222: esalt_size = sizeof (tc_t); break;
10418 case 6223: esalt_size = sizeof (tc_t); break;
10419 case 6231: esalt_size = sizeof (tc_t); break;
10420 case 6232: esalt_size = sizeof (tc_t); break;
10421 case 6233: esalt_size = sizeof (tc_t); break;
10422 case 6241: esalt_size = sizeof (tc_t); break;
10423 case 6242: esalt_size = sizeof (tc_t); break;
10424 case 6243: esalt_size = sizeof (tc_t); break;
10425 case 6600: esalt_size = sizeof (agilekey_t); break;
10426 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10427 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10428 case 7300: esalt_size = sizeof (rakp_t); break;
10429 case 7500: esalt_size = sizeof (krb5pa_t); break;
10430 case 8200: esalt_size = sizeof (cloudkey_t); break;
10431 case 8800: esalt_size = sizeof (androidfde_t); break;
10432 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10433 case 9400: esalt_size = sizeof (office2007_t); break;
10434 case 9500: esalt_size = sizeof (office2010_t); break;
10435 case 9600: esalt_size = sizeof (office2013_t); break;
10436 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10437 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10438 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10439 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10440 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10441 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10442 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10443 case 10200: esalt_size = sizeof (cram_md5_t); break;
10444 case 10400: esalt_size = sizeof (pdf_t); break;
10445 case 10410: esalt_size = sizeof (pdf_t); break;
10446 case 10420: esalt_size = sizeof (pdf_t); break;
10447 case 10500: esalt_size = sizeof (pdf_t); break;
10448 case 10600: esalt_size = sizeof (pdf_t); break;
10449 case 10700: esalt_size = sizeof (pdf_t); break;
10450 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10451 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10452 case 11400: esalt_size = sizeof (sip_t); break;
10453 case 11600: esalt_size = sizeof (seven_zip_t); break;
10454 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10455 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10456 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10457 case 13000: esalt_size = sizeof (rar5_t); break;
10458 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10459 }
10460
10461 data.esalt_size = esalt_size;
10462
10463 /**
10464 * choose dictionary parser
10465 */
10466
10467 if (hash_type == HASH_TYPE_LM)
10468 {
10469 get_next_word_func = get_next_word_lm;
10470 }
10471 else if (opts_type & OPTS_TYPE_PT_UPPER)
10472 {
10473 get_next_word_func = get_next_word_uc;
10474 }
10475 else
10476 {
10477 get_next_word_func = get_next_word_std;
10478 }
10479
10480 /**
10481 * dictstat
10482 */
10483
10484 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10485
10486 #ifdef _POSIX
10487 size_t dictstat_nmemb = 0;
10488 #endif
10489
10490 #ifdef _WIN
10491 uint dictstat_nmemb = 0;
10492 #endif
10493
10494 char dictstat[256] = { 0 };
10495
10496 FILE *dictstat_fp = NULL;
10497
10498 if (keyspace == 0)
10499 {
10500 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10501
10502 dictstat_fp = fopen (dictstat, "rb");
10503
10504 if (dictstat_fp)
10505 {
10506 #ifdef _POSIX
10507 struct stat tmpstat;
10508
10509 fstat (fileno (dictstat_fp), &tmpstat);
10510 #endif
10511
10512 #ifdef _WIN
10513 struct stat64 tmpstat;
10514
10515 _fstat64 (fileno (dictstat_fp), &tmpstat);
10516 #endif
10517
10518 if (tmpstat.st_mtime < COMPTIME)
10519 {
10520 /* with v0.15 the format changed so we have to ensure user is using a good version
10521 since there is no version-header in the dictstat file */
10522
10523 fclose (dictstat_fp);
10524
10525 unlink (dictstat);
10526 }
10527 else
10528 {
10529 while (!feof (dictstat_fp))
10530 {
10531 dictstat_t d;
10532
10533 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10534
10535 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10536
10537 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10538 {
10539 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10540
10541 return -1;
10542 }
10543 }
10544
10545 fclose (dictstat_fp);
10546 }
10547 }
10548 }
10549
10550 /**
10551 * potfile
10552 */
10553
10554 char potfile[256] = { 0 };
10555
10556 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10557
10558 data.pot_fp = NULL;
10559
10560 FILE *out_fp = NULL;
10561 FILE *pot_fp = NULL;
10562
10563 if (show == 1 || left == 1)
10564 {
10565 pot_fp = fopen (potfile, "rb");
10566
10567 if (pot_fp == NULL)
10568 {
10569 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10570
10571 return (-1);
10572 }
10573
10574 if (outfile != NULL)
10575 {
10576 if ((out_fp = fopen (outfile, "ab")) == NULL)
10577 {
10578 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10579
10580 fclose (pot_fp);
10581
10582 return (-1);
10583 }
10584 }
10585 else
10586 {
10587 out_fp = stdout;
10588 }
10589 }
10590 else
10591 {
10592 if (potfile_disable == 0)
10593 {
10594 pot_fp = fopen (potfile, "ab");
10595
10596 if (pot_fp == NULL)
10597 {
10598 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10599
10600 return (-1);
10601 }
10602
10603 data.pot_fp = pot_fp;
10604 }
10605 }
10606
10607 pot_t *pot = NULL;
10608
10609 uint pot_cnt = 0;
10610 uint pot_avail = 0;
10611
10612 if (show == 1 || left == 1)
10613 {
10614 SUPPRESS_OUTPUT = 1;
10615
10616 pot_avail = count_lines (pot_fp);
10617
10618 rewind (pot_fp);
10619
10620 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10621
10622 uint pot_hashes_avail = 0;
10623
10624 uint line_num = 0;
10625
10626 while (!feof (pot_fp))
10627 {
10628 line_num++;
10629
10630 char line_buf[BUFSIZ] = { 0 };
10631
10632 int line_len = fgetl (pot_fp, line_buf);
10633
10634 if (line_len == 0) continue;
10635
10636 char *plain_buf = line_buf + line_len;
10637
10638 pot_t *pot_ptr = &pot[pot_cnt];
10639
10640 hash_t *hashes_buf = &pot_ptr->hash;
10641
10642 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10643 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10644
10645 if (pot_cnt == pot_hashes_avail)
10646 {
10647 uint pos = 0;
10648
10649 for (pos = 0; pos < INCR_POT; pos++)
10650 {
10651 if ((pot_cnt + pos) >= pot_avail) break;
10652
10653 pot_t *tmp_pot = &pot[pot_cnt + pos];
10654
10655 hash_t *tmp_hash = &tmp_pot->hash;
10656
10657 tmp_hash->digest = mymalloc (dgst_size);
10658
10659 if (isSalted)
10660 {
10661 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10662 }
10663
10664 if (esalt_size)
10665 {
10666 tmp_hash->esalt = mymalloc (esalt_size);
10667 }
10668
10669 pot_hashes_avail++;
10670 }
10671 }
10672
10673 int plain_len = 0;
10674
10675 int parser_status;
10676
10677 int iter = MAX_CUT_TRIES;
10678
10679 do
10680 {
10681 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10682 {
10683 if (line_buf[i] == ':')
10684 {
10685 line_len--;
10686
10687 break;
10688 }
10689 }
10690
10691 if (data.hash_mode != 2500)
10692 {
10693 parser_status = parse_func (line_buf, line_len, hashes_buf);
10694 }
10695 else
10696 {
10697 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10698
10699 if (line_len > max_salt_size)
10700 {
10701 parser_status = PARSER_GLOBAL_LENGTH;
10702 }
10703 else
10704 {
10705 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10706
10707 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10708
10709 hashes_buf->salt->salt_len = line_len;
10710
10711 parser_status = PARSER_OK;
10712 }
10713 }
10714
10715 // if NOT parsed without error, we add the ":" to the plain
10716
10717 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10718 {
10719 plain_len++;
10720 plain_buf--;
10721 }
10722
10723 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10724
10725 if (parser_status < PARSER_GLOBAL_ZERO)
10726 {
10727 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10728
10729 continue;
10730 }
10731
10732 if (plain_len >= 255) continue;
10733
10734 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10735
10736 pot_ptr->plain_len = plain_len;
10737
10738 pot_cnt++;
10739 }
10740
10741 fclose (pot_fp);
10742
10743 SUPPRESS_OUTPUT = 0;
10744
10745 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10746 }
10747
10748 /**
10749 * word len
10750 */
10751
10752 uint pw_min = PW_MIN;
10753 uint pw_max = PW_MAX;
10754
10755 switch (hash_mode)
10756 {
10757 case 400: if (pw_max > 40) pw_max = 40;
10758 break;
10759 case 500: if (pw_max > 16) pw_max = 16;
10760 break;
10761 case 1500: if (pw_max > 8) pw_max = 8;
10762 break;
10763 case 1600: if (pw_max > 16) pw_max = 16;
10764 break;
10765 case 1800: if (pw_max > 16) pw_max = 16;
10766 break;
10767 case 2100: if (pw_max > 16) pw_max = 16;
10768 break;
10769 case 2500: if (pw_min < 8) pw_min = 8;
10770 break;
10771 case 3000: if (pw_max > 7) pw_max = 7;
10772 break;
10773 case 5200: if (pw_max > 24) pw_max = 24;
10774 break;
10775 case 5800: if (pw_max > 16) pw_max = 16;
10776 break;
10777 case 6300: if (pw_max > 16) pw_max = 16;
10778 break;
10779 case 7400: if (pw_max > 16) pw_max = 16;
10780 break;
10781 case 7900: if (pw_max > 48) pw_max = 48;
10782 break;
10783 case 8500: if (pw_max > 8) pw_max = 8;
10784 break;
10785 case 8600: if (pw_max > 16) pw_max = 16;
10786 break;
10787 case 9710: pw_min = 5;
10788 pw_max = 5;
10789 break;
10790 case 9810: pw_min = 5;
10791 pw_max = 5;
10792 break;
10793 case 10410: pw_min = 5;
10794 pw_max = 5;
10795 break;
10796 case 10300: if (pw_max < 3) pw_min = 3;
10797 if (pw_max > 40) pw_max = 40;
10798 break;
10799 case 10500: if (pw_max < 3) pw_min = 3;
10800 if (pw_max > 40) pw_max = 40;
10801 break;
10802 case 10700: if (pw_max > 16) pw_max = 16;
10803 break;
10804 case 11300: if (pw_max > 40) pw_max = 40;
10805 break;
10806 case 12500: if (pw_max > 20) pw_max = 20;
10807 break;
10808 case 12800: if (pw_max > 24) pw_max = 24;
10809 break;
10810 }
10811
10812 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10813 {
10814 switch (attack_kern)
10815 {
10816 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10817 break;
10818 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10819 break;
10820 }
10821 }
10822
10823 /**
10824 * charsets : keep them together for more easy maintainnce
10825 */
10826
10827 cs_t mp_sys[6] = { { { 0 }, 0 } };
10828 cs_t mp_usr[4] = { { { 0 }, 0 } };
10829
10830 mp_setup_sys (mp_sys);
10831
10832 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10833 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10834 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10835 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10836
10837 /**
10838 * load hashes, part I: find input mode, count hashes
10839 */
10840
10841 uint hashlist_mode = 0;
10842 uint hashlist_format = HLFMT_HASHCAT;
10843
10844 uint hashes_avail = 0;
10845
10846 if (benchmark == 0)
10847 {
10848 struct stat f;
10849
10850 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10851
10852 if ((hash_mode == 2500) ||
10853 (hash_mode == 5200) ||
10854 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10855 (hash_mode == 9000))
10856 {
10857 hashlist_mode = HL_MODE_ARG;
10858
10859 char *hashfile = myargv[optind];
10860
10861 data.hashfile = hashfile;
10862
10863 logfile_top_var_string ("target", hashfile);
10864 }
10865
10866 if (hashlist_mode == HL_MODE_ARG)
10867 {
10868 if (hash_mode == 2500)
10869 {
10870 struct stat st;
10871
10872 if (stat (data.hashfile, &st) == -1)
10873 {
10874 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10875
10876 return (-1);
10877 }
10878
10879 hashes_avail = st.st_size / sizeof (hccap_t);
10880 }
10881 else
10882 {
10883 hashes_avail = 1;
10884 }
10885 }
10886 else if (hashlist_mode == HL_MODE_FILE)
10887 {
10888 char *hashfile = myargv[optind];
10889
10890 data.hashfile = hashfile;
10891
10892 logfile_top_var_string ("target", hashfile);
10893
10894 FILE *fp = NULL;
10895
10896 if ((fp = fopen (hashfile, "rb")) == NULL)
10897 {
10898 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10899
10900 return (-1);
10901 }
10902
10903 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10904
10905 hashes_avail = count_lines (fp);
10906
10907 rewind (fp);
10908
10909 if (hashes_avail == 0)
10910 {
10911 log_error ("ERROR: hashfile is empty or corrupt");
10912
10913 fclose (fp);
10914
10915 return (-1);
10916 }
10917
10918 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10919
10920 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10921 {
10922 log_error ("ERROR: remove not supported in native hashfile-format mode");
10923
10924 fclose (fp);
10925
10926 return (-1);
10927 }
10928
10929 fclose (fp);
10930 }
10931 }
10932 else
10933 {
10934 hashlist_mode = HL_MODE_ARG;
10935
10936 hashes_avail = 1;
10937 }
10938
10939 if (hash_mode == 3000) hashes_avail *= 2;
10940
10941 data.hashlist_mode = hashlist_mode;
10942 data.hashlist_format = hashlist_format;
10943
10944 logfile_top_uint (hashlist_mode);
10945 logfile_top_uint (hashlist_format);
10946
10947 /**
10948 * load hashes, part II: allocate required memory, set pointers
10949 */
10950
10951 hash_t *hashes_buf = NULL;
10952 void *digests_buf = NULL;
10953 salt_t *salts_buf = NULL;
10954 void *esalts_buf = NULL;
10955
10956 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10957
10958 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10959
10960 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10961 {
10962 u32 hash_pos;
10963
10964 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10965 {
10966 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10967
10968 hashes_buf[hash_pos].hash_info = hash_info;
10969
10970 if (username && (remove || show || left))
10971 {
10972 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10973 }
10974
10975 if (benchmark)
10976 {
10977 hash_info->orighash = (char *) mymalloc (256);
10978 }
10979 }
10980 }
10981
10982 if (isSalted)
10983 {
10984 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10985
10986 if (esalt_size)
10987 {
10988 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10989 }
10990 }
10991 else
10992 {
10993 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10994 }
10995
10996 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10997 {
10998 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10999
11000 if (isSalted)
11001 {
11002 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11003
11004 if (esalt_size)
11005 {
11006 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11007 }
11008 }
11009 else
11010 {
11011 hashes_buf[hash_pos].salt = &salts_buf[0];
11012 }
11013 }
11014
11015 /**
11016 * load hashes, part III: parse hashes or generate them if benchmark
11017 */
11018
11019 uint hashes_cnt = 0;
11020
11021 if (benchmark == 0)
11022 {
11023 if (keyspace == 1)
11024 {
11025 // useless to read hash file for keyspace, cheat a little bit w/ optind
11026 }
11027 else if (hashes_avail == 0)
11028 {
11029 }
11030 else if (hashlist_mode == HL_MODE_ARG)
11031 {
11032 char *input_buf = myargv[optind];
11033
11034 uint input_len = strlen (input_buf);
11035
11036 logfile_top_var_string ("target", input_buf);
11037
11038 char *hash_buf = NULL;
11039 int hash_len = 0;
11040
11041 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11042
11043 if (hash_len)
11044 {
11045 if (opts_type & OPTS_TYPE_HASH_COPY)
11046 {
11047 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11048
11049 hash_info_tmp->orighash = mystrdup (hash_buf);
11050 }
11051
11052 if (isSalted)
11053 {
11054 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11055 }
11056
11057 int parser_status = PARSER_OK;
11058
11059 if (hash_mode == 2500)
11060 {
11061 if (hash_len == 0)
11062 {
11063 log_error ("ERROR: hccap file not specified");
11064
11065 return (-1);
11066 }
11067
11068 hashlist_mode = HL_MODE_FILE;
11069
11070 data.hashlist_mode = hashlist_mode;
11071
11072 FILE *fp = fopen (hash_buf, "rb");
11073
11074 if (fp == NULL)
11075 {
11076 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11077
11078 return (-1);
11079 }
11080
11081 if (hashes_avail < 1)
11082 {
11083 log_error ("ERROR: hccap file is empty or corrupt");
11084
11085 fclose (fp);
11086
11087 return (-1);
11088 }
11089
11090 uint hccap_size = sizeof (hccap_t);
11091
11092 char *in = (char *) mymalloc (hccap_size);
11093
11094 while (!feof (fp))
11095 {
11096 int n = fread (in, hccap_size, 1, fp);
11097
11098 if (n != 1)
11099 {
11100 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11101
11102 break;
11103 }
11104
11105 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11106
11107 if (parser_status != PARSER_OK)
11108 {
11109 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11110
11111 continue;
11112 }
11113
11114 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11115
11116 if ((show == 1) || (left == 1))
11117 {
11118 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11119
11120 char *salt_ptr = (char *) tmp_salt->salt_buf;
11121
11122 int cur_pos = tmp_salt->salt_len;
11123 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11124
11125 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11126
11127 u8 *pke_ptr = (u8 *) wpa->pke;
11128
11129 // do the appending task
11130
11131 snprintf (salt_ptr + cur_pos,
11132 rem_len,
11133 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11134 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11135 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11136
11137
11138 // memset () the remaining part of the salt
11139
11140 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11141 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11142
11143 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11144
11145 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11146 }
11147
11148 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);
11149 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);
11150
11151 hashes_cnt++;
11152 }
11153
11154 fclose (fp);
11155
11156 myfree (in);
11157 }
11158 else if (hash_mode == 3000)
11159 {
11160 if (hash_len == 32)
11161 {
11162 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11163
11164 hash_t *lm_hash_left = NULL;
11165
11166 if (parser_status == PARSER_OK)
11167 {
11168 lm_hash_left = &hashes_buf[hashes_cnt];
11169
11170 hashes_cnt++;
11171 }
11172 else
11173 {
11174 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11175 }
11176
11177 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11178
11179 hash_t *lm_hash_right = NULL;
11180
11181 if (parser_status == PARSER_OK)
11182 {
11183 lm_hash_right = &hashes_buf[hashes_cnt];
11184
11185 hashes_cnt++;
11186 }
11187 else
11188 {
11189 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11190 }
11191
11192 // show / left
11193
11194 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11195 {
11196 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);
11197 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);
11198 }
11199 }
11200 else
11201 {
11202 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11203
11204 if (parser_status == PARSER_OK)
11205 {
11206 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11207 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11208 }
11209
11210 if (parser_status == PARSER_OK)
11211 {
11212 hashes_cnt++;
11213 }
11214 else
11215 {
11216 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11217 }
11218 }
11219 }
11220 else
11221 {
11222 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11223
11224 if (parser_status == PARSER_OK)
11225 {
11226 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11227 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11228 }
11229
11230 if (parser_status == PARSER_OK)
11231 {
11232 hashes_cnt++;
11233 }
11234 else
11235 {
11236 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11237 }
11238 }
11239 }
11240 }
11241 else if (hashlist_mode == HL_MODE_FILE)
11242 {
11243 char *hashfile = data.hashfile;
11244
11245 FILE *fp;
11246
11247 if ((fp = fopen (hashfile, "rb")) == NULL)
11248 {
11249 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11250
11251 return (-1);
11252 }
11253
11254 uint line_num = 0;
11255
11256 while (!feof (fp))
11257 {
11258 line_num++;
11259
11260 char line_buf[BUFSIZ] = { 0 };
11261
11262 int line_len = fgetl (fp, line_buf);
11263
11264 if (line_len == 0) continue;
11265
11266 char *hash_buf = NULL;
11267 int hash_len = 0;
11268
11269 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11270
11271 if (username)
11272 {
11273 char *user_buf = NULL;
11274 int user_len = 0;
11275
11276 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11277
11278 if (remove || show)
11279 {
11280 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11281
11282 *user = (user_t *) mymalloc (sizeof (user_t));
11283
11284 user_t *user_ptr = *user;
11285
11286 if (user_buf != NULL)
11287 {
11288 user_ptr->user_name = mystrdup (user_buf);
11289 }
11290 else
11291 {
11292 user_ptr->user_name = mystrdup ("");
11293 }
11294
11295 user_ptr->user_len = user_len;
11296 }
11297 }
11298
11299 if (opts_type & OPTS_TYPE_HASH_COPY)
11300 {
11301 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11302
11303 hash_info_tmp->orighash = mystrdup (hash_buf);
11304 }
11305
11306 if (isSalted)
11307 {
11308 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11309 }
11310
11311 if (hash_mode == 3000)
11312 {
11313 if (hash_len == 32)
11314 {
11315 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11316
11317 if (parser_status < PARSER_GLOBAL_ZERO)
11318 {
11319 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11320
11321 continue;
11322 }
11323
11324 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11325
11326 hashes_cnt++;
11327
11328 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11329
11330 if (parser_status < PARSER_GLOBAL_ZERO)
11331 {
11332 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11333
11334 continue;
11335 }
11336
11337 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11338
11339 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);
11340
11341 hashes_cnt++;
11342
11343 // show / left
11344
11345 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);
11346 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);
11347 }
11348 else
11349 {
11350 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11351
11352 if (parser_status < PARSER_GLOBAL_ZERO)
11353 {
11354 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11355
11356 continue;
11357 }
11358
11359 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);
11360
11361 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11362 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11363
11364 hashes_cnt++;
11365 }
11366 }
11367 else
11368 {
11369 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11370
11371 if (parser_status < PARSER_GLOBAL_ZERO)
11372 {
11373 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11374
11375 continue;
11376 }
11377
11378 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);
11379
11380 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11381 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11382
11383 hashes_cnt++;
11384 }
11385 }
11386
11387 fclose (fp);
11388
11389 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11390
11391 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11392 }
11393 }
11394 else
11395 {
11396 if (isSalted)
11397 {
11398 hashes_buf[0].salt->salt_len = 8;
11399
11400 // special salt handling
11401
11402 switch (hash_mode)
11403 {
11404 case 1500: hashes_buf[0].salt->salt_len = 2;
11405 break;
11406 case 1731: hashes_buf[0].salt->salt_len = 4;
11407 break;
11408 case 2410: hashes_buf[0].salt->salt_len = 4;
11409 break;
11410 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11411 break;
11412 case 3100: hashes_buf[0].salt->salt_len = 1;
11413 break;
11414 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11415 break;
11416 case 5800: hashes_buf[0].salt->salt_len = 16;
11417 break;
11418 case 6800: hashes_buf[0].salt->salt_len = 32;
11419 break;
11420 case 8400: hashes_buf[0].salt->salt_len = 40;
11421 break;
11422 case 8800: hashes_buf[0].salt->salt_len = 16;
11423 break;
11424 case 8900: hashes_buf[0].salt->salt_len = 16;
11425 hashes_buf[0].salt->scrypt_N = 1024;
11426 hashes_buf[0].salt->scrypt_r = 1;
11427 hashes_buf[0].salt->scrypt_p = 1;
11428 break;
11429 case 9100: hashes_buf[0].salt->salt_len = 16;
11430 break;
11431 case 9300: hashes_buf[0].salt->salt_len = 14;
11432 hashes_buf[0].salt->scrypt_N = 16384;
11433 hashes_buf[0].salt->scrypt_r = 1;
11434 hashes_buf[0].salt->scrypt_p = 1;
11435 break;
11436 case 9400: hashes_buf[0].salt->salt_len = 16;
11437 break;
11438 case 9500: hashes_buf[0].salt->salt_len = 16;
11439 break;
11440 case 9600: hashes_buf[0].salt->salt_len = 16;
11441 break;
11442 case 9700: hashes_buf[0].salt->salt_len = 16;
11443 break;
11444 case 9710: hashes_buf[0].salt->salt_len = 16;
11445 break;
11446 case 9720: hashes_buf[0].salt->salt_len = 16;
11447 break;
11448 case 9800: hashes_buf[0].salt->salt_len = 16;
11449 break;
11450 case 9810: hashes_buf[0].salt->salt_len = 16;
11451 break;
11452 case 9820: hashes_buf[0].salt->salt_len = 16;
11453 break;
11454 case 10300: hashes_buf[0].salt->salt_len = 12;
11455 break;
11456 case 11500: hashes_buf[0].salt->salt_len = 4;
11457 break;
11458 case 11600: hashes_buf[0].salt->salt_len = 4;
11459 break;
11460 case 12400: hashes_buf[0].salt->salt_len = 4;
11461 break;
11462 case 12500: hashes_buf[0].salt->salt_len = 8;
11463 break;
11464 case 12600: hashes_buf[0].salt->salt_len = 64;
11465 break;
11466 }
11467
11468 // special esalt handling
11469
11470 switch (hash_mode)
11471 {
11472 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11473 break;
11474 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11475 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11476 break;
11477 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11478 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11479 break;
11480 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11481 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11482 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11483 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11484 break;
11485 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11486 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11487 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11488 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11489 break;
11490 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11491 break;
11492 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11493 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11494 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11495 break;
11496 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11497 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11498 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11499 break;
11500 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11501 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11502 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11503 break;
11504 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11505 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11506 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11507 break;
11508 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11509 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11510 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11511 break;
11512 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11513 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11514 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11515 break;
11516 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11517 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11518 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11519 break;
11520 }
11521 }
11522
11523 // set hashfile
11524
11525 switch (hash_mode)
11526 {
11527 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11528 break;
11529 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11530 break;
11531 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11532 break;
11533 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11534 break;
11535 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11536 break;
11537 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11538 break;
11539 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11540 break;
11541 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11542 break;
11543 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11544 break;
11545 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11546 break;
11547 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11548 break;
11549 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11550 break;
11551 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11552 break;
11553 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11554 break;
11555 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11556 break;
11557 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11558 break;
11559 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11560 break;
11561 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11562 break;
11563 }
11564
11565 // set default iterations
11566
11567 switch (hash_mode)
11568 {
11569 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11570 break;
11571 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11572 break;
11573 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11574 break;
11575 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11576 break;
11577 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11578 break;
11579 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11580 break;
11581 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11582 break;
11583 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11584 break;
11585 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11586 break;
11587 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11588 break;
11589 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11590 break;
11591 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11592 break;
11593 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11594 break;
11595 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11596 break;
11597 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11598 break;
11599 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11600 break;
11601 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11602 break;
11603 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11604 break;
11605 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11606 break;
11607 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11608 break;
11609 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11610 break;
11611 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11612 break;
11613 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11614 break;
11615 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11616 break;
11617 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11618 break;
11619 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11620 break;
11621 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11622 break;
11623 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11624 break;
11625 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11626 break;
11627 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11628 break;
11629 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11630 break;
11631 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11632 break;
11633 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11634 break;
11635 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11636 break;
11637 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11638 break;
11639 case 8900: hashes_buf[0].salt->salt_iter = 1;
11640 break;
11641 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11642 break;
11643 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11644 break;
11645 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11646 break;
11647 case 9300: hashes_buf[0].salt->salt_iter = 1;
11648 break;
11649 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11650 break;
11651 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11652 break;
11653 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11654 break;
11655 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11656 break;
11657 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11658 break;
11659 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11660 break;
11661 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11662 break;
11663 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11664 break;
11665 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11666 break;
11667 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11668 break;
11669 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11670 break;
11671 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11672 break;
11673 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11674 break;
11675 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11676 break;
11677 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11678 break;
11679 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11680 break;
11681 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11682 break;
11683 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11684 break;
11685 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11686 break;
11687 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11688 break;
11689 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11690 break;
11691 }
11692
11693 hashes_cnt = 1;
11694 }
11695
11696 if (show == 1 || left == 1)
11697 {
11698 for (uint i = 0; i < pot_cnt; i++)
11699 {
11700 pot_t *pot_ptr = &pot[i];
11701
11702 hash_t *hashes_buf = &pot_ptr->hash;
11703
11704 local_free (hashes_buf->digest);
11705
11706 if (isSalted)
11707 {
11708 local_free (hashes_buf->salt);
11709 }
11710 }
11711
11712 local_free (pot);
11713
11714 if (data.quiet == 0) log_info_nn ("");
11715
11716 return (0);
11717 }
11718
11719 if (keyspace == 0)
11720 {
11721 if (hashes_cnt == 0)
11722 {
11723 log_error ("ERROR: No hashes loaded");
11724
11725 return (-1);
11726 }
11727 }
11728
11729 /**
11730 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11731 */
11732
11733 if (data.outfile != NULL)
11734 {
11735 if (data.hashfile != NULL)
11736 {
11737 #ifdef _POSIX
11738 struct stat tmpstat_outfile;
11739 struct stat tmpstat_hashfile;
11740 #endif
11741
11742 #ifdef _WIN
11743 struct stat64 tmpstat_outfile;
11744 struct stat64 tmpstat_hashfile;
11745 #endif
11746
11747 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11748
11749 if (tmp_outfile_fp)
11750 {
11751 #ifdef _POSIX
11752 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11753 #endif
11754
11755 #ifdef _WIN
11756 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11757 #endif
11758
11759 fclose (tmp_outfile_fp);
11760 }
11761
11762 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11763
11764 if (tmp_hashfile_fp)
11765 {
11766 #ifdef _POSIX
11767 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11768 #endif
11769
11770 #ifdef _WIN
11771 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11772 #endif
11773
11774 fclose (tmp_hashfile_fp);
11775 }
11776
11777 if (tmp_outfile_fp && tmp_outfile_fp)
11778 {
11779 tmpstat_outfile.st_mode = 0;
11780 tmpstat_outfile.st_nlink = 0;
11781 tmpstat_outfile.st_uid = 0;
11782 tmpstat_outfile.st_gid = 0;
11783 tmpstat_outfile.st_rdev = 0;
11784 tmpstat_outfile.st_atime = 0;
11785
11786 tmpstat_hashfile.st_mode = 0;
11787 tmpstat_hashfile.st_nlink = 0;
11788 tmpstat_hashfile.st_uid = 0;
11789 tmpstat_hashfile.st_gid = 0;
11790 tmpstat_hashfile.st_rdev = 0;
11791 tmpstat_hashfile.st_atime = 0;
11792
11793 #ifdef _POSIX
11794 tmpstat_outfile.st_blksize = 0;
11795 tmpstat_outfile.st_blocks = 0;
11796
11797 tmpstat_hashfile.st_blksize = 0;
11798 tmpstat_hashfile.st_blocks = 0;
11799 #endif
11800
11801 #ifdef _POSIX
11802 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11803 {
11804 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11805
11806 return (-1);
11807 }
11808 #endif
11809
11810 #ifdef _WIN
11811 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11812 {
11813 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11814
11815 return (-1);
11816 }
11817 #endif
11818 }
11819 }
11820 }
11821
11822 /**
11823 * Remove duplicates
11824 */
11825
11826 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11827
11828 if (isSalted)
11829 {
11830 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11831 }
11832 else
11833 {
11834 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11835 }
11836
11837 uint hashes_cnt_orig = hashes_cnt;
11838
11839 hashes_cnt = 1;
11840
11841 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11842 {
11843 if (isSalted)
11844 {
11845 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11846 {
11847 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11848 }
11849 }
11850 else
11851 {
11852 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11853 }
11854
11855 if (hashes_pos > hashes_cnt)
11856 {
11857 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11858 }
11859
11860 hashes_cnt++;
11861 }
11862
11863 /**
11864 * Potfile removes
11865 */
11866
11867 uint potfile_remove_cracks = 0;
11868
11869 if (potfile_disable == 0)
11870 {
11871 hash_t hash_buf;
11872
11873 hash_buf.digest = mymalloc (dgst_size);
11874 hash_buf.salt = NULL;
11875 hash_buf.esalt = NULL;
11876 hash_buf.hash_info = NULL;
11877 hash_buf.cracked = 0;
11878
11879 if (isSalted)
11880 {
11881 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11882 }
11883
11884 if (esalt_size)
11885 {
11886 hash_buf.esalt = mymalloc (esalt_size);
11887 }
11888
11889 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11890
11891 // no solution for these special hash types (for instane because they use hashfile in output etc)
11892 if ((hash_mode != 5200) &&
11893 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11894 (hash_mode != 9000))
11895 {
11896 FILE *fp = fopen (potfile, "rb");
11897
11898 if (fp != NULL)
11899 {
11900 while (!feof (fp))
11901 {
11902 char line_buf[BUFSIZ] = { 0 };
11903
11904 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11905
11906 if (ptr == NULL) break;
11907
11908 int line_len = strlen (line_buf);
11909
11910 if (line_len == 0) continue;
11911
11912 int iter = MAX_CUT_TRIES;
11913
11914 for (int i = line_len - 1; i && iter; i--, line_len--)
11915 {
11916 if (line_buf[i] != ':') continue;
11917
11918 if (isSalted)
11919 {
11920 memset (hash_buf.salt, 0, sizeof (salt_t));
11921 }
11922
11923 hash_t *found = NULL;
11924
11925 if (hash_mode == 6800)
11926 {
11927 if (i < 64) // 64 = 16 * uint in salt_buf[]
11928 {
11929 // manipulate salt_buf
11930 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11931
11932 hash_buf.salt->salt_len = i;
11933
11934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11935 }
11936 }
11937 else if (hash_mode == 2500)
11938 {
11939 if (i < 64) // 64 = 16 * uint in salt_buf[]
11940 {
11941 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11942 // manipulate salt_buf
11943
11944 // to be safe work with a copy (because of line_len loop, i etc)
11945
11946 char line_buf_cpy[BUFSIZ] = { 0 };
11947
11948 memcpy (line_buf_cpy, line_buf, i);
11949
11950 char *mac2_pos = strrchr (line_buf_cpy, ':');
11951
11952 if (mac2_pos == NULL) continue;
11953
11954 mac2_pos[0] = 0;
11955 mac2_pos++;
11956
11957 if (strlen (mac2_pos) != 12) continue;
11958
11959 char *mac1_pos = strrchr (line_buf_cpy, ':');
11960
11961 if (mac1_pos == NULL) continue;
11962
11963 mac1_pos[0] = 0;
11964 mac1_pos++;
11965
11966 if (strlen (mac1_pos) != 12) continue;
11967
11968 uint essid_length = mac1_pos - line_buf_cpy - 1;
11969
11970 // here we need the ESSID
11971 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11972
11973 hash_buf.salt->salt_len = essid_length;
11974
11975 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11976
11977 if (found)
11978 {
11979 wpa_t *wpa = (wpa_t *) found->esalt;
11980
11981 uint pke[25] = { 0 };
11982
11983 char *pke_ptr = (char *) pke;
11984
11985 for (uint i = 0; i < 25; i++)
11986 {
11987 pke[i] = byte_swap_32 (wpa->pke[i]);
11988 }
11989
11990 u8 mac1[6] = { 0 };
11991 u8 mac2[6] = { 0 };
11992
11993 memcpy (mac1, pke_ptr + 23, 6);
11994 memcpy (mac2, pke_ptr + 29, 6);
11995
11996 // compare hex string(s) vs binary MAC address(es)
11997
11998 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11999 {
12000 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12001 {
12002 found = NULL;
12003 break;
12004 }
12005 }
12006
12007 // early skip ;)
12008 if (!found) continue;
12009
12010 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12011 {
12012 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12013 {
12014 found = NULL;
12015 break;
12016 }
12017 }
12018 }
12019 }
12020 }
12021 else
12022 {
12023 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12024
12025 if (parser_status == PARSER_OK)
12026 {
12027 if (isSalted)
12028 {
12029 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12030 }
12031 else
12032 {
12033 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12034 }
12035 }
12036 }
12037
12038 if (found == NULL) continue;
12039
12040 if (!found->cracked) potfile_remove_cracks++;
12041
12042 found->cracked = 1;
12043
12044 if (found) break;
12045
12046 iter--;
12047 }
12048 }
12049
12050 fclose (fp);
12051 }
12052 }
12053
12054 if (esalt_size)
12055 {
12056 local_free (hash_buf.esalt);
12057 }
12058
12059 if (isSalted)
12060 {
12061 local_free (hash_buf.salt);
12062 }
12063
12064 local_free (hash_buf.digest);
12065 }
12066
12067 /**
12068 * Now generate all the buffers required for later
12069 */
12070
12071 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12072
12073 salt_t *salts_buf_new = NULL;
12074 void *esalts_buf_new = NULL;
12075
12076 if (isSalted)
12077 {
12078 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12079
12080 if (esalt_size)
12081 {
12082 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12083 }
12084 }
12085 else
12086 {
12087 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12088 }
12089
12090 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12091
12092 uint digests_cnt = hashes_cnt;
12093 uint digests_done = 0;
12094
12095 uint size_digests = digests_cnt * dgst_size;
12096 uint size_shown = digests_cnt * sizeof (uint);
12097
12098 uint *digests_shown = (uint *) mymalloc (size_shown);
12099 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12100
12101 uint salts_cnt = 0;
12102 uint salts_done = 0;
12103
12104 hashinfo_t **hash_info = NULL;
12105
12106 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12107 {
12108 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12109
12110 if (username && (remove || show))
12111 {
12112 uint user_pos;
12113
12114 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12115 {
12116 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12117
12118 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12119 }
12120 }
12121 }
12122
12123 uint *salts_shown = (uint *) mymalloc (size_shown);
12124
12125 salt_t *salt_buf;
12126
12127 {
12128 // copied from inner loop
12129
12130 salt_buf = &salts_buf_new[salts_cnt];
12131
12132 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12133
12134 if (esalt_size)
12135 {
12136 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12137 }
12138
12139 salt_buf->digests_cnt = 0;
12140 salt_buf->digests_done = 0;
12141 salt_buf->digests_offset = 0;
12142
12143 salts_cnt++;
12144 }
12145
12146 if (hashes_buf[0].cracked == 1)
12147 {
12148 digests_shown[0] = 1;
12149
12150 digests_done++;
12151
12152 salt_buf->digests_done++;
12153 }
12154
12155 salt_buf->digests_cnt++;
12156
12157 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12158
12159 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12160 {
12161 hash_info[0] = hashes_buf[0].hash_info;
12162 }
12163
12164 // copy from inner loop
12165
12166 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12167 {
12168 if (isSalted)
12169 {
12170 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12171 {
12172 salt_buf = &salts_buf_new[salts_cnt];
12173
12174 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12175
12176 if (esalt_size)
12177 {
12178 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12179 }
12180
12181 salt_buf->digests_cnt = 0;
12182 salt_buf->digests_done = 0;
12183 salt_buf->digests_offset = hashes_pos;
12184
12185 salts_cnt++;
12186 }
12187 }
12188
12189 if (hashes_buf[hashes_pos].cracked == 1)
12190 {
12191 digests_shown[hashes_pos] = 1;
12192
12193 digests_done++;
12194
12195 salt_buf->digests_done++;
12196 }
12197
12198 salt_buf->digests_cnt++;
12199
12200 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12201
12202 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12203 {
12204 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12205 }
12206 }
12207
12208 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12209 {
12210 salt_t *salt_buf = &salts_buf_new[salt_pos];
12211
12212 if (salt_buf->digests_done == salt_buf->digests_cnt)
12213 {
12214 salts_shown[salt_pos] = 1;
12215
12216 salts_done++;
12217 }
12218
12219 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12220 }
12221
12222 local_free (digests_buf);
12223 local_free (salts_buf);
12224 local_free (esalts_buf);
12225
12226 digests_buf = digests_buf_new;
12227 salts_buf = salts_buf_new;
12228 esalts_buf = esalts_buf_new;
12229
12230 local_free (hashes_buf);
12231
12232 /**
12233 * special modification not set from parser
12234 */
12235
12236 switch (hash_mode)
12237 {
12238 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12239 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12240 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12241 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12242 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12243 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12244 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12245 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12246 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12247 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12248 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12249 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12250 }
12251
12252 if (truecrypt_keyfiles)
12253 {
12254 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12255
12256 char *keyfiles = strdup (truecrypt_keyfiles);
12257
12258 char *keyfile = strtok (keyfiles, ",");
12259
12260 do
12261 {
12262 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12263
12264 } while ((keyfile = strtok (NULL, ",")) != NULL);
12265
12266 free (keyfiles);
12267 }
12268
12269 data.digests_cnt = digests_cnt;
12270 data.digests_done = digests_done;
12271 data.digests_buf = digests_buf;
12272 data.digests_shown = digests_shown;
12273 data.digests_shown_tmp = digests_shown_tmp;
12274
12275 data.salts_cnt = salts_cnt;
12276 data.salts_done = salts_done;
12277 data.salts_buf = salts_buf;
12278 data.salts_shown = salts_shown;
12279
12280 data.esalts_buf = esalts_buf;
12281 data.hash_info = hash_info;
12282
12283 /**
12284 * Automatic Optimizers
12285 */
12286
12287 if (salts_cnt == 1)
12288 opti_type |= OPTI_TYPE_SINGLE_SALT;
12289
12290 if (digests_cnt == 1)
12291 opti_type |= OPTI_TYPE_SINGLE_HASH;
12292
12293 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12294 opti_type |= OPTI_TYPE_NOT_ITERATED;
12295
12296 if (attack_mode == ATTACK_MODE_BF)
12297 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12298
12299 data.opti_type = opti_type;
12300
12301 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12302 {
12303 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12304 {
12305 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12306 {
12307 if (opts_type & OPTS_TYPE_ST_ADD80)
12308 {
12309 opts_type &= ~OPTS_TYPE_ST_ADD80;
12310 opts_type |= OPTS_TYPE_PT_ADD80;
12311 }
12312
12313 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12314 {
12315 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12316 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12317 }
12318
12319 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12320 {
12321 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12322 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12323 }
12324 }
12325 }
12326 }
12327
12328 /**
12329 * Some algorithm, like descrypt, can benefit from JIT compilation
12330 */
12331
12332 int force_jit_compilation = -1;
12333
12334 if (hash_mode == 8900)
12335 {
12336 force_jit_compilation = 8900;
12337 }
12338 else if (hash_mode == 9300)
12339 {
12340 force_jit_compilation = 8900;
12341 }
12342 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12343 {
12344 force_jit_compilation = 1500;
12345 }
12346
12347 /**
12348 * generate bitmap tables
12349 */
12350
12351 const uint bitmap_shift1 = 5;
12352 const uint bitmap_shift2 = 13;
12353
12354 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12355
12356 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12357 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12358 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12359 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12360 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12361 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12362 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12363 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12364
12365 uint bitmap_bits;
12366 uint bitmap_nums;
12367 uint bitmap_mask;
12368 uint bitmap_size;
12369
12370 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12371 {
12372 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12373
12374 bitmap_nums = 1 << bitmap_bits;
12375
12376 bitmap_mask = bitmap_nums - 1;
12377
12378 bitmap_size = bitmap_nums * sizeof (uint);
12379
12380 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12381
12382 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;
12383 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;
12384
12385 break;
12386 }
12387
12388 bitmap_nums = 1 << bitmap_bits;
12389
12390 bitmap_mask = bitmap_nums - 1;
12391
12392 bitmap_size = bitmap_nums * sizeof (uint);
12393
12394 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);
12395 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);
12396
12397 /**
12398 * prepare quick rule
12399 */
12400
12401 data.rule_buf_l = rule_buf_l;
12402 data.rule_buf_r = rule_buf_r;
12403
12404 int rule_len_l = (int) strlen (rule_buf_l);
12405 int rule_len_r = (int) strlen (rule_buf_r);
12406
12407 data.rule_len_l = rule_len_l;
12408 data.rule_len_r = rule_len_r;
12409
12410 /**
12411 * load rules
12412 */
12413
12414 uint *all_kernel_rules_cnt = NULL;
12415
12416 kernel_rule_t **all_kernel_rules_buf = NULL;
12417
12418 if (rp_files_cnt)
12419 {
12420 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12421
12422 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12423 }
12424
12425 char rule_buf[BUFSIZ] = { 0 };
12426
12427 int rule_len = 0;
12428
12429 for (uint i = 0; i < rp_files_cnt; i++)
12430 {
12431 uint kernel_rules_avail = 0;
12432
12433 uint kernel_rules_cnt = 0;
12434
12435 kernel_rule_t *kernel_rules_buf = NULL;
12436
12437 char *rp_file = rp_files[i];
12438
12439 char in[BLOCK_SIZE] = { 0 };
12440 char out[BLOCK_SIZE] = { 0 };
12441
12442 FILE *fp = NULL;
12443
12444 uint rule_line = 0;
12445
12446 if ((fp = fopen (rp_file, "rb")) == NULL)
12447 {
12448 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12449
12450 return (-1);
12451 }
12452
12453 while (!feof (fp))
12454 {
12455 memset (rule_buf, 0, BUFSIZ);
12456
12457 rule_len = fgetl (fp, rule_buf);
12458
12459 rule_line++;
12460
12461 if (rule_len == 0) continue;
12462
12463 if (rule_buf[0] == '#') continue;
12464
12465 if (kernel_rules_avail == kernel_rules_cnt)
12466 {
12467 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12468
12469 kernel_rules_avail += INCR_RULES;
12470 }
12471
12472 memset (in, 0, BLOCK_SIZE);
12473 memset (out, 0, BLOCK_SIZE);
12474
12475 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12476
12477 if (result == -1)
12478 {
12479 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12480
12481 continue;
12482 }
12483
12484 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12485 {
12486 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12487
12488 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12489
12490 continue;
12491 }
12492
12493 /* its so slow
12494 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12495 {
12496 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12497
12498 continue;
12499 }
12500 */
12501
12502 kernel_rules_cnt++;
12503 }
12504
12505 fclose (fp);
12506
12507 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12508
12509 all_kernel_rules_buf[i] = kernel_rules_buf;
12510 }
12511
12512 /**
12513 * merge rules or automatic rule generator
12514 */
12515
12516 uint kernel_rules_cnt = 0;
12517
12518 kernel_rule_t *kernel_rules_buf = NULL;
12519
12520 if (attack_mode == ATTACK_MODE_STRAIGHT)
12521 {
12522 if (rp_files_cnt)
12523 {
12524 kernel_rules_cnt = 1;
12525
12526 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12527
12528 repeats[0] = kernel_rules_cnt;
12529
12530 for (uint i = 0; i < rp_files_cnt; i++)
12531 {
12532 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12533
12534 repeats[i + 1] = kernel_rules_cnt;
12535 }
12536
12537 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12538
12539 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12540
12541 for (uint i = 0; i < kernel_rules_cnt; i++)
12542 {
12543 uint out_pos = 0;
12544
12545 kernel_rule_t *out = &kernel_rules_buf[i];
12546
12547 for (uint j = 0; j < rp_files_cnt; j++)
12548 {
12549 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12550 uint in_pos;
12551
12552 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12553
12554 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12555 {
12556 if (out_pos == RULES_MAX - 1)
12557 {
12558 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12559
12560 break;
12561 }
12562
12563 out->cmds[out_pos] = in->cmds[in_pos];
12564 }
12565 }
12566 }
12567
12568 local_free (repeats);
12569 }
12570 else if (rp_gen)
12571 {
12572 uint kernel_rules_avail = 0;
12573
12574 while (kernel_rules_cnt < rp_gen)
12575 {
12576 if (kernel_rules_avail == kernel_rules_cnt)
12577 {
12578 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12579
12580 kernel_rules_avail += INCR_RULES;
12581 }
12582
12583 memset (rule_buf, 0, BLOCK_SIZE);
12584
12585 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12586
12587 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12588
12589 kernel_rules_cnt++;
12590 }
12591 }
12592 }
12593
12594 /**
12595 * generate NOP rules
12596 */
12597
12598 if (kernel_rules_cnt == 0)
12599 {
12600 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12601
12602 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12603
12604 kernel_rules_cnt++;
12605 }
12606
12607 data.kernel_rules_cnt = kernel_rules_cnt;
12608 data.kernel_rules_buf = kernel_rules_buf;
12609
12610 /**
12611 * OpenCL platforms: detect
12612 */
12613
12614 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12615 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12616
12617 cl_uint platforms_cnt = 0;
12618 cl_uint platform_devices_cnt = 0;
12619
12620 if (keyspace == 0)
12621 {
12622 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12623
12624 if (platforms_cnt == 0)
12625 {
12626 log_error ("ERROR: No OpenCL compatible platform found");
12627
12628 return (-1);
12629 }
12630 }
12631
12632 /**
12633 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12634 */
12635
12636 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12637 {
12638 cl_platform_id platform = platforms[platform_id];
12639
12640 char platform_vendor[INFOSZ] = { 0 };
12641
12642 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12643
12644 #ifdef HAVE_HWMON
12645 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12646 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12647 {
12648 // make sure that we do not directly control the fan for NVidia
12649
12650 gpu_temp_retain = 0;
12651
12652 data.gpu_temp_retain = gpu_temp_retain;
12653 }
12654 #endif // HAVE_NVML || HAVE_NVAPI
12655 #endif
12656 }
12657
12658 /**
12659 * OpenCL devices: simply push all devices from all platforms into the same device array
12660 */
12661
12662 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12663
12664 data.devices_param = devices_param;
12665
12666 uint devices_cnt = 0;
12667
12668 uint devices_active = 0;
12669
12670 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12671 {
12672 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12673
12674 cl_platform_id platform = platforms[platform_id];
12675
12676 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12677
12678 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12679 {
12680 size_t param_value_size = 0;
12681
12682 const uint device_id = devices_cnt;
12683
12684 hc_device_param_t *device_param = &data.devices_param[device_id];
12685
12686 device_param->device = platform_devices[platform_devices_id];
12687
12688 device_param->device_id = device_id;
12689
12690 device_param->platform_devices_id = platform_devices_id;
12691
12692 // device_type
12693
12694 cl_device_type device_type;
12695
12696 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12697
12698 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12699
12700 device_param->device_type = device_type;
12701
12702 // vendor_id
12703
12704 cl_uint vendor_id = 0;
12705
12706 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12707
12708 device_param->vendor_id = vendor_id;
12709
12710 // device_name
12711
12712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12713
12714 char *device_name = (char *) mymalloc (param_value_size);
12715
12716 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12717
12718 device_param->device_name = device_name;
12719
12720 // tuning db
12721
12722 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12723
12724 // device_version
12725
12726 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12727
12728 char *device_version = (char *) mymalloc (param_value_size);
12729
12730 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12731
12732 device_param->device_version = device_version;
12733
12734 // device_opencl_version
12735
12736 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12737
12738 char *device_opencl_version = (char *) mymalloc (param_value_size);
12739
12740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12741
12742 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12743
12744 myfree (device_opencl_version);
12745
12746 if (strstr (device_version, "pocl"))
12747 {
12748 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12749 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12750
12751 cl_uint vendor_id = VENDOR_ID_GENERIC;
12752
12753 device_param->vendor_id = vendor_id;
12754 }
12755
12756 // vector_width
12757
12758 cl_uint vector_width;
12759
12760 if (opencl_vector_width_chgd == 0)
12761 {
12762 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
12763 {
12764 if (opti_type & OPTI_TYPE_USES_BITS_64)
12765 {
12766 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12767 }
12768 else
12769 {
12770 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12771 }
12772 }
12773 else
12774 {
12775 vector_width = (cl_uint) tuningdb_entry->vector_width;
12776 }
12777 }
12778 else
12779 {
12780 vector_width = opencl_vector_width;
12781 }
12782
12783 if (vector_width > 16) vector_width = 16;
12784
12785 device_param->vector_width = vector_width;
12786
12787 // max_compute_units
12788
12789 cl_uint device_processors;
12790
12791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12792
12793 device_param->device_processors = device_processors;
12794
12795 // max_mem_alloc_size
12796
12797 cl_ulong device_maxmem_alloc;
12798
12799 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12800
12801 device_param->device_maxmem_alloc = device_maxmem_alloc;
12802
12803 // max_mem_alloc_size
12804
12805 cl_ulong device_global_mem;
12806
12807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12808
12809 device_param->device_global_mem = device_global_mem;
12810
12811 // max_clock_frequency
12812
12813 cl_uint device_maxclock_frequency;
12814
12815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12816
12817 device_param->device_maxclock_frequency = device_maxclock_frequency;
12818
12819 // skipped
12820
12821 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12822 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12823
12824 device_param->skipped = (skipped1 || skipped2);
12825
12826 // driver_version
12827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12828
12829 char *driver_version = (char *) mymalloc (param_value_size);
12830
12831 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12832
12833 device_param->driver_version = driver_version;
12834
12835 // device_name_chksum
12836
12837 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12838
12839 #if __x86_64__
12840 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);
12841 #else
12842 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);
12843 #endif
12844
12845 uint device_name_digest[4] = { 0 };
12846
12847 md5_64 ((uint *) device_name_chksum, device_name_digest);
12848
12849 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12850
12851 device_param->device_name_chksum = device_name_chksum;
12852
12853 // device_processor_cores
12854
12855 if (device_type & CL_DEVICE_TYPE_CPU)
12856 {
12857 cl_uint device_processor_cores = 1;
12858
12859 device_param->device_processor_cores = device_processor_cores;
12860 }
12861
12862 if (device_type & CL_DEVICE_TYPE_GPU)
12863 {
12864 if (vendor_id == VENDOR_ID_AMD)
12865 {
12866 cl_uint device_processor_cores = 0;
12867
12868 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12869
12870 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12871
12872 device_param->device_processor_cores = device_processor_cores;
12873 }
12874 else if (vendor_id == VENDOR_ID_NV)
12875 {
12876 cl_uint kernel_exec_timeout = 0;
12877
12878 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12879
12880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12881
12882 device_param->kernel_exec_timeout = kernel_exec_timeout;
12883
12884 cl_uint device_processor_cores = 0;
12885
12886 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12887
12888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12889
12890 device_param->device_processor_cores = device_processor_cores;
12891
12892 cl_uint sm_minor = 0;
12893 cl_uint sm_major = 0;
12894
12895 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12896 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12897
12898 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12899 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12900
12901 device_param->sm_minor = sm_minor;
12902 device_param->sm_major = sm_major;
12903 }
12904 else
12905 {
12906 cl_uint device_processor_cores = 1;
12907
12908 device_param->device_processor_cores = device_processor_cores;
12909 }
12910 }
12911
12912 // display results
12913
12914 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12915 {
12916 if (device_param->skipped == 0)
12917 {
12918 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12919 device_id + 1,
12920 device_name,
12921 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12922 (unsigned int) (device_global_mem / 1024 / 1024),
12923 (unsigned int) (device_maxclock_frequency),
12924 (unsigned int) device_processors);
12925 }
12926 else
12927 {
12928 log_info ("Device #%u: %s, skipped",
12929 device_id + 1,
12930 device_name);
12931 }
12932 }
12933
12934 // common driver check
12935
12936 if (device_param->skipped == 0)
12937 {
12938 if (strstr (device_version, "pocl"))
12939 {
12940 if (force == 0)
12941 {
12942 log_info ("");
12943 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12944 log_info ("You are STRONGLY encouraged not to use it");
12945 log_info ("You can use --force to override this but do not post error reports if you do so");
12946 log_info ("");
12947
12948 return (-1);
12949 }
12950 }
12951
12952 if (device_type & CL_DEVICE_TYPE_GPU)
12953 {
12954 if (vendor_id == VENDOR_ID_NV)
12955 {
12956 if (device_param->kernel_exec_timeout != 0)
12957 {
12958 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);
12959 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12960 }
12961 }
12962 else if (vendor_id == VENDOR_ID_AMD)
12963 {
12964 int catalyst_check = (force == 1) ? 0 : 1;
12965
12966 int catalyst_warn = 0;
12967
12968 int catalyst_broken = 0;
12969
12970 if (catalyst_check == 1)
12971 {
12972 catalyst_warn = 1;
12973
12974 // v14.9 and higher
12975 if (atoi (device_param->driver_version) >= 1573)
12976 {
12977 catalyst_warn = 0;
12978 }
12979
12980 catalyst_check = 0;
12981 }
12982
12983 if (catalyst_broken == 1)
12984 {
12985 log_info ("");
12986 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12987 log_info ("It will pass over cracked hashes and does not report them as cracked");
12988 log_info ("You are STRONGLY encouraged not to use it");
12989 log_info ("You can use --force to override this but do not post error reports if you do so");
12990 log_info ("");
12991
12992 return (-1);
12993 }
12994
12995 if (catalyst_warn == 1)
12996 {
12997 log_info ("");
12998 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12999 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13000 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
13001 #ifdef _WIN
13002 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13003 #endif
13004 log_info ("You can use --force to override this but do not post error reports if you do so");
13005 log_info ("");
13006
13007 return (-1);
13008 }
13009 }
13010 }
13011
13012 /**
13013 * kernel accel and loops tuning db adjustment
13014 */
13015
13016 device_param->kernel_accel_min = 1;
13017 device_param->kernel_accel_max = 1024;
13018
13019 device_param->kernel_loops_min = 1;
13020 device_param->kernel_loops_max = 1024;
13021
13022 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
13023
13024 if (tuningdb_entry)
13025 {
13026 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13027 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13028
13029 if (_kernel_accel)
13030 {
13031 device_param->kernel_accel_min = _kernel_accel;
13032 device_param->kernel_accel_max = _kernel_accel;
13033 }
13034
13035 if (_kernel_loops)
13036 {
13037 if (workload_profile == 1)
13038 {
13039 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13040 }
13041 else if (workload_profile == 2)
13042 {
13043 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13044 }
13045
13046 device_param->kernel_loops_min = _kernel_loops;
13047 device_param->kernel_loops_max = _kernel_loops;
13048 }
13049 }
13050
13051 // commandline parameters overwrite tuningdb entries
13052
13053 if (kernel_accel)
13054 {
13055 device_param->kernel_accel_min = kernel_accel;
13056 device_param->kernel_accel_max = kernel_accel;
13057 }
13058
13059 if (kernel_loops)
13060 {
13061 device_param->kernel_loops_min = kernel_loops;
13062 device_param->kernel_loops_max = kernel_loops;
13063 }
13064
13065 /**
13066 * activate device
13067 */
13068
13069 devices_active++;
13070 }
13071
13072 // next please
13073
13074 devices_cnt++;
13075 }
13076 }
13077
13078 if (keyspace == 0 && devices_active == 0)
13079 {
13080 log_error ("ERROR: No devices found/left");
13081
13082 return (-1);
13083 }
13084
13085 data.devices_cnt = devices_cnt;
13086
13087 data.devices_active = devices_active;
13088
13089 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13090 {
13091 log_info ("");
13092 }
13093
13094 /**
13095 * HM devices: init
13096 */
13097
13098 #ifdef HAVE_HWMON
13099 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13100 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13101 #endif
13102
13103 #ifdef HAVE_ADL
13104 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13105 #endif
13106
13107 if (gpu_temp_disable == 0)
13108 {
13109 #if defined(WIN) && defined(HAVE_NVAPI)
13110 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13111
13112 if (nvapi_init (nvapi) == 0)
13113 data.hm_nv = nvapi;
13114
13115 if (data.hm_nv)
13116 {
13117 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13118 {
13119 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13120
13121 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13122
13123 int tmp_out = 0;
13124
13125 for (int i = 0; i < tmp_in; i++)
13126 {
13127 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13128 }
13129
13130 for (int i = 0; i < tmp_out; i++)
13131 {
13132 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13133
13134 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13135
13136 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;
13137 }
13138 }
13139 }
13140 #endif // WIN && HAVE_NVAPI
13141
13142 #if defined(LINUX) && defined(HAVE_NVML)
13143 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13144
13145 if (nvml_init (nvml) == 0)
13146 data.hm_nv = nvml;
13147
13148 if (data.hm_nv)
13149 {
13150 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13151 {
13152 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13153
13154 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13155
13156 int tmp_out = 0;
13157
13158 for (int i = 0; i < tmp_in; i++)
13159 {
13160 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13161 }
13162
13163 for (int i = 0; i < tmp_out; i++)
13164 {
13165 unsigned int speed;
13166
13167 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;
13168 }
13169 }
13170 }
13171 #endif // LINUX && HAVE_NVML
13172
13173 data.hm_amd = NULL;
13174
13175 #ifdef HAVE_ADL
13176 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13177
13178 if (adl_init (adl) == 0)
13179 data.hm_amd = adl;
13180
13181 if (data.hm_amd)
13182 {
13183 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13184 {
13185 // total number of adapters
13186
13187 int hm_adapters_num;
13188
13189 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13190
13191 // adapter info
13192
13193 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13194
13195 if (lpAdapterInfo == NULL) return (-1);
13196
13197 // get a list (of ids of) valid/usable adapters
13198
13199 int num_adl_adapters = 0;
13200
13201 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13202
13203 if (num_adl_adapters > 0)
13204 {
13205 hc_thread_mutex_lock (mux_adl);
13206
13207 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13208
13209 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13210
13211 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13212 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13213
13214 hc_thread_mutex_unlock (mux_adl);
13215 }
13216
13217 myfree (valid_adl_device_list);
13218 myfree (lpAdapterInfo);
13219 }
13220 }
13221 #endif // HAVE_ADL
13222
13223 if (data.hm_amd == NULL && data.hm_nv == NULL)
13224 {
13225 gpu_temp_disable = 1;
13226 }
13227 }
13228
13229 /**
13230 * OpenCL devices: allocate buffer for device specific information
13231 */
13232
13233 #ifdef HAVE_HWMON
13234 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13235
13236 #ifdef HAVE_ADL
13237 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13238
13239 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13240 #endif // ADL
13241 #endif
13242
13243 /**
13244 * enable custom signal handler(s)
13245 */
13246
13247 if (benchmark == 0)
13248 {
13249 hc_signal (sigHandler_default);
13250 }
13251 else
13252 {
13253 hc_signal (sigHandler_benchmark);
13254 }
13255
13256 /**
13257 * User-defined GPU temp handling
13258 */
13259
13260 #ifdef HAVE_HWMON
13261 if (gpu_temp_disable == 1)
13262 {
13263 gpu_temp_abort = 0;
13264 gpu_temp_retain = 0;
13265 }
13266
13267 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13268 {
13269 if (gpu_temp_abort < gpu_temp_retain)
13270 {
13271 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13272
13273 return (-1);
13274 }
13275 }
13276
13277 data.gpu_temp_disable = gpu_temp_disable;
13278 data.gpu_temp_abort = gpu_temp_abort;
13279 data.gpu_temp_retain = gpu_temp_retain;
13280 #endif
13281
13282 /**
13283 * inform the user
13284 */
13285
13286 if (data.quiet == 0)
13287 {
13288 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13289
13290 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);
13291
13292 if (attack_mode == ATTACK_MODE_STRAIGHT)
13293 {
13294 log_info ("Rules: %u", kernel_rules_cnt);
13295 }
13296
13297 if (opti_type)
13298 {
13299 log_info ("Applicable Optimizers:");
13300
13301 for (uint i = 0; i < 32; i++)
13302 {
13303 const uint opti_bit = 1u << i;
13304
13305 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13306 }
13307 }
13308
13309 /**
13310 * Watchdog and Temperature balance
13311 */
13312
13313 #ifdef HAVE_HWMON
13314 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13315 {
13316 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13317 }
13318
13319 if (gpu_temp_abort == 0)
13320 {
13321 log_info ("Watchdog: Temperature abort trigger disabled");
13322 }
13323 else
13324 {
13325 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13326 }
13327
13328 if (gpu_temp_retain == 0)
13329 {
13330 log_info ("Watchdog: Temperature retain trigger disabled");
13331 }
13332 else
13333 {
13334 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13335 }
13336 #endif
13337 }
13338
13339 if (data.quiet == 0) log_info ("");
13340
13341 /**
13342 * HM devices: copy
13343 */
13344
13345 if (gpu_temp_disable == 0)
13346 {
13347 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13348 {
13349 hc_device_param_t *device_param = &data.devices_param[device_id];
13350
13351 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13352
13353 if (device_param->skipped) continue;
13354
13355 const uint platform_devices_id = device_param->platform_devices_id;
13356
13357 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13358 if (device_param->vendor_id == VENDOR_ID_NV)
13359 {
13360 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13361 }
13362 #endif
13363
13364 #ifdef HAVE_ADL
13365 if (device_param->vendor_id == VENDOR_ID_AMD)
13366 {
13367 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13368 }
13369 #endif
13370 }
13371 }
13372
13373 /*
13374 * Temporary fix:
13375 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13376 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13377 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13378 * Driver / ADL bug?
13379 */
13380
13381 #ifdef HAVE_ADL
13382 if (powertune_enable == 1)
13383 {
13384 hc_thread_mutex_lock (mux_adl);
13385
13386 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13387 {
13388 hc_device_param_t *device_param = &data.devices_param[device_id];
13389
13390 if (device_param->skipped) continue;
13391
13392 if (data.hm_device[device_id].od_version == 6)
13393 {
13394 // set powertune value only
13395
13396 int powertune_supported = 0;
13397
13398 int ADL_rc = 0;
13399
13400 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13401 {
13402 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13403
13404 return (-1);
13405 }
13406
13407 if (powertune_supported != 0)
13408 {
13409 // powertune set
13410 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13411
13412 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13413 {
13414 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13415
13416 return (-1);
13417 }
13418
13419 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13420 {
13421 log_error ("ERROR: Failed to set new ADL PowerControl values");
13422
13423 return (-1);
13424 }
13425 }
13426 }
13427 }
13428
13429 hc_thread_mutex_unlock (mux_adl);
13430 }
13431 #endif // HAVE_ADK
13432 #endif // HAVE_HWMON
13433
13434 #ifdef OSX
13435 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13436 {
13437 if (force == 0)
13438 {
13439 log_info ("");
13440 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13441 log_info ("You can use --force to override this but do not post error reports if you do so");
13442 log_info ("");
13443
13444 continue;
13445 }
13446 }
13447 #endif
13448
13449 #ifdef DEBUG
13450 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13451 #endif
13452
13453 uint kernel_power_all = 0;
13454
13455 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13456 {
13457 /**
13458 * host buffer
13459 */
13460
13461 hc_device_param_t *device_param = &data.devices_param[device_id];
13462
13463 if (device_param->skipped) continue;
13464
13465 /**
13466 * device properties
13467 */
13468
13469 const char *device_name_chksum = device_param->device_name_chksum;
13470 const u32 device_processors = device_param->device_processors;
13471 const u32 device_processor_cores = device_param->device_processor_cores;
13472
13473 /**
13474 * create context for each device
13475 */
13476
13477 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13478
13479 /**
13480 * create command-queue
13481 */
13482
13483 // not supported with NV
13484 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13485
13486 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13487
13488 /**
13489 * create input buffers on device : calculate size of fixed memory buffers
13490 */
13491
13492 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13493 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13494
13495 device_param->size_root_css = size_root_css;
13496 device_param->size_markov_css = size_markov_css;
13497
13498 uint size_results = KERNEL_THREADS * sizeof (uint);
13499
13500 device_param->size_results = size_results;
13501
13502 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13503 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13504
13505 uint size_plains = digests_cnt * sizeof (plain_t);
13506 uint size_salts = salts_cnt * sizeof (salt_t);
13507 uint size_esalts = salts_cnt * esalt_size;
13508
13509 device_param->size_plains = size_plains;
13510 device_param->size_digests = size_digests;
13511 device_param->size_shown = size_shown;
13512 device_param->size_salts = size_salts;
13513
13514 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13515 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13516 uint size_tm = 32 * sizeof (bs_word_t);
13517
13518 // scryptV stuff
13519
13520 u64 size_scryptV = 1;
13521
13522 if ((hash_mode == 8900) || (hash_mode == 9300))
13523 {
13524 uint tmto_start = 0;
13525 uint tmto_stop = 10;
13526
13527 if (scrypt_tmto)
13528 {
13529 tmto_start = scrypt_tmto;
13530 }
13531 else
13532 {
13533 // in case the user did not specify the tmto manually
13534 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13535 // but set the lower end only in case the user has a device with too less memory
13536
13537 if (hash_mode == 8900)
13538 {
13539 if (device_param->vendor_id == VENDOR_ID_AMD)
13540 {
13541 tmto_start = 1;
13542 }
13543 else if (device_param->vendor_id == VENDOR_ID_NV)
13544 {
13545 tmto_start = 3;
13546 }
13547 }
13548 else if (hash_mode == 9300)
13549 {
13550 if (device_param->vendor_id == VENDOR_ID_AMD)
13551 {
13552 tmto_start = 3;
13553 }
13554 else if (device_param->vendor_id == VENDOR_ID_NV)
13555 {
13556 tmto_start = 5;
13557 }
13558 }
13559 }
13560
13561 if (quiet == 0) log_info ("");
13562
13563 uint shader_per_mp = 1;
13564
13565 if (device_param->vendor_id == VENDOR_ID_AMD)
13566 {
13567 shader_per_mp = 8;
13568 }
13569 else if (device_param->vendor_id == VENDOR_ID_NV)
13570 {
13571 shader_per_mp = 32;
13572 }
13573
13574 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13575 {
13576 // TODO: in theory the following calculation needs to be done per salt, not global
13577 // we assume all hashes have the same scrypt settings
13578
13579 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13580
13581 size_scryptV /= 1 << tmto;
13582
13583 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13584
13585 if (size_scryptV > device_param->device_maxmem_alloc)
13586 {
13587 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13588
13589 continue;
13590 }
13591
13592 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13593 {
13594 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13595 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13596 }
13597
13598 break;
13599 }
13600
13601 if (data.salts_buf[0].scrypt_phy == 0)
13602 {
13603 log_error ("ERROR: can't allocate enough device memory");
13604
13605 return -1;
13606 }
13607
13608 if (quiet == 0) log_info ("");
13609 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13610 }
13611
13612 /**
13613 * create input buffers on device : calculate size of dynamic size memory buffers
13614 */
13615
13616 uint kernel_threads = KERNEL_THREADS;
13617
13618 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13619
13620 if (hash_mode == 3200) kernel_threads = 8;
13621 if (hash_mode == 9000) kernel_threads = 8;
13622
13623 /**
13624 * some algorithms need a fixed kernel-loops count
13625 */
13626
13627 if (hash_mode == 1500)
13628 {
13629 const u32 kernel_loops_fixed = 1024;
13630
13631 device_param->kernel_loops_min = kernel_loops_fixed;
13632 device_param->kernel_loops_max = kernel_loops_fixed;
13633 }
13634
13635 if (hash_mode == 3000)
13636 {
13637 const u32 kernel_loops_fixed = 1024;
13638
13639 device_param->kernel_loops_min = kernel_loops_fixed;
13640 device_param->kernel_loops_max = kernel_loops_fixed;
13641 }
13642
13643 if (hash_mode == 8900)
13644 {
13645 const u32 kernel_loops_fixed = 1;
13646
13647 device_param->kernel_loops_min = kernel_loops_fixed;
13648 device_param->kernel_loops_max = kernel_loops_fixed;
13649 }
13650
13651 if (hash_mode == 9300)
13652 {
13653 const u32 kernel_loops_fixed = 1;
13654
13655 device_param->kernel_loops_min = kernel_loops_fixed;
13656 device_param->kernel_loops_max = kernel_loops_fixed;
13657 }
13658
13659 if (hash_mode == 12500)
13660 {
13661 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13662
13663 device_param->kernel_loops_min = kernel_loops_fixed;
13664 device_param->kernel_loops_max = kernel_loops_fixed;
13665 }
13666
13667 /**
13668 * some algorithms have a maximum kernel-loops count
13669 */
13670
13671 if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
13672 {
13673 if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max)
13674 {
13675 device_param->kernel_loops_max = data.salts_buf[0].salt_iter;
13676 }
13677 }
13678
13679 /**
13680 * some algorithms need a special kernel-accel
13681 */
13682
13683 if (hash_mode == 8900)
13684 {
13685 device_param->kernel_accel_min = 1;
13686 device_param->kernel_accel_max = 64;
13687 }
13688
13689 if (hash_mode == 9300)
13690 {
13691 device_param->kernel_accel_min = 1;
13692 device_param->kernel_accel_max = 64;
13693 }
13694
13695 u32 kernel_accel_min = device_param->kernel_accel_min;
13696 u32 kernel_accel_max = device_param->kernel_accel_max;
13697
13698 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13699
13700 uint size_pws = 4;
13701 uint size_tmps = 4;
13702 uint size_hooks = 4;
13703
13704 while (kernel_accel_max >= kernel_accel_min)
13705 {
13706 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13707
13708 // size_pws
13709
13710 size_pws = kernel_power_max * sizeof (pw_t);
13711
13712 // size_tmps
13713
13714 switch (hash_mode)
13715 {
13716 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13717 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13718 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13719 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13720 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13721 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13722 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13723 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13724 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13725 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13726 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13727 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13728 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13729 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13730 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13731 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13732 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13733 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13734 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13735 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13736 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13737 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13738 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13739 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13740 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13741 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13742 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13743 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13744 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13745 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13746 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13747 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13748 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13749 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13750 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13751 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13752 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13753 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13754 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13755 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13756 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13757 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13758 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13759 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13760 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13761 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13762 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13763 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13764 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13765 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13766 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13767 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13768 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13769 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13770 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13771 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13772 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13773 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13774 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13775 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13776 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13777 };
13778
13779 // size_hooks
13780
13781 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13782 {
13783 // none yet
13784 }
13785
13786 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13787 // if not, decrease amplifier and try again
13788
13789 int skip = 0;
13790
13791 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13792 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13793 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13794
13795 if (( bitmap_size
13796 + bitmap_size
13797 + bitmap_size
13798 + bitmap_size
13799 + bitmap_size
13800 + bitmap_size
13801 + bitmap_size
13802 + bitmap_size
13803 + size_bfs
13804 + size_combs
13805 + size_digests
13806 + size_esalts
13807 + size_hooks
13808 + size_markov_css
13809 + size_plains
13810 + size_pws
13811 + size_results
13812 + size_root_css
13813 + size_rules
13814 + size_rules_c
13815 + size_salts
13816 + size_scryptV
13817 + size_shown
13818 + size_tm
13819 + size_tmps) > device_param->device_global_mem) skip = 1;
13820
13821 if (skip == 1)
13822 {
13823 kernel_accel_max--;
13824
13825 continue;
13826 }
13827
13828 break;
13829 }
13830
13831 /*
13832 if (kernel_accel_max == 0)
13833 {
13834 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13835
13836 return -1;
13837 }
13838 */
13839
13840 device_param->kernel_accel_min = kernel_accel_min;
13841 device_param->kernel_accel_max = kernel_accel_max;
13842
13843 /*
13844 if (kernel_accel_max < kernel_accel)
13845 {
13846 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13847
13848 device_param->kernel_accel = kernel_accel_max;
13849 }
13850 */
13851
13852 device_param->size_pws = size_pws;
13853 device_param->size_tmps = size_tmps;
13854 device_param->size_hooks = size_hooks;
13855
13856 // do not confuse kernel_accel_max with kernel_accel here
13857
13858 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
13859
13860 device_param->kernel_threads = kernel_threads;
13861 device_param->kernel_power_user = kernel_power;
13862
13863 kernel_power_all += kernel_power;
13864
13865 /**
13866 * default building options
13867 */
13868
13869 char build_opts[1024] = { 0 };
13870
13871 // we don't have sm_* on vendors not NV but it doesn't matter
13872
13873 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);
13874
13875 /**
13876 * main kernel
13877 */
13878
13879 {
13880 /**
13881 * kernel source filename
13882 */
13883
13884 char source_file[256] = { 0 };
13885
13886 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13887
13888 struct stat sst;
13889
13890 if (stat (source_file, &sst) == -1)
13891 {
13892 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13893
13894 return -1;
13895 }
13896
13897 /**
13898 * kernel cached filename
13899 */
13900
13901 char cached_file[256] = { 0 };
13902
13903 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13904
13905 int cached = 1;
13906
13907 struct stat cst;
13908
13909 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13910 {
13911 cached = 0;
13912 }
13913
13914 /**
13915 * kernel compile or load
13916 */
13917
13918 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13919
13920 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13921
13922 if (force_jit_compilation == -1)
13923 {
13924 if (cached == 0)
13925 {
13926 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13927
13928 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13929
13930 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13931
13932 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13933
13934 if (rc != 0)
13935 {
13936 device_param->skipped = true;
13937 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13938 continue;
13939 }
13940
13941 size_t binary_size;
13942
13943 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13944
13945 u8 *binary = (u8 *) mymalloc (binary_size);
13946
13947 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13948
13949 writeProgramBin (cached_file, binary, binary_size);
13950
13951 local_free (binary);
13952 }
13953 else
13954 {
13955 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13956
13957 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13958
13959 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13960
13961 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13962 }
13963 }
13964 else
13965 {
13966 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13967
13968 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13969
13970 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13971
13972 char build_opts_update[1024] = { 0 };
13973
13974 if (force_jit_compilation == 1500)
13975 {
13976 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13977 }
13978 else if (force_jit_compilation == 8900)
13979 {
13980 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);
13981 }
13982
13983 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13984
13985 if (rc != 0)
13986 {
13987 device_param->skipped = true;
13988 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13989 }
13990 }
13991
13992 local_free (kernel_lengths);
13993 local_free (kernel_sources[0]);
13994 local_free (kernel_sources);
13995 }
13996
13997 /**
13998 * word generator kernel
13999 */
14000
14001 if (attack_mode != ATTACK_MODE_STRAIGHT)
14002 {
14003 /**
14004 * kernel mp source filename
14005 */
14006
14007 char source_file[256] = { 0 };
14008
14009 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14010
14011 struct stat sst;
14012
14013 if (stat (source_file, &sst) == -1)
14014 {
14015 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14016
14017 return -1;
14018 }
14019
14020 /**
14021 * kernel mp cached filename
14022 */
14023
14024 char cached_file[256] = { 0 };
14025
14026 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14027
14028 int cached = 1;
14029
14030 struct stat cst;
14031
14032 if (stat (cached_file, &cst) == -1)
14033 {
14034 cached = 0;
14035 }
14036
14037 /**
14038 * kernel compile or load
14039 */
14040
14041 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14042
14043 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14044
14045 if (cached == 0)
14046 {
14047 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14048
14049 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14050
14051 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14052
14053 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14054
14055 if (rc != 0)
14056 {
14057 device_param->skipped = true;
14058 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14059 continue;
14060 }
14061
14062 size_t binary_size;
14063
14064 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14065
14066 u8 *binary = (u8 *) mymalloc (binary_size);
14067
14068 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14069
14070 writeProgramBin (cached_file, binary, binary_size);
14071
14072 local_free (binary);
14073 }
14074 else
14075 {
14076 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14077
14078 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14079
14080 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14081
14082 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14083 }
14084
14085 local_free (kernel_lengths);
14086 local_free (kernel_sources[0]);
14087 local_free (kernel_sources);
14088 }
14089
14090 /**
14091 * amplifier kernel
14092 */
14093
14094 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14095 {
14096
14097 }
14098 else
14099 {
14100 /**
14101 * kernel amp source filename
14102 */
14103
14104 char source_file[256] = { 0 };
14105
14106 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14107
14108 struct stat sst;
14109
14110 if (stat (source_file, &sst) == -1)
14111 {
14112 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14113
14114 return -1;
14115 }
14116
14117 /**
14118 * kernel amp cached filename
14119 */
14120
14121 char cached_file[256] = { 0 };
14122
14123 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14124
14125 int cached = 1;
14126
14127 struct stat cst;
14128
14129 if (stat (cached_file, &cst) == -1)
14130 {
14131 cached = 0;
14132 }
14133
14134 /**
14135 * kernel compile or load
14136 */
14137
14138 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14139
14140 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14141
14142 if (cached == 0)
14143 {
14144 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14145
14146 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14147
14148 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14149
14150 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14151
14152 if (rc != 0)
14153 {
14154 device_param->skipped = true;
14155 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14156 continue;
14157 }
14158
14159 size_t binary_size;
14160
14161 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14162
14163 u8 *binary = (u8 *) mymalloc (binary_size);
14164
14165 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14166
14167 writeProgramBin (cached_file, binary, binary_size);
14168
14169 local_free (binary);
14170 }
14171 else
14172 {
14173 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14174
14175 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14176
14177 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14178
14179 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14180 }
14181
14182 local_free (kernel_lengths);
14183 local_free (kernel_sources[0]);
14184 local_free (kernel_sources);
14185 }
14186
14187 // some algorithm collide too fast, make that impossible
14188
14189 if (benchmark == 1)
14190 {
14191 ((uint *) digests_buf)[0] = -1;
14192 ((uint *) digests_buf)[1] = -1;
14193 ((uint *) digests_buf)[2] = -1;
14194 ((uint *) digests_buf)[3] = -1;
14195 }
14196
14197 /**
14198 * global buffers
14199 */
14200
14201 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14202 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14203 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14204 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14205 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14206 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14207 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14208 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14209 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14210 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14211 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14212 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14213 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14214 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14215 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14216 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14217 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14218 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14219
14220 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);
14221 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);
14222 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);
14223 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);
14224 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);
14225 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);
14226 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);
14227 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);
14228 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14229 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14230 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14231
14232 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14233 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14234 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14235 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14236 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14237 run_kernel_bzero (device_param, device_param->d_result, size_results);
14238
14239 /**
14240 * special buffers
14241 */
14242
14243 if (attack_kern == ATTACK_KERN_STRAIGHT)
14244 {
14245 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14246 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14247
14248 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14249
14250 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14251 }
14252 else if (attack_kern == ATTACK_KERN_COMBI)
14253 {
14254 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14255 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14256 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14257 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14258
14259 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14260 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14261 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14262 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14263 }
14264 else if (attack_kern == ATTACK_KERN_BF)
14265 {
14266 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14267 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14268 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14269 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14270 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14271
14272 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14273 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14274 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14275 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14276 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14277 }
14278
14279 if (size_esalts)
14280 {
14281 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14282
14283 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14284 }
14285
14286 /**
14287 * main host data
14288 */
14289
14290 uint *result = (uint *) mymalloc (size_results);
14291
14292 device_param->result = result;
14293
14294 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14295
14296 device_param->pws_buf = pws_buf;
14297
14298 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14299
14300 for (int i = 0; i < 64; i++)
14301 {
14302 pw_caches[i].pw_buf.pw_len = i;
14303 pw_caches[i].cnt = 0;
14304 }
14305
14306 device_param->pw_caches = pw_caches;
14307
14308 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14309
14310 device_param->combs_buf = combs_buf;
14311
14312 void *hooks_buf = mymalloc (size_hooks);
14313
14314 device_param->hooks_buf = hooks_buf;
14315
14316 device_param->pw_transpose = pw_transpose_to_hi1;
14317 device_param->pw_add = pw_add_to_hc1;
14318
14319 /**
14320 * kernel args
14321 */
14322
14323 device_param->kernel_params_buf32[21] = bitmap_mask;
14324 device_param->kernel_params_buf32[22] = bitmap_shift1;
14325 device_param->kernel_params_buf32[23] = bitmap_shift2;
14326 device_param->kernel_params_buf32[24] = 0; // salt_pos
14327 device_param->kernel_params_buf32[25] = 0; // loop_pos
14328 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14329 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14330 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14331 device_param->kernel_params_buf32[29] = 0; // digests_offset
14332 device_param->kernel_params_buf32[30] = 0; // combs_mode
14333 device_param->kernel_params_buf32[31] = 0; // gid_max
14334
14335 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14336 ? &device_param->d_pws_buf
14337 : &device_param->d_pws_amp_buf;
14338 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14339 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14340 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14341 device_param->kernel_params[ 4] = &device_param->d_tmps;
14342 device_param->kernel_params[ 5] = &device_param->d_hooks;
14343 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14344 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14345 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14346 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14347 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14348 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14349 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14350 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14351 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14352 device_param->kernel_params[15] = &device_param->d_digests_buf;
14353 device_param->kernel_params[16] = &device_param->d_digests_shown;
14354 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14355 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14356 device_param->kernel_params[19] = &device_param->d_result;
14357 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14358 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14359 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14360 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14361 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14362 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14363 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14364 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14365 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14366 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14367 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14368 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14369
14370 device_param->kernel_params_mp_buf64[3] = 0;
14371 device_param->kernel_params_mp_buf32[4] = 0;
14372 device_param->kernel_params_mp_buf32[5] = 0;
14373 device_param->kernel_params_mp_buf32[6] = 0;
14374 device_param->kernel_params_mp_buf32[7] = 0;
14375 device_param->kernel_params_mp_buf32[8] = 0;
14376
14377 device_param->kernel_params_mp[0] = NULL;
14378 device_param->kernel_params_mp[1] = NULL;
14379 device_param->kernel_params_mp[2] = NULL;
14380 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14381 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14382 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14383 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14384 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14385 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14386
14387 device_param->kernel_params_mp_l_buf64[3] = 0;
14388 device_param->kernel_params_mp_l_buf32[4] = 0;
14389 device_param->kernel_params_mp_l_buf32[5] = 0;
14390 device_param->kernel_params_mp_l_buf32[6] = 0;
14391 device_param->kernel_params_mp_l_buf32[7] = 0;
14392 device_param->kernel_params_mp_l_buf32[8] = 0;
14393 device_param->kernel_params_mp_l_buf32[9] = 0;
14394
14395 device_param->kernel_params_mp_l[0] = NULL;
14396 device_param->kernel_params_mp_l[1] = NULL;
14397 device_param->kernel_params_mp_l[2] = NULL;
14398 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14399 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14400 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14401 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14402 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14403 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14404 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14405
14406 device_param->kernel_params_mp_r_buf64[3] = 0;
14407 device_param->kernel_params_mp_r_buf32[4] = 0;
14408 device_param->kernel_params_mp_r_buf32[5] = 0;
14409 device_param->kernel_params_mp_r_buf32[6] = 0;
14410 device_param->kernel_params_mp_r_buf32[7] = 0;
14411 device_param->kernel_params_mp_r_buf32[8] = 0;
14412
14413 device_param->kernel_params_mp_r[0] = NULL;
14414 device_param->kernel_params_mp_r[1] = NULL;
14415 device_param->kernel_params_mp_r[2] = NULL;
14416 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14417 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14418 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14419 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14420 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14421 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14422
14423 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14424 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14425
14426 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14427 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14428 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14429 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14430 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14431 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14432 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14433
14434 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14435
14436 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14437 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14438
14439 /**
14440 * kernel name
14441 */
14442
14443 char kernel_name[64] = { 0 };
14444
14445 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14446 {
14447 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14448 {
14449 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14450
14451 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14452
14453 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14454
14455 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14456
14457 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14458
14459 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14460 }
14461 else
14462 {
14463 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14464
14465 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14466
14467 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14468
14469 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14470
14471 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14472
14473 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14474 }
14475
14476 if (data.attack_mode == ATTACK_MODE_BF)
14477 {
14478 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14479 {
14480 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14481
14482 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14483
14484 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14485
14486 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14487 }
14488 }
14489 }
14490 else
14491 {
14492 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14493
14494 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14495
14496 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14497
14498 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14499
14500 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14501
14502 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14503
14504 if (opts_type & OPTS_TYPE_HOOK12)
14505 {
14506 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14507
14508 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14509 }
14510
14511 if (opts_type & OPTS_TYPE_HOOK23)
14512 {
14513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14514
14515 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14516 }
14517 }
14518
14519 for (uint i = 0; i <= 20; i++)
14520 {
14521 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14522 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14523 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14524
14525 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14526 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14527 }
14528
14529 for (uint i = 21; i <= 31; i++)
14530 {
14531 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14532 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14533 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14534
14535 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14536 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14537 }
14538
14539 if (attack_mode == ATTACK_MODE_BF)
14540 {
14541 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14542 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14543
14544 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14545 {
14546 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14547
14548 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14549 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14550 }
14551 }
14552 else if (attack_mode == ATTACK_MODE_HYBRID1)
14553 {
14554 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14555 }
14556 else if (attack_mode == ATTACK_MODE_HYBRID2)
14557 {
14558 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14559 }
14560
14561 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14562 {
14563 // nothing to do
14564 }
14565 else
14566 {
14567 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14568 }
14569
14570 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14571 {
14572 // nothing to do
14573 }
14574 else
14575 {
14576 for (uint i = 0; i < 5; i++)
14577 {
14578 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14579 }
14580
14581 for (uint i = 5; i < 7; i++)
14582 {
14583 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14584 }
14585 }
14586
14587 /**
14588 * Store initial fanspeed if gpu_temp_retain is enabled
14589 */
14590
14591 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14592 int gpu_temp_retain_set = 0;
14593
14594 if (gpu_temp_disable == 0)
14595 {
14596 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14597 {
14598 hc_thread_mutex_lock (mux_adl);
14599
14600 if (data.hm_device[device_id].fan_supported == 1)
14601 {
14602 if (gpu_temp_retain_chgd == 0)
14603 {
14604 uint cur_temp = 0;
14605 uint default_temp = 0;
14606
14607 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);
14608
14609 if (ADL_rc == ADL_OK)
14610 {
14611 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14612
14613 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14614
14615 // special case with multi gpu setups: always use minimum retain
14616
14617 if (gpu_temp_retain_set == 0)
14618 {
14619 gpu_temp_retain = gpu_temp_retain_target;
14620 gpu_temp_retain_set = 1;
14621 }
14622 else
14623 {
14624 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14625 }
14626
14627 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14628 }
14629 }
14630
14631 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14632
14633 temp_retain_fanspeed_value[device_id] = fan_speed;
14634
14635 if (fan_speed == -1)
14636 {
14637 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14638
14639 temp_retain_fanspeed_value[device_id] = 0;
14640 }
14641 }
14642
14643 hc_thread_mutex_unlock (mux_adl);
14644 }
14645 }
14646
14647 /**
14648 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14649 */
14650
14651 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14652 {
14653 hc_thread_mutex_lock (mux_adl);
14654
14655 if (data.hm_device[device_id].od_version == 6)
14656 {
14657 int ADL_rc;
14658
14659 // check powertune capabilities first, if not available then skip device
14660
14661 int powertune_supported = 0;
14662
14663 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14664 {
14665 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14666
14667 return (-1);
14668 }
14669
14670 if (powertune_supported != 0)
14671 {
14672 // powercontrol settings
14673
14674 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14675
14676 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14677 {
14678 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14679 }
14680
14681 if (ADL_rc != ADL_OK)
14682 {
14683 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14684
14685 return (-1);
14686 }
14687
14688 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14689 {
14690 log_error ("ERROR: Failed to set new ADL PowerControl values");
14691
14692 return (-1);
14693 }
14694
14695 // clocks
14696
14697 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14698
14699 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14700
14701 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)
14702 {
14703 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14704
14705 return (-1);
14706 }
14707
14708 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14709
14710 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14711
14712 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14713 {
14714 log_error ("ERROR: Failed to get ADL device capabilities");
14715
14716 return (-1);
14717 }
14718
14719 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14720 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14721
14722 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14723 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14724
14725 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14726 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14727
14728 // warning if profile has too low max values
14729
14730 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14731 {
14732 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14733 }
14734
14735 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14736 {
14737 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14738 }
14739
14740 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14741
14742 performance_state->iNumberOfPerformanceLevels = 2;
14743
14744 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14745 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14746 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14747 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14748
14749 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)
14750 {
14751 log_info ("ERROR: Failed to set ADL performance state");
14752
14753 return (-1);
14754 }
14755
14756 local_free (performance_state);
14757 }
14758 }
14759
14760 hc_thread_mutex_unlock (mux_adl);
14761 }
14762 #endif // HAVE_HWMON && HAVE_ADL
14763 }
14764
14765 data.kernel_power_all = kernel_power_all;
14766
14767 if (data.quiet == 0) log_info ("");
14768
14769 /**
14770 * Inform user which algorithm is checked and at which workload setting
14771 */
14772
14773 if (benchmark == 1)
14774 {
14775 quiet = 0;
14776
14777 data.quiet = quiet;
14778
14779 char *hash_type = strhashtype (data.hash_mode); // not a bug
14780
14781 log_info ("Hashtype: %s", hash_type);
14782 log_info ("");
14783 }
14784
14785 /**
14786 * keep track of the progress
14787 */
14788
14789 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14790 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14791 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14792
14793 /**
14794 * open filehandles
14795 */
14796
14797 #if _WIN
14798 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14799 {
14800 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14801
14802 return (-1);
14803 }
14804
14805 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14806 {
14807 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14808
14809 return (-1);
14810 }
14811
14812 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14813 {
14814 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14815
14816 return (-1);
14817 }
14818 #endif
14819
14820 /**
14821 * dictionary pad
14822 */
14823
14824 segment_size *= (1024 * 1024);
14825
14826 data.segment_size = segment_size;
14827
14828 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14829
14830 wl_data->buf = (char *) mymalloc (segment_size);
14831 wl_data->avail = segment_size;
14832 wl_data->incr = segment_size;
14833 wl_data->cnt = 0;
14834 wl_data->pos = 0;
14835
14836 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14837
14838 data.wordlist_mode = wordlist_mode;
14839
14840 cs_t *css_buf = NULL;
14841 uint css_cnt = 0;
14842 uint dictcnt = 0;
14843 uint maskcnt = 1;
14844 char **masks = NULL;
14845 char **dictfiles = NULL;
14846
14847 uint mask_from_file = 0;
14848
14849 if (attack_mode == ATTACK_MODE_STRAIGHT)
14850 {
14851 if (wordlist_mode == WL_MODE_FILE)
14852 {
14853 int wls_left = myargc - (optind + 1);
14854
14855 for (int i = 0; i < wls_left; i++)
14856 {
14857 char *l0_filename = myargv[optind + 1 + i];
14858
14859 struct stat l0_stat;
14860
14861 if (stat (l0_filename, &l0_stat) == -1)
14862 {
14863 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14864
14865 return (-1);
14866 }
14867
14868 uint is_dir = S_ISDIR (l0_stat.st_mode);
14869
14870 if (is_dir == 0)
14871 {
14872 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14873
14874 dictcnt++;
14875
14876 dictfiles[dictcnt - 1] = l0_filename;
14877 }
14878 else
14879 {
14880 // do not allow --keyspace w/ a directory
14881
14882 if (keyspace == 1)
14883 {
14884 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14885
14886 return (-1);
14887 }
14888
14889 char **dictionary_files = NULL;
14890
14891 dictionary_files = scan_directory (l0_filename);
14892
14893 if (dictionary_files != NULL)
14894 {
14895 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14896
14897 for (int d = 0; dictionary_files[d] != NULL; d++)
14898 {
14899 char *l1_filename = dictionary_files[d];
14900
14901 struct stat l1_stat;
14902
14903 if (stat (l1_filename, &l1_stat) == -1)
14904 {
14905 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14906
14907 return (-1);
14908 }
14909
14910 if (S_ISREG (l1_stat.st_mode))
14911 {
14912 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14913
14914 dictcnt++;
14915
14916 dictfiles[dictcnt - 1] = strdup (l1_filename);
14917 }
14918 }
14919 }
14920
14921 local_free (dictionary_files);
14922 }
14923 }
14924
14925 if (dictcnt < 1)
14926 {
14927 log_error ("ERROR: No usable dictionary file found.");
14928
14929 return (-1);
14930 }
14931 }
14932 else if (wordlist_mode == WL_MODE_STDIN)
14933 {
14934 dictcnt = 1;
14935 }
14936 }
14937 else if (attack_mode == ATTACK_MODE_COMBI)
14938 {
14939 // display
14940
14941 char *dictfile1 = myargv[optind + 1 + 0];
14942 char *dictfile2 = myargv[optind + 1 + 1];
14943
14944 // find the bigger dictionary and use as base
14945
14946 FILE *fp1 = NULL;
14947 FILE *fp2 = NULL;
14948
14949 struct stat tmp_stat;
14950
14951 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14952 {
14953 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14954
14955 return (-1);
14956 }
14957
14958 if (stat (dictfile1, &tmp_stat) == -1)
14959 {
14960 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14961
14962 fclose (fp1);
14963
14964 return (-1);
14965 }
14966
14967 if (S_ISDIR (tmp_stat.st_mode))
14968 {
14969 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14970
14971 fclose (fp1);
14972
14973 return (-1);
14974 }
14975
14976 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14977 {
14978 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14979
14980 fclose (fp1);
14981
14982 return (-1);
14983 }
14984
14985 if (stat (dictfile2, &tmp_stat) == -1)
14986 {
14987 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14988
14989 fclose (fp1);
14990 fclose (fp2);
14991
14992 return (-1);
14993 }
14994
14995 if (S_ISDIR (tmp_stat.st_mode))
14996 {
14997 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14998
14999 fclose (fp1);
15000 fclose (fp2);
15001
15002 return (-1);
15003 }
15004
15005 data.combs_cnt = 1;
15006
15007 data.quiet = 1;
15008
15009 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15010
15011 data.quiet = quiet;
15012
15013 if (words1_cnt == 0)
15014 {
15015 log_error ("ERROR: %s: empty file", dictfile1);
15016
15017 fclose (fp1);
15018 fclose (fp2);
15019
15020 return (-1);
15021 }
15022
15023 data.combs_cnt = 1;
15024
15025 data.quiet = 1;
15026
15027 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15028
15029 data.quiet = quiet;
15030
15031 if (words2_cnt == 0)
15032 {
15033 log_error ("ERROR: %s: empty file", dictfile2);
15034
15035 fclose (fp1);
15036 fclose (fp2);
15037
15038 return (-1);
15039 }
15040
15041 fclose (fp1);
15042 fclose (fp2);
15043
15044 data.dictfile = dictfile1;
15045 data.dictfile2 = dictfile2;
15046
15047 if (words1_cnt >= words2_cnt)
15048 {
15049 data.combs_cnt = words2_cnt;
15050 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15051
15052 dictfiles = &data.dictfile;
15053
15054 dictcnt = 1;
15055 }
15056 else
15057 {
15058 data.combs_cnt = words1_cnt;
15059 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15060
15061 dictfiles = &data.dictfile2;
15062
15063 dictcnt = 1;
15064
15065 // we also have to switch wordlist related rules!
15066
15067 char *tmpc = data.rule_buf_l;
15068
15069 data.rule_buf_l = data.rule_buf_r;
15070 data.rule_buf_r = tmpc;
15071
15072 int tmpi = data.rule_len_l;
15073
15074 data.rule_len_l = data.rule_len_r;
15075 data.rule_len_r = tmpi;
15076 }
15077 }
15078 else if (attack_mode == ATTACK_MODE_BF)
15079 {
15080 char *mask = NULL;
15081
15082 maskcnt = 0;
15083
15084 if (benchmark == 0)
15085 {
15086 mask = myargv[optind + 1];
15087
15088 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15089
15090 if ((optind + 2) <= myargc)
15091 {
15092 struct stat file_stat;
15093
15094 if (stat (mask, &file_stat) == -1)
15095 {
15096 maskcnt = 1;
15097
15098 masks[maskcnt - 1] = mystrdup (mask);
15099 }
15100 else
15101 {
15102 int wls_left = myargc - (optind + 1);
15103
15104 uint masks_avail = INCR_MASKS;
15105
15106 for (int i = 0; i < wls_left; i++)
15107 {
15108 if (i != 0)
15109 {
15110 mask = myargv[optind + 1 + i];
15111
15112 if (stat (mask, &file_stat) == -1)
15113 {
15114 log_error ("ERROR: %s: %s", mask, strerror (errno));
15115
15116 return (-1);
15117 }
15118 }
15119
15120 uint is_file = S_ISREG (file_stat.st_mode);
15121
15122 if (is_file == 1)
15123 {
15124 FILE *mask_fp;
15125
15126 if ((mask_fp = fopen (mask, "r")) == NULL)
15127 {
15128 log_error ("ERROR: %s: %s", mask, strerror (errno));
15129
15130 return (-1);
15131 }
15132
15133 char line_buf[BUFSIZ] = { 0 };
15134
15135 while (!feof (mask_fp))
15136 {
15137 memset (line_buf, 0, BUFSIZ);
15138
15139 int line_len = fgetl (mask_fp, line_buf);
15140
15141 if (line_len == 0) continue;
15142
15143 if (line_buf[0] == '#') continue;
15144
15145 if (masks_avail == maskcnt)
15146 {
15147 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15148
15149 masks_avail += INCR_MASKS;
15150 }
15151
15152 masks[maskcnt] = mystrdup (line_buf);
15153
15154 maskcnt++;
15155 }
15156
15157 fclose (mask_fp);
15158 }
15159 else
15160 {
15161 log_error ("ERROR: %s: unsupported file-type", mask);
15162
15163 return (-1);
15164 }
15165 }
15166
15167 mask_from_file = 1;
15168 }
15169 }
15170 else
15171 {
15172 custom_charset_1 = (char *) "?l?d?u";
15173 custom_charset_2 = (char *) "?l?d";
15174 custom_charset_3 = (char *) "?l?d*!$@_";
15175
15176 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15177 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15178 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15179
15180 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15181
15182 wordlist_mode = WL_MODE_MASK;
15183
15184 data.wordlist_mode = wordlist_mode;
15185
15186 increment = 1;
15187
15188 maskcnt = 1;
15189 }
15190 }
15191 else
15192 {
15193 /**
15194 * generate full masks and charsets
15195 */
15196
15197 masks = (char **) mymalloc (sizeof (char *));
15198
15199 switch (hash_mode)
15200 {
15201 case 1731: pw_min = 5;
15202 pw_max = 5;
15203 mask = mystrdup ("?b?b?b?b?b");
15204 break;
15205 case 12500: pw_min = 5;
15206 pw_max = 5;
15207 mask = mystrdup ("?b?b?b?b?b");
15208 break;
15209 default: pw_min = 7;
15210 pw_max = 7;
15211 mask = mystrdup ("?b?b?b?b?b?b?b");
15212 break;
15213 }
15214
15215 maskcnt = 1;
15216
15217 masks[maskcnt - 1] = mystrdup (mask);
15218
15219 wordlist_mode = WL_MODE_MASK;
15220
15221 data.wordlist_mode = wordlist_mode;
15222
15223 increment = 1;
15224 }
15225
15226 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15227
15228 if (increment)
15229 {
15230 if (increment_min > pw_min) pw_min = increment_min;
15231
15232 if (increment_max < pw_max) pw_max = increment_max;
15233 }
15234 }
15235 else if (attack_mode == ATTACK_MODE_HYBRID1)
15236 {
15237 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15238
15239 // display
15240
15241 char *mask = myargv[myargc - 1];
15242
15243 maskcnt = 0;
15244
15245 masks = (char **) mymalloc (1 * sizeof (char *));
15246
15247 // mod
15248
15249 struct stat file_stat;
15250
15251 if (stat (mask, &file_stat) == -1)
15252 {
15253 maskcnt = 1;
15254
15255 masks[maskcnt - 1] = mystrdup (mask);
15256 }
15257 else
15258 {
15259 uint is_file = S_ISREG (file_stat.st_mode);
15260
15261 if (is_file == 1)
15262 {
15263 FILE *mask_fp;
15264
15265 if ((mask_fp = fopen (mask, "r")) == NULL)
15266 {
15267 log_error ("ERROR: %s: %s", mask, strerror (errno));
15268
15269 return (-1);
15270 }
15271
15272 char line_buf[BUFSIZ] = { 0 };
15273
15274 uint masks_avail = 1;
15275
15276 while (!feof (mask_fp))
15277 {
15278 memset (line_buf, 0, BUFSIZ);
15279
15280 int line_len = fgetl (mask_fp, line_buf);
15281
15282 if (line_len == 0) continue;
15283
15284 if (line_buf[0] == '#') continue;
15285
15286 if (masks_avail == maskcnt)
15287 {
15288 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15289
15290 masks_avail += INCR_MASKS;
15291 }
15292
15293 masks[maskcnt] = mystrdup (line_buf);
15294
15295 maskcnt++;
15296 }
15297
15298 fclose (mask_fp);
15299
15300 mask_from_file = 1;
15301 }
15302 else
15303 {
15304 maskcnt = 1;
15305
15306 masks[maskcnt - 1] = mystrdup (mask);
15307 }
15308 }
15309
15310 // base
15311
15312 int wls_left = myargc - (optind + 2);
15313
15314 for (int i = 0; i < wls_left; i++)
15315 {
15316 char *filename = myargv[optind + 1 + i];
15317
15318 struct stat file_stat;
15319
15320 if (stat (filename, &file_stat) == -1)
15321 {
15322 log_error ("ERROR: %s: %s", filename, strerror (errno));
15323
15324 return (-1);
15325 }
15326
15327 uint is_dir = S_ISDIR (file_stat.st_mode);
15328
15329 if (is_dir == 0)
15330 {
15331 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15332
15333 dictcnt++;
15334
15335 dictfiles[dictcnt - 1] = filename;
15336 }
15337 else
15338 {
15339 // do not allow --keyspace w/ a directory
15340
15341 if (keyspace == 1)
15342 {
15343 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15344
15345 return (-1);
15346 }
15347
15348 char **dictionary_files = NULL;
15349
15350 dictionary_files = scan_directory (filename);
15351
15352 if (dictionary_files != NULL)
15353 {
15354 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15355
15356 for (int d = 0; dictionary_files[d] != NULL; d++)
15357 {
15358 char *l1_filename = dictionary_files[d];
15359
15360 struct stat l1_stat;
15361
15362 if (stat (l1_filename, &l1_stat) == -1)
15363 {
15364 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15365
15366 return (-1);
15367 }
15368
15369 if (S_ISREG (l1_stat.st_mode))
15370 {
15371 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15372
15373 dictcnt++;
15374
15375 dictfiles[dictcnt - 1] = strdup (l1_filename);
15376 }
15377 }
15378 }
15379
15380 local_free (dictionary_files);
15381 }
15382 }
15383
15384 if (dictcnt < 1)
15385 {
15386 log_error ("ERROR: No usable dictionary file found.");
15387
15388 return (-1);
15389 }
15390
15391 if (increment)
15392 {
15393 maskcnt = 0;
15394
15395 uint mask_min = increment_min; // we can't reject smaller masks here
15396 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15397
15398 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15399 {
15400 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15401
15402 if (cur_mask == NULL) break;
15403
15404 masks[maskcnt] = cur_mask;
15405
15406 maskcnt++;
15407
15408 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15409 }
15410 }
15411 }
15412 else if (attack_mode == ATTACK_MODE_HYBRID2)
15413 {
15414 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15415
15416 // display
15417
15418 char *mask = myargv[optind + 1 + 0];
15419
15420 maskcnt = 0;
15421
15422 masks = (char **) mymalloc (1 * sizeof (char *));
15423
15424 // mod
15425
15426 struct stat file_stat;
15427
15428 if (stat (mask, &file_stat) == -1)
15429 {
15430 maskcnt = 1;
15431
15432 masks[maskcnt - 1] = mystrdup (mask);
15433 }
15434 else
15435 {
15436 uint is_file = S_ISREG (file_stat.st_mode);
15437
15438 if (is_file == 1)
15439 {
15440 FILE *mask_fp;
15441
15442 if ((mask_fp = fopen (mask, "r")) == NULL)
15443 {
15444 log_error ("ERROR: %s: %s", mask, strerror (errno));
15445
15446 return (-1);
15447 }
15448
15449 char line_buf[BUFSIZ] = { 0 };
15450
15451 uint masks_avail = 1;
15452
15453 while (!feof (mask_fp))
15454 {
15455 memset (line_buf, 0, BUFSIZ);
15456
15457 int line_len = fgetl (mask_fp, line_buf);
15458
15459 if (line_len == 0) continue;
15460
15461 if (line_buf[0] == '#') continue;
15462
15463 if (masks_avail == maskcnt)
15464 {
15465 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15466
15467 masks_avail += INCR_MASKS;
15468 }
15469
15470 masks[maskcnt] = mystrdup (line_buf);
15471
15472 maskcnt++;
15473 }
15474
15475 fclose (mask_fp);
15476
15477 mask_from_file = 1;
15478 }
15479 else
15480 {
15481 maskcnt = 1;
15482
15483 masks[maskcnt - 1] = mystrdup (mask);
15484 }
15485 }
15486
15487 // base
15488
15489 int wls_left = myargc - (optind + 2);
15490
15491 for (int i = 0; i < wls_left; i++)
15492 {
15493 char *filename = myargv[optind + 2 + i];
15494
15495 struct stat file_stat;
15496
15497 if (stat (filename, &file_stat) == -1)
15498 {
15499 log_error ("ERROR: %s: %s", filename, strerror (errno));
15500
15501 return (-1);
15502 }
15503
15504 uint is_dir = S_ISDIR (file_stat.st_mode);
15505
15506 if (is_dir == 0)
15507 {
15508 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15509
15510 dictcnt++;
15511
15512 dictfiles[dictcnt - 1] = filename;
15513 }
15514 else
15515 {
15516 // do not allow --keyspace w/ a directory
15517
15518 if (keyspace == 1)
15519 {
15520 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15521
15522 return (-1);
15523 }
15524
15525 char **dictionary_files = NULL;
15526
15527 dictionary_files = scan_directory (filename);
15528
15529 if (dictionary_files != NULL)
15530 {
15531 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15532
15533 for (int d = 0; dictionary_files[d] != NULL; d++)
15534 {
15535 char *l1_filename = dictionary_files[d];
15536
15537 struct stat l1_stat;
15538
15539 if (stat (l1_filename, &l1_stat) == -1)
15540 {
15541 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15542
15543 return (-1);
15544 }
15545
15546 if (S_ISREG (l1_stat.st_mode))
15547 {
15548 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15549
15550 dictcnt++;
15551
15552 dictfiles[dictcnt - 1] = strdup (l1_filename);
15553 }
15554 }
15555 }
15556
15557 local_free (dictionary_files);
15558 }
15559 }
15560
15561 if (dictcnt < 1)
15562 {
15563 log_error ("ERROR: No usable dictionary file found.");
15564
15565 return (-1);
15566 }
15567
15568 if (increment)
15569 {
15570 maskcnt = 0;
15571
15572 uint mask_min = increment_min; // we can't reject smaller masks here
15573 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15574
15575 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15576 {
15577 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15578
15579 if (cur_mask == NULL) break;
15580
15581 masks[maskcnt] = cur_mask;
15582
15583 maskcnt++;
15584
15585 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15586 }
15587 }
15588 }
15589
15590 data.pw_min = pw_min;
15591 data.pw_max = pw_max;
15592
15593 /**
15594 * weak hash check
15595 */
15596
15597 if (weak_hash_threshold >= salts_cnt)
15598 {
15599 hc_device_param_t *device_param = NULL;
15600
15601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15602 {
15603 device_param = &data.devices_param[device_id];
15604
15605 if (device_param->skipped) continue;
15606
15607 break;
15608 }
15609
15610 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15611
15612 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15613 {
15614 weak_hash_check (device_param, salt_pos);
15615 }
15616 }
15617
15618 // Display hack, guarantee that there is at least one \r before real start
15619
15620 if (data.quiet == 0) log_info_nn ("");
15621
15622 /**
15623 * status and monitor threads
15624 */
15625
15626 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15627
15628 hc_thread_t i_thread = 0;
15629
15630 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15631 {
15632 hc_thread_create (i_thread, thread_keypress, &benchmark);
15633 }
15634
15635 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15636
15637 uint ni_threads_cnt = 0;
15638
15639 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15640
15641 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15642
15643 ni_threads_cnt++;
15644
15645 /**
15646 * Outfile remove
15647 */
15648
15649 if (keyspace == 0)
15650 {
15651 if (outfile_check_timer != 0)
15652 {
15653 if (data.outfile_check_directory != NULL)
15654 {
15655 if ((hash_mode != 5200) &&
15656 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15657 (hash_mode != 9000))
15658 {
15659 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15660
15661 ni_threads_cnt++;
15662 }
15663 else
15664 {
15665 outfile_check_timer = 0;
15666 }
15667 }
15668 else
15669 {
15670 outfile_check_timer = 0;
15671 }
15672 }
15673 }
15674
15675 /**
15676 * Inform the user if we got some hashes remove because of the pot file remove feature
15677 */
15678
15679 if (data.quiet == 0)
15680 {
15681 if (potfile_remove_cracks > 0)
15682 {
15683 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15684 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15685 }
15686 }
15687
15688 data.outfile_check_timer = outfile_check_timer;
15689
15690 /**
15691 * main loop
15692 */
15693
15694 char **induction_dictionaries = NULL;
15695
15696 int induction_dictionaries_cnt = 0;
15697
15698 hcstat_table_t *root_table_buf = NULL;
15699 hcstat_table_t *markov_table_buf = NULL;
15700
15701 uint initial_restore_done = 0;
15702
15703 data.maskcnt = maskcnt;
15704
15705 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15706 {
15707 if (data.devices_status == STATUS_CRACKED) break;
15708
15709 data.devices_status = STATUS_INIT;
15710
15711 if (maskpos > rd->maskpos)
15712 {
15713 rd->dictpos = 0;
15714 }
15715
15716 rd->maskpos = maskpos;
15717 data.maskpos = maskpos;
15718
15719 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15720 {
15721 char *mask = masks[maskpos];
15722
15723 if (mask_from_file == 1)
15724 {
15725 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15726
15727 char *str_ptr;
15728 uint str_pos;
15729
15730 uint mask_offset = 0;
15731
15732 uint separator_cnt;
15733
15734 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15735 {
15736 str_ptr = strstr (mask + mask_offset, ",");
15737
15738 if (str_ptr == NULL) break;
15739
15740 str_pos = str_ptr - mask;
15741
15742 // escaped separator, i.e. "\,"
15743
15744 if (str_pos > 0)
15745 {
15746 if (mask[str_pos - 1] == '\\')
15747 {
15748 separator_cnt --;
15749
15750 mask_offset = str_pos + 1;
15751
15752 continue;
15753 }
15754 }
15755
15756 // reset the offset
15757
15758 mask_offset = 0;
15759
15760 mask[str_pos] = '\0';
15761
15762 switch (separator_cnt)
15763 {
15764 case 0:
15765 mp_reset_usr (mp_usr, 0);
15766
15767 custom_charset_1 = mask;
15768 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15769 break;
15770
15771 case 1:
15772 mp_reset_usr (mp_usr, 1);
15773
15774 custom_charset_2 = mask;
15775 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15776 break;
15777
15778 case 2:
15779 mp_reset_usr (mp_usr, 2);
15780
15781 custom_charset_3 = mask;
15782 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15783 break;
15784
15785 case 3:
15786 mp_reset_usr (mp_usr, 3);
15787
15788 custom_charset_4 = mask;
15789 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15790 break;
15791 }
15792
15793 mask = mask + str_pos + 1;
15794 }
15795 }
15796
15797 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15798 {
15799 if (maskpos > 0)
15800 {
15801 local_free (css_buf);
15802 local_free (data.root_css_buf);
15803 local_free (data.markov_css_buf);
15804
15805 local_free (masks[maskpos - 1]);
15806 }
15807
15808 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15809
15810 data.mask = mask;
15811 data.css_cnt = css_cnt;
15812 data.css_buf = css_buf;
15813
15814 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15815
15816 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15817
15818 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15819 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15820
15821 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15822
15823 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15824
15825 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15826 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15827
15828 data.root_css_buf = root_css_buf;
15829 data.markov_css_buf = markov_css_buf;
15830
15831 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15832
15833 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15834
15835 local_free (root_table_buf);
15836 local_free (markov_table_buf);
15837
15838 // args
15839
15840 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15841 {
15842 hc_device_param_t *device_param = &data.devices_param[device_id];
15843
15844 if (device_param->skipped) continue;
15845
15846 device_param->kernel_params_mp[0] = &device_param->d_combs;
15847 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15848 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15849
15850 device_param->kernel_params_mp_buf64[3] = 0;
15851 device_param->kernel_params_mp_buf32[4] = css_cnt;
15852 device_param->kernel_params_mp_buf32[5] = 0;
15853 device_param->kernel_params_mp_buf32[6] = 0;
15854 device_param->kernel_params_mp_buf32[7] = 0;
15855
15856 if (attack_mode == ATTACK_MODE_HYBRID1)
15857 {
15858 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15859 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15860 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15861 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15862 }
15863 else if (attack_mode == ATTACK_MODE_HYBRID2)
15864 {
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
15870 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]);
15871 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]);
15872 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]);
15873
15874 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);
15875 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);
15876 }
15877 }
15878 else if (attack_mode == ATTACK_MODE_BF)
15879 {
15880 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15881
15882 if (increment)
15883 {
15884 for (uint i = 0; i < dictcnt; i++)
15885 {
15886 local_free (dictfiles[i]);
15887 }
15888
15889 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15890 {
15891 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15892
15893 if (l1_filename == NULL) break;
15894
15895 dictcnt++;
15896
15897 dictfiles[dictcnt - 1] = l1_filename;
15898 }
15899 }
15900 else
15901 {
15902 dictcnt++;
15903
15904 dictfiles[dictcnt - 1] = mask;
15905 }
15906
15907 if (dictcnt == 0)
15908 {
15909 log_error ("ERROR: Mask is too small");
15910
15911 return (-1);
15912 }
15913 }
15914 }
15915
15916 free (induction_dictionaries);
15917
15918 // induction_dictionaries_cnt = 0; // implied
15919
15920 if (attack_mode != ATTACK_MODE_BF)
15921 {
15922 if (keyspace == 0)
15923 {
15924 induction_dictionaries = scan_directory (induction_directory);
15925
15926 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15927 }
15928 }
15929
15930 if (induction_dictionaries_cnt)
15931 {
15932 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15933 }
15934
15935 /**
15936 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15937 */
15938 if (keyspace == 1)
15939 {
15940 if ((maskcnt > 1) || (dictcnt > 1))
15941 {
15942 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15943
15944 return (-1);
15945 }
15946 }
15947
15948 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15949 {
15950 char *subid = logfile_generate_subid ();
15951
15952 data.subid = subid;
15953
15954 logfile_sub_msg ("START");
15955
15956 data.devices_status = STATUS_INIT;
15957
15958 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15959 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15960 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15961
15962 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15963
15964 data.cpt_pos = 0;
15965
15966 data.cpt_start = time (NULL);
15967
15968 data.cpt_total = 0;
15969
15970 if (data.restore == 0)
15971 {
15972 rd->words_cur = skip;
15973
15974 skip = 0;
15975
15976 data.skip = 0;
15977 }
15978
15979 data.ms_paused = 0;
15980
15981 data.words_cur = rd->words_cur;
15982
15983 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15984 {
15985 hc_device_param_t *device_param = &data.devices_param[device_id];
15986
15987 if (device_param->skipped) continue;
15988
15989 device_param->speed_pos = 0;
15990
15991 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15992 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15993 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15994
15995 device_param->exec_pos = 0;
15996
15997 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15998
15999 device_param->kernel_power = device_param->kernel_power_user;
16000
16001 device_param->outerloop_pos = 0;
16002 device_param->outerloop_left = 0;
16003 device_param->innerloop_pos = 0;
16004 device_param->innerloop_left = 0;
16005
16006 // some more resets:
16007
16008 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
16009
16010 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16011
16012 device_param->pw_cnt = 0;
16013 device_param->pws_cnt = 0;
16014
16015 device_param->words_off = 0;
16016 device_param->words_done = 0;
16017 }
16018
16019 data.kernel_power_div = 0;
16020
16021 // figure out some workload
16022
16023 if (attack_mode == ATTACK_MODE_STRAIGHT)
16024 {
16025 if (data.wordlist_mode == WL_MODE_FILE)
16026 {
16027 char *dictfile = NULL;
16028
16029 if (induction_dictionaries_cnt)
16030 {
16031 dictfile = induction_dictionaries[0];
16032 }
16033 else
16034 {
16035 dictfile = dictfiles[dictpos];
16036 }
16037
16038 data.dictfile = dictfile;
16039
16040 logfile_sub_string (dictfile);
16041
16042 for (uint i = 0; i < rp_files_cnt; i++)
16043 {
16044 logfile_sub_var_string ("rulefile", rp_files[i]);
16045 }
16046
16047 FILE *fd2 = fopen (dictfile, "rb");
16048
16049 if (fd2 == NULL)
16050 {
16051 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16052
16053 return (-1);
16054 }
16055
16056 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16057
16058 fclose (fd2);
16059
16060 if (data.words_cnt == 0)
16061 {
16062 if (data.devices_status == STATUS_CRACKED) break;
16063 if (data.devices_status == STATUS_ABORTED) break;
16064
16065 dictpos++;
16066
16067 continue;
16068 }
16069 }
16070 }
16071 else if (attack_mode == ATTACK_MODE_COMBI)
16072 {
16073 char *dictfile = data.dictfile;
16074 char *dictfile2 = data.dictfile2;
16075
16076 logfile_sub_string (dictfile);
16077 logfile_sub_string (dictfile2);
16078
16079 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16080 {
16081 FILE *fd2 = fopen (dictfile, "rb");
16082
16083 if (fd2 == NULL)
16084 {
16085 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16086
16087 return (-1);
16088 }
16089
16090 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16091
16092 fclose (fd2);
16093 }
16094 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16095 {
16096 FILE *fd2 = fopen (dictfile2, "rb");
16097
16098 if (fd2 == NULL)
16099 {
16100 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16101
16102 return (-1);
16103 }
16104
16105 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16106
16107 fclose (fd2);
16108 }
16109
16110 if (data.words_cnt == 0)
16111 {
16112 if (data.devices_status == STATUS_CRACKED) break;
16113 if (data.devices_status == STATUS_ABORTED) break;
16114
16115 dictpos++;
16116
16117 continue;
16118 }
16119 }
16120 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16121 {
16122 char *dictfile = NULL;
16123
16124 if (induction_dictionaries_cnt)
16125 {
16126 dictfile = induction_dictionaries[0];
16127 }
16128 else
16129 {
16130 dictfile = dictfiles[dictpos];
16131 }
16132
16133 data.dictfile = dictfile;
16134
16135 char *mask = data.mask;
16136
16137 logfile_sub_string (dictfile);
16138 logfile_sub_string (mask);
16139
16140 FILE *fd2 = fopen (dictfile, "rb");
16141
16142 if (fd2 == NULL)
16143 {
16144 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16145
16146 return (-1);
16147 }
16148
16149 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16150
16151 fclose (fd2);
16152
16153 if (data.words_cnt == 0)
16154 {
16155 if (data.devices_status == STATUS_CRACKED) break;
16156 if (data.devices_status == STATUS_ABORTED) break;
16157
16158 dictpos++;
16159
16160 continue;
16161 }
16162 }
16163 else if (attack_mode == ATTACK_MODE_BF)
16164 {
16165 local_free (css_buf);
16166 local_free (data.root_css_buf);
16167 local_free (data.markov_css_buf);
16168
16169 char *mask = dictfiles[dictpos];
16170
16171 logfile_sub_string (mask);
16172
16173 // base
16174
16175 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16176
16177 if (opts_type & OPTS_TYPE_PT_UNICODE)
16178 {
16179 uint css_cnt_unicode = css_cnt * 2;
16180
16181 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16182
16183 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16184 {
16185 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16186
16187 css_buf_unicode[j + 1].cs_buf[0] = 0;
16188 css_buf_unicode[j + 1].cs_len = 1;
16189 }
16190
16191 free (css_buf);
16192
16193 css_buf = css_buf_unicode;
16194 css_cnt = css_cnt_unicode;
16195 }
16196
16197 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16198
16199 uint mask_min = pw_min;
16200 uint mask_max = pw_max;
16201
16202 if (opts_type & OPTS_TYPE_PT_UNICODE)
16203 {
16204 mask_min *= 2;
16205 mask_max *= 2;
16206 }
16207
16208 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16209 {
16210 if (css_cnt < mask_min)
16211 {
16212 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16213 }
16214
16215 if (css_cnt > mask_max)
16216 {
16217 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16218 }
16219
16220 // skip to next mask
16221
16222 dictpos++;
16223
16224 rd->dictpos = dictpos;
16225
16226 logfile_sub_msg ("STOP");
16227
16228 continue;
16229 }
16230
16231 uint save_css_cnt = css_cnt;
16232
16233 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16234 {
16235 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16236 {
16237 uint salt_len = (uint) data.salts_buf[0].salt_len;
16238 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16239
16240 uint css_cnt_salt = css_cnt + salt_len;
16241
16242 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16243
16244 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16245
16246 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16247 {
16248 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16249 css_buf_salt[j].cs_len = 1;
16250 }
16251
16252 free (css_buf);
16253
16254 css_buf = css_buf_salt;
16255 css_cnt = css_cnt_salt;
16256 }
16257 }
16258
16259 data.mask = mask;
16260 data.css_cnt = css_cnt;
16261 data.css_buf = css_buf;
16262
16263 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16264
16265 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16266
16267 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16268
16269 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16270 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16271
16272 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16273
16274 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16275
16276 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16277 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16278
16279 data.root_css_buf = root_css_buf;
16280 data.markov_css_buf = markov_css_buf;
16281
16282 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16283
16284 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16285
16286 local_free (root_table_buf);
16287 local_free (markov_table_buf);
16288
16289 // copy + args
16290
16291 uint css_cnt_l = css_cnt;
16292 uint css_cnt_r;
16293
16294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16295 {
16296 if (save_css_cnt < 6)
16297 {
16298 css_cnt_r = 1;
16299 }
16300 else if (save_css_cnt == 6)
16301 {
16302 css_cnt_r = 2;
16303 }
16304 else
16305 {
16306 if (opts_type & OPTS_TYPE_PT_UNICODE)
16307 {
16308 if (save_css_cnt == 8 || save_css_cnt == 10)
16309 {
16310 css_cnt_r = 2;
16311 }
16312 else
16313 {
16314 css_cnt_r = 4;
16315 }
16316 }
16317 else
16318 {
16319 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16320 {
16321 css_cnt_r = 3;
16322 }
16323 else
16324 {
16325 css_cnt_r = 4;
16326 }
16327 }
16328 }
16329 }
16330 else
16331 {
16332 css_cnt_r = 1;
16333
16334 /* unfinished code?
16335 int sum = css_buf[css_cnt_r - 1].cs_len;
16336
16337 for (uint i = 1; i < 4 && i < css_cnt; i++)
16338 {
16339 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16340
16341 css_cnt_r++;
16342
16343 sum *= css_buf[css_cnt_r - 1].cs_len;
16344 }
16345 */
16346 }
16347
16348 css_cnt_l -= css_cnt_r;
16349
16350 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16351
16352 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16353 {
16354 hc_device_param_t *device_param = &data.devices_param[device_id];
16355
16356 if (device_param->skipped) continue;
16357
16358 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16359 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16360 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16361
16362 device_param->kernel_params_mp_l_buf64[3] = 0;
16363 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16364 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16365 device_param->kernel_params_mp_l_buf32[6] = 0;
16366 device_param->kernel_params_mp_l_buf32[7] = 0;
16367 device_param->kernel_params_mp_l_buf32[8] = 0;
16368
16369 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16370 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16371 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16372 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16373
16374 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16375 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16376 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16377
16378 device_param->kernel_params_mp_r_buf64[3] = 0;
16379 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16380 device_param->kernel_params_mp_r_buf32[5] = 0;
16381 device_param->kernel_params_mp_r_buf32[6] = 0;
16382 device_param->kernel_params_mp_r_buf32[7] = 0;
16383
16384 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]);
16385 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]);
16386 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]);
16387
16388 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]);
16389 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]);
16390 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]);
16391
16392 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);
16393 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);
16394 }
16395 }
16396
16397 u64 words_base = data.words_cnt;
16398
16399 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16400 {
16401 if (data.kernel_rules_cnt)
16402 {
16403 words_base /= data.kernel_rules_cnt;
16404 }
16405 }
16406 else if (data.attack_kern == ATTACK_KERN_COMBI)
16407 {
16408 if (data.combs_cnt)
16409 {
16410 words_base /= data.combs_cnt;
16411 }
16412 }
16413 else if (data.attack_kern == ATTACK_KERN_BF)
16414 {
16415 if (data.bfs_cnt)
16416 {
16417 words_base /= data.bfs_cnt;
16418 }
16419 }
16420
16421 data.words_base = words_base;
16422
16423 if (keyspace == 1)
16424 {
16425 log_info ("%llu", (unsigned long long int) words_base);
16426
16427 return (0);
16428 }
16429
16430 if (data.words_cur > data.words_base)
16431 {
16432 log_error ("ERROR: restore value greater keyspace");
16433
16434 return (-1);
16435 }
16436
16437 if (data.words_cur)
16438 {
16439 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16440 {
16441 for (uint i = 0; i < data.salts_cnt; i++)
16442 {
16443 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16444 }
16445 }
16446 else if (data.attack_kern == ATTACK_KERN_COMBI)
16447 {
16448 for (uint i = 0; i < data.salts_cnt; i++)
16449 {
16450 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16451 }
16452 }
16453 else if (data.attack_kern == ATTACK_KERN_BF)
16454 {
16455 for (uint i = 0; i < data.salts_cnt; i++)
16456 {
16457 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16458 }
16459 }
16460 }
16461
16462 /*
16463 * Inform user about possible slow speeds
16464 */
16465
16466 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16467 {
16468 if (data.words_base < kernel_power_all)
16469 {
16470 if (quiet == 0)
16471 {
16472 log_info ("");
16473 log_info ("ATTENTION!");
16474 log_info (" The wordlist or mask you are using is too small.");
16475 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16476 log_info (" The cracking speed will drop.");
16477 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16478 log_info ("");
16479 }
16480 }
16481 }
16482
16483 /*
16484 * Update loopback file
16485 */
16486
16487 if (loopback == 1)
16488 {
16489 time_t now;
16490
16491 time (&now);
16492
16493 uint random_num = get_random_num (0, 9999);
16494
16495 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16496
16497 data.loopback_file = loopback_file;
16498 }
16499
16500 /*
16501 * Update dictionary statistic
16502 */
16503
16504 if (keyspace == 0)
16505 {
16506 dictstat_fp = fopen (dictstat, "wb");
16507
16508 if (dictstat_fp)
16509 {
16510 lock_file (dictstat_fp);
16511
16512 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16513
16514 fclose (dictstat_fp);
16515 }
16516 }
16517
16518 data.devices_status = STATUS_RUNNING;
16519
16520 if (initial_restore_done == 0)
16521 {
16522 if (data.restore_disable == 0) cycle_restore ();
16523
16524 initial_restore_done = 1;
16525 }
16526
16527 hc_timer_set (&data.timer_running);
16528
16529 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16530 {
16531 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16532 {
16533 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16534 if (quiet == 0) fflush (stdout);
16535 }
16536 }
16537 else if (wordlist_mode == WL_MODE_STDIN)
16538 {
16539 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16540 if (data.quiet == 0) log_info ("");
16541 }
16542
16543 time_t runtime_start;
16544
16545 time (&runtime_start);
16546
16547 data.runtime_start = runtime_start;
16548
16549 /**
16550 * create cracker threads
16551 */
16552
16553 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16554
16555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16556 {
16557 hc_device_param_t *device_param = &devices_param[device_id];
16558
16559 if (wordlist_mode == WL_MODE_STDIN)
16560 {
16561 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16562 }
16563 else
16564 {
16565 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16566 }
16567 }
16568
16569 // wait for crack threads to exit
16570
16571 hc_thread_wait (data.devices_cnt, c_threads);
16572
16573 local_free (c_threads);
16574
16575 data.restore = 0;
16576
16577 // finalize task
16578
16579 logfile_sub_var_uint ("status-after-work", data.devices_status);
16580
16581 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16582
16583 if (data.devices_status == STATUS_CRACKED) break;
16584 if (data.devices_status == STATUS_ABORTED) break;
16585
16586 if (data.devices_status == STATUS_BYPASS)
16587 {
16588 data.devices_status = STATUS_RUNNING;
16589 }
16590
16591 if (induction_dictionaries_cnt)
16592 {
16593 unlink (induction_dictionaries[0]);
16594 }
16595
16596 free (induction_dictionaries);
16597
16598 if (attack_mode != ATTACK_MODE_BF)
16599 {
16600 induction_dictionaries = scan_directory (induction_directory);
16601
16602 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16603 }
16604
16605 if (benchmark == 0)
16606 {
16607 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16608 {
16609 if (quiet == 0) clear_prompt ();
16610
16611 if (quiet == 0) log_info ("");
16612
16613 if (status == 1)
16614 {
16615 status_display ();
16616 }
16617 else
16618 {
16619 if (quiet == 0) status_display ();
16620 }
16621
16622 if (quiet == 0) log_info ("");
16623 }
16624 }
16625
16626 if (attack_mode == ATTACK_MODE_BF)
16627 {
16628 dictpos++;
16629
16630 rd->dictpos = dictpos;
16631 }
16632 else
16633 {
16634 if (induction_dictionaries_cnt)
16635 {
16636 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16637 }
16638 else
16639 {
16640 dictpos++;
16641
16642 rd->dictpos = dictpos;
16643 }
16644 }
16645
16646 time_t runtime_stop;
16647
16648 time (&runtime_stop);
16649
16650 data.runtime_stop = runtime_stop;
16651
16652 logfile_sub_uint (runtime_start);
16653 logfile_sub_uint (runtime_stop);
16654
16655 logfile_sub_msg ("STOP");
16656
16657 global_free (subid);
16658 }
16659
16660 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16661
16662 if (data.devices_status == STATUS_CRACKED) break;
16663 if (data.devices_status == STATUS_ABORTED) break;
16664 if (data.devices_status == STATUS_QUIT) break;
16665
16666 if (data.devices_status == STATUS_BYPASS)
16667 {
16668 data.devices_status = STATUS_RUNNING;
16669 }
16670 }
16671
16672 // 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
16673
16674 if (attack_mode == ATTACK_MODE_STRAIGHT)
16675 {
16676 if (data.wordlist_mode == WL_MODE_FILE)
16677 {
16678 if (data.dictfile == NULL)
16679 {
16680 if (dictfiles != NULL)
16681 {
16682 data.dictfile = dictfiles[0];
16683
16684 hc_timer_set (&data.timer_running);
16685 }
16686 }
16687 }
16688 }
16689 // NOTE: combi is okay because it is already set beforehand
16690 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16691 {
16692 if (data.dictfile == NULL)
16693 {
16694 if (dictfiles != NULL)
16695 {
16696 hc_timer_set (&data.timer_running);
16697
16698 data.dictfile = dictfiles[0];
16699 }
16700 }
16701 }
16702 else if (attack_mode == ATTACK_MODE_BF)
16703 {
16704 if (data.mask == NULL)
16705 {
16706 hc_timer_set (&data.timer_running);
16707
16708 data.mask = masks[0];
16709 }
16710 }
16711
16712 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16713 {
16714 data.devices_status = STATUS_EXHAUSTED;
16715 }
16716
16717 // if cracked / aborted remove last induction dictionary
16718
16719 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16720 {
16721 struct stat induct_stat;
16722
16723 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16724 {
16725 unlink (induction_dictionaries[file_pos]);
16726 }
16727 }
16728
16729 // wait for non-interactive threads
16730
16731 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16732 {
16733 hc_thread_wait (1, &ni_threads[thread_idx]);
16734 }
16735
16736 local_free (ni_threads);
16737
16738 // wait for interactive threads
16739
16740 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16741 {
16742 hc_thread_wait (1, &i_thread);
16743 }
16744
16745 // we dont need restore file anymore
16746 if (data.restore_disable == 0)
16747 {
16748 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16749 {
16750 unlink (eff_restore_file);
16751 unlink (new_restore_file);
16752 }
16753 else
16754 {
16755 cycle_restore ();
16756 }
16757 }
16758
16759 // finally save left hashes
16760
16761 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16762 {
16763 save_hash ();
16764 }
16765
16766 /**
16767 * Clean up
16768 */
16769
16770 if (benchmark == 1)
16771 {
16772 status_benchmark ();
16773
16774 log_info ("");
16775 }
16776 else
16777 {
16778 if (quiet == 0) clear_prompt ();
16779
16780 if (quiet == 0) log_info ("");
16781
16782 if (status == 1)
16783 {
16784 status_display ();
16785 }
16786 else
16787 {
16788 if (quiet == 0) status_display ();
16789 }
16790
16791 if (quiet == 0) log_info ("");
16792 }
16793
16794 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16795 {
16796 hc_device_param_t *device_param = &data.devices_param[device_id];
16797
16798 if (device_param->skipped) continue;
16799
16800 local_free (device_param->result);
16801
16802 local_free (device_param->pw_caches);
16803
16804 local_free (device_param->combs_buf);
16805
16806 local_free (device_param->hooks_buf);
16807
16808 local_free (device_param->device_name);
16809
16810 local_free (device_param->device_name_chksum);
16811
16812 local_free (device_param->device_version);
16813
16814 local_free (device_param->driver_version);
16815
16816 if (device_param->pws_buf) myfree (device_param->pws_buf);
16817 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16818 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16819 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16820 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16821 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16822 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16823 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16824 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16825 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16826 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16827 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16828 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16829 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16830 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16831 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16832 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16833 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16834 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16835 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16836 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16837 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16838 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16839 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16840 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16841 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16842 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16843 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16844 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16845
16846 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16847 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16848 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16849 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16850 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16851 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16852 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16853 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16854 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16855 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16856 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16857
16858 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16859 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16860 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16861
16862 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16863 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16864 }
16865
16866 // reset default fan speed
16867
16868 #ifdef HAVE_HWMON
16869 if (gpu_temp_disable == 0)
16870 {
16871 #ifdef HAVE_ADL
16872 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16873 {
16874 hc_thread_mutex_lock (mux_adl);
16875
16876 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16877 {
16878 hc_device_param_t *device_param = &data.devices_param[device_id];
16879
16880 if (device_param->skipped) continue;
16881
16882 if (data.hm_device[device_id].fan_supported == 1)
16883 {
16884 int fanspeed = temp_retain_fanspeed_value[device_id];
16885
16886 if (fanspeed == -1) continue;
16887
16888 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16889
16890 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16891 }
16892 }
16893
16894 hc_thread_mutex_unlock (mux_adl);
16895 }
16896 #endif // HAVE_ADL
16897 }
16898
16899 #ifdef HAVE_ADL
16900 // reset power tuning
16901
16902 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16903 {
16904 hc_thread_mutex_lock (mux_adl);
16905
16906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16907 {
16908 hc_device_param_t *device_param = &data.devices_param[device_id];
16909
16910 if (device_param->skipped) continue;
16911
16912 if (data.hm_device[device_id].od_version == 6)
16913 {
16914 // check powertune capabilities first, if not available then skip device
16915
16916 int powertune_supported = 0;
16917
16918 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16919 {
16920 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16921
16922 return (-1);
16923 }
16924
16925 if (powertune_supported != 0)
16926 {
16927 // powercontrol settings
16928
16929 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)
16930 {
16931 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16932
16933 return (-1);
16934 }
16935
16936 // clocks
16937
16938 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16939
16940 performance_state->iNumberOfPerformanceLevels = 2;
16941
16942 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16943 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16944 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16945 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16946
16947 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)
16948 {
16949 log_info ("ERROR: Failed to restore ADL performance state");
16950
16951 return (-1);
16952 }
16953
16954 local_free (performance_state);
16955 }
16956 }
16957 }
16958
16959 hc_thread_mutex_unlock (mux_adl);
16960 }
16961 #endif // HAVE_ADL
16962
16963 if (gpu_temp_disable == 0)
16964 {
16965 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16966 if (data.hm_nv)
16967 {
16968 #if defined(LINUX) && defined(HAVE_NVML)
16969
16970 hm_NVML_nvmlShutdown (data.hm_nv);
16971
16972 nvml_close (data.hm_nv);
16973
16974 #elif defined(WIN) && (HAVE_NVAPI)
16975
16976 hm_NvAPI_Unload (data.hm_nv);
16977
16978 nvapi_close (data.hm_nv);
16979
16980 #endif
16981
16982 data.hm_nv = NULL;
16983 }
16984 #endif
16985
16986 #ifdef HAVE_ADL
16987 if (data.hm_amd)
16988 {
16989 hm_ADL_Main_Control_Destroy (data.hm_amd);
16990
16991 adl_close (data.hm_amd);
16992 data.hm_amd = NULL;
16993 }
16994 #endif
16995 }
16996 #endif // HAVE_HWMON
16997
16998 // free memory
16999
17000 local_free (masks);
17001
17002 local_free (dictstat_base);
17003
17004 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17005 {
17006 pot_t *pot_ptr = &pot[pot_pos];
17007
17008 hash_t *hash = &pot_ptr->hash;
17009
17010 local_free (hash->digest);
17011
17012 if (isSalted)
17013 {
17014 local_free (hash->salt);
17015 }
17016 }
17017
17018 local_free (pot);
17019
17020 local_free (all_kernel_rules_cnt);
17021 local_free (all_kernel_rules_buf);
17022
17023 local_free (wl_data->buf);
17024 local_free (wl_data);
17025
17026 local_free (bitmap_s1_a);
17027 local_free (bitmap_s1_b);
17028 local_free (bitmap_s1_c);
17029 local_free (bitmap_s1_d);
17030 local_free (bitmap_s2_a);
17031 local_free (bitmap_s2_b);
17032 local_free (bitmap_s2_c);
17033 local_free (bitmap_s2_d);
17034
17035 #ifdef HAVE_HWMON
17036 local_free (temp_retain_fanspeed_value);
17037 #ifdef HAVE_ADL
17038 local_free (od_clock_mem_status);
17039 local_free (od_power_control_status);
17040 #endif // ADL
17041 #endif
17042
17043 global_free (devices_param);
17044
17045 global_free (kernel_rules_buf);
17046
17047 global_free (root_css_buf);
17048 global_free (markov_css_buf);
17049
17050 global_free (digests_buf);
17051 global_free (digests_shown);
17052 global_free (digests_shown_tmp);
17053
17054 global_free (salts_buf);
17055 global_free (salts_shown);
17056
17057 global_free (esalts_buf);
17058
17059 global_free (words_progress_done);
17060 global_free (words_progress_rejected);
17061 global_free (words_progress_restored);
17062
17063 if (pot_fp) fclose (pot_fp);
17064
17065 if (data.devices_status == STATUS_QUIT) break;
17066 }
17067
17068 // destroy others mutex
17069
17070 hc_thread_mutex_delete (mux_dispatcher);
17071 hc_thread_mutex_delete (mux_counter);
17072 hc_thread_mutex_delete (mux_display);
17073 hc_thread_mutex_delete (mux_adl);
17074
17075 // free memory
17076
17077 local_free (eff_restore_file);
17078 local_free (new_restore_file);
17079
17080 local_free (rd);
17081
17082 // tuning db
17083
17084 tuning_db_destroy (tuning_db);
17085
17086 // loopback
17087
17088 local_free (loopback_file);
17089
17090 if (loopback == 1) unlink (loopback_file);
17091
17092 // induction directory
17093
17094 if (induction_dir == NULL)
17095 {
17096 if (attack_mode != ATTACK_MODE_BF)
17097 {
17098 if (rmdir (induction_directory) == -1)
17099 {
17100 if (errno == ENOENT)
17101 {
17102 // good, we can ignore
17103 }
17104 else if (errno == ENOTEMPTY)
17105 {
17106 // good, we can ignore
17107 }
17108 else
17109 {
17110 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17111
17112 return (-1);
17113 }
17114 }
17115
17116 local_free (induction_directory);
17117 }
17118 }
17119
17120 // outfile-check directory
17121
17122 if (outfile_check_dir == NULL)
17123 {
17124 if (rmdir (outfile_check_directory) == -1)
17125 {
17126 if (errno == ENOENT)
17127 {
17128 // good, we can ignore
17129 }
17130 else if (errno == ENOTEMPTY)
17131 {
17132 // good, we can ignore
17133 }
17134 else
17135 {
17136 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17137
17138 return (-1);
17139 }
17140 }
17141
17142 local_free (outfile_check_directory);
17143 }
17144
17145 time_t proc_stop;
17146
17147 time (&proc_stop);
17148
17149 logfile_top_uint (proc_start);
17150 logfile_top_uint (proc_stop);
17151
17152 logfile_top_msg ("STOP");
17153
17154 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17155 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17156
17157 if (data.ocl) ocl_close (data.ocl);
17158
17159 if (data.devices_status == STATUS_ABORTED) return 2;
17160 if (data.devices_status == STATUS_QUIT) return 2;
17161 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17162 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17163 if (data.devices_status == STATUS_CRACKED) return 0;
17164
17165 return -1;
17166 }
Hashcat additions to support pwdhash