projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Autotuning engine prototype
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 double TARGET_MS_PROFILE[3] = { 8, 16, 96 };
22
23 #define INCR_RULES 10000
24 #define INCR_SALTS 100000
25 #define INCR_MASKS 1000
26 #define INCR_POT 1000
27
28 #define USAGE 0
29 #define VERSION 0
30 #define QUIET 0
31 #define MARKOV_THRESHOLD 0
32 #define MARKOV_DISABLE 0
33 #define MARKOV_CLASSIC 0
34 #define BENCHMARK 0
35 #define RESTORE 0
36 #define RESTORE_TIMER 60
37 #define RESTORE_DISABLE 0
38 #define STATUS 0
39 #define STATUS_TIMER 10
40 #define STATUS_AUTOMAT 0
41 #define LOOPBACK 0
42 #define WEAK_HASH_THRESHOLD 100
43 #define SHOW 0
44 #define LEFT 0
45 #define USERNAME 0
46 #define REMOVE 0
47 #define REMOVE_TIMER 60
48 #define SKIP 0
49 #define LIMIT 0
50 #define KEYSPACE 0
51 #define POTFILE_DISABLE 0
52 #define DEBUG_MODE 0
53 #define RP_GEN 0
54 #define RP_GEN_FUNC_MIN 1
55 #define RP_GEN_FUNC_MAX 4
56 #define RP_GEN_SEED 0
57 #define RULE_BUF_L ":"
58 #define RULE_BUF_R ":"
59 #define FORCE 0
60 #define RUNTIME 0
61 #define HEX_CHARSET 0
62 #define HEX_SALT 0
63 #define HEX_WORDLIST 0
64 #define OUTFILE_FORMAT 3
65 #define OUTFILE_AUTOHEX 1
66 #define OUTFILE_CHECK_TIMER 5
67 #define ATTACK_MODE 0
68 #define HASH_MODE 0
69 #define SEGMENT_SIZE 32
70 #define INCREMENT 0
71 #define INCREMENT_MIN 1
72 #define INCREMENT_MAX PW_MAX
73 #define SEPARATOR ':'
74 #define BITMAP_MIN 16
75 #define BITMAP_MAX 24
76 #define GPU_TEMP_DISABLE 0
77 #define GPU_TEMP_ABORT 90
78 #define GPU_TEMP_RETAIN 80
79 #define WORKLOAD_PROFILE 2
80 #define KERNEL_ACCEL 0
81 #define KERNEL_LOOPS 0
82 #define KERNEL_RULES 1024
83 #define KERNEL_COMBS 1024
84 #define KERNEL_BFS 1024
85 #define KERNEL_THREADS 64
86 #define POWERTUNE_ENABLE 0
87 #define LOGFILE_DISABLE 0
88 #define SCRYPT_TMTO 0
89 #define OPENCL_VECTOR_WIDTH 0
90
91 #define WL_MODE_STDIN 1
92 #define WL_MODE_FILE 2
93 #define WL_MODE_MASK 3
94
95 #define HL_MODE_FILE 4
96 #define HL_MODE_ARG 5
97
98 #define HLFMT_HASHCAT 0
99 #define HLFMT_PWDUMP 1
100 #define HLFMT_PASSWD 2
101 #define HLFMT_SHADOW 3
102 #define HLFMT_DCC 4
103 #define HLFMT_DCC2 5
104 #define HLFMT_NETNTLM1 7
105 #define HLFMT_NETNTLM2 8
106 #define HLFMT_NSLDAP 9
107 #define HLFMT_NSLDAPS 10
108 #define HLFMTS_CNT 11
109
110 #define ATTACK_MODE_STRAIGHT 0
111 #define ATTACK_MODE_COMBI 1
112 #define ATTACK_MODE_TOGGLE 2
113 #define ATTACK_MODE_BF 3
114 #define ATTACK_MODE_PERM 4
115 #define ATTACK_MODE_TABLE 5
116 #define ATTACK_MODE_HYBRID1 6
117 #define ATTACK_MODE_HYBRID2 7
118 #define ATTACK_MODE_NONE 100
119
120 #define ATTACK_KERN_STRAIGHT 0
121 #define ATTACK_KERN_COMBI 1
122 #define ATTACK_KERN_BF 3
123 #define ATTACK_KERN_NONE 100
124
125 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
126 #define ATTACK_EXEC_INSIDE_KERNEL 11
127
128 #define COMBINATOR_MODE_BASE_LEFT 10001
129 #define COMBINATOR_MODE_BASE_RIGHT 10002
130
131 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
132 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
133
134 #define MAX_CUT_TRIES 4
135
136 #define MAX_DICTSTAT 10000
137
138 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
139
140 #define global_free(attr) \
141 { \
142 myfree ((void *) data.attr); \
143 \
144 data.attr = NULL; \
145 }
146
147 #define local_free(attr) \
148 { \
149 myfree ((void *) attr); \
150 \
151 attr = NULL; \
152 }
153
154 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
155 {
156 900,
157 0,
158 5100,
159 100,
160 1400,
161 10800,
162 1700,
163 5000,
164 10100,
165 6000,
166 6100,
167 6900,
168 11700,
169 11800,
170 400,
171 8900,
172 11900,
173 12000,
174 10900,
175 12100,
176 23,
177 2500,
178 5300,
179 5400,
180 5500,
181 5600,
182 7300,
183 7500,
184 8300,
185 11100,
186 11200,
187 11400,
188 121,
189 2611,
190 2711,
191 2811,
192 8400,
193 11,
194 2612,
195 7900,
196 21,
197 11000,
198 124,
199 10000,
200 3711,
201 7600,
202 12,
203 131,
204 132,
205 1731,
206 200,
207 300,
208 3100,
209 112,
210 12300,
211 8000,
212 141,
213 1441,
214 1600,
215 12600,
216 1421,
217 101,
218 111,
219 1711,
220 3000, // broken in osx
221 1000,
222 1100,
223 2100,
224 12800,
225 1500, // broken in osx
226 12400,
227 500,
228 3200,
229 7400,
230 1800,
231 122,
232 1722,
233 7100,
234 6300,
235 6700,
236 6400,
237 6500,
238 2400,
239 2410,
240 5700,
241 9200,
242 9300,
243 22,
244 501,
245 5800,
246 8100,
247 8500,
248 7200,
249 9900,
250 7700,
251 7800,
252 10300,
253 8600,
254 8700,
255 9100,
256 133,
257 11600,
258 12500,
259 13000,
260 6211,
261 6221,
262 6231,
263 6241,
264 8800,
265 12900,
266 12200,
267 9700,
268 9710,
269 9800,
270 9810,
271 9400,
272 9500,
273 9600,
274 10400,
275 10410,
276 10500,
277 10600,
278 10700, // broken in osx
279 9000,
280 5200,
281 6800,
282 6600,
283 8200,
284 11300,
285 12700
286 };
287
288 /**
289 * types
290 */
291
292 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
293
294 /**
295 * globals
296 */
297
298 static unsigned int full01 = 0x01010101;
299 static unsigned int full80 = 0x80808080;
300
301 int SUPPRESS_OUTPUT = 0;
302
303 hc_thread_mutex_t mux_adl;
304 hc_thread_mutex_t mux_counter;
305 hc_thread_mutex_t mux_dispatcher;
306 hc_thread_mutex_t mux_display;
307
308 hc_global_data_t data;
309
310 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
311
312 const char *USAGE_MINI[] =
313 {
314 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
315 "",
316 "Try --help for more help.",
317 NULL
318 };
319
320 const char *USAGE_BIG[] =
321 {
322 "%s, advanced password recovery",
323 "",
324 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
325 "",
326 "=======",
327 "Options",
328 "=======",
329 "",
330 "* General:",
331 "",
332 " -m, --hash-type=NUM Hash-type, see references below",
333 " -a, --attack-mode=NUM Attack-mode, see references below",
334 " -V, --version Print version",
335 " -h, --help Print help",
336 " --quiet Suppress output",
337 "",
338 "* Misc:",
339 "",
340 " --hex-charset Assume charset is given in hex",
341 " --hex-salt Assume salt is given in hex",
342 " --hex-wordlist Assume words in wordlist is given in hex",
343 " --force Ignore warnings",
344 " --status Enable automatic update of the status-screen",
345 " --status-timer=NUM Seconds between status-screen update",
346 " --status-automat Display the status view in a machine readable format",
347 " --loopback Add new plains to induct directory",
348 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
349 "",
350 "* Markov:",
351 "",
352 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
353 " --markov-disable Disables markov-chains, emulates classic brute-force",
354 " --markov-classic Enables classic markov-chains, no per-position enhancement",
355 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
356 "",
357 "* Session:",
358 "",
359 " --runtime=NUM Abort session after NUM seconds of runtime",
360 " --session=STR Define specific session name",
361 " --restore Restore session from --session",
362 " --restore-disable Do not write restore file",
363 "",
364 "* Files:",
365 "",
366 " -o, --outfile=FILE Define outfile for recovered hash",
367 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
368 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
369 " --outfile-check-timer=NUM Seconds between outfile checks",
370 " -p, --separator=CHAR Separator char for hashlists and outfile",
371 " --show Show cracked passwords only",
372 " --left Show un-cracked passwords only",
373 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
374 " --remove Enable remove of hash once it is cracked",
375 " --remove-timer=NUM Update input hash file each NUM seconds",
376 " --potfile-disable Do not write potfile",
377 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
378 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
379 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
380 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
381 " --logfile-disable Disable the logfile",
382 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
383 "",
384 "* Resources:",
385 "",
386 " -b, --benchmark Run benchmark",
387 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
388 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
389 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
390 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
391 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
392 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
393 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
394 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
395 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
396 " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size",
397 " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size",
398 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
399 #ifdef HAVE_HWMON
400 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
401 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
402 #ifdef HAVE_ADL
403 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
404 #endif
405 #endif
406 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
407 "",
408 "* Distributed:",
409 "",
410 " -s, --skip=NUM Skip number of words",
411 " -l, --limit=NUM Limit number of words",
412 " --keyspace Show keyspace base:mod values and quit",
413 "",
414 "* Rules:",
415 "",
416 " -j, --rule-left=RULE Single rule applied to each word from left dict",
417 " -k, --rule-right=RULE Single rule applied to each word from right dict",
418 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
419 " -g, --generate-rules=NUM Generate NUM random rules",
420 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
421 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
422 " --generate-rules-seed=NUM Force RNG seed to NUM",
423 "",
424 "* Custom charsets:",
425 "",
426 " -1, --custom-charset1=CS User-defined charsets",
427 " -2, --custom-charset2=CS Example:",
428 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
429 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
430 "",
431 "* Increment:",
432 "",
433 " -i, --increment Enable increment mode",
434 " --increment-min=NUM Start incrementing at NUM",
435 " --increment-max=NUM Stop incrementing at NUM",
436 "",
437 "==========",
438 "References",
439 "==========",
440 "",
441 "* Workload Profile:",
442 "",
443 " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed",
444 " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting",
445 " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed",
446 "",
447 "* OpenCL device-types:",
448 "",
449 " 1 = CPU devices",
450 " 2 = GPU devices",
451 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
452 "",
453 "* Outfile Formats:",
454 "",
455 " 1 = hash[:salt]",
456 " 2 = plain",
457 " 3 = hash[:salt]:plain",
458 " 4 = hex_plain",
459 " 5 = hash[:salt]:hex_plain",
460 " 6 = plain:hex_plain",
461 " 7 = hash[:salt]:plain:hex_plain",
462 " 8 = crackpos",
463 " 9 = hash[:salt]:crackpos",
464 " 10 = plain:crackpos",
465 " 11 = hash[:salt]:plain:crackpos",
466 " 12 = hex_plain:crackpos",
467 " 13 = hash[:salt]:hex_plain:crackpos",
468 " 14 = plain:hex_plain:crackpos",
469 " 15 = hash[:salt]:plain:hex_plain:crackpos",
470 "",
471 "* Debug mode output formats (for hybrid mode only, by using rules):",
472 "",
473 " 1 = save finding rule",
474 " 2 = save original word",
475 " 3 = save original word and finding rule",
476 " 4 = save original word, finding rule and modified plain",
477 "",
478 "* Built-in charsets:",
479 "",
480 " ?l = abcdefghijklmnopqrstuvwxyz",
481 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
482 " ?d = 0123456789",
483 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
484 " ?a = ?l?u?d?s",
485 " ?b = 0x00 - 0xff",
486 "",
487 "* Attack modes:",
488 "",
489 " 0 = Straight",
490 " 1 = Combination",
491 " 3 = Brute-force",
492 " 6 = Hybrid dict + mask",
493 " 7 = Hybrid mask + dict",
494 "",
495 "* Hash types:",
496 "",
497 "[[ Roll-your-own: Raw Hashes ]]",
498 "",
499 " 900 = MD4",
500 " 0 = MD5",
501 " 5100 = Half MD5",
502 " 100 = SHA1",
503 " 10800 = SHA-384",
504 " 1400 = SHA-256",
505 " 1700 = SHA-512",
506 " 5000 = SHA-3(Keccak)",
507 " 10100 = SipHash",
508 " 6000 = RipeMD160",
509 " 6100 = Whirlpool",
510 " 6900 = GOST R 34.11-94",
511 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
512 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
513 "",
514 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
515 "",
516 " 10 = md5($pass.$salt)",
517 " 20 = md5($salt.$pass)",
518 " 30 = md5(unicode($pass).$salt)",
519 " 40 = md5($salt.unicode($pass))",
520 " 3800 = md5($salt.$pass.$salt)",
521 " 3710 = md5($salt.md5($pass))",
522 " 2600 = md5(md5($pass)",
523 " 4300 = md5(strtoupper(md5($pass)))",
524 " 4400 = md5(sha1($pass))",
525 " 110 = sha1($pass.$salt)",
526 " 120 = sha1($salt.$pass)",
527 " 130 = sha1(unicode($pass).$salt)",
528 " 140 = sha1($salt.unicode($pass))",
529 " 4500 = sha1(sha1($pass)",
530 " 4700 = sha1(md5($pass))",
531 " 4900 = sha1($salt.$pass.$salt)",
532 " 1410 = sha256($pass.$salt)",
533 " 1420 = sha256($salt.$pass)",
534 " 1430 = sha256(unicode($pass).$salt)",
535 " 1440 = sha256($salt.unicode($pass))",
536 " 1710 = sha512($pass.$salt)",
537 " 1720 = sha512($salt.$pass)",
538 " 1730 = sha512(unicode($pass).$salt)",
539 " 1740 = sha512($salt.unicode($pass))",
540 "",
541 "[[ Roll-your-own: Authenticated Hashes ]]",
542 "",
543 " 50 = HMAC-MD5 (key = $pass)",
544 " 60 = HMAC-MD5 (key = $salt)",
545 " 150 = HMAC-SHA1 (key = $pass)",
546 " 160 = HMAC-SHA1 (key = $salt)",
547 " 1450 = HMAC-SHA256 (key = $pass)",
548 " 1460 = HMAC-SHA256 (key = $salt)",
549 " 1750 = HMAC-SHA512 (key = $pass)",
550 " 1760 = HMAC-SHA512 (key = $salt)",
551 "",
552 "[[ Generic KDF ]]",
553 "",
554 " 400 = phpass",
555 " 8900 = scrypt",
556 " 11900 = PBKDF2-HMAC-MD5",
557 " 12000 = PBKDF2-HMAC-SHA1",
558 " 10900 = PBKDF2-HMAC-SHA256",
559 " 12100 = PBKDF2-HMAC-SHA512",
560 "",
561 "[[ Network protocols, Challenge-Response ]]",
562 "",
563 " 23 = Skype",
564 " 2500 = WPA/WPA2",
565 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
566 " 5300 = IKE-PSK MD5",
567 " 5400 = IKE-PSK SHA1",
568 " 5500 = NetNTLMv1",
569 " 5500 = NetNTLMv1 + ESS",
570 " 5600 = NetNTLMv2",
571 " 7300 = IPMI2 RAKP HMAC-SHA1",
572 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
573 " 8300 = DNSSEC (NSEC3)",
574 " 10200 = Cram MD5",
575 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
576 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
577 " 11400 = SIP digest authentication (MD5)",
578 "",
579 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
580 "",
581 " 121 = SMF (Simple Machines Forum)",
582 " 400 = phpBB3",
583 " 2611 = vBulletin < v3.8.5",
584 " 2711 = vBulletin > v3.8.5",
585 " 2811 = MyBB",
586 " 2811 = IPB (Invison Power Board)",
587 " 8400 = WBB3 (Woltlab Burning Board)",
588 " 11 = Joomla < 2.5.18",
589 " 400 = Joomla > 2.5.18",
590 " 400 = Wordpress",
591 " 2612 = PHPS",
592 " 7900 = Drupal7",
593 " 21 = osCommerce",
594 " 21 = xt:Commerce",
595 " 11000 = PrestaShop",
596 " 124 = Django (SHA-1)",
597 " 10000 = Django (PBKDF2-SHA256)",
598 " 3711 = Mediawiki B type",
599 " 7600 = Redmine",
600 "",
601 "[[ Database Server ]]",
602 "",
603 " 12 = PostgreSQL",
604 " 131 = MSSQL(2000)",
605 " 132 = MSSQL(2005)",
606 " 1731 = MSSQL(2012)",
607 " 1731 = MSSQL(2014)",
608 " 200 = MySQL323",
609 " 300 = MySQL4.1/MySQL5",
610 " 3100 = Oracle H: Type (Oracle 7+)",
611 " 112 = Oracle S: Type (Oracle 11+)",
612 " 12300 = Oracle T: Type (Oracle 12+)",
613 " 8000 = Sybase ASE",
614 "",
615 "[[ HTTP, SMTP, LDAP Server ]]",
616 "",
617 " 141 = EPiServer 6.x < v4",
618 " 1441 = EPiServer 6.x > v4",
619 " 1600 = Apache $apr1$",
620 " 12600 = ColdFusion 10+",
621 " 1421 = hMailServer",
622 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
623 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
624 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
625 "",
626 "[[ Checksums ]]",
627 "",
628 " 11500 = CRC32",
629 "",
630 "[[ Operating-Systems ]]",
631 "",
632 " 3000 = LM",
633 " 1000 = NTLM",
634 " 1100 = Domain Cached Credentials (DCC), MS Cache",
635 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
636 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
637 " 1500 = descrypt, DES(Unix), Traditional DES",
638 " 12400 = BSDiCrypt, Extended DES",
639 " 500 = md5crypt $1$, MD5(Unix)",
640 " 3200 = bcrypt $2*$, Blowfish(Unix)",
641 " 7400 = sha256crypt $5$, SHA256(Unix)",
642 " 1800 = sha512crypt $6$, SHA512(Unix)",
643 " 122 = OSX v10.4",
644 " 122 = OSX v10.5",
645 " 122 = OSX v10.6",
646 " 1722 = OSX v10.7",
647 " 7100 = OSX v10.8",
648 " 7100 = OSX v10.9",
649 " 7100 = OSX v10.10",
650 " 6300 = AIX {smd5}",
651 " 6700 = AIX {ssha1}",
652 " 6400 = AIX {ssha256}",
653 " 6500 = AIX {ssha512}",
654 " 2400 = Cisco-PIX",
655 " 2410 = Cisco-ASA",
656 " 500 = Cisco-IOS $1$",
657 " 5700 = Cisco-IOS $4$",
658 " 9200 = Cisco-IOS $8$",
659 " 9300 = Cisco-IOS $9$",
660 " 22 = Juniper Netscreen/SSG (ScreenOS)",
661 " 501 = Juniper IVE",
662 " 5800 = Android PIN",
663 " 8100 = Citrix Netscaler",
664 " 8500 = RACF",
665 " 7200 = GRUB 2",
666 " 9900 = Radmin2",
667 "",
668 "[[ Enterprise Application Software (EAS) ]]",
669 "",
670 " 7700 = SAP CODVN B (BCODE)",
671 " 7800 = SAP CODVN F/G (PASSCODE)",
672 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
673 " 8600 = Lotus Notes/Domino 5",
674 " 8700 = Lotus Notes/Domino 6",
675 " 9100 = Lotus Notes/Domino 8",
676 " 133 = PeopleSoft",
677 "",
678 "[[ Archives ]]",
679 "",
680 " 11600 = 7-Zip",
681 " 12500 = RAR3-hp",
682 " 13000 = RAR5",
683 "",
684 "[[ Full-Disk encryptions (FDE) ]]",
685 "",
686 " 62XY = TrueCrypt 5.0+",
687 " X = 1 = PBKDF2-HMAC-RipeMD160",
688 " X = 2 = PBKDF2-HMAC-SHA512",
689 " X = 3 = PBKDF2-HMAC-Whirlpool",
690 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
691 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
692 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
693 " Y = 3 = XTS 1536 bit (Ciphers: All)",
694 " 8800 = Android FDE < v4.3",
695 " 12900 = Android FDE (Samsung DEK)",
696 " 12200 = eCryptfs",
697 "",
698 "[[ Documents ]]",
699 "",
700 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
701 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
702 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
703 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
704 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
705 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
706 " 9400 = MS Office 2007",
707 " 9500 = MS Office 2010",
708 " 9600 = MS Office 2013",
709 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
710 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
711 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
712 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
713 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
714 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
715 "",
716 "[[ Password Managers ]]",
717 "",
718 " 9000 = Password Safe v2",
719 " 5200 = Password Safe v3",
720 " 6800 = Lastpass",
721 " 6600 = 1Password, agilekeychain",
722 " 8200 = 1Password, cloudkeychain",
723 " 11300 = Bitcoin/Litecoin wallet.dat",
724 " 12700 = Blockchain, My Wallet",
725 "",
726 NULL
727 };
728
729 /**
730 * oclHashcat specific functions
731 */
732
733 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
734 {
735 int exec_pos = (int) device_param->exec_pos - last_num_entries;
736
737 if (exec_pos < 0) exec_pos += EXEC_CACHE;
738
739 double exec_ms_sum = 0;
740
741 int exec_ms_cnt = 0;
742
743 for (int i = 0; i < last_num_entries; i++)
744 {
745 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
746
747 if (exec_ms)
748 {
749 exec_ms_sum += exec_ms;
750
751 exec_ms_cnt++;
752 }
753 }
754
755 if (exec_ms_cnt == 0) return 0;
756
757 return exec_ms_sum / exec_ms_cnt;
758 }
759
760 void status_display_automat ()
761 {
762 FILE *out = stdout;
763
764 fprintf (out, "STATUS\t%u\t", data.devices_status);
765
766 /**
767 * speed new
768 */
769
770 fprintf (out, "SPEED\t");
771
772 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
773 {
774 hc_device_param_t *device_param = &data.devices_param[device_id];
775
776 if (device_param->skipped) continue;
777
778 u64 speed_cnt = 0;
779 float speed_ms = 0;
780
781 for (int i = 0; i < SPEED_CACHE; i++)
782 {
783 float rec_ms;
784
785 hc_timer_get (device_param->speed_rec[i], rec_ms);
786
787 if (rec_ms > SPEED_MAXAGE) continue;
788
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 uint salts_left = data.salts_cnt - data.salts_done;
829
830 if (salts_left == 0) salts_left = 1;
831
832 u64 progress_total = data.words_cnt * salts_left;
833
834 u64 all_done = 0;
835 u64 all_rejected = 0;
836 u64 all_restored = 0;
837
838 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
839 {
840 if (salts_left > 1)
841 {
842 // otherwise the final cracked status shows 0/XXX progress
843
844 if (data.salts_shown[salt_pos] == 1) continue;
845 }
846
847 all_done += data.words_progress_done[salt_pos];
848 all_rejected += data.words_progress_rejected[salt_pos];
849 all_restored += data.words_progress_restored[salt_pos];
850 }
851
852 u64 progress_cur = all_restored + all_done + all_rejected;
853 u64 progress_end = progress_total;
854
855 u64 progress_skip = 0;
856
857 if (data.skip)
858 {
859 progress_skip = MIN (data.skip, data.words_base) * salts_left;
860
861 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
862 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
863 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
864 }
865
866 if (data.limit)
867 {
868 progress_end = MIN (data.limit, data.words_base) * salts_left;
869
870 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
871 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
872 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
873 }
874
875 u64 progress_cur_relative_skip = progress_cur - progress_skip;
876 u64 progress_end_relative_skip = progress_end - progress_skip;
877
878 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
879
880 /**
881 * cracks
882 */
883
884 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
885 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
886
887 /**
888 * temperature
889 */
890
891 #ifdef HAVE_HWMON
892 if (data.gpu_temp_disable == 0)
893 {
894 fprintf (out, "TEMP\t");
895
896 hc_thread_mutex_lock (mux_adl);
897
898 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
899 {
900 hc_device_param_t *device_param = &data.devices_param[device_id];
901
902 if (device_param->skipped) continue;
903
904 int temp = hm_get_temperature_with_device_id (device_id);
905
906 fprintf (out, "%d\t", temp);
907 }
908
909 hc_thread_mutex_unlock (mux_adl);
910 }
911 #endif // HAVE_HWMON
912
913 /**
914 * flush
915 */
916
917 #ifdef _WIN
918 fputc ('\r', out);
919 fputc ('\n', out);
920 #endif
921
922 #ifdef _POSIX
923 fputc ('\n', out);
924 #endif
925
926 fflush (out);
927 }
928
929 void status_display ()
930 {
931 if (data.devices_status == STATUS_INIT) return;
932 if (data.devices_status == STATUS_STARTING) return;
933 if (data.devices_status == STATUS_BYPASS) return;
934
935 if (data.status_automat == 1)
936 {
937 status_display_automat ();
938
939 return;
940 }
941
942 char tmp_buf[1000] = { 0 };
943
944 uint tmp_len = 0;
945
946 log_info ("Session.Name...: %s", data.session);
947
948 char *status_type = strstatus (data.devices_status);
949
950 uint hash_mode = data.hash_mode;
951
952 char *hash_type = strhashtype (hash_mode); // not a bug
953
954 log_info ("Status.........: %s", status_type);
955
956 /**
957 * show rules
958 */
959
960 if (data.rp_files_cnt)
961 {
962 uint i;
963
964 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
965 {
966 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
967 }
968
969 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
970
971 log_info ("Rules.Type.....: %s", tmp_buf);
972
973 tmp_len = 0;
974 }
975
976 if (data.rp_gen)
977 {
978 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
979
980 if (data.rp_gen_seed)
981 {
982 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
983 }
984 }
985
986 /**
987 * show input
988 */
989
990 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
991 {
992 if (data.wordlist_mode == WL_MODE_FILE)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
995 }
996 else if (data.wordlist_mode == WL_MODE_STDIN)
997 {
998 log_info ("Input.Mode.....: Pipe");
999 }
1000 }
1001 else if (data.attack_mode == ATTACK_MODE_COMBI)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1004 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_BF)
1007 {
1008 char *mask = data.mask;
1009
1010 if (mask != NULL)
1011 {
1012 uint mask_len = data.css_cnt;
1013
1014 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1015
1016 if (mask_len > 0)
1017 {
1018 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1019 {
1020 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1021 {
1022 mask_len -= data.salts_buf[0].salt_len;
1023 }
1024 }
1025
1026 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1029 }
1030
1031 if (data.maskcnt > 1)
1032 {
1033 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1034
1035 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1036 }
1037
1038 log_info ("Input.Mode.....: %s", tmp_buf);
1039 }
1040
1041 tmp_len = 0;
1042 }
1043 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1044 {
1045 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1046 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1049 {
1050 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1052 }
1053
1054 if (data.digests_cnt == 1)
1055 {
1056 if (data.hash_mode == 2500)
1057 {
1058 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1059
1060 uint pke[25] = { 0 };
1061
1062 char *pke_ptr = (char *) pke;
1063
1064 for (uint i = 0; i < 25; i++)
1065 {
1066 pke[i] = byte_swap_32 (wpa->pke[i]);
1067 }
1068
1069 char mac1[6] = { 0 };
1070 char mac2[6] = { 0 };
1071
1072 memcpy (mac1, pke_ptr + 23, 6);
1073 memcpy (mac2, pke_ptr + 29, 6);
1074
1075 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1076 (char *) data.salts_buf[0].salt_buf,
1077 mac1[0] & 0xff,
1078 mac1[1] & 0xff,
1079 mac1[2] & 0xff,
1080 mac1[3] & 0xff,
1081 mac1[4] & 0xff,
1082 mac1[5] & 0xff,
1083 mac2[0] & 0xff,
1084 mac2[1] & 0xff,
1085 mac2[2] & 0xff,
1086 mac2[3] & 0xff,
1087 mac2[4] & 0xff,
1088 mac2[5] & 0xff);
1089 }
1090 else if (data.hash_mode == 5200)
1091 {
1092 log_info ("Hash.Target....: File (%s)", data.hashfile);
1093 }
1094 else if (data.hash_mode == 9000)
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1099 {
1100 log_info ("Hash.Target....: File (%s)", data.hashfile);
1101 }
1102 else
1103 {
1104 char out_buf[4096] = { 0 };
1105
1106 ascii_digest (out_buf, 0, 0);
1107
1108 // limit length
1109 if (strlen (out_buf) > 40)
1110 {
1111 out_buf[41] = '.';
1112 out_buf[42] = '.';
1113 out_buf[43] = '.';
1114 out_buf[44] = 0;
1115 }
1116
1117 log_info ("Hash.Target....: %s", out_buf);
1118 }
1119 }
1120 else
1121 {
1122 if (data.hash_mode == 3000)
1123 {
1124 char out_buf1[4096] = { 0 };
1125 char out_buf2[4096] = { 0 };
1126
1127 ascii_digest (out_buf1, 0, 0);
1128 ascii_digest (out_buf2, 0, 1);
1129
1130 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1131 }
1132 else
1133 {
1134 log_info ("Hash.Target....: File (%s)", data.hashfile);
1135 }
1136 }
1137
1138 log_info ("Hash.Type......: %s", hash_type);
1139
1140 /**
1141 * speed new
1142 */
1143
1144 u64 speed_cnt[DEVICES_MAX] = { 0 };
1145 float speed_ms[DEVICES_MAX] = { 0 };
1146
1147 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1148 {
1149 hc_device_param_t *device_param = &data.devices_param[device_id];
1150
1151 if (device_param->skipped) continue;
1152
1153 // we need to clear values (set to 0) because in case the device does
1154 // not get new candidates it idles around but speed display would
1155 // show it as working.
1156 // if we instantly set it to 0 after reading it happens that the
1157 // speed can be shown as zero if the users refreshes too fast.
1158 // therefore, we add a timestamp when a stat was recorded and if its
1159 // too old we will not use it
1160
1161 speed_cnt[device_id] = 0;
1162 speed_ms[device_id] = 0;
1163
1164 for (int i = 0; i < SPEED_CACHE; i++)
1165 {
1166 float rec_ms;
1167
1168 hc_timer_get (device_param->speed_rec[i], rec_ms);
1169
1170 if (rec_ms > SPEED_MAXAGE) continue;
1171
1172 speed_cnt[device_id] += device_param->speed_cnt[i];
1173 speed_ms[device_id] += device_param->speed_ms[i];
1174 }
1175
1176 speed_cnt[device_id] /= SPEED_CACHE;
1177 speed_ms[device_id] /= SPEED_CACHE;
1178 }
1179
1180 float hashes_all_ms = 0;
1181
1182 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1183
1184 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1185 {
1186 hc_device_param_t *device_param = &data.devices_param[device_id];
1187
1188 if (device_param->skipped) continue;
1189
1190 hashes_dev_ms[device_id] = 0;
1191
1192 if (speed_ms[device_id])
1193 {
1194 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1195
1196 hashes_all_ms += hashes_dev_ms[device_id];
1197 }
1198 }
1199
1200 /**
1201 * exec time
1202 */
1203
1204 double exec_all_ms[DEVICES_MAX] = { 0 };
1205
1206 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1207 {
1208 hc_device_param_t *device_param = &data.devices_param[device_id];
1209
1210 if (device_param->skipped) continue;
1211
1212 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1213
1214 exec_all_ms[device_id] = exec_ms_avg;
1215 }
1216
1217 /**
1218 * timers
1219 */
1220
1221 float ms_running = 0;
1222
1223 hc_timer_get (data.timer_running, ms_running);
1224
1225 float ms_paused = data.ms_paused;
1226
1227 if (data.devices_status == STATUS_PAUSED)
1228 {
1229 float ms_paused_tmp = 0;
1230
1231 hc_timer_get (data.timer_paused, ms_paused_tmp);
1232
1233 ms_paused += ms_paused_tmp;
1234 }
1235
1236 #ifdef WIN
1237
1238 __time64_t sec_run = ms_running / 1000;
1239
1240 #else
1241
1242 time_t sec_run = ms_running / 1000;
1243
1244 #endif
1245
1246 if (sec_run)
1247 {
1248 char display_run[32] = { 0 };
1249
1250 struct tm tm_run;
1251
1252 struct tm *tmp = NULL;
1253
1254 #ifdef WIN
1255
1256 tmp = _gmtime64 (&sec_run);
1257
1258 #else
1259
1260 tmp = gmtime (&sec_run);
1261
1262 #endif
1263
1264 if (tmp != NULL)
1265 {
1266 memset (&tm_run, 0, sizeof (tm_run));
1267
1268 memcpy (&tm_run, tmp, sizeof (tm_run));
1269
1270 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1271
1272 char *start = ctime (&data.proc_start);
1273
1274 size_t start_len = strlen (start);
1275
1276 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1277 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1278
1279 log_info ("Time.Started...: %s (%s)", start, display_run);
1280 }
1281 }
1282 else
1283 {
1284 log_info ("Time.Started...: 0 secs");
1285 }
1286
1287 /**
1288 * counters
1289 */
1290
1291 uint salts_left = data.salts_cnt - data.salts_done;
1292
1293 if (salts_left == 0) salts_left = 1;
1294
1295 u64 progress_total = data.words_cnt * salts_left;
1296
1297 u64 all_done = 0;
1298 u64 all_rejected = 0;
1299 u64 all_restored = 0;
1300
1301 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1302 {
1303 if (salts_left > 1)
1304 {
1305 // otherwise the final cracked status shows 0/XXX progress
1306
1307 if (data.salts_shown[salt_pos] == 1) continue;
1308 }
1309
1310 all_done += data.words_progress_done[salt_pos];
1311 all_rejected += data.words_progress_rejected[salt_pos];
1312 all_restored += data.words_progress_restored[salt_pos];
1313 }
1314
1315 u64 progress_cur = all_restored + all_done + all_rejected;
1316 u64 progress_end = progress_total;
1317
1318 u64 progress_skip = 0;
1319
1320 if (data.skip)
1321 {
1322 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1323
1324 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1325 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1326 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1327 }
1328
1329 if (data.limit)
1330 {
1331 progress_end = MIN (data.limit, data.words_base) * salts_left;
1332
1333 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1334 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1335 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1336 }
1337
1338 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1339 u64 progress_end_relative_skip = progress_end - progress_skip;
1340
1341 float speed_ms_real = ms_running - ms_paused;
1342 u64 speed_plains_real = all_done;
1343
1344 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1345 {
1346 if (data.devices_status != STATUS_CRACKED)
1347 {
1348 u64 words_per_ms = 0;
1349
1350 if (speed_plains_real && speed_ms_real)
1351 {
1352 words_per_ms = speed_plains_real / speed_ms_real;
1353 }
1354
1355 #ifdef WIN
1356 __time64_t sec_etc = 0;
1357 #else
1358 time_t sec_etc = 0;
1359 #endif
1360
1361 if (words_per_ms)
1362 {
1363 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1364
1365 u64 ms_left = progress_left_relative_skip / words_per_ms;
1366
1367 sec_etc = ms_left / 1000;
1368 }
1369
1370 if (sec_etc == 0)
1371 {
1372 log_info ("Time.Estimated.: 0 secs");
1373 }
1374 else if ((u64) sec_etc > ETC_MAX)
1375 {
1376 log_info ("Time.Estimated.: > 10 Years");
1377 }
1378 else
1379 {
1380 char display_etc[32] = { 0 };
1381
1382 struct tm tm_etc;
1383
1384 struct tm *tmp = NULL;
1385
1386 #ifdef WIN
1387
1388 tmp = _gmtime64 (&sec_etc);
1389
1390 #else
1391
1392 tmp = gmtime (&sec_etc);
1393
1394 #endif
1395
1396 if (tmp != NULL)
1397 {
1398 memset (&tm_etc, 0, sizeof (tm_etc));
1399
1400 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1401
1402 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1403
1404 time_t now;
1405
1406 time (&now);
1407
1408 now += sec_etc;
1409
1410 char *etc = ctime (&now);
1411
1412 size_t etc_len = strlen (etc);
1413
1414 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1415 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1416
1417 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1418 }
1419 }
1420 }
1421 }
1422
1423 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1424 {
1425 hc_device_param_t *device_param = &data.devices_param[device_id];
1426
1427 if (device_param->skipped) continue;
1428
1429 char display_dev_cur[16] = { 0 };
1430
1431 strncpy (display_dev_cur, "0.00", 4);
1432
1433 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1434
1435 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1436 }
1437
1438 char display_all_cur[16] = { 0 };
1439
1440 strncpy (display_all_cur, "0.00", 4);
1441
1442 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1443
1444 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1445
1446 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1447 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1448
1449 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);
1450
1451 // crack-per-time
1452
1453 if (data.digests_cnt > 100)
1454 {
1455 time_t now = time (NULL);
1456
1457 int cpt_cur_min = 0;
1458 int cpt_cur_hour = 0;
1459 int cpt_cur_day = 0;
1460
1461 for (int i = 0; i < CPT_BUF; i++)
1462 {
1463 const uint cracked = data.cpt_buf[i].cracked;
1464 const time_t timestamp = data.cpt_buf[i].timestamp;
1465
1466 if ((timestamp + 60) > now)
1467 {
1468 cpt_cur_min += cracked;
1469 }
1470
1471 if ((timestamp + 3600) > now)
1472 {
1473 cpt_cur_hour += cracked;
1474 }
1475
1476 if ((timestamp + 86400) > now)
1477 {
1478 cpt_cur_day += cracked;
1479 }
1480 }
1481
1482 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1483 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1484 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1485
1486 if ((data.cpt_start + 86400) < now)
1487 {
1488 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1489 cpt_cur_min,
1490 cpt_cur_hour,
1491 cpt_cur_day,
1492 cpt_avg_min,
1493 cpt_avg_hour,
1494 cpt_avg_day);
1495 }
1496 else if ((data.cpt_start + 3600) < now)
1497 {
1498 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1499 cpt_cur_min,
1500 cpt_cur_hour,
1501 cpt_avg_min,
1502 cpt_avg_hour,
1503 cpt_avg_day);
1504 }
1505 else if ((data.cpt_start + 60) < now)
1506 {
1507 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1508 cpt_cur_min,
1509 cpt_avg_min,
1510 cpt_avg_hour,
1511 cpt_avg_day);
1512 }
1513 else
1514 {
1515 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1516 cpt_avg_min,
1517 cpt_avg_hour,
1518 cpt_avg_day);
1519 }
1520 }
1521
1522 // Restore point
1523
1524 u64 restore_point = get_lowest_words_done ();
1525
1526 u64 restore_total = data.words_base;
1527
1528 float percent_restore = 0;
1529
1530 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1531
1532 if (progress_end_relative_skip)
1533 {
1534 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1535 {
1536 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1537 float percent_rejected = 0.0;
1538
1539 if (progress_cur)
1540 {
1541 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1542 }
1543
1544 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);
1545 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1546
1547 if (data.restore_disable == 0)
1548 {
1549 if (percent_finished != 1)
1550 {
1551 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1552 }
1553 }
1554 }
1555 }
1556 else
1557 {
1558 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1559 {
1560 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1562
1563 if (data.restore_disable == 0)
1564 {
1565 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1566 }
1567 }
1568 else
1569 {
1570 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1571 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1572
1573 // --restore not allowed if stdin is used -- really? why?
1574
1575 //if (data.restore_disable == 0)
1576 //{
1577 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1578 //}
1579 }
1580 }
1581
1582 #ifdef HAVE_HWMON
1583 if (data.gpu_temp_disable == 0)
1584 {
1585 hc_thread_mutex_lock (mux_adl);
1586
1587 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1588 {
1589 hc_device_param_t *device_param = &data.devices_param[device_id];
1590
1591 if (device_param->skipped) continue;
1592
1593 #define HM_STR_BUF_SIZE 255
1594
1595 if (data.hm_device[device_id].fan_supported == 1)
1596 {
1597 char utilization[HM_STR_BUF_SIZE] = { 0 };
1598 char temperature[HM_STR_BUF_SIZE] = { 0 };
1599 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1600
1601 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1602 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1603
1604 if (device_param->vendor_id == VENDOR_ID_AMD)
1605 {
1606 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1607 }
1608 else if (device_param->vendor_id == VENDOR_ID_NV)
1609 {
1610 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1611 }
1612
1613 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1614 }
1615 else
1616 {
1617 char utilization[HM_STR_BUF_SIZE] = { 0 };
1618 char temperature[HM_STR_BUF_SIZE] = { 0 };
1619
1620 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1621 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1622
1623 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1624 }
1625 }
1626
1627 hc_thread_mutex_unlock (mux_adl);
1628 }
1629 #endif // HAVE_HWMON
1630 }
1631
1632 static void status_benchmark ()
1633 {
1634 if (data.devices_status == STATUS_INIT) return;
1635 if (data.devices_status == STATUS_STARTING) return;
1636
1637 if (data.words_cnt == 0) return;
1638
1639 u64 speed_cnt[DEVICES_MAX] = { 0 };
1640 float speed_ms[DEVICES_MAX] = { 0 };
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 speed_cnt[device_id] = 0;
1649 speed_ms[device_id] = 0;
1650
1651 for (int i = 0; i < SPEED_CACHE; i++)
1652 {
1653 speed_cnt[device_id] += device_param->speed_cnt[i];
1654 speed_ms[device_id] += device_param->speed_ms[i];
1655 }
1656
1657 speed_cnt[device_id] /= SPEED_CACHE;
1658 speed_ms[device_id] /= SPEED_CACHE;
1659 }
1660
1661 float hashes_all_ms = 0;
1662
1663 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 hashes_dev_ms[device_id] = 0;
1672
1673 if (speed_ms[device_id])
1674 {
1675 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1676
1677 hashes_all_ms += hashes_dev_ms[device_id];
1678 }
1679 }
1680
1681 /**
1682 * exec time
1683 */
1684
1685 double exec_all_ms[DEVICES_MAX] = { 0 };
1686
1687 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1688 {
1689 hc_device_param_t *device_param = &data.devices_param[device_id];
1690
1691 if (device_param->skipped) continue;
1692
1693 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1694
1695 exec_all_ms[device_id] = exec_ms_avg;
1696 }
1697
1698 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1699 {
1700 hc_device_param_t *device_param = &data.devices_param[device_id];
1701
1702 if (device_param->skipped) continue;
1703
1704 char display_dev_cur[16] = { 0 };
1705
1706 strncpy (display_dev_cur, "0.00", 4);
1707
1708 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1709
1710 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1711 }
1712
1713 char display_all_cur[16] = { 0 };
1714
1715 strncpy (display_all_cur, "0.00", 4);
1716
1717 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1718
1719 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1720 }
1721
1722 /**
1723 * oclHashcat -only- functions
1724 */
1725
1726 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1727 {
1728 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1729 {
1730 if (attack_kern == ATTACK_KERN_STRAIGHT)
1731 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1732 else if (attack_kern == ATTACK_KERN_COMBI)
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1734 else if (attack_kern == ATTACK_KERN_BF)
1735 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1736 }
1737 else
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1739 }
1740
1741 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)
1742 {
1743 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1744 {
1745 if (attack_kern == ATTACK_KERN_STRAIGHT)
1746 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1747 else if (attack_kern == ATTACK_KERN_COMBI)
1748 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1749 else if (attack_kern == ATTACK_KERN_BF)
1750 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1751 }
1752 else
1753 {
1754 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1755 }
1756 }
1757
1758 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1759 {
1760 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1761 {
1762 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1763 }
1764 else
1765 {
1766 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1767 }
1768 }
1769
1770 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)
1771 {
1772 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1773 {
1774 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1775 }
1776 else
1777 {
1778 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1779 }
1780 }
1781
1782 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1783 {
1784 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1785 }
1786
1787 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1788 {
1789 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1790 }
1791
1792 static uint convert_from_hex (char *line_buf, const uint line_len)
1793 {
1794 if (line_len & 1) return (line_len); // not in hex
1795
1796 if (data.hex_wordlist == 1)
1797 {
1798 uint i;
1799 uint j;
1800
1801 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1802 {
1803 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1804 }
1805
1806 memset (line_buf + i, 0, line_len - i);
1807
1808 return (i);
1809 }
1810 else if (line_len >= 6) // $HEX[] = 6
1811 {
1812 if (line_buf[0] != '$') return (line_len);
1813 if (line_buf[1] != 'H') return (line_len);
1814 if (line_buf[2] != 'E') return (line_len);
1815 if (line_buf[3] != 'X') return (line_len);
1816 if (line_buf[4] != '[') return (line_len);
1817 if (line_buf[line_len - 1] != ']') return (line_len);
1818
1819 uint i;
1820 uint j;
1821
1822 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1823 {
1824 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1825 }
1826
1827 memset (line_buf + i, 0, line_len - i);
1828
1829 return (i);
1830 }
1831
1832 return (line_len);
1833 }
1834
1835 static void clear_prompt ()
1836 {
1837 fputc ('\r', stdout);
1838
1839 for (size_t i = 0; i < strlen (PROMPT); i++)
1840 {
1841 fputc (' ', stdout);
1842 }
1843
1844 fputc ('\r', stdout);
1845
1846 fflush (stdout);
1847 }
1848
1849 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1850 {
1851 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);
1852 }
1853
1854 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1855 {
1856 char *outfile = data.outfile;
1857 uint quiet = data.quiet;
1858 FILE *pot_fp = data.pot_fp;
1859 uint loopback = data.loopback;
1860 uint debug_mode = data.debug_mode;
1861 char *debug_file = data.debug_file;
1862
1863 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1864 int debug_rule_len = 0; // -1 error
1865 uint debug_plain_len = 0;
1866
1867 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1868
1869 // hash
1870
1871 char out_buf[4096] = { 0 };
1872
1873 ascii_digest (out_buf, salt_pos, digest_pos);
1874
1875 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1876
1877 // plain
1878
1879 plain_t plain;
1880
1881 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);
1882
1883 uint gidvid = plain.gidvid;
1884 uint il_pos = plain.il_pos;
1885
1886 u64 crackpos = device_param->words_off;
1887
1888 uint plain_buf[16] = { 0 };
1889
1890 u8 *plain_ptr = (u8 *) plain_buf;
1891 unsigned int plain_len = 0;
1892
1893 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1894 {
1895 u64 gidd = gidvid;
1896 u64 gidm = 0;
1897
1898 pw_t pw;
1899
1900 gidd_to_pw_t (device_param, gidd, &pw);
1901
1902 for (int i = 0, j = gidm; i < 16; i++, j++)
1903 {
1904 plain_buf[i] = pw.h.hi1[0][j];
1905 }
1906
1907 plain_len = pw.pw_len;
1908
1909 const uint off = device_param->innerloop_pos + il_pos;
1910
1911 if (debug_mode > 0)
1912 {
1913 debug_rule_len = 0;
1914
1915 // save rule
1916 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1917 {
1918 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1919
1920 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1921 }
1922
1923 // save plain
1924 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1925 {
1926 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1927
1928 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1929
1930 debug_plain_len = plain_len;
1931 }
1932 }
1933
1934 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1935
1936 crackpos += gidvid;
1937 crackpos *= data.kernel_rules_cnt;
1938 crackpos += device_param->innerloop_pos + il_pos;
1939
1940 if (plain_len > data.pw_max) plain_len = data.pw_max;
1941 }
1942 else if (data.attack_mode == ATTACK_MODE_COMBI)
1943 {
1944 u64 gidd = gidvid;
1945 u64 gidm = 0;
1946
1947 pw_t pw;
1948
1949 gidd_to_pw_t (device_param, gidd, &pw);
1950
1951 for (int i = 0, j = gidm; i < 16; i++, j++)
1952 {
1953 plain_buf[i] = pw.h.hi1[0][j];
1954 }
1955
1956 plain_len = pw.pw_len;
1957
1958 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1959 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1960
1961 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1962 {
1963 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1964 }
1965 else
1966 {
1967 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1968
1969 memcpy (plain_ptr, comb_buf, comb_len);
1970 }
1971
1972 plain_len += comb_len;
1973
1974 crackpos += gidvid;
1975 crackpos *= data.combs_cnt;
1976 crackpos += device_param->innerloop_pos + il_pos;
1977
1978 if (data.pw_max != PW_DICTMAX1)
1979 {
1980 if (plain_len > data.pw_max) plain_len = data.pw_max;
1981 }
1982 }
1983 else if (data.attack_mode == ATTACK_MODE_BF)
1984 {
1985 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1986 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1987
1988 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1989 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1990
1991 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1992 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1993
1994 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1995 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1996
1997 plain_len = data.css_cnt;
1998
1999 crackpos += gidvid;
2000 crackpos *= data.bfs_cnt;
2001 crackpos += device_param->innerloop_pos + il_pos;
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2004 {
2005 u64 gidd = gidvid;
2006 u64 gidm = 0;
2007
2008 pw_t pw;
2009
2010 gidd_to_pw_t (device_param, gidd, &pw);
2011
2012 for (int i = 0, j = gidm; i < 16; i++, j++)
2013 {
2014 plain_buf[i] = pw.h.hi1[0][j];
2015 }
2016
2017 plain_len = pw.pw_len;
2018
2019 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2020
2021 uint start = 0;
2022 uint stop = device_param->kernel_params_mp_buf32[4];
2023
2024 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2025
2026 plain_len += start + stop;
2027
2028 crackpos += gidvid;
2029 crackpos *= data.combs_cnt;
2030 crackpos += device_param->innerloop_pos + il_pos;
2031
2032 if (data.pw_max != PW_DICTMAX1)
2033 {
2034 if (plain_len > data.pw_max) plain_len = data.pw_max;
2035 }
2036 }
2037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2038 {
2039 u64 gidd = gidvid;
2040 u64 gidm = 0;
2041
2042 pw_t pw;
2043
2044 gidd_to_pw_t (device_param, gidd, &pw);
2045
2046 for (int i = 0, j = gidm; i < 16; i++, j++)
2047 {
2048 plain_buf[i] = pw.h.hi1[0][j];
2049 }
2050
2051 plain_len = pw.pw_len;
2052
2053 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2054
2055 uint start = 0;
2056 uint stop = device_param->kernel_params_mp_buf32[4];
2057
2058 memmove (plain_ptr + stop, plain_ptr, plain_len);
2059
2060 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2061
2062 plain_len += start + stop;
2063
2064 crackpos += gidvid;
2065 crackpos *= data.combs_cnt;
2066 crackpos += device_param->innerloop_pos + il_pos;
2067
2068 if (data.pw_max != PW_DICTMAX1)
2069 {
2070 if (plain_len > data.pw_max) plain_len = data.pw_max;
2071 }
2072 }
2073
2074 if (data.attack_mode == ATTACK_MODE_BF)
2075 {
2076 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2077 {
2078 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2079 {
2080 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2081 {
2082 plain_len = plain_len - data.salts_buf[0].salt_len;
2083 }
2084 }
2085
2086 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2087 {
2088 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2089 {
2090 plain_ptr[j] = plain_ptr[i];
2091 }
2092
2093 plain_len = plain_len / 2;
2094 }
2095 }
2096 }
2097
2098 // if enabled, update also the potfile
2099
2100 if (pot_fp)
2101 {
2102 lock_file (pot_fp);
2103
2104 fprintf (pot_fp, "%s:", out_buf);
2105
2106 format_plain (pot_fp, plain_ptr, plain_len, 1);
2107
2108 fputc ('\n', pot_fp);
2109
2110 fflush (pot_fp);
2111
2112 unlock_file (pot_fp);
2113 }
2114
2115 // outfile
2116
2117 FILE *out_fp = NULL;
2118
2119 if (outfile != NULL)
2120 {
2121 if ((out_fp = fopen (outfile, "ab")) == NULL)
2122 {
2123 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2124
2125 out_fp = stdout;
2126 }
2127 lock_file (out_fp);
2128 }
2129 else
2130 {
2131 out_fp = stdout;
2132
2133 if (quiet == 0) clear_prompt ();
2134 }
2135
2136 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2137
2138 if (outfile != NULL)
2139 {
2140 if (out_fp != stdout)
2141 {
2142 fclose (out_fp);
2143 }
2144 }
2145 else
2146 {
2147 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2148 {
2149 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2150 {
2151 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2152 if (quiet == 0) fflush (stdout);
2153 }
2154 }
2155 }
2156
2157 // loopback
2158
2159 if (loopback)
2160 {
2161 char *loopback_file = data.loopback_file;
2162
2163 FILE *fb_fp = NULL;
2164
2165 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2166 {
2167 lock_file (fb_fp);
2168
2169 format_plain (fb_fp, plain_ptr, plain_len, 1);
2170
2171 fputc ('\n', fb_fp);
2172
2173 fclose (fb_fp);
2174 }
2175 }
2176
2177 // (rule) debug mode
2178
2179 // the next check implies that:
2180 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2181 // - debug_mode > 0
2182
2183 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2184 {
2185 if (debug_rule_len < 0) debug_rule_len = 0;
2186
2187 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2188
2189 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2190
2191 if ((quiet == 0) && (debug_file == NULL))
2192 {
2193 fprintf (stdout, "%s", PROMPT);
2194 fflush (stdout);
2195 }
2196 }
2197 }
2198
2199 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2200 {
2201 salt_t *salt_buf = &data.salts_buf[salt_pos];
2202
2203 int found = 0;
2204
2205 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);
2206
2207 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2208
2209 if (found == 1)
2210 {
2211 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2212
2213 log_info_nn ("");
2214
2215 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);
2216
2217 uint cpt_cracked = 0;
2218
2219 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2220 {
2221 uint idx = salt_buf->digests_offset + digest_pos;
2222
2223 if (data.digests_shown_tmp[idx] == 0) continue;
2224
2225 if (data.digests_shown[idx] == 1) continue;
2226
2227 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2228 {
2229 data.digests_shown[idx] = 1;
2230
2231 data.digests_done++;
2232
2233 cpt_cracked++;
2234
2235 salt_buf->digests_done++;
2236
2237 if (salt_buf->digests_done == salt_buf->digests_cnt)
2238 {
2239 data.salts_shown[salt_pos] = 1;
2240
2241 data.salts_done++;
2242 }
2243 }
2244
2245 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2246
2247 check_hash (device_param, salt_pos, digest_pos);
2248 }
2249
2250 if (cpt_cracked > 0)
2251 {
2252 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2253 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2254
2255 data.cpt_pos++;
2256
2257 data.cpt_total += cpt_cracked;
2258
2259 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2260 }
2261
2262 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2263 {
2264 // we need to reset cracked state on the device
2265 // otherwise host thinks again and again the hash was cracked
2266 // and returns invalid password each time
2267
2268 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2269
2270 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);
2271 }
2272
2273 memset (device_param->result, 0, device_param->size_results);
2274
2275 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);
2276 }
2277 }
2278
2279 static void save_hash ()
2280 {
2281 char *hashfile = data.hashfile;
2282
2283 char new_hashfile[256] = { 0 };
2284 char old_hashfile[256] = { 0 };
2285
2286 snprintf (new_hashfile, 255, "%s.new", hashfile);
2287 snprintf (old_hashfile, 255, "%s.old", hashfile);
2288
2289 unlink (new_hashfile);
2290
2291 char separator = data.separator;
2292
2293 FILE *fp = fopen (new_hashfile, "wb");
2294
2295 if (fp == NULL)
2296 {
2297 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2298
2299 exit (-1);
2300 }
2301
2302 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2303 {
2304 if (data.salts_shown[salt_pos] == 1) continue;
2305
2306 salt_t *salt_buf = &data.salts_buf[salt_pos];
2307
2308 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2309 {
2310 uint idx = salt_buf->digests_offset + digest_pos;
2311
2312 if (data.digests_shown[idx] == 1) continue;
2313
2314 if (data.hash_mode != 2500)
2315 {
2316 char out_buf[4096] = { 0 };
2317
2318 if (data.username == 1)
2319 {
2320 user_t *user = data.hash_info[idx]->user;
2321
2322 uint i;
2323
2324 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2325
2326 fputc (separator, fp);
2327 }
2328
2329 ascii_digest (out_buf, salt_pos, digest_pos);
2330
2331 fputs (out_buf, fp);
2332
2333 log_out (fp, "");
2334 }
2335 else
2336 {
2337 hccap_t hccap;
2338
2339 to_hccap_t (&hccap, salt_pos, digest_pos);
2340
2341 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2342 }
2343 }
2344 }
2345
2346 fflush (fp);
2347
2348 fclose (fp);
2349
2350 unlink (old_hashfile);
2351
2352 if (rename (hashfile, old_hashfile) != 0)
2353 {
2354 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2355
2356 exit (-1);
2357 }
2358
2359 unlink (hashfile);
2360
2361 if (rename (new_hashfile, hashfile) != 0)
2362 {
2363 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2364
2365 exit (-1);
2366 }
2367
2368 unlink (old_hashfile);
2369 }
2370
2371 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2372 {
2373 // function called only in case kernel_power_all > words_left
2374
2375 float kernel_power_div = (float) (total_left) / kernel_power_all;
2376
2377 kernel_power_div += kernel_power_div / 100;
2378
2379 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2380
2381 while (kernel_power_new < total_left)
2382 {
2383 kernel_power_div += kernel_power_div / 100;
2384
2385 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2386 }
2387
2388 if (data.quiet == 0)
2389 {
2390 clear_prompt ();
2391
2392 log_info ("");
2393
2394 log_info ("INFO: approaching final keyspace, workload adjusted");
2395
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2450 }
2451 else
2452 {
2453 const size_t global_work_size[3] = { num_elements, 1, 1 };
2454 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2455
2456 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2457
2458 if (rc != CL_SUCCESS)
2459 {
2460 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2461
2462 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2463 }
2464 }
2465
2466 hc_clFlush (data.ocl, device_param->command_queue);
2467
2468 hc_clWaitForEvents (data.ocl, 1, &event);
2469
2470 if (event_update)
2471 {
2472 cl_ulong time_start;
2473 cl_ulong time_end;
2474
2475 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2476 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2477
2478 const double exec_time = (time_end - time_start) / 1000000.0;
2479
2480 uint exec_pos = device_param->exec_pos;
2481
2482 device_param->exec_ms[exec_pos] = exec_time;
2483
2484 exec_pos++;
2485
2486 if (exec_pos == EXEC_CACHE)
2487 {
2488 exec_pos = 0;
2489 }
2490
2491 device_param->exec_pos = exec_pos;
2492 }
2493
2494 hc_clReleaseEvent (data.ocl, event);
2495
2496 hc_clFinish (data.ocl, device_param->command_queue);
2497 }
2498
2499 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2500 {
2501 uint num_elements = num;
2502
2503 switch (kern_run)
2504 {
2505 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2506 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2507 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2508 }
2509
2510 // causes problems with special threads like in bcrypt
2511 // const uint kernel_threads = device_param->kernel_threads;
2512
2513 const uint kernel_threads = KERNEL_THREADS;
2514
2515 while (num_elements % kernel_threads) num_elements++;
2516
2517 cl_kernel kernel = NULL;
2518
2519 switch (kern_run)
2520 {
2521 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2522 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2523 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2524 }
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2529 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2530 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2531 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2532 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2533 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2534 break;
2535 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2536 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2537 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2538 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2539 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2540 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2541 break;
2542 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2543 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2544 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2545 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2546 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2547 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2548 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2549 break;
2550 }
2551
2552 const size_t global_work_size[3] = { num_elements, 1, 1 };
2553 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2554
2555 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2556
2557 if (rc != CL_SUCCESS)
2558 {
2559 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2560
2561 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2562 }
2563
2564 hc_clFlush (data.ocl, device_param->command_queue);
2565
2566 hc_clFinish (data.ocl, device_param->command_queue);
2567 }
2568
2569 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2570 {
2571 uint num_elements = num;
2572
2573 uint kernel_threads = device_param->kernel_threads;
2574
2575 while (num_elements % kernel_threads) num_elements++;
2576
2577 cl_kernel kernel = device_param->kernel_tb;
2578
2579 const size_t global_work_size[3] = { num_elements, 1, 1 };
2580 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2581
2582 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2583
2584 if (rc != CL_SUCCESS)
2585 {
2586 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2587
2588 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2589 }
2590
2591 hc_clFlush (data.ocl, device_param->command_queue);
2592
2593 hc_clFinish (data.ocl, device_param->command_queue);
2594 }
2595
2596 static void run_kernel_tm (hc_device_param_t *device_param)
2597 {
2598 const uint num_elements = 1024; // fixed
2599
2600 const uint kernel_threads = 32;
2601
2602 cl_kernel kernel = device_param->kernel_tm;
2603
2604 const size_t global_work_size[3] = { num_elements, 1, 1 };
2605 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2606
2607 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2608
2609 if (rc != CL_SUCCESS)
2610 {
2611 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2612
2613 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2614 }
2615
2616 hc_clFlush (data.ocl, device_param->command_queue);
2617
2618 hc_clFinish (data.ocl, device_param->command_queue);
2619 }
2620
2621 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2622 {
2623 uint num_elements = num;
2624
2625 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2626 device_param->kernel_params_amp_buf32[6] = num_elements;
2627
2628 // causes problems with special threads like in bcrypt
2629 // const uint kernel_threads = device_param->kernel_threads;
2630
2631 const uint kernel_threads = KERNEL_THREADS;
2632
2633 while (num_elements % kernel_threads) num_elements++;
2634
2635 cl_kernel kernel = device_param->kernel_amp;
2636
2637 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2638 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2639
2640 const size_t global_work_size[3] = { num_elements, 1, 1 };
2641 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2642
2643 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, false);
2644
2645 if (rc != CL_SUCCESS)
2646 {
2647 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2648
2649 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2650 }
2651
2652 hc_clFlush (data.ocl, device_param->command_queue);
2653
2654 hc_clFinish (data.ocl, device_param->command_queue);
2655 }
2656
2657 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2658 {
2659 int rc = -1;
2660
2661 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2662 {
2663 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2664
2665 const cl_uchar zero = 0;
2666
2667 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2668 }
2669
2670 if (rc != 0)
2671 {
2672 // NOTE: clEnqueueFillBuffer () always fails with -59
2673 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2674 // How's that possible, OpenCL 1.2 support is advertised??
2675 // We need to workaround...
2676
2677 #define FILLSZ 0x100000
2678
2679 char *tmp = (char *) mymalloc (FILLSZ);
2680
2681 for (uint i = 0; i < size; i += FILLSZ)
2682 {
2683 const int left = size - i;
2684
2685 const int fillsz = MIN (FILLSZ, left);
2686
2687 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2688 }
2689
2690 myfree (tmp);
2691 }
2692 }
2693
2694 static int run_rule_engine (const int rule_len, const char *rule_buf)
2695 {
2696 if (rule_len == 0)
2697 {
2698 return 0;
2699 }
2700 else if (rule_len == 1)
2701 {
2702 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2703 }
2704
2705 return 1;
2706 }
2707
2708 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2709 {
2710 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2711 {
2712 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);
2713 }
2714 else if (data.attack_kern == ATTACK_KERN_COMBI)
2715 {
2716 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);
2717 }
2718 else if (data.attack_kern == ATTACK_KERN_BF)
2719 {
2720 const u64 off = device_param->words_off;
2721
2722 device_param->kernel_params_mp_l_buf64[3] = off;
2723
2724 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2725 }
2726 }
2727
2728 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops, const int repeat)
2729 {
2730 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2731
2732 device_param->kernel_params_buf32[26] = kernel_loops;
2733 device_param->kernel_params_buf32[27] = kernel_loops;
2734
2735 // caching run
2736
2737 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2738 {
2739 run_kernel (KERN_RUN_1, device_param, kernel_power, false);
2740 }
2741 else
2742 {
2743 run_kernel (KERN_RUN_2, device_param, kernel_power, false);
2744 }
2745
2746 // now user repeats
2747
2748 for (int i = 0; i < repeat; i++)
2749 {
2750 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2751 {
2752 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2753 }
2754 else
2755 {
2756 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2757 }
2758 }
2759
2760 const double exec_ms_prev = get_avg_exec_time (device_param, repeat);
2761
2762 return exec_ms_prev;
2763 }
2764
2765 static void autotune (hc_device_param_t *device_param)
2766 {
2767 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2768
2769 u32 kernel_loops_min = device_param->kernel_loops_min;
2770 u32 kernel_loops_max = device_param->kernel_loops_max;
2771
2772 u32 kernel_accel_min = device_param->kernel_accel_min;
2773 u32 kernel_accel_max = device_param->kernel_accel_max;
2774
2775 u32 kernel_loops = kernel_loops_min;
2776 u32 kernel_accel = kernel_accel_min;
2777
2778 // init some fake words
2779
2780 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
2781
2782 for (u32 i = 0; i < kernel_power_max; i++)
2783 {
2784 device_param->pws_buf[i].pw_len = 8;
2785 }
2786
2787 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);
2788 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);
2789
2790 // good increase steps
2791
2792 u32 steps[32];
2793
2794 steps[ 0] = 1;
2795 steps[ 1] = 2;
2796 steps[ 2] = 3;
2797 steps[ 3] = 4;
2798 steps[ 4] = 8;
2799 steps[ 5] = 12;
2800 steps[ 6] = 16;
2801 steps[ 7] = 24;
2802 steps[ 8] = 28;
2803 steps[ 9] = 32;
2804 steps[10] = 40;
2805 steps[11] = 48;
2806 steps[12] = 56;
2807 steps[13] = 64;
2808 steps[14] = 80;
2809 steps[15] = 96;
2810 steps[16] = 100;
2811 steps[17] = 112;
2812 steps[18] = 128;
2813 steps[19] = 160;
2814 steps[20] = 200;
2815 steps[21] = 250;
2816 steps[22] = 256;
2817 steps[23] = 384;
2818 steps[24] = 400;
2819 steps[25] = 500;
2820 steps[26] = 512;
2821 steps[27] = 640;
2822 steps[28] = 768;
2823 steps[29] = 800;
2824 steps[30] = 1000;
2825 steps[31] = 1024;
2826
2827 // find out highest kernel-loops that stays below target_ms, we can use it later for multiplication as this is a linear function
2828
2829 u32 kernel_loops_tmp;
2830
2831 for (kernel_loops_tmp = kernel_loops_max; kernel_loops_tmp >= kernel_loops_min; kernel_loops_tmp >>= 1)
2832 {
2833 const double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops_tmp, 1);
2834
2835 if (exec_ms < target_ms) break;
2836
2837 if (kernel_loops_tmp == kernel_loops_min) break;
2838 }
2839
2840 // kernel-accel
2841
2842 double e_best = 0;
2843
2844 for (int i = 0; i < 32; i++)
2845 {
2846 const u32 kernel_accel_try = steps[i];
2847
2848 if (kernel_accel_try < kernel_accel_min) continue;
2849 if (kernel_accel_try > kernel_accel_max) break;
2850
2851 const double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_tmp, 1);
2852
2853 if (exec_ms > target_ms) break;
2854
2855 const double e = kernel_accel_try / exec_ms;
2856
2857 if (e > e_best)
2858 {
2859 kernel_accel = kernel_accel_try;
2860
2861 e_best = e;
2862 }
2863 }
2864
2865 // kernel-loops final
2866
2867 e_best = 0;
2868
2869 for (int i = 0; i < 32; i++)
2870 {
2871 const u32 kernel_loops_try = steps[i];
2872
2873 if (kernel_loops_try < kernel_loops_min) continue;
2874 if (kernel_loops_try > kernel_loops_max) break;
2875
2876 const double exec_ms = try_run (device_param, kernel_accel, kernel_loops_try, 1);
2877
2878 if (exec_ms > target_ms) break;
2879
2880 const double e = kernel_loops_try / exec_ms;
2881
2882 if (e > e_best)
2883 {
2884 kernel_loops = kernel_loops_try;
2885
2886 e_best = e;
2887 }
2888 }
2889
2890 // reset timer
2891
2892 device_param->exec_pos = 0;
2893
2894 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2895
2896 // reset fake words
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].pw_len = 0;
2901 }
2902
2903 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);
2904 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);
2905
2906 // store
2907
2908 device_param->kernel_loops = kernel_loops;
2909 device_param->kernel_accel = kernel_accel;
2910
2911 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2912
2913 device_param->kernel_power = kernel_power;
2914
2915 log_info ("Device #%u: autotuned kernel-accel to %u", device_param->device_id + 1, kernel_accel);
2916 log_info ("Device #%u: autotuned kernel-loops to %u", device_param->device_id + 1, kernel_loops);
2917 log_info ("");
2918 }
2919
2920 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2921 {
2922 // init speed timer
2923
2924 uint speed_pos = device_param->speed_pos;
2925
2926 #ifdef _POSIX
2927 if (device_param->timer_speed.tv_sec == 0)
2928 {
2929 hc_timer_set (&device_param->timer_speed);
2930 }
2931 #endif
2932
2933 #ifdef _WIN
2934 if (device_param->timer_speed.QuadPart == 0)
2935 {
2936 hc_timer_set (&device_param->timer_speed);
2937 }
2938 #endif
2939
2940 // find higest password length, this is for optimization stuff
2941
2942 uint highest_pw_len = 0;
2943
2944 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2945 {
2946 }
2947 else if (data.attack_kern == ATTACK_KERN_COMBI)
2948 {
2949 }
2950 else if (data.attack_kern == ATTACK_KERN_BF)
2951 {
2952 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2953 + device_param->kernel_params_mp_l_buf32[5];
2954 }
2955
2956 // bitslice optimization stuff
2957
2958 if (data.attack_mode == ATTACK_MODE_BF)
2959 {
2960 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2961 {
2962 run_kernel_tb (device_param, pws_cnt);
2963 }
2964 }
2965
2966 // iteration type
2967
2968 uint innerloop_step = 0;
2969 uint innerloop_cnt = 0;
2970
2971 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
2972 else innerloop_step = 1;
2973
2974 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2975 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2976 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2977
2978 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2979
2980 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2981 {
2982 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2983
2984 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2985
2986 if (data.devices_status == STATUS_CRACKED) break;
2987 if (data.devices_status == STATUS_ABORTED) break;
2988 if (data.devices_status == STATUS_QUIT) break;
2989 if (data.devices_status == STATUS_BYPASS) break;
2990
2991 if (data.salts_shown[salt_pos] == 1) continue;
2992
2993 salt_t *salt_buf = &data.salts_buf[salt_pos];
2994
2995 device_param->kernel_params_buf32[24] = salt_pos;
2996 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2997 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2998
2999 FILE *combs_fp = device_param->combs_fp;
3000
3001 if (data.attack_mode == ATTACK_MODE_COMBI)
3002 {
3003 rewind (combs_fp);
3004 }
3005
3006 // innerloops
3007
3008 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3009 {
3010 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3011
3012 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3013
3014 if (data.devices_status == STATUS_CRACKED) break;
3015 if (data.devices_status == STATUS_ABORTED) break;
3016 if (data.devices_status == STATUS_QUIT) break;
3017 if (data.devices_status == STATUS_BYPASS) break;
3018
3019 uint innerloop_left = innerloop_cnt - innerloop_pos;
3020
3021 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3022
3023 device_param->innerloop_pos = innerloop_pos;
3024 device_param->innerloop_left = innerloop_left;
3025
3026 device_param->kernel_params_buf32[27] = innerloop_left;
3027
3028 // i think we can get rid of this
3029 if (innerloop_left == 0)
3030 {
3031 puts ("bug, how should this happen????\n");
3032
3033 continue;
3034 }
3035
3036 // initialize amplifiers
3037
3038 if (data.attack_mode == ATTACK_MODE_COMBI)
3039 {
3040 char line_buf[BUFSIZ] = { 0 };
3041
3042 uint i = 0;
3043
3044 while (i < innerloop_left)
3045 {
3046 if (feof (combs_fp)) break;
3047
3048 int line_len = fgetl (combs_fp, line_buf);
3049
3050 if (line_len >= PW_MAX1) continue;
3051
3052 line_len = convert_from_hex (line_buf, line_len);
3053
3054 char *line_buf_new = line_buf;
3055
3056 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3057 {
3058 char rule_buf_out[BLOCK_SIZE] = { 0 };
3059
3060 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3061
3062 if (rule_len_out < 0)
3063 {
3064 data.words_progress_rejected[salt_pos] += pw_cnt;
3065
3066 continue;
3067 }
3068
3069 line_len = rule_len_out;
3070
3071 line_buf_new = rule_buf_out;
3072 }
3073
3074 line_len = MIN (line_len, PW_DICTMAX);
3075
3076 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3077
3078 memcpy (ptr, line_buf_new, line_len);
3079
3080 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3081
3082 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3083 {
3084 uppercase (ptr, line_len);
3085 }
3086
3087 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3088 {
3089 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3090 {
3091 ptr[line_len] = 0x80;
3092 }
3093
3094 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3095 {
3096 ptr[line_len] = 0x01;
3097 }
3098 }
3099
3100 device_param->combs_buf[i].pw_len = line_len;
3101
3102 i++;
3103 }
3104
3105 for (uint j = i; j < innerloop_left; j++)
3106 {
3107 device_param->combs_buf[j].i[0] = 0;
3108 device_param->combs_buf[j].i[1] = 0;
3109 device_param->combs_buf[j].i[2] = 0;
3110 device_param->combs_buf[j].i[3] = 0;
3111 device_param->combs_buf[j].i[4] = 0;
3112 device_param->combs_buf[j].i[5] = 0;
3113 device_param->combs_buf[j].i[6] = 0;
3114 device_param->combs_buf[j].i[7] = 0;
3115
3116 device_param->combs_buf[j].pw_len = 0;
3117 }
3118
3119 innerloop_left = i;
3120 }
3121 else if (data.attack_mode == ATTACK_MODE_BF)
3122 {
3123 u64 off = innerloop_pos;
3124
3125 device_param->kernel_params_mp_r_buf64[3] = off;
3126
3127 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3128 }
3129 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3130 {
3131 u64 off = innerloop_pos;
3132
3133 device_param->kernel_params_mp_buf64[3] = off;
3134
3135 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3136 }
3137 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3138 {
3139 u64 off = innerloop_pos;
3140
3141 device_param->kernel_params_mp_buf64[3] = off;
3142
3143 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3144 }
3145
3146 // copy amplifiers
3147
3148 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3149 {
3150 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);
3151 }
3152 else if (data.attack_mode == ATTACK_MODE_COMBI)
3153 {
3154 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);
3155 }
3156 else if (data.attack_mode == ATTACK_MODE_BF)
3157 {
3158 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);
3159 }
3160 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3161 {
3162 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);
3163 }
3164 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3165 {
3166 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);
3167 }
3168
3169 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3170 {
3171 if (data.attack_mode == ATTACK_MODE_BF)
3172 {
3173 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3174 {
3175 const uint size_tm = 32 * sizeof (bs_word_t);
3176
3177 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3178
3179 run_kernel_tm (device_param);
3180
3181 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);
3182 }
3183 }
3184
3185 if (highest_pw_len < 16)
3186 {
3187 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3188 }
3189 else if (highest_pw_len < 32)
3190 {
3191 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3192 }
3193 else
3194 {
3195 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3196 }
3197 }
3198 else
3199 {
3200 run_kernel_amp (device_param, pws_cnt);
3201
3202 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3203
3204 if (data.opts_type & OPTS_TYPE_HOOK12)
3205 {
3206 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3207 }
3208
3209 uint iter = salt_buf->salt_iter;
3210
3211 uint loop_step = device_param->kernel_loops;
3212
3213 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
3214 {
3215 uint loop_left = iter - loop_pos;
3216
3217 loop_left = MIN (loop_left, loop_step);
3218
3219 device_param->kernel_params_buf32[25] = loop_pos;
3220 device_param->kernel_params_buf32[26] = loop_left;
3221
3222 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3223
3224 if (data.devices_status == STATUS_CRACKED) break;
3225 if (data.devices_status == STATUS_ABORTED) break;
3226 if (data.devices_status == STATUS_QUIT) break;
3227 }
3228
3229 if (data.opts_type & OPTS_TYPE_HOOK23)
3230 {
3231 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3232
3233 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);
3234
3235 // do something with data
3236
3237 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);
3238 }
3239
3240 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3241 }
3242
3243 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3244
3245 if (data.devices_status == STATUS_CRACKED) break;
3246 if (data.devices_status == STATUS_ABORTED) break;
3247 if (data.devices_status == STATUS_QUIT) break;
3248
3249 /**
3250 * result
3251 */
3252
3253 hc_thread_mutex_lock (mux_display);
3254
3255 check_cracked (device_param, salt_pos);
3256
3257 hc_thread_mutex_unlock (mux_display);
3258
3259 /**
3260 * progress
3261 */
3262
3263 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3264
3265 hc_thread_mutex_lock (mux_counter);
3266
3267 data.words_progress_done[salt_pos] += perf_sum_all;
3268
3269 hc_thread_mutex_unlock (mux_counter);
3270
3271 /**
3272 * speed
3273 */
3274
3275 float speed_ms;
3276
3277 hc_timer_get (device_param->timer_speed, speed_ms);
3278
3279 hc_timer_set (&device_param->timer_speed);
3280
3281 hc_thread_mutex_lock (mux_display);
3282
3283 device_param->speed_cnt[speed_pos] = perf_sum_all;
3284
3285 device_param->speed_ms[speed_pos] = speed_ms;
3286
3287 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3288
3289 hc_thread_mutex_unlock (mux_display);
3290
3291 speed_pos++;
3292
3293 if (speed_pos == SPEED_CACHE)
3294 {
3295 speed_pos = 0;
3296 }
3297 }
3298 }
3299
3300 device_param->speed_pos = speed_pos;
3301 }
3302
3303 static void load_segment (wl_data_t *wl_data, FILE *fd)
3304 {
3305 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3306
3307 wl_data->pos = 0;
3308
3309 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3310
3311 wl_data->buf[wl_data->cnt] = 0;
3312
3313 if (wl_data->cnt == 0) return;
3314
3315 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3316
3317 while (!feof (fd))
3318 {
3319 if (wl_data->cnt == wl_data->avail)
3320 {
3321 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3322
3323 wl_data->avail += wl_data->incr;
3324 }
3325
3326 const int c = fgetc (fd);
3327
3328 if (c == EOF) break;
3329
3330 wl_data->buf[wl_data->cnt] = (char) c;
3331
3332 wl_data->cnt++;
3333
3334 if (c == '\n') break;
3335 }
3336
3337 // ensure stream ends with a newline
3338
3339 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3340 {
3341 wl_data->cnt++;
3342
3343 wl_data->buf[wl_data->cnt - 1] = '\n';
3344 }
3345
3346 return;
3347 }
3348
3349 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3350 {
3351 char *ptr = buf;
3352
3353 for (u32 i = 0; i < sz; i++, ptr++)
3354 {
3355 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3356
3357 if (i == 7)
3358 {
3359 *off = i;
3360 *len = i;
3361
3362 return;
3363 }
3364
3365 if (*ptr != '\n') continue;
3366
3367 *off = i + 1;
3368
3369 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3370
3371 *len = i;
3372
3373 return;
3374 }
3375
3376 *off = sz;
3377 *len = sz;
3378 }
3379
3380 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3381 {
3382 char *ptr = buf;
3383
3384 for (u32 i = 0; i < sz; i++, ptr++)
3385 {
3386 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3387
3388 if (*ptr != '\n') continue;
3389
3390 *off = i + 1;
3391
3392 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3393
3394 *len = i;
3395
3396 return;
3397 }
3398
3399 *off = sz;
3400 *len = sz;
3401 }
3402
3403 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3404 {
3405 char *ptr = buf;
3406
3407 for (u32 i = 0; i < sz; i++, ptr++)
3408 {
3409 if (*ptr != '\n') continue;
3410
3411 *off = i + 1;
3412
3413 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3414
3415 *len = i;
3416
3417 return;
3418 }
3419
3420 *off = sz;
3421 *len = sz;
3422 }
3423
3424 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3425 {
3426 while (wl_data->pos < wl_data->cnt)
3427 {
3428 uint off;
3429 uint len;
3430
3431 char *ptr = wl_data->buf + wl_data->pos;
3432
3433 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3434
3435 wl_data->pos += off;
3436
3437 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3438 {
3439 char rule_buf_out[BLOCK_SIZE] = { 0 };
3440
3441 int rule_len_out = -1;
3442
3443 if (len < BLOCK_SIZE)
3444 {
3445 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3446 }
3447
3448 if (rule_len_out < 0)
3449 {
3450 continue;
3451 }
3452
3453 if (rule_len_out > PW_MAX)
3454 {
3455 continue;
3456 }
3457 }
3458 else
3459 {
3460 if (len > PW_MAX)
3461 {
3462 continue;
3463 }
3464 }
3465
3466 *out_buf = ptr;
3467 *out_len = len;
3468
3469 return;
3470 }
3471
3472 if (feof (fd))
3473 {
3474 fprintf (stderr, "bug!!\n");
3475
3476 return;
3477 }
3478
3479 load_segment (wl_data, fd);
3480
3481 get_next_word (wl_data, fd, out_buf, out_len);
3482 }
3483
3484 #ifdef _POSIX
3485 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3486 #endif
3487
3488 #ifdef _WIN
3489 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3490 #endif
3491 {
3492 hc_signal (NULL);
3493
3494 dictstat_t d;
3495
3496 d.cnt = 0;
3497
3498 #ifdef _POSIX
3499 fstat (fileno (fd), &d.stat);
3500 #endif
3501
3502 #ifdef _WIN
3503 _fstat64 (fileno (fd), &d.stat);
3504 #endif
3505
3506 d.stat.st_mode = 0;
3507 d.stat.st_nlink = 0;
3508 d.stat.st_uid = 0;
3509 d.stat.st_gid = 0;
3510 d.stat.st_rdev = 0;
3511 d.stat.st_atime = 0;
3512
3513 #ifdef _POSIX
3514 d.stat.st_blksize = 0;
3515 d.stat.st_blocks = 0;
3516 #endif
3517
3518 if (d.stat.st_size == 0) return 0;
3519
3520 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3521
3522 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3523 {
3524 if (d_cache)
3525 {
3526 u64 cnt = d_cache->cnt;
3527
3528 u64 keyspace = cnt;
3529
3530 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3531 {
3532 keyspace *= data.kernel_rules_cnt;
3533 }
3534 else if (data.attack_kern == ATTACK_KERN_COMBI)
3535 {
3536 keyspace *= data.combs_cnt;
3537 }
3538
3539 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);
3540 if (data.quiet == 0) log_info ("");
3541
3542 hc_signal (sigHandler_default);
3543
3544 return (keyspace);
3545 }
3546 }
3547
3548 time_t now = 0;
3549 time_t prev = 0;
3550
3551 u64 comp = 0;
3552 u64 cnt = 0;
3553 u64 cnt2 = 0;
3554
3555 while (!feof (fd))
3556 {
3557 load_segment (wl_data, fd);
3558
3559 comp += wl_data->cnt;
3560
3561 u32 i = 0;
3562
3563 while (i < wl_data->cnt)
3564 {
3565 u32 len;
3566 u32 off;
3567
3568 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3569
3570 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3571 {
3572 char rule_buf_out[BLOCK_SIZE] = { 0 };
3573
3574 int rule_len_out = -1;
3575
3576 if (len < BLOCK_SIZE)
3577 {
3578 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3579 }
3580
3581 if (rule_len_out < 0)
3582 {
3583 len = PW_MAX1;
3584 }
3585 else
3586 {
3587 len = rule_len_out;
3588 }
3589 }
3590
3591 if (len < PW_MAX1)
3592 {
3593 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3594 {
3595 cnt += data.kernel_rules_cnt;
3596 }
3597 else if (data.attack_kern == ATTACK_KERN_COMBI)
3598 {
3599 cnt += data.combs_cnt;
3600 }
3601
3602 d.cnt++;
3603 }
3604
3605 i += off;
3606
3607 cnt2++;
3608 }
3609
3610 time (&now);
3611
3612 if ((now - prev) == 0) continue;
3613
3614 float percent = (float) comp / (float) d.stat.st_size;
3615
3616 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);
3617
3618 time (&prev);
3619 }
3620
3621 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);
3622 if (data.quiet == 0) log_info ("");
3623
3624 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3625
3626 hc_signal (sigHandler_default);
3627
3628 return (cnt);
3629 }
3630
3631 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3632 {
3633 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3634 }
3635
3636 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3637 {
3638 if (data.devices_status == STATUS_BYPASS) return 0;
3639
3640 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3641
3642 uint cache_cnt = pw_cache->cnt;
3643
3644 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3645
3646 memcpy (pw_hc1, pw_buf, pw_len);
3647
3648 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3649
3650 uint pws_cnt = device_param->pws_cnt;
3651
3652 cache_cnt++;
3653
3654 pw_t *pw = device_param->pws_buf + pws_cnt;
3655
3656 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3657
3658 pw->pw_len = pw_len;
3659
3660 pws_cnt++;
3661
3662 device_param->pws_cnt = pws_cnt;
3663 device_param->pw_cnt = pws_cnt * 1;
3664
3665 cache_cnt = 0;
3666
3667 pw_cache->cnt = cache_cnt;
3668
3669 return pws_cnt;
3670 }
3671
3672 static void *thread_monitor (void *p)
3673 {
3674 uint runtime_check = 0;
3675 uint remove_check = 0;
3676 uint status_check = 0;
3677 uint restore_check = 0;
3678
3679 uint restore_left = data.restore_timer;
3680 uint remove_left = data.remove_timer;
3681 uint status_left = data.status_timer;
3682
3683 #ifdef HAVE_HWMON
3684 uint hwmon_check = 0;
3685
3686 // these variables are mainly used for fan control (AMD only)
3687
3688 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3689
3690 // temperature controller "loopback" values
3691
3692 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3693 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3694
3695 #ifdef HAVE_ADL
3696 int temp_threshold = 1; // degrees celcius
3697
3698 int fan_speed_min = 15; // in percentage
3699 int fan_speed_max = 100;
3700 #endif // HAVE_ADL
3701
3702 time_t last_temp_check_time;
3703 #endif // HAVE_HWMON
3704
3705 uint sleep_time = 1;
3706
3707 if (data.runtime)
3708 {
3709 runtime_check = 1;
3710 }
3711
3712 if (data.restore_timer)
3713 {
3714 restore_check = 1;
3715 }
3716
3717 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3718 {
3719 remove_check = 1;
3720 }
3721
3722 if (data.status == 1)
3723 {
3724 status_check = 1;
3725 }
3726
3727 #ifdef HAVE_HWMON
3728 if (data.gpu_temp_disable == 0)
3729 {
3730 time (&last_temp_check_time);
3731
3732 hwmon_check = 1;
3733 }
3734 #endif
3735
3736 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3737 {
3738 #ifdef HAVE_HWMON
3739 if (hwmon_check == 0)
3740 #endif
3741 return (p);
3742 }
3743
3744 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3745 {
3746 hc_sleep (sleep_time);
3747
3748 if (data.devices_status != STATUS_RUNNING) continue;
3749
3750 #ifdef HAVE_HWMON
3751 if (hwmon_check == 1)
3752 {
3753 hc_thread_mutex_lock (mux_adl);
3754
3755 time_t temp_check_time;
3756
3757 time (&temp_check_time);
3758
3759 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3760
3761 if (Ta == 0) Ta = 1;
3762
3763 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3764 {
3765 hc_device_param_t *device_param = &data.devices_param[device_id];
3766
3767 if (device_param->skipped) continue;
3768
3769 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3770
3771 const int temperature = hm_get_temperature_with_device_id (device_id);
3772
3773 if (temperature > (int) data.gpu_temp_abort)
3774 {
3775 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3776
3777 if (data.devices_status != STATUS_QUIT) myabort ();
3778
3779 break;
3780 }
3781
3782 #ifdef HAVE_ADL
3783 const int gpu_temp_retain = data.gpu_temp_retain;
3784
3785 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3786 {
3787 if (data.hm_device[device_id].fan_supported == 1)
3788 {
3789 int temp_cur = temperature;
3790
3791 int temp_diff_new = gpu_temp_retain - temp_cur;
3792
3793 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3794
3795 // calculate Ta value (time difference in seconds between the last check and this check)
3796
3797 last_temp_check_time = temp_check_time;
3798
3799 float Kp = 1.8;
3800 float Ki = 0.005;
3801 float Kd = 6;
3802
3803 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3804
3805 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);
3806
3807 if (abs (fan_diff_required) >= temp_threshold)
3808 {
3809 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3810
3811 int fan_speed_level = fan_speed_cur;
3812
3813 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3814
3815 int fan_speed_new = fan_speed_level - fan_diff_required;
3816
3817 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3818 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3819
3820 if (fan_speed_new != fan_speed_cur)
3821 {
3822 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3823 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3824
3825 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3826 {
3827 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3828
3829 fan_speed_chgd[device_id] = 1;
3830 }
3831
3832 temp_diff_old[device_id] = temp_diff_new;
3833 }
3834 }
3835 }
3836 }
3837 #endif // HAVE_ADL
3838 }
3839
3840 hc_thread_mutex_unlock (mux_adl);
3841 }
3842 #endif // HAVE_HWMON
3843
3844 if (restore_check == 1)
3845 {
3846 restore_left--;
3847
3848 if (restore_left == 0)
3849 {
3850 if (data.restore_disable == 0) cycle_restore ();
3851
3852 restore_left = data.restore_timer;
3853 }
3854 }
3855
3856 if ((runtime_check == 1) && (data.runtime_start > 0))
3857 {
3858 time_t runtime_cur;
3859
3860 time (&runtime_cur);
3861
3862 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3863
3864 if (runtime_left <= 0)
3865 {
3866 if (data.benchmark == 0)
3867 {
3868 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3869 }
3870
3871 if (data.devices_status != STATUS_QUIT) myabort ();
3872 }
3873 }
3874
3875 if (remove_check == 1)
3876 {
3877 remove_left--;
3878
3879 if (remove_left == 0)
3880 {
3881 if (data.digests_saved != data.digests_done)
3882 {
3883 data.digests_saved = data.digests_done;
3884
3885 save_hash ();
3886 }
3887
3888 remove_left = data.remove_timer;
3889 }
3890 }
3891
3892 if (status_check == 1)
3893 {
3894 status_left--;
3895
3896 if (status_left == 0)
3897 {
3898 hc_thread_mutex_lock (mux_display);
3899
3900 if (data.quiet == 0) clear_prompt ();
3901
3902 if (data.quiet == 0) log_info ("");
3903
3904 status_display ();
3905
3906 if (data.quiet == 0) log_info ("");
3907
3908 hc_thread_mutex_unlock (mux_display);
3909
3910 status_left = data.status_timer;
3911 }
3912 }
3913 }
3914
3915 #ifdef HAVE_HWMON
3916 myfree (fan_speed_chgd);
3917
3918 myfree (temp_diff_old);
3919 myfree (temp_diff_sum);
3920 #endif
3921
3922 p = NULL;
3923
3924 return (p);
3925 }
3926
3927 static void *thread_outfile_remove (void *p)
3928 {
3929 // some hash-dependent constants
3930 char *outfile_dir = data.outfile_check_directory;
3931 uint dgst_size = data.dgst_size;
3932 uint isSalted = data.isSalted;
3933 uint esalt_size = data.esalt_size;
3934 uint hash_mode = data.hash_mode;
3935
3936 uint outfile_check_timer = data.outfile_check_timer;
3937
3938 char separator = data.separator;
3939
3940 // some hash-dependent functions
3941 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3942 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3943
3944 // buffers
3945 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3946
3947 hash_buf.digest = mymalloc (dgst_size);
3948
3949 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3950
3951 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3952
3953 uint digest_buf[64] = { 0 };
3954
3955 outfile_data_t *out_info = NULL;
3956
3957 char **out_files = NULL;
3958
3959 time_t folder_mtime = 0;
3960
3961 int out_cnt = 0;
3962
3963 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3964
3965 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3966 {
3967 hc_sleep (1);
3968
3969 if (data.devices_status != STATUS_RUNNING) continue;
3970
3971 check_left--;
3972
3973 if (check_left == 0)
3974 {
3975 struct stat outfile_check_stat;
3976
3977 if (stat (outfile_dir, &outfile_check_stat) == 0)
3978 {
3979 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3980
3981 if (is_dir == 1)
3982 {
3983 if (outfile_check_stat.st_mtime > folder_mtime)
3984 {
3985 char **out_files_new = scan_directory (outfile_dir);
3986
3987 int out_cnt_new = count_dictionaries (out_files_new);
3988
3989 outfile_data_t *out_info_new = NULL;
3990
3991 if (out_cnt_new > 0)
3992 {
3993 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3994
3995 for (int i = 0; i < out_cnt_new; i++)
3996 {
3997 out_info_new[i].file_name = out_files_new[i];
3998
3999 // check if there are files that we have seen/checked before (and not changed)
4000
4001 for (int j = 0; j < out_cnt; j++)
4002 {
4003 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4004 {
4005 struct stat outfile_stat;
4006
4007 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4008 {
4009 if (outfile_stat.st_ctime == out_info[j].ctime)
4010 {
4011 out_info_new[i].ctime = out_info[j].ctime;
4012 out_info_new[i].seek = out_info[j].seek;
4013 }
4014 }
4015 }
4016 }
4017 }
4018 }
4019
4020 local_free (out_info);
4021 local_free (out_files);
4022
4023 out_files = out_files_new;
4024 out_cnt = out_cnt_new;
4025 out_info = out_info_new;
4026
4027 folder_mtime = outfile_check_stat.st_mtime;
4028 }
4029
4030 for (int j = 0; j < out_cnt; j++)
4031 {
4032 FILE *fp = fopen (out_info[j].file_name, "rb");
4033
4034 if (fp != NULL)
4035 {
4036 //hc_thread_mutex_lock (mux_display);
4037
4038 #ifdef _POSIX
4039 struct stat outfile_stat;
4040
4041 fstat (fileno (fp), &outfile_stat);
4042 #endif
4043
4044 #ifdef _WIN
4045 struct stat64 outfile_stat;
4046
4047 _fstat64 (fileno (fp), &outfile_stat);
4048 #endif
4049
4050 if (outfile_stat.st_ctime > out_info[j].ctime)
4051 {
4052 out_info[j].ctime = outfile_stat.st_ctime;
4053 out_info[j].seek = 0;
4054 }
4055
4056 fseek (fp, out_info[j].seek, SEEK_SET);
4057
4058 while (!feof (fp))
4059 {
4060 char line_buf[BUFSIZ] = { 0 };
4061
4062 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
4063
4064 if (ptr == NULL) break;
4065
4066 int line_len = strlen (line_buf);
4067
4068 if (line_len <= 0) continue;
4069
4070 int iter = MAX_CUT_TRIES;
4071
4072 for (uint i = line_len - 1; i && iter; i--, line_len--)
4073 {
4074 if (line_buf[i] != separator) continue;
4075
4076 int parser_status = PARSER_OK;
4077
4078 if ((hash_mode != 2500) && (hash_mode != 6800))
4079 {
4080 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4081 }
4082
4083 uint found = 0;
4084
4085 if (parser_status == PARSER_OK)
4086 {
4087 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4088 {
4089 if (data.salts_shown[salt_pos] == 1) continue;
4090
4091 salt_t *salt_buf = &data.salts_buf[salt_pos];
4092
4093 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4094 {
4095 uint idx = salt_buf->digests_offset + digest_pos;
4096
4097 if (data.digests_shown[idx] == 1) continue;
4098
4099 uint cracked = 0;
4100
4101 if (hash_mode == 6800)
4102 {
4103 if (i == salt_buf->salt_len)
4104 {
4105 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4106 }
4107 }
4108 else if (hash_mode == 2500)
4109 {
4110 // BSSID : MAC1 : MAC2 (:plain)
4111 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4112 {
4113 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4114
4115 if (!cracked) continue;
4116
4117 // now compare MAC1 and MAC2 too, since we have this additional info
4118 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4119 char *mac2_pos = mac1_pos + 12 + 1;
4120
4121 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4122 wpa_t *wpa = &wpas[salt_pos];
4123
4124 uint pke[25] = { 0 };
4125
4126 char *pke_ptr = (char *) pke;
4127
4128 for (uint i = 0; i < 25; i++)
4129 {
4130 pke[i] = byte_swap_32 (wpa->pke[i]);
4131 }
4132
4133 u8 mac1[6] = { 0 };
4134 u8 mac2[6] = { 0 };
4135
4136 memcpy (mac1, pke_ptr + 23, 6);
4137 memcpy (mac2, pke_ptr + 29, 6);
4138
4139 // compare hex string(s) vs binary MAC address(es)
4140
4141 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4142 {
4143 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4144 {
4145 cracked = 0;
4146 break;
4147 }
4148 }
4149
4150 // early skip ;)
4151 if (!cracked) continue;
4152
4153 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4154 {
4155 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4156 {
4157 cracked = 0;
4158 break;
4159 }
4160 }
4161 }
4162 }
4163 else
4164 {
4165 char *digests_buf_ptr = (char *) data.digests_buf;
4166
4167 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4168
4169 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4170 }
4171
4172 if (cracked == 1)
4173 {
4174 found = 1;
4175
4176 data.digests_shown[idx] = 1;
4177
4178 data.digests_done++;
4179
4180 salt_buf->digests_done++;
4181
4182 if (salt_buf->digests_done == salt_buf->digests_cnt)
4183 {
4184 data.salts_shown[salt_pos] = 1;
4185
4186 data.salts_done++;
4187
4188 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4189 }
4190 }
4191 }
4192
4193 if (data.devices_status == STATUS_CRACKED) break;
4194 }
4195 }
4196
4197 if (found) break;
4198
4199 if (data.devices_status == STATUS_CRACKED) break;
4200
4201 iter--;
4202 }
4203
4204 if (data.devices_status == STATUS_CRACKED) break;
4205 }
4206
4207 out_info[j].seek = ftell (fp);
4208
4209 //hc_thread_mutex_unlock (mux_display);
4210
4211 fclose (fp);
4212 }
4213 }
4214 }
4215 }
4216
4217 check_left = outfile_check_timer;
4218 }
4219 }
4220
4221 if (esalt_size) local_free (hash_buf.esalt);
4222
4223 if (isSalted) local_free (hash_buf.salt);
4224
4225 local_free (hash_buf.digest);
4226
4227 local_free (out_info);
4228
4229 local_free (out_files);
4230
4231 p = NULL;
4232
4233 return (p);
4234 }
4235
4236 static uint get_work (hc_device_param_t *device_param, const u64 max)
4237 {
4238 hc_thread_mutex_lock (mux_dispatcher);
4239
4240 const u64 words_cur = data.words_cur;
4241 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4242
4243 device_param->words_off = words_cur;
4244
4245 const u64 words_left = words_base - words_cur;
4246
4247 if (data.kernel_power_all > words_left)
4248 {
4249 if (data.kernel_power_div == 0)
4250 {
4251 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4252 }
4253 }
4254
4255 if (data.kernel_power_div)
4256 {
4257 if (device_param->kernel_power == device_param->kernel_power_user)
4258 {
4259 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4260
4261 if (kernel_power_new < device_param->kernel_power)
4262 {
4263 device_param->kernel_power = kernel_power_new;
4264 }
4265 }
4266 }
4267
4268 const uint kernel_power = device_param->kernel_power;
4269
4270 uint work = MIN (words_left, kernel_power);
4271
4272 work = MIN (work, max);
4273
4274 data.words_cur += work;
4275
4276 hc_thread_mutex_unlock (mux_dispatcher);
4277
4278 return work;
4279 }
4280
4281 static void *thread_calc_stdin (void *p)
4282 {
4283 hc_device_param_t *device_param = (hc_device_param_t *) p;
4284
4285 if (device_param->skipped) return NULL;
4286
4287 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4288 {
4289 autotune (device_param);
4290 }
4291
4292 const uint attack_kern = data.attack_kern;
4293
4294 const uint kernel_power = device_param->kernel_power;
4295
4296 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4297 {
4298 hc_thread_mutex_lock (mux_dispatcher);
4299
4300 if (feof (stdin) != 0)
4301 {
4302 hc_thread_mutex_unlock (mux_dispatcher);
4303
4304 break;
4305 }
4306
4307 uint words_cur = 0;
4308
4309 while (words_cur < kernel_power)
4310 {
4311 char buf[BUFSIZ] = { 0 };
4312
4313 char *line_buf = fgets (buf, sizeof (buf), stdin);
4314
4315 if (line_buf == NULL) break;
4316
4317 uint line_len = in_superchop (line_buf);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (line_len > PW_MAX)
4341 {
4342 continue;
4343 }
4344
4345 if (attack_kern == ATTACK_KERN_STRAIGHT)
4346 {
4347 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4348 {
4349 hc_thread_mutex_lock (mux_counter);
4350
4351 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4352 {
4353 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4354 }
4355
4356 hc_thread_mutex_unlock (mux_counter);
4357
4358 continue;
4359 }
4360 }
4361 else if (attack_kern == ATTACK_KERN_COMBI)
4362 {
4363 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4364 // since we still need to combine the plains
4365
4366 if (line_len > data.pw_max)
4367 {
4368 hc_thread_mutex_lock (mux_counter);
4369
4370 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4371 {
4372 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4373 }
4374
4375 hc_thread_mutex_unlock (mux_counter);
4376
4377 continue;
4378 }
4379 }
4380
4381 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4382
4383 words_cur++;
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // we need 2 flushing because we have two independant caches and it can occur
4399 // that one buffer is already at threshold plus for that length also exists
4400 // more data in the 2nd buffer so it would overflow
4401
4402 // flush session 1
4403
4404 {
4405 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4406 {
4407 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4408
4409 const uint pw_cache_cnt = pw_cache->cnt;
4410
4411 if (pw_cache_cnt == 0) continue;
4412
4413 pw_cache->cnt = 0;
4414
4415 uint pws_cnt = device_param->pws_cnt;
4416
4417 pw_t *pw = device_param->pws_buf + pws_cnt;
4418
4419 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4420
4421 pw->pw_len = pw_len;
4422
4423 uint pw_cnt = device_param->pw_cnt;
4424
4425 pw_cnt += pw_cache_cnt;
4426
4427 device_param->pw_cnt = pw_cnt;
4428
4429 pws_cnt++;
4430
4431 device_param->pws_cnt = pws_cnt;
4432
4433 if (pws_cnt == device_param->kernel_power_user) break;
4434 }
4435
4436 const uint pw_cnt = device_param->pw_cnt;
4437 const uint pws_cnt = device_param->pws_cnt;
4438
4439 if (pws_cnt)
4440 {
4441 run_copy (device_param, pws_cnt);
4442
4443 run_cracker (device_param, pw_cnt, pws_cnt);
4444
4445 device_param->pw_cnt = 0;
4446 device_param->pws_cnt = 0;
4447 }
4448 }
4449
4450 // flush session 2
4451
4452 {
4453 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4454 {
4455 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4456
4457 const uint pw_cache_cnt = pw_cache->cnt;
4458
4459 if (pw_cache_cnt == 0) continue;
4460
4461 pw_cache->cnt = 0;
4462
4463 uint pws_cnt = device_param->pws_cnt;
4464
4465 pw_t *pw = device_param->pws_buf + pws_cnt;
4466
4467 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4468
4469 pw->pw_len = pw_len;
4470
4471 uint pw_cnt = device_param->pw_cnt;
4472
4473 pw_cnt += pw_cache_cnt;
4474
4475 device_param->pw_cnt = pw_cnt;
4476
4477 pws_cnt++;
4478
4479 device_param->pws_cnt = pws_cnt;
4480 }
4481
4482 const uint pw_cnt = device_param->pw_cnt;
4483 const uint pws_cnt = device_param->pws_cnt;
4484
4485 if (pws_cnt)
4486 {
4487 run_copy (device_param, pws_cnt);
4488
4489 run_cracker (device_param, pw_cnt, pws_cnt);
4490
4491 device_param->pw_cnt = 0;
4492 device_param->pws_cnt = 0;
4493 }
4494 }
4495 }
4496
4497 return NULL;
4498 }
4499
4500 static void *thread_calc (void *p)
4501 {
4502 hc_device_param_t *device_param = (hc_device_param_t *) p;
4503
4504 if (device_param->skipped) return NULL;
4505
4506 if ((device_param->kernel_accel == 0) && (device_param->kernel_loops == 0))
4507 {
4508 autotune (device_param);
4509 }
4510
4511 const uint attack_mode = data.attack_mode;
4512 const uint attack_kern = data.attack_kern;
4513
4514 if (attack_mode == ATTACK_MODE_BF)
4515 {
4516 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4517 {
4518 const uint work = get_work (device_param, -1);
4519
4520 if (work == 0) break;
4521
4522 const u64 words_off = device_param->words_off;
4523 const u64 words_fin = words_off + work;
4524
4525 const uint pw_cnt = work;
4526 const uint pws_cnt = work;
4527
4528 device_param->pw_cnt = pw_cnt;
4529 device_param->pws_cnt = pws_cnt;
4530
4531 if (pws_cnt)
4532 {
4533 run_copy (device_param, pws_cnt);
4534
4535 run_cracker (device_param, pw_cnt, pws_cnt);
4536
4537 device_param->pw_cnt = 0;
4538 device_param->pws_cnt = 0;
4539 }
4540
4541 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4542
4543 if (data.devices_status == STATUS_CRACKED) break;
4544 if (data.devices_status == STATUS_ABORTED) break;
4545 if (data.devices_status == STATUS_QUIT) break;
4546 if (data.devices_status == STATUS_BYPASS) break;
4547
4548 device_param->words_done = words_fin;
4549 }
4550 }
4551 else
4552 {
4553 const uint segment_size = data.segment_size;
4554
4555 char *dictfile = data.dictfile;
4556
4557 if (attack_mode == ATTACK_MODE_COMBI)
4558 {
4559 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4560 {
4561 dictfile = data.dictfile2;
4562 }
4563 }
4564
4565 FILE *fd = fopen (dictfile, "rb");
4566
4567 if (fd == NULL)
4568 {
4569 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4570
4571 return NULL;
4572 }
4573
4574 if (attack_mode == ATTACK_MODE_COMBI)
4575 {
4576 const uint combs_mode = data.combs_mode;
4577
4578 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4579 {
4580 const char *dictfilec = data.dictfile2;
4581
4582 FILE *combs_fp = fopen (dictfilec, "rb");
4583
4584 if (combs_fp == NULL)
4585 {
4586 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4587
4588 fclose (fd);
4589
4590 return NULL;
4591 }
4592
4593 device_param->combs_fp = combs_fp;
4594 }
4595 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4596 {
4597 const char *dictfilec = data.dictfile;
4598
4599 FILE *combs_fp = fopen (dictfilec, "rb");
4600
4601 if (combs_fp == NULL)
4602 {
4603 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4604
4605 fclose (fd);
4606
4607 return NULL;
4608 }
4609
4610 device_param->combs_fp = combs_fp;
4611 }
4612 }
4613
4614 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4615
4616 wl_data->buf = (char *) mymalloc (segment_size);
4617 wl_data->avail = segment_size;
4618 wl_data->incr = segment_size;
4619 wl_data->cnt = 0;
4620 wl_data->pos = 0;
4621
4622 u64 words_cur = 0;
4623
4624 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4625 {
4626 u64 words_off = 0;
4627 u64 words_fin = 0;
4628
4629 u64 max = -1;
4630
4631 while (max)
4632 {
4633 const uint work = get_work (device_param, max);
4634
4635 if (work == 0) break;
4636
4637 words_off = device_param->words_off;
4638 words_fin = words_off + work;
4639
4640 char *line_buf;
4641 uint line_len;
4642
4643 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4644
4645 max = 0;
4646
4647 for ( ; words_cur < words_fin; words_cur++)
4648 {
4649 get_next_word (wl_data, fd, &line_buf, &line_len);
4650
4651 line_len = convert_from_hex (line_buf, line_len);
4652
4653 // post-process rule engine
4654
4655 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4656 {
4657 char rule_buf_out[BLOCK_SIZE] = { 0 };
4658
4659 int rule_len_out = -1;
4660
4661 if (line_len < BLOCK_SIZE)
4662 {
4663 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4664 }
4665
4666 if (rule_len_out < 0) continue;
4667
4668 line_buf = rule_buf_out;
4669 line_len = rule_len_out;
4670 }
4671
4672 if (attack_kern == ATTACK_KERN_STRAIGHT)
4673 {
4674 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4675 {
4676 max++;
4677
4678 hc_thread_mutex_lock (mux_counter);
4679
4680 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4681 {
4682 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4683 }
4684
4685 hc_thread_mutex_unlock (mux_counter);
4686
4687 continue;
4688 }
4689 }
4690 else if (attack_kern == ATTACK_KERN_COMBI)
4691 {
4692 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4693 // since we still need to combine the plains
4694
4695 if (line_len > data.pw_max)
4696 {
4697 max++;
4698
4699 hc_thread_mutex_lock (mux_counter);
4700
4701 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4702 {
4703 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4704 }
4705
4706 hc_thread_mutex_unlock (mux_counter);
4707
4708 continue;
4709 }
4710 }
4711
4712 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4713
4714 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4715
4716 if (data.devices_status == STATUS_CRACKED) break;
4717 if (data.devices_status == STATUS_ABORTED) break;
4718 if (data.devices_status == STATUS_QUIT) break;
4719 if (data.devices_status == STATUS_BYPASS) break;
4720 }
4721
4722 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4723
4724 if (data.devices_status == STATUS_CRACKED) break;
4725 if (data.devices_status == STATUS_ABORTED) break;
4726 if (data.devices_status == STATUS_QUIT) break;
4727 if (data.devices_status == STATUS_BYPASS) break;
4728 }
4729
4730 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4731
4732 if (data.devices_status == STATUS_CRACKED) break;
4733 if (data.devices_status == STATUS_ABORTED) break;
4734 if (data.devices_status == STATUS_QUIT) break;
4735 if (data.devices_status == STATUS_BYPASS) break;
4736
4737 // we need 2 flushing because we have two independant caches and it can occur
4738 // that one buffer is already at threshold plus for that length also exists
4739 // more data in the 2nd buffer so it would overflow
4740
4741 //
4742 // flush session 1
4743 //
4744
4745 {
4746 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4747 {
4748 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4749
4750 const uint pw_cache_cnt = pw_cache->cnt;
4751
4752 if (pw_cache_cnt == 0) continue;
4753
4754 pw_cache->cnt = 0;
4755
4756 uint pws_cnt = device_param->pws_cnt;
4757
4758 pw_t *pw = device_param->pws_buf + pws_cnt;
4759
4760 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4761
4762 pw->pw_len = pw_len;
4763
4764 uint pw_cnt = device_param->pw_cnt;
4765
4766 pw_cnt += pw_cache_cnt;
4767
4768 device_param->pw_cnt = pw_cnt;
4769
4770 pws_cnt++;
4771
4772 device_param->pws_cnt = pws_cnt;
4773
4774 if (pws_cnt == device_param->kernel_power_user) break;
4775 }
4776
4777 const uint pw_cnt = device_param->pw_cnt;
4778 const uint pws_cnt = device_param->pws_cnt;
4779
4780 if (pws_cnt)
4781 {
4782 run_copy (device_param, pws_cnt);
4783
4784 run_cracker (device_param, pw_cnt, pws_cnt);
4785
4786 device_param->pw_cnt = 0;
4787 device_param->pws_cnt = 0;
4788 }
4789
4790 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4791
4792 if (data.devices_status == STATUS_CRACKED) break;
4793 if (data.devices_status == STATUS_ABORTED) break;
4794 if (data.devices_status == STATUS_QUIT) break;
4795 if (data.devices_status == STATUS_BYPASS) break;
4796 }
4797
4798 //
4799 // flush session 2
4800 //
4801
4802 {
4803 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4804 {
4805 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4806
4807 const uint pw_cache_cnt = pw_cache->cnt;
4808
4809 if (pw_cache_cnt == 0) continue;
4810
4811 pw_cache->cnt = 0;
4812
4813 uint pws_cnt = device_param->pws_cnt;
4814
4815 pw_t *pw = device_param->pws_buf + pws_cnt;
4816
4817 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4818
4819 pw->pw_len = pw_len;
4820
4821 uint pw_cnt = device_param->pw_cnt;
4822
4823 pw_cnt += pw_cache_cnt;
4824
4825 device_param->pw_cnt = pw_cnt;
4826
4827 pws_cnt++;
4828
4829 device_param->pws_cnt = pws_cnt;
4830 }
4831
4832 const uint pw_cnt = device_param->pw_cnt;
4833 const uint pws_cnt = device_param->pws_cnt;
4834
4835 if (pws_cnt)
4836 {
4837 run_copy (device_param, pws_cnt);
4838
4839 run_cracker (device_param, pw_cnt, pws_cnt);
4840
4841 device_param->pw_cnt = 0;
4842 device_param->pws_cnt = 0;
4843 }
4844
4845 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4846
4847 if (data.devices_status == STATUS_CRACKED) break;
4848 if (data.devices_status == STATUS_ABORTED) break;
4849 if (data.devices_status == STATUS_QUIT) break;
4850 if (data.devices_status == STATUS_BYPASS) break;
4851 }
4852
4853 if (words_fin == 0) break;
4854
4855 device_param->words_done = words_fin;
4856 }
4857
4858 if (attack_mode == ATTACK_MODE_COMBI)
4859 {
4860 fclose (device_param->combs_fp);
4861 }
4862
4863 free (wl_data->buf);
4864 free (wl_data);
4865
4866 fclose (fd);
4867 }
4868
4869 return NULL;
4870 }
4871
4872 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4873 {
4874 if (!device_param)
4875 {
4876 log_error ("ERROR: %s : Invalid argument", __func__);
4877
4878 exit (-1);
4879 }
4880
4881 salt_t *salt_buf = &data.salts_buf[salt_pos];
4882
4883 device_param->kernel_params_buf32[24] = salt_pos;
4884 device_param->kernel_params_buf32[27] = 1;
4885 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4886 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4887 device_param->kernel_params_buf32[30] = 0;
4888 device_param->kernel_params_buf32[31] = 1;
4889
4890 char *dictfile_old = data.dictfile;
4891
4892 const char *weak_hash_check = "weak-hash-check";
4893
4894 data.dictfile = (char *) weak_hash_check;
4895
4896 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4897
4898 data.kernel_rules_buf[0].cmds[0] = 0;
4899
4900 /**
4901 * run the kernel
4902 */
4903
4904 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4905 {
4906 run_kernel (KERN_RUN_1, device_param, 1, false);
4907 }
4908 else
4909 {
4910 run_kernel (KERN_RUN_1, device_param, 1, false);
4911
4912 uint loop_step = 16;
4913
4914 const uint iter = salt_buf->salt_iter;
4915
4916 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4917 {
4918 uint loop_left = iter - loop_pos;
4919
4920 loop_left = MIN (loop_left, loop_step);
4921
4922 device_param->kernel_params_buf32[25] = loop_pos;
4923 device_param->kernel_params_buf32[26] = loop_left;
4924
4925 run_kernel (KERN_RUN_2, device_param, 1, false);
4926 }
4927
4928 run_kernel (KERN_RUN_3, device_param, 1, false);
4929 }
4930
4931 /**
4932 * result
4933 */
4934
4935 check_cracked (device_param, salt_pos);
4936
4937 /**
4938 * cleanup
4939 */
4940
4941 device_param->kernel_params_buf32[24] = 0;
4942 device_param->kernel_params_buf32[25] = 0;
4943 device_param->kernel_params_buf32[26] = 0;
4944 device_param->kernel_params_buf32[27] = 0;
4945 device_param->kernel_params_buf32[28] = 0;
4946 device_param->kernel_params_buf32[29] = 0;
4947 device_param->kernel_params_buf32[30] = 0;
4948 device_param->kernel_params_buf32[31] = 0;
4949
4950 data.dictfile = dictfile_old;
4951
4952 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4953 }
4954
4955 // hlfmt hashcat
4956
4957 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4958 {
4959 if (data.username == 0)
4960 {
4961 *hashbuf_pos = line_buf;
4962 *hashbuf_len = line_len;
4963 }
4964 else
4965 {
4966 char *pos = line_buf;
4967 int len = line_len;
4968
4969 for (int i = 0; i < line_len; i++, pos++, len--)
4970 {
4971 if (line_buf[i] == data.separator)
4972 {
4973 pos++;
4974
4975 len--;
4976
4977 break;
4978 }
4979 }
4980
4981 *hashbuf_pos = pos;
4982 *hashbuf_len = len;
4983 }
4984 }
4985
4986 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4987 {
4988 char *pos = NULL;
4989 int len = 0;
4990
4991 int sep_cnt = 0;
4992
4993 for (int i = 0; i < line_len; i++)
4994 {
4995 if (line_buf[i] == data.separator)
4996 {
4997 sep_cnt++;
4998
4999 continue;
5000 }
5001
5002 if (sep_cnt == 0)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009
5010 *userbuf_pos = pos;
5011 *userbuf_len = len;
5012 }
5013
5014 // hlfmt pwdump
5015
5016 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
5017 {
5018 int sep_cnt = 0;
5019
5020 int sep2_len = 0;
5021 int sep3_len = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 2) sep2_len++;
5033 if (sep_cnt == 3) sep3_len++;
5034 }
5035
5036 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5037
5038 return 0;
5039 }
5040
5041 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5042 {
5043 char *pos = NULL;
5044 int len = 0;
5045
5046 int sep_cnt = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == ':')
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (data.hash_mode == 1000)
5058 {
5059 if (sep_cnt == 3)
5060 {
5061 if (pos == NULL) pos = line_buf + i;
5062
5063 len++;
5064 }
5065 }
5066 else if (data.hash_mode == 3000)
5067 {
5068 if (sep_cnt == 2)
5069 {
5070 if (pos == NULL) pos = line_buf + i;
5071
5072 len++;
5073 }
5074 }
5075 }
5076
5077 *hashbuf_pos = pos;
5078 *hashbuf_len = len;
5079 }
5080
5081 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5082 {
5083 char *pos = NULL;
5084 int len = 0;
5085
5086 int sep_cnt = 0;
5087
5088 for (int i = 0; i < line_len; i++)
5089 {
5090 if (line_buf[i] == ':')
5091 {
5092 sep_cnt++;
5093
5094 continue;
5095 }
5096
5097 if (sep_cnt == 0)
5098 {
5099 if (pos == NULL) pos = line_buf + i;
5100
5101 len++;
5102 }
5103 }
5104
5105 *userbuf_pos = pos;
5106 *userbuf_len = len;
5107 }
5108
5109 // hlfmt passwd
5110
5111 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
5112 {
5113 int sep_cnt = 0;
5114
5115 char sep5_first = 0;
5116 char sep6_first = 0;
5117
5118 for (int i = 0; i < line_len; i++)
5119 {
5120 if (line_buf[i] == ':')
5121 {
5122 sep_cnt++;
5123
5124 continue;
5125 }
5126
5127 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5128 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5129 }
5130
5131 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5132
5133 return 0;
5134 }
5135
5136 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5137 {
5138 char *pos = NULL;
5139 int len = 0;
5140
5141 int sep_cnt = 0;
5142
5143 for (int i = 0; i < line_len; i++)
5144 {
5145 if (line_buf[i] == ':')
5146 {
5147 sep_cnt++;
5148
5149 continue;
5150 }
5151
5152 if (sep_cnt == 1)
5153 {
5154 if (pos == NULL) pos = line_buf + i;
5155
5156 len++;
5157 }
5158 }
5159
5160 *hashbuf_pos = pos;
5161 *hashbuf_len = len;
5162 }
5163
5164 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5165 {
5166 char *pos = NULL;
5167 int len = 0;
5168
5169 int sep_cnt = 0;
5170
5171 for (int i = 0; i < line_len; i++)
5172 {
5173 if (line_buf[i] == ':')
5174 {
5175 sep_cnt++;
5176
5177 continue;
5178 }
5179
5180 if (sep_cnt == 0)
5181 {
5182 if (pos == NULL) pos = line_buf + i;
5183
5184 len++;
5185 }
5186 }
5187
5188 *userbuf_pos = pos;
5189 *userbuf_len = len;
5190 }
5191
5192 // hlfmt shadow
5193
5194 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5195 {
5196 int sep_cnt = 0;
5197
5198 for (int i = 0; i < line_len; i++)
5199 {
5200 if (line_buf[i] == ':') sep_cnt++;
5201 }
5202
5203 if (sep_cnt == 8) return 1;
5204
5205 return 0;
5206 }
5207
5208 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5209 {
5210 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5211 }
5212
5213 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5214 {
5215 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5216 }
5217
5218 // hlfmt main
5219
5220 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5221 {
5222 switch (hashfile_format)
5223 {
5224 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5225 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5226 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5227 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5228 }
5229 }
5230
5231 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5232 {
5233 switch (hashfile_format)
5234 {
5235 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5236 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5237 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5238 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5239 }
5240 }
5241
5242 static uint hlfmt_detect (FILE *fp, uint max_check)
5243 {
5244 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5245
5246 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5247 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5248
5249 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5250
5251 uint num_check = 0;
5252
5253 while (!feof (fp))
5254 {
5255 char line_buf[BUFSIZ] = { 0 };
5256
5257 int line_len = fgetl (fp, line_buf);
5258
5259 if (line_len == 0) continue;
5260
5261 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5262 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5263 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5264
5265 if (num_check == max_check) break;
5266
5267 num_check++;
5268 }
5269
5270 uint hashlist_format = HLFMT_HASHCAT;
5271
5272 for (int i = 1; i < HLFMTS_CNT; i++)
5273 {
5274 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5275
5276 hashlist_format = i;
5277 }
5278
5279 free (formats_cnt);
5280
5281 return hashlist_format;
5282 }
5283
5284 /**
5285 * some further helper function
5286 */
5287
5288 // wrapper around mymalloc for ADL
5289
5290 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5291 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5292 {
5293 return mymalloc (iSize);
5294 }
5295 #endif
5296
5297 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)
5298 {
5299 u64 collisions = 0;
5300
5301 const uint dgst_pos0 = data.dgst_pos0;
5302 const uint dgst_pos1 = data.dgst_pos1;
5303 const uint dgst_pos2 = data.dgst_pos2;
5304 const uint dgst_pos3 = data.dgst_pos3;
5305
5306 memset (bitmap_a, 0, bitmap_size);
5307 memset (bitmap_b, 0, bitmap_size);
5308 memset (bitmap_c, 0, bitmap_size);
5309 memset (bitmap_d, 0, bitmap_size);
5310
5311 for (uint i = 0; i < digests_cnt; i++)
5312 {
5313 uint *digest_ptr = (uint *) digests_buf_ptr;
5314
5315 digests_buf_ptr += dgst_size;
5316
5317 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5318 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5319 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5320 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5321
5322 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5323 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5324 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5325 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5326
5327 if (bitmap_a[idx0] & val0) collisions++;
5328 if (bitmap_b[idx1] & val1) collisions++;
5329 if (bitmap_c[idx2] & val2) collisions++;
5330 if (bitmap_d[idx3] & val3) collisions++;
5331
5332 bitmap_a[idx0] |= val0;
5333 bitmap_b[idx1] |= val1;
5334 bitmap_c[idx2] |= val2;
5335 bitmap_d[idx3] |= val3;
5336
5337 if (collisions >= collisions_max) return 0x7fffffff;
5338 }
5339
5340 return collisions;
5341 }
5342
5343 /**
5344 * main
5345 */
5346
5347 int main (int argc, char **argv)
5348 {
5349 /**
5350 * To help users a bit
5351 */
5352
5353 char *compute = getenv ("COMPUTE");
5354
5355 if (compute)
5356 {
5357 static char display[100];
5358
5359 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5360
5361 putenv (display);
5362 }
5363 else
5364 {
5365 if (getenv ("DISPLAY") == NULL)
5366 putenv ((char *) "DISPLAY=:0");
5367 }
5368
5369 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5370 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5371
5372 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5373 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5374
5375 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5376 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5377
5378 /**
5379 * Real init
5380 */
5381
5382 memset (&data, 0, sizeof (hc_global_data_t));
5383
5384 time_t proc_start;
5385
5386 time (&proc_start);
5387
5388 data.proc_start = proc_start;
5389
5390 int myargc = argc;
5391 char **myargv = argv;
5392
5393 hc_thread_mutex_init (mux_dispatcher);
5394 hc_thread_mutex_init (mux_counter);
5395 hc_thread_mutex_init (mux_display);
5396 hc_thread_mutex_init (mux_adl);
5397
5398 /**
5399 * commandline parameters
5400 */
5401
5402 uint usage = USAGE;
5403 uint version = VERSION;
5404 uint quiet = QUIET;
5405 uint benchmark = BENCHMARK;
5406 uint show = SHOW;
5407 uint left = LEFT;
5408 uint username = USERNAME;
5409 uint remove = REMOVE;
5410 uint remove_timer = REMOVE_TIMER;
5411 u64 skip = SKIP;
5412 u64 limit = LIMIT;
5413 uint keyspace = KEYSPACE;
5414 uint potfile_disable = POTFILE_DISABLE;
5415 uint debug_mode = DEBUG_MODE;
5416 char *debug_file = NULL;
5417 char *induction_dir = NULL;
5418 char *outfile_check_dir = NULL;
5419 uint force = FORCE;
5420 uint runtime = RUNTIME;
5421 uint hash_mode = HASH_MODE;
5422 uint attack_mode = ATTACK_MODE;
5423 uint markov_disable = MARKOV_DISABLE;
5424 uint markov_classic = MARKOV_CLASSIC;
5425 uint markov_threshold = MARKOV_THRESHOLD;
5426 char *markov_hcstat = NULL;
5427 char *outfile = NULL;
5428 uint outfile_format = OUTFILE_FORMAT;
5429 uint outfile_autohex = OUTFILE_AUTOHEX;
5430 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5431 uint restore = RESTORE;
5432 uint restore_timer = RESTORE_TIMER;
5433 uint restore_disable = RESTORE_DISABLE;
5434 uint status = STATUS;
5435 uint status_timer = STATUS_TIMER;
5436 uint status_automat = STATUS_AUTOMAT;
5437 uint loopback = LOOPBACK;
5438 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5439 char *session = NULL;
5440 uint hex_charset = HEX_CHARSET;
5441 uint hex_salt = HEX_SALT;
5442 uint hex_wordlist = HEX_WORDLIST;
5443 uint rp_gen = RP_GEN;
5444 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5445 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5446 uint rp_gen_seed = RP_GEN_SEED;
5447 char *rule_buf_l = (char *) RULE_BUF_L;
5448 char *rule_buf_r = (char *) RULE_BUF_R;
5449 uint increment = INCREMENT;
5450 uint increment_min = INCREMENT_MIN;
5451 uint increment_max = INCREMENT_MAX;
5452 char *cpu_affinity = NULL;
5453 OCL_PTR *ocl = NULL;
5454 char *opencl_devices = NULL;
5455 char *opencl_platforms = NULL;
5456 char *opencl_device_types = NULL;
5457 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5458 char *truecrypt_keyfiles = NULL;
5459 uint workload_profile = WORKLOAD_PROFILE;
5460 uint kernel_accel = KERNEL_ACCEL;
5461 uint kernel_loops = KERNEL_LOOPS;
5462 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5463 #ifdef HAVE_HWMON
5464 uint gpu_temp_abort = GPU_TEMP_ABORT;
5465 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5466 #ifdef HAVE_ADL
5467 uint powertune_enable = POWERTUNE_ENABLE;
5468 #endif
5469 #endif
5470 uint logfile_disable = LOGFILE_DISABLE;
5471 uint segment_size = SEGMENT_SIZE;
5472 uint scrypt_tmto = SCRYPT_TMTO;
5473 char separator = SEPARATOR;
5474 uint bitmap_min = BITMAP_MIN;
5475 uint bitmap_max = BITMAP_MAX;
5476 char *custom_charset_1 = NULL;
5477 char *custom_charset_2 = NULL;
5478 char *custom_charset_3 = NULL;
5479 char *custom_charset_4 = NULL;
5480
5481 #define IDX_HELP 'h'
5482 #define IDX_VERSION 'V'
5483 #define IDX_VERSION_LOWER 'v'
5484 #define IDX_QUIET 0xff02
5485 #define IDX_SHOW 0xff03
5486 #define IDX_LEFT 0xff04
5487 #define IDX_REMOVE 0xff05
5488 #define IDX_REMOVE_TIMER 0xff37
5489 #define IDX_SKIP 's'
5490 #define IDX_LIMIT 'l'
5491 #define IDX_KEYSPACE 0xff35
5492 #define IDX_POTFILE_DISABLE 0xff06
5493 #define IDX_DEBUG_MODE 0xff43
5494 #define IDX_DEBUG_FILE 0xff44
5495 #define IDX_INDUCTION_DIR 0xff46
5496 #define IDX_OUTFILE_CHECK_DIR 0xff47
5497 #define IDX_USERNAME 0xff07
5498 #define IDX_FORCE 0xff08
5499 #define IDX_RUNTIME 0xff09
5500 #define IDX_BENCHMARK 'b'
5501 #define IDX_HASH_MODE 'm'
5502 #define IDX_ATTACK_MODE 'a'
5503 #define IDX_RP_FILE 'r'
5504 #define IDX_RP_GEN 'g'
5505 #define IDX_RP_GEN_FUNC_MIN 0xff10
5506 #define IDX_RP_GEN_FUNC_MAX 0xff11
5507 #define IDX_RP_GEN_SEED 0xff34
5508 #define IDX_RULE_BUF_L 'j'
5509 #define IDX_RULE_BUF_R 'k'
5510 #define IDX_INCREMENT 'i'
5511 #define IDX_INCREMENT_MIN 0xff12
5512 #define IDX_INCREMENT_MAX 0xff13
5513 #define IDX_OUTFILE 'o'
5514 #define IDX_OUTFILE_FORMAT 0xff14
5515 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5516 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5517 #define IDX_RESTORE 0xff15
5518 #define IDX_RESTORE_DISABLE 0xff27
5519 #define IDX_STATUS 0xff17
5520 #define IDX_STATUS_TIMER 0xff18
5521 #define IDX_STATUS_AUTOMAT 0xff50
5522 #define IDX_LOOPBACK 0xff38
5523 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5524 #define IDX_SESSION 0xff19
5525 #define IDX_HEX_CHARSET 0xff20
5526 #define IDX_HEX_SALT 0xff21
5527 #define IDX_HEX_WORDLIST 0xff40
5528 #define IDX_MARKOV_DISABLE 0xff22
5529 #define IDX_MARKOV_CLASSIC 0xff23
5530 #define IDX_MARKOV_THRESHOLD 't'
5531 #define IDX_MARKOV_HCSTAT 0xff24
5532 #define IDX_CPU_AFFINITY 0xff25
5533 #define IDX_OPENCL_DEVICES 'd'
5534 #define IDX_OPENCL_PLATFORMS 0xff72
5535 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5536 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5537 #define IDX_WORKLOAD_PROFILE 'w'
5538 #define IDX_KERNEL_ACCEL 'n'
5539 #define IDX_KERNEL_LOOPS 'u'
5540 #define IDX_GPU_TEMP_DISABLE 0xff29
5541 #define IDX_GPU_TEMP_ABORT 0xff30
5542 #define IDX_GPU_TEMP_RETAIN 0xff31
5543 #define IDX_POWERTUNE_ENABLE 0xff41
5544 #define IDX_LOGFILE_DISABLE 0xff51
5545 #define IDX_TRUECRYPT_KEYFILES 0xff52
5546 #define IDX_SCRYPT_TMTO 0xff61
5547 #define IDX_SEGMENT_SIZE 'c'
5548 #define IDX_SEPARATOR 'p'
5549 #define IDX_BITMAP_MIN 0xff70
5550 #define IDX_BITMAP_MAX 0xff71
5551 #define IDX_CUSTOM_CHARSET_1 '1'
5552 #define IDX_CUSTOM_CHARSET_2 '2'
5553 #define IDX_CUSTOM_CHARSET_3 '3'
5554 #define IDX_CUSTOM_CHARSET_4 '4'
5555
5556 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5557
5558 struct option long_options[] =
5559 {
5560 {"help", no_argument, 0, IDX_HELP},
5561 {"version", no_argument, 0, IDX_VERSION},
5562 {"quiet", no_argument, 0, IDX_QUIET},
5563 {"show", no_argument, 0, IDX_SHOW},
5564 {"left", no_argument, 0, IDX_LEFT},
5565 {"username", no_argument, 0, IDX_USERNAME},
5566 {"remove", no_argument, 0, IDX_REMOVE},
5567 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5568 {"skip", required_argument, 0, IDX_SKIP},
5569 {"limit", required_argument, 0, IDX_LIMIT},
5570 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5571 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5572 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5573 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5574 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5575 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5576 {"force", no_argument, 0, IDX_FORCE},
5577 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5578 {"restore", no_argument, 0, IDX_RESTORE},
5579 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5580 {"status", no_argument, 0, IDX_STATUS},
5581 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5582 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5583 {"loopback", no_argument, 0, IDX_LOOPBACK},
5584 {"weak-hash-threshold",
5585 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5586 {"session", required_argument, 0, IDX_SESSION},
5587 {"runtime", required_argument, 0, IDX_RUNTIME},
5588 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5589 {"generate-rules-func-min",
5590 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5591 {"generate-rules-func-max",
5592 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5593 {"generate-rules-seed",
5594 required_argument, 0, IDX_RP_GEN_SEED},
5595 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5596 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5597 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5598 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5599 {"rules-file", required_argument, 0, IDX_RP_FILE},
5600 {"outfile", required_argument, 0, IDX_OUTFILE},
5601 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5602 {"outfile-autohex-disable",
5603 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5604 {"outfile-check-timer",
5605 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5606 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5607 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5608 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5609 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5610 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5611 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5612 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5613 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5614 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5615 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5616 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5617 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5618 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5619 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5620 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5621 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5622 #ifdef HAVE_HWMON
5623 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5624 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5625 #ifdef HAVE_ADL
5626 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5627 #endif
5628 #endif // HAVE_HWMON
5629 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5630 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5631 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5632 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5633 // deprecated
5634 {"seperator", required_argument, 0, IDX_SEPARATOR},
5635 {"separator", required_argument, 0, IDX_SEPARATOR},
5636 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5637 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5638 {"increment", no_argument, 0, IDX_INCREMENT},
5639 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5640 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5641 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5642 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5643 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5644 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5645
5646 {0, 0, 0, 0}
5647 };
5648
5649 uint rp_files_cnt = 0;
5650
5651 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5652
5653 int option_index = 0;
5654 int c = -1;
5655
5656 optind = 1;
5657 optopt = 0;
5658
5659 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5660 {
5661 switch (c)
5662 {
5663 case IDX_HELP: usage = 1; break;
5664 case IDX_VERSION:
5665 case IDX_VERSION_LOWER: version = 1; break;
5666 case IDX_RESTORE: restore = 1; break;
5667 case IDX_SESSION: session = optarg; break;
5668 case IDX_SHOW: show = 1; break;
5669 case IDX_LEFT: left = 1; break;
5670 case '?': return (-1);
5671 }
5672 }
5673
5674 if (optopt != 0)
5675 {
5676 log_error ("ERROR: Invalid argument specified");
5677
5678 return (-1);
5679 }
5680
5681 /**
5682 * exit functions
5683 */
5684
5685 if (version)
5686 {
5687 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5688
5689 return (0);
5690 }
5691
5692 if (usage)
5693 {
5694 usage_big_print (PROGNAME);
5695
5696 return (0);
5697 }
5698
5699 /**
5700 * session needs to be set, always!
5701 */
5702
5703 if (session == NULL) session = (char *) PROGNAME;
5704
5705 /**
5706 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5707 */
5708
5709 char *exec_path = get_exec_path ();
5710
5711 #ifdef LINUX
5712
5713 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5714 char *resolved_exec_path = realpath (exec_path, NULL);
5715
5716 char *install_dir = get_install_dir (resolved_exec_path);
5717 char *profile_dir = NULL;
5718 char *session_dir = NULL;
5719 char *shared_dir = NULL;
5720
5721 if (strcmp (install_dir, resolved_install_folder) == 0)
5722 {
5723 struct passwd *pw = getpwuid (getuid ());
5724
5725 const char *homedir = pw->pw_dir;
5726
5727 profile_dir = get_profile_dir (homedir);
5728 session_dir = get_session_dir (profile_dir);
5729 shared_dir = strdup (SHARED_FOLDER);
5730
5731 mkdir (profile_dir, 0700);
5732 mkdir (session_dir, 0700);
5733 }
5734 else
5735 {
5736 profile_dir = install_dir;
5737 session_dir = install_dir;
5738 shared_dir = install_dir;
5739 }
5740
5741 myfree (resolved_install_folder);
5742 myfree (resolved_exec_path);
5743
5744 #else
5745
5746 char *install_dir = get_install_dir (exec_path);
5747 char *profile_dir = install_dir;
5748 char *session_dir = install_dir;
5749 char *shared_dir = install_dir;
5750
5751 #endif
5752
5753 data.install_dir = install_dir;
5754 data.profile_dir = profile_dir;
5755 data.session_dir = session_dir;
5756 data.shared_dir = shared_dir;
5757
5758 myfree (exec_path);
5759
5760 /**
5761 * kernel cache, we need to make sure folder exist
5762 */
5763
5764 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5765
5766 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5767
5768 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5769
5770 mkdir (kernels_folder, 0700);
5771
5772 myfree (kernels_folder);
5773
5774 /**
5775 * session
5776 */
5777
5778 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5779
5780 data.session = session;
5781
5782 char *eff_restore_file = (char *) mymalloc (session_size);
5783 char *new_restore_file = (char *) mymalloc (session_size);
5784
5785 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5786 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5787
5788 data.eff_restore_file = eff_restore_file;
5789 data.new_restore_file = new_restore_file;
5790
5791 if (((show == 1) || (left == 1)) && (restore == 1))
5792 {
5793 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5794 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5795
5796 return (-1);
5797 }
5798
5799 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5800 if ((show == 1) || (left == 1))
5801 {
5802 restore_disable = 1;
5803
5804 restore = 0;
5805 }
5806
5807 data.restore_disable = restore_disable;
5808
5809 restore_data_t *rd = init_restore (argc, argv);
5810
5811 data.rd = rd;
5812
5813 /**
5814 * restore file
5815 */
5816
5817 if (restore == 1)
5818 {
5819 read_restore (eff_restore_file, rd);
5820
5821 if (rd->version_bin < RESTORE_MIN)
5822 {
5823 log_error ("ERROR: Incompatible restore-file version");
5824
5825 return (-1);
5826 }
5827
5828 myargc = rd->argc;
5829 myargv = rd->argv;
5830
5831 #ifdef _POSIX
5832 rd->pid = getpid ();
5833 #elif _WIN
5834 rd->pid = GetCurrentProcessId ();
5835 #endif
5836 }
5837
5838 uint hash_mode_chgd = 0;
5839 uint runtime_chgd = 0;
5840 uint kernel_loops_chgd = 0;
5841 uint kernel_accel_chgd = 0;
5842 uint attack_mode_chgd = 0;
5843 uint outfile_format_chgd = 0;
5844 uint rp_gen_seed_chgd = 0;
5845 uint remove_timer_chgd = 0;
5846 uint increment_min_chgd = 0;
5847 uint increment_max_chgd = 0;
5848 uint workload_profile_chgd = 0;
5849 uint opencl_vector_width_chgd = 0;
5850
5851 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5852 uint gpu_temp_retain_chgd = 0;
5853 uint gpu_temp_abort_chgd = 0;
5854 #endif
5855
5856 optind = 1;
5857 optopt = 0;
5858 option_index = 0;
5859
5860 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5861 {
5862 switch (c)
5863 {
5864 //case IDX_HELP: usage = 1; break;
5865 //case IDX_VERSION: version = 1; break;
5866 //case IDX_RESTORE: restore = 1; break;
5867 case IDX_QUIET: quiet = 1; break;
5868 //case IDX_SHOW: show = 1; break;
5869 case IDX_SHOW: break;
5870 //case IDX_LEFT: left = 1; break;
5871 case IDX_LEFT: break;
5872 case IDX_USERNAME: username = 1; break;
5873 case IDX_REMOVE: remove = 1; break;
5874 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5875 remove_timer_chgd = 1; break;
5876 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5877 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5878 case IDX_DEBUG_FILE: debug_file = optarg; break;
5879 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5880 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5881 case IDX_FORCE: force = 1; break;
5882 case IDX_SKIP: skip = atoll (optarg); break;
5883 case IDX_LIMIT: limit = atoll (optarg); break;
5884 case IDX_KEYSPACE: keyspace = 1; break;
5885 case IDX_BENCHMARK: benchmark = 1; break;
5886 case IDX_RESTORE: break;
5887 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5888 case IDX_STATUS: status = 1; break;
5889 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5890 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5891 case IDX_LOOPBACK: loopback = 1; break;
5892 case IDX_WEAK_HASH_THRESHOLD:
5893 weak_hash_threshold = atoi (optarg); break;
5894 //case IDX_SESSION: session = optarg; break;
5895 case IDX_SESSION: break;
5896 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5897 hash_mode_chgd = 1; break;
5898 case IDX_RUNTIME: runtime = atoi (optarg);
5899 runtime_chgd = 1; break;
5900 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5901 attack_mode_chgd = 1; break;
5902 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5903 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5904 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5905 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5906 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5907 rp_gen_seed_chgd = 1; break;
5908 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5909 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5910 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5911 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5912 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5913 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5914 case IDX_OUTFILE: outfile = optarg; break;
5915 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5916 outfile_format_chgd = 1; break;
5917 case IDX_OUTFILE_AUTOHEX_DISABLE:
5918 outfile_autohex = 0; break;
5919 case IDX_OUTFILE_CHECK_TIMER:
5920 outfile_check_timer = atoi (optarg); break;
5921 case IDX_HEX_CHARSET: hex_charset = 1; break;
5922 case IDX_HEX_SALT: hex_salt = 1; break;
5923 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5924 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5925 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5926 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5927 case IDX_OPENCL_DEVICE_TYPES:
5928 opencl_device_types = optarg; break;
5929 case IDX_OPENCL_VECTOR_WIDTH:
5930 opencl_vector_width = atoi (optarg);
5931 opencl_vector_width_chgd = 1; break;
5932 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5933 workload_profile_chgd = 1; break;
5934 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5935 kernel_accel_chgd = 1; break;
5936 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5937 kernel_loops_chgd = 1; break;
5938 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5939 #ifdef HAVE_HWMON
5940 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5941 #ifdef HAVE_ADL
5942 gpu_temp_abort_chgd = 1;
5943 #endif
5944 break;
5945 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5946 #ifdef HAVE_ADL
5947 gpu_temp_retain_chgd = 1;
5948 #endif
5949 break;
5950 #ifdef HAVE_ADL
5951 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5952 #endif
5953 #endif // HAVE_HWMON
5954 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5955 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5956 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5957 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5958 case IDX_SEPARATOR: separator = optarg[0]; break;
5959 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5960 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5961 case IDX_INCREMENT: increment = 1; break;
5962 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5963 increment_min_chgd = 1; break;
5964 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5965 increment_max_chgd = 1; break;
5966 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5967 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5968 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5969 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5970
5971 default:
5972 log_error ("ERROR: Invalid argument specified");
5973 return (-1);
5974 }
5975 }
5976
5977 if (optopt != 0)
5978 {
5979 log_error ("ERROR: Invalid argument specified");
5980
5981 return (-1);
5982 }
5983
5984 /**
5985 * Inform user things getting started,
5986 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5987 * - we do not need to check algorithm_pos
5988 */
5989
5990 if (quiet == 0)
5991 {
5992 if (benchmark == 1)
5993 {
5994 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5995
5996 log_info ("");
5997 }
5998 else if (restore == 1)
5999 {
6000 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
6001
6002 log_info ("");
6003 }
6004 else
6005 {
6006 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
6007
6008 log_info ("");
6009 }
6010 }
6011
6012 /**
6013 * sanity check
6014 */
6015
6016 if (attack_mode > 7)
6017 {
6018 log_error ("ERROR: Invalid attack-mode specified");
6019
6020 return (-1);
6021 }
6022
6023 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6024 {
6025 log_error ("ERROR: Invalid runtime specified");
6026
6027 return (-1);
6028 }
6029
6030 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
6031 {
6032 log_error ("ERROR: Invalid hash-type specified");
6033
6034 return (-1);
6035 }
6036
6037 // renamed hash modes
6038
6039 if (hash_mode_chgd)
6040 {
6041 int n = -1;
6042
6043 switch (hash_mode)
6044 {
6045 case 123: n = 124;
6046 break;
6047 }
6048
6049 if (n >= 0)
6050 {
6051 log_error ("Old -m specified, use -m %d instead", n);
6052
6053 return (-1);
6054 }
6055 }
6056
6057 if (username == 1)
6058 {
6059 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
6060 {
6061 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6062
6063 return (-1);
6064 }
6065 }
6066
6067 if (outfile_format > 16)
6068 {
6069 log_error ("ERROR: Invalid outfile-format specified");
6070
6071 return (-1);
6072 }
6073
6074 if (left == 1)
6075 {
6076 if (outfile_format_chgd == 1)
6077 {
6078 if (outfile_format > 1)
6079 {
6080 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6081
6082 return (-1);
6083 }
6084 }
6085 else
6086 {
6087 outfile_format = OUTFILE_FMT_HASH;
6088 }
6089 }
6090
6091 if (show == 1)
6092 {
6093 if (outfile_format_chgd == 1)
6094 {
6095 if ((outfile_format > 7) && (outfile_format < 16))
6096 {
6097 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6098
6099 return (-1);
6100 }
6101 }
6102 }
6103
6104 if (increment_min < INCREMENT_MIN)
6105 {
6106 log_error ("ERROR: Invalid increment-min specified");
6107
6108 return (-1);
6109 }
6110
6111 if (increment_max > INCREMENT_MAX)
6112 {
6113 log_error ("ERROR: Invalid increment-max specified");
6114
6115 return (-1);
6116 }
6117
6118 if (increment_min > increment_max)
6119 {
6120 log_error ("ERROR: Invalid increment-min specified");
6121
6122 return (-1);
6123 }
6124
6125 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6126 {
6127 log_error ("ERROR: increment is not allowed in attack-mode 0");
6128
6129 return (-1);
6130 }
6131
6132 if ((increment == 0) && (increment_min_chgd == 1))
6133 {
6134 log_error ("ERROR: increment-min is only supported together with increment switch");
6135
6136 return (-1);
6137 }
6138
6139 if ((increment == 0) && (increment_max_chgd == 1))
6140 {
6141 log_error ("ERROR: increment-max is only supported together with increment switch");
6142
6143 return (-1);
6144 }
6145
6146 if (rp_files_cnt && rp_gen)
6147 {
6148 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6149
6150 return (-1);
6151 }
6152
6153 if (rp_files_cnt || rp_gen)
6154 {
6155 if (attack_mode != ATTACK_MODE_STRAIGHT)
6156 {
6157 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if (rp_gen_func_min > rp_gen_func_max)
6164 {
6165 log_error ("ERROR: Invalid rp-gen-func-min specified");
6166
6167 return (-1);
6168 }
6169
6170 if (kernel_accel_chgd == 1 && kernel_loops_chgd == 0)
6171 {
6172 log_error ("ERROR: If kernel-accel is specified, kernel-loops need to be specified as well");
6173
6174 return (-1);
6175 }
6176
6177 if (kernel_loops_chgd == 1 && kernel_accel_chgd == 0)
6178 {
6179 log_error ("ERROR: If kernel-loops is specified, kernel-accel need to be specified as well");
6180
6181 return (-1);
6182 }
6183
6184 if (kernel_accel_chgd == 1)
6185 {
6186 if (kernel_accel < 1)
6187 {
6188 log_error ("ERROR: Invalid kernel-accel specified");
6189
6190 return (-1);
6191 }
6192
6193 if (kernel_accel > 1024)
6194 {
6195 log_error ("ERROR: Invalid kernel-accel specified");
6196
6197 return (-1);
6198 }
6199 }
6200
6201 if (kernel_loops_chgd == 1)
6202 {
6203 if (kernel_loops < 1)
6204 {
6205 log_error ("ERROR: Invalid kernel-loops specified");
6206
6207 return (-1);
6208 }
6209
6210 if (kernel_loops > 1024)
6211 {
6212 log_error ("ERROR: Invalid kernel-loops specified");
6213
6214 return (-1);
6215 }
6216 }
6217
6218 if ((workload_profile < 1) || (workload_profile > 3))
6219 {
6220 log_error ("ERROR: workload-profile %i not available", workload_profile);
6221
6222 return (-1);
6223 }
6224
6225 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6226 {
6227 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6228
6229 return (-1);
6230 }
6231
6232 if (show == 1 || left == 1)
6233 {
6234 attack_mode = ATTACK_MODE_NONE;
6235
6236 if (remove == 1)
6237 {
6238 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6239
6240 return (-1);
6241 }
6242
6243 if (potfile_disable == 1)
6244 {
6245 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6246
6247 return (-1);
6248 }
6249 }
6250
6251 uint attack_kern = ATTACK_KERN_NONE;
6252
6253 switch (attack_mode)
6254 {
6255 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6256 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6257 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6258 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6259 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6260 }
6261
6262 if (benchmark == 0)
6263 {
6264 if (keyspace == 1)
6265 {
6266 int num_additional_params = 1;
6267
6268 if (attack_kern == ATTACK_KERN_COMBI)
6269 {
6270 num_additional_params = 2;
6271 }
6272
6273 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6274
6275 if (keyspace_wordlist_specified == 0) optind--;
6276 }
6277
6278 if (attack_kern == ATTACK_KERN_NONE)
6279 {
6280 if ((optind + 1) != myargc)
6281 {
6282 usage_mini_print (myargv[0]);
6283
6284 return (-1);
6285 }
6286 }
6287 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6288 {
6289 if ((optind + 1) > myargc)
6290 {
6291 usage_mini_print (myargv[0]);
6292
6293 return (-1);
6294 }
6295 }
6296 else if (attack_kern == ATTACK_KERN_COMBI)
6297 {
6298 if ((optind + 3) != myargc)
6299 {
6300 usage_mini_print (myargv[0]);
6301
6302 return (-1);
6303 }
6304 }
6305 else if (attack_kern == ATTACK_KERN_BF)
6306 {
6307 if ((optind + 1) > myargc)
6308 {
6309 usage_mini_print (myargv[0]);
6310
6311 return (-1);
6312 }
6313 }
6314 else
6315 {
6316 usage_mini_print (myargv[0]);
6317
6318 return (-1);
6319 }
6320 }
6321 else
6322 {
6323 if (myargv[optind] != 0)
6324 {
6325 log_error ("ERROR: Invalid argument for benchmark mode specified");
6326
6327 return (-1);
6328 }
6329
6330 if (attack_mode_chgd == 1)
6331 {
6332 if (attack_mode != ATTACK_MODE_BF)
6333 {
6334 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6335
6336 return (-1);
6337 }
6338 }
6339 }
6340
6341 if (skip != 0 && limit != 0)
6342 {
6343 limit += skip;
6344 }
6345
6346 if (keyspace == 1)
6347 {
6348 if (show == 1)
6349 {
6350 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6351
6352 return (-1);
6353 }
6354 else if (left == 1)
6355 {
6356 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6357
6358 return (-1);
6359 }
6360
6361 potfile_disable = 1;
6362
6363 restore_disable = 1;
6364
6365 restore = 0;
6366
6367 weak_hash_threshold = 0;
6368
6369 quiet = 1;
6370 }
6371
6372 if (remove_timer_chgd == 1)
6373 {
6374 if (remove == 0)
6375 {
6376 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6377
6378 return (-1);
6379 }
6380
6381 if (remove_timer < 1)
6382 {
6383 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6384
6385 return (-1);
6386 }
6387 }
6388
6389 if (loopback == 1)
6390 {
6391 if (attack_mode == ATTACK_MODE_BF)
6392 {
6393 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6394
6395 return (-1);
6396 }
6397 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6398 {
6399 if ((rp_files_cnt == 0) && (rp_gen == 0))
6400 {
6401 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6402
6403 return (-1);
6404 }
6405 }
6406 }
6407
6408 if (debug_mode > 0)
6409 {
6410 if (attack_mode != ATTACK_MODE_STRAIGHT)
6411 {
6412 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6413
6414 return (-1);
6415 }
6416
6417 if ((rp_files_cnt == 0) && (rp_gen == 0))
6418 {
6419 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6420
6421 return (-1);
6422 }
6423 }
6424
6425 if (debug_mode > 4)
6426 {
6427 log_error ("ERROR: Invalid debug-mode specified");
6428
6429 return (-1);
6430 }
6431
6432 if (debug_file != NULL)
6433 {
6434 if (debug_mode < 1)
6435 {
6436 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6437
6438 return (-1);
6439 }
6440 }
6441
6442 if (induction_dir != NULL)
6443 {
6444 if (attack_mode == ATTACK_MODE_BF)
6445 {
6446 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6447
6448 return (-1);
6449 }
6450 }
6451
6452 if (attack_mode != ATTACK_MODE_STRAIGHT)
6453 {
6454 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6455 {
6456 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6457
6458 return (-1);
6459 }
6460
6461 weak_hash_threshold = 0;
6462 }
6463
6464 /**
6465 * induction directory
6466 */
6467
6468 char *induction_directory = NULL;
6469
6470 if (attack_mode != ATTACK_MODE_BF)
6471 {
6472 if (induction_dir == NULL)
6473 {
6474 induction_directory = (char *) mymalloc (session_size);
6475
6476 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6477
6478 // create induction folder if it does not already exist
6479
6480 if (keyspace == 0)
6481 {
6482 if (rmdir (induction_directory) == -1)
6483 {
6484 if (errno == ENOENT)
6485 {
6486 // good, we can ignore
6487 }
6488 else if (errno == ENOTEMPTY)
6489 {
6490 char *induction_directory_mv = (char *) mymalloc (session_size);
6491
6492 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6493
6494 if (rename (induction_directory, induction_directory_mv) != 0)
6495 {
6496 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6497
6498 return (-1);
6499 }
6500 }
6501 else
6502 {
6503 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6504
6505 return (-1);
6506 }
6507 }
6508
6509 if (mkdir (induction_directory, 0700) == -1)
6510 {
6511 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6512
6513 return (-1);
6514 }
6515 }
6516 }
6517 else
6518 {
6519 induction_directory = induction_dir;
6520 }
6521 }
6522
6523 data.induction_directory = induction_directory;
6524
6525 /**
6526 * loopback
6527 */
6528
6529 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6530
6531 char *loopback_file = (char *) mymalloc (loopback_size);
6532
6533 /**
6534 * tuning db
6535 */
6536
6537 char tuning_db_file[256] = { 0 };
6538
6539 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6540
6541 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6542
6543 /**
6544 * outfile-check directory
6545 */
6546
6547 char *outfile_check_directory = NULL;
6548
6549 if (outfile_check_dir == NULL)
6550 {
6551 outfile_check_directory = (char *) mymalloc (session_size);
6552
6553 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6554 }
6555 else
6556 {
6557 outfile_check_directory = outfile_check_dir;
6558 }
6559
6560 data.outfile_check_directory = outfile_check_directory;
6561
6562 if (keyspace == 0)
6563 {
6564 struct stat outfile_check_stat;
6565
6566 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6567 {
6568 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6569
6570 if (is_dir == 0)
6571 {
6572 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6573
6574 return (-1);
6575 }
6576 }
6577 else if (outfile_check_dir == NULL)
6578 {
6579 if (mkdir (outfile_check_directory, 0700) == -1)
6580 {
6581 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6582
6583 return (-1);
6584 }
6585 }
6586 }
6587
6588 /**
6589 * special other stuff
6590 */
6591
6592 if (hash_mode == 9710)
6593 {
6594 outfile_format = 5;
6595 outfile_format_chgd = 1;
6596 }
6597
6598 if (hash_mode == 9810)
6599 {
6600 outfile_format = 5;
6601 outfile_format_chgd = 1;
6602 }
6603
6604 if (hash_mode == 10410)
6605 {
6606 outfile_format = 5;
6607 outfile_format_chgd = 1;
6608 }
6609
6610 /**
6611 * store stuff
6612 */
6613
6614 data.hash_mode = hash_mode;
6615 data.restore = restore;
6616 data.restore_timer = restore_timer;
6617 data.restore_disable = restore_disable;
6618 data.status = status;
6619 data.status_timer = status_timer;
6620 data.status_automat = status_automat;
6621 data.loopback = loopback;
6622 data.runtime = runtime;
6623 data.remove = remove;
6624 data.remove_timer = remove_timer;
6625 data.debug_mode = debug_mode;
6626 data.debug_file = debug_file;
6627 data.username = username;
6628 data.quiet = quiet;
6629 data.outfile = outfile;
6630 data.outfile_format = outfile_format;
6631 data.outfile_autohex = outfile_autohex;
6632 data.hex_charset = hex_charset;
6633 data.hex_salt = hex_salt;
6634 data.hex_wordlist = hex_wordlist;
6635 data.separator = separator;
6636 data.rp_files = rp_files;
6637 data.rp_files_cnt = rp_files_cnt;
6638 data.rp_gen = rp_gen;
6639 data.rp_gen_seed = rp_gen_seed;
6640 data.force = force;
6641 data.benchmark = benchmark;
6642 data.skip = skip;
6643 data.limit = limit;
6644 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6645 data.powertune_enable = powertune_enable;
6646 #endif
6647 data.logfile_disable = logfile_disable;
6648 data.truecrypt_keyfiles = truecrypt_keyfiles;
6649 data.scrypt_tmto = scrypt_tmto;
6650 data.workload_profile = workload_profile;
6651
6652 /**
6653 * cpu affinity
6654 */
6655
6656 if (cpu_affinity)
6657 {
6658 set_cpu_affinity (cpu_affinity);
6659 }
6660
6661 if (rp_gen_seed_chgd == 0)
6662 {
6663 srand (proc_start);
6664 }
6665 else
6666 {
6667 srand (rp_gen_seed);
6668 }
6669
6670 /**
6671 * logfile init
6672 */
6673
6674 if (logfile_disable == 0)
6675 {
6676 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6677
6678 char *logfile = (char *) mymalloc (logfile_size);
6679
6680 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6681
6682 data.logfile = logfile;
6683
6684 char *topid = logfile_generate_topid ();
6685
6686 data.topid = topid;
6687 }
6688
6689 // logfile_append() checks for logfile_disable internally to make it easier from here
6690
6691 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6692 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6693 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6694 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6695 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6696 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6697 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6698 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6699 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6700 #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));
6701
6702 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6703 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6704 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6705 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6706 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6707 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6708 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6709 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6710
6711 logfile_top_msg ("START");
6712
6713 logfile_top_uint (attack_mode);
6714 logfile_top_uint (attack_kern);
6715 logfile_top_uint (benchmark);
6716 logfile_top_uint (bitmap_min);
6717 logfile_top_uint (bitmap_max);
6718 logfile_top_uint (debug_mode);
6719 logfile_top_uint (force);
6720 logfile_top_uint (kernel_accel);
6721 logfile_top_uint (kernel_loops);
6722 logfile_top_uint (gpu_temp_disable);
6723 #ifdef HAVE_HWMON
6724 logfile_top_uint (gpu_temp_abort);
6725 logfile_top_uint (gpu_temp_retain);
6726 #endif
6727 logfile_top_uint (hash_mode);
6728 logfile_top_uint (hex_charset);
6729 logfile_top_uint (hex_salt);
6730 logfile_top_uint (hex_wordlist);
6731 logfile_top_uint (increment);
6732 logfile_top_uint (increment_max);
6733 logfile_top_uint (increment_min);
6734 logfile_top_uint (keyspace);
6735 logfile_top_uint (left);
6736 logfile_top_uint (logfile_disable);
6737 logfile_top_uint (loopback);
6738 logfile_top_uint (markov_classic);
6739 logfile_top_uint (markov_disable);
6740 logfile_top_uint (markov_threshold);
6741 logfile_top_uint (outfile_autohex);
6742 logfile_top_uint (outfile_check_timer);
6743 logfile_top_uint (outfile_format);
6744 logfile_top_uint (potfile_disable);
6745 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6746 logfile_top_uint (powertune_enable);
6747 #endif
6748 logfile_top_uint (scrypt_tmto);
6749 logfile_top_uint (quiet);
6750 logfile_top_uint (remove);
6751 logfile_top_uint (remove_timer);
6752 logfile_top_uint (restore);
6753 logfile_top_uint (restore_disable);
6754 logfile_top_uint (restore_timer);
6755 logfile_top_uint (rp_gen);
6756 logfile_top_uint (rp_gen_func_max);
6757 logfile_top_uint (rp_gen_func_min);
6758 logfile_top_uint (rp_gen_seed);
6759 logfile_top_uint (runtime);
6760 logfile_top_uint (segment_size);
6761 logfile_top_uint (show);
6762 logfile_top_uint (status);
6763 logfile_top_uint (status_automat);
6764 logfile_top_uint (status_timer);
6765 logfile_top_uint (usage);
6766 logfile_top_uint (username);
6767 logfile_top_uint (version);
6768 logfile_top_uint (weak_hash_threshold);
6769 logfile_top_uint (workload_profile);
6770 logfile_top_uint64 (limit);
6771 logfile_top_uint64 (skip);
6772 logfile_top_char (separator);
6773 logfile_top_string (cpu_affinity);
6774 logfile_top_string (custom_charset_1);
6775 logfile_top_string (custom_charset_2);
6776 logfile_top_string (custom_charset_3);
6777 logfile_top_string (custom_charset_4);
6778 logfile_top_string (debug_file);
6779 logfile_top_string (opencl_devices);
6780 logfile_top_string (opencl_platforms);
6781 logfile_top_string (opencl_device_types);
6782 logfile_top_uint (opencl_vector_width);
6783 logfile_top_string (induction_dir);
6784 logfile_top_string (markov_hcstat);
6785 logfile_top_string (outfile);
6786 logfile_top_string (outfile_check_dir);
6787 logfile_top_string (rule_buf_l);
6788 logfile_top_string (rule_buf_r);
6789 logfile_top_string (session);
6790 logfile_top_string (truecrypt_keyfiles);
6791
6792 /**
6793 * Init OpenCL library loader
6794 */
6795
6796 if (keyspace == 0)
6797 {
6798 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6799
6800 ocl_init (ocl);
6801
6802 data.ocl = ocl;
6803 }
6804
6805 /**
6806 * OpenCL platform selection
6807 */
6808
6809 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6810
6811 /**
6812 * OpenCL device selection
6813 */
6814
6815 u32 devices_filter = setup_devices_filter (opencl_devices);
6816
6817 /**
6818 * OpenCL device type selection
6819 */
6820
6821 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6822
6823 /**
6824 * benchmark
6825 */
6826
6827 if (benchmark == 1)
6828 {
6829 /**
6830 * disable useless stuff for benchmark
6831 */
6832
6833 status_timer = 0;
6834 restore_timer = 0;
6835 restore_disable = 1;
6836 potfile_disable = 1;
6837 weak_hash_threshold = 0;
6838
6839 data.status_timer = status_timer;
6840 data.restore_timer = restore_timer;
6841 data.restore_disable = restore_disable;
6842
6843 /**
6844 * force attack mode to be bruteforce
6845 */
6846
6847 attack_mode = ATTACK_MODE_BF;
6848 attack_kern = ATTACK_KERN_BF;
6849
6850 if (workload_profile_chgd == 0)
6851 {
6852 workload_profile = 3;
6853
6854 data.workload_profile = workload_profile;
6855 }
6856
6857 if (runtime_chgd == 0)
6858 {
6859 runtime = 17;
6860
6861 data.runtime = runtime;
6862 }
6863 }
6864
6865 /**
6866 * config
6867 */
6868
6869 uint hash_type = 0;
6870 uint salt_type = 0;
6871 uint attack_exec = 0;
6872 uint opts_type = 0;
6873 uint kern_type = 0;
6874 uint dgst_size = 0;
6875 uint esalt_size = 0;
6876 uint opti_type = 0;
6877 uint dgst_pos0 = -1;
6878 uint dgst_pos1 = -1;
6879 uint dgst_pos2 = -1;
6880 uint dgst_pos3 = -1;
6881
6882 int (*parse_func) (char *, uint, hash_t *);
6883 int (*sort_by_digest) (const void *, const void *);
6884
6885 uint algorithm_pos = 0;
6886 uint algorithm_max = 1;
6887
6888 uint *algorithms = default_benchmark_algorithms;
6889
6890 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6891
6892 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6893 {
6894 /*
6895 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6896 * the following algos are skipped entirely
6897 */
6898
6899 if (algorithm_pos > 0)
6900 {
6901 local_free (rd);
6902
6903 rd = init_restore (argc, argv);
6904
6905 data.rd = rd;
6906 }
6907
6908 /**
6909 * update hash_mode in case of multihash benchmark
6910 */
6911
6912 if (benchmark == 1)
6913 {
6914 if (hash_mode_chgd == 0)
6915 {
6916 hash_mode = algorithms[algorithm_pos];
6917
6918 data.hash_mode = hash_mode;
6919 }
6920
6921 quiet = 1;
6922
6923 data.quiet = quiet;
6924 }
6925
6926 switch (hash_mode)
6927 {
6928 case 0: hash_type = HASH_TYPE_MD5;
6929 salt_type = SALT_TYPE_NONE;
6930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6931 opts_type = OPTS_TYPE_PT_GENERATE_LE
6932 | OPTS_TYPE_PT_ADD80
6933 | OPTS_TYPE_PT_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = md5_parse_hash;
6937 sort_by_digest = sort_by_digest_4_4;
6938 opti_type = OPTI_TYPE_ZERO_BYTE
6939 | OPTI_TYPE_PRECOMPUTE_INIT
6940 | OPTI_TYPE_PRECOMPUTE_MERKLE
6941 | OPTI_TYPE_MEET_IN_MIDDLE
6942 | OPTI_TYPE_EARLY_SKIP
6943 | OPTI_TYPE_NOT_ITERATED
6944 | OPTI_TYPE_NOT_SALTED
6945 | OPTI_TYPE_RAW_HASH;
6946 dgst_pos0 = 0;
6947 dgst_pos1 = 3;
6948 dgst_pos2 = 2;
6949 dgst_pos3 = 1;
6950 break;
6951
6952 case 10: hash_type = HASH_TYPE_MD5;
6953 salt_type = SALT_TYPE_INTERN;
6954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6955 opts_type = OPTS_TYPE_PT_GENERATE_LE
6956 | OPTS_TYPE_ST_ADD80
6957 | OPTS_TYPE_ST_ADDBITS14;
6958 kern_type = KERN_TYPE_MD5_PWSLT;
6959 dgst_size = DGST_SIZE_4_4;
6960 parse_func = md5s_parse_hash;
6961 sort_by_digest = sort_by_digest_4_4;
6962 opti_type = OPTI_TYPE_ZERO_BYTE
6963 | OPTI_TYPE_PRECOMPUTE_INIT
6964 | OPTI_TYPE_PRECOMPUTE_MERKLE
6965 | OPTI_TYPE_MEET_IN_MIDDLE
6966 | OPTI_TYPE_EARLY_SKIP
6967 | OPTI_TYPE_NOT_ITERATED
6968 | OPTI_TYPE_APPENDED_SALT
6969 | OPTI_TYPE_RAW_HASH;
6970 dgst_pos0 = 0;
6971 dgst_pos1 = 3;
6972 dgst_pos2 = 2;
6973 dgst_pos3 = 1;
6974 break;
6975
6976 case 11: hash_type = HASH_TYPE_MD5;
6977 salt_type = SALT_TYPE_INTERN;
6978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6979 opts_type = OPTS_TYPE_PT_GENERATE_LE
6980 | OPTS_TYPE_ST_ADD80
6981 | OPTS_TYPE_ST_ADDBITS14;
6982 kern_type = KERN_TYPE_MD5_PWSLT;
6983 dgst_size = DGST_SIZE_4_4;
6984 parse_func = joomla_parse_hash;
6985 sort_by_digest = sort_by_digest_4_4;
6986 opti_type = OPTI_TYPE_ZERO_BYTE
6987 | OPTI_TYPE_PRECOMPUTE_INIT
6988 | OPTI_TYPE_PRECOMPUTE_MERKLE
6989 | OPTI_TYPE_MEET_IN_MIDDLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_APPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 0;
6995 dgst_pos1 = 3;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 12: hash_type = HASH_TYPE_MD5;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_LE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS14;
7006 kern_type = KERN_TYPE_MD5_PWSLT;
7007 dgst_size = DGST_SIZE_4_4;
7008 parse_func = postgresql_parse_hash;
7009 sort_by_digest = sort_by_digest_4_4;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_PRECOMPUTE_INIT
7012 | OPTI_TYPE_PRECOMPUTE_MERKLE
7013 | OPTI_TYPE_MEET_IN_MIDDLE
7014 | OPTI_TYPE_EARLY_SKIP
7015 | OPTI_TYPE_NOT_ITERATED
7016 | OPTI_TYPE_APPENDED_SALT
7017 | OPTI_TYPE_RAW_HASH;
7018 dgst_pos0 = 0;
7019 dgst_pos1 = 3;
7020 dgst_pos2 = 2;
7021 dgst_pos3 = 1;
7022 break;
7023
7024 case 20: hash_type = HASH_TYPE_MD5;
7025 salt_type = SALT_TYPE_INTERN;
7026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7027 opts_type = OPTS_TYPE_PT_GENERATE_LE
7028 | OPTS_TYPE_PT_ADD80
7029 | OPTS_TYPE_PT_ADDBITS14;
7030 kern_type = KERN_TYPE_MD5_SLTPW;
7031 dgst_size = DGST_SIZE_4_4;
7032 parse_func = md5s_parse_hash;
7033 sort_by_digest = sort_by_digest_4_4;
7034 opti_type = OPTI_TYPE_ZERO_BYTE
7035 | OPTI_TYPE_PRECOMPUTE_INIT
7036 | OPTI_TYPE_PRECOMPUTE_MERKLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_PREPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 0;
7042 dgst_pos1 = 3;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 21: hash_type = HASH_TYPE_MD5;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_LE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS14;
7053 kern_type = KERN_TYPE_MD5_SLTPW;
7054 dgst_size = DGST_SIZE_4_4;
7055 parse_func = osc_parse_hash;
7056 sort_by_digest = sort_by_digest_4_4;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_EARLY_SKIP
7061 | OPTI_TYPE_NOT_ITERATED
7062 | OPTI_TYPE_PREPENDED_SALT
7063 | OPTI_TYPE_RAW_HASH;
7064 dgst_pos0 = 0;
7065 dgst_pos1 = 3;
7066 dgst_pos2 = 2;
7067 dgst_pos3 = 1;
7068 break;
7069
7070 case 22: hash_type = HASH_TYPE_MD5;
7071 salt_type = SALT_TYPE_EMBEDDED;
7072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7073 opts_type = OPTS_TYPE_PT_GENERATE_LE
7074 | OPTS_TYPE_PT_ADD80
7075 | OPTS_TYPE_PT_ADDBITS14;
7076 kern_type = KERN_TYPE_MD5_SLTPW;
7077 dgst_size = DGST_SIZE_4_4;
7078 parse_func = netscreen_parse_hash;
7079 sort_by_digest = sort_by_digest_4_4;
7080 opti_type = OPTI_TYPE_ZERO_BYTE
7081 | OPTI_TYPE_PRECOMPUTE_INIT
7082 | OPTI_TYPE_PRECOMPUTE_MERKLE
7083 | OPTI_TYPE_EARLY_SKIP
7084 | OPTI_TYPE_NOT_ITERATED
7085 | OPTI_TYPE_PREPENDED_SALT
7086 | OPTI_TYPE_RAW_HASH;
7087 dgst_pos0 = 0;
7088 dgst_pos1 = 3;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 23: hash_type = HASH_TYPE_MD5;
7094 salt_type = SALT_TYPE_EMBEDDED;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_LE
7097 | OPTS_TYPE_PT_ADD80
7098 | OPTS_TYPE_PT_ADDBITS14;
7099 kern_type = KERN_TYPE_MD5_SLTPW;
7100 dgst_size = DGST_SIZE_4_4;
7101 parse_func = skype_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_PRECOMPUTE_INIT
7105 | OPTI_TYPE_PRECOMPUTE_MERKLE
7106 | OPTI_TYPE_EARLY_SKIP
7107 | OPTI_TYPE_NOT_ITERATED
7108 | OPTI_TYPE_PREPENDED_SALT
7109 | OPTI_TYPE_RAW_HASH;
7110 dgst_pos0 = 0;
7111 dgst_pos1 = 3;
7112 dgst_pos2 = 2;
7113 dgst_pos3 = 1;
7114 break;
7115
7116 case 30: hash_type = HASH_TYPE_MD5;
7117 salt_type = SALT_TYPE_INTERN;
7118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7119 opts_type = OPTS_TYPE_PT_GENERATE_LE
7120 | OPTS_TYPE_PT_UNICODE
7121 | OPTS_TYPE_ST_ADD80
7122 | OPTS_TYPE_ST_ADDBITS14;
7123 kern_type = KERN_TYPE_MD5_PWUSLT;
7124 dgst_size = DGST_SIZE_4_4;
7125 parse_func = md5s_parse_hash;
7126 sort_by_digest = sort_by_digest_4_4;
7127 opti_type = OPTI_TYPE_ZERO_BYTE
7128 | OPTI_TYPE_PRECOMPUTE_INIT
7129 | OPTI_TYPE_PRECOMPUTE_MERKLE
7130 | OPTI_TYPE_MEET_IN_MIDDLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_APPENDED_SALT
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 3;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 40: hash_type = HASH_TYPE_MD5;
7142 salt_type = SALT_TYPE_INTERN;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_LE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS14
7147 | OPTS_TYPE_PT_UNICODE;
7148 kern_type = KERN_TYPE_MD5_SLTPWU;
7149 dgst_size = DGST_SIZE_4_4;
7150 parse_func = md5s_parse_hash;
7151 sort_by_digest = sort_by_digest_4_4;
7152 opti_type = OPTI_TYPE_ZERO_BYTE
7153 | OPTI_TYPE_PRECOMPUTE_INIT
7154 | OPTI_TYPE_PRECOMPUTE_MERKLE
7155 | OPTI_TYPE_EARLY_SKIP
7156 | OPTI_TYPE_NOT_ITERATED
7157 | OPTI_TYPE_PREPENDED_SALT
7158 | OPTI_TYPE_RAW_HASH;
7159 dgst_pos0 = 0;
7160 dgst_pos1 = 3;
7161 dgst_pos2 = 2;
7162 dgst_pos3 = 1;
7163 break;
7164
7165 case 50: hash_type = HASH_TYPE_MD5;
7166 salt_type = SALT_TYPE_INTERN;
7167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7168 opts_type = OPTS_TYPE_PT_GENERATE_LE
7169 | OPTS_TYPE_ST_ADD80
7170 | OPTS_TYPE_ST_ADDBITS14;
7171 kern_type = KERN_TYPE_HMACMD5_PW;
7172 dgst_size = DGST_SIZE_4_4;
7173 parse_func = hmacmd5_parse_hash;
7174 sort_by_digest = sort_by_digest_4_4;
7175 opti_type = OPTI_TYPE_ZERO_BYTE
7176 | OPTI_TYPE_NOT_ITERATED;
7177 dgst_pos0 = 0;
7178 dgst_pos1 = 3;
7179 dgst_pos2 = 2;
7180 dgst_pos3 = 1;
7181 break;
7182
7183 case 60: hash_type = HASH_TYPE_MD5;
7184 salt_type = SALT_TYPE_INTERN;
7185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7186 opts_type = OPTS_TYPE_PT_GENERATE_LE
7187 | OPTS_TYPE_PT_ADD80
7188 | OPTS_TYPE_PT_ADDBITS14;
7189 kern_type = KERN_TYPE_HMACMD5_SLT;
7190 dgst_size = DGST_SIZE_4_4;
7191 parse_func = hmacmd5_parse_hash;
7192 sort_by_digest = sort_by_digest_4_4;
7193 opti_type = OPTI_TYPE_ZERO_BYTE
7194 | OPTI_TYPE_NOT_ITERATED;
7195 dgst_pos0 = 0;
7196 dgst_pos1 = 3;
7197 dgst_pos2 = 2;
7198 dgst_pos3 = 1;
7199 break;
7200
7201 case 100: hash_type = HASH_TYPE_SHA1;
7202 salt_type = SALT_TYPE_NONE;
7203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7204 opts_type = OPTS_TYPE_PT_GENERATE_BE
7205 | OPTS_TYPE_PT_ADD80
7206 | OPTS_TYPE_PT_ADDBITS15;
7207 kern_type = KERN_TYPE_SHA1;
7208 dgst_size = DGST_SIZE_4_5;
7209 parse_func = sha1_parse_hash;
7210 sort_by_digest = sort_by_digest_4_5;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED
7216 | OPTI_TYPE_NOT_SALTED
7217 | OPTI_TYPE_RAW_HASH;
7218 dgst_pos0 = 3;
7219 dgst_pos1 = 4;
7220 dgst_pos2 = 2;
7221 dgst_pos3 = 1;
7222 break;
7223
7224 case 101: hash_type = HASH_TYPE_SHA1;
7225 salt_type = SALT_TYPE_NONE;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = OPTS_TYPE_PT_GENERATE_BE
7228 | OPTS_TYPE_PT_ADD80
7229 | OPTS_TYPE_PT_ADDBITS15;
7230 kern_type = KERN_TYPE_SHA1;
7231 dgst_size = DGST_SIZE_4_5;
7232 parse_func = sha1b64_parse_hash;
7233 sort_by_digest = sort_by_digest_4_5;
7234 opti_type = OPTI_TYPE_ZERO_BYTE
7235 | OPTI_TYPE_PRECOMPUTE_INIT
7236 | OPTI_TYPE_PRECOMPUTE_MERKLE
7237 | OPTI_TYPE_EARLY_SKIP
7238 | OPTI_TYPE_NOT_ITERATED
7239 | OPTI_TYPE_NOT_SALTED
7240 | OPTI_TYPE_RAW_HASH;
7241 dgst_pos0 = 3;
7242 dgst_pos1 = 4;
7243 dgst_pos2 = 2;
7244 dgst_pos3 = 1;
7245 break;
7246
7247 case 110: hash_type = HASH_TYPE_SHA1;
7248 salt_type = SALT_TYPE_INTERN;
7249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7250 opts_type = OPTS_TYPE_PT_GENERATE_BE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS15;
7253 kern_type = KERN_TYPE_SHA1_PWSLT;
7254 dgst_size = DGST_SIZE_4_5;
7255 parse_func = sha1s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_5;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_EARLY_SKIP
7261 | OPTI_TYPE_NOT_ITERATED
7262 | OPTI_TYPE_APPENDED_SALT
7263 | OPTI_TYPE_RAW_HASH;
7264 dgst_pos0 = 3;
7265 dgst_pos1 = 4;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 1;
7268 break;
7269
7270 case 111: hash_type = HASH_TYPE_SHA1;
7271 salt_type = SALT_TYPE_EMBEDDED;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_BE
7274 | OPTS_TYPE_ST_ADD80
7275 | OPTS_TYPE_ST_ADDBITS15;
7276 kern_type = KERN_TYPE_SHA1_PWSLT;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = sha1b64s_parse_hash;
7279 sort_by_digest = sort_by_digest_4_5;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_PRECOMPUTE_INIT
7282 | OPTI_TYPE_PRECOMPUTE_MERKLE
7283 | OPTI_TYPE_EARLY_SKIP
7284 | OPTI_TYPE_NOT_ITERATED
7285 | OPTI_TYPE_APPENDED_SALT
7286 | OPTI_TYPE_RAW_HASH;
7287 dgst_pos0 = 3;
7288 dgst_pos1 = 4;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 112: hash_type = HASH_TYPE_SHA1;
7294 salt_type = SALT_TYPE_INTERN;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_BE
7297 | OPTS_TYPE_ST_ADD80
7298 | OPTS_TYPE_ST_ADDBITS15
7299 | OPTS_TYPE_ST_HEX;
7300 kern_type = KERN_TYPE_SHA1_PWSLT;
7301 dgst_size = DGST_SIZE_4_5;
7302 parse_func = oracles_parse_hash;
7303 sort_by_digest = sort_by_digest_4_5;
7304 opti_type = OPTI_TYPE_ZERO_BYTE
7305 | OPTI_TYPE_PRECOMPUTE_INIT
7306 | OPTI_TYPE_PRECOMPUTE_MERKLE
7307 | OPTI_TYPE_EARLY_SKIP
7308 | OPTI_TYPE_NOT_ITERATED
7309 | OPTI_TYPE_APPENDED_SALT
7310 | OPTI_TYPE_RAW_HASH;
7311 dgst_pos0 = 3;
7312 dgst_pos1 = 4;
7313 dgst_pos2 = 2;
7314 dgst_pos3 = 1;
7315 break;
7316
7317 case 120: hash_type = HASH_TYPE_SHA1;
7318 salt_type = SALT_TYPE_INTERN;
7319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7320 opts_type = OPTS_TYPE_PT_GENERATE_BE
7321 | OPTS_TYPE_PT_ADD80
7322 | OPTS_TYPE_PT_ADDBITS15;
7323 kern_type = KERN_TYPE_SHA1_SLTPW;
7324 dgst_size = DGST_SIZE_4_5;
7325 parse_func = sha1s_parse_hash;
7326 sort_by_digest = sort_by_digest_4_5;
7327 opti_type = OPTI_TYPE_ZERO_BYTE
7328 | OPTI_TYPE_PRECOMPUTE_INIT
7329 | OPTI_TYPE_PRECOMPUTE_MERKLE
7330 | OPTI_TYPE_EARLY_SKIP
7331 | OPTI_TYPE_NOT_ITERATED
7332 | OPTI_TYPE_PREPENDED_SALT
7333 | OPTI_TYPE_RAW_HASH;
7334 dgst_pos0 = 3;
7335 dgst_pos1 = 4;
7336 dgst_pos2 = 2;
7337 dgst_pos3 = 1;
7338 break;
7339
7340 case 121: hash_type = HASH_TYPE_SHA1;
7341 salt_type = SALT_TYPE_INTERN;
7342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7343 opts_type = OPTS_TYPE_PT_GENERATE_BE
7344 | OPTS_TYPE_PT_ADD80
7345 | OPTS_TYPE_PT_ADDBITS15
7346 | OPTS_TYPE_ST_LOWER;
7347 kern_type = KERN_TYPE_SHA1_SLTPW;
7348 dgst_size = DGST_SIZE_4_5;
7349 parse_func = smf_parse_hash;
7350 sort_by_digest = sort_by_digest_4_5;
7351 opti_type = OPTI_TYPE_ZERO_BYTE
7352 | OPTI_TYPE_PRECOMPUTE_INIT
7353 | OPTI_TYPE_PRECOMPUTE_MERKLE
7354 | OPTI_TYPE_EARLY_SKIP
7355 | OPTI_TYPE_NOT_ITERATED
7356 | OPTI_TYPE_PREPENDED_SALT
7357 | OPTI_TYPE_RAW_HASH;
7358 dgst_pos0 = 3;
7359 dgst_pos1 = 4;
7360 dgst_pos2 = 2;
7361 dgst_pos3 = 1;
7362 break;
7363
7364 case 122: hash_type = HASH_TYPE_SHA1;
7365 salt_type = SALT_TYPE_EMBEDDED;
7366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7367 opts_type = OPTS_TYPE_PT_GENERATE_BE
7368 | OPTS_TYPE_PT_ADD80
7369 | OPTS_TYPE_PT_ADDBITS15
7370 | OPTS_TYPE_ST_HEX;
7371 kern_type = KERN_TYPE_SHA1_SLTPW;
7372 dgst_size = DGST_SIZE_4_5;
7373 parse_func = osx1_parse_hash;
7374 sort_by_digest = sort_by_digest_4_5;
7375 opti_type = OPTI_TYPE_ZERO_BYTE
7376 | OPTI_TYPE_PRECOMPUTE_INIT
7377 | OPTI_TYPE_PRECOMPUTE_MERKLE
7378 | OPTI_TYPE_EARLY_SKIP
7379 | OPTI_TYPE_NOT_ITERATED
7380 | OPTI_TYPE_PREPENDED_SALT
7381 | OPTI_TYPE_RAW_HASH;
7382 dgst_pos0 = 3;
7383 dgst_pos1 = 4;
7384 dgst_pos2 = 2;
7385 dgst_pos3 = 1;
7386 break;
7387
7388 case 124: hash_type = HASH_TYPE_SHA1;
7389 salt_type = SALT_TYPE_EMBEDDED;
7390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7391 opts_type = OPTS_TYPE_PT_GENERATE_BE
7392 | OPTS_TYPE_PT_ADD80
7393 | OPTS_TYPE_PT_ADDBITS15;
7394 kern_type = KERN_TYPE_SHA1_SLTPW;
7395 dgst_size = DGST_SIZE_4_5;
7396 parse_func = djangosha1_parse_hash;
7397 sort_by_digest = sort_by_digest_4_5;
7398 opti_type = OPTI_TYPE_ZERO_BYTE
7399 | OPTI_TYPE_PRECOMPUTE_INIT
7400 | OPTI_TYPE_PRECOMPUTE_MERKLE
7401 | OPTI_TYPE_EARLY_SKIP
7402 | OPTI_TYPE_NOT_ITERATED
7403 | OPTI_TYPE_PREPENDED_SALT
7404 | OPTI_TYPE_RAW_HASH;
7405 dgst_pos0 = 3;
7406 dgst_pos1 = 4;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 130: hash_type = HASH_TYPE_SHA1;
7412 salt_type = SALT_TYPE_INTERN;
7413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7414 opts_type = OPTS_TYPE_PT_GENERATE_BE
7415 | OPTS_TYPE_PT_UNICODE
7416 | OPTS_TYPE_ST_ADD80
7417 | OPTS_TYPE_ST_ADDBITS15;
7418 kern_type = KERN_TYPE_SHA1_PWUSLT;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = sha1s_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_APPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 131: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_EMBEDDED;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_UNICODE
7440 | OPTS_TYPE_PT_UPPER
7441 | OPTS_TYPE_ST_ADD80
7442 | OPTS_TYPE_ST_ADDBITS15
7443 | OPTS_TYPE_ST_HEX;
7444 kern_type = KERN_TYPE_SHA1_PWUSLT;
7445 dgst_size = DGST_SIZE_4_5;
7446 parse_func = mssql2000_parse_hash;
7447 sort_by_digest = sort_by_digest_4_5;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 4;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 1;
7459 break;
7460
7461 case 132: hash_type = HASH_TYPE_SHA1;
7462 salt_type = SALT_TYPE_EMBEDDED;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_UNICODE
7466 | OPTS_TYPE_ST_ADD80
7467 | OPTS_TYPE_ST_ADDBITS15
7468 | OPTS_TYPE_ST_HEX;
7469 kern_type = KERN_TYPE_SHA1_PWUSLT;
7470 dgst_size = DGST_SIZE_4_5;
7471 parse_func = mssql2005_parse_hash;
7472 sort_by_digest = sort_by_digest_4_5;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_APPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 3;
7481 dgst_pos1 = 4;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 133: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_EMBEDDED;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_UNICODE
7491 | OPTS_TYPE_ST_ADD80
7492 | OPTS_TYPE_ST_ADDBITS15;
7493 kern_type = KERN_TYPE_SHA1_PWUSLT;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = peoplesoft_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_APPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 140: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_PT_ADD80
7515 | OPTS_TYPE_PT_ADDBITS15
7516 | OPTS_TYPE_PT_UNICODE;
7517 kern_type = KERN_TYPE_SHA1_SLTPWU;
7518 dgst_size = DGST_SIZE_4_5;
7519 parse_func = sha1s_parse_hash;
7520 sort_by_digest = sort_by_digest_4_5;
7521 opti_type = OPTI_TYPE_ZERO_BYTE
7522 | OPTI_TYPE_PRECOMPUTE_INIT
7523 | OPTI_TYPE_PRECOMPUTE_MERKLE
7524 | OPTI_TYPE_EARLY_SKIP
7525 | OPTI_TYPE_NOT_ITERATED
7526 | OPTI_TYPE_PREPENDED_SALT
7527 | OPTI_TYPE_RAW_HASH;
7528 dgst_pos0 = 3;
7529 dgst_pos1 = 4;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 141: hash_type = HASH_TYPE_SHA1;
7535 salt_type = SALT_TYPE_EMBEDDED;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_BE
7538 | OPTS_TYPE_PT_ADD80
7539 | OPTS_TYPE_PT_ADDBITS15
7540 | OPTS_TYPE_PT_UNICODE
7541 | OPTS_TYPE_ST_BASE64;
7542 kern_type = KERN_TYPE_SHA1_SLTPWU;
7543 dgst_size = DGST_SIZE_4_5;
7544 parse_func = episerver_parse_hash;
7545 sort_by_digest = sort_by_digest_4_5;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_PRECOMPUTE_INIT
7548 | OPTI_TYPE_PRECOMPUTE_MERKLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_PREPENDED_SALT
7552 | OPTI_TYPE_RAW_HASH;
7553 dgst_pos0 = 3;
7554 dgst_pos1 = 4;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 150: hash_type = HASH_TYPE_SHA1;
7560 salt_type = SALT_TYPE_INTERN;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_ST_ADD80
7564 | OPTS_TYPE_ST_ADDBITS15;
7565 kern_type = KERN_TYPE_HMACSHA1_PW;
7566 dgst_size = DGST_SIZE_4_5;
7567 parse_func = hmacsha1_parse_hash;
7568 sort_by_digest = sort_by_digest_4_5;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_NOT_ITERATED;
7571 dgst_pos0 = 3;
7572 dgst_pos1 = 4;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 1;
7575 break;
7576
7577 case 160: hash_type = HASH_TYPE_SHA1;
7578 salt_type = SALT_TYPE_INTERN;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_PT_ADD80
7582 | OPTS_TYPE_PT_ADDBITS15;
7583 kern_type = KERN_TYPE_HMACSHA1_SLT;
7584 dgst_size = DGST_SIZE_4_5;
7585 parse_func = hmacsha1_parse_hash;
7586 sort_by_digest = sort_by_digest_4_5;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_NOT_ITERATED;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 1;
7593 break;
7594
7595 case 190: hash_type = HASH_TYPE_SHA1;
7596 salt_type = SALT_TYPE_NONE;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_ADD80
7600 | OPTS_TYPE_PT_ADDBITS15;
7601 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7602 dgst_size = DGST_SIZE_4_5;
7603 parse_func = sha1linkedin_parse_hash;
7604 sort_by_digest = sort_by_digest_4_5;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_NOT_SALTED;
7610 dgst_pos0 = 0;
7611 dgst_pos1 = 4;
7612 dgst_pos2 = 3;
7613 dgst_pos3 = 2;
7614 break;
7615
7616 case 200: hash_type = HASH_TYPE_MYSQL;
7617 salt_type = SALT_TYPE_NONE;
7618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7619 opts_type = 0;
7620 kern_type = KERN_TYPE_MYSQL;
7621 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7622 parse_func = mysql323_parse_hash;
7623 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7624 opti_type = OPTI_TYPE_ZERO_BYTE;
7625 dgst_pos0 = 0;
7626 dgst_pos1 = 1;
7627 dgst_pos2 = 2;
7628 dgst_pos3 = 3;
7629 break;
7630
7631 case 300: hash_type = HASH_TYPE_SHA1;
7632 salt_type = SALT_TYPE_NONE;
7633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7634 opts_type = OPTS_TYPE_PT_GENERATE_BE
7635 | OPTS_TYPE_PT_ADD80
7636 | OPTS_TYPE_PT_ADDBITS15;
7637 kern_type = KERN_TYPE_MYSQL41;
7638 dgst_size = DGST_SIZE_4_5;
7639 parse_func = sha1_parse_hash;
7640 sort_by_digest = sort_by_digest_4_5;
7641 opti_type = OPTI_TYPE_ZERO_BYTE
7642 | OPTI_TYPE_PRECOMPUTE_INIT
7643 | OPTI_TYPE_PRECOMPUTE_MERKLE
7644 | OPTI_TYPE_EARLY_SKIP
7645 | OPTI_TYPE_NOT_ITERATED
7646 | OPTI_TYPE_NOT_SALTED;
7647 dgst_pos0 = 3;
7648 dgst_pos1 = 4;
7649 dgst_pos2 = 2;
7650 dgst_pos3 = 1;
7651 break;
7652
7653 case 400: hash_type = HASH_TYPE_MD5;
7654 salt_type = SALT_TYPE_EMBEDDED;
7655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7657 kern_type = KERN_TYPE_PHPASS;
7658 dgst_size = DGST_SIZE_4_4;
7659 parse_func = phpass_parse_hash;
7660 sort_by_digest = sort_by_digest_4_4;
7661 opti_type = OPTI_TYPE_ZERO_BYTE;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 1;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 3;
7666 break;
7667
7668 case 500: hash_type = HASH_TYPE_MD5;
7669 salt_type = SALT_TYPE_EMBEDDED;
7670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7672 kern_type = KERN_TYPE_MD5CRYPT;
7673 dgst_size = DGST_SIZE_4_4;
7674 parse_func = md5crypt_parse_hash;
7675 sort_by_digest = sort_by_digest_4_4;
7676 opti_type = OPTI_TYPE_ZERO_BYTE;
7677 dgst_pos0 = 0;
7678 dgst_pos1 = 1;
7679 dgst_pos2 = 2;
7680 dgst_pos3 = 3;
7681 break;
7682
7683 case 501: hash_type = HASH_TYPE_MD5;
7684 salt_type = SALT_TYPE_EMBEDDED;
7685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7686 opts_type = OPTS_TYPE_PT_GENERATE_LE
7687 | OPTS_TYPE_HASH_COPY;
7688 kern_type = KERN_TYPE_MD5CRYPT;
7689 dgst_size = DGST_SIZE_4_4;
7690 parse_func = juniper_parse_hash;
7691 sort_by_digest = sort_by_digest_4_4;
7692 opti_type = OPTI_TYPE_ZERO_BYTE;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 1;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 3;
7697 break;
7698
7699 case 900: hash_type = HASH_TYPE_MD4;
7700 salt_type = SALT_TYPE_NONE;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_LE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS14;
7705 kern_type = KERN_TYPE_MD4;
7706 dgst_size = DGST_SIZE_4_4;
7707 parse_func = md4_parse_hash;
7708 sort_by_digest = sort_by_digest_4_4;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_PRECOMPUTE_INIT
7711 | OPTI_TYPE_PRECOMPUTE_MERKLE
7712 | OPTI_TYPE_MEET_IN_MIDDLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_NOT_SALTED
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 0;
7718 dgst_pos1 = 3;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 1;
7721 break;
7722
7723 case 1000: hash_type = HASH_TYPE_MD4;
7724 salt_type = SALT_TYPE_NONE;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_LE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS14
7729 | OPTS_TYPE_PT_UNICODE;
7730 kern_type = KERN_TYPE_MD4_PWU;
7731 dgst_size = DGST_SIZE_4_4;
7732 parse_func = md4_parse_hash;
7733 sort_by_digest = sort_by_digest_4_4;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_PRECOMPUTE_MERKLE
7737 | OPTI_TYPE_MEET_IN_MIDDLE
7738 | OPTI_TYPE_EARLY_SKIP
7739 | OPTI_TYPE_NOT_ITERATED
7740 | OPTI_TYPE_NOT_SALTED
7741 | OPTI_TYPE_RAW_HASH;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 3;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 1;
7746 break;
7747
7748 case 1100: hash_type = HASH_TYPE_MD4;
7749 salt_type = SALT_TYPE_INTERN;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_LE
7752 | OPTS_TYPE_PT_ADD80
7753 | OPTS_TYPE_PT_ADDBITS14
7754 | OPTS_TYPE_PT_UNICODE
7755 | OPTS_TYPE_ST_ADD80
7756 | OPTS_TYPE_ST_UNICODE
7757 | OPTS_TYPE_ST_LOWER;
7758 kern_type = KERN_TYPE_MD44_PWUSLT;
7759 dgst_size = DGST_SIZE_4_4;
7760 parse_func = dcc_parse_hash;
7761 sort_by_digest = sort_by_digest_4_4;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_PRECOMPUTE_INIT
7764 | OPTI_TYPE_PRECOMPUTE_MERKLE
7765 | OPTI_TYPE_EARLY_SKIP
7766 | OPTI_TYPE_NOT_ITERATED;
7767 dgst_pos0 = 0;
7768 dgst_pos1 = 3;
7769 dgst_pos2 = 2;
7770 dgst_pos3 = 1;
7771 break;
7772
7773 case 1400: hash_type = HASH_TYPE_SHA256;
7774 salt_type = SALT_TYPE_NONE;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_PT_ADD80
7778 | OPTS_TYPE_PT_ADDBITS15;
7779 kern_type = KERN_TYPE_SHA256;
7780 dgst_size = DGST_SIZE_4_8;
7781 parse_func = sha256_parse_hash;
7782 sort_by_digest = sort_by_digest_4_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_NOT_SALTED
7789 | OPTI_TYPE_RAW_HASH;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 7;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 6;
7794 break;
7795
7796 case 1410: hash_type = HASH_TYPE_SHA256;
7797 salt_type = SALT_TYPE_INTERN;
7798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_BE
7800 | OPTS_TYPE_ST_ADD80
7801 | OPTS_TYPE_ST_ADDBITS15;
7802 kern_type = KERN_TYPE_SHA256_PWSLT;
7803 dgst_size = DGST_SIZE_4_8;
7804 parse_func = sha256s_parse_hash;
7805 sort_by_digest = sort_by_digest_4_8;
7806 opti_type = OPTI_TYPE_ZERO_BYTE
7807 | OPTI_TYPE_PRECOMPUTE_INIT
7808 | OPTI_TYPE_PRECOMPUTE_MERKLE
7809 | OPTI_TYPE_EARLY_SKIP
7810 | OPTI_TYPE_NOT_ITERATED
7811 | OPTI_TYPE_APPENDED_SALT
7812 | OPTI_TYPE_RAW_HASH;
7813 dgst_pos0 = 3;
7814 dgst_pos1 = 7;
7815 dgst_pos2 = 2;
7816 dgst_pos3 = 6;
7817 break;
7818
7819 case 1420: hash_type = HASH_TYPE_SHA256;
7820 salt_type = SALT_TYPE_INTERN;
7821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7822 opts_type = OPTS_TYPE_PT_GENERATE_BE
7823 | OPTS_TYPE_PT_ADD80
7824 | OPTS_TYPE_PT_ADDBITS15;
7825 kern_type = KERN_TYPE_SHA256_SLTPW;
7826 dgst_size = DGST_SIZE_4_8;
7827 parse_func = sha256s_parse_hash;
7828 sort_by_digest = sort_by_digest_4_8;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_PRECOMPUTE_INIT
7831 | OPTI_TYPE_PRECOMPUTE_MERKLE
7832 | OPTI_TYPE_EARLY_SKIP
7833 | OPTI_TYPE_NOT_ITERATED
7834 | OPTI_TYPE_PREPENDED_SALT
7835 | OPTI_TYPE_RAW_HASH;
7836 dgst_pos0 = 3;
7837 dgst_pos1 = 7;
7838 dgst_pos2 = 2;
7839 dgst_pos3 = 6;
7840 break;
7841
7842 case 1421: hash_type = HASH_TYPE_SHA256;
7843 salt_type = SALT_TYPE_EMBEDDED;
7844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7845 opts_type = OPTS_TYPE_PT_GENERATE_BE
7846 | OPTS_TYPE_PT_ADD80
7847 | OPTS_TYPE_PT_ADDBITS15;
7848 kern_type = KERN_TYPE_SHA256_SLTPW;
7849 dgst_size = DGST_SIZE_4_8;
7850 parse_func = hmailserver_parse_hash;
7851 sort_by_digest = sort_by_digest_4_8;
7852 opti_type = OPTI_TYPE_ZERO_BYTE
7853 | OPTI_TYPE_PRECOMPUTE_INIT
7854 | OPTI_TYPE_PRECOMPUTE_MERKLE
7855 | OPTI_TYPE_EARLY_SKIP
7856 | OPTI_TYPE_NOT_ITERATED
7857 | OPTI_TYPE_PREPENDED_SALT
7858 | OPTI_TYPE_RAW_HASH;
7859 dgst_pos0 = 3;
7860 dgst_pos1 = 7;
7861 dgst_pos2 = 2;
7862 dgst_pos3 = 6;
7863 break;
7864
7865 case 1430: hash_type = HASH_TYPE_SHA256;
7866 salt_type = SALT_TYPE_INTERN;
7867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7868 opts_type = OPTS_TYPE_PT_GENERATE_BE
7869 | OPTS_TYPE_PT_UNICODE
7870 | OPTS_TYPE_ST_ADD80
7871 | OPTS_TYPE_ST_ADDBITS15;
7872 kern_type = KERN_TYPE_SHA256_PWUSLT;
7873 dgst_size = DGST_SIZE_4_8;
7874 parse_func = sha256s_parse_hash;
7875 sort_by_digest = sort_by_digest_4_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE
7877 | OPTI_TYPE_PRECOMPUTE_INIT
7878 | OPTI_TYPE_PRECOMPUTE_MERKLE
7879 | OPTI_TYPE_EARLY_SKIP
7880 | OPTI_TYPE_NOT_ITERATED
7881 | OPTI_TYPE_APPENDED_SALT
7882 | OPTI_TYPE_RAW_HASH;
7883 dgst_pos0 = 3;
7884 dgst_pos1 = 7;
7885 dgst_pos2 = 2;
7886 dgst_pos3 = 6;
7887 break;
7888
7889 case 1440: hash_type = HASH_TYPE_SHA256;
7890 salt_type = SALT_TYPE_INTERN;
7891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7892 opts_type = OPTS_TYPE_PT_GENERATE_BE
7893 | OPTS_TYPE_PT_ADD80
7894 | OPTS_TYPE_PT_ADDBITS15
7895 | OPTS_TYPE_PT_UNICODE;
7896 kern_type = KERN_TYPE_SHA256_SLTPWU;
7897 dgst_size = DGST_SIZE_4_8;
7898 parse_func = sha256s_parse_hash;
7899 sort_by_digest = sort_by_digest_4_8;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP
7904 | OPTI_TYPE_NOT_ITERATED
7905 | OPTI_TYPE_PREPENDED_SALT
7906 | OPTI_TYPE_RAW_HASH;
7907 dgst_pos0 = 3;
7908 dgst_pos1 = 7;
7909 dgst_pos2 = 2;
7910 dgst_pos3 = 6;
7911 break;
7912
7913 case 1441: hash_type = HASH_TYPE_SHA256;
7914 salt_type = SALT_TYPE_EMBEDDED;
7915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_BE
7917 | OPTS_TYPE_PT_ADD80
7918 | OPTS_TYPE_PT_ADDBITS15
7919 | OPTS_TYPE_PT_UNICODE
7920 | OPTS_TYPE_ST_BASE64;
7921 kern_type = KERN_TYPE_SHA256_SLTPWU;
7922 dgst_size = DGST_SIZE_4_8;
7923 parse_func = episerver4_parse_hash;
7924 sort_by_digest = sort_by_digest_4_8;
7925 opti_type = OPTI_TYPE_ZERO_BYTE
7926 | OPTI_TYPE_PRECOMPUTE_INIT
7927 | OPTI_TYPE_PRECOMPUTE_MERKLE
7928 | OPTI_TYPE_EARLY_SKIP
7929 | OPTI_TYPE_NOT_ITERATED
7930 | OPTI_TYPE_PREPENDED_SALT
7931 | OPTI_TYPE_RAW_HASH;
7932 dgst_pos0 = 3;
7933 dgst_pos1 = 7;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 6;
7936 break;
7937
7938 case 1450: hash_type = HASH_TYPE_SHA256;
7939 salt_type = SALT_TYPE_INTERN;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_BE
7942 | OPTS_TYPE_ST_ADD80;
7943 kern_type = KERN_TYPE_HMACSHA256_PW;
7944 dgst_size = DGST_SIZE_4_8;
7945 parse_func = hmacsha256_parse_hash;
7946 sort_by_digest = sort_by_digest_4_8;
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_NOT_ITERATED;
7949 dgst_pos0 = 3;
7950 dgst_pos1 = 7;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 6;
7953 break;
7954
7955 case 1460: hash_type = HASH_TYPE_SHA256;
7956 salt_type = SALT_TYPE_INTERN;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_PT_ADD80
7960 | OPTS_TYPE_PT_ADDBITS15;
7961 kern_type = KERN_TYPE_HMACSHA256_SLT;
7962 dgst_size = DGST_SIZE_4_8;
7963 parse_func = hmacsha256_parse_hash;
7964 sort_by_digest = sort_by_digest_4_8;
7965 opti_type = OPTI_TYPE_ZERO_BYTE
7966 | OPTI_TYPE_NOT_ITERATED;
7967 dgst_pos0 = 3;
7968 dgst_pos1 = 7;
7969 dgst_pos2 = 2;
7970 dgst_pos3 = 6;
7971 break;
7972
7973 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7974 salt_type = SALT_TYPE_EMBEDDED;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_LE
7977 | OPTS_TYPE_PT_BITSLICE;
7978 kern_type = KERN_TYPE_DESCRYPT;
7979 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7980 parse_func = descrypt_parse_hash;
7981 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7984 dgst_pos0 = 0;
7985 dgst_pos1 = 1;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 3;
7988 break;
7989
7990 case 1600: hash_type = HASH_TYPE_MD5;
7991 salt_type = SALT_TYPE_EMBEDDED;
7992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7994 kern_type = KERN_TYPE_APR1CRYPT;
7995 dgst_size = DGST_SIZE_4_4;
7996 parse_func = md5apr1_parse_hash;
7997 sort_by_digest = sort_by_digest_4_4;
7998 opti_type = OPTI_TYPE_ZERO_BYTE;
7999 dgst_pos0 = 0;
8000 dgst_pos1 = 1;
8001 dgst_pos2 = 2;
8002 dgst_pos3 = 3;
8003 break;
8004
8005 case 1700: hash_type = HASH_TYPE_SHA512;
8006 salt_type = SALT_TYPE_NONE;
8007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8008 opts_type = OPTS_TYPE_PT_GENERATE_BE
8009 | OPTS_TYPE_PT_ADD80
8010 | OPTS_TYPE_PT_ADDBITS15;
8011 kern_type = KERN_TYPE_SHA512;
8012 dgst_size = DGST_SIZE_8_8;
8013 parse_func = sha512_parse_hash;
8014 sort_by_digest = sort_by_digest_8_8;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP
8019 | OPTI_TYPE_NOT_ITERATED
8020 | OPTI_TYPE_NOT_SALTED
8021 | OPTI_TYPE_USES_BITS_64
8022 | OPTI_TYPE_RAW_HASH;
8023 dgst_pos0 = 14;
8024 dgst_pos1 = 15;
8025 dgst_pos2 = 6;
8026 dgst_pos3 = 7;
8027 break;
8028
8029 case 1710: hash_type = HASH_TYPE_SHA512;
8030 salt_type = SALT_TYPE_INTERN;
8031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8032 opts_type = OPTS_TYPE_PT_GENERATE_BE
8033 | OPTS_TYPE_ST_ADD80
8034 | OPTS_TYPE_ST_ADDBITS15;
8035 kern_type = KERN_TYPE_SHA512_PWSLT;
8036 dgst_size = DGST_SIZE_8_8;
8037 parse_func = sha512s_parse_hash;
8038 sort_by_digest = sort_by_digest_8_8;
8039 opti_type = OPTI_TYPE_ZERO_BYTE
8040 | OPTI_TYPE_PRECOMPUTE_INIT
8041 | OPTI_TYPE_PRECOMPUTE_MERKLE
8042 | OPTI_TYPE_EARLY_SKIP
8043 | OPTI_TYPE_NOT_ITERATED
8044 | OPTI_TYPE_APPENDED_SALT
8045 | OPTI_TYPE_USES_BITS_64
8046 | OPTI_TYPE_RAW_HASH;
8047 dgst_pos0 = 14;
8048 dgst_pos1 = 15;
8049 dgst_pos2 = 6;
8050 dgst_pos3 = 7;
8051 break;
8052
8053 case 1711: hash_type = HASH_TYPE_SHA512;
8054 salt_type = SALT_TYPE_EMBEDDED;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_BE
8057 | OPTS_TYPE_ST_ADD80
8058 | OPTS_TYPE_ST_ADDBITS15;
8059 kern_type = KERN_TYPE_SHA512_PWSLT;
8060 dgst_size = DGST_SIZE_8_8;
8061 parse_func = sha512b64s_parse_hash;
8062 sort_by_digest = sort_by_digest_8_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_PRECOMPUTE_INIT
8065 | OPTI_TYPE_PRECOMPUTE_MERKLE
8066 | OPTI_TYPE_EARLY_SKIP
8067 | OPTI_TYPE_NOT_ITERATED
8068 | OPTI_TYPE_APPENDED_SALT
8069 | OPTI_TYPE_USES_BITS_64
8070 | OPTI_TYPE_RAW_HASH;
8071 dgst_pos0 = 14;
8072 dgst_pos1 = 15;
8073 dgst_pos2 = 6;
8074 dgst_pos3 = 7;
8075 break;
8076
8077 case 1720: hash_type = HASH_TYPE_SHA512;
8078 salt_type = SALT_TYPE_INTERN;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_BE
8081 | OPTS_TYPE_PT_ADD80
8082 | OPTS_TYPE_PT_ADDBITS15;
8083 kern_type = KERN_TYPE_SHA512_SLTPW;
8084 dgst_size = DGST_SIZE_8_8;
8085 parse_func = sha512s_parse_hash;
8086 sort_by_digest = sort_by_digest_8_8;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP
8091 | OPTI_TYPE_NOT_ITERATED
8092 | OPTI_TYPE_PREPENDED_SALT
8093 | OPTI_TYPE_USES_BITS_64
8094 | OPTI_TYPE_RAW_HASH;
8095 dgst_pos0 = 14;
8096 dgst_pos1 = 15;
8097 dgst_pos2 = 6;
8098 dgst_pos3 = 7;
8099 break;
8100
8101 case 1722: hash_type = HASH_TYPE_SHA512;
8102 salt_type = SALT_TYPE_EMBEDDED;
8103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_PT_ADD80
8106 | OPTS_TYPE_PT_ADDBITS15
8107 | OPTS_TYPE_ST_HEX;
8108 kern_type = KERN_TYPE_SHA512_SLTPW;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = osx512_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_INIT
8114 | OPTI_TYPE_PRECOMPUTE_MERKLE
8115 | OPTI_TYPE_EARLY_SKIP
8116 | OPTI_TYPE_NOT_ITERATED
8117 | OPTI_TYPE_PREPENDED_SALT
8118 | OPTI_TYPE_USES_BITS_64
8119 | OPTI_TYPE_RAW_HASH;
8120 dgst_pos0 = 14;
8121 dgst_pos1 = 15;
8122 dgst_pos2 = 6;
8123 dgst_pos3 = 7;
8124 break;
8125
8126 case 1730: hash_type = HASH_TYPE_SHA512;
8127 salt_type = SALT_TYPE_INTERN;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_BE
8130 | OPTS_TYPE_PT_UNICODE
8131 | OPTS_TYPE_ST_ADD80
8132 | OPTS_TYPE_ST_ADDBITS15;
8133 kern_type = KERN_TYPE_SHA512_PWSLTU;
8134 dgst_size = DGST_SIZE_8_8;
8135 parse_func = sha512s_parse_hash;
8136 sort_by_digest = sort_by_digest_8_8;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_INIT
8139 | OPTI_TYPE_PRECOMPUTE_MERKLE
8140 | OPTI_TYPE_EARLY_SKIP
8141 | OPTI_TYPE_NOT_ITERATED
8142 | OPTI_TYPE_APPENDED_SALT
8143 | OPTI_TYPE_USES_BITS_64
8144 | OPTI_TYPE_RAW_HASH;
8145 dgst_pos0 = 14;
8146 dgst_pos1 = 15;
8147 dgst_pos2 = 6;
8148 dgst_pos3 = 7;
8149 break;
8150
8151 case 1731: hash_type = HASH_TYPE_SHA512;
8152 salt_type = SALT_TYPE_EMBEDDED;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_BE
8155 | OPTS_TYPE_PT_UNICODE
8156 | OPTS_TYPE_ST_ADD80
8157 | OPTS_TYPE_ST_ADDBITS15
8158 | OPTS_TYPE_ST_HEX;
8159 kern_type = KERN_TYPE_SHA512_PWSLTU;
8160 dgst_size = DGST_SIZE_8_8;
8161 parse_func = mssql2012_parse_hash;
8162 sort_by_digest = sort_by_digest_8_8;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_PRECOMPUTE_INIT
8165 | OPTI_TYPE_PRECOMPUTE_MERKLE
8166 | OPTI_TYPE_EARLY_SKIP
8167 | OPTI_TYPE_NOT_ITERATED
8168 | OPTI_TYPE_APPENDED_SALT
8169 | OPTI_TYPE_USES_BITS_64
8170 | OPTI_TYPE_RAW_HASH;
8171 dgst_pos0 = 14;
8172 dgst_pos1 = 15;
8173 dgst_pos2 = 6;
8174 dgst_pos3 = 7;
8175 break;
8176
8177 case 1740: hash_type = HASH_TYPE_SHA512;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_PT_ADD80
8182 | OPTS_TYPE_PT_ADDBITS15
8183 | OPTS_TYPE_PT_UNICODE;
8184 kern_type = KERN_TYPE_SHA512_SLTPWU;
8185 dgst_size = DGST_SIZE_8_8;
8186 parse_func = sha512s_parse_hash;
8187 sort_by_digest = sort_by_digest_8_8;
8188 opti_type = OPTI_TYPE_ZERO_BYTE
8189 | OPTI_TYPE_PRECOMPUTE_INIT
8190 | OPTI_TYPE_PRECOMPUTE_MERKLE
8191 | OPTI_TYPE_EARLY_SKIP
8192 | OPTI_TYPE_NOT_ITERATED
8193 | OPTI_TYPE_PREPENDED_SALT
8194 | OPTI_TYPE_USES_BITS_64
8195 | OPTI_TYPE_RAW_HASH;
8196 dgst_pos0 = 14;
8197 dgst_pos1 = 15;
8198 dgst_pos2 = 6;
8199 dgst_pos3 = 7;
8200 break;
8201
8202 case 1750: hash_type = HASH_TYPE_SHA512;
8203 salt_type = SALT_TYPE_INTERN;
8204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8205 opts_type = OPTS_TYPE_PT_GENERATE_BE
8206 | OPTS_TYPE_ST_ADD80;
8207 kern_type = KERN_TYPE_HMACSHA512_PW;
8208 dgst_size = DGST_SIZE_8_8;
8209 parse_func = hmacsha512_parse_hash;
8210 sort_by_digest = sort_by_digest_8_8;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_USES_BITS_64
8213 | OPTI_TYPE_NOT_ITERATED;
8214 dgst_pos0 = 14;
8215 dgst_pos1 = 15;
8216 dgst_pos2 = 6;
8217 dgst_pos3 = 7;
8218 break;
8219
8220 case 1760: hash_type = HASH_TYPE_SHA512;
8221 salt_type = SALT_TYPE_INTERN;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_BE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS15;
8226 kern_type = KERN_TYPE_HMACSHA512_SLT;
8227 dgst_size = DGST_SIZE_8_8;
8228 parse_func = hmacsha512_parse_hash;
8229 sort_by_digest = sort_by_digest_8_8;
8230 opti_type = OPTI_TYPE_ZERO_BYTE
8231 | OPTI_TYPE_USES_BITS_64
8232 | OPTI_TYPE_NOT_ITERATED;
8233 dgst_pos0 = 14;
8234 dgst_pos1 = 15;
8235 dgst_pos2 = 6;
8236 dgst_pos3 = 7;
8237 break;
8238
8239 case 1800: hash_type = HASH_TYPE_SHA512;
8240 salt_type = SALT_TYPE_EMBEDDED;
8241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8243 kern_type = KERN_TYPE_SHA512CRYPT;
8244 dgst_size = DGST_SIZE_8_8;
8245 parse_func = sha512crypt_parse_hash;
8246 sort_by_digest = sort_by_digest_8_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_USES_BITS_64;
8249 dgst_pos0 = 0;
8250 dgst_pos1 = 1;
8251 dgst_pos2 = 2;
8252 dgst_pos3 = 3;
8253 break;
8254
8255 case 2100: hash_type = HASH_TYPE_DCC2;
8256 salt_type = SALT_TYPE_EMBEDDED;
8257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8258 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8259 | OPTS_TYPE_ST_LOWER
8260 | OPTS_TYPE_ST_UNICODE;
8261 kern_type = KERN_TYPE_DCC2;
8262 dgst_size = DGST_SIZE_4_4;
8263 parse_func = dcc2_parse_hash;
8264 sort_by_digest = sort_by_digest_4_4;
8265 opti_type = OPTI_TYPE_ZERO_BYTE;
8266 dgst_pos0 = 0;
8267 dgst_pos1 = 1;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 3;
8270 break;
8271
8272 case 2400: hash_type = HASH_TYPE_MD5;
8273 salt_type = SALT_TYPE_NONE;
8274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8276 kern_type = KERN_TYPE_MD5PIX;
8277 dgst_size = DGST_SIZE_4_4;
8278 parse_func = md5pix_parse_hash;
8279 sort_by_digest = sort_by_digest_4_4;
8280 opti_type = OPTI_TYPE_ZERO_BYTE
8281 | OPTI_TYPE_PRECOMPUTE_INIT
8282 | OPTI_TYPE_PRECOMPUTE_MERKLE
8283 | OPTI_TYPE_EARLY_SKIP
8284 | OPTI_TYPE_NOT_ITERATED
8285 | OPTI_TYPE_NOT_SALTED;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2410: hash_type = HASH_TYPE_MD5;
8293 salt_type = SALT_TYPE_INTERN;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8296 kern_type = KERN_TYPE_MD5ASA;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = md5asa_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_PRECOMPUTE_INIT
8302 | OPTI_TYPE_PRECOMPUTE_MERKLE
8303 | OPTI_TYPE_EARLY_SKIP
8304 | OPTI_TYPE_NOT_ITERATED;
8305 dgst_pos0 = 0;
8306 dgst_pos1 = 3;
8307 dgst_pos2 = 2;
8308 dgst_pos3 = 1;
8309 break;
8310
8311 case 2500: hash_type = HASH_TYPE_WPA;
8312 salt_type = SALT_TYPE_EMBEDDED;
8313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8315 kern_type = KERN_TYPE_WPA;
8316 dgst_size = DGST_SIZE_4_4;
8317 parse_func = wpa_parse_hash;
8318 sort_by_digest = sort_by_digest_4_4;
8319 opti_type = OPTI_TYPE_ZERO_BYTE;
8320 dgst_pos0 = 0;
8321 dgst_pos1 = 1;
8322 dgst_pos2 = 2;
8323 dgst_pos3 = 3;
8324 break;
8325
8326 case 2600: hash_type = HASH_TYPE_MD5;
8327 salt_type = SALT_TYPE_VIRTUAL;
8328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8329 opts_type = OPTS_TYPE_PT_GENERATE_LE
8330 | OPTS_TYPE_PT_ADD80
8331 | OPTS_TYPE_PT_ADDBITS14
8332 | OPTS_TYPE_ST_ADD80;
8333 kern_type = KERN_TYPE_MD55_PWSLT1;
8334 dgst_size = DGST_SIZE_4_4;
8335 parse_func = md5md5_parse_hash;
8336 sort_by_digest = sort_by_digest_4_4;
8337 opti_type = OPTI_TYPE_ZERO_BYTE
8338 | OPTI_TYPE_PRECOMPUTE_INIT
8339 | OPTI_TYPE_PRECOMPUTE_MERKLE
8340 | OPTI_TYPE_EARLY_SKIP;
8341 dgst_pos0 = 0;
8342 dgst_pos1 = 3;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 1;
8345 break;
8346
8347 case 2611: hash_type = HASH_TYPE_MD5;
8348 salt_type = SALT_TYPE_INTERN;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_LE
8351 | OPTS_TYPE_PT_ADD80
8352 | OPTS_TYPE_PT_ADDBITS14
8353 | OPTS_TYPE_ST_ADD80;
8354 kern_type = KERN_TYPE_MD55_PWSLT1;
8355 dgst_size = DGST_SIZE_4_4;
8356 parse_func = vb3_parse_hash;
8357 sort_by_digest = sort_by_digest_4_4;
8358 opti_type = OPTI_TYPE_ZERO_BYTE
8359 | OPTI_TYPE_PRECOMPUTE_INIT
8360 | OPTI_TYPE_PRECOMPUTE_MERKLE
8361 | OPTI_TYPE_EARLY_SKIP;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 3;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 1;
8366 break;
8367
8368 case 2612: hash_type = HASH_TYPE_MD5;
8369 salt_type = SALT_TYPE_EMBEDDED;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_ADD80
8373 | OPTS_TYPE_PT_ADDBITS14
8374 | OPTS_TYPE_ST_ADD80
8375 | OPTS_TYPE_ST_HEX;
8376 kern_type = KERN_TYPE_MD55_PWSLT1;
8377 dgst_size = DGST_SIZE_4_4;
8378 parse_func = phps_parse_hash;
8379 sort_by_digest = sort_by_digest_4_4;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_PRECOMPUTE_INIT
8382 | OPTI_TYPE_PRECOMPUTE_MERKLE
8383 | OPTI_TYPE_EARLY_SKIP;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 3;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 1;
8388 break;
8389
8390 case 2711: hash_type = HASH_TYPE_MD5;
8391 salt_type = SALT_TYPE_INTERN;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80
8395 | OPTS_TYPE_PT_ADDBITS14
8396 | OPTS_TYPE_ST_ADD80;
8397 kern_type = KERN_TYPE_MD55_PWSLT2;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = vb30_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE
8402 | OPTI_TYPE_PRECOMPUTE_INIT
8403 | OPTI_TYPE_EARLY_SKIP;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 3;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 1;
8408 break;
8409
8410 case 2811: hash_type = HASH_TYPE_MD5;
8411 salt_type = SALT_TYPE_INTERN;
8412 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE
8414 | OPTS_TYPE_PT_ADD80
8415 | OPTS_TYPE_PT_ADDBITS14;
8416 kern_type = KERN_TYPE_MD55_SLTPW;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = ipb2_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_PRECOMPUTE_INIT
8422 | OPTI_TYPE_EARLY_SKIP;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 3;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 1;
8427 break;
8428
8429 case 3000: hash_type = HASH_TYPE_LM;
8430 salt_type = SALT_TYPE_NONE;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE
8433 | OPTS_TYPE_PT_UPPER
8434 | OPTS_TYPE_PT_BITSLICE;
8435 kern_type = KERN_TYPE_LM;
8436 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8437 parse_func = lm_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 1;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 3;
8445 break;
8446
8447 case 3100: hash_type = HASH_TYPE_ORACLEH;
8448 salt_type = SALT_TYPE_INTERN;
8449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE
8451 | OPTS_TYPE_PT_UPPER
8452 | OPTS_TYPE_ST_UPPER;
8453 kern_type = KERN_TYPE_ORACLEH;
8454 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8455 parse_func = oracleh_parse_hash;
8456 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8457 opti_type = OPTI_TYPE_ZERO_BYTE;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 3200: hash_type = HASH_TYPE_BCRYPT;
8465 salt_type = SALT_TYPE_EMBEDDED;
8466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_ST_GENERATE_LE;
8469 kern_type = KERN_TYPE_BCRYPT;
8470 dgst_size = DGST_SIZE_4_6;
8471 parse_func = bcrypt_parse_hash;
8472 sort_by_digest = sort_by_digest_4_6;
8473 opti_type = OPTI_TYPE_ZERO_BYTE;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 1;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 3;
8478 break;
8479
8480 case 3710: hash_type = HASH_TYPE_MD5;
8481 salt_type = SALT_TYPE_INTERN;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_LE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS14;
8486 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8487 dgst_size = DGST_SIZE_4_4;
8488 parse_func = md5s_parse_hash;
8489 sort_by_digest = sort_by_digest_4_4;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 3;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 1;
8498 break;
8499
8500 case 3711: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE
8504 | OPTS_TYPE_PT_ADD80
8505 | OPTS_TYPE_PT_ADDBITS14;
8506 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8507 dgst_size = DGST_SIZE_4_4;
8508 parse_func = mediawiki_b_parse_hash;
8509 sort_by_digest = sort_by_digest_4_4;
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_INIT
8512 | OPTI_TYPE_PRECOMPUTE_MERKLE
8513 | OPTI_TYPE_EARLY_SKIP;
8514 dgst_pos0 = 0;
8515 dgst_pos1 = 3;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 1;
8518 break;
8519
8520 case 3800: hash_type = HASH_TYPE_MD5;
8521 salt_type = SALT_TYPE_INTERN;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_LE
8524 | OPTS_TYPE_ST_ADDBITS14;
8525 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8526 dgst_size = DGST_SIZE_4_4;
8527 parse_func = md5s_parse_hash;
8528 sort_by_digest = sort_by_digest_4_4;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP
8533 | OPTI_TYPE_NOT_ITERATED
8534 | OPTI_TYPE_RAW_HASH;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 3;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 1;
8539 break;
8540
8541 case 4300: hash_type = HASH_TYPE_MD5;
8542 salt_type = SALT_TYPE_VIRTUAL;
8543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE
8545 | OPTS_TYPE_PT_ADD80
8546 | OPTS_TYPE_PT_ADDBITS14
8547 | OPTS_TYPE_ST_ADD80;
8548 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8549 dgst_size = DGST_SIZE_4_4;
8550 parse_func = md5md5_parse_hash;
8551 sort_by_digest = sort_by_digest_4_4;
8552 opti_type = OPTI_TYPE_ZERO_BYTE
8553 | OPTI_TYPE_PRECOMPUTE_INIT
8554 | OPTI_TYPE_PRECOMPUTE_MERKLE
8555 | OPTI_TYPE_EARLY_SKIP;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 3;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 1;
8560 break;
8561
8562
8563 case 4400: hash_type = HASH_TYPE_MD5;
8564 salt_type = SALT_TYPE_NONE;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_BE
8567 | OPTS_TYPE_PT_ADD80
8568 | OPTS_TYPE_PT_ADDBITS15;
8569 kern_type = KERN_TYPE_MD5_SHA1;
8570 dgst_size = DGST_SIZE_4_4;
8571 parse_func = md5_parse_hash;
8572 sort_by_digest = sort_by_digest_4_4;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_NOT_SALTED
8579 | OPTI_TYPE_RAW_HASH;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 3;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 1;
8584 break;
8585
8586 case 4500: hash_type = HASH_TYPE_SHA1;
8587 salt_type = SALT_TYPE_NONE;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_BE
8590 | OPTS_TYPE_PT_ADD80
8591 | OPTS_TYPE_PT_ADDBITS15;
8592 kern_type = KERN_TYPE_SHA11;
8593 dgst_size = DGST_SIZE_4_5;
8594 parse_func = sha1_parse_hash;
8595 sort_by_digest = sort_by_digest_4_5;
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_INIT
8598 | OPTI_TYPE_PRECOMPUTE_MERKLE
8599 | OPTI_TYPE_EARLY_SKIP
8600 | OPTI_TYPE_NOT_SALTED;
8601 dgst_pos0 = 3;
8602 dgst_pos1 = 4;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 1;
8605 break;
8606
8607 case 4700: hash_type = HASH_TYPE_SHA1;
8608 salt_type = SALT_TYPE_NONE;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE
8611 | OPTS_TYPE_PT_ADD80
8612 | OPTS_TYPE_PT_ADDBITS14;
8613 kern_type = KERN_TYPE_SHA1_MD5;
8614 dgst_size = DGST_SIZE_4_5;
8615 parse_func = sha1_parse_hash;
8616 sort_by_digest = sort_by_digest_4_5;
8617 opti_type = OPTI_TYPE_ZERO_BYTE
8618 | OPTI_TYPE_PRECOMPUTE_INIT
8619 | OPTI_TYPE_PRECOMPUTE_MERKLE
8620 | OPTI_TYPE_EARLY_SKIP
8621 | OPTI_TYPE_NOT_ITERATED
8622 | OPTI_TYPE_NOT_SALTED
8623 | OPTI_TYPE_RAW_HASH;
8624 dgst_pos0 = 3;
8625 dgst_pos1 = 4;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 1;
8628 break;
8629
8630 case 4800: hash_type = HASH_TYPE_MD5;
8631 salt_type = SALT_TYPE_EMBEDDED;
8632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE
8634 | OPTS_TYPE_PT_ADDBITS14;
8635 kern_type = KERN_TYPE_MD5_CHAP;
8636 dgst_size = DGST_SIZE_4_4;
8637 parse_func = chap_parse_hash;
8638 sort_by_digest = sort_by_digest_4_4;
8639 opti_type = OPTI_TYPE_ZERO_BYTE
8640 | OPTI_TYPE_PRECOMPUTE_INIT
8641 | OPTI_TYPE_PRECOMPUTE_MERKLE
8642 | OPTI_TYPE_MEET_IN_MIDDLE
8643 | OPTI_TYPE_EARLY_SKIP
8644 | OPTI_TYPE_NOT_ITERATED
8645 | OPTI_TYPE_RAW_HASH;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 4900: hash_type = HASH_TYPE_SHA1;
8653 salt_type = SALT_TYPE_INTERN;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8656 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8657 dgst_size = DGST_SIZE_4_5;
8658 parse_func = sha1s_parse_hash;
8659 sort_by_digest = sort_by_digest_4_5;
8660 opti_type = OPTI_TYPE_ZERO_BYTE
8661 | OPTI_TYPE_PRECOMPUTE_INIT
8662 | OPTI_TYPE_PRECOMPUTE_MERKLE
8663 | OPTI_TYPE_EARLY_SKIP;
8664 dgst_pos0 = 3;
8665 dgst_pos1 = 4;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 1;
8668 break;
8669
8670 case 5000: hash_type = HASH_TYPE_KECCAK;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE
8674 | OPTS_TYPE_PT_ADD01;
8675 kern_type = KERN_TYPE_KECCAK;
8676 dgst_size = DGST_SIZE_8_25;
8677 parse_func = keccak_parse_hash;
8678 sort_by_digest = sort_by_digest_8_25;
8679 opti_type = OPTI_TYPE_ZERO_BYTE
8680 | OPTI_TYPE_USES_BITS_64
8681 | OPTI_TYPE_RAW_HASH;
8682 dgst_pos0 = 2;
8683 dgst_pos1 = 3;
8684 dgst_pos2 = 4;
8685 dgst_pos3 = 5;
8686 break;
8687
8688 case 5100: hash_type = HASH_TYPE_MD5H;
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_MD5H;
8695 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8696 parse_func = md5half_parse_hash;
8697 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_RAW_HASH;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 1;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 3;
8704 break;
8705
8706 case 5200: hash_type = HASH_TYPE_SHA256;
8707 salt_type = SALT_TYPE_EMBEDDED;
8708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8710 kern_type = KERN_TYPE_PSAFE3;
8711 dgst_size = DGST_SIZE_4_8;
8712 parse_func = psafe3_parse_hash;
8713 sort_by_digest = sort_by_digest_4_8;
8714 opti_type = OPTI_TYPE_ZERO_BYTE;
8715 dgst_pos0 = 0;
8716 dgst_pos1 = 1;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 3;
8719 break;
8720
8721 case 5300: hash_type = HASH_TYPE_MD5;
8722 salt_type = SALT_TYPE_EMBEDDED;
8723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_LE
8725 | OPTS_TYPE_ST_ADD80;
8726 kern_type = KERN_TYPE_IKEPSK_MD5;
8727 dgst_size = DGST_SIZE_4_4;
8728 parse_func = ikepsk_md5_parse_hash;
8729 sort_by_digest = sort_by_digest_4_4;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 3;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 1;
8735 break;
8736
8737 case 5400: hash_type = HASH_TYPE_SHA1;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_ST_ADD80;
8742 kern_type = KERN_TYPE_IKEPSK_SHA1;
8743 dgst_size = DGST_SIZE_4_5;
8744 parse_func = ikepsk_sha1_parse_hash;
8745 sort_by_digest = sort_by_digest_4_5;
8746 opti_type = OPTI_TYPE_ZERO_BYTE;
8747 dgst_pos0 = 3;
8748 dgst_pos1 = 4;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 1;
8751 break;
8752
8753 case 5500: hash_type = HASH_TYPE_NETNTLM;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE
8757 | OPTS_TYPE_PT_ADD80
8758 | OPTS_TYPE_PT_ADDBITS14
8759 | OPTS_TYPE_PT_UNICODE
8760 | OPTS_TYPE_ST_HEX;
8761 kern_type = KERN_TYPE_NETNTLMv1;
8762 dgst_size = DGST_SIZE_4_4;
8763 parse_func = netntlmv1_parse_hash;
8764 sort_by_digest = sort_by_digest_4_4;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 5600: hash_type = HASH_TYPE_MD5;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE
8777 | OPTS_TYPE_PT_ADD80
8778 | OPTS_TYPE_PT_ADDBITS14
8779 | OPTS_TYPE_PT_UNICODE;
8780 kern_type = KERN_TYPE_NETNTLMv2;
8781 dgst_size = DGST_SIZE_4_4;
8782 parse_func = netntlmv2_parse_hash;
8783 sort_by_digest = sort_by_digest_4_4;
8784 opti_type = OPTI_TYPE_ZERO_BYTE;
8785 dgst_pos0 = 0;
8786 dgst_pos1 = 3;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 1;
8789 break;
8790
8791 case 5700: hash_type = HASH_TYPE_SHA256;
8792 salt_type = SALT_TYPE_NONE;
8793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_BE
8795 | OPTS_TYPE_PT_ADD80
8796 | OPTS_TYPE_PT_ADDBITS15;
8797 kern_type = KERN_TYPE_SHA256;
8798 dgst_size = DGST_SIZE_4_8;
8799 parse_func = cisco4_parse_hash;
8800 sort_by_digest = sort_by_digest_4_8;
8801 opti_type = OPTI_TYPE_ZERO_BYTE
8802 | OPTI_TYPE_PRECOMPUTE_INIT
8803 | OPTI_TYPE_PRECOMPUTE_MERKLE
8804 | OPTI_TYPE_EARLY_SKIP
8805 | OPTI_TYPE_NOT_ITERATED
8806 | OPTI_TYPE_NOT_SALTED
8807 | OPTI_TYPE_RAW_HASH;
8808 dgst_pos0 = 3;
8809 dgst_pos1 = 7;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 6;
8812 break;
8813
8814 case 5800: hash_type = HASH_TYPE_SHA1;
8815 salt_type = SALT_TYPE_INTERN;
8816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8818 | OPTS_TYPE_ST_ADD80;
8819 kern_type = KERN_TYPE_ANDROIDPIN;
8820 dgst_size = DGST_SIZE_4_5;
8821 parse_func = androidpin_parse_hash;
8822 sort_by_digest = sort_by_digest_4_5;
8823 opti_type = OPTI_TYPE_ZERO_BYTE;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 1;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 3;
8828 break;
8829
8830 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8831 salt_type = SALT_TYPE_NONE;
8832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_PT_ADD80;
8835 kern_type = KERN_TYPE_RIPEMD160;
8836 dgst_size = DGST_SIZE_4_5;
8837 parse_func = ripemd160_parse_hash;
8838 sort_by_digest = sort_by_digest_4_5;
8839 opti_type = OPTI_TYPE_ZERO_BYTE;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8847 salt_type = SALT_TYPE_NONE;
8848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_BE
8850 | OPTS_TYPE_PT_ADD80;
8851 kern_type = KERN_TYPE_WHIRLPOOL;
8852 dgst_size = DGST_SIZE_4_16;
8853 parse_func = whirlpool_parse_hash;
8854 sort_by_digest = sort_by_digest_4_16;
8855 opti_type = OPTI_TYPE_ZERO_BYTE;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8866 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8867 dgst_size = DGST_SIZE_4_5;
8868 parse_func = truecrypt_parse_hash_2k;
8869 sort_by_digest = sort_by_digest_4_5;
8870 opti_type = OPTI_TYPE_ZERO_BYTE;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8881 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8882 dgst_size = DGST_SIZE_4_5;
8883 parse_func = truecrypt_parse_hash_2k;
8884 sort_by_digest = sort_by_digest_4_5;
8885 opti_type = OPTI_TYPE_ZERO_BYTE;
8886 dgst_pos0 = 0;
8887 dgst_pos1 = 1;
8888 dgst_pos2 = 2;
8889 dgst_pos3 = 3;
8890 break;
8891
8892 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8893 salt_type = SALT_TYPE_EMBEDDED;
8894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8896 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8897 dgst_size = DGST_SIZE_4_5;
8898 parse_func = truecrypt_parse_hash_2k;
8899 sort_by_digest = sort_by_digest_4_5;
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 6221: hash_type = HASH_TYPE_SHA512;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8911 kern_type = KERN_TYPE_TCSHA512_XTS512;
8912 dgst_size = DGST_SIZE_8_8;
8913 parse_func = truecrypt_parse_hash_1k;
8914 sort_by_digest = sort_by_digest_8_8;
8915 opti_type = OPTI_TYPE_ZERO_BYTE
8916 | OPTI_TYPE_USES_BITS_64;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 6222: hash_type = HASH_TYPE_SHA512;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8927 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8928 dgst_size = DGST_SIZE_8_8;
8929 parse_func = truecrypt_parse_hash_1k;
8930 sort_by_digest = sort_by_digest_8_8;
8931 opti_type = OPTI_TYPE_ZERO_BYTE
8932 | OPTI_TYPE_USES_BITS_64;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6223: hash_type = HASH_TYPE_SHA512;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8943 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8944 dgst_size = DGST_SIZE_8_8;
8945 parse_func = truecrypt_parse_hash_1k;
8946 sort_by_digest = sort_by_digest_8_8;
8947 opti_type = OPTI_TYPE_ZERO_BYTE
8948 | OPTI_TYPE_USES_BITS_64;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8959 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8960 dgst_size = DGST_SIZE_4_8;
8961 parse_func = truecrypt_parse_hash_1k;
8962 sort_by_digest = sort_by_digest_4_8;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8974 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8975 dgst_size = DGST_SIZE_4_8;
8976 parse_func = truecrypt_parse_hash_1k;
8977 sort_by_digest = sort_by_digest_4_8;
8978 opti_type = OPTI_TYPE_ZERO_BYTE;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8989 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8990 dgst_size = DGST_SIZE_4_8;
8991 parse_func = truecrypt_parse_hash_1k;
8992 sort_by_digest = sort_by_digest_4_8;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9004 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9005 dgst_size = DGST_SIZE_4_5;
9006 parse_func = truecrypt_parse_hash_1k;
9007 sort_by_digest = sort_by_digest_4_5;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9019 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9020 dgst_size = DGST_SIZE_4_5;
9021 parse_func = truecrypt_parse_hash_1k;
9022 sort_by_digest = sort_by_digest_4_5;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9034 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9035 dgst_size = DGST_SIZE_4_5;
9036 parse_func = truecrypt_parse_hash_1k;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 6300: hash_type = HASH_TYPE_MD5;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9049 kern_type = KERN_TYPE_MD5AIX;
9050 dgst_size = DGST_SIZE_4_4;
9051 parse_func = md5aix_parse_hash;
9052 sort_by_digest = sort_by_digest_4_4;
9053 opti_type = OPTI_TYPE_ZERO_BYTE;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6400: hash_type = HASH_TYPE_SHA256;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9064 kern_type = KERN_TYPE_SHA256AIX;
9065 dgst_size = DGST_SIZE_4_8;
9066 parse_func = sha256aix_parse_hash;
9067 sort_by_digest = sort_by_digest_4_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE;
9069 dgst_pos0 = 0;
9070 dgst_pos1 = 1;
9071 dgst_pos2 = 2;
9072 dgst_pos3 = 3;
9073 break;
9074
9075 case 6500: hash_type = HASH_TYPE_SHA512;
9076 salt_type = SALT_TYPE_EMBEDDED;
9077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9079 kern_type = KERN_TYPE_SHA512AIX;
9080 dgst_size = DGST_SIZE_8_8;
9081 parse_func = sha512aix_parse_hash;
9082 sort_by_digest = sort_by_digest_8_8;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_USES_BITS_64;
9085 dgst_pos0 = 0;
9086 dgst_pos1 = 1;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 3;
9089 break;
9090
9091 case 6600: hash_type = HASH_TYPE_AES;
9092 salt_type = SALT_TYPE_EMBEDDED;
9093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9095 kern_type = KERN_TYPE_AGILEKEY;
9096 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9097 parse_func = agilekey_parse_hash;
9098 sort_by_digest = sort_by_digest_4_5;
9099 opti_type = OPTI_TYPE_ZERO_BYTE;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 6700: hash_type = HASH_TYPE_SHA1;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9110 kern_type = KERN_TYPE_SHA1AIX;
9111 dgst_size = DGST_SIZE_4_5;
9112 parse_func = sha1aix_parse_hash;
9113 sort_by_digest = sort_by_digest_4_5;
9114 opti_type = OPTI_TYPE_ZERO_BYTE;
9115 dgst_pos0 = 0;
9116 dgst_pos1 = 1;
9117 dgst_pos2 = 2;
9118 dgst_pos3 = 3;
9119 break;
9120
9121 case 6800: hash_type = HASH_TYPE_AES;
9122 salt_type = SALT_TYPE_EMBEDDED;
9123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9124 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9125 kern_type = KERN_TYPE_LASTPASS;
9126 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9127 parse_func = lastpass_parse_hash;
9128 sort_by_digest = sort_by_digest_4_8;
9129 opti_type = OPTI_TYPE_ZERO_BYTE;
9130 dgst_pos0 = 0;
9131 dgst_pos1 = 1;
9132 dgst_pos2 = 2;
9133 dgst_pos3 = 3;
9134 break;
9135
9136 case 6900: hash_type = HASH_TYPE_GOST;
9137 salt_type = SALT_TYPE_NONE;
9138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9139 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9140 kern_type = KERN_TYPE_GOST;
9141 dgst_size = DGST_SIZE_4_8;
9142 parse_func = gost_parse_hash;
9143 sort_by_digest = sort_by_digest_4_8;
9144 opti_type = OPTI_TYPE_ZERO_BYTE;
9145 dgst_pos0 = 0;
9146 dgst_pos1 = 1;
9147 dgst_pos2 = 2;
9148 dgst_pos3 = 3;
9149 break;
9150
9151 case 7100: hash_type = HASH_TYPE_SHA512;
9152 salt_type = SALT_TYPE_EMBEDDED;
9153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9154 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9155 kern_type = KERN_TYPE_PBKDF2_SHA512;
9156 dgst_size = DGST_SIZE_8_16;
9157 parse_func = sha512osx_parse_hash;
9158 sort_by_digest = sort_by_digest_8_16;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_USES_BITS_64;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7200: hash_type = HASH_TYPE_SHA512;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9171 kern_type = KERN_TYPE_PBKDF2_SHA512;
9172 dgst_size = DGST_SIZE_8_16;
9173 parse_func = sha512grub_parse_hash;
9174 sort_by_digest = sort_by_digest_8_16;
9175 opti_type = OPTI_TYPE_ZERO_BYTE
9176 | OPTI_TYPE_USES_BITS_64;
9177 dgst_pos0 = 0;
9178 dgst_pos1 = 1;
9179 dgst_pos2 = 2;
9180 dgst_pos3 = 3;
9181 break;
9182
9183 case 7300: hash_type = HASH_TYPE_SHA1;
9184 salt_type = SALT_TYPE_EMBEDDED;
9185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9186 opts_type = OPTS_TYPE_PT_GENERATE_BE
9187 | OPTS_TYPE_ST_ADD80
9188 | OPTS_TYPE_ST_ADDBITS15;
9189 kern_type = KERN_TYPE_RAKP;
9190 dgst_size = DGST_SIZE_4_5;
9191 parse_func = rakp_parse_hash;
9192 sort_by_digest = sort_by_digest_4_5;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_NOT_ITERATED;
9195 dgst_pos0 = 3;
9196 dgst_pos1 = 4;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 1;
9199 break;
9200
9201 case 7400: hash_type = HASH_TYPE_SHA256;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9205 kern_type = KERN_TYPE_SHA256CRYPT;
9206 dgst_size = DGST_SIZE_4_8;
9207 parse_func = sha256crypt_parse_hash;
9208 sort_by_digest = sort_by_digest_4_8;
9209 opti_type = OPTI_TYPE_ZERO_BYTE;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 7500: hash_type = HASH_TYPE_KRB5PA;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9220 kern_type = KERN_TYPE_KRB5PA;
9221 dgst_size = DGST_SIZE_4_4;
9222 parse_func = krb5pa_parse_hash;
9223 sort_by_digest = sort_by_digest_4_4;
9224 opti_type = OPTI_TYPE_ZERO_BYTE
9225 | OPTI_TYPE_NOT_ITERATED;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 7600: hash_type = HASH_TYPE_SHA1;
9233 salt_type = SALT_TYPE_INTERN;
9234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_BE
9236 | OPTS_TYPE_PT_ADD80
9237 | OPTS_TYPE_PT_ADDBITS15;
9238 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9239 dgst_size = DGST_SIZE_4_5;
9240 parse_func = redmine_parse_hash;
9241 sort_by_digest = sort_by_digest_4_5;
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_EARLY_SKIP
9245 | OPTI_TYPE_NOT_ITERATED
9246 | OPTI_TYPE_PREPENDED_SALT;
9247 dgst_pos0 = 3;
9248 dgst_pos1 = 4;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 1;
9251 break;
9252
9253 case 7700: hash_type = HASH_TYPE_SAPB;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE
9257 | OPTS_TYPE_PT_UPPER
9258 | OPTS_TYPE_ST_UPPER;
9259 kern_type = KERN_TYPE_SAPB;
9260 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9261 parse_func = sapb_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_NOT_ITERATED;
9266 dgst_pos0 = 0;
9267 dgst_pos1 = 1;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 3;
9270 break;
9271
9272 case 7800: hash_type = HASH_TYPE_SAPG;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_BE
9276 | OPTS_TYPE_ST_ADD80
9277 | OPTS_TYPE_ST_UPPER;
9278 kern_type = KERN_TYPE_SAPG;
9279 dgst_size = DGST_SIZE_4_5;
9280 parse_func = sapg_parse_hash;
9281 sort_by_digest = sort_by_digest_4_5;
9282 opti_type = OPTI_TYPE_ZERO_BYTE
9283 | OPTI_TYPE_PRECOMPUTE_INIT
9284 | OPTI_TYPE_NOT_ITERATED;
9285 dgst_pos0 = 3;
9286 dgst_pos1 = 4;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 1;
9289 break;
9290
9291 case 7900: hash_type = HASH_TYPE_SHA512;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9295 kern_type = KERN_TYPE_DRUPAL7;
9296 dgst_size = DGST_SIZE_8_8;
9297 parse_func = drupal7_parse_hash;
9298 sort_by_digest = sort_by_digest_8_8;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_USES_BITS_64;
9301 dgst_pos0 = 0;
9302 dgst_pos1 = 1;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 3;
9305 break;
9306
9307 case 8000: hash_type = HASH_TYPE_SHA256;
9308 salt_type = SALT_TYPE_EMBEDDED;
9309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_BE
9311 | OPTS_TYPE_PT_UNICODE
9312 | OPTS_TYPE_ST_ADD80
9313 | OPTS_TYPE_ST_HEX;
9314 kern_type = KERN_TYPE_SYBASEASE;
9315 dgst_size = DGST_SIZE_4_8;
9316 parse_func = sybasease_parse_hash;
9317 sort_by_digest = sort_by_digest_4_8;
9318 opti_type = OPTI_TYPE_ZERO_BYTE
9319 | OPTI_TYPE_PRECOMPUTE_INIT
9320 | OPTI_TYPE_EARLY_SKIP
9321 | OPTI_TYPE_NOT_ITERATED
9322 | OPTI_TYPE_RAW_HASH;
9323 dgst_pos0 = 3;
9324 dgst_pos1 = 7;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 6;
9327 break;
9328
9329 case 8100: hash_type = HASH_TYPE_SHA1;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9333 kern_type = KERN_TYPE_NETSCALER;
9334 dgst_size = DGST_SIZE_4_5;
9335 parse_func = netscaler_parse_hash;
9336 sort_by_digest = sort_by_digest_4_5;
9337 opti_type = OPTI_TYPE_ZERO_BYTE
9338 | OPTI_TYPE_PRECOMPUTE_INIT
9339 | OPTI_TYPE_PRECOMPUTE_MERKLE
9340 | OPTI_TYPE_EARLY_SKIP
9341 | OPTI_TYPE_NOT_ITERATED
9342 | OPTI_TYPE_PREPENDED_SALT
9343 | OPTI_TYPE_RAW_HASH;
9344 dgst_pos0 = 3;
9345 dgst_pos1 = 4;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 1;
9348 break;
9349
9350 case 8200: hash_type = HASH_TYPE_SHA256;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9354 kern_type = KERN_TYPE_CLOUDKEY;
9355 dgst_size = DGST_SIZE_4_8;
9356 parse_func = cloudkey_parse_hash;
9357 sort_by_digest = sort_by_digest_4_8;
9358 opti_type = OPTI_TYPE_ZERO_BYTE;
9359 dgst_pos0 = 0;
9360 dgst_pos1 = 1;
9361 dgst_pos2 = 2;
9362 dgst_pos3 = 3;
9363 break;
9364
9365 case 8300: hash_type = HASH_TYPE_SHA1;
9366 salt_type = SALT_TYPE_EMBEDDED;
9367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9368 opts_type = OPTS_TYPE_PT_GENERATE_LE
9369 | OPTS_TYPE_ST_HEX
9370 | OPTS_TYPE_ST_ADD80;
9371 kern_type = KERN_TYPE_NSEC3;
9372 dgst_size = DGST_SIZE_4_5;
9373 parse_func = nsec3_parse_hash;
9374 sort_by_digest = sort_by_digest_4_5;
9375 opti_type = OPTI_TYPE_ZERO_BYTE;
9376 dgst_pos0 = 3;
9377 dgst_pos1 = 4;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 1;
9380 break;
9381
9382 case 8400: hash_type = HASH_TYPE_SHA1;
9383 salt_type = SALT_TYPE_INTERN;
9384 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_BE
9386 | OPTS_TYPE_PT_ADD80
9387 | OPTS_TYPE_PT_ADDBITS15;
9388 kern_type = KERN_TYPE_WBB3;
9389 dgst_size = DGST_SIZE_4_5;
9390 parse_func = wbb3_parse_hash;
9391 sort_by_digest = sort_by_digest_4_5;
9392 opti_type = OPTI_TYPE_ZERO_BYTE
9393 | OPTI_TYPE_PRECOMPUTE_INIT
9394 | OPTI_TYPE_NOT_ITERATED;
9395 dgst_pos0 = 3;
9396 dgst_pos1 = 4;
9397 dgst_pos2 = 2;
9398 dgst_pos3 = 1;
9399 break;
9400
9401 case 8500: hash_type = HASH_TYPE_DESRACF;
9402 salt_type = SALT_TYPE_EMBEDDED;
9403 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9404 opts_type = OPTS_TYPE_PT_GENERATE_LE
9405 | OPTS_TYPE_ST_UPPER;
9406 kern_type = KERN_TYPE_RACF;
9407 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9408 parse_func = racf_parse_hash;
9409 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9410 opti_type = OPTI_TYPE_ZERO_BYTE
9411 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 8600: hash_type = HASH_TYPE_LOTUS5;
9419 salt_type = SALT_TYPE_NONE;
9420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9422 kern_type = KERN_TYPE_LOTUS5;
9423 dgst_size = DGST_SIZE_4_4;
9424 parse_func = lotus5_parse_hash;
9425 sort_by_digest = sort_by_digest_4_4;
9426 opti_type = OPTI_TYPE_EARLY_SKIP
9427 | OPTI_TYPE_NOT_ITERATED
9428 | OPTI_TYPE_NOT_SALTED
9429 | OPTI_TYPE_RAW_HASH;
9430 dgst_pos0 = 0;
9431 dgst_pos1 = 1;
9432 dgst_pos2 = 2;
9433 dgst_pos3 = 3;
9434 break;
9435
9436 case 8700: hash_type = HASH_TYPE_LOTUS6;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9440 kern_type = KERN_TYPE_LOTUS6;
9441 dgst_size = DGST_SIZE_4_4;
9442 parse_func = lotus6_parse_hash;
9443 sort_by_digest = sort_by_digest_4_4;
9444 opti_type = OPTI_TYPE_EARLY_SKIP
9445 | OPTI_TYPE_NOT_ITERATED
9446 | OPTI_TYPE_RAW_HASH;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9457 kern_type = KERN_TYPE_ANDROIDFDE;
9458 dgst_size = DGST_SIZE_4_4;
9459 parse_func = androidfde_parse_hash;
9460 sort_by_digest = sort_by_digest_4_4;
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 8900: hash_type = HASH_TYPE_SCRYPT;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9472 kern_type = KERN_TYPE_SCRYPT;
9473 dgst_size = DGST_SIZE_4_8;
9474 parse_func = scrypt_parse_hash;
9475 sort_by_digest = sort_by_digest_4_8;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9000: hash_type = HASH_TYPE_SHA1;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE
9487 | OPTS_TYPE_ST_GENERATE_LE;
9488 kern_type = KERN_TYPE_PSAFE2;
9489 dgst_size = DGST_SIZE_4_5;
9490 parse_func = psafe2_parse_hash;
9491 sort_by_digest = sort_by_digest_4_5;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9100: hash_type = HASH_TYPE_LOTUS8;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_LOTUS8;
9504 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9505 parse_func = lotus8_parse_hash;
9506 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9200: hash_type = HASH_TYPE_SHA256;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9518 kern_type = KERN_TYPE_PBKDF2_SHA256;
9519 dgst_size = DGST_SIZE_4_32;
9520 parse_func = cisco8_parse_hash;
9521 sort_by_digest = sort_by_digest_4_32;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9300: hash_type = HASH_TYPE_SCRYPT;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_SCRYPT;
9534 dgst_size = DGST_SIZE_4_8;
9535 parse_func = cisco9_parse_hash;
9536 sort_by_digest = sort_by_digest_4_8;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9548 kern_type = KERN_TYPE_OFFICE2007;
9549 dgst_size = DGST_SIZE_4_4;
9550 parse_func = office2007_parse_hash;
9551 sort_by_digest = sort_by_digest_4_4;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_OFFICE2010;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = office2010_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 1;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 3;
9572 break;
9573
9574 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9578 kern_type = KERN_TYPE_OFFICE2013;
9579 dgst_size = DGST_SIZE_4_4;
9580 parse_func = office2013_parse_hash;
9581 sort_by_digest = sort_by_digest_4_4;
9582 opti_type = OPTI_TYPE_ZERO_BYTE;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE
9593 | OPTS_TYPE_PT_ADD80
9594 | OPTS_TYPE_PT_UNICODE;
9595 kern_type = KERN_TYPE_OLDOFFICE01;
9596 dgst_size = DGST_SIZE_4_4;
9597 parse_func = oldoffice01_parse_hash;
9598 sort_by_digest = sort_by_digest_4_4;
9599 opti_type = OPTI_TYPE_ZERO_BYTE
9600 | OPTI_TYPE_PRECOMPUTE_INIT
9601 | OPTI_TYPE_NOT_ITERATED;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 1;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 3;
9606 break;
9607
9608 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9609 salt_type = SALT_TYPE_EMBEDDED;
9610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE
9612 | OPTS_TYPE_PT_ADD80;
9613 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice01cm1_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_LE
9630 | OPTS_TYPE_PT_ADD80
9631 | OPTS_TYPE_PT_UNICODE
9632 | OPTS_TYPE_PT_NEVERCRACK;
9633 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = oldoffice01cm2_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE
9638 | OPTI_TYPE_PRECOMPUTE_INIT
9639 | OPTI_TYPE_NOT_ITERATED;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_BE
9650 | OPTS_TYPE_PT_ADD80
9651 | OPTS_TYPE_PT_UNICODE;
9652 kern_type = KERN_TYPE_OLDOFFICE34;
9653 dgst_size = DGST_SIZE_4_4;
9654 parse_func = oldoffice34_parse_hash;
9655 sort_by_digest = sort_by_digest_4_4;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_PRECOMPUTE_INIT
9658 | OPTI_TYPE_NOT_ITERATED;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 1;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 3;
9663 break;
9664
9665 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9669 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9670 dgst_size = DGST_SIZE_4_4;
9671 parse_func = oldoffice34cm1_parse_hash;
9672 sort_by_digest = sort_by_digest_4_4;
9673 opti_type = OPTI_TYPE_ZERO_BYTE
9674 | OPTI_TYPE_PRECOMPUTE_INIT
9675 | OPTI_TYPE_NOT_ITERATED;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_BE
9686 | OPTS_TYPE_PT_ADD80
9687 | OPTS_TYPE_PT_UNICODE
9688 | OPTS_TYPE_PT_NEVERCRACK;
9689 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9690 dgst_size = DGST_SIZE_4_4;
9691 parse_func = oldoffice34cm2_parse_hash;
9692 sort_by_digest = sort_by_digest_4_4;
9693 opti_type = OPTI_TYPE_ZERO_BYTE
9694 | OPTI_TYPE_PRECOMPUTE_INIT
9695 | OPTI_TYPE_NOT_ITERATED;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 1;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 3;
9700 break;
9701
9702 case 9900: hash_type = HASH_TYPE_MD5;
9703 salt_type = SALT_TYPE_NONE;
9704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9706 kern_type = KERN_TYPE_RADMIN2;
9707 dgst_size = DGST_SIZE_4_4;
9708 parse_func = radmin2_parse_hash;
9709 sort_by_digest = sort_by_digest_4_4;
9710 opti_type = OPTI_TYPE_ZERO_BYTE
9711 | OPTI_TYPE_PRECOMPUTE_INIT
9712 | OPTI_TYPE_EARLY_SKIP
9713 | OPTI_TYPE_NOT_ITERATED
9714 | OPTI_TYPE_NOT_SALTED;
9715 dgst_pos0 = 0;
9716 dgst_pos1 = 3;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 1;
9719 break;
9720
9721 case 10000: hash_type = HASH_TYPE_SHA256;
9722 salt_type = SALT_TYPE_EMBEDDED;
9723 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9725 kern_type = KERN_TYPE_PBKDF2_SHA256;
9726 dgst_size = DGST_SIZE_4_32;
9727 parse_func = djangopbkdf2_parse_hash;
9728 sort_by_digest = sort_by_digest_4_32;
9729 opti_type = OPTI_TYPE_ZERO_BYTE;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 10100: hash_type = HASH_TYPE_SIPHASH;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9740 kern_type = KERN_TYPE_SIPHASH;
9741 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9742 parse_func = siphash_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_NOT_ITERATED
9746 | OPTI_TYPE_RAW_HASH;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 10200: hash_type = HASH_TYPE_MD5;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_LE
9757 | OPTS_TYPE_ST_ADD80
9758 | OPTS_TYPE_ST_ADDBITS14;
9759 kern_type = KERN_TYPE_HMACMD5_PW;
9760 dgst_size = DGST_SIZE_4_4;
9761 parse_func = crammd5_parse_hash;
9762 sort_by_digest = sort_by_digest_4_4;
9763 opti_type = OPTI_TYPE_ZERO_BYTE
9764 | OPTI_TYPE_NOT_ITERATED;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 3;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 1;
9769 break;
9770
9771 case 10300: hash_type = HASH_TYPE_SHA1;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9775 kern_type = KERN_TYPE_SAPH_SHA1;
9776 dgst_size = DGST_SIZE_4_5;
9777 parse_func = saph_sha1_parse_hash;
9778 sort_by_digest = sort_by_digest_4_5;
9779 opti_type = OPTI_TYPE_ZERO_BYTE;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 10400: hash_type = HASH_TYPE_PDFU16;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_PDF11;
9791 dgst_size = DGST_SIZE_4_4;
9792 parse_func = pdf11_parse_hash;
9793 sort_by_digest = sort_by_digest_4_4;
9794 opti_type = OPTI_TYPE_ZERO_BYTE
9795 | OPTI_TYPE_NOT_ITERATED;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 10410: hash_type = HASH_TYPE_PDFU16;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9806 kern_type = KERN_TYPE_PDF11CM1;
9807 dgst_size = DGST_SIZE_4_4;
9808 parse_func = pdf11cm1_parse_hash;
9809 sort_by_digest = sort_by_digest_4_4;
9810 opti_type = OPTI_TYPE_ZERO_BYTE
9811 | OPTI_TYPE_NOT_ITERATED;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 10420: hash_type = HASH_TYPE_PDFU16;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9822 kern_type = KERN_TYPE_PDF11CM2;
9823 dgst_size = DGST_SIZE_4_4;
9824 parse_func = pdf11cm2_parse_hash;
9825 sort_by_digest = sort_by_digest_4_4;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_NOT_ITERATED;
9828 dgst_pos0 = 0;
9829 dgst_pos1 = 1;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 3;
9832 break;
9833
9834 case 10500: hash_type = HASH_TYPE_PDFU16;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9838 kern_type = KERN_TYPE_PDF14;
9839 dgst_size = DGST_SIZE_4_4;
9840 parse_func = pdf14_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_NOT_ITERATED;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 10600: hash_type = HASH_TYPE_SHA256;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_BE
9854 | OPTS_TYPE_ST_ADD80
9855 | OPTS_TYPE_ST_ADDBITS15
9856 | OPTS_TYPE_HASH_COPY;
9857 kern_type = KERN_TYPE_SHA256_PWSLT;
9858 dgst_size = DGST_SIZE_4_8;
9859 parse_func = pdf17l3_parse_hash;
9860 sort_by_digest = sort_by_digest_4_8;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_PRECOMPUTE_INIT
9863 | OPTI_TYPE_PRECOMPUTE_MERKLE
9864 | OPTI_TYPE_EARLY_SKIP
9865 | OPTI_TYPE_NOT_ITERATED
9866 | OPTI_TYPE_APPENDED_SALT
9867 | OPTI_TYPE_RAW_HASH;
9868 dgst_pos0 = 3;
9869 dgst_pos1 = 7;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 6;
9872 break;
9873
9874 case 10700: hash_type = HASH_TYPE_PDFU32;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_HASH_COPY;
9879 kern_type = KERN_TYPE_PDF17L8;
9880 dgst_size = DGST_SIZE_4_8;
9881 parse_func = pdf17l8_parse_hash;
9882 sort_by_digest = sort_by_digest_4_8;
9883 opti_type = OPTI_TYPE_ZERO_BYTE
9884 | OPTI_TYPE_NOT_ITERATED;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 1;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 3;
9889 break;
9890
9891 case 10800: hash_type = HASH_TYPE_SHA384;
9892 salt_type = SALT_TYPE_NONE;
9893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_BE
9895 | OPTS_TYPE_PT_ADD80
9896 | OPTS_TYPE_PT_ADDBITS15;
9897 kern_type = KERN_TYPE_SHA384;
9898 dgst_size = DGST_SIZE_8_8;
9899 parse_func = sha384_parse_hash;
9900 sort_by_digest = sort_by_digest_8_8;
9901 opti_type = OPTI_TYPE_ZERO_BYTE
9902 | OPTI_TYPE_PRECOMPUTE_INIT
9903 | OPTI_TYPE_PRECOMPUTE_MERKLE
9904 | OPTI_TYPE_EARLY_SKIP
9905 | OPTI_TYPE_NOT_ITERATED
9906 | OPTI_TYPE_NOT_SALTED
9907 | OPTI_TYPE_USES_BITS_64
9908 | OPTI_TYPE_RAW_HASH;
9909 dgst_pos0 = 6;
9910 dgst_pos1 = 7;
9911 dgst_pos2 = 4;
9912 dgst_pos3 = 5;
9913 break;
9914
9915 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE
9919 | OPTS_TYPE_ST_BASE64
9920 | OPTS_TYPE_HASH_COPY;
9921 kern_type = KERN_TYPE_PBKDF2_SHA256;
9922 dgst_size = DGST_SIZE_4_32;
9923 parse_func = pbkdf2_sha256_parse_hash;
9924 sort_by_digest = sort_by_digest_4_32;
9925 opti_type = OPTI_TYPE_ZERO_BYTE;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 11000: hash_type = HASH_TYPE_MD5;
9933 salt_type = SALT_TYPE_INTERN;
9934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_PT_ADD80;
9937 kern_type = KERN_TYPE_PRESTASHOP;
9938 dgst_size = DGST_SIZE_4_4;
9939 parse_func = prestashop_parse_hash;
9940 sort_by_digest = sort_by_digest_4_4;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_PRECOMPUTE_INIT
9943 | OPTI_TYPE_NOT_ITERATED
9944 | OPTI_TYPE_PREPENDED_SALT;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 3;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 1;
9949 break;
9950
9951 case 11100: hash_type = HASH_TYPE_MD5;
9952 salt_type = SALT_TYPE_EMBEDDED;
9953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE
9955 | OPTS_TYPE_ST_ADD80;
9956 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9957 dgst_size = DGST_SIZE_4_4;
9958 parse_func = postgresql_auth_parse_hash;
9959 sort_by_digest = sort_by_digest_4_4;
9960 opti_type = OPTI_TYPE_ZERO_BYTE
9961 | OPTI_TYPE_PRECOMPUTE_INIT
9962 | OPTI_TYPE_PRECOMPUTE_MERKLE
9963 | OPTI_TYPE_EARLY_SKIP;
9964 dgst_pos0 = 0;
9965 dgst_pos1 = 3;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 1;
9968 break;
9969
9970 case 11200: hash_type = HASH_TYPE_SHA1;
9971 salt_type = SALT_TYPE_EMBEDDED;
9972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_BE
9974 | OPTS_TYPE_PT_ADD80
9975 | OPTS_TYPE_ST_HEX;
9976 kern_type = KERN_TYPE_MYSQL_AUTH;
9977 dgst_size = DGST_SIZE_4_5;
9978 parse_func = mysql_auth_parse_hash;
9979 sort_by_digest = sort_by_digest_4_5;
9980 opti_type = OPTI_TYPE_ZERO_BYTE
9981 | OPTI_TYPE_EARLY_SKIP;
9982 dgst_pos0 = 3;
9983 dgst_pos1 = 4;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 1;
9986 break;
9987
9988 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE
9992 | OPTS_TYPE_ST_HEX
9993 | OPTS_TYPE_ST_ADD80;
9994 kern_type = KERN_TYPE_BITCOIN_WALLET;
9995 dgst_size = DGST_SIZE_4_4;
9996 parse_func = bitcoin_wallet_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 11400: hash_type = HASH_TYPE_MD5;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_PT_ADD80
10010 | OPTS_TYPE_HASH_COPY;
10011 kern_type = KERN_TYPE_SIP_AUTH;
10012 dgst_size = DGST_SIZE_4_4;
10013 parse_func = sip_auth_parse_hash;
10014 sort_by_digest = sort_by_digest_4_4;
10015 opti_type = OPTI_TYPE_ZERO_BYTE;
10016 dgst_pos0 = 0;
10017 dgst_pos1 = 3;
10018 dgst_pos2 = 2;
10019 dgst_pos3 = 1;
10020 break;
10021
10022 case 11500: hash_type = HASH_TYPE_CRC32;
10023 salt_type = SALT_TYPE_INTERN;
10024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10025 opts_type = OPTS_TYPE_PT_GENERATE_LE
10026 | OPTS_TYPE_ST_GENERATE_LE
10027 | OPTS_TYPE_ST_HEX;
10028 kern_type = KERN_TYPE_CRC32;
10029 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10030 parse_func = crc32_parse_hash;
10031 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10032 opti_type = OPTI_TYPE_ZERO_BYTE;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 11600: hash_type = HASH_TYPE_AES;
10040 salt_type = SALT_TYPE_EMBEDDED;
10041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE
10043 | OPTS_TYPE_PT_NEVERCRACK;
10044 kern_type = KERN_TYPE_SEVEN_ZIP;
10045 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10046 parse_func = seven_zip_parse_hash;
10047 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10048 opti_type = OPTI_TYPE_ZERO_BYTE;
10049 dgst_pos0 = 0;
10050 dgst_pos1 = 1;
10051 dgst_pos2 = 2;
10052 dgst_pos3 = 3;
10053 break;
10054
10055 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10056 salt_type = SALT_TYPE_NONE;
10057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10058 opts_type = OPTS_TYPE_PT_GENERATE_LE
10059 | OPTS_TYPE_PT_ADD01;
10060 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10061 dgst_size = DGST_SIZE_4_8;
10062 parse_func = gost2012sbog_256_parse_hash;
10063 sort_by_digest = sort_by_digest_4_8;
10064 opti_type = OPTI_TYPE_ZERO_BYTE;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10072 salt_type = SALT_TYPE_NONE;
10073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE
10075 | OPTS_TYPE_PT_ADD01;
10076 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10077 dgst_size = DGST_SIZE_4_16;
10078 parse_func = gost2012sbog_512_parse_hash;
10079 sort_by_digest = sort_by_digest_4_16;
10080 opti_type = OPTI_TYPE_ZERO_BYTE;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE
10091 | OPTS_TYPE_ST_BASE64
10092 | OPTS_TYPE_HASH_COPY;
10093 kern_type = KERN_TYPE_PBKDF2_MD5;
10094 dgst_size = DGST_SIZE_4_32;
10095 parse_func = pbkdf2_md5_parse_hash;
10096 sort_by_digest = sort_by_digest_4_32;
10097 opti_type = OPTI_TYPE_ZERO_BYTE;
10098 dgst_pos0 = 0;
10099 dgst_pos1 = 1;
10100 dgst_pos2 = 2;
10101 dgst_pos3 = 3;
10102 break;
10103
10104 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10105 salt_type = SALT_TYPE_EMBEDDED;
10106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10107 opts_type = OPTS_TYPE_PT_GENERATE_LE
10108 | OPTS_TYPE_ST_BASE64
10109 | OPTS_TYPE_HASH_COPY;
10110 kern_type = KERN_TYPE_PBKDF2_SHA1;
10111 dgst_size = DGST_SIZE_4_32;
10112 parse_func = pbkdf2_sha1_parse_hash;
10113 sort_by_digest = sort_by_digest_4_32;
10114 opti_type = OPTI_TYPE_ZERO_BYTE;
10115 dgst_pos0 = 0;
10116 dgst_pos1 = 1;
10117 dgst_pos2 = 2;
10118 dgst_pos3 = 3;
10119 break;
10120
10121 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10122 salt_type = SALT_TYPE_EMBEDDED;
10123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10124 opts_type = OPTS_TYPE_PT_GENERATE_LE
10125 | OPTS_TYPE_ST_BASE64
10126 | OPTS_TYPE_HASH_COPY;
10127 kern_type = KERN_TYPE_PBKDF2_SHA512;
10128 dgst_size = DGST_SIZE_8_16;
10129 parse_func = pbkdf2_sha512_parse_hash;
10130 sort_by_digest = sort_by_digest_8_16;
10131 opti_type = OPTI_TYPE_ZERO_BYTE
10132 | OPTI_TYPE_USES_BITS_64;
10133 dgst_pos0 = 0;
10134 dgst_pos1 = 1;
10135 dgst_pos2 = 2;
10136 dgst_pos3 = 3;
10137 break;
10138
10139 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10140 salt_type = SALT_TYPE_EMBEDDED;
10141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10142 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10143 kern_type = KERN_TYPE_ECRYPTFS;
10144 dgst_size = DGST_SIZE_8_8;
10145 parse_func = ecryptfs_parse_hash;
10146 sort_by_digest = sort_by_digest_8_8;
10147 opti_type = OPTI_TYPE_ZERO_BYTE
10148 | OPTI_TYPE_USES_BITS_64;
10149 dgst_pos0 = 0;
10150 dgst_pos1 = 1;
10151 dgst_pos2 = 2;
10152 dgst_pos3 = 3;
10153 break;
10154
10155 case 12300: hash_type = HASH_TYPE_ORACLET;
10156 salt_type = SALT_TYPE_EMBEDDED;
10157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10159 kern_type = KERN_TYPE_ORACLET;
10160 dgst_size = DGST_SIZE_8_16;
10161 parse_func = oraclet_parse_hash;
10162 sort_by_digest = sort_by_digest_8_16;
10163 opti_type = OPTI_TYPE_ZERO_BYTE
10164 | OPTI_TYPE_USES_BITS_64;
10165 dgst_pos0 = 0;
10166 dgst_pos1 = 1;
10167 dgst_pos2 = 2;
10168 dgst_pos3 = 3;
10169 break;
10170
10171 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10172 salt_type = SALT_TYPE_EMBEDDED;
10173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10175 kern_type = KERN_TYPE_BSDICRYPT;
10176 dgst_size = DGST_SIZE_4_4;
10177 parse_func = bsdicrypt_parse_hash;
10178 sort_by_digest = sort_by_digest_4_4;
10179 opti_type = OPTI_TYPE_ZERO_BYTE
10180 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 1;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 3;
10185 break;
10186
10187 case 12500: hash_type = HASH_TYPE_RAR3HP;
10188 salt_type = SALT_TYPE_EMBEDDED;
10189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10191 kern_type = KERN_TYPE_RAR3;
10192 dgst_size = DGST_SIZE_4_4;
10193 parse_func = rar3hp_parse_hash;
10194 sort_by_digest = sort_by_digest_4_4;
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 12600: hash_type = HASH_TYPE_SHA256;
10203 salt_type = SALT_TYPE_INTERN;
10204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_BE
10206 | OPTS_TYPE_PT_ADD80;
10207 kern_type = KERN_TYPE_CF10;
10208 dgst_size = DGST_SIZE_4_8;
10209 parse_func = cf10_parse_hash;
10210 sort_by_digest = sort_by_digest_4_8;
10211 opti_type = OPTI_TYPE_ZERO_BYTE
10212 | OPTI_TYPE_PRECOMPUTE_INIT
10213 | OPTI_TYPE_EARLY_SKIP
10214 | OPTI_TYPE_NOT_ITERATED;
10215 dgst_pos0 = 3;
10216 dgst_pos1 = 7;
10217 dgst_pos2 = 2;
10218 dgst_pos3 = 6;
10219 break;
10220
10221 case 12700: hash_type = HASH_TYPE_AES;
10222 salt_type = SALT_TYPE_EMBEDDED;
10223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10224 opts_type = OPTS_TYPE_PT_GENERATE_LE
10225 | OPTS_TYPE_HASH_COPY;
10226 kern_type = KERN_TYPE_MYWALLET;
10227 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10228 parse_func = mywallet_parse_hash;
10229 sort_by_digest = sort_by_digest_4_5;
10230 opti_type = OPTI_TYPE_ZERO_BYTE;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_MS_DRSR;
10242 dgst_size = DGST_SIZE_4_8;
10243 parse_func = ms_drsr_parse_hash;
10244 sort_by_digest = sort_by_digest_4_8;
10245 opti_type = OPTI_TYPE_ZERO_BYTE;
10246 dgst_pos0 = 0;
10247 dgst_pos1 = 1;
10248 dgst_pos2 = 2;
10249 dgst_pos3 = 3;
10250 break;
10251
10252 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
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_ANDROIDFDE_SAMSUNG;
10257 dgst_size = DGST_SIZE_4_8;
10258 parse_func = androidfde_samsung_parse_hash;
10259 sort_by_digest = sort_by_digest_4_8;
10260 opti_type = OPTI_TYPE_ZERO_BYTE;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_RAR5;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = rar5_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE;
10276 dgst_pos0 = 0;
10277 dgst_pos1 = 1;
10278 dgst_pos2 = 2;
10279 dgst_pos3 = 3;
10280 break;
10281
10282 default: usage_mini_print (PROGNAME); return (-1);
10283 }
10284
10285 /**
10286 * transpose
10287 */
10288
10289 data.parse_func = parse_func;
10290
10291 /**
10292 * misc stuff
10293 */
10294
10295 if (hex_salt)
10296 {
10297 if (salt_type == SALT_TYPE_INTERN)
10298 {
10299 opts_type |= OPTS_TYPE_ST_HEX;
10300 }
10301 else
10302 {
10303 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10304
10305 return (-1);
10306 }
10307 }
10308
10309 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10310 | (salt_type == SALT_TYPE_EXTERN)
10311 | (salt_type == SALT_TYPE_EMBEDDED)
10312 | (salt_type == SALT_TYPE_VIRTUAL));
10313
10314 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10315
10316 data.hash_type = hash_type;
10317 data.attack_mode = attack_mode;
10318 data.attack_kern = attack_kern;
10319 data.attack_exec = attack_exec;
10320 data.kern_type = kern_type;
10321 data.opts_type = opts_type;
10322 data.dgst_size = dgst_size;
10323 data.salt_type = salt_type;
10324 data.isSalted = isSalted;
10325 data.sort_by_digest = sort_by_digest;
10326 data.dgst_pos0 = dgst_pos0;
10327 data.dgst_pos1 = dgst_pos1;
10328 data.dgst_pos2 = dgst_pos2;
10329 data.dgst_pos3 = dgst_pos3;
10330
10331 esalt_size = 0;
10332
10333 switch (hash_mode)
10334 {
10335 case 2500: esalt_size = sizeof (wpa_t); break;
10336 case 5300: esalt_size = sizeof (ikepsk_t); break;
10337 case 5400: esalt_size = sizeof (ikepsk_t); break;
10338 case 5500: esalt_size = sizeof (netntlm_t); break;
10339 case 5600: esalt_size = sizeof (netntlm_t); break;
10340 case 6211: esalt_size = sizeof (tc_t); break;
10341 case 6212: esalt_size = sizeof (tc_t); break;
10342 case 6213: esalt_size = sizeof (tc_t); break;
10343 case 6221: esalt_size = sizeof (tc_t); break;
10344 case 6222: esalt_size = sizeof (tc_t); break;
10345 case 6223: esalt_size = sizeof (tc_t); break;
10346 case 6231: esalt_size = sizeof (tc_t); break;
10347 case 6232: esalt_size = sizeof (tc_t); break;
10348 case 6233: esalt_size = sizeof (tc_t); break;
10349 case 6241: esalt_size = sizeof (tc_t); break;
10350 case 6242: esalt_size = sizeof (tc_t); break;
10351 case 6243: esalt_size = sizeof (tc_t); break;
10352 case 6600: esalt_size = sizeof (agilekey_t); break;
10353 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10354 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10355 case 7300: esalt_size = sizeof (rakp_t); break;
10356 case 7500: esalt_size = sizeof (krb5pa_t); break;
10357 case 8200: esalt_size = sizeof (cloudkey_t); break;
10358 case 8800: esalt_size = sizeof (androidfde_t); break;
10359 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10360 case 9400: esalt_size = sizeof (office2007_t); break;
10361 case 9500: esalt_size = sizeof (office2010_t); break;
10362 case 9600: esalt_size = sizeof (office2013_t); break;
10363 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10364 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10365 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10366 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10367 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10368 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10369 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10370 case 10200: esalt_size = sizeof (cram_md5_t); break;
10371 case 10400: esalt_size = sizeof (pdf_t); break;
10372 case 10410: esalt_size = sizeof (pdf_t); break;
10373 case 10420: esalt_size = sizeof (pdf_t); break;
10374 case 10500: esalt_size = sizeof (pdf_t); break;
10375 case 10600: esalt_size = sizeof (pdf_t); break;
10376 case 10700: esalt_size = sizeof (pdf_t); break;
10377 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10378 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10379 case 11400: esalt_size = sizeof (sip_t); break;
10380 case 11600: esalt_size = sizeof (seven_zip_t); break;
10381 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10382 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10383 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10384 case 13000: esalt_size = sizeof (rar5_t); break;
10385 }
10386
10387 data.esalt_size = esalt_size;
10388
10389 /**
10390 * choose dictionary parser
10391 */
10392
10393 if (hash_type == HASH_TYPE_LM)
10394 {
10395 get_next_word_func = get_next_word_lm;
10396 }
10397 else if (opts_type & OPTS_TYPE_PT_UPPER)
10398 {
10399 get_next_word_func = get_next_word_uc;
10400 }
10401 else
10402 {
10403 get_next_word_func = get_next_word_std;
10404 }
10405
10406 /**
10407 * dictstat
10408 */
10409
10410 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10411
10412 #ifdef _POSIX
10413 size_t dictstat_nmemb = 0;
10414 #endif
10415
10416 #ifdef _WIN
10417 uint dictstat_nmemb = 0;
10418 #endif
10419
10420 char dictstat[256] = { 0 };
10421
10422 FILE *dictstat_fp = NULL;
10423
10424 if (keyspace == 0)
10425 {
10426 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10427
10428 dictstat_fp = fopen (dictstat, "rb");
10429
10430 if (dictstat_fp)
10431 {
10432 #ifdef _POSIX
10433 struct stat tmpstat;
10434
10435 fstat (fileno (dictstat_fp), &tmpstat);
10436 #endif
10437
10438 #ifdef _WIN
10439 struct stat64 tmpstat;
10440
10441 _fstat64 (fileno (dictstat_fp), &tmpstat);
10442 #endif
10443
10444 if (tmpstat.st_mtime < COMPTIME)
10445 {
10446 /* with v0.15 the format changed so we have to ensure user is using a good version
10447 since there is no version-header in the dictstat file */
10448
10449 fclose (dictstat_fp);
10450
10451 unlink (dictstat);
10452 }
10453 else
10454 {
10455 while (!feof (dictstat_fp))
10456 {
10457 dictstat_t d;
10458
10459 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10460
10461 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10462
10463 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10464 {
10465 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10466
10467 return -1;
10468 }
10469 }
10470
10471 fclose (dictstat_fp);
10472 }
10473 }
10474 }
10475
10476 /**
10477 * potfile
10478 */
10479
10480 char potfile[256] = { 0 };
10481
10482 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10483
10484 data.pot_fp = NULL;
10485
10486 FILE *out_fp = NULL;
10487 FILE *pot_fp = NULL;
10488
10489 if (show == 1 || left == 1)
10490 {
10491 pot_fp = fopen (potfile, "rb");
10492
10493 if (pot_fp == NULL)
10494 {
10495 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10496
10497 return (-1);
10498 }
10499
10500 if (outfile != NULL)
10501 {
10502 if ((out_fp = fopen (outfile, "ab")) == NULL)
10503 {
10504 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10505
10506 fclose (pot_fp);
10507
10508 return (-1);
10509 }
10510 }
10511 else
10512 {
10513 out_fp = stdout;
10514 }
10515 }
10516 else
10517 {
10518 if (potfile_disable == 0)
10519 {
10520 pot_fp = fopen (potfile, "ab");
10521
10522 if (pot_fp == NULL)
10523 {
10524 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10525
10526 return (-1);
10527 }
10528
10529 data.pot_fp = pot_fp;
10530 }
10531 }
10532
10533 pot_t *pot = NULL;
10534
10535 uint pot_cnt = 0;
10536 uint pot_avail = 0;
10537
10538 if (show == 1 || left == 1)
10539 {
10540 SUPPRESS_OUTPUT = 1;
10541
10542 pot_avail = count_lines (pot_fp);
10543
10544 rewind (pot_fp);
10545
10546 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10547
10548 uint pot_hashes_avail = 0;
10549
10550 uint line_num = 0;
10551
10552 while (!feof (pot_fp))
10553 {
10554 line_num++;
10555
10556 char line_buf[BUFSIZ] = { 0 };
10557
10558 int line_len = fgetl (pot_fp, line_buf);
10559
10560 if (line_len == 0) continue;
10561
10562 char *plain_buf = line_buf + line_len;
10563
10564 pot_t *pot_ptr = &pot[pot_cnt];
10565
10566 hash_t *hashes_buf = &pot_ptr->hash;
10567
10568 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10569 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10570
10571 if (pot_cnt == pot_hashes_avail)
10572 {
10573 uint pos = 0;
10574
10575 for (pos = 0; pos < INCR_POT; pos++)
10576 {
10577 if ((pot_cnt + pos) >= pot_avail) break;
10578
10579 pot_t *tmp_pot = &pot[pot_cnt + pos];
10580
10581 hash_t *tmp_hash = &tmp_pot->hash;
10582
10583 tmp_hash->digest = mymalloc (dgst_size);
10584
10585 if (isSalted)
10586 {
10587 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10588 }
10589
10590 if (esalt_size)
10591 {
10592 tmp_hash->esalt = mymalloc (esalt_size);
10593 }
10594
10595 pot_hashes_avail++;
10596 }
10597 }
10598
10599 int plain_len = 0;
10600
10601 int parser_status;
10602
10603 int iter = MAX_CUT_TRIES;
10604
10605 do
10606 {
10607 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10608 {
10609 if (line_buf[i] == ':')
10610 {
10611 line_len--;
10612
10613 break;
10614 }
10615 }
10616
10617 if (data.hash_mode != 2500)
10618 {
10619 parser_status = parse_func (line_buf, line_len, hashes_buf);
10620 }
10621 else
10622 {
10623 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10624
10625 if (line_len > max_salt_size)
10626 {
10627 parser_status = PARSER_GLOBAL_LENGTH;
10628 }
10629 else
10630 {
10631 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10632
10633 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10634
10635 hashes_buf->salt->salt_len = line_len;
10636
10637 parser_status = PARSER_OK;
10638 }
10639 }
10640
10641 // if NOT parsed without error, we add the ":" to the plain
10642
10643 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10644 {
10645 plain_len++;
10646 plain_buf--;
10647 }
10648
10649 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10650
10651 if (parser_status < PARSER_GLOBAL_ZERO)
10652 {
10653 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10654
10655 continue;
10656 }
10657
10658 if (plain_len >= 255) continue;
10659
10660 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10661
10662 pot_ptr->plain_len = plain_len;
10663
10664 pot_cnt++;
10665 }
10666
10667 fclose (pot_fp);
10668
10669 SUPPRESS_OUTPUT = 0;
10670
10671 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10672 }
10673
10674 /**
10675 * word len
10676 */
10677
10678 uint pw_min = PW_MIN;
10679 uint pw_max = PW_MAX;
10680
10681 switch (hash_mode)
10682 {
10683 case 400: if (pw_max > 40) pw_max = 40;
10684 break;
10685 case 500: if (pw_max > 16) pw_max = 16;
10686 break;
10687 case 1500: if (pw_max > 8) pw_max = 8;
10688 break;
10689 case 1600: if (pw_max > 16) pw_max = 16;
10690 break;
10691 case 1800: if (pw_max > 16) pw_max = 16;
10692 break;
10693 case 2100: if (pw_max > 16) pw_max = 16;
10694 break;
10695 case 2500: if (pw_min < 8) pw_min = 8;
10696 break;
10697 case 3000: if (pw_max > 7) pw_max = 7;
10698 break;
10699 case 5200: if (pw_max > 24) pw_max = 24;
10700 break;
10701 case 5800: if (pw_max > 16) pw_max = 16;
10702 break;
10703 case 6300: if (pw_max > 16) pw_max = 16;
10704 break;
10705 case 7400: if (pw_max > 16) pw_max = 16;
10706 break;
10707 case 7900: if (pw_max > 48) pw_max = 48;
10708 break;
10709 case 8500: if (pw_max > 8) pw_max = 8;
10710 break;
10711 case 8600: if (pw_max > 16) pw_max = 16;
10712 break;
10713 case 9710: pw_min = 5;
10714 pw_max = 5;
10715 break;
10716 case 9810: pw_min = 5;
10717 pw_max = 5;
10718 break;
10719 case 10410: pw_min = 5;
10720 pw_max = 5;
10721 break;
10722 case 10300: if (pw_max < 3) pw_min = 3;
10723 if (pw_max > 40) pw_max = 40;
10724 break;
10725 case 10500: if (pw_max < 3) pw_min = 3;
10726 if (pw_max > 40) pw_max = 40;
10727 break;
10728 case 10700: if (pw_max > 16) pw_max = 16;
10729 break;
10730 case 11300: if (pw_max > 40) pw_max = 40;
10731 break;
10732 case 12500: if (pw_max > 20) pw_max = 20;
10733 break;
10734 case 12800: if (pw_max > 24) pw_max = 24;
10735 break;
10736 }
10737
10738 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10739 {
10740 switch (attack_kern)
10741 {
10742 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10743 break;
10744 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10745 break;
10746 }
10747 }
10748
10749 /**
10750 * charsets : keep them together for more easy maintainnce
10751 */
10752
10753 cs_t mp_sys[6] = { { { 0 }, 0 } };
10754 cs_t mp_usr[4] = { { { 0 }, 0 } };
10755
10756 mp_setup_sys (mp_sys);
10757
10758 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10759 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10760 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10761 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10762
10763 /**
10764 * load hashes, part I: find input mode, count hashes
10765 */
10766
10767 uint hashlist_mode = 0;
10768 uint hashlist_format = HLFMT_HASHCAT;
10769
10770 uint hashes_avail = 0;
10771
10772 if (benchmark == 0)
10773 {
10774 struct stat f;
10775
10776 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10777
10778 if ((hash_mode == 2500) ||
10779 (hash_mode == 5200) ||
10780 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10781 (hash_mode == 9000))
10782 {
10783 hashlist_mode = HL_MODE_ARG;
10784
10785 char *hashfile = myargv[optind];
10786
10787 data.hashfile = hashfile;
10788
10789 logfile_top_var_string ("target", hashfile);
10790 }
10791
10792 if (hashlist_mode == HL_MODE_ARG)
10793 {
10794 if (hash_mode == 2500)
10795 {
10796 struct stat st;
10797
10798 if (stat (data.hashfile, &st) == -1)
10799 {
10800 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10801
10802 return (-1);
10803 }
10804
10805 hashes_avail = st.st_size / sizeof (hccap_t);
10806 }
10807 else
10808 {
10809 hashes_avail = 1;
10810 }
10811 }
10812 else if (hashlist_mode == HL_MODE_FILE)
10813 {
10814 char *hashfile = myargv[optind];
10815
10816 data.hashfile = hashfile;
10817
10818 logfile_top_var_string ("target", hashfile);
10819
10820 FILE *fp = NULL;
10821
10822 if ((fp = fopen (hashfile, "rb")) == NULL)
10823 {
10824 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10825
10826 return (-1);
10827 }
10828
10829 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10830
10831 hashes_avail = count_lines (fp);
10832
10833 rewind (fp);
10834
10835 if (hashes_avail == 0)
10836 {
10837 log_error ("ERROR: hashfile is empty or corrupt");
10838
10839 fclose (fp);
10840
10841 return (-1);
10842 }
10843
10844 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10845
10846 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10847 {
10848 log_error ("ERROR: remove not supported in native hashfile-format mode");
10849
10850 fclose (fp);
10851
10852 return (-1);
10853 }
10854
10855 fclose (fp);
10856 }
10857 }
10858 else
10859 {
10860 hashlist_mode = HL_MODE_ARG;
10861
10862 hashes_avail = 1;
10863 }
10864
10865 if (hash_mode == 3000) hashes_avail *= 2;
10866
10867 data.hashlist_mode = hashlist_mode;
10868 data.hashlist_format = hashlist_format;
10869
10870 logfile_top_uint (hashlist_mode);
10871 logfile_top_uint (hashlist_format);
10872
10873 /**
10874 * load hashes, part II: allocate required memory, set pointers
10875 */
10876
10877 hash_t *hashes_buf = NULL;
10878 void *digests_buf = NULL;
10879 salt_t *salts_buf = NULL;
10880 void *esalts_buf = NULL;
10881
10882 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10883
10884 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10885
10886 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10887 {
10888 u32 hash_pos;
10889
10890 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10891 {
10892 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10893
10894 hashes_buf[hash_pos].hash_info = hash_info;
10895
10896 if (username && (remove || show || left))
10897 {
10898 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10899 }
10900
10901 if (benchmark)
10902 {
10903 hash_info->orighash = (char *) mymalloc (256);
10904 }
10905 }
10906 }
10907
10908 if (isSalted)
10909 {
10910 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10911
10912 if (esalt_size)
10913 {
10914 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10915 }
10916 }
10917 else
10918 {
10919 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10920 }
10921
10922 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10923 {
10924 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10925
10926 if (isSalted)
10927 {
10928 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10929
10930 if (esalt_size)
10931 {
10932 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10933 }
10934 }
10935 else
10936 {
10937 hashes_buf[hash_pos].salt = &salts_buf[0];
10938 }
10939 }
10940
10941 /**
10942 * load hashes, part III: parse hashes or generate them if benchmark
10943 */
10944
10945 uint hashes_cnt = 0;
10946
10947 if (benchmark == 0)
10948 {
10949 if (keyspace == 1)
10950 {
10951 // useless to read hash file for keyspace, cheat a little bit w/ optind
10952 }
10953 else if (hashes_avail == 0)
10954 {
10955 }
10956 else if (hashlist_mode == HL_MODE_ARG)
10957 {
10958 char *input_buf = myargv[optind];
10959
10960 uint input_len = strlen (input_buf);
10961
10962 logfile_top_var_string ("target", input_buf);
10963
10964 char *hash_buf = NULL;
10965 int hash_len = 0;
10966
10967 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10968
10969 if (hash_len)
10970 {
10971 if (opts_type & OPTS_TYPE_HASH_COPY)
10972 {
10973 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10974
10975 hash_info_tmp->orighash = mystrdup (hash_buf);
10976 }
10977
10978 if (isSalted)
10979 {
10980 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10981 }
10982
10983 int parser_status = PARSER_OK;
10984
10985 if (hash_mode == 2500)
10986 {
10987 if (hash_len == 0)
10988 {
10989 log_error ("ERROR: hccap file not specified");
10990
10991 return (-1);
10992 }
10993
10994 hashlist_mode = HL_MODE_FILE;
10995
10996 data.hashlist_mode = hashlist_mode;
10997
10998 FILE *fp = fopen (hash_buf, "rb");
10999
11000 if (fp == NULL)
11001 {
11002 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11003
11004 return (-1);
11005 }
11006
11007 if (hashes_avail < 1)
11008 {
11009 log_error ("ERROR: hccap file is empty or corrupt");
11010
11011 fclose (fp);
11012
11013 return (-1);
11014 }
11015
11016 uint hccap_size = sizeof (hccap_t);
11017
11018 char *in = (char *) mymalloc (hccap_size);
11019
11020 while (!feof (fp))
11021 {
11022 int n = fread (in, hccap_size, 1, fp);
11023
11024 if (n != 1)
11025 {
11026 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11027
11028 break;
11029 }
11030
11031 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11032
11033 if (parser_status != PARSER_OK)
11034 {
11035 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11036
11037 continue;
11038 }
11039
11040 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11041
11042 if ((show == 1) || (left == 1))
11043 {
11044 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11045
11046 char *salt_ptr = (char *) tmp_salt->salt_buf;
11047
11048 int cur_pos = tmp_salt->salt_len;
11049 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11050
11051 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11052
11053 u8 *pke_ptr = (u8 *) wpa->pke;
11054
11055 // do the appending task
11056
11057 snprintf (salt_ptr + cur_pos,
11058 rem_len,
11059 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11060 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
11061 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
11062
11063
11064 // memset () the remaining part of the salt
11065
11066 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11067 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11068
11069 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11070
11071 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11072 }
11073
11074 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);
11075 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);
11076
11077 hashes_cnt++;
11078 }
11079
11080 fclose (fp);
11081
11082 myfree (in);
11083 }
11084 else if (hash_mode == 3000)
11085 {
11086 if (hash_len == 32)
11087 {
11088 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11089
11090 hash_t *lm_hash_left = NULL;
11091
11092 if (parser_status == PARSER_OK)
11093 {
11094 lm_hash_left = &hashes_buf[hashes_cnt];
11095
11096 hashes_cnt++;
11097 }
11098 else
11099 {
11100 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11101 }
11102
11103 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11104
11105 hash_t *lm_hash_right = NULL;
11106
11107 if (parser_status == PARSER_OK)
11108 {
11109 lm_hash_right = &hashes_buf[hashes_cnt];
11110
11111 hashes_cnt++;
11112 }
11113 else
11114 {
11115 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11116 }
11117
11118 // show / left
11119
11120 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11121 {
11122 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);
11123 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);
11124 }
11125 }
11126 else
11127 {
11128 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11129
11130 if (parser_status == PARSER_OK)
11131 {
11132 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11133 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134 }
11135
11136 if (parser_status == PARSER_OK)
11137 {
11138 hashes_cnt++;
11139 }
11140 else
11141 {
11142 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11143 }
11144 }
11145 }
11146 else
11147 {
11148 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11149
11150 if (parser_status == PARSER_OK)
11151 {
11152 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11153 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11154 }
11155
11156 if (parser_status == PARSER_OK)
11157 {
11158 hashes_cnt++;
11159 }
11160 else
11161 {
11162 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11163 }
11164 }
11165 }
11166 }
11167 else if (hashlist_mode == HL_MODE_FILE)
11168 {
11169 char *hashfile = data.hashfile;
11170
11171 FILE *fp;
11172
11173 if ((fp = fopen (hashfile, "rb")) == NULL)
11174 {
11175 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11176
11177 return (-1);
11178 }
11179
11180 uint line_num = 0;
11181
11182 while (!feof (fp))
11183 {
11184 line_num++;
11185
11186 char line_buf[BUFSIZ] = { 0 };
11187
11188 int line_len = fgetl (fp, line_buf);
11189
11190 if (line_len == 0) continue;
11191
11192 char *hash_buf = NULL;
11193 int hash_len = 0;
11194
11195 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11196
11197 if (username)
11198 {
11199 char *user_buf = NULL;
11200 int user_len = 0;
11201
11202 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11203
11204 if (remove || show)
11205 {
11206 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11207
11208 *user = (user_t *) mymalloc (sizeof (user_t));
11209
11210 user_t *user_ptr = *user;
11211
11212 if (user_buf != NULL)
11213 {
11214 user_ptr->user_name = mystrdup (user_buf);
11215 }
11216 else
11217 {
11218 user_ptr->user_name = mystrdup ("");
11219 }
11220
11221 user_ptr->user_len = user_len;
11222 }
11223 }
11224
11225 if (opts_type & OPTS_TYPE_HASH_COPY)
11226 {
11227 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11228
11229 hash_info_tmp->orighash = mystrdup (hash_buf);
11230 }
11231
11232 if (isSalted)
11233 {
11234 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11235 }
11236
11237 if (hash_mode == 3000)
11238 {
11239 if (hash_len == 32)
11240 {
11241 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11242
11243 if (parser_status < PARSER_GLOBAL_ZERO)
11244 {
11245 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11246
11247 continue;
11248 }
11249
11250 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11251
11252 hashes_cnt++;
11253
11254 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11255
11256 if (parser_status < PARSER_GLOBAL_ZERO)
11257 {
11258 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11259
11260 continue;
11261 }
11262
11263 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11264
11265 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);
11266
11267 hashes_cnt++;
11268
11269 // show / left
11270
11271 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);
11272 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);
11273 }
11274 else
11275 {
11276 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11277
11278 if (parser_status < PARSER_GLOBAL_ZERO)
11279 {
11280 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11281
11282 continue;
11283 }
11284
11285 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);
11286
11287 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11288 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11289
11290 hashes_cnt++;
11291 }
11292 }
11293 else
11294 {
11295 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11296
11297 if (parser_status < PARSER_GLOBAL_ZERO)
11298 {
11299 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11300
11301 continue;
11302 }
11303
11304 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);
11305
11306 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11307 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11308
11309 hashes_cnt++;
11310 }
11311 }
11312
11313 fclose (fp);
11314
11315 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11316
11317 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11318 }
11319 }
11320 else
11321 {
11322 if (isSalted)
11323 {
11324 hashes_buf[0].salt->salt_len = 8;
11325
11326 // special salt handling
11327
11328 switch (hash_mode)
11329 {
11330 case 1500: hashes_buf[0].salt->salt_len = 2;
11331 break;
11332 case 1731: hashes_buf[0].salt->salt_len = 4;
11333 break;
11334 case 2410: hashes_buf[0].salt->salt_len = 4;
11335 break;
11336 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11337 break;
11338 case 3100: hashes_buf[0].salt->salt_len = 1;
11339 break;
11340 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11341 break;
11342 case 5800: hashes_buf[0].salt->salt_len = 16;
11343 break;
11344 case 6800: hashes_buf[0].salt->salt_len = 32;
11345 break;
11346 case 8400: hashes_buf[0].salt->salt_len = 40;
11347 break;
11348 case 8800: hashes_buf[0].salt->salt_len = 16;
11349 break;
11350 case 8900: hashes_buf[0].salt->salt_len = 16;
11351 hashes_buf[0].salt->scrypt_N = 1024;
11352 hashes_buf[0].salt->scrypt_r = 1;
11353 hashes_buf[0].salt->scrypt_p = 1;
11354 break;
11355 case 9100: hashes_buf[0].salt->salt_len = 16;
11356 break;
11357 case 9300: hashes_buf[0].salt->salt_len = 14;
11358 hashes_buf[0].salt->scrypt_N = 16384;
11359 hashes_buf[0].salt->scrypt_r = 1;
11360 hashes_buf[0].salt->scrypt_p = 1;
11361 break;
11362 case 9400: hashes_buf[0].salt->salt_len = 16;
11363 break;
11364 case 9500: hashes_buf[0].salt->salt_len = 16;
11365 break;
11366 case 9600: hashes_buf[0].salt->salt_len = 16;
11367 break;
11368 case 9700: hashes_buf[0].salt->salt_len = 16;
11369 break;
11370 case 9710: hashes_buf[0].salt->salt_len = 16;
11371 break;
11372 case 9720: hashes_buf[0].salt->salt_len = 16;
11373 break;
11374 case 9800: hashes_buf[0].salt->salt_len = 16;
11375 break;
11376 case 9810: hashes_buf[0].salt->salt_len = 16;
11377 break;
11378 case 9820: hashes_buf[0].salt->salt_len = 16;
11379 break;
11380 case 10300: hashes_buf[0].salt->salt_len = 12;
11381 break;
11382 case 11500: hashes_buf[0].salt->salt_len = 4;
11383 break;
11384 case 11600: hashes_buf[0].salt->salt_len = 4;
11385 break;
11386 case 12400: hashes_buf[0].salt->salt_len = 4;
11387 break;
11388 case 12500: hashes_buf[0].salt->salt_len = 8;
11389 break;
11390 case 12600: hashes_buf[0].salt->salt_len = 64;
11391 break;
11392 }
11393
11394 // special esalt handling
11395
11396 switch (hash_mode)
11397 {
11398 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11399 break;
11400 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11401 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11402 break;
11403 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11404 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11405 break;
11406 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11407 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11408 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11409 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11410 break;
11411 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11412 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11413 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11414 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11415 break;
11416 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11417 break;
11418 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11419 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11420 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11421 break;
11422 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11423 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11424 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11425 break;
11426 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11427 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11428 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11429 break;
11430 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11431 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11432 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11433 break;
11434 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11435 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11436 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11437 break;
11438 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11439 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11440 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11441 break;
11442 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11443 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11444 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11445 break;
11446 }
11447 }
11448
11449 // set hashfile
11450
11451 switch (hash_mode)
11452 {
11453 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11454 break;
11455 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11456 break;
11457 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11458 break;
11459 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11460 break;
11461 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11462 break;
11463 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11464 break;
11465 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11466 break;
11467 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11468 break;
11469 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11470 break;
11471 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11472 break;
11473 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11474 break;
11475 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11476 break;
11477 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11478 break;
11479 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11480 break;
11481 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11482 break;
11483 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11484 break;
11485 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11486 break;
11487 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11488 break;
11489 }
11490
11491 // set default iterations
11492
11493 switch (hash_mode)
11494 {
11495 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11496 break;
11497 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11498 break;
11499 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11500 break;
11501 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11502 break;
11503 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11504 break;
11505 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11506 break;
11507 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11508 break;
11509 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11510 break;
11511 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11512 break;
11513 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11514 break;
11515 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11516 break;
11517 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11518 break;
11519 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11520 break;
11521 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11522 break;
11523 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11524 break;
11525 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11526 break;
11527 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11528 break;
11529 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11530 break;
11531 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11532 break;
11533 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11534 break;
11535 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11536 break;
11537 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11538 break;
11539 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11540 break;
11541 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11542 break;
11543 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11544 break;
11545 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11546 break;
11547 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11548 break;
11549 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11550 break;
11551 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11552 break;
11553 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11554 break;
11555 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11556 break;
11557 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11558 break;
11559 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11560 break;
11561 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11562 break;
11563 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11564 break;
11565 case 8900: hashes_buf[0].salt->salt_iter = 1;
11566 break;
11567 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11568 break;
11569 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11570 break;
11571 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11572 break;
11573 case 9300: hashes_buf[0].salt->salt_iter = 1;
11574 break;
11575 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11576 break;
11577 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11578 break;
11579 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11580 break;
11581 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11582 break;
11583 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11584 break;
11585 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11586 break;
11587 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11588 break;
11589 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11590 break;
11591 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11592 break;
11593 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11594 break;
11595 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11596 break;
11597 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11598 break;
11599 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11600 break;
11601 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11602 break;
11603 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11604 break;
11605 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11606 break;
11607 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11608 break;
11609 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11610 break;
11611 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11612 break;
11613 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11614 break;
11615 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11616 break;
11617 }
11618
11619 hashes_cnt = 1;
11620 }
11621
11622 if (show == 1 || left == 1)
11623 {
11624 for (uint i = 0; i < pot_cnt; i++)
11625 {
11626 pot_t *pot_ptr = &pot[i];
11627
11628 hash_t *hashes_buf = &pot_ptr->hash;
11629
11630 local_free (hashes_buf->digest);
11631
11632 if (isSalted)
11633 {
11634 local_free (hashes_buf->salt);
11635 }
11636 }
11637
11638 local_free (pot);
11639
11640 if (data.quiet == 0) log_info_nn ("");
11641
11642 return (0);
11643 }
11644
11645 if (keyspace == 0)
11646 {
11647 if (hashes_cnt == 0)
11648 {
11649 log_error ("ERROR: No hashes loaded");
11650
11651 return (-1);
11652 }
11653 }
11654
11655 /**
11656 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11657 */
11658
11659 if (data.outfile != NULL)
11660 {
11661 if (data.hashfile != NULL)
11662 {
11663 #ifdef _POSIX
11664 struct stat tmpstat_outfile;
11665 struct stat tmpstat_hashfile;
11666 #endif
11667
11668 #ifdef _WIN
11669 struct stat64 tmpstat_outfile;
11670 struct stat64 tmpstat_hashfile;
11671 #endif
11672
11673 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11674
11675 if (tmp_outfile_fp)
11676 {
11677 #ifdef _POSIX
11678 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11679 #endif
11680
11681 #ifdef _WIN
11682 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11683 #endif
11684
11685 fclose (tmp_outfile_fp);
11686 }
11687
11688 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11689
11690 if (tmp_hashfile_fp)
11691 {
11692 #ifdef _POSIX
11693 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11694 #endif
11695
11696 #ifdef _WIN
11697 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11698 #endif
11699
11700 fclose (tmp_hashfile_fp);
11701 }
11702
11703 if (tmp_outfile_fp && tmp_outfile_fp)
11704 {
11705 tmpstat_outfile.st_mode = 0;
11706 tmpstat_outfile.st_nlink = 0;
11707 tmpstat_outfile.st_uid = 0;
11708 tmpstat_outfile.st_gid = 0;
11709 tmpstat_outfile.st_rdev = 0;
11710 tmpstat_outfile.st_atime = 0;
11711
11712 tmpstat_hashfile.st_mode = 0;
11713 tmpstat_hashfile.st_nlink = 0;
11714 tmpstat_hashfile.st_uid = 0;
11715 tmpstat_hashfile.st_gid = 0;
11716 tmpstat_hashfile.st_rdev = 0;
11717 tmpstat_hashfile.st_atime = 0;
11718
11719 #ifdef _POSIX
11720 tmpstat_outfile.st_blksize = 0;
11721 tmpstat_outfile.st_blocks = 0;
11722
11723 tmpstat_hashfile.st_blksize = 0;
11724 tmpstat_hashfile.st_blocks = 0;
11725 #endif
11726
11727 #ifdef _POSIX
11728 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11729 {
11730 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11731
11732 return (-1);
11733 }
11734 #endif
11735
11736 #ifdef _WIN
11737 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11738 {
11739 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11740
11741 return (-1);
11742 }
11743 #endif
11744 }
11745 }
11746 }
11747
11748 /**
11749 * Remove duplicates
11750 */
11751
11752 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11753
11754 if (isSalted)
11755 {
11756 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11757 }
11758 else
11759 {
11760 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11761 }
11762
11763 uint hashes_cnt_orig = hashes_cnt;
11764
11765 hashes_cnt = 1;
11766
11767 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11768 {
11769 if (isSalted)
11770 {
11771 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11772 {
11773 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11774 }
11775 }
11776 else
11777 {
11778 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11779 }
11780
11781 if (hashes_pos > hashes_cnt)
11782 {
11783 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11784 }
11785
11786 hashes_cnt++;
11787 }
11788
11789 /**
11790 * Potfile removes
11791 */
11792
11793 uint potfile_remove_cracks = 0;
11794
11795 if (potfile_disable == 0)
11796 {
11797 hash_t hash_buf;
11798
11799 hash_buf.digest = mymalloc (dgst_size);
11800 hash_buf.salt = NULL;
11801 hash_buf.esalt = NULL;
11802 hash_buf.hash_info = NULL;
11803 hash_buf.cracked = 0;
11804
11805 if (isSalted)
11806 {
11807 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11808 }
11809
11810 if (esalt_size)
11811 {
11812 hash_buf.esalt = mymalloc (esalt_size);
11813 }
11814
11815 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11816
11817 // no solution for these special hash types (for instane because they use hashfile in output etc)
11818 if ((hash_mode != 5200) &&
11819 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11820 (hash_mode != 9000))
11821 {
11822 FILE *fp = fopen (potfile, "rb");
11823
11824 if (fp != NULL)
11825 {
11826 while (!feof (fp))
11827 {
11828 char line_buf[BUFSIZ] = { 0 };
11829
11830 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11831
11832 if (ptr == NULL) break;
11833
11834 int line_len = strlen (line_buf);
11835
11836 if (line_len == 0) continue;
11837
11838 int iter = MAX_CUT_TRIES;
11839
11840 for (int i = line_len - 1; i && iter; i--, line_len--)
11841 {
11842 if (line_buf[i] != ':') continue;
11843
11844 if (isSalted)
11845 {
11846 memset (hash_buf.salt, 0, sizeof (salt_t));
11847 }
11848
11849 hash_t *found = NULL;
11850
11851 if (hash_mode == 6800)
11852 {
11853 if (i < 64) // 64 = 16 * uint in salt_buf[]
11854 {
11855 // manipulate salt_buf
11856 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11857
11858 hash_buf.salt->salt_len = i;
11859
11860 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11861 }
11862 }
11863 else if (hash_mode == 2500)
11864 {
11865 if (i < 64) // 64 = 16 * uint in salt_buf[]
11866 {
11867 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11868 // manipulate salt_buf
11869
11870 // to be safe work with a copy (because of line_len loop, i etc)
11871
11872 char line_buf_cpy[BUFSIZ] = { 0 };
11873
11874 memcpy (line_buf_cpy, line_buf, i);
11875
11876 char *mac2_pos = strrchr (line_buf_cpy, ':');
11877
11878 if (mac2_pos == NULL) continue;
11879
11880 mac2_pos[0] = 0;
11881 mac2_pos++;
11882
11883 if (strlen (mac2_pos) != 12) continue;
11884
11885 char *mac1_pos = strrchr (line_buf_cpy, ':');
11886
11887 if (mac1_pos == NULL) continue;
11888
11889 mac1_pos[0] = 0;
11890 mac1_pos++;
11891
11892 if (strlen (mac1_pos) != 12) continue;
11893
11894 uint essid_length = mac1_pos - line_buf_cpy - 1;
11895
11896 // here we need the ESSID
11897 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11898
11899 hash_buf.salt->salt_len = essid_length;
11900
11901 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11902
11903 if (found)
11904 {
11905 wpa_t *wpa = (wpa_t *) found->esalt;
11906
11907 uint pke[25] = { 0 };
11908
11909 char *pke_ptr = (char *) pke;
11910
11911 for (uint i = 0; i < 25; i++)
11912 {
11913 pke[i] = byte_swap_32 (wpa->pke[i]);
11914 }
11915
11916 u8 mac1[6] = { 0 };
11917 u8 mac2[6] = { 0 };
11918
11919 memcpy (mac1, pke_ptr + 23, 6);
11920 memcpy (mac2, pke_ptr + 29, 6);
11921
11922 // compare hex string(s) vs binary MAC address(es)
11923
11924 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11925 {
11926 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11927 {
11928 found = NULL;
11929 break;
11930 }
11931 }
11932
11933 // early skip ;)
11934 if (!found) continue;
11935
11936 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11937 {
11938 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11939 {
11940 found = NULL;
11941 break;
11942 }
11943 }
11944 }
11945 }
11946 }
11947 else
11948 {
11949 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11950
11951 if (parser_status == PARSER_OK)
11952 {
11953 if (isSalted)
11954 {
11955 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11956 }
11957 else
11958 {
11959 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11960 }
11961 }
11962 }
11963
11964 if (found == NULL) continue;
11965
11966 if (!found->cracked) potfile_remove_cracks++;
11967
11968 found->cracked = 1;
11969
11970 if (found) break;
11971
11972 iter--;
11973 }
11974 }
11975
11976 fclose (fp);
11977 }
11978 }
11979
11980 if (esalt_size)
11981 {
11982 local_free (hash_buf.esalt);
11983 }
11984
11985 if (isSalted)
11986 {
11987 local_free (hash_buf.salt);
11988 }
11989
11990 local_free (hash_buf.digest);
11991 }
11992
11993 /**
11994 * Now generate all the buffers required for later
11995 */
11996
11997 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11998
11999 salt_t *salts_buf_new = NULL;
12000 void *esalts_buf_new = NULL;
12001
12002 if (isSalted)
12003 {
12004 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12005
12006 if (esalt_size)
12007 {
12008 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12009 }
12010 }
12011 else
12012 {
12013 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12014 }
12015
12016 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12017
12018 uint digests_cnt = hashes_cnt;
12019 uint digests_done = 0;
12020
12021 uint size_digests = digests_cnt * dgst_size;
12022 uint size_shown = digests_cnt * sizeof (uint);
12023
12024 uint *digests_shown = (uint *) mymalloc (size_shown);
12025 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12026
12027 uint salts_cnt = 0;
12028 uint salts_done = 0;
12029
12030 hashinfo_t **hash_info = NULL;
12031
12032 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12033 {
12034 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12035
12036 if (username && (remove || show))
12037 {
12038 uint user_pos;
12039
12040 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12041 {
12042 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12043
12044 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12045 }
12046 }
12047 }
12048
12049 uint *salts_shown = (uint *) mymalloc (size_shown);
12050
12051 salt_t *salt_buf;
12052
12053 {
12054 // copied from inner loop
12055
12056 salt_buf = &salts_buf_new[salts_cnt];
12057
12058 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12059
12060 if (esalt_size)
12061 {
12062 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12063 }
12064
12065 salt_buf->digests_cnt = 0;
12066 salt_buf->digests_done = 0;
12067 salt_buf->digests_offset = 0;
12068
12069 salts_cnt++;
12070 }
12071
12072 if (hashes_buf[0].cracked == 1)
12073 {
12074 digests_shown[0] = 1;
12075
12076 digests_done++;
12077
12078 salt_buf->digests_done++;
12079 }
12080
12081 salt_buf->digests_cnt++;
12082
12083 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12084
12085 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12086 {
12087 hash_info[0] = hashes_buf[0].hash_info;
12088 }
12089
12090 // copy from inner loop
12091
12092 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12093 {
12094 if (isSalted)
12095 {
12096 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12097 {
12098 salt_buf = &salts_buf_new[salts_cnt];
12099
12100 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12101
12102 if (esalt_size)
12103 {
12104 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12105 }
12106
12107 salt_buf->digests_cnt = 0;
12108 salt_buf->digests_done = 0;
12109 salt_buf->digests_offset = hashes_pos;
12110
12111 salts_cnt++;
12112 }
12113 }
12114
12115 if (hashes_buf[hashes_pos].cracked == 1)
12116 {
12117 digests_shown[hashes_pos] = 1;
12118
12119 digests_done++;
12120
12121 salt_buf->digests_done++;
12122 }
12123
12124 salt_buf->digests_cnt++;
12125
12126 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12127
12128 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12129 {
12130 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12131 }
12132 }
12133
12134 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12135 {
12136 salt_t *salt_buf = &salts_buf_new[salt_pos];
12137
12138 if (salt_buf->digests_done == salt_buf->digests_cnt)
12139 {
12140 salts_shown[salt_pos] = 1;
12141
12142 salts_done++;
12143 }
12144
12145 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12146 }
12147
12148 local_free (digests_buf);
12149 local_free (salts_buf);
12150 local_free (esalts_buf);
12151
12152 digests_buf = digests_buf_new;
12153 salts_buf = salts_buf_new;
12154 esalts_buf = esalts_buf_new;
12155
12156 local_free (hashes_buf);
12157
12158 /**
12159 * special modification not set from parser
12160 */
12161
12162 switch (hash_mode)
12163 {
12164 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12165 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12166 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12167 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12168 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12169 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12170 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12171 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12172 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12173 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12174 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12175 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12176 }
12177
12178 if (truecrypt_keyfiles)
12179 {
12180 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12181
12182 char *keyfiles = strdup (truecrypt_keyfiles);
12183
12184 char *keyfile = strtok (keyfiles, ",");
12185
12186 do
12187 {
12188 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12189
12190 } while ((keyfile = strtok (NULL, ",")) != NULL);
12191
12192 free (keyfiles);
12193 }
12194
12195 data.digests_cnt = digests_cnt;
12196 data.digests_done = digests_done;
12197 data.digests_buf = digests_buf;
12198 data.digests_shown = digests_shown;
12199 data.digests_shown_tmp = digests_shown_tmp;
12200
12201 data.salts_cnt = salts_cnt;
12202 data.salts_done = salts_done;
12203 data.salts_buf = salts_buf;
12204 data.salts_shown = salts_shown;
12205
12206 data.esalts_buf = esalts_buf;
12207 data.hash_info = hash_info;
12208
12209 /**
12210 * Automatic Optimizers
12211 */
12212
12213 if (salts_cnt == 1)
12214 opti_type |= OPTI_TYPE_SINGLE_SALT;
12215
12216 if (digests_cnt == 1)
12217 opti_type |= OPTI_TYPE_SINGLE_HASH;
12218
12219 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12220 opti_type |= OPTI_TYPE_NOT_ITERATED;
12221
12222 if (attack_mode == ATTACK_MODE_BF)
12223 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12224
12225 data.opti_type = opti_type;
12226
12227 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12228 {
12229 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12230 {
12231 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12232 {
12233 if (opts_type & OPTS_TYPE_ST_ADD80)
12234 {
12235 opts_type &= ~OPTS_TYPE_ST_ADD80;
12236 opts_type |= OPTS_TYPE_PT_ADD80;
12237 }
12238
12239 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12240 {
12241 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12242 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12243 }
12244
12245 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12246 {
12247 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12248 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12249 }
12250 }
12251 }
12252 }
12253
12254 /**
12255 * Some algorithm, like descrypt, can benefit from JIT compilation
12256 */
12257
12258 int force_jit_compilation = -1;
12259
12260 if (hash_mode == 8900)
12261 {
12262 force_jit_compilation = 8900;
12263 }
12264 else if (hash_mode == 9300)
12265 {
12266 force_jit_compilation = 8900;
12267 }
12268 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12269 {
12270 force_jit_compilation = 1500;
12271 }
12272
12273 /**
12274 * generate bitmap tables
12275 */
12276
12277 const uint bitmap_shift1 = 5;
12278 const uint bitmap_shift2 = 13;
12279
12280 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12281
12282 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12283 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12284 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12285 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12286 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12287 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12288 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12289 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12290
12291 uint bitmap_bits;
12292 uint bitmap_nums;
12293 uint bitmap_mask;
12294 uint bitmap_size;
12295
12296 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12297 {
12298 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12299
12300 bitmap_nums = 1 << bitmap_bits;
12301
12302 bitmap_mask = bitmap_nums - 1;
12303
12304 bitmap_size = bitmap_nums * sizeof (uint);
12305
12306 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12307
12308 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;
12309 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;
12310
12311 break;
12312 }
12313
12314 bitmap_nums = 1 << bitmap_bits;
12315
12316 bitmap_mask = bitmap_nums - 1;
12317
12318 bitmap_size = bitmap_nums * sizeof (uint);
12319
12320 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);
12321 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);
12322
12323 /**
12324 * prepare quick rule
12325 */
12326
12327 data.rule_buf_l = rule_buf_l;
12328 data.rule_buf_r = rule_buf_r;
12329
12330 int rule_len_l = (int) strlen (rule_buf_l);
12331 int rule_len_r = (int) strlen (rule_buf_r);
12332
12333 data.rule_len_l = rule_len_l;
12334 data.rule_len_r = rule_len_r;
12335
12336 /**
12337 * load rules
12338 */
12339
12340 uint *all_kernel_rules_cnt = NULL;
12341
12342 kernel_rule_t **all_kernel_rules_buf = NULL;
12343
12344 if (rp_files_cnt)
12345 {
12346 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12347
12348 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12349 }
12350
12351 char rule_buf[BUFSIZ] = { 0 };
12352
12353 int rule_len = 0;
12354
12355 for (uint i = 0; i < rp_files_cnt; i++)
12356 {
12357 uint kernel_rules_avail = 0;
12358
12359 uint kernel_rules_cnt = 0;
12360
12361 kernel_rule_t *kernel_rules_buf = NULL;
12362
12363 char *rp_file = rp_files[i];
12364
12365 char in[BLOCK_SIZE] = { 0 };
12366 char out[BLOCK_SIZE] = { 0 };
12367
12368 FILE *fp = NULL;
12369
12370 uint rule_line = 0;
12371
12372 if ((fp = fopen (rp_file, "rb")) == NULL)
12373 {
12374 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12375
12376 return (-1);
12377 }
12378
12379 while (!feof (fp))
12380 {
12381 memset (rule_buf, 0, BUFSIZ);
12382
12383 rule_len = fgetl (fp, rule_buf);
12384
12385 rule_line++;
12386
12387 if (rule_len == 0) continue;
12388
12389 if (rule_buf[0] == '#') continue;
12390
12391 if (kernel_rules_avail == kernel_rules_cnt)
12392 {
12393 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12394
12395 kernel_rules_avail += INCR_RULES;
12396 }
12397
12398 memset (in, 0, BLOCK_SIZE);
12399 memset (out, 0, BLOCK_SIZE);
12400
12401 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12402
12403 if (result == -1)
12404 {
12405 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12406
12407 continue;
12408 }
12409
12410 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12411 {
12412 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12413
12414 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12415
12416 continue;
12417 }
12418
12419 /* its so slow
12420 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12421 {
12422 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12423
12424 continue;
12425 }
12426 */
12427
12428 kernel_rules_cnt++;
12429 }
12430
12431 fclose (fp);
12432
12433 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12434
12435 all_kernel_rules_buf[i] = kernel_rules_buf;
12436 }
12437
12438 /**
12439 * merge rules or automatic rule generator
12440 */
12441
12442 uint kernel_rules_cnt = 0;
12443
12444 kernel_rule_t *kernel_rules_buf = NULL;
12445
12446 if (attack_mode == ATTACK_MODE_STRAIGHT)
12447 {
12448 if (rp_files_cnt)
12449 {
12450 kernel_rules_cnt = 1;
12451
12452 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12453
12454 repeats[0] = kernel_rules_cnt;
12455
12456 for (uint i = 0; i < rp_files_cnt; i++)
12457 {
12458 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12459
12460 repeats[i + 1] = kernel_rules_cnt;
12461 }
12462
12463 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12464
12465 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12466
12467 for (uint i = 0; i < kernel_rules_cnt; i++)
12468 {
12469 uint out_pos = 0;
12470
12471 kernel_rule_t *out = &kernel_rules_buf[i];
12472
12473 for (uint j = 0; j < rp_files_cnt; j++)
12474 {
12475 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12476 uint in_pos;
12477
12478 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12479
12480 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12481 {
12482 if (out_pos == RULES_MAX - 1)
12483 {
12484 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12485
12486 break;
12487 }
12488
12489 out->cmds[out_pos] = in->cmds[in_pos];
12490 }
12491 }
12492 }
12493
12494 local_free (repeats);
12495 }
12496 else if (rp_gen)
12497 {
12498 uint kernel_rules_avail = 0;
12499
12500 while (kernel_rules_cnt < rp_gen)
12501 {
12502 if (kernel_rules_avail == kernel_rules_cnt)
12503 {
12504 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12505
12506 kernel_rules_avail += INCR_RULES;
12507 }
12508
12509 memset (rule_buf, 0, BLOCK_SIZE);
12510
12511 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12512
12513 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12514
12515 kernel_rules_cnt++;
12516 }
12517 }
12518 }
12519
12520 /**
12521 * generate NOP rules
12522 */
12523
12524 if (kernel_rules_cnt == 0)
12525 {
12526 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12527
12528 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12529
12530 kernel_rules_cnt++;
12531 }
12532
12533 data.kernel_rules_cnt = kernel_rules_cnt;
12534 data.kernel_rules_buf = kernel_rules_buf;
12535
12536 /**
12537 * OpenCL platforms: detect
12538 */
12539
12540 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12541 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12542
12543 cl_uint platforms_cnt = 0;
12544 cl_uint platform_devices_cnt = 0;
12545
12546 if (keyspace == 0)
12547 {
12548 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12549
12550 if (platforms_cnt == 0)
12551 {
12552 log_error ("ERROR: No OpenCL compatible platform found");
12553
12554 return (-1);
12555 }
12556 }
12557
12558 /**
12559 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12560 */
12561
12562 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12563 {
12564 cl_platform_id platform = platforms[platform_id];
12565
12566 char platform_vendor[INFOSZ] = { 0 };
12567
12568 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12569
12570 #ifdef HAVE_HWMON
12571 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12572 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12573 {
12574 // make sure that we do not directly control the fan for NVidia
12575
12576 gpu_temp_retain = 0;
12577
12578 data.gpu_temp_retain = gpu_temp_retain;
12579 }
12580 #endif // HAVE_NVML || HAVE_NVAPI
12581 #endif
12582 }
12583
12584 /**
12585 * OpenCL devices: simply push all devices from all platforms into the same device array
12586 */
12587
12588 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12589
12590 data.devices_param = devices_param;
12591
12592 uint devices_cnt = 0;
12593
12594 uint devices_active = 0;
12595
12596 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12597 {
12598 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12599
12600 cl_platform_id platform = platforms[platform_id];
12601
12602 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12603
12604 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12605 {
12606 size_t param_value_size = 0;
12607
12608 const uint device_id = devices_cnt;
12609
12610 hc_device_param_t *device_param = &data.devices_param[device_id];
12611
12612 device_param->device = platform_devices[platform_devices_id];
12613
12614 device_param->device_id = device_id;
12615
12616 device_param->platform_devices_id = platform_devices_id;
12617
12618 // device_type
12619
12620 cl_device_type device_type;
12621
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12623
12624 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12625
12626 device_param->device_type = device_type;
12627
12628 // vendor_id
12629
12630 cl_uint vendor_id = 0;
12631
12632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12633
12634 device_param->vendor_id = vendor_id;
12635
12636 // device_name
12637
12638 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12639
12640 char *device_name = (char *) mymalloc (param_value_size);
12641
12642 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12643
12644 device_param->device_name = device_name;
12645
12646 // tuning db
12647
12648 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12649
12650 // device_version
12651
12652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12653
12654 char *device_version = (char *) mymalloc (param_value_size);
12655
12656 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12657
12658 device_param->device_version = device_version;
12659
12660 // device_opencl_version
12661
12662 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12663
12664 char *device_opencl_version = (char *) mymalloc (param_value_size);
12665
12666 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12667
12668 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12669
12670 myfree (device_opencl_version);
12671
12672 if (strstr (device_version, "pocl"))
12673 {
12674 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12675 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12676
12677 cl_uint vendor_id = VENDOR_ID_GENERIC;
12678
12679 device_param->vendor_id = vendor_id;
12680 }
12681
12682 // vector_width
12683
12684 cl_uint vector_width;
12685
12686 if (opencl_vector_width_chgd == 0)
12687 {
12688 if (tuningdb_entry == NULL)
12689 {
12690 if (opti_type & OPTI_TYPE_USES_BITS_64)
12691 {
12692 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12693 }
12694 else
12695 {
12696 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12697 }
12698 }
12699 else
12700 {
12701 if (tuningdb_entry->vector_width == -1)
12702 {
12703 if (opti_type & OPTI_TYPE_USES_BITS_64)
12704 {
12705 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
12706 }
12707 else
12708 {
12709 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12710 }
12711 }
12712 else
12713 {
12714 vector_width = (cl_uint) tuningdb_entry->vector_width;
12715 }
12716 }
12717 }
12718 else
12719 {
12720 vector_width = opencl_vector_width;
12721 }
12722
12723 if (vector_width > 8) vector_width = 8;
12724
12725 device_param->vector_width = vector_width;
12726
12727 // max_compute_units
12728
12729 cl_uint device_processors;
12730
12731 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12732
12733 device_param->device_processors = device_processors;
12734
12735 // max_mem_alloc_size
12736
12737 cl_ulong device_maxmem_alloc;
12738
12739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12740
12741 device_param->device_maxmem_alloc = device_maxmem_alloc;
12742
12743 // max_mem_alloc_size
12744
12745 cl_ulong device_global_mem;
12746
12747 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12748
12749 device_param->device_global_mem = device_global_mem;
12750
12751 // max_clock_frequency
12752
12753 cl_uint device_maxclock_frequency;
12754
12755 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12756
12757 device_param->device_maxclock_frequency = device_maxclock_frequency;
12758
12759 // skipped
12760
12761 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12762 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12763
12764 device_param->skipped = (skipped1 || skipped2);
12765
12766 // driver_version
12767 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12768
12769 char *driver_version = (char *) mymalloc (param_value_size);
12770
12771 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12772
12773 device_param->driver_version = driver_version;
12774
12775 // device_name_chksum
12776
12777 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12778
12779 #if __x86_64__
12780 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);
12781 #else
12782 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);
12783 #endif
12784
12785 uint device_name_digest[4] = { 0 };
12786
12787 md5_64 ((uint *) device_name_chksum, device_name_digest);
12788
12789 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12790
12791 device_param->device_name_chksum = device_name_chksum;
12792
12793 // device_processor_cores
12794
12795 if (device_type & CL_DEVICE_TYPE_CPU)
12796 {
12797 cl_uint device_processor_cores = 1;
12798
12799 device_param->device_processor_cores = device_processor_cores;
12800 }
12801
12802 if (device_type & CL_DEVICE_TYPE_GPU)
12803 {
12804 if (vendor_id == VENDOR_ID_AMD)
12805 {
12806 cl_uint device_processor_cores = 0;
12807
12808 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12809
12810 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12811
12812 device_param->device_processor_cores = device_processor_cores;
12813 }
12814 else if (vendor_id == VENDOR_ID_NV)
12815 {
12816 cl_uint kernel_exec_timeout = 0;
12817
12818 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12819
12820 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12821
12822 device_param->kernel_exec_timeout = kernel_exec_timeout;
12823
12824 cl_uint device_processor_cores = 0;
12825
12826 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12827
12828 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12829
12830 device_param->device_processor_cores = device_processor_cores;
12831
12832 cl_uint sm_minor = 0;
12833 cl_uint sm_major = 0;
12834
12835 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12836 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12837
12838 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12839 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12840
12841 device_param->sm_minor = sm_minor;
12842 device_param->sm_major = sm_major;
12843 }
12844 else
12845 {
12846 cl_uint device_processor_cores = 1;
12847
12848 device_param->device_processor_cores = device_processor_cores;
12849 }
12850 }
12851
12852 // display results
12853
12854 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12855 {
12856 if (device_param->skipped == 0)
12857 {
12858 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12859 device_id + 1,
12860 device_name,
12861 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12862 (unsigned int) (device_global_mem / 1024 / 1024),
12863 (unsigned int) (device_maxclock_frequency),
12864 (unsigned int) device_processors);
12865 }
12866 else
12867 {
12868 log_info ("Device #%u: %s, skipped",
12869 device_id + 1,
12870 device_name);
12871 }
12872 }
12873
12874 // common driver check
12875
12876 if (device_param->skipped == 0)
12877 {
12878 if (strstr (device_version, "pocl"))
12879 {
12880 if (force == 0)
12881 {
12882 log_info ("");
12883 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12884 log_info ("You are STRONGLY encouraged not to use it");
12885 log_info ("You can use --force to override this but do not post error reports if you do so");
12886 log_info ("");
12887
12888 return (-1);
12889 }
12890 }
12891
12892 if (device_type & CL_DEVICE_TYPE_GPU)
12893 {
12894 if (vendor_id == VENDOR_ID_NV)
12895 {
12896 if (device_param->kernel_exec_timeout != 0)
12897 {
12898 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);
12899 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12900 }
12901 }
12902 else if (vendor_id == VENDOR_ID_AMD)
12903 {
12904 int catalyst_check = (force == 1) ? 0 : 1;
12905
12906 int catalyst_warn = 0;
12907
12908 int catalyst_broken = 0;
12909
12910 if (catalyst_check == 1)
12911 {
12912 catalyst_warn = 1;
12913
12914 // v14.9 and higher
12915 if (atoi (device_param->driver_version) >= 1573)
12916 {
12917 catalyst_warn = 0;
12918 }
12919
12920 catalyst_check = 0;
12921 }
12922
12923 if (catalyst_broken == 1)
12924 {
12925 log_info ("");
12926 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12927 log_info ("It will pass over cracked hashes and does not report them as cracked");
12928 log_info ("You are STRONGLY encouraged not to use it");
12929 log_info ("You can use --force to override this but do not post error reports if you do so");
12930 log_info ("");
12931
12932 return (-1);
12933 }
12934
12935 if (catalyst_warn == 1)
12936 {
12937 log_info ("");
12938 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12939 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12940 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12941 #ifdef _WIN
12942 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12943 #endif
12944 log_info ("You can use --force to override this but do not post error reports if you do so");
12945 log_info ("");
12946
12947 return (-1);
12948 }
12949 }
12950 }
12951
12952 /**
12953 * kernel accel and loops tuning db adjustment
12954 */
12955
12956 uint _kernel_accel = kernel_accel;
12957 uint _kernel_loops = kernel_loops;
12958
12959 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode);
12960
12961 if (kernel_accel_chgd == 0)
12962 {
12963 if (tuningdb_entry)
12964 {
12965 _kernel_accel = tuningdb_entry->kernel_accel;
12966 }
12967 }
12968
12969 if (kernel_loops_chgd == 0)
12970 {
12971 if (tuningdb_entry)
12972 {
12973 _kernel_loops = tuningdb_entry->kernel_loops;
12974
12975 if (workload_profile == 1)
12976 {
12977 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
12978 }
12979 else if (workload_profile == 2)
12980 {
12981 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
12982 }
12983 }
12984 }
12985
12986 device_param->kernel_accel = _kernel_accel;
12987 device_param->kernel_loops = _kernel_loops;
12988
12989 devices_active++;
12990 }
12991
12992 // next please
12993
12994 devices_cnt++;
12995 }
12996 }
12997
12998 if (keyspace == 0 && devices_active == 0)
12999 {
13000 log_error ("ERROR: No devices found/left");
13001
13002 return (-1);
13003 }
13004
13005 data.devices_cnt = devices_cnt;
13006
13007 data.devices_active = devices_active;
13008
13009 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13010 {
13011 log_info ("");
13012 }
13013
13014 /**
13015 * HM devices: init
13016 */
13017
13018 #ifdef HAVE_HWMON
13019 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13020 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13021 #endif
13022
13023 #ifdef HAVE_ADL
13024 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13025 #endif
13026
13027 if (gpu_temp_disable == 0)
13028 {
13029 #if defined(WIN) && defined(HAVE_NVAPI)
13030 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13031
13032 if (nvapi_init (nvapi) == 0)
13033 data.hm_nv = nvapi;
13034
13035 if (data.hm_nv)
13036 {
13037 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13038 {
13039 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13040
13041 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13042
13043 int tmp_out = 0;
13044
13045 for (int i = 0; i < tmp_in; i++)
13046 {
13047 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13048 }
13049
13050 for (int i = 0; i < tmp_out; i++)
13051 {
13052 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13053
13054 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13055
13056 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;
13057 }
13058 }
13059 }
13060 #endif // WIN && HAVE_NVAPI
13061
13062 #if defined(LINUX) && defined(HAVE_NVML)
13063 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13064
13065 if (nvml_init (nvml) == 0)
13066 data.hm_nv = nvml;
13067
13068 if (data.hm_nv)
13069 {
13070 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13071 {
13072 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13073
13074 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13075
13076 int tmp_out = 0;
13077
13078 for (int i = 0; i < tmp_in; i++)
13079 {
13080 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13081 }
13082
13083 for (int i = 0; i < tmp_out; i++)
13084 {
13085 unsigned int speed;
13086
13087 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;
13088 }
13089 }
13090 }
13091 #endif // LINUX && HAVE_NVML
13092
13093 data.hm_amd = NULL;
13094
13095 #ifdef HAVE_ADL
13096 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13097
13098 if (adl_init (adl) == 0)
13099 data.hm_amd = adl;
13100
13101 if (data.hm_amd)
13102 {
13103 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13104 {
13105 // total number of adapters
13106
13107 int hm_adapters_num;
13108
13109 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13110
13111 // adapter info
13112
13113 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13114
13115 if (lpAdapterInfo == NULL) return (-1);
13116
13117 // get a list (of ids of) valid/usable adapters
13118
13119 int num_adl_adapters = 0;
13120
13121 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13122
13123 if (num_adl_adapters > 0)
13124 {
13125 hc_thread_mutex_lock (mux_adl);
13126
13127 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13128
13129 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13130
13131 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13132 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13133
13134 hc_thread_mutex_unlock (mux_adl);
13135 }
13136
13137 myfree (valid_adl_device_list);
13138 myfree (lpAdapterInfo);
13139 }
13140 }
13141 #endif // HAVE_ADL
13142
13143 if (data.hm_amd == NULL && data.hm_nv == NULL)
13144 {
13145 gpu_temp_disable = 1;
13146 }
13147 }
13148
13149 /**
13150 * OpenCL devices: allocate buffer for device specific information
13151 */
13152
13153 #ifdef HAVE_HWMON
13154 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13155
13156 #ifdef HAVE_ADL
13157 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13158
13159 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13160 #endif // ADL
13161 #endif
13162
13163 /**
13164 * enable custom signal handler(s)
13165 */
13166
13167 if (benchmark == 0)
13168 {
13169 hc_signal (sigHandler_default);
13170 }
13171 else
13172 {
13173 hc_signal (sigHandler_benchmark);
13174 }
13175
13176 /**
13177 * User-defined GPU temp handling
13178 */
13179
13180 #ifdef HAVE_HWMON
13181 if (gpu_temp_disable == 1)
13182 {
13183 gpu_temp_abort = 0;
13184 gpu_temp_retain = 0;
13185 }
13186
13187 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13188 {
13189 if (gpu_temp_abort < gpu_temp_retain)
13190 {
13191 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13192
13193 return (-1);
13194 }
13195 }
13196
13197 data.gpu_temp_disable = gpu_temp_disable;
13198 data.gpu_temp_abort = gpu_temp_abort;
13199 data.gpu_temp_retain = gpu_temp_retain;
13200 #endif
13201
13202 /**
13203 * inform the user
13204 */
13205
13206 if (data.quiet == 0)
13207 {
13208 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13209
13210 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);
13211
13212 if (attack_mode == ATTACK_MODE_STRAIGHT)
13213 {
13214 log_info ("Rules: %u", kernel_rules_cnt);
13215 }
13216
13217 if (opti_type)
13218 {
13219 log_info ("Applicable Optimizers:");
13220
13221 for (uint i = 0; i < 32; i++)
13222 {
13223 const uint opti_bit = 1u << i;
13224
13225 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13226 }
13227 }
13228
13229 /**
13230 * Watchdog and Temperature balance
13231 */
13232
13233 #ifdef HAVE_HWMON
13234 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13235 {
13236 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13237 }
13238
13239 if (gpu_temp_abort == 0)
13240 {
13241 log_info ("Watchdog: Temperature abort trigger disabled");
13242 }
13243 else
13244 {
13245 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13246 }
13247
13248 if (gpu_temp_retain == 0)
13249 {
13250 log_info ("Watchdog: Temperature retain trigger disabled");
13251 }
13252 else
13253 {
13254 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13255 }
13256 #endif
13257 }
13258
13259 if (data.quiet == 0) log_info ("");
13260
13261 /**
13262 * HM devices: copy
13263 */
13264
13265 if (gpu_temp_disable == 0)
13266 {
13267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13268 {
13269 hc_device_param_t *device_param = &data.devices_param[device_id];
13270
13271 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13272
13273 if (device_param->skipped) continue;
13274
13275 const uint platform_devices_id = device_param->platform_devices_id;
13276
13277 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13278 if (device_param->vendor_id == VENDOR_ID_NV)
13279 {
13280 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13281 }
13282 #endif
13283
13284 #ifdef HAVE_ADL
13285 if (device_param->vendor_id == VENDOR_ID_AMD)
13286 {
13287 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13288 }
13289 #endif
13290 }
13291 }
13292
13293 /*
13294 * Temporary fix:
13295 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13296 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13297 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13298 * Driver / ADL bug?
13299 */
13300
13301 #ifdef HAVE_ADL
13302 if (powertune_enable == 1)
13303 {
13304 hc_thread_mutex_lock (mux_adl);
13305
13306 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13307 {
13308 hc_device_param_t *device_param = &data.devices_param[device_id];
13309
13310 if (device_param->skipped) continue;
13311
13312 if (data.hm_device[device_id].od_version == 6)
13313 {
13314 // set powertune value only
13315
13316 int powertune_supported = 0;
13317
13318 int ADL_rc = 0;
13319
13320 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13321 {
13322 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13323
13324 return (-1);
13325 }
13326
13327 if (powertune_supported != 0)
13328 {
13329 // powertune set
13330 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13331
13332 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13333 {
13334 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13335
13336 return (-1);
13337 }
13338
13339 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13340 {
13341 log_error ("ERROR: Failed to set new ADL PowerControl values");
13342
13343 return (-1);
13344 }
13345 }
13346 }
13347 }
13348
13349 hc_thread_mutex_unlock (mux_adl);
13350 }
13351 #endif // HAVE_ADK
13352 #endif // HAVE_HWMON
13353
13354 #ifdef OSX
13355 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13356 {
13357 if (force == 0)
13358 {
13359 log_info ("");
13360 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13361 log_info ("You can use --force to override this but do not post error reports if you do so");
13362 log_info ("");
13363
13364 continue;
13365 }
13366 }
13367 #endif
13368
13369 #ifdef DEBUG
13370 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13371 #endif
13372
13373 uint kernel_power_all = 0;
13374
13375 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13376 {
13377 /**
13378 * host buffer
13379 */
13380
13381 hc_device_param_t *device_param = &data.devices_param[device_id];
13382
13383 if (device_param->skipped) continue;
13384
13385 /**
13386 * device properties
13387 */
13388
13389 const char *device_name_chksum = device_param->device_name_chksum;
13390 const u32 device_processors = device_param->device_processors;
13391 const u32 device_processor_cores = device_param->device_processor_cores;
13392
13393 /**
13394 * create context for each device
13395 */
13396
13397 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13398
13399 /**
13400 * create command-queue
13401 */
13402
13403 // not supported with NV
13404 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13405
13406 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13407
13408 /**
13409 * create input buffers on device : calculate size of fixed memory buffers
13410 */
13411
13412 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13413 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13414
13415 device_param->size_root_css = size_root_css;
13416 device_param->size_markov_css = size_markov_css;
13417
13418 uint size_results = KERNEL_THREADS * sizeof (uint);
13419
13420 device_param->size_results = size_results;
13421
13422 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13423 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13424
13425 uint size_plains = digests_cnt * sizeof (plain_t);
13426 uint size_salts = salts_cnt * sizeof (salt_t);
13427 uint size_esalts = salts_cnt * esalt_size;
13428
13429 device_param->size_plains = size_plains;
13430 device_param->size_digests = size_digests;
13431 device_param->size_shown = size_shown;
13432 device_param->size_salts = size_salts;
13433
13434 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13435 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13436 uint size_tm = 32 * sizeof (bs_word_t);
13437
13438 // scryptV stuff
13439
13440 u64 size_scryptV = 1;
13441
13442 if ((hash_mode == 8900) || (hash_mode == 9300))
13443 {
13444 uint tmto_start = 0;
13445 uint tmto_stop = 10;
13446
13447 if (scrypt_tmto)
13448 {
13449 tmto_start = scrypt_tmto;
13450 }
13451 else
13452 {
13453 // in case the user did not specify the tmto manually
13454 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13455 // but set the lower end only in case the user has a device with too less memory
13456
13457 if (hash_mode == 8900)
13458 {
13459 if (device_param->vendor_id == VENDOR_ID_AMD)
13460 {
13461 tmto_start = 1;
13462 }
13463 else if (device_param->vendor_id == VENDOR_ID_NV)
13464 {
13465 tmto_start = 3;
13466 }
13467 }
13468 else if (hash_mode == 9300)
13469 {
13470 if (device_param->vendor_id == VENDOR_ID_AMD)
13471 {
13472 tmto_start = 3;
13473 }
13474 else if (device_param->vendor_id == VENDOR_ID_NV)
13475 {
13476 tmto_start = 5;
13477 }
13478 }
13479 }
13480
13481 if (quiet == 0) log_info ("");
13482
13483 uint shader_per_mp = 1;
13484
13485 if (device_param->vendor_id == VENDOR_ID_AMD)
13486 {
13487 shader_per_mp = 8;
13488 }
13489 else if (device_param->vendor_id == VENDOR_ID_NV)
13490 {
13491 shader_per_mp = 32;
13492 }
13493
13494 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13495 {
13496 // TODO: in theory the following calculation needs to be done per salt, not global
13497 // we assume all hashes have the same scrypt settings
13498
13499 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13500
13501 size_scryptV /= 1 << tmto;
13502
13503 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13504
13505 if (size_scryptV > device_param->device_maxmem_alloc)
13506 {
13507 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13508
13509 continue;
13510 }
13511
13512 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13513 {
13514 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13515 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13516 }
13517
13518 break;
13519 }
13520
13521 if (data.salts_buf[0].scrypt_phy == 0)
13522 {
13523 log_error ("ERROR: can't allocate enough device memory");
13524
13525 return -1;
13526 }
13527
13528 if (quiet == 0) log_info ("");
13529 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13530 }
13531
13532 /**
13533 * create input buffers on device : calculate size of dynamic size memory buffers
13534 */
13535
13536 uint kernel_threads = KERNEL_THREADS;
13537
13538 // some algorithms need a fixed kernel-threads count (mostly because of shared memory usage)
13539
13540 if (hash_mode == 3200) kernel_threads = 8;
13541 if (hash_mode == 9000) kernel_threads = 8;
13542
13543 /**
13544 * some algorithms need a fixed kernel-loops count
13545 */
13546
13547 u32 kernel_loops_min = 1;
13548 u32 kernel_loops_max = 1024;
13549
13550 if (hash_mode == 1500)
13551 {
13552 const u32 kernel_loops_fixed = 1024;
13553
13554 kernel_loops_min = kernel_loops_fixed;
13555 kernel_loops_max = kernel_loops_fixed;
13556 }
13557
13558 if (hash_mode == 3000)
13559 {
13560 const u32 kernel_loops_fixed = 1024;
13561
13562 kernel_loops_min = kernel_loops_fixed;
13563 kernel_loops_max = kernel_loops_fixed;
13564 }
13565
13566 if (hash_mode == 8900)
13567 {
13568 const u32 kernel_loops_fixed = 1;
13569
13570 kernel_loops_min = kernel_loops_fixed;
13571 kernel_loops_max = kernel_loops_fixed;
13572 }
13573
13574 if (hash_mode == 9300)
13575 {
13576 const u32 kernel_loops_fixed = 1;
13577
13578 kernel_loops_min = kernel_loops_fixed;
13579 kernel_loops_max = kernel_loops_fixed;
13580 }
13581
13582 if (hash_mode == 12500)
13583 {
13584 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
13585
13586 kernel_loops_min = kernel_loops_fixed;
13587 kernel_loops_max = kernel_loops_fixed;
13588 }
13589
13590 if (data.salts_buf[0].salt_iter < kernel_loops_max)
13591 {
13592 kernel_loops_max = data.salts_buf[0].salt_iter;
13593 }
13594
13595 device_param->kernel_loops_min = kernel_loops_min;
13596 device_param->kernel_loops_max = kernel_loops_max;
13597
13598 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13599
13600 uint size_pws = 4;
13601 uint size_tmps = 4;
13602 uint size_hooks = 4;
13603
13604 uint kernel_accel_min = 1;
13605 uint kernel_accel_max = 1024;
13606
13607 /**
13608 * some algorithms need a special kernel-accel
13609 */
13610
13611 if (hash_mode == 8900)
13612 {
13613 kernel_accel_max = 64;
13614 }
13615
13616 if (hash_mode == 9300)
13617 {
13618 kernel_accel_max = 64;
13619 }
13620
13621 while (kernel_accel_max)
13622 {
13623 uint kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
13624
13625 // size_pws
13626
13627 size_pws = kernel_power_max * sizeof (pw_t);
13628
13629 // size_tmps
13630
13631 switch (hash_mode)
13632 {
13633 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
13634 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13635 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13636 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13637 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
13638 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
13639 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
13640 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
13641 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
13642 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
13643 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13644 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13645 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13646 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13647 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13648 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
13649 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13650 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13651 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13652 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13653 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13654 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
13655 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
13656 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
13657 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
13658 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
13659 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
13660 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
13661 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13662 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13663 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
13664 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
13665 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13666 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
13667 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13668 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
13669 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
13670 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13671 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
13672 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
13673 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
13674 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
13675 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13676 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
13677 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
13678 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
13679 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
13680 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13681 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
13682 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
13683 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
13684 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
13685 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
13686 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
13687 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
13688 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
13689 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
13690 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
13691 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13692 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13693 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
13694 };
13695
13696 // size_hooks
13697
13698 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13699 {
13700 // none yet
13701 }
13702
13703 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
13704 // if not, decrease amplifier and try again
13705
13706 int skip = 0;
13707
13708 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
13709 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
13710 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
13711
13712 if (( bitmap_size
13713 + bitmap_size
13714 + bitmap_size
13715 + bitmap_size
13716 + bitmap_size
13717 + bitmap_size
13718 + bitmap_size
13719 + bitmap_size
13720 + size_bfs
13721 + size_combs
13722 + size_digests
13723 + size_esalts
13724 + size_hooks
13725 + size_markov_css
13726 + size_plains
13727 + size_pws
13728 + size_results
13729 + size_root_css
13730 + size_rules
13731 + size_rules_c
13732 + size_salts
13733 + size_scryptV
13734 + size_shown
13735 + size_tm
13736 + size_tmps) > device_param->device_global_mem) skip = 1;
13737
13738 if (skip == 1)
13739 {
13740 kernel_accel_max--;
13741
13742 continue;
13743 }
13744
13745 break;
13746 }
13747
13748 if (kernel_accel_max == 0)
13749 {
13750 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13751
13752 return -1;
13753 }
13754
13755 device_param->kernel_accel_min = kernel_accel_min;
13756 device_param->kernel_accel_max = kernel_accel_max;
13757
13758 if (kernel_accel_max < kernel_accel)
13759 {
13760 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
13761
13762 device_param->kernel_accel = kernel_accel_max;
13763 }
13764
13765 const u32 kernel_accel = device_param->kernel_accel;
13766
13767 device_param->size_pws = size_pws;
13768 device_param->size_tmps = size_tmps;
13769 device_param->size_hooks = size_hooks;
13770
13771 // do not confuse kernel_accel_max with kernel_accel here
13772
13773 const u32 kernel_power = device_processors * kernel_threads * kernel_accel;
13774
13775 device_param->kernel_threads = kernel_threads;
13776 device_param->kernel_power_user = kernel_power;
13777
13778 kernel_power_all += kernel_power;
13779
13780 /**
13781 * default building options
13782 */
13783
13784 char build_opts[1024] = { 0 };
13785
13786 // we don't have sm_* on vendors not NV but it doesn't matter
13787
13788 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);
13789
13790 /**
13791 * main kernel
13792 */
13793
13794 {
13795 /**
13796 * kernel source filename
13797 */
13798
13799 char source_file[256] = { 0 };
13800
13801 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13802
13803 struct stat sst;
13804
13805 if (stat (source_file, &sst) == -1)
13806 {
13807 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13808
13809 return -1;
13810 }
13811
13812 /**
13813 * kernel cached filename
13814 */
13815
13816 char cached_file[256] = { 0 };
13817
13818 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13819
13820 int cached = 1;
13821
13822 struct stat cst;
13823
13824 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13825 {
13826 cached = 0;
13827 }
13828
13829 /**
13830 * kernel compile or load
13831 */
13832
13833 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13834
13835 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13836
13837 if (force_jit_compilation == -1)
13838 {
13839 if (cached == 0)
13840 {
13841 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13842
13843 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13844
13845 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13846
13847 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13848
13849 if (rc != 0)
13850 {
13851 device_param->skipped = true;
13852 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13853 continue;
13854 }
13855
13856 size_t binary_size;
13857
13858 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13859
13860 u8 *binary = (u8 *) mymalloc (binary_size);
13861
13862 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13863
13864 writeProgramBin (cached_file, binary, binary_size);
13865
13866 local_free (binary);
13867 }
13868 else
13869 {
13870 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13871
13872 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13873
13874 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13875
13876 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13877 }
13878 }
13879 else
13880 {
13881 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13882
13883 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13884
13885 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13886
13887 char build_opts_update[1024] = { 0 };
13888
13889 if (force_jit_compilation == 1500)
13890 {
13891 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13892 }
13893 else if (force_jit_compilation == 8900)
13894 {
13895 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);
13896 }
13897
13898 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13899
13900 if (rc != 0)
13901 {
13902 device_param->skipped = true;
13903 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13904 }
13905 }
13906
13907 local_free (kernel_lengths);
13908 local_free (kernel_sources[0]);
13909 local_free (kernel_sources);
13910 }
13911
13912 /**
13913 * word generator kernel
13914 */
13915
13916 if (attack_mode != ATTACK_MODE_STRAIGHT)
13917 {
13918 /**
13919 * kernel mp source filename
13920 */
13921
13922 char source_file[256] = { 0 };
13923
13924 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13925
13926 struct stat sst;
13927
13928 if (stat (source_file, &sst) == -1)
13929 {
13930 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13931
13932 return -1;
13933 }
13934
13935 /**
13936 * kernel mp cached filename
13937 */
13938
13939 char cached_file[256] = { 0 };
13940
13941 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13942
13943 int cached = 1;
13944
13945 struct stat cst;
13946
13947 if (stat (cached_file, &cst) == -1)
13948 {
13949 cached = 0;
13950 }
13951
13952 /**
13953 * kernel compile or load
13954 */
13955
13956 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13957
13958 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13959
13960 if (cached == 0)
13961 {
13962 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13963
13964 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13965
13966 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13967
13968 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13969
13970 if (rc != 0)
13971 {
13972 device_param->skipped = true;
13973 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13974 continue;
13975 }
13976
13977 size_t binary_size;
13978
13979 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13980
13981 u8 *binary = (u8 *) mymalloc (binary_size);
13982
13983 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13984
13985 writeProgramBin (cached_file, binary, binary_size);
13986
13987 local_free (binary);
13988 }
13989 else
13990 {
13991 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13992
13993 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13994
13995 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13996
13997 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13998 }
13999
14000 local_free (kernel_lengths);
14001 local_free (kernel_sources[0]);
14002 local_free (kernel_sources);
14003 }
14004
14005 /**
14006 * amplifier kernel
14007 */
14008
14009 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14010 {
14011
14012 }
14013 else
14014 {
14015 /**
14016 * kernel amp source filename
14017 */
14018
14019 char source_file[256] = { 0 };
14020
14021 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14022
14023 struct stat sst;
14024
14025 if (stat (source_file, &sst) == -1)
14026 {
14027 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14028
14029 return -1;
14030 }
14031
14032 /**
14033 * kernel amp cached filename
14034 */
14035
14036 char cached_file[256] = { 0 };
14037
14038 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14039
14040 int cached = 1;
14041
14042 struct stat cst;
14043
14044 if (stat (cached_file, &cst) == -1)
14045 {
14046 cached = 0;
14047 }
14048
14049 /**
14050 * kernel compile or load
14051 */
14052
14053 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14054
14055 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14056
14057 if (cached == 0)
14058 {
14059 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14060
14061 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14062
14063 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14064
14065 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14066
14067 if (rc != 0)
14068 {
14069 device_param->skipped = true;
14070 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14071 continue;
14072 }
14073
14074 size_t binary_size;
14075
14076 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14077
14078 u8 *binary = (u8 *) mymalloc (binary_size);
14079
14080 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14081
14082 writeProgramBin (cached_file, binary, binary_size);
14083
14084 local_free (binary);
14085 }
14086 else
14087 {
14088 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14089
14090 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14091
14092 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14093
14094 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14095 }
14096
14097 local_free (kernel_lengths);
14098 local_free (kernel_sources[0]);
14099 local_free (kernel_sources);
14100 }
14101
14102 // some algorithm collide too fast, make that impossible
14103
14104 if (benchmark == 1)
14105 {
14106 ((uint *) digests_buf)[0] = -1;
14107 ((uint *) digests_buf)[1] = -1;
14108 ((uint *) digests_buf)[2] = -1;
14109 ((uint *) digests_buf)[3] = -1;
14110 }
14111
14112 /**
14113 * global buffers
14114 */
14115
14116 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14117 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14118 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14119 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14120 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14121 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14122 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14123 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14124 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14125 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14126 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14127 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14128 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14129 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14130 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14131 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14132 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14133 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14134
14135 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);
14136 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);
14137 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);
14138 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);
14139 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);
14140 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);
14141 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);
14142 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);
14143 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14144 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14145 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14146
14147 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14148 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14149 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14150 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14151 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14152 run_kernel_bzero (device_param, device_param->d_result, size_results);
14153
14154 /**
14155 * special buffers
14156 */
14157
14158 if (attack_kern == ATTACK_KERN_STRAIGHT)
14159 {
14160 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14161 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14162
14163 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14164
14165 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14166 }
14167 else if (attack_kern == ATTACK_KERN_COMBI)
14168 {
14169 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14170 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14171 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14172 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14173
14174 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14175 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14176 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14177 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14178 }
14179 else if (attack_kern == ATTACK_KERN_BF)
14180 {
14181 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14182 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14183 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14184 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14185 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14186
14187 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14188 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14189 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14190 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14191 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14192 }
14193
14194 if (size_esalts)
14195 {
14196 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14197
14198 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14199 }
14200
14201 /**
14202 * main host data
14203 */
14204
14205 uint *result = (uint *) mymalloc (size_results);
14206
14207 device_param->result = result;
14208
14209 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14210
14211 device_param->pws_buf = pws_buf;
14212
14213 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14214
14215 for (int i = 0; i < 64; i++)
14216 {
14217 pw_caches[i].pw_buf.pw_len = i;
14218 pw_caches[i].cnt = 0;
14219 }
14220
14221 device_param->pw_caches = pw_caches;
14222
14223 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14224
14225 device_param->combs_buf = combs_buf;
14226
14227 void *hooks_buf = mymalloc (size_hooks);
14228
14229 device_param->hooks_buf = hooks_buf;
14230
14231 device_param->pw_transpose = pw_transpose_to_hi1;
14232 device_param->pw_add = pw_add_to_hc1;
14233
14234 /**
14235 * kernel args
14236 */
14237
14238 device_param->kernel_params_buf32[21] = bitmap_mask;
14239 device_param->kernel_params_buf32[22] = bitmap_shift1;
14240 device_param->kernel_params_buf32[23] = bitmap_shift2;
14241 device_param->kernel_params_buf32[24] = 0; // salt_pos
14242 device_param->kernel_params_buf32[25] = 0; // loop_pos
14243 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14244 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14245 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14246 device_param->kernel_params_buf32[29] = 0; // digests_offset
14247 device_param->kernel_params_buf32[30] = 0; // combs_mode
14248 device_param->kernel_params_buf32[31] = 0; // gid_max
14249
14250 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14251 ? &device_param->d_pws_buf
14252 : &device_param->d_pws_amp_buf;
14253 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14254 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14255 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14256 device_param->kernel_params[ 4] = &device_param->d_tmps;
14257 device_param->kernel_params[ 5] = &device_param->d_hooks;
14258 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14259 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14260 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14261 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14262 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14263 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14264 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14265 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14266 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14267 device_param->kernel_params[15] = &device_param->d_digests_buf;
14268 device_param->kernel_params[16] = &device_param->d_digests_shown;
14269 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14270 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14271 device_param->kernel_params[19] = &device_param->d_result;
14272 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14273 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14274 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14275 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14276 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14277 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14278 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14279 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14280 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14281 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14282 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14283 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14284
14285 device_param->kernel_params_mp_buf64[3] = 0;
14286 device_param->kernel_params_mp_buf32[4] = 0;
14287 device_param->kernel_params_mp_buf32[5] = 0;
14288 device_param->kernel_params_mp_buf32[6] = 0;
14289 device_param->kernel_params_mp_buf32[7] = 0;
14290 device_param->kernel_params_mp_buf32[8] = 0;
14291
14292 device_param->kernel_params_mp[0] = NULL;
14293 device_param->kernel_params_mp[1] = NULL;
14294 device_param->kernel_params_mp[2] = NULL;
14295 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14296 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14297 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14298 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14299 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14300 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14301
14302 device_param->kernel_params_mp_l_buf64[3] = 0;
14303 device_param->kernel_params_mp_l_buf32[4] = 0;
14304 device_param->kernel_params_mp_l_buf32[5] = 0;
14305 device_param->kernel_params_mp_l_buf32[6] = 0;
14306 device_param->kernel_params_mp_l_buf32[7] = 0;
14307 device_param->kernel_params_mp_l_buf32[8] = 0;
14308 device_param->kernel_params_mp_l_buf32[9] = 0;
14309
14310 device_param->kernel_params_mp_l[0] = NULL;
14311 device_param->kernel_params_mp_l[1] = NULL;
14312 device_param->kernel_params_mp_l[2] = NULL;
14313 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14314 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14315 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14316 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14317 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14318 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14319 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14320
14321 device_param->kernel_params_mp_r_buf64[3] = 0;
14322 device_param->kernel_params_mp_r_buf32[4] = 0;
14323 device_param->kernel_params_mp_r_buf32[5] = 0;
14324 device_param->kernel_params_mp_r_buf32[6] = 0;
14325 device_param->kernel_params_mp_r_buf32[7] = 0;
14326 device_param->kernel_params_mp_r_buf32[8] = 0;
14327
14328 device_param->kernel_params_mp_r[0] = NULL;
14329 device_param->kernel_params_mp_r[1] = NULL;
14330 device_param->kernel_params_mp_r[2] = NULL;
14331 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14332 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14333 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14334 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14335 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14336 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14337
14338 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14339 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14340
14341 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14342 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14343 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14344 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14345 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14346 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14347 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14348
14349 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14350
14351 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14352 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14353
14354 /**
14355 * kernel name
14356 */
14357
14358 char kernel_name[64] = { 0 };
14359
14360 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14361 {
14362 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14363 {
14364 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14365
14366 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14367
14368 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14369
14370 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14371
14372 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14373
14374 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14375 }
14376 else
14377 {
14378 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14379
14380 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14381
14382 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14383
14384 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14385
14386 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14387
14388 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14389 }
14390
14391 if (data.attack_mode == ATTACK_MODE_BF)
14392 {
14393 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14394 {
14395 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14396
14397 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14398
14399 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14400
14401 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14402 }
14403 }
14404 }
14405 else
14406 {
14407 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14408
14409 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14410
14411 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14412
14413 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14414
14415 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14416
14417 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14418
14419 if (opts_type & OPTS_TYPE_HOOK12)
14420 {
14421 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14422
14423 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14424 }
14425
14426 if (opts_type & OPTS_TYPE_HOOK23)
14427 {
14428 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14429
14430 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14431 }
14432 }
14433
14434 for (uint i = 0; i <= 20; i++)
14435 {
14436 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14437 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14438 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14439
14440 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14441 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14442 }
14443
14444 for (uint i = 21; i <= 31; i++)
14445 {
14446 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14447 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14448 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14449
14450 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14451 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14452 }
14453
14454 if (attack_mode == ATTACK_MODE_BF)
14455 {
14456 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14457 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14458
14459 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14460 {
14461 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14462
14463 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14464 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14465 }
14466 }
14467 else if (attack_mode == ATTACK_MODE_HYBRID1)
14468 {
14469 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14470 }
14471 else if (attack_mode == ATTACK_MODE_HYBRID2)
14472 {
14473 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14474 }
14475
14476 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14477 {
14478 // nothing to do
14479 }
14480 else
14481 {
14482 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14483 }
14484
14485 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14486 {
14487 // nothing to do
14488 }
14489 else
14490 {
14491 for (uint i = 0; i < 5; i++)
14492 {
14493 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14494 }
14495
14496 for (uint i = 5; i < 7; i++)
14497 {
14498 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14499 }
14500 }
14501
14502 /**
14503 * Store initial fanspeed if gpu_temp_retain is enabled
14504 */
14505
14506 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14507 int gpu_temp_retain_set = 0;
14508
14509 if (gpu_temp_disable == 0)
14510 {
14511 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14512 {
14513 hc_thread_mutex_lock (mux_adl);
14514
14515 if (data.hm_device[device_id].fan_supported == 1)
14516 {
14517 if (gpu_temp_retain_chgd == 0)
14518 {
14519 uint cur_temp = 0;
14520 uint default_temp = 0;
14521
14522 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);
14523
14524 if (ADL_rc == ADL_OK)
14525 {
14526 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14527
14528 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14529
14530 // special case with multi gpu setups: always use minimum retain
14531
14532 if (gpu_temp_retain_set == 0)
14533 {
14534 gpu_temp_retain = gpu_temp_retain_target;
14535 gpu_temp_retain_set = 1;
14536 }
14537 else
14538 {
14539 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14540 }
14541
14542 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14543 }
14544 }
14545
14546 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14547
14548 temp_retain_fanspeed_value[device_id] = fan_speed;
14549
14550 if (fan_speed == -1)
14551 {
14552 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14553
14554 temp_retain_fanspeed_value[device_id] = 0;
14555 }
14556 }
14557
14558 hc_thread_mutex_unlock (mux_adl);
14559 }
14560 }
14561
14562 /**
14563 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14564 */
14565
14566 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14567 {
14568 hc_thread_mutex_lock (mux_adl);
14569
14570 if (data.hm_device[device_id].od_version == 6)
14571 {
14572 int ADL_rc;
14573
14574 // check powertune capabilities first, if not available then skip device
14575
14576 int powertune_supported = 0;
14577
14578 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14579 {
14580 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14581
14582 return (-1);
14583 }
14584
14585 if (powertune_supported != 0)
14586 {
14587 // powercontrol settings
14588
14589 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14590
14591 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14592 {
14593 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14594 }
14595
14596 if (ADL_rc != ADL_OK)
14597 {
14598 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14599
14600 return (-1);
14601 }
14602
14603 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14604 {
14605 log_error ("ERROR: Failed to set new ADL PowerControl values");
14606
14607 return (-1);
14608 }
14609
14610 // clocks
14611
14612 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14613
14614 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14615
14616 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)
14617 {
14618 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14619
14620 return (-1);
14621 }
14622
14623 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14624
14625 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14626
14627 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14628 {
14629 log_error ("ERROR: Failed to get ADL device capabilities");
14630
14631 return (-1);
14632 }
14633
14634 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14635 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14636
14637 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14638 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14639
14640 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14641 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14642
14643 // warning if profile has too low max values
14644
14645 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14646 {
14647 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14648 }
14649
14650 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14651 {
14652 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14653 }
14654
14655 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14656
14657 performance_state->iNumberOfPerformanceLevels = 2;
14658
14659 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14660 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14661 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14662 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14663
14664 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)
14665 {
14666 log_info ("ERROR: Failed to set ADL performance state");
14667
14668 return (-1);
14669 }
14670
14671 local_free (performance_state);
14672 }
14673 }
14674
14675 hc_thread_mutex_unlock (mux_adl);
14676 }
14677 #endif // HAVE_HWMON && HAVE_ADL
14678 }
14679
14680 data.kernel_power_all = kernel_power_all;
14681
14682 if (data.quiet == 0) log_info ("");
14683
14684 /**
14685 * Inform user which algorithm is checked and at which workload setting
14686 */
14687
14688 if (benchmark == 1)
14689 {
14690 quiet = 0;
14691
14692 data.quiet = quiet;
14693
14694 char *hash_type = strhashtype (data.hash_mode); // not a bug
14695
14696 log_info ("Hashtype: %s", hash_type);
14697 log_info ("");
14698 }
14699
14700 /**
14701 * keep track of the progress
14702 */
14703
14704 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14705 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14706 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14707
14708 /**
14709 * open filehandles
14710 */
14711
14712 #if _WIN
14713 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14714 {
14715 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14716
14717 return (-1);
14718 }
14719
14720 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14721 {
14722 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14723
14724 return (-1);
14725 }
14726
14727 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14728 {
14729 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14730
14731 return (-1);
14732 }
14733 #endif
14734
14735 /**
14736 * dictionary pad
14737 */
14738
14739 segment_size *= (1024 * 1024);
14740
14741 data.segment_size = segment_size;
14742
14743 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14744
14745 wl_data->buf = (char *) mymalloc (segment_size);
14746 wl_data->avail = segment_size;
14747 wl_data->incr = segment_size;
14748 wl_data->cnt = 0;
14749 wl_data->pos = 0;
14750
14751 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14752
14753 data.wordlist_mode = wordlist_mode;
14754
14755 cs_t *css_buf = NULL;
14756 uint css_cnt = 0;
14757 uint dictcnt = 0;
14758 uint maskcnt = 1;
14759 char **masks = NULL;
14760 char **dictfiles = NULL;
14761
14762 uint mask_from_file = 0;
14763
14764 if (attack_mode == ATTACK_MODE_STRAIGHT)
14765 {
14766 if (wordlist_mode == WL_MODE_FILE)
14767 {
14768 int wls_left = myargc - (optind + 1);
14769
14770 for (int i = 0; i < wls_left; i++)
14771 {
14772 char *l0_filename = myargv[optind + 1 + i];
14773
14774 struct stat l0_stat;
14775
14776 if (stat (l0_filename, &l0_stat) == -1)
14777 {
14778 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14779
14780 return (-1);
14781 }
14782
14783 uint is_dir = S_ISDIR (l0_stat.st_mode);
14784
14785 if (is_dir == 0)
14786 {
14787 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14788
14789 dictcnt++;
14790
14791 dictfiles[dictcnt - 1] = l0_filename;
14792 }
14793 else
14794 {
14795 // do not allow --keyspace w/ a directory
14796
14797 if (keyspace == 1)
14798 {
14799 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14800
14801 return (-1);
14802 }
14803
14804 char **dictionary_files = NULL;
14805
14806 dictionary_files = scan_directory (l0_filename);
14807
14808 if (dictionary_files != NULL)
14809 {
14810 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14811
14812 for (int d = 0; dictionary_files[d] != NULL; d++)
14813 {
14814 char *l1_filename = dictionary_files[d];
14815
14816 struct stat l1_stat;
14817
14818 if (stat (l1_filename, &l1_stat) == -1)
14819 {
14820 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14821
14822 return (-1);
14823 }
14824
14825 if (S_ISREG (l1_stat.st_mode))
14826 {
14827 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14828
14829 dictcnt++;
14830
14831 dictfiles[dictcnt - 1] = strdup (l1_filename);
14832 }
14833 }
14834 }
14835
14836 local_free (dictionary_files);
14837 }
14838 }
14839
14840 if (dictcnt < 1)
14841 {
14842 log_error ("ERROR: No usable dictionary file found.");
14843
14844 return (-1);
14845 }
14846 }
14847 else if (wordlist_mode == WL_MODE_STDIN)
14848 {
14849 dictcnt = 1;
14850 }
14851 }
14852 else if (attack_mode == ATTACK_MODE_COMBI)
14853 {
14854 // display
14855
14856 char *dictfile1 = myargv[optind + 1 + 0];
14857 char *dictfile2 = myargv[optind + 1 + 1];
14858
14859 // find the bigger dictionary and use as base
14860
14861 FILE *fp1 = NULL;
14862 FILE *fp2 = NULL;
14863
14864 struct stat tmp_stat;
14865
14866 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14867 {
14868 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14869
14870 return (-1);
14871 }
14872
14873 if (stat (dictfile1, &tmp_stat) == -1)
14874 {
14875 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14876
14877 fclose (fp1);
14878
14879 return (-1);
14880 }
14881
14882 if (S_ISDIR (tmp_stat.st_mode))
14883 {
14884 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14885
14886 fclose (fp1);
14887
14888 return (-1);
14889 }
14890
14891 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14892 {
14893 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14894
14895 fclose (fp1);
14896
14897 return (-1);
14898 }
14899
14900 if (stat (dictfile2, &tmp_stat) == -1)
14901 {
14902 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14903
14904 fclose (fp1);
14905 fclose (fp2);
14906
14907 return (-1);
14908 }
14909
14910 if (S_ISDIR (tmp_stat.st_mode))
14911 {
14912 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14913
14914 fclose (fp1);
14915 fclose (fp2);
14916
14917 return (-1);
14918 }
14919
14920 data.combs_cnt = 1;
14921
14922 data.quiet = 1;
14923
14924 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14925
14926 data.quiet = quiet;
14927
14928 if (words1_cnt == 0)
14929 {
14930 log_error ("ERROR: %s: empty file", dictfile1);
14931
14932 fclose (fp1);
14933 fclose (fp2);
14934
14935 return (-1);
14936 }
14937
14938 data.combs_cnt = 1;
14939
14940 data.quiet = 1;
14941
14942 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14943
14944 data.quiet = quiet;
14945
14946 if (words2_cnt == 0)
14947 {
14948 log_error ("ERROR: %s: empty file", dictfile2);
14949
14950 fclose (fp1);
14951 fclose (fp2);
14952
14953 return (-1);
14954 }
14955
14956 fclose (fp1);
14957 fclose (fp2);
14958
14959 data.dictfile = dictfile1;
14960 data.dictfile2 = dictfile2;
14961
14962 if (words1_cnt >= words2_cnt)
14963 {
14964 data.combs_cnt = words2_cnt;
14965 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14966
14967 dictfiles = &data.dictfile;
14968
14969 dictcnt = 1;
14970 }
14971 else
14972 {
14973 data.combs_cnt = words1_cnt;
14974 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14975
14976 dictfiles = &data.dictfile2;
14977
14978 dictcnt = 1;
14979
14980 // we also have to switch wordlist related rules!
14981
14982 char *tmpc = data.rule_buf_l;
14983
14984 data.rule_buf_l = data.rule_buf_r;
14985 data.rule_buf_r = tmpc;
14986
14987 int tmpi = data.rule_len_l;
14988
14989 data.rule_len_l = data.rule_len_r;
14990 data.rule_len_r = tmpi;
14991 }
14992 }
14993 else if (attack_mode == ATTACK_MODE_BF)
14994 {
14995 char *mask = NULL;
14996
14997 maskcnt = 0;
14998
14999 if (benchmark == 0)
15000 {
15001 mask = myargv[optind + 1];
15002
15003 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15004
15005 if ((optind + 2) <= myargc)
15006 {
15007 struct stat file_stat;
15008
15009 if (stat (mask, &file_stat) == -1)
15010 {
15011 maskcnt = 1;
15012
15013 masks[maskcnt - 1] = mystrdup (mask);
15014 }
15015 else
15016 {
15017 int wls_left = myargc - (optind + 1);
15018
15019 uint masks_avail = INCR_MASKS;
15020
15021 for (int i = 0; i < wls_left; i++)
15022 {
15023 if (i != 0)
15024 {
15025 mask = myargv[optind + 1 + i];
15026
15027 if (stat (mask, &file_stat) == -1)
15028 {
15029 log_error ("ERROR: %s: %s", mask, strerror (errno));
15030
15031 return (-1);
15032 }
15033 }
15034
15035 uint is_file = S_ISREG (file_stat.st_mode);
15036
15037 if (is_file == 1)
15038 {
15039 FILE *mask_fp;
15040
15041 if ((mask_fp = fopen (mask, "r")) == NULL)
15042 {
15043 log_error ("ERROR: %s: %s", mask, strerror (errno));
15044
15045 return (-1);
15046 }
15047
15048 char line_buf[BUFSIZ] = { 0 };
15049
15050 while (!feof (mask_fp))
15051 {
15052 memset (line_buf, 0, BUFSIZ);
15053
15054 int line_len = fgetl (mask_fp, line_buf);
15055
15056 if (line_len == 0) continue;
15057
15058 if (line_buf[0] == '#') continue;
15059
15060 if (masks_avail == maskcnt)
15061 {
15062 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15063
15064 masks_avail += INCR_MASKS;
15065 }
15066
15067 masks[maskcnt] = mystrdup (line_buf);
15068
15069 maskcnt++;
15070 }
15071
15072 fclose (mask_fp);
15073 }
15074 else
15075 {
15076 log_error ("ERROR: %s: unsupported file-type", mask);
15077
15078 return (-1);
15079 }
15080 }
15081
15082 mask_from_file = 1;
15083 }
15084 }
15085 else
15086 {
15087 custom_charset_1 = (char *) "?l?d?u";
15088 custom_charset_2 = (char *) "?l?d";
15089 custom_charset_3 = (char *) "?l?d*!$@_";
15090
15091 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15092 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15093 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15094
15095 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15096
15097 wordlist_mode = WL_MODE_MASK;
15098
15099 data.wordlist_mode = wordlist_mode;
15100
15101 increment = 1;
15102
15103 maskcnt = 1;
15104 }
15105 }
15106 else
15107 {
15108 /**
15109 * generate full masks and charsets
15110 */
15111
15112 masks = (char **) mymalloc (sizeof (char *));
15113
15114 switch (hash_mode)
15115 {
15116 case 1731: pw_min = 5;
15117 pw_max = 5;
15118 mask = mystrdup ("?b?b?b?b?b");
15119 break;
15120 case 12500: pw_min = 5;
15121 pw_max = 5;
15122 mask = mystrdup ("?b?b?b?b?b");
15123 break;
15124 default: pw_min = 7;
15125 pw_max = 7;
15126 mask = mystrdup ("?b?b?b?b?b?b?b");
15127 break;
15128 }
15129
15130 maskcnt = 1;
15131
15132 masks[maskcnt - 1] = mystrdup (mask);
15133
15134 wordlist_mode = WL_MODE_MASK;
15135
15136 data.wordlist_mode = wordlist_mode;
15137
15138 increment = 1;
15139 }
15140
15141 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15142
15143 if (increment)
15144 {
15145 if (increment_min > pw_min) pw_min = increment_min;
15146
15147 if (increment_max < pw_max) pw_max = increment_max;
15148 }
15149 }
15150 else if (attack_mode == ATTACK_MODE_HYBRID1)
15151 {
15152 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15153
15154 // display
15155
15156 char *mask = myargv[myargc - 1];
15157
15158 maskcnt = 0;
15159
15160 masks = (char **) mymalloc (1 * sizeof (char *));
15161
15162 // mod
15163
15164 struct stat file_stat;
15165
15166 if (stat (mask, &file_stat) == -1)
15167 {
15168 maskcnt = 1;
15169
15170 masks[maskcnt - 1] = mystrdup (mask);
15171 }
15172 else
15173 {
15174 uint is_file = S_ISREG (file_stat.st_mode);
15175
15176 if (is_file == 1)
15177 {
15178 FILE *mask_fp;
15179
15180 if ((mask_fp = fopen (mask, "r")) == NULL)
15181 {
15182 log_error ("ERROR: %s: %s", mask, strerror (errno));
15183
15184 return (-1);
15185 }
15186
15187 char line_buf[BUFSIZ] = { 0 };
15188
15189 uint masks_avail = 1;
15190
15191 while (!feof (mask_fp))
15192 {
15193 memset (line_buf, 0, BUFSIZ);
15194
15195 int line_len = fgetl (mask_fp, line_buf);
15196
15197 if (line_len == 0) continue;
15198
15199 if (line_buf[0] == '#') continue;
15200
15201 if (masks_avail == maskcnt)
15202 {
15203 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15204
15205 masks_avail += INCR_MASKS;
15206 }
15207
15208 masks[maskcnt] = mystrdup (line_buf);
15209
15210 maskcnt++;
15211 }
15212
15213 fclose (mask_fp);
15214
15215 mask_from_file = 1;
15216 }
15217 else
15218 {
15219 maskcnt = 1;
15220
15221 masks[maskcnt - 1] = mystrdup (mask);
15222 }
15223 }
15224
15225 // base
15226
15227 int wls_left = myargc - (optind + 2);
15228
15229 for (int i = 0; i < wls_left; i++)
15230 {
15231 char *filename = myargv[optind + 1 + i];
15232
15233 struct stat file_stat;
15234
15235 if (stat (filename, &file_stat) == -1)
15236 {
15237 log_error ("ERROR: %s: %s", filename, strerror (errno));
15238
15239 return (-1);
15240 }
15241
15242 uint is_dir = S_ISDIR (file_stat.st_mode);
15243
15244 if (is_dir == 0)
15245 {
15246 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15247
15248 dictcnt++;
15249
15250 dictfiles[dictcnt - 1] = filename;
15251 }
15252 else
15253 {
15254 // do not allow --keyspace w/ a directory
15255
15256 if (keyspace == 1)
15257 {
15258 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15259
15260 return (-1);
15261 }
15262
15263 char **dictionary_files = NULL;
15264
15265 dictionary_files = scan_directory (filename);
15266
15267 if (dictionary_files != NULL)
15268 {
15269 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15270
15271 for (int d = 0; dictionary_files[d] != NULL; d++)
15272 {
15273 char *l1_filename = dictionary_files[d];
15274
15275 struct stat l1_stat;
15276
15277 if (stat (l1_filename, &l1_stat) == -1)
15278 {
15279 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15280
15281 return (-1);
15282 }
15283
15284 if (S_ISREG (l1_stat.st_mode))
15285 {
15286 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15287
15288 dictcnt++;
15289
15290 dictfiles[dictcnt - 1] = strdup (l1_filename);
15291 }
15292 }
15293 }
15294
15295 local_free (dictionary_files);
15296 }
15297 }
15298
15299 if (dictcnt < 1)
15300 {
15301 log_error ("ERROR: No usable dictionary file found.");
15302
15303 return (-1);
15304 }
15305
15306 if (increment)
15307 {
15308 maskcnt = 0;
15309
15310 uint mask_min = increment_min; // we can't reject smaller masks here
15311 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15312
15313 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15314 {
15315 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15316
15317 if (cur_mask == NULL) break;
15318
15319 masks[maskcnt] = cur_mask;
15320
15321 maskcnt++;
15322
15323 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15324 }
15325 }
15326 }
15327 else if (attack_mode == ATTACK_MODE_HYBRID2)
15328 {
15329 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15330
15331 // display
15332
15333 char *mask = myargv[optind + 1 + 0];
15334
15335 maskcnt = 0;
15336
15337 masks = (char **) mymalloc (1 * sizeof (char *));
15338
15339 // mod
15340
15341 struct stat file_stat;
15342
15343 if (stat (mask, &file_stat) == -1)
15344 {
15345 maskcnt = 1;
15346
15347 masks[maskcnt - 1] = mystrdup (mask);
15348 }
15349 else
15350 {
15351 uint is_file = S_ISREG (file_stat.st_mode);
15352
15353 if (is_file == 1)
15354 {
15355 FILE *mask_fp;
15356
15357 if ((mask_fp = fopen (mask, "r")) == NULL)
15358 {
15359 log_error ("ERROR: %s: %s", mask, strerror (errno));
15360
15361 return (-1);
15362 }
15363
15364 char line_buf[BUFSIZ] = { 0 };
15365
15366 uint masks_avail = 1;
15367
15368 while (!feof (mask_fp))
15369 {
15370 memset (line_buf, 0, BUFSIZ);
15371
15372 int line_len = fgetl (mask_fp, line_buf);
15373
15374 if (line_len == 0) continue;
15375
15376 if (line_buf[0] == '#') continue;
15377
15378 if (masks_avail == maskcnt)
15379 {
15380 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15381
15382 masks_avail += INCR_MASKS;
15383 }
15384
15385 masks[maskcnt] = mystrdup (line_buf);
15386
15387 maskcnt++;
15388 }
15389
15390 fclose (mask_fp);
15391
15392 mask_from_file = 1;
15393 }
15394 else
15395 {
15396 maskcnt = 1;
15397
15398 masks[maskcnt - 1] = mystrdup (mask);
15399 }
15400 }
15401
15402 // base
15403
15404 int wls_left = myargc - (optind + 2);
15405
15406 for (int i = 0; i < wls_left; i++)
15407 {
15408 char *filename = myargv[optind + 2 + i];
15409
15410 struct stat file_stat;
15411
15412 if (stat (filename, &file_stat) == -1)
15413 {
15414 log_error ("ERROR: %s: %s", filename, strerror (errno));
15415
15416 return (-1);
15417 }
15418
15419 uint is_dir = S_ISDIR (file_stat.st_mode);
15420
15421 if (is_dir == 0)
15422 {
15423 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15424
15425 dictcnt++;
15426
15427 dictfiles[dictcnt - 1] = filename;
15428 }
15429 else
15430 {
15431 // do not allow --keyspace w/ a directory
15432
15433 if (keyspace == 1)
15434 {
15435 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15436
15437 return (-1);
15438 }
15439
15440 char **dictionary_files = NULL;
15441
15442 dictionary_files = scan_directory (filename);
15443
15444 if (dictionary_files != NULL)
15445 {
15446 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15447
15448 for (int d = 0; dictionary_files[d] != NULL; d++)
15449 {
15450 char *l1_filename = dictionary_files[d];
15451
15452 struct stat l1_stat;
15453
15454 if (stat (l1_filename, &l1_stat) == -1)
15455 {
15456 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15457
15458 return (-1);
15459 }
15460
15461 if (S_ISREG (l1_stat.st_mode))
15462 {
15463 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15464
15465 dictcnt++;
15466
15467 dictfiles[dictcnt - 1] = strdup (l1_filename);
15468 }
15469 }
15470 }
15471
15472 local_free (dictionary_files);
15473 }
15474 }
15475
15476 if (dictcnt < 1)
15477 {
15478 log_error ("ERROR: No usable dictionary file found.");
15479
15480 return (-1);
15481 }
15482
15483 if (increment)
15484 {
15485 maskcnt = 0;
15486
15487 uint mask_min = increment_min; // we can't reject smaller masks here
15488 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15489
15490 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15491 {
15492 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15493
15494 if (cur_mask == NULL) break;
15495
15496 masks[maskcnt] = cur_mask;
15497
15498 maskcnt++;
15499
15500 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15501 }
15502 }
15503 }
15504
15505 data.pw_min = pw_min;
15506 data.pw_max = pw_max;
15507
15508 /**
15509 * weak hash check
15510 */
15511
15512 if (weak_hash_threshold >= salts_cnt)
15513 {
15514 hc_device_param_t *device_param = NULL;
15515
15516 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15517 {
15518 device_param = &data.devices_param[device_id];
15519
15520 if (device_param->skipped) continue;
15521
15522 break;
15523 }
15524
15525 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15526
15527 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15528 {
15529 weak_hash_check (device_param, salt_pos);
15530 }
15531 }
15532
15533 // Display hack, guarantee that there is at least one \r before real start
15534
15535 if (data.quiet == 0) log_info_nn ("");
15536
15537 /**
15538 * status and monitor threads
15539 */
15540
15541 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15542
15543 hc_thread_t i_thread = 0;
15544
15545 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15546 {
15547 hc_thread_create (i_thread, thread_keypress, &benchmark);
15548 }
15549
15550 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15551
15552 uint ni_threads_cnt = 0;
15553
15554 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15555
15556 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15557
15558 ni_threads_cnt++;
15559
15560 /**
15561 * Outfile remove
15562 */
15563
15564 if (keyspace == 0)
15565 {
15566 if (outfile_check_timer != 0)
15567 {
15568 if (data.outfile_check_directory != NULL)
15569 {
15570 if ((hash_mode != 5200) &&
15571 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15572 (hash_mode != 9000))
15573 {
15574 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15575
15576 ni_threads_cnt++;
15577 }
15578 else
15579 {
15580 outfile_check_timer = 0;
15581 }
15582 }
15583 else
15584 {
15585 outfile_check_timer = 0;
15586 }
15587 }
15588 }
15589
15590 /**
15591 * Inform the user if we got some hashes remove because of the pot file remove feature
15592 */
15593
15594 if (data.quiet == 0)
15595 {
15596 if (potfile_remove_cracks > 0)
15597 {
15598 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15599 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15600 }
15601 }
15602
15603 data.outfile_check_timer = outfile_check_timer;
15604
15605 /**
15606 * main loop
15607 */
15608
15609 char **induction_dictionaries = NULL;
15610
15611 int induction_dictionaries_cnt = 0;
15612
15613 hcstat_table_t *root_table_buf = NULL;
15614 hcstat_table_t *markov_table_buf = NULL;
15615
15616 uint initial_restore_done = 0;
15617
15618 data.maskcnt = maskcnt;
15619
15620 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15621 {
15622 if (data.devices_status == STATUS_CRACKED) break;
15623
15624 data.devices_status = STATUS_INIT;
15625
15626 if (maskpos > rd->maskpos)
15627 {
15628 rd->dictpos = 0;
15629 }
15630
15631 rd->maskpos = maskpos;
15632 data.maskpos = maskpos;
15633
15634 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15635 {
15636 char *mask = masks[maskpos];
15637
15638 if (mask_from_file == 1)
15639 {
15640 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15641
15642 char *str_ptr;
15643 uint str_pos;
15644
15645 uint mask_offset = 0;
15646
15647 uint separator_cnt;
15648
15649 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15650 {
15651 str_ptr = strstr (mask + mask_offset, ",");
15652
15653 if (str_ptr == NULL) break;
15654
15655 str_pos = str_ptr - mask;
15656
15657 // escaped separator, i.e. "\,"
15658
15659 if (str_pos > 0)
15660 {
15661 if (mask[str_pos - 1] == '\\')
15662 {
15663 separator_cnt --;
15664
15665 mask_offset = str_pos + 1;
15666
15667 continue;
15668 }
15669 }
15670
15671 // reset the offset
15672
15673 mask_offset = 0;
15674
15675 mask[str_pos] = '\0';
15676
15677 switch (separator_cnt)
15678 {
15679 case 0:
15680 mp_reset_usr (mp_usr, 0);
15681
15682 custom_charset_1 = mask;
15683 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15684 break;
15685
15686 case 1:
15687 mp_reset_usr (mp_usr, 1);
15688
15689 custom_charset_2 = mask;
15690 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15691 break;
15692
15693 case 2:
15694 mp_reset_usr (mp_usr, 2);
15695
15696 custom_charset_3 = mask;
15697 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15698 break;
15699
15700 case 3:
15701 mp_reset_usr (mp_usr, 3);
15702
15703 custom_charset_4 = mask;
15704 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15705 break;
15706 }
15707
15708 mask = mask + str_pos + 1;
15709 }
15710 }
15711
15712 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15713 {
15714 if (maskpos > 0)
15715 {
15716 local_free (css_buf);
15717 local_free (data.root_css_buf);
15718 local_free (data.markov_css_buf);
15719
15720 local_free (masks[maskpos - 1]);
15721 }
15722
15723 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15724
15725 data.mask = mask;
15726 data.css_cnt = css_cnt;
15727 data.css_buf = css_buf;
15728
15729 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15730
15731 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15732
15733 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15734 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15735
15736 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15737
15738 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15739
15740 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15741 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15742
15743 data.root_css_buf = root_css_buf;
15744 data.markov_css_buf = markov_css_buf;
15745
15746 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15747
15748 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15749
15750 local_free (root_table_buf);
15751 local_free (markov_table_buf);
15752
15753 // args
15754
15755 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15756 {
15757 hc_device_param_t *device_param = &data.devices_param[device_id];
15758
15759 if (device_param->skipped) continue;
15760
15761 device_param->kernel_params_mp[0] = &device_param->d_combs;
15762 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15763 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15764
15765 device_param->kernel_params_mp_buf64[3] = 0;
15766 device_param->kernel_params_mp_buf32[4] = css_cnt;
15767 device_param->kernel_params_mp_buf32[5] = 0;
15768 device_param->kernel_params_mp_buf32[6] = 0;
15769 device_param->kernel_params_mp_buf32[7] = 0;
15770
15771 if (attack_mode == ATTACK_MODE_HYBRID1)
15772 {
15773 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15774 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15775 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15776 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15777 }
15778 else if (attack_mode == ATTACK_MODE_HYBRID2)
15779 {
15780 device_param->kernel_params_mp_buf32[5] = 0;
15781 device_param->kernel_params_mp_buf32[6] = 0;
15782 device_param->kernel_params_mp_buf32[7] = 0;
15783 }
15784
15785 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]);
15786 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]);
15787 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]);
15788
15789 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);
15790 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);
15791 }
15792 }
15793 else if (attack_mode == ATTACK_MODE_BF)
15794 {
15795 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15796
15797 if (increment)
15798 {
15799 for (uint i = 0; i < dictcnt; i++)
15800 {
15801 local_free (dictfiles[i]);
15802 }
15803
15804 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15805 {
15806 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15807
15808 if (l1_filename == NULL) break;
15809
15810 dictcnt++;
15811
15812 dictfiles[dictcnt - 1] = l1_filename;
15813 }
15814 }
15815 else
15816 {
15817 dictcnt++;
15818
15819 dictfiles[dictcnt - 1] = mask;
15820 }
15821
15822 if (dictcnt == 0)
15823 {
15824 log_error ("ERROR: Mask is too small");
15825
15826 return (-1);
15827 }
15828 }
15829 }
15830
15831 free (induction_dictionaries);
15832
15833 // induction_dictionaries_cnt = 0; // implied
15834
15835 if (attack_mode != ATTACK_MODE_BF)
15836 {
15837 if (keyspace == 0)
15838 {
15839 induction_dictionaries = scan_directory (induction_directory);
15840
15841 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15842 }
15843 }
15844
15845 if (induction_dictionaries_cnt)
15846 {
15847 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15848 }
15849
15850 /**
15851 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15852 */
15853 if (keyspace == 1)
15854 {
15855 if ((maskcnt > 1) || (dictcnt > 1))
15856 {
15857 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15858
15859 return (-1);
15860 }
15861 }
15862
15863 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15864 {
15865 char *subid = logfile_generate_subid ();
15866
15867 data.subid = subid;
15868
15869 logfile_sub_msg ("START");
15870
15871 data.devices_status = STATUS_INIT;
15872
15873 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15874 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15875 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15876
15877 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15878
15879 data.cpt_pos = 0;
15880
15881 data.cpt_start = time (NULL);
15882
15883 data.cpt_total = 0;
15884
15885 if (data.restore == 0)
15886 {
15887 rd->words_cur = skip;
15888
15889 skip = 0;
15890
15891 data.skip = 0;
15892 }
15893
15894 data.ms_paused = 0;
15895
15896 data.words_cur = rd->words_cur;
15897
15898 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15899 {
15900 hc_device_param_t *device_param = &data.devices_param[device_id];
15901
15902 if (device_param->skipped) continue;
15903
15904 device_param->speed_pos = 0;
15905
15906 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15907 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15908 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15909
15910 device_param->exec_pos = 0;
15911
15912 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
15913
15914 device_param->kernel_power = device_param->kernel_power_user;
15915
15916 device_param->outerloop_pos = 0;
15917 device_param->outerloop_left = 0;
15918 device_param->innerloop_pos = 0;
15919 device_param->innerloop_left = 0;
15920
15921 // some more resets:
15922
15923 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15924
15925 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15926
15927 device_param->pw_cnt = 0;
15928 device_param->pws_cnt = 0;
15929
15930 device_param->words_off = 0;
15931 device_param->words_done = 0;
15932 }
15933
15934 data.kernel_power_div = 0;
15935
15936 // figure out some workload
15937
15938 if (attack_mode == ATTACK_MODE_STRAIGHT)
15939 {
15940 if (data.wordlist_mode == WL_MODE_FILE)
15941 {
15942 char *dictfile = NULL;
15943
15944 if (induction_dictionaries_cnt)
15945 {
15946 dictfile = induction_dictionaries[0];
15947 }
15948 else
15949 {
15950 dictfile = dictfiles[dictpos];
15951 }
15952
15953 data.dictfile = dictfile;
15954
15955 logfile_sub_string (dictfile);
15956
15957 for (uint i = 0; i < rp_files_cnt; i++)
15958 {
15959 logfile_sub_var_string ("rulefile", rp_files[i]);
15960 }
15961
15962 FILE *fd2 = fopen (dictfile, "rb");
15963
15964 if (fd2 == NULL)
15965 {
15966 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15967
15968 return (-1);
15969 }
15970
15971 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15972
15973 fclose (fd2);
15974
15975 if (data.words_cnt == 0)
15976 {
15977 if (data.devices_status == STATUS_CRACKED) break;
15978 if (data.devices_status == STATUS_ABORTED) break;
15979
15980 dictpos++;
15981
15982 continue;
15983 }
15984 }
15985 }
15986 else if (attack_mode == ATTACK_MODE_COMBI)
15987 {
15988 char *dictfile = data.dictfile;
15989 char *dictfile2 = data.dictfile2;
15990
15991 logfile_sub_string (dictfile);
15992 logfile_sub_string (dictfile2);
15993
15994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15995 {
15996 FILE *fd2 = fopen (dictfile, "rb");
15997
15998 if (fd2 == NULL)
15999 {
16000 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16001
16002 return (-1);
16003 }
16004
16005 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16006
16007 fclose (fd2);
16008 }
16009 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16010 {
16011 FILE *fd2 = fopen (dictfile2, "rb");
16012
16013 if (fd2 == NULL)
16014 {
16015 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16016
16017 return (-1);
16018 }
16019
16020 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16021
16022 fclose (fd2);
16023 }
16024
16025 if (data.words_cnt == 0)
16026 {
16027 if (data.devices_status == STATUS_CRACKED) break;
16028 if (data.devices_status == STATUS_ABORTED) break;
16029
16030 dictpos++;
16031
16032 continue;
16033 }
16034 }
16035 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16036 {
16037 char *dictfile = NULL;
16038
16039 if (induction_dictionaries_cnt)
16040 {
16041 dictfile = induction_dictionaries[0];
16042 }
16043 else
16044 {
16045 dictfile = dictfiles[dictpos];
16046 }
16047
16048 data.dictfile = dictfile;
16049
16050 char *mask = data.mask;
16051
16052 logfile_sub_string (dictfile);
16053 logfile_sub_string (mask);
16054
16055 FILE *fd2 = fopen (dictfile, "rb");
16056
16057 if (fd2 == NULL)
16058 {
16059 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16060
16061 return (-1);
16062 }
16063
16064 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16065
16066 fclose (fd2);
16067
16068 if (data.words_cnt == 0)
16069 {
16070 if (data.devices_status == STATUS_CRACKED) break;
16071 if (data.devices_status == STATUS_ABORTED) break;
16072
16073 dictpos++;
16074
16075 continue;
16076 }
16077 }
16078 else if (attack_mode == ATTACK_MODE_BF)
16079 {
16080 local_free (css_buf);
16081 local_free (data.root_css_buf);
16082 local_free (data.markov_css_buf);
16083
16084 char *mask = dictfiles[dictpos];
16085
16086 logfile_sub_string (mask);
16087
16088 // base
16089
16090 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16091
16092 if (opts_type & OPTS_TYPE_PT_UNICODE)
16093 {
16094 uint css_cnt_unicode = css_cnt * 2;
16095
16096 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16097
16098 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16099 {
16100 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16101
16102 css_buf_unicode[j + 1].cs_buf[0] = 0;
16103 css_buf_unicode[j + 1].cs_len = 1;
16104 }
16105
16106 free (css_buf);
16107
16108 css_buf = css_buf_unicode;
16109 css_cnt = css_cnt_unicode;
16110 }
16111
16112 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16113
16114 uint mask_min = pw_min;
16115 uint mask_max = pw_max;
16116
16117 if (opts_type & OPTS_TYPE_PT_UNICODE)
16118 {
16119 mask_min *= 2;
16120 mask_max *= 2;
16121 }
16122
16123 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16124 {
16125 if (css_cnt < mask_min)
16126 {
16127 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16128 }
16129
16130 if (css_cnt > mask_max)
16131 {
16132 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16133 }
16134
16135 // skip to next mask
16136
16137 dictpos++;
16138
16139 rd->dictpos = dictpos;
16140
16141 logfile_sub_msg ("STOP");
16142
16143 continue;
16144 }
16145
16146 uint save_css_cnt = css_cnt;
16147
16148 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16149 {
16150 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16151 {
16152 uint salt_len = (uint) data.salts_buf[0].salt_len;
16153 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16154
16155 uint css_cnt_salt = css_cnt + salt_len;
16156
16157 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16158
16159 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16160
16161 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16162 {
16163 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16164 css_buf_salt[j].cs_len = 1;
16165 }
16166
16167 free (css_buf);
16168
16169 css_buf = css_buf_salt;
16170 css_cnt = css_cnt_salt;
16171 }
16172 }
16173
16174 data.mask = mask;
16175 data.css_cnt = css_cnt;
16176 data.css_buf = css_buf;
16177
16178 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16179
16180 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16181
16182 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16183
16184 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16185 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16186
16187 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16188
16189 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16190
16191 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16192 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16193
16194 data.root_css_buf = root_css_buf;
16195 data.markov_css_buf = markov_css_buf;
16196
16197 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16198
16199 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16200
16201 local_free (root_table_buf);
16202 local_free (markov_table_buf);
16203
16204 // copy + args
16205
16206 uint css_cnt_l = css_cnt;
16207 uint css_cnt_r;
16208
16209 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16210 {
16211 if (save_css_cnt < 6)
16212 {
16213 css_cnt_r = 1;
16214 }
16215 else if (save_css_cnt == 6)
16216 {
16217 css_cnt_r = 2;
16218 }
16219 else
16220 {
16221 if (opts_type & OPTS_TYPE_PT_UNICODE)
16222 {
16223 if (save_css_cnt == 8 || save_css_cnt == 10)
16224 {
16225 css_cnt_r = 2;
16226 }
16227 else
16228 {
16229 css_cnt_r = 4;
16230 }
16231 }
16232 else
16233 {
16234 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16235 {
16236 css_cnt_r = 3;
16237 }
16238 else
16239 {
16240 css_cnt_r = 4;
16241 }
16242 }
16243 }
16244 }
16245 else
16246 {
16247 css_cnt_r = 1;
16248
16249 /* unfinished code?
16250 int sum = css_buf[css_cnt_r - 1].cs_len;
16251
16252 for (uint i = 1; i < 4 && i < css_cnt; i++)
16253 {
16254 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16255
16256 css_cnt_r++;
16257
16258 sum *= css_buf[css_cnt_r - 1].cs_len;
16259 }
16260 */
16261 }
16262
16263 css_cnt_l -= css_cnt_r;
16264
16265 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16266
16267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16268 {
16269 hc_device_param_t *device_param = &data.devices_param[device_id];
16270
16271 if (device_param->skipped) continue;
16272
16273 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16274 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16275 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16276
16277 device_param->kernel_params_mp_l_buf64[3] = 0;
16278 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16279 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16280 device_param->kernel_params_mp_l_buf32[6] = 0;
16281 device_param->kernel_params_mp_l_buf32[7] = 0;
16282 device_param->kernel_params_mp_l_buf32[8] = 0;
16283
16284 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16285 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16286 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16287 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16288
16289 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16290 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16291 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16292
16293 device_param->kernel_params_mp_r_buf64[3] = 0;
16294 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16295 device_param->kernel_params_mp_r_buf32[5] = 0;
16296 device_param->kernel_params_mp_r_buf32[6] = 0;
16297 device_param->kernel_params_mp_r_buf32[7] = 0;
16298
16299 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]);
16300 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]);
16301 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]);
16302
16303 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]);
16304 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]);
16305 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]);
16306
16307 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);
16308 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);
16309 }
16310 }
16311
16312 u64 words_base = data.words_cnt;
16313
16314 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16315 {
16316 if (data.kernel_rules_cnt)
16317 {
16318 words_base /= data.kernel_rules_cnt;
16319 }
16320 }
16321 else if (data.attack_kern == ATTACK_KERN_COMBI)
16322 {
16323 if (data.combs_cnt)
16324 {
16325 words_base /= data.combs_cnt;
16326 }
16327 }
16328 else if (data.attack_kern == ATTACK_KERN_BF)
16329 {
16330 if (data.bfs_cnt)
16331 {
16332 words_base /= data.bfs_cnt;
16333 }
16334 }
16335
16336 data.words_base = words_base;
16337
16338 if (keyspace == 1)
16339 {
16340 log_info ("%llu", (unsigned long long int) words_base);
16341
16342 return (0);
16343 }
16344
16345 if (data.words_cur > data.words_base)
16346 {
16347 log_error ("ERROR: restore value greater keyspace");
16348
16349 return (-1);
16350 }
16351
16352 if (data.words_cur)
16353 {
16354 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16355 {
16356 for (uint i = 0; i < data.salts_cnt; i++)
16357 {
16358 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16359 }
16360 }
16361 else if (data.attack_kern == ATTACK_KERN_COMBI)
16362 {
16363 for (uint i = 0; i < data.salts_cnt; i++)
16364 {
16365 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16366 }
16367 }
16368 else if (data.attack_kern == ATTACK_KERN_BF)
16369 {
16370 for (uint i = 0; i < data.salts_cnt; i++)
16371 {
16372 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16373 }
16374 }
16375 }
16376
16377 /*
16378 * Inform user about possible slow speeds
16379 */
16380
16381 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16382 {
16383 if (data.words_base < kernel_power_all)
16384 {
16385 if (quiet == 0)
16386 {
16387 log_info ("");
16388 log_info ("ATTENTION!");
16389 log_info (" The wordlist or mask you are using is too small.");
16390 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16391 log_info (" The cracking speed will drop.");
16392 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16393 log_info ("");
16394 }
16395 }
16396 }
16397
16398 /*
16399 * Update loopback file
16400 */
16401
16402 if (loopback == 1)
16403 {
16404 time_t now;
16405
16406 time (&now);
16407
16408 uint random_num = get_random_num (0, 9999);
16409
16410 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16411
16412 data.loopback_file = loopback_file;
16413 }
16414
16415 /*
16416 * Update dictionary statistic
16417 */
16418
16419 if (keyspace == 0)
16420 {
16421 dictstat_fp = fopen (dictstat, "wb");
16422
16423 if (dictstat_fp)
16424 {
16425 lock_file (dictstat_fp);
16426
16427 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16428
16429 fclose (dictstat_fp);
16430 }
16431 }
16432
16433 data.devices_status = STATUS_RUNNING;
16434
16435 if (initial_restore_done == 0)
16436 {
16437 if (data.restore_disable == 0) cycle_restore ();
16438
16439 initial_restore_done = 1;
16440 }
16441
16442 hc_timer_set (&data.timer_running);
16443
16444 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16445 {
16446 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16447 {
16448 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16449 if (quiet == 0) fflush (stdout);
16450 }
16451 }
16452 else if (wordlist_mode == WL_MODE_STDIN)
16453 {
16454 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16455 if (data.quiet == 0) log_info ("");
16456 }
16457
16458 time_t runtime_start;
16459
16460 time (&runtime_start);
16461
16462 data.runtime_start = runtime_start;
16463
16464 /**
16465 * create cracker threads
16466 */
16467
16468 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16469
16470 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16471 {
16472 hc_device_param_t *device_param = &devices_param[device_id];
16473
16474 if (wordlist_mode == WL_MODE_STDIN)
16475 {
16476 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16477 }
16478 else
16479 {
16480 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16481 }
16482 }
16483
16484 // wait for crack threads to exit
16485
16486 hc_thread_wait (data.devices_cnt, c_threads);
16487
16488 local_free (c_threads);
16489
16490 data.restore = 0;
16491
16492 // finalize task
16493
16494 logfile_sub_var_uint ("status-after-work", data.devices_status);
16495
16496 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16497
16498 if (data.devices_status == STATUS_CRACKED) break;
16499 if (data.devices_status == STATUS_ABORTED) break;
16500
16501 if (data.devices_status == STATUS_BYPASS)
16502 {
16503 data.devices_status = STATUS_RUNNING;
16504 }
16505
16506 if (induction_dictionaries_cnt)
16507 {
16508 unlink (induction_dictionaries[0]);
16509 }
16510
16511 free (induction_dictionaries);
16512
16513 if (attack_mode != ATTACK_MODE_BF)
16514 {
16515 induction_dictionaries = scan_directory (induction_directory);
16516
16517 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16518 }
16519
16520 if (benchmark == 0)
16521 {
16522 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16523 {
16524 if (quiet == 0) clear_prompt ();
16525
16526 if (quiet == 0) log_info ("");
16527
16528 if (status == 1)
16529 {
16530 status_display ();
16531 }
16532 else
16533 {
16534 if (quiet == 0) status_display ();
16535 }
16536
16537 if (quiet == 0) log_info ("");
16538 }
16539 }
16540
16541 if (attack_mode == ATTACK_MODE_BF)
16542 {
16543 dictpos++;
16544
16545 rd->dictpos = dictpos;
16546 }
16547 else
16548 {
16549 if (induction_dictionaries_cnt)
16550 {
16551 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16552 }
16553 else
16554 {
16555 dictpos++;
16556
16557 rd->dictpos = dictpos;
16558 }
16559 }
16560
16561 time_t runtime_stop;
16562
16563 time (&runtime_stop);
16564
16565 data.runtime_stop = runtime_stop;
16566
16567 logfile_sub_uint (runtime_start);
16568 logfile_sub_uint (runtime_stop);
16569
16570 logfile_sub_msg ("STOP");
16571
16572 global_free (subid);
16573 }
16574
16575 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16576
16577 if (data.devices_status == STATUS_CRACKED) break;
16578 if (data.devices_status == STATUS_ABORTED) break;
16579 if (data.devices_status == STATUS_QUIT) break;
16580
16581 if (data.devices_status == STATUS_BYPASS)
16582 {
16583 data.devices_status = STATUS_RUNNING;
16584 }
16585 }
16586
16587 // 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
16588
16589 if (attack_mode == ATTACK_MODE_STRAIGHT)
16590 {
16591 if (data.wordlist_mode == WL_MODE_FILE)
16592 {
16593 if (data.dictfile == NULL)
16594 {
16595 if (dictfiles != NULL)
16596 {
16597 data.dictfile = dictfiles[0];
16598
16599 hc_timer_set (&data.timer_running);
16600 }
16601 }
16602 }
16603 }
16604 // NOTE: combi is okay because it is already set beforehand
16605 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16606 {
16607 if (data.dictfile == NULL)
16608 {
16609 if (dictfiles != NULL)
16610 {
16611 hc_timer_set (&data.timer_running);
16612
16613 data.dictfile = dictfiles[0];
16614 }
16615 }
16616 }
16617 else if (attack_mode == ATTACK_MODE_BF)
16618 {
16619 if (data.mask == NULL)
16620 {
16621 hc_timer_set (&data.timer_running);
16622
16623 data.mask = masks[0];
16624 }
16625 }
16626
16627 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16628 {
16629 data.devices_status = STATUS_EXHAUSTED;
16630 }
16631
16632 // if cracked / aborted remove last induction dictionary
16633
16634 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16635 {
16636 struct stat induct_stat;
16637
16638 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16639 {
16640 unlink (induction_dictionaries[file_pos]);
16641 }
16642 }
16643
16644 // wait for non-interactive threads
16645
16646 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16647 {
16648 hc_thread_wait (1, &ni_threads[thread_idx]);
16649 }
16650
16651 local_free (ni_threads);
16652
16653 // wait for interactive threads
16654
16655 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16656 {
16657 hc_thread_wait (1, &i_thread);
16658 }
16659
16660 // we dont need restore file anymore
16661 if (data.restore_disable == 0)
16662 {
16663 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16664 {
16665 unlink (eff_restore_file);
16666 unlink (new_restore_file);
16667 }
16668 else
16669 {
16670 cycle_restore ();
16671 }
16672 }
16673
16674 // finally save left hashes
16675
16676 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16677 {
16678 save_hash ();
16679 }
16680
16681 /**
16682 * Clean up
16683 */
16684
16685 if (benchmark == 1)
16686 {
16687 status_benchmark ();
16688
16689 log_info ("");
16690 }
16691 else
16692 {
16693 if (quiet == 0) clear_prompt ();
16694
16695 if (quiet == 0) log_info ("");
16696
16697 if (status == 1)
16698 {
16699 status_display ();
16700 }
16701 else
16702 {
16703 if (quiet == 0) status_display ();
16704 }
16705
16706 if (quiet == 0) log_info ("");
16707 }
16708
16709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16710 {
16711 hc_device_param_t *device_param = &data.devices_param[device_id];
16712
16713 if (device_param->skipped) continue;
16714
16715 local_free (device_param->result);
16716
16717 local_free (device_param->pw_caches);
16718
16719 local_free (device_param->combs_buf);
16720
16721 local_free (device_param->hooks_buf);
16722
16723 local_free (device_param->device_name);
16724
16725 local_free (device_param->device_name_chksum);
16726
16727 local_free (device_param->device_version);
16728
16729 local_free (device_param->driver_version);
16730
16731 if (device_param->pws_buf) myfree (device_param->pws_buf);
16732 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16733 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16734 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16735 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16736 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16737 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16738 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16739 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16740 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16741 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16742 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16743 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16744 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16745 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16746 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16747 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16748 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16749 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16750 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16751 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16752 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16753 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16754 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16755 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16756 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16757 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16758 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16759 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16760
16761 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16762 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16763 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16764 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16765 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16766 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16767 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16768 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16769 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16770 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16771 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16772
16773 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16774 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16775 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16776
16777 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16778 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16779 }
16780
16781 // reset default fan speed
16782
16783 #ifdef HAVE_HWMON
16784 if (gpu_temp_disable == 0)
16785 {
16786 #ifdef HAVE_ADL
16787 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16788 {
16789 hc_thread_mutex_lock (mux_adl);
16790
16791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16792 {
16793 hc_device_param_t *device_param = &data.devices_param[device_id];
16794
16795 if (device_param->skipped) continue;
16796
16797 if (data.hm_device[device_id].fan_supported == 1)
16798 {
16799 int fanspeed = temp_retain_fanspeed_value[device_id];
16800
16801 if (fanspeed == -1) continue;
16802
16803 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16804
16805 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16806 }
16807 }
16808
16809 hc_thread_mutex_unlock (mux_adl);
16810 }
16811 #endif // HAVE_ADL
16812 }
16813
16814 #ifdef HAVE_ADL
16815 // reset power tuning
16816
16817 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16818 {
16819 hc_thread_mutex_lock (mux_adl);
16820
16821 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16822 {
16823 hc_device_param_t *device_param = &data.devices_param[device_id];
16824
16825 if (device_param->skipped) continue;
16826
16827 if (data.hm_device[device_id].od_version == 6)
16828 {
16829 // check powertune capabilities first, if not available then skip device
16830
16831 int powertune_supported = 0;
16832
16833 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16834 {
16835 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16836
16837 return (-1);
16838 }
16839
16840 if (powertune_supported != 0)
16841 {
16842 // powercontrol settings
16843
16844 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)
16845 {
16846 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16847
16848 return (-1);
16849 }
16850
16851 // clocks
16852
16853 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16854
16855 performance_state->iNumberOfPerformanceLevels = 2;
16856
16857 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16858 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16859 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16860 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16861
16862 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)
16863 {
16864 log_info ("ERROR: Failed to restore ADL performance state");
16865
16866 return (-1);
16867 }
16868
16869 local_free (performance_state);
16870 }
16871 }
16872 }
16873
16874 hc_thread_mutex_unlock (mux_adl);
16875 }
16876 #endif // HAVE_ADL
16877
16878 if (gpu_temp_disable == 0)
16879 {
16880 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16881 if (data.hm_nv)
16882 {
16883 #if defined(LINUX) && defined(HAVE_NVML)
16884
16885 hm_NVML_nvmlShutdown (data.hm_nv);
16886
16887 nvml_close (data.hm_nv);
16888
16889 #elif defined(WIN) && (HAVE_NVAPI)
16890
16891 hm_NvAPI_Unload (data.hm_nv);
16892
16893 nvapi_close (data.hm_nv);
16894
16895 #endif
16896
16897 data.hm_nv = NULL;
16898 }
16899 #endif
16900
16901 #ifdef HAVE_ADL
16902 if (data.hm_amd)
16903 {
16904 hm_ADL_Main_Control_Destroy (data.hm_amd);
16905
16906 adl_close (data.hm_amd);
16907 data.hm_amd = NULL;
16908 }
16909 #endif
16910 }
16911 #endif // HAVE_HWMON
16912
16913 // free memory
16914
16915 local_free (masks);
16916
16917 local_free (dictstat_base);
16918
16919 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16920 {
16921 pot_t *pot_ptr = &pot[pot_pos];
16922
16923 hash_t *hash = &pot_ptr->hash;
16924
16925 local_free (hash->digest);
16926
16927 if (isSalted)
16928 {
16929 local_free (hash->salt);
16930 }
16931 }
16932
16933 local_free (pot);
16934
16935 local_free (all_kernel_rules_cnt);
16936 local_free (all_kernel_rules_buf);
16937
16938 local_free (wl_data->buf);
16939 local_free (wl_data);
16940
16941 local_free (bitmap_s1_a);
16942 local_free (bitmap_s1_b);
16943 local_free (bitmap_s1_c);
16944 local_free (bitmap_s1_d);
16945 local_free (bitmap_s2_a);
16946 local_free (bitmap_s2_b);
16947 local_free (bitmap_s2_c);
16948 local_free (bitmap_s2_d);
16949
16950 #ifdef HAVE_HWMON
16951 local_free (temp_retain_fanspeed_value);
16952 #ifdef HAVE_ADL
16953 local_free (od_clock_mem_status);
16954 local_free (od_power_control_status);
16955 #endif // ADL
16956 #endif
16957
16958 global_free (devices_param);
16959
16960 global_free (kernel_rules_buf);
16961
16962 global_free (root_css_buf);
16963 global_free (markov_css_buf);
16964
16965 global_free (digests_buf);
16966 global_free (digests_shown);
16967 global_free (digests_shown_tmp);
16968
16969 global_free (salts_buf);
16970 global_free (salts_shown);
16971
16972 global_free (esalts_buf);
16973
16974 global_free (words_progress_done);
16975 global_free (words_progress_rejected);
16976 global_free (words_progress_restored);
16977
16978 if (pot_fp) fclose (pot_fp);
16979
16980 if (data.devices_status == STATUS_QUIT) break;
16981 }
16982
16983 // destroy others mutex
16984
16985 hc_thread_mutex_delete (mux_dispatcher);
16986 hc_thread_mutex_delete (mux_counter);
16987 hc_thread_mutex_delete (mux_display);
16988 hc_thread_mutex_delete (mux_adl);
16989
16990 // free memory
16991
16992 local_free (eff_restore_file);
16993 local_free (new_restore_file);
16994
16995 local_free (rd);
16996
16997 // tuning db
16998
16999 tuning_db_destroy (tuning_db);
17000
17001 // loopback
17002
17003 local_free (loopback_file);
17004
17005 if (loopback == 1) unlink (loopback_file);
17006
17007 // induction directory
17008
17009 if (induction_dir == NULL)
17010 {
17011 if (attack_mode != ATTACK_MODE_BF)
17012 {
17013 if (rmdir (induction_directory) == -1)
17014 {
17015 if (errno == ENOENT)
17016 {
17017 // good, we can ignore
17018 }
17019 else if (errno == ENOTEMPTY)
17020 {
17021 // good, we can ignore
17022 }
17023 else
17024 {
17025 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17026
17027 return (-1);
17028 }
17029 }
17030
17031 local_free (induction_directory);
17032 }
17033 }
17034
17035 // outfile-check directory
17036
17037 if (outfile_check_dir == NULL)
17038 {
17039 if (rmdir (outfile_check_directory) == -1)
17040 {
17041 if (errno == ENOENT)
17042 {
17043 // good, we can ignore
17044 }
17045 else if (errno == ENOTEMPTY)
17046 {
17047 // good, we can ignore
17048 }
17049 else
17050 {
17051 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17052
17053 return (-1);
17054 }
17055 }
17056
17057 local_free (outfile_check_directory);
17058 }
17059
17060 time_t proc_stop;
17061
17062 time (&proc_stop);
17063
17064 logfile_top_uint (proc_start);
17065 logfile_top_uint (proc_stop);
17066
17067 logfile_top_msg ("STOP");
17068
17069 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17070 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17071
17072 if (data.ocl) ocl_close (data.ocl);
17073
17074 if (data.devices_status == STATUS_ABORTED) return 2;
17075 if (data.devices_status == STATUS_QUIT) return 2;
17076 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17077 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17078 if (data.devices_status == STATUS_CRACKED) return 0;
17079
17080 return -1;
17081 }
Hashcat additions to support pwdhash