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