projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added the execution time of the running kernel to the status display
[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 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
400 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Reduced performance profile (low latency desktop)",
447 " 2 = Default performance profile",
448 " 3 = Tuned performance profile (high latency desktop)",
449 "",
450 "* Benchmark Settings:",
451 "",
452 " 0 = Manual Tuning",
453 " 1 = Performance Tuning, default",
454 "",
455 "* OpenCL device-types:",
456 "",
457 " 1 = CPU devices",
458 " 2 = GPU devices",
459 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
460 "",
461 "* Outfile Formats:",
462 "",
463 " 1 = hash[:salt]",
464 " 2 = plain",
465 " 3 = hash[:salt]:plain",
466 " 4 = hex_plain",
467 " 5 = hash[:salt]:hex_plain",
468 " 6 = plain:hex_plain",
469 " 7 = hash[:salt]:plain:hex_plain",
470 " 8 = crackpos",
471 " 9 = hash[:salt]:crackpos",
472 " 10 = plain:crackpos",
473 " 11 = hash[:salt]:plain:crackpos",
474 " 12 = hex_plain:crackpos",
475 " 13 = hash[:salt]:hex_plain:crackpos",
476 " 14 = plain:hex_plain:crackpos",
477 " 15 = hash[:salt]:plain:hex_plain:crackpos",
478 "",
479 "* Debug mode output formats (for hybrid mode only, by using rules):",
480 "",
481 " 1 = save finding rule",
482 " 2 = save original word",
483 " 3 = save original word and finding rule",
484 " 4 = save original word, finding rule and modified plain",
485 "",
486 "* Built-in charsets:",
487 "",
488 " ?l = abcdefghijklmnopqrstuvwxyz",
489 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
490 " ?d = 0123456789",
491 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
492 " ?a = ?l?u?d?s",
493 " ?b = 0x00 - 0xff",
494 "",
495 "* Attack modes:",
496 "",
497 " 0 = Straight",
498 " 1 = Combination",
499 " 3 = Brute-force",
500 " 6 = Hybrid dict + mask",
501 " 7 = Hybrid mask + dict",
502 "",
503 "* Hash types:",
504 "",
505 "[[ Roll-your-own: Raw Hashes ]]",
506 "",
507 " 900 = MD4",
508 " 0 = MD5",
509 " 5100 = Half MD5",
510 " 100 = SHA1",
511 " 10800 = SHA-384",
512 " 1400 = SHA-256",
513 " 1700 = SHA-512",
514 " 5000 = SHA-3(Keccak)",
515 " 10100 = SipHash",
516 " 6000 = RipeMD160",
517 " 6100 = Whirlpool",
518 " 6900 = GOST R 34.11-94",
519 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
520 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
521 "",
522 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
523 "",
524 " 10 = md5($pass.$salt)",
525 " 20 = md5($salt.$pass)",
526 " 30 = md5(unicode($pass).$salt)",
527 " 40 = md5($salt.unicode($pass))",
528 " 3800 = md5($salt.$pass.$salt)",
529 " 3710 = md5($salt.md5($pass))",
530 " 2600 = md5(md5($pass)",
531 " 4300 = md5(strtoupper(md5($pass)))",
532 " 4400 = md5(sha1($pass))",
533 " 110 = sha1($pass.$salt)",
534 " 120 = sha1($salt.$pass)",
535 " 130 = sha1(unicode($pass).$salt)",
536 " 140 = sha1($salt.unicode($pass))",
537 " 4500 = sha1(sha1($pass)",
538 " 4700 = sha1(md5($pass))",
539 " 4900 = sha1($salt.$pass.$salt)",
540 " 1410 = sha256($pass.$salt)",
541 " 1420 = sha256($salt.$pass)",
542 " 1430 = sha256(unicode($pass).$salt)",
543 " 1440 = sha256($salt.unicode($pass))",
544 " 1710 = sha512($pass.$salt)",
545 " 1720 = sha512($salt.$pass)",
546 " 1730 = sha512(unicode($pass).$salt)",
547 " 1740 = sha512($salt.unicode($pass))",
548 "",
549 "[[ Roll-your-own: Authenticated Hashes ]]",
550 "",
551 " 50 = HMAC-MD5 (key = $pass)",
552 " 60 = HMAC-MD5 (key = $salt)",
553 " 150 = HMAC-SHA1 (key = $pass)",
554 " 160 = HMAC-SHA1 (key = $salt)",
555 " 1450 = HMAC-SHA256 (key = $pass)",
556 " 1460 = HMAC-SHA256 (key = $salt)",
557 " 1750 = HMAC-SHA512 (key = $pass)",
558 " 1760 = HMAC-SHA512 (key = $salt)",
559 "",
560 "[[ Generic KDF ]]",
561 "",
562 " 400 = phpass",
563 " 8900 = scrypt",
564 " 11900 = PBKDF2-HMAC-MD5",
565 " 12000 = PBKDF2-HMAC-SHA1",
566 " 10900 = PBKDF2-HMAC-SHA256",
567 " 12100 = PBKDF2-HMAC-SHA512",
568 "",
569 "[[ Network protocols, Challenge-Response ]]",
570 "",
571 " 23 = Skype",
572 " 2500 = WPA/WPA2",
573 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
574 " 5300 = IKE-PSK MD5",
575 " 5400 = IKE-PSK SHA1",
576 " 5500 = NetNTLMv1",
577 " 5500 = NetNTLMv1 + ESS",
578 " 5600 = NetNTLMv2",
579 " 7300 = IPMI2 RAKP HMAC-SHA1",
580 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
581 " 8300 = DNSSEC (NSEC3)",
582 " 10200 = Cram MD5",
583 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
584 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
585 " 11400 = SIP digest authentication (MD5)",
586 "",
587 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
588 "",
589 " 121 = SMF (Simple Machines Forum)",
590 " 400 = phpBB3",
591 " 2611 = vBulletin < v3.8.5",
592 " 2711 = vBulletin > v3.8.5",
593 " 2811 = MyBB",
594 " 2811 = IPB (Invison Power Board)",
595 " 8400 = WBB3 (Woltlab Burning Board)",
596 " 11 = Joomla < 2.5.18",
597 " 400 = Joomla > 2.5.18",
598 " 400 = Wordpress",
599 " 2612 = PHPS",
600 " 7900 = Drupal7",
601 " 21 = osCommerce",
602 " 21 = xt:Commerce",
603 " 11000 = PrestaShop",
604 " 124 = Django (SHA-1)",
605 " 10000 = Django (PBKDF2-SHA256)",
606 " 3711 = Mediawiki B type",
607 " 7600 = Redmine",
608 "",
609 "[[ Database Server ]]",
610 "",
611 " 12 = PostgreSQL",
612 " 131 = MSSQL(2000)",
613 " 132 = MSSQL(2005)",
614 " 1731 = MSSQL(2012)",
615 " 1731 = MSSQL(2014)",
616 " 200 = MySQL323",
617 " 300 = MySQL4.1/MySQL5",
618 " 3100 = Oracle H: Type (Oracle 7+)",
619 " 112 = Oracle S: Type (Oracle 11+)",
620 " 12300 = Oracle T: Type (Oracle 12+)",
621 " 8000 = Sybase ASE",
622 "",
623 "[[ HTTP, SMTP, LDAP Server ]]",
624 "",
625 " 141 = EPiServer 6.x < v4",
626 " 1441 = EPiServer 6.x > v4",
627 " 1600 = Apache $apr1$",
628 " 12600 = ColdFusion 10+",
629 " 1421 = hMailServer",
630 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
631 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
632 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
633 "",
634 "[[ Checksums ]]",
635 "",
636 " 11500 = CRC32",
637 "",
638 "[[ Operating-Systems ]]",
639 "",
640 " 3000 = LM",
641 " 1000 = NTLM",
642 " 1100 = Domain Cached Credentials (DCC), MS Cache",
643 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
644 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
645 " 1500 = descrypt, DES(Unix), Traditional DES",
646 " 12400 = BSDiCrypt, Extended DES",
647 " 500 = md5crypt $1$, MD5(Unix)",
648 " 3200 = bcrypt $2*$, Blowfish(Unix)",
649 " 7400 = sha256crypt $5$, SHA256(Unix)",
650 " 1800 = sha512crypt $6$, SHA512(Unix)",
651 " 122 = OSX v10.4",
652 " 122 = OSX v10.5",
653 " 122 = OSX v10.6",
654 " 1722 = OSX v10.7",
655 " 7100 = OSX v10.8",
656 " 7100 = OSX v10.9",
657 " 7100 = OSX v10.10",
658 " 6300 = AIX {smd5}",
659 " 6700 = AIX {ssha1}",
660 " 6400 = AIX {ssha256}",
661 " 6500 = AIX {ssha512}",
662 " 2400 = Cisco-PIX",
663 " 2410 = Cisco-ASA",
664 " 500 = Cisco-IOS $1$",
665 " 5700 = Cisco-IOS $4$",
666 " 9200 = Cisco-IOS $8$",
667 " 9300 = Cisco-IOS $9$",
668 " 22 = Juniper Netscreen/SSG (ScreenOS)",
669 " 501 = Juniper IVE",
670 " 5800 = Android PIN",
671 " 8100 = Citrix Netscaler",
672 " 8500 = RACF",
673 " 7200 = GRUB 2",
674 " 9900 = Radmin2",
675 "",
676 "[[ Enterprise Application Software (EAS) ]]",
677 "",
678 " 7700 = SAP CODVN B (BCODE)",
679 " 7800 = SAP CODVN F/G (PASSCODE)",
680 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
681 " 8600 = Lotus Notes/Domino 5",
682 " 8700 = Lotus Notes/Domino 6",
683 " 9100 = Lotus Notes/Domino 8",
684 " 133 = PeopleSoft",
685 "",
686 "[[ Archives ]]",
687 "",
688 " 11600 = 7-Zip",
689 " 12500 = RAR3-hp",
690 " 13000 = RAR5",
691 "",
692 "[[ Full-Disk encryptions (FDE) ]]",
693 "",
694 " 62XY = TrueCrypt 5.0+",
695 " X = 1 = PBKDF2-HMAC-RipeMD160",
696 " X = 2 = PBKDF2-HMAC-SHA512",
697 " X = 3 = PBKDF2-HMAC-Whirlpool",
698 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
699 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
700 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
701 " Y = 3 = XTS 1536 bit (Ciphers: All)",
702 " 8800 = Android FDE < v4.3",
703 " 12900 = Android FDE (Samsung DEK)",
704 " 12200 = eCryptfs",
705 "",
706 "[[ Documents ]]",
707 "",
708 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
709 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
710 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
711 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
712 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
713 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
714 " 9400 = MS Office 2007",
715 " 9500 = MS Office 2010",
716 " 9600 = MS Office 2013",
717 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
718 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
719 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
720 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
721 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
722 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
723 "",
724 "[[ Password Managers ]]",
725 "",
726 " 9000 = Password Safe v2",
727 " 5200 = Password Safe v3",
728 " 6800 = Lastpass",
729 " 6600 = 1Password, agilekeychain",
730 " 8200 = 1Password, cloudkeychain",
731 " 11300 = Bitcoin/Litecoin wallet.dat",
732 " 12700 = Blockchain, My Wallet",
733 "",
734 NULL
735 };
736
737 /**
738 * oclHashcat specific functions
739 */
740
741 void status_display_automat ()
742 {
743 FILE *out = stdout;
744
745 fprintf (out, "STATUS\t%u\t", data.devices_status);
746
747 /**
748 * speed new
749 */
750
751 fprintf (out, "SPEED\t");
752
753 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
754 {
755 hc_device_param_t *device_param = &data.devices_param[device_id];
756
757 if (device_param->skipped) continue;
758
759 u64 speed_cnt = 0;
760 float speed_ms = 0;
761
762 for (int i = 0; i < SPEED_CACHE; i++)
763 {
764 float rec_ms;
765
766 hc_timer_get (device_param->speed_rec[i], rec_ms);
767
768 if (rec_ms > SPEED_MAXAGE) continue;
769
770 speed_cnt += device_param->speed_cnt[i];
771 speed_ms += device_param->speed_ms[i];
772 }
773
774 speed_cnt /= SPEED_CACHE;
775 speed_ms /= SPEED_CACHE;
776
777 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
778 }
779
780 /**
781 * exec time
782 */
783
784 fprintf (out, "EXEC_RUNTIME\t");
785
786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
787 {
788 hc_device_param_t *device_param = &data.devices_param[device_id];
789
790 if (device_param->skipped) continue;
791
792 if (device_param->event == NULL) continue;
793
794 cl_ulong time_start;
795 cl_ulong time_end;
796
797 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
798 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
799
800 const double total_time = (time_end - time_start) / 1000000.0;
801
802 fprintf (out, "%f\t", total_time);
803 }
804
805 /**
806 * words_cur
807 */
808
809 u64 words_cur = get_lowest_words_done ();
810
811 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
812
813 /**
814 * counter
815 */
816
817 uint salts_left = data.salts_cnt - data.salts_done;
818
819 if (salts_left == 0) salts_left = 1;
820
821 u64 progress_total = data.words_cnt * salts_left;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 if (salts_left > 1)
830 {
831 // otherwise the final cracked status shows 0/XXX progress
832
833 if (data.salts_shown[salt_pos] == 1) continue;
834 }
835
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * salts_left;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * salts_left;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.status_automat == 1)
925 {
926 status_display_automat ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 uint pke[25] = { 0 };
1050
1051 char *pke_ptr = (char *) pke;
1052
1053 for (uint i = 0; i < 25; i++)
1054 {
1055 pke[i] = byte_swap_32 (wpa->pke[i]);
1056 }
1057
1058 char mac1[6] = { 0 };
1059 char mac2[6] = { 0 };
1060
1061 memcpy (mac1, pke_ptr + 23, 6);
1062 memcpy (mac2, pke_ptr + 29, 6);
1063
1064 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1065 (char *) data.salts_buf[0].salt_buf,
1066 mac1[0] & 0xff,
1067 mac1[1] & 0xff,
1068 mac1[2] & 0xff,
1069 mac1[3] & 0xff,
1070 mac1[4] & 0xff,
1071 mac1[5] & 0xff,
1072 mac2[0] & 0xff,
1073 mac2[1] & 0xff,
1074 mac2[2] & 0xff,
1075 mac2[3] & 0xff,
1076 mac2[4] & 0xff,
1077 mac2[5] & 0xff);
1078 }
1079 else if (data.hash_mode == 5200)
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if (data.hash_mode == 9000)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else
1092 {
1093 char out_buf[4096] = { 0 };
1094
1095 ascii_digest (out_buf, 0, 0);
1096
1097 // limit length
1098 if (strlen (out_buf) > 40)
1099 {
1100 out_buf[41] = '.';
1101 out_buf[42] = '.';
1102 out_buf[43] = '.';
1103 out_buf[44] = 0;
1104 }
1105
1106 log_info ("Hash.Target....: %s", out_buf);
1107 }
1108 }
1109 else
1110 {
1111 if (data.hash_mode == 3000)
1112 {
1113 char out_buf1[4096] = { 0 };
1114 char out_buf2[4096] = { 0 };
1115
1116 ascii_digest (out_buf1, 0, 0);
1117 ascii_digest (out_buf2, 0, 1);
1118
1119 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120 }
1121 else
1122 {
1123 log_info ("Hash.Target....: File (%s)", data.hashfile);
1124 }
1125 }
1126
1127 log_info ("Hash.Type......: %s", hash_type);
1128
1129 /**
1130 * speed new
1131 */
1132
1133 u64 speed_cnt[DEVICES_MAX] = { 0 };
1134 float speed_ms[DEVICES_MAX] = { 0 };
1135
1136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137 {
1138 hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140 if (device_param->skipped) continue;
1141
1142 // we need to clear values (set to 0) because in case the device does
1143 // not get new candidates it idles around but speed display would
1144 // show it as working.
1145 // if we instantly set it to 0 after reading it happens that the
1146 // speed can be shown as zero if the users refreshes too fast.
1147 // therefore, we add a timestamp when a stat was recorded and if its
1148 // too old we will not use it
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 float rec_ms;
1156
1157 hc_timer_get (device_param->speed_rec[i], rec_ms);
1158
1159 if (rec_ms > SPEED_MAXAGE) continue;
1160
1161 speed_cnt[device_id] += device_param->speed_cnt[i];
1162 speed_ms[device_id] += device_param->speed_ms[i];
1163 }
1164
1165 speed_cnt[device_id] /= SPEED_CACHE;
1166 speed_ms[device_id] /= SPEED_CACHE;
1167 }
1168
1169 float hashes_all_ms = 0;
1170
1171 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1172
1173 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1174 {
1175 hc_device_param_t *device_param = &data.devices_param[device_id];
1176
1177 if (device_param->skipped) continue;
1178
1179 hashes_dev_ms[device_id] = 0;
1180
1181 if (speed_ms[device_id])
1182 {
1183 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1184
1185 hashes_all_ms += hashes_dev_ms[device_id];
1186 }
1187 }
1188
1189 /**
1190 * exec time
1191 */
1192
1193 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1194
1195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1196 {
1197 hc_device_param_t *device_param = &data.devices_param[device_id];
1198
1199 if (device_param->skipped) continue;
1200
1201 if (device_param->event == NULL) continue;
1202
1203 cl_ulong time_start;
1204 cl_ulong time_end;
1205
1206 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1207 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1208
1209 const double total_time = (time_end - time_start) / 1000000.0;
1210
1211 exec_runtime_ms[device_id] = total_time;
1212 }
1213
1214 /**
1215 * timers
1216 */
1217
1218 float ms_running = 0;
1219
1220 hc_timer_get (data.timer_running, ms_running);
1221
1222 float ms_paused = data.ms_paused;
1223
1224 if (data.devices_status == STATUS_PAUSED)
1225 {
1226 float ms_paused_tmp = 0;
1227
1228 hc_timer_get (data.timer_paused, ms_paused_tmp);
1229
1230 ms_paused += ms_paused_tmp;
1231 }
1232
1233 #ifdef WIN
1234
1235 __time64_t sec_run = ms_running / 1000;
1236
1237 #else
1238
1239 time_t sec_run = ms_running / 1000;
1240
1241 #endif
1242
1243 if (sec_run)
1244 {
1245 char display_run[32] = { 0 };
1246
1247 struct tm tm_run;
1248
1249 struct tm *tmp = NULL;
1250
1251 #ifdef WIN
1252
1253 tmp = _gmtime64 (&sec_run);
1254
1255 #else
1256
1257 tmp = gmtime (&sec_run);
1258
1259 #endif
1260
1261 if (tmp != NULL)
1262 {
1263 memset (&tm_run, 0, sizeof (tm_run));
1264
1265 memcpy (&tm_run, tmp, sizeof (tm_run));
1266
1267 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1268
1269 char *start = ctime (&data.proc_start);
1270
1271 size_t start_len = strlen (start);
1272
1273 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1274 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1275
1276 log_info ("Time.Started...: %s (%s)", start, display_run);
1277 }
1278 }
1279 else
1280 {
1281 log_info ("Time.Started...: 0 secs");
1282 }
1283
1284 /**
1285 * counters
1286 */
1287
1288 uint salts_left = data.salts_cnt - data.salts_done;
1289
1290 if (salts_left == 0) salts_left = 1;
1291
1292 u64 progress_total = data.words_cnt * salts_left;
1293
1294 u64 all_done = 0;
1295 u64 all_rejected = 0;
1296 u64 all_restored = 0;
1297
1298 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1299 {
1300 if (salts_left > 1)
1301 {
1302 // otherwise the final cracked status shows 0/XXX progress
1303
1304 if (data.salts_shown[salt_pos] == 1) continue;
1305 }
1306
1307 all_done += data.words_progress_done[salt_pos];
1308 all_rejected += data.words_progress_rejected[salt_pos];
1309 all_restored += data.words_progress_restored[salt_pos];
1310 }
1311
1312 u64 progress_cur = all_restored + all_done + all_rejected;
1313 u64 progress_end = progress_total;
1314
1315 u64 progress_skip = 0;
1316
1317 if (data.skip)
1318 {
1319 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1320
1321 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1323 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1324 }
1325
1326 if (data.limit)
1327 {
1328 progress_end = MIN (data.limit, data.words_base) * salts_left;
1329
1330 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1332 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1333 }
1334
1335 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1336 u64 progress_end_relative_skip = progress_end - progress_skip;
1337
1338 float speed_ms_real = ms_running - ms_paused;
1339 u64 speed_plains_real = all_done;
1340
1341 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1342 {
1343 if (data.devices_status != STATUS_CRACKED)
1344 {
1345 u64 words_per_ms = 0;
1346
1347 if (speed_plains_real && speed_ms_real)
1348 {
1349 words_per_ms = speed_plains_real / speed_ms_real;
1350 }
1351
1352 #ifdef WIN
1353 __time64_t sec_etc = 0;
1354 #else
1355 time_t sec_etc = 0;
1356 #endif
1357
1358 if (words_per_ms)
1359 {
1360 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1361
1362 u64 ms_left = progress_left_relative_skip / words_per_ms;
1363
1364 sec_etc = ms_left / 1000;
1365 }
1366
1367 if (sec_etc == 0)
1368 {
1369 log_info ("Time.Estimated.: 0 secs");
1370 }
1371 else if ((u64) sec_etc > ETC_MAX)
1372 {
1373 log_info ("Time.Estimated.: > 10 Years");
1374 }
1375 else
1376 {
1377 char display_etc[32] = { 0 };
1378
1379 struct tm tm_etc;
1380
1381 struct tm *tmp = NULL;
1382
1383 #ifdef WIN
1384
1385 tmp = _gmtime64 (&sec_etc);
1386
1387 #else
1388
1389 tmp = gmtime (&sec_etc);
1390
1391 #endif
1392
1393 if (tmp != NULL)
1394 {
1395 memset (&tm_etc, 0, sizeof (tm_etc));
1396
1397 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1398
1399 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1400
1401 time_t now;
1402
1403 time (&now);
1404
1405 now += sec_etc;
1406
1407 char *etc = ctime (&now);
1408
1409 size_t etc_len = strlen (etc);
1410
1411 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1412 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1413
1414 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 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);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1480 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1481 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1482
1483 if ((data.cpt_start + 86400) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_cur_hour,
1488 cpt_cur_day,
1489 cpt_avg_min,
1490 cpt_avg_hour,
1491 cpt_avg_day);
1492 }
1493 else if ((data.cpt_start + 3600) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_avg_min,
1499 cpt_avg_hour,
1500 cpt_avg_day);
1501 }
1502 else if ((data.cpt_start + 60) < now)
1503 {
1504 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1505 cpt_cur_min,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else
1511 {
1512 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 }
1518
1519 // Restore point
1520
1521 u64 restore_point = get_lowest_words_done ();
1522
1523 u64 restore_total = data.words_base;
1524
1525 float percent_restore = 0;
1526
1527 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1528
1529 if (progress_end_relative_skip)
1530 {
1531 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532 {
1533 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1534 float percent_rejected = 0.0;
1535
1536 if (progress_cur)
1537 {
1538 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1539 }
1540
1541 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);
1542 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1543
1544 if (data.restore_disable == 0)
1545 {
1546 if (percent_finished != 1)
1547 {
1548 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1549 }
1550 }
1551 }
1552 }
1553 else
1554 {
1555 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1556 {
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 }
1564 }
1565 else
1566 {
1567 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1568 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1569
1570 // --restore not allowed if stdin is used -- really? why?
1571
1572 //if (data.restore_disable == 0)
1573 //{
1574 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1575 //}
1576 }
1577 }
1578
1579 #ifdef HAVE_HWMON
1580 if (data.gpu_temp_disable == 0)
1581 {
1582 hc_thread_mutex_lock (mux_adl);
1583
1584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1585 {
1586 hc_device_param_t *device_param = &data.devices_param[device_id];
1587
1588 if (device_param->skipped) continue;
1589
1590 #define HM_STR_BUF_SIZE 255
1591
1592 if (data.hm_device[device_id].fan_supported == 1)
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 if (device_param->vendor_id == VENDOR_ID_AMD)
1602 {
1603 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1604 }
1605 else if (device_param->vendor_id == VENDOR_ID_NV)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609
1610 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1611 }
1612 else
1613 {
1614 char utilization[HM_STR_BUF_SIZE] = { 0 };
1615 char temperature[HM_STR_BUF_SIZE] = { 0 };
1616
1617 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1618 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1621 }
1622 }
1623
1624 hc_thread_mutex_unlock (mux_adl);
1625 }
1626 #endif // HAVE_HWMON
1627 }
1628
1629 static void status_benchmark ()
1630 {
1631 if (data.devices_status == STATUS_INIT) return;
1632 if (data.devices_status == STATUS_STARTING) return;
1633
1634 if (data.words_cnt == 0) return;
1635
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 float speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = 0;
1646 speed_ms[device_id] = 0;
1647
1648 for (int i = 0; i < SPEED_CACHE; i++)
1649 {
1650 speed_cnt[device_id] += device_param->speed_cnt[i];
1651 speed_ms[device_id] += device_param->speed_ms[i];
1652 }
1653
1654 speed_cnt[device_id] /= SPEED_CACHE;
1655 speed_ms[device_id] /= SPEED_CACHE;
1656 }
1657
1658 float hashes_all_ms = 0;
1659
1660 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1661
1662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1663 {
1664 hc_device_param_t *device_param = &data.devices_param[device_id];
1665
1666 if (device_param->skipped) continue;
1667
1668 hashes_dev_ms[device_id] = 0;
1669
1670 if (speed_ms[device_id])
1671 {
1672 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1673
1674 hashes_all_ms += hashes_dev_ms[device_id];
1675 }
1676 }
1677
1678 /**
1679 * exec time
1680 */
1681
1682 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 if (device_param->event == NULL) continue;
1691
1692 cl_ulong time_start;
1693 cl_ulong time_end;
1694
1695 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1696 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1697
1698 const double total_time = (time_end - time_start) / 1000000.0;
1699
1700 exec_runtime_ms[device_id] = total_time;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static uint count_lines (FILE *fd)
1841 {
1842 uint cnt = 0;
1843
1844 char *buf = (char *) mymalloc (BUFSIZ + 1);
1845
1846 size_t nread_tmp = 0;
1847
1848 char *ptr = buf;
1849
1850 while (!feof (fd))
1851 {
1852 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1853 nread_tmp = nread;
1854
1855 if (nread < 1) continue;
1856
1857 ptr = buf;
1858
1859 do
1860 {
1861 if (*ptr++ == '\n') cnt++;
1862
1863 } while (nread--);
1864 }
1865
1866 // special case (if last line did not contain a newline char ... at the very end of the file)
1867
1868 if (nread_tmp > 3)
1869 {
1870 ptr -= 2;
1871
1872 if (*ptr != '\n')
1873 {
1874 ptr--;
1875
1876 if (*ptr != '\n') // needed ? different on windows systems?
1877 {
1878 cnt++;
1879 }
1880 }
1881 }
1882
1883 myfree (buf);
1884
1885 return cnt;
1886 }
1887
1888 static void clear_prompt ()
1889 {
1890 fputc ('\r', stdout);
1891
1892 for (size_t i = 0; i < strlen (PROMPT); i++)
1893 {
1894 fputc (' ', stdout);
1895 }
1896
1897 fputc ('\r', stdout);
1898
1899 fflush (stdout);
1900 }
1901
1902 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1903 {
1904 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);
1905 }
1906
1907 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1908 {
1909 char *outfile = data.outfile;
1910 uint quiet = data.quiet;
1911 FILE *pot_fp = data.pot_fp;
1912 uint loopback = data.loopback;
1913 uint debug_mode = data.debug_mode;
1914 char *debug_file = data.debug_file;
1915
1916 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1917 int debug_rule_len = 0; // -1 error
1918 uint debug_plain_len = 0;
1919
1920 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1921
1922 // hash
1923
1924 char out_buf[4096] = { 0 };
1925
1926 ascii_digest (out_buf, salt_pos, digest_pos);
1927
1928 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1929
1930 // plain
1931
1932 plain_t plain;
1933
1934 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);
1935
1936 uint gidvid = plain.gidvid;
1937 uint il_pos = plain.il_pos;
1938
1939 u64 crackpos = device_param->words_off;
1940
1941 uint plain_buf[16] = { 0 };
1942
1943 u8 *plain_ptr = (u8 *) plain_buf;
1944 unsigned int plain_len = 0;
1945
1946 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1947 {
1948 u64 gidd = gidvid;
1949 u64 gidm = 0;
1950
1951 pw_t pw;
1952
1953 gidd_to_pw_t (device_param, gidd, &pw);
1954
1955 for (int i = 0, j = gidm; i < 16; i++, j++)
1956 {
1957 plain_buf[i] = pw.h.hi1[0][j];
1958 }
1959
1960 plain_len = pw.pw_len;
1961
1962 const uint off = device_param->innerloop_pos + il_pos;
1963
1964 if (debug_mode > 0)
1965 {
1966 debug_rule_len = 0;
1967
1968 // save rule
1969 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1970 {
1971 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1972
1973 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1974 }
1975
1976 // save plain
1977 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1978 {
1979 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1980
1981 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1982
1983 debug_plain_len = plain_len;
1984 }
1985 }
1986
1987 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1988
1989 crackpos += gidvid;
1990 crackpos *= data.kernel_rules_cnt;
1991 crackpos += device_param->innerloop_pos + il_pos;
1992
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 else if (data.attack_mode == ATTACK_MODE_COMBI)
1996 {
1997 u64 gidd = gidvid;
1998 u64 gidm = 0;
1999
2000 pw_t pw;
2001
2002 gidd_to_pw_t (device_param, gidd, &pw);
2003
2004 for (int i = 0, j = gidm; i < 16; i++, j++)
2005 {
2006 plain_buf[i] = pw.h.hi1[0][j];
2007 }
2008
2009 plain_len = pw.pw_len;
2010
2011 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2012 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2013
2014 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2015 {
2016 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2017 }
2018 else
2019 {
2020 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2021
2022 memcpy (plain_ptr, comb_buf, comb_len);
2023 }
2024
2025 plain_len += comb_len;
2026
2027 crackpos += gidvid;
2028 crackpos *= data.combs_cnt;
2029 crackpos += device_param->innerloop_pos + il_pos;
2030
2031 if (data.pw_max != PW_DICTMAX1)
2032 {
2033 if (plain_len > data.pw_max) plain_len = data.pw_max;
2034 }
2035 }
2036 else if (data.attack_mode == ATTACK_MODE_BF)
2037 {
2038 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2039 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2040
2041 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2042 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2043
2044 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2045 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2046
2047 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2048 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2049
2050 plain_len = data.css_cnt;
2051
2052 crackpos += gidvid;
2053 crackpos *= data.bfs_cnt;
2054 crackpos += device_param->innerloop_pos + il_pos;
2055 }
2056 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2057 {
2058 u64 gidd = gidvid;
2059 u64 gidm = 0;
2060
2061 pw_t pw;
2062
2063 gidd_to_pw_t (device_param, gidd, &pw);
2064
2065 for (int i = 0, j = gidm; i < 16; i++, j++)
2066 {
2067 plain_buf[i] = pw.h.hi1[0][j];
2068 }
2069
2070 plain_len = pw.pw_len;
2071
2072 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2073
2074 uint start = 0;
2075 uint stop = device_param->kernel_params_mp_buf32[4];
2076
2077 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2091 {
2092 u64 gidd = gidvid;
2093 u64 gidm = 0;
2094
2095 pw_t pw;
2096
2097 gidd_to_pw_t (device_param, gidd, &pw);
2098
2099 for (int i = 0, j = gidm; i < 16; i++, j++)
2100 {
2101 plain_buf[i] = pw.h.hi1[0][j];
2102 }
2103
2104 plain_len = pw.pw_len;
2105
2106 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2107
2108 uint start = 0;
2109 uint stop = device_param->kernel_params_mp_buf32[4];
2110
2111 memmove (plain_ptr + stop, plain_ptr, plain_len);
2112
2113 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2114
2115 plain_len += start + stop;
2116
2117 crackpos += gidvid;
2118 crackpos *= data.combs_cnt;
2119 crackpos += device_param->innerloop_pos + il_pos;
2120
2121 if (data.pw_max != PW_DICTMAX1)
2122 {
2123 if (plain_len > data.pw_max) plain_len = data.pw_max;
2124 }
2125 }
2126
2127 if (data.attack_mode == ATTACK_MODE_BF)
2128 {
2129 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2130 {
2131 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2132 {
2133 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2134 {
2135 plain_len = plain_len - data.salts_buf[0].salt_len;
2136 }
2137 }
2138
2139 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2140 {
2141 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2142 {
2143 plain_ptr[j] = plain_ptr[i];
2144 }
2145
2146 plain_len = plain_len / 2;
2147 }
2148 }
2149 }
2150
2151 // if enabled, update also the potfile
2152
2153 if (pot_fp)
2154 {
2155 lock_file (pot_fp);
2156
2157 fprintf (pot_fp, "%s:", out_buf);
2158
2159 format_plain (pot_fp, plain_ptr, plain_len, 1);
2160
2161 fputc ('\n', pot_fp);
2162
2163 fflush (pot_fp);
2164
2165 unlock_file (pot_fp);
2166 }
2167
2168 // outfile
2169
2170 FILE *out_fp = NULL;
2171
2172 if (outfile != NULL)
2173 {
2174 if ((out_fp = fopen (outfile, "ab")) == NULL)
2175 {
2176 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2177
2178 out_fp = stdout;
2179 }
2180 lock_file (out_fp);
2181 }
2182 else
2183 {
2184 out_fp = stdout;
2185
2186 if (quiet == 0) clear_prompt ();
2187 }
2188
2189 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2190
2191 if (outfile != NULL)
2192 {
2193 if (out_fp != stdout)
2194 {
2195 fclose (out_fp);
2196 }
2197 }
2198 else
2199 {
2200 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2201 {
2202 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2203 {
2204 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2205 if (quiet == 0) fflush (stdout);
2206 }
2207 }
2208 }
2209
2210 // loopback
2211
2212 if (loopback)
2213 {
2214 char *loopback_file = data.loopback_file;
2215
2216 FILE *fb_fp = NULL;
2217
2218 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2219 {
2220 lock_file (fb_fp);
2221
2222 format_plain (fb_fp, plain_ptr, plain_len, 1);
2223
2224 fputc ('\n', fb_fp);
2225
2226 fclose (fb_fp);
2227 }
2228 }
2229
2230 // (rule) debug mode
2231
2232 // the next check implies that:
2233 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2234 // - debug_mode > 0
2235
2236 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2237 {
2238 if (debug_rule_len < 0) debug_rule_len = 0;
2239
2240 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2241
2242 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2243
2244 if ((quiet == 0) && (debug_file == NULL))
2245 {
2246 fprintf (stdout, "%s", PROMPT);
2247 fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2253 {
2254 salt_t *salt_buf = &data.salts_buf[salt_pos];
2255
2256 int found = 0;
2257
2258 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);
2259
2260 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2261
2262 if (found == 1)
2263 {
2264 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2265
2266 log_info_nn ("");
2267
2268 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);
2269
2270 uint cpt_cracked = 0;
2271
2272 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2273 {
2274 uint idx = salt_buf->digests_offset + digest_pos;
2275
2276 if (data.digests_shown_tmp[idx] == 0) continue;
2277
2278 if (data.digests_shown[idx] == 1) continue;
2279
2280 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2281 {
2282 data.digests_shown[idx] = 1;
2283
2284 data.digests_done++;
2285
2286 cpt_cracked++;
2287
2288 salt_buf->digests_done++;
2289
2290 if (salt_buf->digests_done == salt_buf->digests_cnt)
2291 {
2292 data.salts_shown[salt_pos] = 1;
2293
2294 data.salts_done++;
2295 }
2296 }
2297
2298 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2299
2300 check_hash (device_param, salt_pos, digest_pos);
2301 }
2302
2303 if (cpt_cracked > 0)
2304 {
2305 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2306 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2307
2308 data.cpt_pos++;
2309
2310 data.cpt_total += cpt_cracked;
2311
2312 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2313 }
2314
2315 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2316 {
2317 // we need to reset cracked state on the device
2318 // otherwise host thinks again and again the hash was cracked
2319 // and returns invalid password each time
2320
2321 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2322
2323 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);
2324 }
2325
2326 memset (device_param->result, 0, device_param->size_results);
2327
2328 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);
2329 }
2330 }
2331
2332 static void save_hash ()
2333 {
2334 char *hashfile = data.hashfile;
2335
2336 char new_hashfile[256] = { 0 };
2337 char old_hashfile[256] = { 0 };
2338
2339 snprintf (new_hashfile, 255, "%s.new", hashfile);
2340 snprintf (old_hashfile, 255, "%s.old", hashfile);
2341
2342 unlink (new_hashfile);
2343
2344 char separator = data.separator;
2345
2346 FILE *fp = fopen (new_hashfile, "wb");
2347
2348 if (fp == NULL)
2349 {
2350 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2351
2352 exit (-1);
2353 }
2354
2355 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2356 {
2357 if (data.salts_shown[salt_pos] == 1) continue;
2358
2359 salt_t *salt_buf = &data.salts_buf[salt_pos];
2360
2361 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2362 {
2363 uint idx = salt_buf->digests_offset + digest_pos;
2364
2365 if (data.digests_shown[idx] == 1) continue;
2366
2367 if (data.hash_mode != 2500)
2368 {
2369 char out_buf[4096] = { 0 };
2370
2371 if (data.username == 1)
2372 {
2373 user_t *user = data.hash_info[idx]->user;
2374
2375 uint i;
2376
2377 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2378
2379 fputc (separator, fp);
2380 }
2381
2382 ascii_digest (out_buf, salt_pos, digest_pos);
2383
2384 fputs (out_buf, fp);
2385
2386 log_out (fp, "");
2387 }
2388 else
2389 {
2390 hccap_t hccap;
2391
2392 to_hccap_t (&hccap, salt_pos, digest_pos);
2393
2394 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2395 }
2396 }
2397 }
2398
2399 fflush (fp);
2400
2401 fclose (fp);
2402
2403 unlink (old_hashfile);
2404
2405 if (rename (hashfile, old_hashfile) != 0)
2406 {
2407 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2408
2409 exit (-1);
2410 }
2411
2412 unlink (hashfile);
2413
2414 if (rename (new_hashfile, hashfile) != 0)
2415 {
2416 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2417
2418 exit (-1);
2419 }
2420
2421 unlink (old_hashfile);
2422 }
2423
2424 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2425 {
2426 // function called only in case kernel_blocks_all > words_left)
2427
2428 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2429
2430 kernel_blocks_div += kernel_blocks_div / 100;
2431
2432 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2433
2434 while (kernel_blocks_new < total_left)
2435 {
2436 kernel_blocks_div += kernel_blocks_div / 100;
2437
2438 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2439 }
2440
2441 if (data.quiet == 0)
2442 {
2443 clear_prompt ();
2444
2445 log_info ("");
2446
2447 log_info ("INFO: approaching final keyspace, workload adjusted");
2448
2449 log_info ("");
2450
2451 fprintf (stdout, "%s", PROMPT);
2452
2453 fflush (stdout);
2454 }
2455
2456 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2457
2458 return kernel_blocks_div;
2459 }
2460
2461 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2462 {
2463 uint num_elements = num;
2464
2465 device_param->kernel_params_buf32[30] = data.combs_mode;
2466 device_param->kernel_params_buf32[31] = num;
2467
2468 uint kernel_threads = device_param->kernel_threads;
2469
2470 while (num_elements % kernel_threads) num_elements++;
2471
2472 cl_kernel kernel = NULL;
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_1: kernel = device_param->kernel1; break;
2477 case KERN_RUN_12: kernel = device_param->kernel12; break;
2478 case KERN_RUN_2: kernel = device_param->kernel2; break;
2479 case KERN_RUN_23: kernel = device_param->kernel23; break;
2480 case KERN_RUN_3: kernel = device_param->kernel3; break;
2481 }
2482
2483 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2484 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2485 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2486 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2487 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2488 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2489 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2490 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2491 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2492 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2493 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2494
2495 cl_event event;
2496
2497 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2498 {
2499 const size_t global_work_size[3] = { num_elements, 32, 1 };
2500 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2501
2502 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2503 }
2504 else
2505 {
2506 const size_t global_work_size[3] = { num_elements, 1, 1 };
2507 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2508
2509 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);
2510
2511 if (rc != CL_SUCCESS)
2512 {
2513 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2514
2515 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2516 }
2517 }
2518
2519 hc_clFlush (data.ocl, device_param->command_queue);
2520
2521 //hc_clFinish (data.ocl, device_param->command_queue);
2522
2523 hc_clWaitForEvents (data.ocl, 1, &event);
2524
2525 if (event_update) device_param->event = event;
2526 }
2527
2528 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2529 {
2530 uint num_elements = num;
2531
2532 switch (kern_run)
2533 {
2534 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2535 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2536 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2537 }
2538
2539 // causes problems with special threads like in bcrypt
2540 // const uint kernel_threads = device_param->kernel_threads;
2541
2542 const uint kernel_threads = KERNEL_THREADS;
2543
2544 while (num_elements % kernel_threads) num_elements++;
2545
2546 cl_kernel kernel = NULL;
2547
2548 switch (kern_run)
2549 {
2550 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2551 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2552 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2553 }
2554
2555 switch (kern_run)
2556 {
2557 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2558 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2559 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2560 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2561 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2562 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2563 break;
2564 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2565 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2566 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2567 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2568 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2569 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2570 break;
2571 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2572 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2573 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2574 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2575 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2576 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2577 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2578 break;
2579 }
2580
2581 const size_t global_work_size[3] = { num_elements, 1, 1 };
2582 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2583
2584 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);
2585
2586 if (rc != CL_SUCCESS)
2587 {
2588 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2589
2590 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2591 }
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2599 {
2600 uint num_elements = num;
2601
2602 uint kernel_threads = device_param->kernel_threads;
2603
2604 while (num_elements % kernel_threads) num_elements++;
2605
2606 cl_kernel kernel = device_param->kernel_tb;
2607
2608 const size_t global_work_size[3] = { num_elements, 1, 1 };
2609 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2610
2611 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);
2612
2613 if (rc != CL_SUCCESS)
2614 {
2615 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2616
2617 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2618 }
2619
2620 hc_clFlush (data.ocl, device_param->command_queue);
2621
2622 hc_clFinish (data.ocl, device_param->command_queue);
2623 }
2624
2625 static void run_kernel_tm (hc_device_param_t *device_param)
2626 {
2627 const uint num_elements = 1024; // fixed
2628
2629 const uint kernel_threads = 32;
2630
2631 cl_kernel kernel = device_param->kernel_tm;
2632
2633 const size_t global_work_size[3] = { num_elements, 1, 1 };
2634 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2635
2636 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);
2637
2638 if (rc != CL_SUCCESS)
2639 {
2640 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2641
2642 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2643 }
2644
2645 hc_clFlush (data.ocl, device_param->command_queue);
2646
2647 hc_clFinish (data.ocl, device_param->command_queue);
2648 }
2649
2650 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2651 {
2652 uint num_elements = num;
2653
2654 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2655 device_param->kernel_params_amp_buf32[6] = num_elements;
2656
2657 // causes problems with special threads like in bcrypt
2658 // const uint kernel_threads = device_param->kernel_threads;
2659
2660 const uint kernel_threads = KERNEL_THREADS;
2661
2662 while (num_elements % kernel_threads) num_elements++;
2663
2664 cl_kernel kernel = device_param->kernel_amp;
2665
2666 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2667 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2668
2669 const size_t global_work_size[3] = { num_elements, 1, 1 };
2670 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2671
2672 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);
2673
2674 if (rc != CL_SUCCESS)
2675 {
2676 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2677
2678 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2679 }
2680
2681 hc_clFlush (data.ocl, device_param->command_queue);
2682
2683 hc_clFinish (data.ocl, device_param->command_queue);
2684 }
2685
2686 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2687 {
2688 int rc = -1;
2689
2690 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2691 {
2692 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2693
2694 const cl_uchar zero = 0;
2695
2696 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2697 }
2698
2699 if (rc != 0)
2700 {
2701 // NOTE: clEnqueueFillBuffer () always fails with -59
2702 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2703 // How's that possible, OpenCL 1.2 support is advertised??
2704 // We need to workaround...
2705
2706 #define FILLSZ 0x100000
2707
2708 char *tmp = (char *) mymalloc (FILLSZ);
2709
2710 for (uint i = 0; i < size; i += FILLSZ)
2711 {
2712 const int left = size - i;
2713
2714 const int fillsz = MIN (FILLSZ, left);
2715
2716 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2717 }
2718
2719 myfree (tmp);
2720 }
2721 }
2722
2723 static int run_rule_engine (const int rule_len, const char *rule_buf)
2724 {
2725 if (rule_len == 0)
2726 {
2727 return 0;
2728 }
2729 else if (rule_len == 1)
2730 {
2731 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2732 }
2733
2734 return 1;
2735 }
2736
2737 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2738 {
2739 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2740 {
2741 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);
2742 }
2743 else if (data.attack_kern == ATTACK_KERN_COMBI)
2744 {
2745 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);
2746 }
2747 else if (data.attack_kern == ATTACK_KERN_BF)
2748 {
2749 const u64 off = device_param->words_off;
2750
2751 device_param->kernel_params_mp_l_buf64[3] = off;
2752
2753 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2754 }
2755 }
2756
2757 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2758 {
2759 const uint kernel_loops = device_param->kernel_loops;
2760
2761 //only useful in debug
2762 //if (data.quiet == 0)
2763 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2764
2765 // init speed timer
2766
2767 uint speed_pos = device_param->speed_pos;
2768
2769 #ifdef _POSIX
2770 if (device_param->timer_speed.tv_sec == 0)
2771 {
2772 hc_timer_set (&device_param->timer_speed);
2773 }
2774 #endif
2775
2776 #ifdef _WIN
2777 if (device_param->timer_speed.QuadPart == 0)
2778 {
2779 hc_timer_set (&device_param->timer_speed);
2780 }
2781 #endif
2782
2783 // find higest password length, this is for optimization stuff
2784
2785 uint highest_pw_len = 0;
2786
2787 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2788 {
2789 }
2790 else if (data.attack_kern == ATTACK_KERN_COMBI)
2791 {
2792 }
2793 else if (data.attack_kern == ATTACK_KERN_BF)
2794 {
2795 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2796 + device_param->kernel_params_mp_l_buf32[5];
2797 }
2798
2799 // bitslice optimization stuff
2800
2801 if (data.attack_mode == ATTACK_MODE_BF)
2802 {
2803 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2804 {
2805 run_kernel_tb (device_param, pws_cnt);
2806 }
2807 }
2808
2809 // iteration type
2810
2811 uint innerloop_step = 0;
2812 uint innerloop_cnt = 0;
2813
2814 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2815 else innerloop_step = 1;
2816
2817 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2818 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2819 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2820
2821 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2822
2823 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2824 {
2825 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2826
2827 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2828
2829 if (data.devices_status == STATUS_CRACKED) break;
2830 if (data.devices_status == STATUS_ABORTED) break;
2831 if (data.devices_status == STATUS_QUIT) break;
2832 if (data.devices_status == STATUS_BYPASS) break;
2833
2834 if (data.salts_shown[salt_pos] == 1) continue;
2835
2836 salt_t *salt_buf = &data.salts_buf[salt_pos];
2837
2838 device_param->kernel_params_buf32[24] = salt_pos;
2839 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2840 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2841
2842 FILE *combs_fp = device_param->combs_fp;
2843
2844 if (data.attack_mode == ATTACK_MODE_COMBI)
2845 {
2846 rewind (combs_fp);
2847 }
2848
2849 // innerloops
2850
2851 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2852 {
2853 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2854
2855 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2856
2857 if (data.devices_status == STATUS_CRACKED) break;
2858 if (data.devices_status == STATUS_ABORTED) break;
2859 if (data.devices_status == STATUS_QUIT) break;
2860 if (data.devices_status == STATUS_BYPASS) break;
2861
2862 uint innerloop_left = innerloop_cnt - innerloop_pos;
2863
2864 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2865
2866 device_param->innerloop_pos = innerloop_pos;
2867 device_param->innerloop_left = innerloop_left;
2868
2869 device_param->kernel_params_buf32[27] = innerloop_left;
2870
2871 if (innerloop_left == 0) continue;
2872
2873 // initialize amplifiers
2874
2875 if (data.attack_mode == ATTACK_MODE_COMBI)
2876 {
2877 char line_buf[BUFSIZ] = { 0 };
2878
2879 uint i = 0;
2880
2881 while (i < innerloop_left)
2882 {
2883 if (feof (combs_fp)) break;
2884
2885 int line_len = fgetl (combs_fp, line_buf);
2886
2887 if (line_len >= PW_MAX1) continue;
2888
2889 line_len = convert_from_hex (line_buf, line_len);
2890
2891 char *line_buf_new = line_buf;
2892
2893 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2894 {
2895 char rule_buf_out[BLOCK_SIZE] = { 0 };
2896
2897 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2898
2899 if (rule_len_out < 0)
2900 {
2901 data.words_progress_rejected[salt_pos] += pw_cnt;
2902
2903 continue;
2904 }
2905
2906 line_len = rule_len_out;
2907
2908 line_buf_new = rule_buf_out;
2909 }
2910
2911 line_len = MIN (line_len, PW_DICTMAX);
2912
2913 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2914
2915 memcpy (ptr, line_buf_new, line_len);
2916
2917 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2918
2919 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2920 {
2921 uppercase (ptr, line_len);
2922 }
2923
2924 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2925 {
2926 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2927 {
2928 ptr[line_len] = 0x80;
2929 }
2930
2931 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2932 {
2933 ptr[line_len] = 0x01;
2934 }
2935 }
2936
2937 device_param->combs_buf[i].pw_len = line_len;
2938
2939 i++;
2940 }
2941
2942 for (uint j = i; j < innerloop_left; j++)
2943 {
2944 device_param->combs_buf[j].i[0] = 0;
2945 device_param->combs_buf[j].i[1] = 0;
2946 device_param->combs_buf[j].i[2] = 0;
2947 device_param->combs_buf[j].i[3] = 0;
2948 device_param->combs_buf[j].i[4] = 0;
2949 device_param->combs_buf[j].i[5] = 0;
2950 device_param->combs_buf[j].i[6] = 0;
2951 device_param->combs_buf[j].i[7] = 0;
2952
2953 device_param->combs_buf[j].pw_len = 0;
2954 }
2955
2956 innerloop_left = i;
2957 }
2958 else if (data.attack_mode == ATTACK_MODE_BF)
2959 {
2960 u64 off = innerloop_pos;
2961
2962 device_param->kernel_params_mp_r_buf64[3] = off;
2963
2964 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2965 }
2966 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2967 {
2968 u64 off = innerloop_pos;
2969
2970 device_param->kernel_params_mp_buf64[3] = off;
2971
2972 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2973 }
2974 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2975 {
2976 u64 off = innerloop_pos;
2977
2978 device_param->kernel_params_mp_buf64[3] = off;
2979
2980 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2981 }
2982
2983 // copy amplifiers
2984
2985 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2986 {
2987 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);
2988 }
2989 else if (data.attack_mode == ATTACK_MODE_COMBI)
2990 {
2991 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);
2992 }
2993 else if (data.attack_mode == ATTACK_MODE_BF)
2994 {
2995 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);
2996 }
2997 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2998 {
2999 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);
3000 }
3001 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3002 {
3003 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);
3004 }
3005
3006 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3007 {
3008 if (data.attack_mode == ATTACK_MODE_BF)
3009 {
3010 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
3011 {
3012 const uint size_tm = 32 * sizeof (bs_word_t);
3013
3014 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3015
3016 run_kernel_tm (device_param);
3017
3018 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);
3019 }
3020 }
3021
3022 if (highest_pw_len < 16)
3023 {
3024 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
3025 }
3026 else if (highest_pw_len < 32)
3027 {
3028 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3029 }
3030 else
3031 {
3032 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
3033 }
3034 }
3035 else
3036 {
3037 run_kernel_amp (device_param, pws_cnt);
3038
3039 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
3040
3041 if (data.opts_type & OPTS_TYPE_HOOK12)
3042 {
3043 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
3044 }
3045
3046 uint iter = salt_buf->salt_iter;
3047
3048 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
3049 {
3050 uint loop_left = iter - loop_pos;
3051
3052 loop_left = MIN (loop_left, kernel_loops);
3053
3054 device_param->kernel_params_buf32[25] = loop_pos;
3055 device_param->kernel_params_buf32[26] = loop_left;
3056
3057 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3058
3059 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3060
3061 if (data.devices_status == STATUS_CRACKED) break;
3062 if (data.devices_status == STATUS_ABORTED) break;
3063 if (data.devices_status == STATUS_QUIT) break;
3064 }
3065
3066 if (data.opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3069
3070 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);
3071
3072 // do something with data
3073
3074 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);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3078 }
3079
3080 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3081
3082 if (data.devices_status == STATUS_CRACKED) break;
3083 if (data.devices_status == STATUS_ABORTED) break;
3084 if (data.devices_status == STATUS_QUIT) break;
3085
3086 /**
3087 * result
3088 */
3089
3090 hc_thread_mutex_lock (mux_display);
3091
3092 check_cracked (device_param, salt_pos);
3093
3094 hc_thread_mutex_unlock (mux_display);
3095
3096 /**
3097 * progress
3098 */
3099
3100 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3101
3102 hc_thread_mutex_lock (mux_counter);
3103
3104 data.words_progress_done[salt_pos] += perf_sum_all;
3105
3106 hc_thread_mutex_unlock (mux_counter);
3107
3108 /**
3109 * speed
3110 */
3111
3112 float speed_ms;
3113
3114 hc_timer_get (device_param->timer_speed, speed_ms);
3115
3116 hc_timer_set (&device_param->timer_speed);
3117
3118 hc_thread_mutex_lock (mux_display);
3119
3120 device_param->speed_cnt[speed_pos] = perf_sum_all;
3121
3122 device_param->speed_ms[speed_pos] = speed_ms;
3123
3124 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3125
3126 hc_thread_mutex_unlock (mux_display);
3127
3128 speed_pos++;
3129
3130 if (speed_pos == SPEED_CACHE)
3131 {
3132 speed_pos = 0;
3133 }
3134 }
3135 }
3136
3137 device_param->speed_pos = speed_pos;
3138 }
3139
3140 static void load_segment (wl_data_t *wl_data, FILE *fd)
3141 {
3142 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3143
3144 wl_data->pos = 0;
3145
3146 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3147
3148 wl_data->buf[wl_data->cnt] = 0;
3149
3150 if (wl_data->cnt == 0) return;
3151
3152 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3153
3154 while (!feof (fd))
3155 {
3156 if (wl_data->cnt == wl_data->avail)
3157 {
3158 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3159
3160 wl_data->avail += wl_data->incr;
3161 }
3162
3163 const int c = fgetc (fd);
3164
3165 if (c == EOF) break;
3166
3167 wl_data->buf[wl_data->cnt] = (char) c;
3168
3169 wl_data->cnt++;
3170
3171 if (c == '\n') break;
3172 }
3173
3174 // ensure stream ends with a newline
3175
3176 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3177 {
3178 wl_data->cnt++;
3179
3180 wl_data->buf[wl_data->cnt - 1] = '\n';
3181 }
3182
3183 return;
3184 }
3185
3186 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3187 {
3188 char *ptr = buf;
3189
3190 for (u32 i = 0; i < sz; i++, ptr++)
3191 {
3192 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3193
3194 if (i == 7)
3195 {
3196 *off = i;
3197 *len = i;
3198
3199 return;
3200 }
3201
3202 if (*ptr != '\n') continue;
3203
3204 *off = i + 1;
3205
3206 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3207
3208 *len = i;
3209
3210 return;
3211 }
3212
3213 *off = sz;
3214 *len = sz;
3215 }
3216
3217 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3218 {
3219 char *ptr = buf;
3220
3221 for (u32 i = 0; i < sz; i++, ptr++)
3222 {
3223 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3224
3225 if (*ptr != '\n') continue;
3226
3227 *off = i + 1;
3228
3229 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3230
3231 *len = i;
3232
3233 return;
3234 }
3235
3236 *off = sz;
3237 *len = sz;
3238 }
3239
3240 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3241 {
3242 char *ptr = buf;
3243
3244 for (u32 i = 0; i < sz; i++, ptr++)
3245 {
3246 if (*ptr != '\n') continue;
3247
3248 *off = i + 1;
3249
3250 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3251
3252 *len = i;
3253
3254 return;
3255 }
3256
3257 *off = sz;
3258 *len = sz;
3259 }
3260
3261 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3262 {
3263 while (wl_data->pos < wl_data->cnt)
3264 {
3265 uint off;
3266 uint len;
3267
3268 char *ptr = wl_data->buf + wl_data->pos;
3269
3270 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3271
3272 wl_data->pos += off;
3273
3274 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3275 {
3276 char rule_buf_out[BLOCK_SIZE] = { 0 };
3277
3278 int rule_len_out = -1;
3279
3280 if (len < BLOCK_SIZE)
3281 {
3282 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3283 }
3284
3285 if (rule_len_out < 0)
3286 {
3287 continue;
3288 }
3289
3290 if (rule_len_out > PW_MAX)
3291 {
3292 continue;
3293 }
3294 }
3295 else
3296 {
3297 if (len > PW_MAX)
3298 {
3299 continue;
3300 }
3301 }
3302
3303 *out_buf = ptr;
3304 *out_len = len;
3305
3306 return;
3307 }
3308
3309 if (feof (fd))
3310 {
3311 fprintf (stderr, "bug!!\n");
3312
3313 return;
3314 }
3315
3316 load_segment (wl_data, fd);
3317
3318 get_next_word (wl_data, fd, out_buf, out_len);
3319 }
3320
3321 #ifdef _POSIX
3322 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3323 #endif
3324
3325 #ifdef _WIN
3326 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3327 #endif
3328 {
3329 hc_signal (NULL);
3330
3331 dictstat_t d;
3332
3333 d.cnt = 0;
3334
3335 #ifdef _POSIX
3336 fstat (fileno (fd), &d.stat);
3337 #endif
3338
3339 #ifdef _WIN
3340 _fstat64 (fileno (fd), &d.stat);
3341 #endif
3342
3343 d.stat.st_mode = 0;
3344 d.stat.st_nlink = 0;
3345 d.stat.st_uid = 0;
3346 d.stat.st_gid = 0;
3347 d.stat.st_rdev = 0;
3348 d.stat.st_atime = 0;
3349
3350 #ifdef _POSIX
3351 d.stat.st_blksize = 0;
3352 d.stat.st_blocks = 0;
3353 #endif
3354
3355 if (d.stat.st_size == 0) return 0;
3356
3357 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3358
3359 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3360 {
3361 if (d_cache)
3362 {
3363 u64 cnt = d_cache->cnt;
3364
3365 u64 keyspace = cnt;
3366
3367 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3368 {
3369 keyspace *= data.kernel_rules_cnt;
3370 }
3371 else if (data.attack_kern == ATTACK_KERN_COMBI)
3372 {
3373 keyspace *= data.combs_cnt;
3374 }
3375
3376 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);
3377 if (data.quiet == 0) log_info ("");
3378
3379 hc_signal (sigHandler_default);
3380
3381 return (keyspace);
3382 }
3383 }
3384
3385 time_t now = 0;
3386 time_t prev = 0;
3387
3388 u64 comp = 0;
3389 u64 cnt = 0;
3390 u64 cnt2 = 0;
3391
3392 while (!feof (fd))
3393 {
3394 load_segment (wl_data, fd);
3395
3396 comp += wl_data->cnt;
3397
3398 u32 i = 0;
3399
3400 while (i < wl_data->cnt)
3401 {
3402 u32 len;
3403 u32 off;
3404
3405 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3406
3407 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3408 {
3409 char rule_buf_out[BLOCK_SIZE] = { 0 };
3410
3411 int rule_len_out = -1;
3412
3413 if (len < BLOCK_SIZE)
3414 {
3415 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3416 }
3417
3418 if (rule_len_out < 0)
3419 {
3420 len = PW_MAX1;
3421 }
3422 else
3423 {
3424 len = rule_len_out;
3425 }
3426 }
3427
3428 if (len < PW_MAX1)
3429 {
3430 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3431 {
3432 cnt += data.kernel_rules_cnt;
3433 }
3434 else if (data.attack_kern == ATTACK_KERN_COMBI)
3435 {
3436 cnt += data.combs_cnt;
3437 }
3438
3439 d.cnt++;
3440 }
3441
3442 i += off;
3443
3444 cnt2++;
3445 }
3446
3447 time (&now);
3448
3449 if ((now - prev) == 0) continue;
3450
3451 float percent = (float) comp / (float) d.stat.st_size;
3452
3453 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);
3454
3455 time (&prev);
3456 }
3457
3458 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);
3459 if (data.quiet == 0) log_info ("");
3460
3461 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3462
3463 hc_signal (sigHandler_default);
3464
3465 return (cnt);
3466 }
3467
3468 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3469 {
3470 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3471 }
3472
3473 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3474 {
3475 if (data.devices_status == STATUS_BYPASS) return 0;
3476
3477 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3478
3479 uint cache_cnt = pw_cache->cnt;
3480
3481 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3482
3483 memcpy (pw_hc1, pw_buf, pw_len);
3484
3485 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3486
3487 uint pws_cnt = device_param->pws_cnt;
3488
3489 cache_cnt++;
3490
3491 pw_t *pw = device_param->pws_buf + pws_cnt;
3492
3493 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3494
3495 pw->pw_len = pw_len;
3496
3497 pws_cnt++;
3498
3499 device_param->pws_cnt = pws_cnt;
3500 device_param->pw_cnt = pws_cnt * 1;
3501
3502 cache_cnt = 0;
3503
3504 pw_cache->cnt = cache_cnt;
3505
3506 return pws_cnt;
3507 }
3508
3509 static void *thread_monitor (void *p)
3510 {
3511 uint runtime_check = 0;
3512 uint remove_check = 0;
3513 uint status_check = 0;
3514 uint restore_check = 0;
3515
3516 uint restore_left = data.restore_timer;
3517 uint remove_left = data.remove_timer;
3518 uint status_left = data.status_timer;
3519
3520 #ifdef HAVE_HWMON
3521 uint hwmon_check = 0;
3522
3523 // these variables are mainly used for fan control (AMD only)
3524
3525 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3526
3527 // temperature controller "loopback" values
3528
3529 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3530 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3531
3532 #ifdef HAVE_ADL
3533 int temp_threshold = 1; // degrees celcius
3534
3535 int fan_speed_min = 15; // in percentage
3536 int fan_speed_max = 100;
3537 #endif // HAVE_ADL
3538
3539 time_t last_temp_check_time;
3540 #endif // HAVE_HWMON
3541
3542 uint sleep_time = 1;
3543
3544 if (data.runtime)
3545 {
3546 runtime_check = 1;
3547 }
3548
3549 if (data.restore_timer)
3550 {
3551 restore_check = 1;
3552 }
3553
3554 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3555 {
3556 remove_check = 1;
3557 }
3558
3559 if (data.status == 1)
3560 {
3561 status_check = 1;
3562 }
3563
3564 #ifdef HAVE_HWMON
3565 if (data.gpu_temp_disable == 0)
3566 {
3567 time (&last_temp_check_time);
3568
3569 hwmon_check = 1;
3570 }
3571 #endif
3572
3573 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3574 {
3575 #ifdef HAVE_HWMON
3576 if (hwmon_check == 0)
3577 #endif
3578 return (p);
3579 }
3580
3581 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3582 {
3583 hc_sleep (sleep_time);
3584
3585 if (data.devices_status != STATUS_RUNNING) continue;
3586
3587 #ifdef HAVE_HWMON
3588 if (hwmon_check == 1)
3589 {
3590 hc_thread_mutex_lock (mux_adl);
3591
3592 time_t temp_check_time;
3593
3594 time (&temp_check_time);
3595
3596 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3597
3598 if (Ta == 0) Ta = 1;
3599
3600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3601 {
3602 hc_device_param_t *device_param = &data.devices_param[device_id];
3603
3604 if (device_param->skipped) continue;
3605
3606 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3607
3608 const int temperature = hm_get_temperature_with_device_id (device_id);
3609
3610 if (temperature > (int) data.gpu_temp_abort)
3611 {
3612 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3613
3614 if (data.devices_status != STATUS_QUIT) myabort ();
3615
3616 break;
3617 }
3618
3619 #ifdef HAVE_ADL
3620 const int gpu_temp_retain = data.gpu_temp_retain;
3621
3622 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3623 {
3624 if (data.hm_device[device_id].fan_supported == 1)
3625 {
3626 int temp_cur = temperature;
3627
3628 int temp_diff_new = gpu_temp_retain - temp_cur;
3629
3630 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3631
3632 // calculate Ta value (time difference in seconds between the last check and this check)
3633
3634 last_temp_check_time = temp_check_time;
3635
3636 float Kp = 1.8;
3637 float Ki = 0.005;
3638 float Kd = 6;
3639
3640 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3641
3642 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);
3643
3644 if (abs (fan_diff_required) >= temp_threshold)
3645 {
3646 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3647
3648 int fan_speed_level = fan_speed_cur;
3649
3650 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3651
3652 int fan_speed_new = fan_speed_level - fan_diff_required;
3653
3654 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3655 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3656
3657 if (fan_speed_new != fan_speed_cur)
3658 {
3659 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3660 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3661
3662 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3663 {
3664 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3665
3666 fan_speed_chgd[device_id] = 1;
3667 }
3668
3669 temp_diff_old[device_id] = temp_diff_new;
3670 }
3671 }
3672 }
3673 }
3674 #endif // HAVE_ADL
3675 }
3676
3677 hc_thread_mutex_unlock (mux_adl);
3678 }
3679 #endif // HAVE_HWMON
3680
3681 if (restore_check == 1)
3682 {
3683 restore_left--;
3684
3685 if (restore_left == 0)
3686 {
3687 if (data.restore_disable == 0) cycle_restore ();
3688
3689 restore_left = data.restore_timer;
3690 }
3691 }
3692
3693 if ((runtime_check == 1) && (data.runtime_start > 0))
3694 {
3695 time_t runtime_cur;
3696
3697 time (&runtime_cur);
3698
3699 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3700
3701 if (runtime_left <= 0)
3702 {
3703 if (data.benchmark == 0)
3704 {
3705 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3706 }
3707
3708 if (data.devices_status != STATUS_QUIT) myabort ();
3709 }
3710 }
3711
3712 if (remove_check == 1)
3713 {
3714 remove_left--;
3715
3716 if (remove_left == 0)
3717 {
3718 if (data.digests_saved != data.digests_done)
3719 {
3720 data.digests_saved = data.digests_done;
3721
3722 save_hash ();
3723 }
3724
3725 remove_left = data.remove_timer;
3726 }
3727 }
3728
3729 if (status_check == 1)
3730 {
3731 status_left--;
3732
3733 if (status_left == 0)
3734 {
3735 hc_thread_mutex_lock (mux_display);
3736
3737 if (data.quiet == 0) clear_prompt ();
3738
3739 if (data.quiet == 0) log_info ("");
3740
3741 status_display ();
3742
3743 if (data.quiet == 0) log_info ("");
3744
3745 hc_thread_mutex_unlock (mux_display);
3746
3747 status_left = data.status_timer;
3748 }
3749 }
3750 }
3751
3752 #ifdef HAVE_HWMON
3753 myfree (fan_speed_chgd);
3754
3755 myfree (temp_diff_old);
3756 myfree (temp_diff_sum);
3757 #endif
3758
3759 p = NULL;
3760
3761 return (p);
3762 }
3763
3764 static void *thread_outfile_remove (void *p)
3765 {
3766 // some hash-dependent constants
3767 char *outfile_dir = data.outfile_check_directory;
3768 uint dgst_size = data.dgst_size;
3769 uint isSalted = data.isSalted;
3770 uint esalt_size = data.esalt_size;
3771 uint hash_mode = data.hash_mode;
3772
3773 uint outfile_check_timer = data.outfile_check_timer;
3774
3775 char separator = data.separator;
3776
3777 // some hash-dependent functions
3778 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3779 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3780
3781 // buffers
3782 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3783
3784 hash_buf.digest = mymalloc (dgst_size);
3785
3786 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3787
3788 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3789
3790 uint digest_buf[64] = { 0 };
3791
3792 outfile_data_t *out_info = NULL;
3793
3794 char **out_files = NULL;
3795
3796 time_t folder_mtime = 0;
3797
3798 int out_cnt = 0;
3799
3800 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3801
3802 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3803 {
3804 hc_sleep (1);
3805
3806 if (data.devices_status != STATUS_RUNNING) continue;
3807
3808 check_left--;
3809
3810 if (check_left == 0)
3811 {
3812 struct stat outfile_check_stat;
3813
3814 if (stat (outfile_dir, &outfile_check_stat) == 0)
3815 {
3816 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3817
3818 if (is_dir == 1)
3819 {
3820 if (outfile_check_stat.st_mtime > folder_mtime)
3821 {
3822 char **out_files_new = scan_directory (outfile_dir);
3823
3824 int out_cnt_new = count_dictionaries (out_files_new);
3825
3826 outfile_data_t *out_info_new = NULL;
3827
3828 if (out_cnt_new > 0)
3829 {
3830 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3831
3832 for (int i = 0; i < out_cnt_new; i++)
3833 {
3834 out_info_new[i].file_name = out_files_new[i];
3835
3836 // check if there are files that we have seen/checked before (and not changed)
3837
3838 for (int j = 0; j < out_cnt; j++)
3839 {
3840 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3841 {
3842 struct stat outfile_stat;
3843
3844 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3845 {
3846 if (outfile_stat.st_ctime == out_info[j].ctime)
3847 {
3848 out_info_new[i].ctime = out_info[j].ctime;
3849 out_info_new[i].seek = out_info[j].seek;
3850 }
3851 }
3852 }
3853 }
3854 }
3855 }
3856
3857 local_free (out_info);
3858 local_free (out_files);
3859
3860 out_files = out_files_new;
3861 out_cnt = out_cnt_new;
3862 out_info = out_info_new;
3863
3864 folder_mtime = outfile_check_stat.st_mtime;
3865 }
3866
3867 for (int j = 0; j < out_cnt; j++)
3868 {
3869 FILE *fp = fopen (out_info[j].file_name, "rb");
3870
3871 if (fp != NULL)
3872 {
3873 //hc_thread_mutex_lock (mux_display);
3874
3875 #ifdef _POSIX
3876 struct stat outfile_stat;
3877
3878 fstat (fileno (fp), &outfile_stat);
3879 #endif
3880
3881 #ifdef _WIN
3882 struct stat64 outfile_stat;
3883
3884 _fstat64 (fileno (fp), &outfile_stat);
3885 #endif
3886
3887 if (outfile_stat.st_ctime > out_info[j].ctime)
3888 {
3889 out_info[j].ctime = outfile_stat.st_ctime;
3890 out_info[j].seek = 0;
3891 }
3892
3893 fseek (fp, out_info[j].seek, SEEK_SET);
3894
3895 while (!feof (fp))
3896 {
3897 char line_buf[BUFSIZ] = { 0 };
3898
3899 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3900
3901 if (ptr == NULL) break;
3902
3903 int line_len = strlen (line_buf);
3904
3905 if (line_len <= 0) continue;
3906
3907 int iter = MAX_CUT_TRIES;
3908
3909 for (uint i = line_len - 1; i && iter; i--, line_len--)
3910 {
3911 if (line_buf[i] != separator) continue;
3912
3913 int parser_status = PARSER_OK;
3914
3915 if ((hash_mode != 2500) && (hash_mode != 6800))
3916 {
3917 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3918 }
3919
3920 uint found = 0;
3921
3922 if (parser_status == PARSER_OK)
3923 {
3924 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3925 {
3926 if (data.salts_shown[salt_pos] == 1) continue;
3927
3928 salt_t *salt_buf = &data.salts_buf[salt_pos];
3929
3930 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3931 {
3932 uint idx = salt_buf->digests_offset + digest_pos;
3933
3934 if (data.digests_shown[idx] == 1) continue;
3935
3936 uint cracked = 0;
3937
3938 if (hash_mode == 6800)
3939 {
3940 if (i == salt_buf->salt_len)
3941 {
3942 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3943 }
3944 }
3945 else if (hash_mode == 2500)
3946 {
3947 // BSSID : MAC1 : MAC2 (:plain)
3948 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3949 {
3950 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3951
3952 if (!cracked) continue;
3953
3954 // now compare MAC1 and MAC2 too, since we have this additional info
3955 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3956 char *mac2_pos = mac1_pos + 12 + 1;
3957
3958 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3959 wpa_t *wpa = &wpas[salt_pos];
3960
3961 uint pke[25] = { 0 };
3962
3963 char *pke_ptr = (char *) pke;
3964
3965 for (uint i = 0; i < 25; i++)
3966 {
3967 pke[i] = byte_swap_32 (wpa->pke[i]);
3968 }
3969
3970 u8 mac1[6] = { 0 };
3971 u8 mac2[6] = { 0 };
3972
3973 memcpy (mac1, pke_ptr + 23, 6);
3974 memcpy (mac2, pke_ptr + 29, 6);
3975
3976 // compare hex string(s) vs binary MAC address(es)
3977
3978 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3979 {
3980 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3981 {
3982 cracked = 0;
3983 break;
3984 }
3985 }
3986
3987 // early skip ;)
3988 if (!cracked) continue;
3989
3990 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3991 {
3992 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3993 {
3994 cracked = 0;
3995 break;
3996 }
3997 }
3998 }
3999 }
4000 else
4001 {
4002 char *digests_buf_ptr = (char *) data.digests_buf;
4003
4004 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4005
4006 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4007 }
4008
4009 if (cracked == 1)
4010 {
4011 found = 1;
4012
4013 data.digests_shown[idx] = 1;
4014
4015 data.digests_done++;
4016
4017 salt_buf->digests_done++;
4018
4019 if (salt_buf->digests_done == salt_buf->digests_cnt)
4020 {
4021 data.salts_shown[salt_pos] = 1;
4022
4023 data.salts_done++;
4024
4025 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4026 }
4027 }
4028 }
4029
4030 if (data.devices_status == STATUS_CRACKED) break;
4031 }
4032 }
4033
4034 if (found) break;
4035
4036 if (data.devices_status == STATUS_CRACKED) break;
4037
4038 iter--;
4039 }
4040
4041 if (data.devices_status == STATUS_CRACKED) break;
4042 }
4043
4044 out_info[j].seek = ftell (fp);
4045
4046 //hc_thread_mutex_unlock (mux_display);
4047
4048 fclose (fp);
4049 }
4050 }
4051 }
4052 }
4053
4054 check_left = outfile_check_timer;
4055 }
4056 }
4057
4058 if (esalt_size) local_free (hash_buf.esalt);
4059
4060 if (isSalted) local_free (hash_buf.salt);
4061
4062 local_free (hash_buf.digest);
4063
4064 local_free (out_info);
4065
4066 local_free (out_files);
4067
4068 p = NULL;
4069
4070 return (p);
4071 }
4072
4073 static uint get_work (hc_device_param_t *device_param, const u64 max)
4074 {
4075 hc_thread_mutex_lock (mux_dispatcher);
4076
4077 const u64 words_cur = data.words_cur;
4078 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4079
4080 device_param->words_off = words_cur;
4081
4082 const u64 words_left = words_base - words_cur;
4083
4084 if (data.kernel_blocks_all > words_left)
4085 {
4086 if (data.kernel_blocks_div == 0)
4087 {
4088 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4089 }
4090 }
4091
4092 if (data.kernel_blocks_div)
4093 {
4094 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4095 {
4096 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4097 const u32 kernel_power_new = kernel_blocks_new;
4098
4099 if (kernel_blocks_new < device_param->kernel_blocks)
4100 {
4101 device_param->kernel_blocks = kernel_blocks_new;
4102 device_param->kernel_power = kernel_power_new;
4103 }
4104 }
4105 }
4106
4107 const uint kernel_blocks = device_param->kernel_blocks;
4108
4109 uint work = MIN (words_left, kernel_blocks);
4110
4111 work = MIN (work, max);
4112
4113 data.words_cur += work;
4114
4115 hc_thread_mutex_unlock (mux_dispatcher);
4116
4117 return work;
4118 }
4119
4120 static void *thread_calc_stdin (void *p)
4121 {
4122 hc_device_param_t *device_param = (hc_device_param_t *) p;
4123
4124 if (device_param->skipped) return NULL;
4125
4126 const uint attack_kern = data.attack_kern;
4127
4128 const uint kernel_blocks = device_param->kernel_blocks;
4129
4130 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4131 {
4132 hc_thread_mutex_lock (mux_dispatcher);
4133
4134 if (feof (stdin) != 0)
4135 {
4136 hc_thread_mutex_unlock (mux_dispatcher);
4137
4138 break;
4139 }
4140
4141 uint words_cur = 0;
4142
4143 while (words_cur < kernel_blocks)
4144 {
4145 char buf[BUFSIZ] = { 0 };
4146
4147 char *line_buf = fgets (buf, sizeof (buf), stdin);
4148
4149 if (line_buf == NULL) break;
4150
4151 uint line_len = in_superchop (line_buf);
4152
4153 line_len = convert_from_hex (line_buf, line_len);
4154
4155 // post-process rule engine
4156
4157 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4158 {
4159 char rule_buf_out[BLOCK_SIZE] = { 0 };
4160
4161 int rule_len_out = -1;
4162
4163 if (line_len < BLOCK_SIZE)
4164 {
4165 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4166 }
4167
4168 if (rule_len_out < 0) continue;
4169
4170 line_buf = rule_buf_out;
4171 line_len = rule_len_out;
4172 }
4173
4174 if (line_len > PW_MAX)
4175 {
4176 continue;
4177 }
4178
4179 if (attack_kern == ATTACK_KERN_STRAIGHT)
4180 {
4181 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4182 {
4183 hc_thread_mutex_lock (mux_counter);
4184
4185 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4186 {
4187 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4188 }
4189
4190 hc_thread_mutex_unlock (mux_counter);
4191
4192 continue;
4193 }
4194 }
4195 else if (attack_kern == ATTACK_KERN_COMBI)
4196 {
4197 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4198 // since we still need to combine the plains
4199
4200 if (line_len > data.pw_max)
4201 {
4202 hc_thread_mutex_lock (mux_counter);
4203
4204 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4205 {
4206 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4207 }
4208
4209 hc_thread_mutex_unlock (mux_counter);
4210
4211 continue;
4212 }
4213 }
4214
4215 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4216
4217 words_cur++;
4218
4219 if (data.devices_status == STATUS_CRACKED) break;
4220 if (data.devices_status == STATUS_ABORTED) break;
4221 if (data.devices_status == STATUS_QUIT) break;
4222 if (data.devices_status == STATUS_BYPASS) break;
4223 }
4224
4225 hc_thread_mutex_unlock (mux_dispatcher);
4226
4227 if (data.devices_status == STATUS_CRACKED) break;
4228 if (data.devices_status == STATUS_ABORTED) break;
4229 if (data.devices_status == STATUS_QUIT) break;
4230 if (data.devices_status == STATUS_BYPASS) break;
4231
4232 // we need 2 flushing because we have two independant caches and it can occur
4233 // that one buffer is already at threshold plus for that length also exists
4234 // more data in the 2nd buffer so it would overflow
4235
4236 // flush session 1
4237
4238 {
4239 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4240 {
4241 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4242
4243 const uint pw_cache_cnt = pw_cache->cnt;
4244
4245 if (pw_cache_cnt == 0) continue;
4246
4247 pw_cache->cnt = 0;
4248
4249 uint pws_cnt = device_param->pws_cnt;
4250
4251 pw_t *pw = device_param->pws_buf + pws_cnt;
4252
4253 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4254
4255 pw->pw_len = pw_len;
4256
4257 uint pw_cnt = device_param->pw_cnt;
4258
4259 pw_cnt += pw_cache_cnt;
4260
4261 device_param->pw_cnt = pw_cnt;
4262
4263 pws_cnt++;
4264
4265 device_param->pws_cnt = pws_cnt;
4266
4267 if (pws_cnt == device_param->kernel_power_user) break;
4268 }
4269
4270 const uint pw_cnt = device_param->pw_cnt;
4271 const uint pws_cnt = device_param->pws_cnt;
4272
4273 if (pws_cnt)
4274 {
4275 run_copy (device_param, pws_cnt);
4276
4277 run_cracker (device_param, pw_cnt, pws_cnt);
4278
4279 device_param->pw_cnt = 0;
4280 device_param->pws_cnt = 0;
4281 }
4282 }
4283
4284 // flush session 2
4285
4286 {
4287 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4288 {
4289 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4290
4291 const uint pw_cache_cnt = pw_cache->cnt;
4292
4293 if (pw_cache_cnt == 0) continue;
4294
4295 pw_cache->cnt = 0;
4296
4297 uint pws_cnt = device_param->pws_cnt;
4298
4299 pw_t *pw = device_param->pws_buf + pws_cnt;
4300
4301 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4302
4303 pw->pw_len = pw_len;
4304
4305 uint pw_cnt = device_param->pw_cnt;
4306
4307 pw_cnt += pw_cache_cnt;
4308
4309 device_param->pw_cnt = pw_cnt;
4310
4311 pws_cnt++;
4312
4313 device_param->pws_cnt = pws_cnt;
4314 }
4315
4316 const uint pw_cnt = device_param->pw_cnt;
4317 const uint pws_cnt = device_param->pws_cnt;
4318
4319 if (pws_cnt)
4320 {
4321 run_copy (device_param, pws_cnt);
4322
4323 run_cracker (device_param, pw_cnt, pws_cnt);
4324
4325 device_param->pw_cnt = 0;
4326 device_param->pws_cnt = 0;
4327 }
4328 }
4329 }
4330
4331 return NULL;
4332 }
4333
4334 static void *thread_calc (void *p)
4335 {
4336 hc_device_param_t *device_param = (hc_device_param_t *) p;
4337
4338 if (device_param->skipped) return NULL;
4339
4340 const uint attack_mode = data.attack_mode;
4341 const uint attack_kern = data.attack_kern;
4342
4343 if (attack_mode == ATTACK_MODE_BF)
4344 {
4345 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4346 {
4347 const uint work = get_work (device_param, -1);
4348
4349 if (work == 0) break;
4350
4351 const u64 words_off = device_param->words_off;
4352 const u64 words_fin = words_off + work;
4353
4354 const uint pw_cnt = work;
4355 const uint pws_cnt = work;
4356
4357 device_param->pw_cnt = pw_cnt;
4358 device_param->pws_cnt = pws_cnt;
4359
4360 if (pws_cnt)
4361 {
4362 run_copy (device_param, pws_cnt);
4363
4364 run_cracker (device_param, pw_cnt, pws_cnt);
4365
4366 device_param->pw_cnt = 0;
4367 device_param->pws_cnt = 0;
4368 }
4369
4370 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4371
4372 if (data.devices_status == STATUS_CRACKED) break;
4373 if (data.devices_status == STATUS_ABORTED) break;
4374 if (data.devices_status == STATUS_QUIT) break;
4375 if (data.devices_status == STATUS_BYPASS) break;
4376
4377 device_param->words_done = words_fin;
4378 }
4379 }
4380 else
4381 {
4382 const uint segment_size = data.segment_size;
4383
4384 char *dictfile = data.dictfile;
4385
4386 if (attack_mode == ATTACK_MODE_COMBI)
4387 {
4388 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4389 {
4390 dictfile = data.dictfile2;
4391 }
4392 }
4393
4394 FILE *fd = fopen (dictfile, "rb");
4395
4396 if (fd == NULL)
4397 {
4398 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4399
4400 return NULL;
4401 }
4402
4403 if (attack_mode == ATTACK_MODE_COMBI)
4404 {
4405 const uint combs_mode = data.combs_mode;
4406
4407 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4408 {
4409 const char *dictfilec = data.dictfile2;
4410
4411 FILE *combs_fp = fopen (dictfilec, "rb");
4412
4413 if (combs_fp == NULL)
4414 {
4415 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4416
4417 fclose (fd);
4418
4419 return NULL;
4420 }
4421
4422 device_param->combs_fp = combs_fp;
4423 }
4424 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4425 {
4426 const char *dictfilec = data.dictfile;
4427
4428 FILE *combs_fp = fopen (dictfilec, "rb");
4429
4430 if (combs_fp == NULL)
4431 {
4432 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4433
4434 fclose (fd);
4435
4436 return NULL;
4437 }
4438
4439 device_param->combs_fp = combs_fp;
4440 }
4441 }
4442
4443 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4444
4445 wl_data->buf = (char *) mymalloc (segment_size);
4446 wl_data->avail = segment_size;
4447 wl_data->incr = segment_size;
4448 wl_data->cnt = 0;
4449 wl_data->pos = 0;
4450
4451 u64 words_cur = 0;
4452
4453 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4454 {
4455 u64 words_off = 0;
4456 u64 words_fin = 0;
4457
4458 u64 max = -1;
4459
4460 while (max)
4461 {
4462 const uint work = get_work (device_param, max);
4463
4464 if (work == 0) break;
4465
4466 words_off = device_param->words_off;
4467 words_fin = words_off + work;
4468
4469 char *line_buf;
4470 uint line_len;
4471
4472 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4473
4474 max = 0;
4475
4476 for ( ; words_cur < words_fin; words_cur++)
4477 {
4478 get_next_word (wl_data, fd, &line_buf, &line_len);
4479
4480 line_len = convert_from_hex (line_buf, line_len);
4481
4482 // post-process rule engine
4483
4484 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4485 {
4486 char rule_buf_out[BLOCK_SIZE] = { 0 };
4487
4488 int rule_len_out = -1;
4489
4490 if (line_len < BLOCK_SIZE)
4491 {
4492 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4493 }
4494
4495 if (rule_len_out < 0) continue;
4496
4497 line_buf = rule_buf_out;
4498 line_len = rule_len_out;
4499 }
4500
4501 if (attack_kern == ATTACK_KERN_STRAIGHT)
4502 {
4503 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4504 {
4505 max++;
4506
4507 hc_thread_mutex_lock (mux_counter);
4508
4509 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4510 {
4511 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4512 }
4513
4514 hc_thread_mutex_unlock (mux_counter);
4515
4516 continue;
4517 }
4518 }
4519 else if (attack_kern == ATTACK_KERN_COMBI)
4520 {
4521 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4522 // since we still need to combine the plains
4523
4524 if (line_len > data.pw_max)
4525 {
4526 max++;
4527
4528 hc_thread_mutex_lock (mux_counter);
4529
4530 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4531 {
4532 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4533 }
4534
4535 hc_thread_mutex_unlock (mux_counter);
4536
4537 continue;
4538 }
4539 }
4540
4541 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4542
4543 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4544
4545 if (data.devices_status == STATUS_CRACKED) break;
4546 if (data.devices_status == STATUS_ABORTED) break;
4547 if (data.devices_status == STATUS_QUIT) break;
4548 if (data.devices_status == STATUS_BYPASS) break;
4549 }
4550
4551 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4552
4553 if (data.devices_status == STATUS_CRACKED) break;
4554 if (data.devices_status == STATUS_ABORTED) break;
4555 if (data.devices_status == STATUS_QUIT) break;
4556 if (data.devices_status == STATUS_BYPASS) break;
4557 }
4558
4559 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4560
4561 if (data.devices_status == STATUS_CRACKED) break;
4562 if (data.devices_status == STATUS_ABORTED) break;
4563 if (data.devices_status == STATUS_QUIT) break;
4564 if (data.devices_status == STATUS_BYPASS) break;
4565
4566 // we need 2 flushing because we have two independant caches and it can occur
4567 // that one buffer is already at threshold plus for that length also exists
4568 // more data in the 2nd buffer so it would overflow
4569
4570 //
4571 // flush session 1
4572 //
4573
4574 {
4575 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4576 {
4577 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4578
4579 const uint pw_cache_cnt = pw_cache->cnt;
4580
4581 if (pw_cache_cnt == 0) continue;
4582
4583 pw_cache->cnt = 0;
4584
4585 uint pws_cnt = device_param->pws_cnt;
4586
4587 pw_t *pw = device_param->pws_buf + pws_cnt;
4588
4589 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4590
4591 pw->pw_len = pw_len;
4592
4593 uint pw_cnt = device_param->pw_cnt;
4594
4595 pw_cnt += pw_cache_cnt;
4596
4597 device_param->pw_cnt = pw_cnt;
4598
4599 pws_cnt++;
4600
4601 device_param->pws_cnt = pws_cnt;
4602
4603 if (pws_cnt == device_param->kernel_power_user) break;
4604 }
4605
4606 const uint pw_cnt = device_param->pw_cnt;
4607 const uint pws_cnt = device_param->pws_cnt;
4608
4609 if (pws_cnt)
4610 {
4611 run_copy (device_param, pws_cnt);
4612
4613 run_cracker (device_param, pw_cnt, pws_cnt);
4614
4615 device_param->pw_cnt = 0;
4616 device_param->pws_cnt = 0;
4617 }
4618
4619 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4620
4621 if (data.devices_status == STATUS_CRACKED) break;
4622 if (data.devices_status == STATUS_ABORTED) break;
4623 if (data.devices_status == STATUS_QUIT) break;
4624 if (data.devices_status == STATUS_BYPASS) break;
4625 }
4626
4627 //
4628 // flush session 2
4629 //
4630
4631 {
4632 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4633 {
4634 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4635
4636 const uint pw_cache_cnt = pw_cache->cnt;
4637
4638 if (pw_cache_cnt == 0) continue;
4639
4640 pw_cache->cnt = 0;
4641
4642 uint pws_cnt = device_param->pws_cnt;
4643
4644 pw_t *pw = device_param->pws_buf + pws_cnt;
4645
4646 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4647
4648 pw->pw_len = pw_len;
4649
4650 uint pw_cnt = device_param->pw_cnt;
4651
4652 pw_cnt += pw_cache_cnt;
4653
4654 device_param->pw_cnt = pw_cnt;
4655
4656 pws_cnt++;
4657
4658 device_param->pws_cnt = pws_cnt;
4659 }
4660
4661 const uint pw_cnt = device_param->pw_cnt;
4662 const uint pws_cnt = device_param->pws_cnt;
4663
4664 if (pws_cnt)
4665 {
4666 run_copy (device_param, pws_cnt);
4667
4668 run_cracker (device_param, pw_cnt, pws_cnt);
4669
4670 device_param->pw_cnt = 0;
4671 device_param->pws_cnt = 0;
4672 }
4673
4674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677 if (data.devices_status == STATUS_ABORTED) break;
4678 if (data.devices_status == STATUS_QUIT) break;
4679 if (data.devices_status == STATUS_BYPASS) break;
4680 }
4681
4682 if (words_fin == 0) break;
4683
4684 device_param->words_done = words_fin;
4685 }
4686
4687 if (attack_mode == ATTACK_MODE_COMBI)
4688 {
4689 fclose (device_param->combs_fp);
4690 }
4691
4692 free (wl_data->buf);
4693 free (wl_data);
4694
4695 fclose (fd);
4696 }
4697
4698 return NULL;
4699 }
4700
4701 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4702 {
4703 if (!device_param)
4704 {
4705 log_error ("ERROR: %s : Invalid argument", __func__);
4706
4707 exit (-1);
4708 }
4709
4710 salt_t *salt_buf = &data.salts_buf[salt_pos];
4711
4712 device_param->kernel_params_buf32[24] = salt_pos;
4713 device_param->kernel_params_buf32[27] = 1;
4714 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4715 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4716 device_param->kernel_params_buf32[30] = 0;
4717 device_param->kernel_params_buf32[31] = 1;
4718
4719 char *dictfile_old = data.dictfile;
4720
4721 const char *weak_hash_check = "weak-hash-check";
4722
4723 data.dictfile = (char *) weak_hash_check;
4724
4725 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4726
4727 data.kernel_rules_buf[0].cmds[0] = 0;
4728
4729 /**
4730 * run the kernel
4731 */
4732
4733 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4734 {
4735 run_kernel (KERN_RUN_1, device_param, 1, false);
4736 }
4737 else
4738 {
4739 run_kernel (KERN_RUN_1, device_param, 1, false);
4740
4741 const uint iter = salt_buf->salt_iter;
4742
4743 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4744 {
4745 uint loop_left = iter - loop_pos;
4746
4747 loop_left = MIN (loop_left, kernel_loops);
4748
4749 device_param->kernel_params_buf32[25] = loop_pos;
4750 device_param->kernel_params_buf32[26] = loop_left;
4751
4752 run_kernel (KERN_RUN_2, device_param, 1, false);
4753 }
4754
4755 run_kernel (KERN_RUN_3, device_param, 1, false);
4756 }
4757
4758 /**
4759 * result
4760 */
4761
4762 check_cracked (device_param, salt_pos);
4763
4764 /**
4765 * cleanup
4766 */
4767
4768 device_param->kernel_params_buf32[24] = 0;
4769 device_param->kernel_params_buf32[25] = 0;
4770 device_param->kernel_params_buf32[26] = 0;
4771 device_param->kernel_params_buf32[27] = 0;
4772 device_param->kernel_params_buf32[28] = 0;
4773 device_param->kernel_params_buf32[29] = 0;
4774 device_param->kernel_params_buf32[30] = 0;
4775 device_param->kernel_params_buf32[31] = 0;
4776
4777 data.dictfile = dictfile_old;
4778
4779 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4780 }
4781
4782 // hlfmt hashcat
4783
4784 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4785 {
4786 if (data.username == 0)
4787 {
4788 *hashbuf_pos = line_buf;
4789 *hashbuf_len = line_len;
4790 }
4791 else
4792 {
4793 char *pos = line_buf;
4794 int len = line_len;
4795
4796 for (int i = 0; i < line_len; i++, pos++, len--)
4797 {
4798 if (line_buf[i] == data.separator)
4799 {
4800 pos++;
4801
4802 len--;
4803
4804 break;
4805 }
4806 }
4807
4808 *hashbuf_pos = pos;
4809 *hashbuf_len = len;
4810 }
4811 }
4812
4813 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4814 {
4815 char *pos = NULL;
4816 int len = 0;
4817
4818 int sep_cnt = 0;
4819
4820 for (int i = 0; i < line_len; i++)
4821 {
4822 if (line_buf[i] == data.separator)
4823 {
4824 sep_cnt++;
4825
4826 continue;
4827 }
4828
4829 if (sep_cnt == 0)
4830 {
4831 if (pos == NULL) pos = line_buf + i;
4832
4833 len++;
4834 }
4835 }
4836
4837 *userbuf_pos = pos;
4838 *userbuf_len = len;
4839 }
4840
4841 // hlfmt pwdump
4842
4843 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4844 {
4845 int sep_cnt = 0;
4846
4847 int sep2_len = 0;
4848 int sep3_len = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':')
4853 {
4854 sep_cnt++;
4855
4856 continue;
4857 }
4858
4859 if (sep_cnt == 2) sep2_len++;
4860 if (sep_cnt == 3) sep3_len++;
4861 }
4862
4863 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4864
4865 return 0;
4866 }
4867
4868 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4869 {
4870 char *pos = NULL;
4871 int len = 0;
4872
4873 int sep_cnt = 0;
4874
4875 for (int i = 0; i < line_len; i++)
4876 {
4877 if (line_buf[i] == ':')
4878 {
4879 sep_cnt++;
4880
4881 continue;
4882 }
4883
4884 if (data.hash_mode == 1000)
4885 {
4886 if (sep_cnt == 3)
4887 {
4888 if (pos == NULL) pos = line_buf + i;
4889
4890 len++;
4891 }
4892 }
4893 else if (data.hash_mode == 3000)
4894 {
4895 if (sep_cnt == 2)
4896 {
4897 if (pos == NULL) pos = line_buf + i;
4898
4899 len++;
4900 }
4901 }
4902 }
4903
4904 *hashbuf_pos = pos;
4905 *hashbuf_len = len;
4906 }
4907
4908 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4909 {
4910 char *pos = NULL;
4911 int len = 0;
4912
4913 int sep_cnt = 0;
4914
4915 for (int i = 0; i < line_len; i++)
4916 {
4917 if (line_buf[i] == ':')
4918 {
4919 sep_cnt++;
4920
4921 continue;
4922 }
4923
4924 if (sep_cnt == 0)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931
4932 *userbuf_pos = pos;
4933 *userbuf_len = len;
4934 }
4935
4936 // hlfmt passwd
4937
4938 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4939 {
4940 int sep_cnt = 0;
4941
4942 char sep5_first = 0;
4943 char sep6_first = 0;
4944
4945 for (int i = 0; i < line_len; i++)
4946 {
4947 if (line_buf[i] == ':')
4948 {
4949 sep_cnt++;
4950
4951 continue;
4952 }
4953
4954 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4955 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4956 }
4957
4958 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4959
4960 return 0;
4961 }
4962
4963 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4964 {
4965 char *pos = NULL;
4966 int len = 0;
4967
4968 int sep_cnt = 0;
4969
4970 for (int i = 0; i < line_len; i++)
4971 {
4972 if (line_buf[i] == ':')
4973 {
4974 sep_cnt++;
4975
4976 continue;
4977 }
4978
4979 if (sep_cnt == 1)
4980 {
4981 if (pos == NULL) pos = line_buf + i;
4982
4983 len++;
4984 }
4985 }
4986
4987 *hashbuf_pos = pos;
4988 *hashbuf_len = len;
4989 }
4990
4991 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4992 {
4993 char *pos = NULL;
4994 int len = 0;
4995
4996 int sep_cnt = 0;
4997
4998 for (int i = 0; i < line_len; i++)
4999 {
5000 if (line_buf[i] == ':')
5001 {
5002 sep_cnt++;
5003
5004 continue;
5005 }
5006
5007 if (sep_cnt == 0)
5008 {
5009 if (pos == NULL) pos = line_buf + i;
5010
5011 len++;
5012 }
5013 }
5014
5015 *userbuf_pos = pos;
5016 *userbuf_len = len;
5017 }
5018
5019 // hlfmt shadow
5020
5021 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
5022 {
5023 int sep_cnt = 0;
5024
5025 for (int i = 0; i < line_len; i++)
5026 {
5027 if (line_buf[i] == ':') sep_cnt++;
5028 }
5029
5030 if (sep_cnt == 8) return 1;
5031
5032 return 0;
5033 }
5034
5035 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5036 {
5037 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5038 }
5039
5040 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5041 {
5042 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5043 }
5044
5045 // hlfmt main
5046
5047 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5048 {
5049 switch (hashfile_format)
5050 {
5051 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5052 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5053 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5054 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5055 }
5056 }
5057
5058 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5059 {
5060 switch (hashfile_format)
5061 {
5062 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5063 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5064 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5065 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5066 }
5067 }
5068
5069 static uint hlfmt_detect (FILE *fp, uint max_check)
5070 {
5071 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5072
5073 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5074 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5075
5076 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5077
5078 uint num_check = 0;
5079
5080 while (!feof (fp))
5081 {
5082 char line_buf[BUFSIZ] = { 0 };
5083
5084 int line_len = fgetl (fp, line_buf);
5085
5086 if (line_len == 0) continue;
5087
5088 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5089 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5090 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5091
5092 if (num_check == max_check) break;
5093
5094 num_check++;
5095 }
5096
5097 uint hashlist_format = HLFMT_HASHCAT;
5098
5099 for (int i = 1; i < HLFMTS_CNT; i++)
5100 {
5101 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5102
5103 hashlist_format = i;
5104 }
5105
5106 free (formats_cnt);
5107
5108 return hashlist_format;
5109 }
5110
5111 /**
5112 * some further helper function
5113 */
5114
5115 // wrapper around mymalloc for ADL
5116
5117 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5118 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5119 {
5120 return mymalloc (iSize);
5121 }
5122 #endif
5123
5124 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)
5125 {
5126 u64 collisions = 0;
5127
5128 const uint dgst_pos0 = data.dgst_pos0;
5129 const uint dgst_pos1 = data.dgst_pos1;
5130 const uint dgst_pos2 = data.dgst_pos2;
5131 const uint dgst_pos3 = data.dgst_pos3;
5132
5133 memset (bitmap_a, 0, bitmap_size);
5134 memset (bitmap_b, 0, bitmap_size);
5135 memset (bitmap_c, 0, bitmap_size);
5136 memset (bitmap_d, 0, bitmap_size);
5137
5138 for (uint i = 0; i < digests_cnt; i++)
5139 {
5140 uint *digest_ptr = (uint *) digests_buf_ptr;
5141
5142 digests_buf_ptr += dgst_size;
5143
5144 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5145 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5146 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5147 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5148
5149 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5150 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5151 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5152 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5153
5154 if (bitmap_a[idx0] & val0) collisions++;
5155 if (bitmap_b[idx1] & val1) collisions++;
5156 if (bitmap_c[idx2] & val2) collisions++;
5157 if (bitmap_d[idx3] & val3) collisions++;
5158
5159 bitmap_a[idx0] |= val0;
5160 bitmap_b[idx1] |= val1;
5161 bitmap_c[idx2] |= val2;
5162 bitmap_d[idx3] |= val3;
5163
5164 if (collisions >= collisions_max) return 0x7fffffff;
5165 }
5166
5167 return collisions;
5168 }
5169
5170 /**
5171 * main
5172 */
5173
5174 int main (int argc, char **argv)
5175 {
5176 /**
5177 * To help users a bit
5178 */
5179
5180 char *compute = getenv ("COMPUTE");
5181
5182 if (compute)
5183 {
5184 static char display[100];
5185
5186 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5187
5188 putenv (display);
5189 }
5190 else
5191 {
5192 if (getenv ("DISPLAY") == NULL)
5193 putenv ((char *) "DISPLAY=:0");
5194 }
5195
5196 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5197 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5198
5199 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5200 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5201
5202 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5203 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5204
5205 /**
5206 * Real init
5207 */
5208
5209 memset (&data, 0, sizeof (hc_global_data_t));
5210
5211 time_t proc_start;
5212
5213 time (&proc_start);
5214
5215 data.proc_start = proc_start;
5216
5217 int myargc = argc;
5218 char **myargv = argv;
5219
5220 hc_thread_mutex_init (mux_dispatcher);
5221 hc_thread_mutex_init (mux_counter);
5222 hc_thread_mutex_init (mux_display);
5223 hc_thread_mutex_init (mux_adl);
5224
5225 /**
5226 * commandline parameters
5227 */
5228
5229 uint usage = USAGE;
5230 uint version = VERSION;
5231 uint quiet = QUIET;
5232 uint benchmark = BENCHMARK;
5233 uint benchmark_mode = BENCHMARK_MODE;
5234 uint show = SHOW;
5235 uint left = LEFT;
5236 uint username = USERNAME;
5237 uint remove = REMOVE;
5238 uint remove_timer = REMOVE_TIMER;
5239 u64 skip = SKIP;
5240 u64 limit = LIMIT;
5241 uint keyspace = KEYSPACE;
5242 uint potfile_disable = POTFILE_DISABLE;
5243 uint debug_mode = DEBUG_MODE;
5244 char *debug_file = NULL;
5245 char *induction_dir = NULL;
5246 char *outfile_check_dir = NULL;
5247 uint force = FORCE;
5248 uint runtime = RUNTIME;
5249 uint hash_mode = HASH_MODE;
5250 uint attack_mode = ATTACK_MODE;
5251 uint markov_disable = MARKOV_DISABLE;
5252 uint markov_classic = MARKOV_CLASSIC;
5253 uint markov_threshold = MARKOV_THRESHOLD;
5254 char *markov_hcstat = NULL;
5255 char *outfile = NULL;
5256 uint outfile_format = OUTFILE_FORMAT;
5257 uint outfile_autohex = OUTFILE_AUTOHEX;
5258 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5259 uint restore = RESTORE;
5260 uint restore_timer = RESTORE_TIMER;
5261 uint restore_disable = RESTORE_DISABLE;
5262 uint status = STATUS;
5263 uint status_timer = STATUS_TIMER;
5264 uint status_automat = STATUS_AUTOMAT;
5265 uint loopback = LOOPBACK;
5266 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5267 char *session = NULL;
5268 uint hex_charset = HEX_CHARSET;
5269 uint hex_salt = HEX_SALT;
5270 uint hex_wordlist = HEX_WORDLIST;
5271 uint rp_gen = RP_GEN;
5272 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5273 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5274 uint rp_gen_seed = RP_GEN_SEED;
5275 char *rule_buf_l = (char *) RULE_BUF_L;
5276 char *rule_buf_r = (char *) RULE_BUF_R;
5277 uint increment = INCREMENT;
5278 uint increment_min = INCREMENT_MIN;
5279 uint increment_max = INCREMENT_MAX;
5280 char *cpu_affinity = NULL;
5281 OCL_PTR *ocl = NULL;
5282 char *opencl_devices = NULL;
5283 char *opencl_platforms = NULL;
5284 char *opencl_device_types = NULL;
5285 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5286 char *truecrypt_keyfiles = NULL;
5287 uint workload_profile = WORKLOAD_PROFILE;
5288 uint kernel_accel = KERNEL_ACCEL;
5289 uint kernel_loops = KERNEL_LOOPS;
5290 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5291 #ifdef HAVE_HWMON
5292 uint gpu_temp_abort = GPU_TEMP_ABORT;
5293 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5294 #ifdef HAVE_ADL
5295 uint powertune_enable = POWERTUNE_ENABLE;
5296 #endif
5297 #endif
5298 uint logfile_disable = LOGFILE_DISABLE;
5299 uint segment_size = SEGMENT_SIZE;
5300 uint scrypt_tmto = SCRYPT_TMTO;
5301 char separator = SEPARATOR;
5302 uint bitmap_min = BITMAP_MIN;
5303 uint bitmap_max = BITMAP_MAX;
5304 char *custom_charset_1 = NULL;
5305 char *custom_charset_2 = NULL;
5306 char *custom_charset_3 = NULL;
5307 char *custom_charset_4 = NULL;
5308
5309 #define IDX_HELP 'h'
5310 #define IDX_VERSION 'V'
5311 #define IDX_VERSION_LOWER 'v'
5312 #define IDX_QUIET 0xff02
5313 #define IDX_SHOW 0xff03
5314 #define IDX_LEFT 0xff04
5315 #define IDX_REMOVE 0xff05
5316 #define IDX_REMOVE_TIMER 0xff37
5317 #define IDX_SKIP 's'
5318 #define IDX_LIMIT 'l'
5319 #define IDX_KEYSPACE 0xff35
5320 #define IDX_POTFILE_DISABLE 0xff06
5321 #define IDX_DEBUG_MODE 0xff43
5322 #define IDX_DEBUG_FILE 0xff44
5323 #define IDX_INDUCTION_DIR 0xff46
5324 #define IDX_OUTFILE_CHECK_DIR 0xff47
5325 #define IDX_USERNAME 0xff07
5326 #define IDX_FORCE 0xff08
5327 #define IDX_RUNTIME 0xff09
5328 #define IDX_BENCHMARK 'b'
5329 #define IDX_BENCHMARK_MODE 0xff32
5330 #define IDX_HASH_MODE 'm'
5331 #define IDX_ATTACK_MODE 'a'
5332 #define IDX_RP_FILE 'r'
5333 #define IDX_RP_GEN 'g'
5334 #define IDX_RP_GEN_FUNC_MIN 0xff10
5335 #define IDX_RP_GEN_FUNC_MAX 0xff11
5336 #define IDX_RP_GEN_SEED 0xff34
5337 #define IDX_RULE_BUF_L 'j'
5338 #define IDX_RULE_BUF_R 'k'
5339 #define IDX_INCREMENT 'i'
5340 #define IDX_INCREMENT_MIN 0xff12
5341 #define IDX_INCREMENT_MAX 0xff13
5342 #define IDX_OUTFILE 'o'
5343 #define IDX_OUTFILE_FORMAT 0xff14
5344 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5345 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5346 #define IDX_RESTORE 0xff15
5347 #define IDX_RESTORE_DISABLE 0xff27
5348 #define IDX_STATUS 0xff17
5349 #define IDX_STATUS_TIMER 0xff18
5350 #define IDX_STATUS_AUTOMAT 0xff50
5351 #define IDX_LOOPBACK 0xff38
5352 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5353 #define IDX_SESSION 0xff19
5354 #define IDX_HEX_CHARSET 0xff20
5355 #define IDX_HEX_SALT 0xff21
5356 #define IDX_HEX_WORDLIST 0xff40
5357 #define IDX_MARKOV_DISABLE 0xff22
5358 #define IDX_MARKOV_CLASSIC 0xff23
5359 #define IDX_MARKOV_THRESHOLD 't'
5360 #define IDX_MARKOV_HCSTAT 0xff24
5361 #define IDX_CPU_AFFINITY 0xff25
5362 #define IDX_OPENCL_DEVICES 'd'
5363 #define IDX_OPENCL_PLATFORMS 0xff72
5364 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5365 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5366 #define IDX_WORKLOAD_PROFILE 'w'
5367 #define IDX_KERNEL_ACCEL 'n'
5368 #define IDX_KERNEL_LOOPS 'u'
5369 #define IDX_GPU_TEMP_DISABLE 0xff29
5370 #define IDX_GPU_TEMP_ABORT 0xff30
5371 #define IDX_GPU_TEMP_RETAIN 0xff31
5372 #define IDX_POWERTUNE_ENABLE 0xff41
5373 #define IDX_LOGFILE_DISABLE 0xff51
5374 #define IDX_TRUECRYPT_KEYFILES 0xff52
5375 #define IDX_SCRYPT_TMTO 0xff61
5376 #define IDX_SEGMENT_SIZE 'c'
5377 #define IDX_SEPARATOR 'p'
5378 #define IDX_BITMAP_MIN 0xff70
5379 #define IDX_BITMAP_MAX 0xff71
5380 #define IDX_CUSTOM_CHARSET_1 '1'
5381 #define IDX_CUSTOM_CHARSET_2 '2'
5382 #define IDX_CUSTOM_CHARSET_3 '3'
5383 #define IDX_CUSTOM_CHARSET_4 '4'
5384
5385 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5386
5387 struct option long_options[] =
5388 {
5389 {"help", no_argument, 0, IDX_HELP},
5390 {"version", no_argument, 0, IDX_VERSION},
5391 {"quiet", no_argument, 0, IDX_QUIET},
5392 {"show", no_argument, 0, IDX_SHOW},
5393 {"left", no_argument, 0, IDX_LEFT},
5394 {"username", no_argument, 0, IDX_USERNAME},
5395 {"remove", no_argument, 0, IDX_REMOVE},
5396 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5397 {"skip", required_argument, 0, IDX_SKIP},
5398 {"limit", required_argument, 0, IDX_LIMIT},
5399 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5400 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5401 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5402 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5403 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5404 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5405 {"force", no_argument, 0, IDX_FORCE},
5406 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5407 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5408 {"restore", no_argument, 0, IDX_RESTORE},
5409 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5410 {"status", no_argument, 0, IDX_STATUS},
5411 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5412 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5413 {"loopback", no_argument, 0, IDX_LOOPBACK},
5414 {"weak-hash-threshold",
5415 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5416 {"session", required_argument, 0, IDX_SESSION},
5417 {"runtime", required_argument, 0, IDX_RUNTIME},
5418 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5419 {"generate-rules-func-min",
5420 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5421 {"generate-rules-func-max",
5422 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5423 {"generate-rules-seed",
5424 required_argument, 0, IDX_RP_GEN_SEED},
5425 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5426 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5427 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5428 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5429 {"rules-file", required_argument, 0, IDX_RP_FILE},
5430 {"outfile", required_argument, 0, IDX_OUTFILE},
5431 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5432 {"outfile-autohex-disable",
5433 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5434 {"outfile-check-timer",
5435 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5436 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5437 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5438 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5439 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5440 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5441 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5442 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5443 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5444 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5445 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5446 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5447 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5448 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5449 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5450 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5451 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5452 #ifdef HAVE_HWMON
5453 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5454 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5455 #ifdef HAVE_ADL
5456 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5457 #endif
5458 #endif // HAVE_HWMON
5459 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5460 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5461 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5462 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5463 // deprecated
5464 {"seperator", required_argument, 0, IDX_SEPARATOR},
5465 {"separator", required_argument, 0, IDX_SEPARATOR},
5466 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5467 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5468 {"increment", no_argument, 0, IDX_INCREMENT},
5469 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5470 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5471 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5472 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5473 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5474 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5475
5476 {0, 0, 0, 0}
5477 };
5478
5479 uint rp_files_cnt = 0;
5480
5481 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5482
5483 int option_index = 0;
5484 int c = -1;
5485
5486 optind = 1;
5487 optopt = 0;
5488
5489 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5490 {
5491 switch (c)
5492 {
5493 case IDX_HELP: usage = 1; break;
5494 case IDX_VERSION:
5495 case IDX_VERSION_LOWER: version = 1; break;
5496 case IDX_RESTORE: restore = 1; break;
5497 case IDX_SESSION: session = optarg; break;
5498 case IDX_SHOW: show = 1; break;
5499 case IDX_LEFT: left = 1; break;
5500 case '?': return (-1);
5501 }
5502 }
5503
5504 if (optopt != 0)
5505 {
5506 log_error ("ERROR: Invalid argument specified");
5507
5508 return (-1);
5509 }
5510
5511 /**
5512 * exit functions
5513 */
5514
5515 if (version)
5516 {
5517 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5518
5519 return (0);
5520 }
5521
5522 if (usage)
5523 {
5524 usage_big_print (PROGNAME);
5525
5526 return (0);
5527 }
5528
5529 /**
5530 * session needs to be set, always!
5531 */
5532
5533 if (session == NULL) session = (char *) PROGNAME;
5534
5535 /**
5536 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5537 */
5538
5539 char *exec_path = get_exec_path ();
5540
5541 #ifdef LINUX
5542
5543 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5544 char *resolved_exec_path = realpath (exec_path, NULL);
5545
5546 char *install_dir = get_install_dir (resolved_exec_path);
5547 char *profile_dir = NULL;
5548 char *session_dir = NULL;
5549 char *shared_dir = NULL;
5550
5551 if (strcmp (install_dir, resolved_install_folder) == 0)
5552 {
5553 struct passwd *pw = getpwuid (getuid ());
5554
5555 const char *homedir = pw->pw_dir;
5556
5557 profile_dir = get_profile_dir (homedir);
5558 session_dir = get_session_dir (profile_dir);
5559 shared_dir = strdup (SHARED_FOLDER);
5560
5561 mkdir (profile_dir, 0700);
5562 mkdir (session_dir, 0700);
5563 }
5564 else
5565 {
5566 profile_dir = install_dir;
5567 session_dir = install_dir;
5568 shared_dir = install_dir;
5569 }
5570
5571 myfree (resolved_install_folder);
5572 myfree (resolved_exec_path);
5573
5574 #else
5575
5576 char *install_dir = get_install_dir (exec_path);
5577 char *profile_dir = install_dir;
5578 char *session_dir = install_dir;
5579 char *shared_dir = install_dir;
5580
5581 #endif
5582
5583 data.install_dir = install_dir;
5584 data.profile_dir = profile_dir;
5585 data.session_dir = session_dir;
5586 data.shared_dir = shared_dir;
5587
5588 myfree (exec_path);
5589
5590 /**
5591 * kernel cache, we need to make sure folder exist
5592 */
5593
5594 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5595
5596 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5597
5598 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5599
5600 mkdir (kernels_folder, 0700);
5601
5602 myfree (kernels_folder);
5603
5604 /**
5605 * session
5606 */
5607
5608 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5609
5610 data.session = session;
5611
5612 char *eff_restore_file = (char *) mymalloc (session_size);
5613 char *new_restore_file = (char *) mymalloc (session_size);
5614
5615 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5616 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5617
5618 data.eff_restore_file = eff_restore_file;
5619 data.new_restore_file = new_restore_file;
5620
5621 if (((show == 1) || (left == 1)) && (restore == 1))
5622 {
5623 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5624 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5625
5626 return (-1);
5627 }
5628
5629 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5630 if ((show == 1) || (left == 1))
5631 {
5632 restore_disable = 1;
5633
5634 restore = 0;
5635 }
5636
5637 data.restore_disable = restore_disable;
5638
5639 restore_data_t *rd = init_restore (argc, argv);
5640
5641 data.rd = rd;
5642
5643 /**
5644 * restore file
5645 */
5646
5647 if (restore == 1)
5648 {
5649 read_restore (eff_restore_file, rd);
5650
5651 if (rd->version_bin < RESTORE_MIN)
5652 {
5653 log_error ("ERROR: Incompatible restore-file version");
5654
5655 return (-1);
5656 }
5657
5658 myargc = rd->argc;
5659 myargv = rd->argv;
5660
5661 #ifdef _POSIX
5662 rd->pid = getpid ();
5663 #elif _WIN
5664 rd->pid = GetCurrentProcessId ();
5665 #endif
5666 }
5667
5668 uint hash_mode_chgd = 0;
5669 uint runtime_chgd = 0;
5670 uint kernel_loops_chgd = 0;
5671 uint kernel_accel_chgd = 0;
5672 uint attack_mode_chgd = 0;
5673 uint outfile_format_chgd = 0;
5674 uint rp_gen_seed_chgd = 0;
5675 uint remove_timer_chgd = 0;
5676 uint increment_min_chgd = 0;
5677 uint increment_max_chgd = 0;
5678 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5679 uint gpu_temp_retain_chgd = 0;
5680 uint gpu_temp_abort_chgd = 0;
5681 #endif
5682
5683 optind = 1;
5684 optopt = 0;
5685 option_index = 0;
5686
5687 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5688 {
5689 switch (c)
5690 {
5691 //case IDX_HELP: usage = 1; break;
5692 //case IDX_VERSION: version = 1; break;
5693 //case IDX_RESTORE: restore = 1; break;
5694 case IDX_QUIET: quiet = 1; break;
5695 //case IDX_SHOW: show = 1; break;
5696 case IDX_SHOW: break;
5697 //case IDX_LEFT: left = 1; break;
5698 case IDX_LEFT: break;
5699 case IDX_USERNAME: username = 1; break;
5700 case IDX_REMOVE: remove = 1; break;
5701 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5702 remove_timer_chgd = 1; break;
5703 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5704 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5705 case IDX_DEBUG_FILE: debug_file = optarg; break;
5706 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5707 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5708 case IDX_FORCE: force = 1; break;
5709 case IDX_SKIP: skip = atoll (optarg); break;
5710 case IDX_LIMIT: limit = atoll (optarg); break;
5711 case IDX_KEYSPACE: keyspace = 1; break;
5712 case IDX_BENCHMARK: benchmark = 1; break;
5713 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5714 case IDX_RESTORE: break;
5715 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5716 case IDX_STATUS: status = 1; break;
5717 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5718 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5719 case IDX_LOOPBACK: loopback = 1; break;
5720 case IDX_WEAK_HASH_THRESHOLD:
5721 weak_hash_threshold = atoi (optarg); break;
5722 //case IDX_SESSION: session = optarg; break;
5723 case IDX_SESSION: break;
5724 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5725 hash_mode_chgd = 1; break;
5726 case IDX_RUNTIME: runtime = atoi (optarg);
5727 runtime_chgd = 1; break;
5728 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5729 attack_mode_chgd = 1; break;
5730 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5731 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5732 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5733 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5734 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5735 rp_gen_seed_chgd = 1; break;
5736 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5737 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5738 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5739 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5740 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5741 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5742 case IDX_OUTFILE: outfile = optarg; break;
5743 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5744 outfile_format_chgd = 1; break;
5745 case IDX_OUTFILE_AUTOHEX_DISABLE:
5746 outfile_autohex = 0; break;
5747 case IDX_OUTFILE_CHECK_TIMER:
5748 outfile_check_timer = atoi (optarg); break;
5749 case IDX_HEX_CHARSET: hex_charset = 1; break;
5750 case IDX_HEX_SALT: hex_salt = 1; break;
5751 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5752 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5753 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5754 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5755 case IDX_OPENCL_DEVICE_TYPES:
5756 opencl_device_types = optarg; break;
5757 case IDX_OPENCL_VECTOR_WIDTH:
5758 opencl_vector_width = atoi (optarg); break;
5759 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5760 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5761 kernel_accel_chgd = 1; break;
5762 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5763 kernel_loops_chgd = 1; break;
5764 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5765 #ifdef HAVE_HWMON
5766 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5767 #ifdef HAVE_ADL
5768 gpu_temp_abort_chgd = 1;
5769 #endif
5770 break;
5771 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5772 #ifdef HAVE_ADL
5773 gpu_temp_retain_chgd = 1;
5774 #endif
5775 break;
5776 #ifdef HAVE_ADL
5777 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5778 #endif
5779 #endif // HAVE_HWMON
5780 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5781 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5782 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5783 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5784 case IDX_SEPARATOR: separator = optarg[0]; break;
5785 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5786 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5787 case IDX_INCREMENT: increment = 1; break;
5788 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5789 increment_min_chgd = 1; break;
5790 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5791 increment_max_chgd = 1; break;
5792 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5793 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5794 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5795 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5796
5797 default:
5798 log_error ("ERROR: Invalid argument specified");
5799 return (-1);
5800 }
5801 }
5802
5803 if (optopt != 0)
5804 {
5805 log_error ("ERROR: Invalid argument specified");
5806
5807 return (-1);
5808 }
5809
5810 /**
5811 * Inform user things getting started,
5812 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5813 * - we do not need to check algorithm_pos
5814 */
5815
5816 if (quiet == 0)
5817 {
5818 if (benchmark == 1)
5819 {
5820 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5821
5822 log_info ("");
5823 }
5824 else if (restore == 1)
5825 {
5826 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5827
5828 log_info ("");
5829 }
5830 else
5831 {
5832 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5833
5834 log_info ("");
5835 }
5836 }
5837
5838 /**
5839 * sanity check
5840 */
5841
5842 if (attack_mode > 7)
5843 {
5844 log_error ("ERROR: Invalid attack-mode specified");
5845
5846 return (-1);
5847 }
5848
5849 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5850 {
5851 log_error ("ERROR: Invalid runtime specified");
5852
5853 return (-1);
5854 }
5855
5856 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5857 {
5858 log_error ("ERROR: Invalid hash-type specified");
5859
5860 return (-1);
5861 }
5862
5863 // renamed hash modes
5864
5865 if (hash_mode_chgd)
5866 {
5867 int n = -1;
5868
5869 switch (hash_mode)
5870 {
5871 case 123: n = 124;
5872 break;
5873 }
5874
5875 if (n >= 0)
5876 {
5877 log_error ("Old -m specified, use -m %d instead", n);
5878
5879 return (-1);
5880 }
5881 }
5882
5883 if (username == 1)
5884 {
5885 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5886 {
5887 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5888
5889 return (-1);
5890 }
5891 }
5892
5893 if (outfile_format > 16)
5894 {
5895 log_error ("ERROR: Invalid outfile-format specified");
5896
5897 return (-1);
5898 }
5899
5900 if (left == 1)
5901 {
5902 if (outfile_format_chgd == 1)
5903 {
5904 if (outfile_format > 1)
5905 {
5906 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5907
5908 return (-1);
5909 }
5910 }
5911 else
5912 {
5913 outfile_format = OUTFILE_FMT_HASH;
5914 }
5915 }
5916
5917 if (show == 1)
5918 {
5919 if (outfile_format_chgd == 1)
5920 {
5921 if ((outfile_format > 7) && (outfile_format < 16))
5922 {
5923 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5924
5925 return (-1);
5926 }
5927 }
5928 }
5929
5930 if (increment_min < INCREMENT_MIN)
5931 {
5932 log_error ("ERROR: Invalid increment-min specified");
5933
5934 return (-1);
5935 }
5936
5937 if (increment_max > INCREMENT_MAX)
5938 {
5939 log_error ("ERROR: Invalid increment-max specified");
5940
5941 return (-1);
5942 }
5943
5944 if (increment_min > increment_max)
5945 {
5946 log_error ("ERROR: Invalid increment-min specified");
5947
5948 return (-1);
5949 }
5950
5951 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5952 {
5953 log_error ("ERROR: increment is not allowed in attack-mode 0");
5954
5955 return (-1);
5956 }
5957
5958 if ((increment == 0) && (increment_min_chgd == 1))
5959 {
5960 log_error ("ERROR: increment-min is only supported together with increment switch");
5961
5962 return (-1);
5963 }
5964
5965 if ((increment == 0) && (increment_max_chgd == 1))
5966 {
5967 log_error ("ERROR: increment-max is only supported together with increment switch");
5968
5969 return (-1);
5970 }
5971
5972 if (rp_files_cnt && rp_gen)
5973 {
5974 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5975
5976 return (-1);
5977 }
5978
5979 if (rp_files_cnt || rp_gen)
5980 {
5981 if (attack_mode != ATTACK_MODE_STRAIGHT)
5982 {
5983 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5984
5985 return (-1);
5986 }
5987 }
5988
5989 if (rp_gen_func_min > rp_gen_func_max)
5990 {
5991 log_error ("ERROR: Invalid rp-gen-func-min specified");
5992
5993 return (-1);
5994 }
5995
5996 if (kernel_accel_chgd == 1)
5997 {
5998 if (workload_profile != WORKLOAD_PROFILE)
5999 {
6000 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6001
6002 return (-1);
6003 }
6004
6005 if (kernel_accel < 1)
6006 {
6007 log_error ("ERROR: Invalid kernel-accel specified");
6008
6009 return (-1);
6010 }
6011
6012 if (kernel_accel > 1024)
6013 {
6014 log_error ("ERROR: Invalid kernel-accel specified");
6015
6016 return (-1);
6017 }
6018 }
6019
6020 if (kernel_loops_chgd == 1)
6021 {
6022 if (workload_profile != WORKLOAD_PROFILE)
6023 {
6024 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
6025
6026 return (-1);
6027 }
6028
6029 if (kernel_loops < 1)
6030 {
6031 log_error ("ERROR: Invalid kernel-loops specified");
6032
6033 return (-1);
6034 }
6035
6036 if (kernel_loops > 1024)
6037 {
6038 log_error ("ERROR: Invalid kernel-loops specified");
6039
6040 return (-1);
6041 }
6042 }
6043
6044 if (benchmark == 1)
6045 {
6046 if (workload_profile != WORKLOAD_PROFILE)
6047 {
6048 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6049
6050 return (-1);
6051 }
6052 }
6053
6054 if ((workload_profile < 1) || (workload_profile > 3))
6055 {
6056 log_error ("ERROR: workload-profile %i not available", workload_profile);
6057
6058 return (-1);
6059 }
6060
6061 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6062 {
6063 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6064
6065 return (-1);
6066 }
6067
6068 if (show == 1 || left == 1)
6069 {
6070 attack_mode = ATTACK_MODE_NONE;
6071
6072 if (remove == 1)
6073 {
6074 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6075
6076 return (-1);
6077 }
6078
6079 if (potfile_disable == 1)
6080 {
6081 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6082
6083 return (-1);
6084 }
6085 }
6086
6087 uint attack_kern = ATTACK_KERN_NONE;
6088
6089 switch (attack_mode)
6090 {
6091 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6092 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6093 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6094 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6095 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6096 }
6097
6098 if (benchmark == 0)
6099 {
6100 if (keyspace == 1)
6101 {
6102 int num_additional_params = 1;
6103
6104 if (attack_kern == ATTACK_KERN_COMBI)
6105 {
6106 num_additional_params = 2;
6107 }
6108
6109 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6110
6111 if (keyspace_wordlist_specified == 0) optind--;
6112 }
6113
6114 if (attack_kern == ATTACK_KERN_NONE)
6115 {
6116 if ((optind + 1) != myargc)
6117 {
6118 usage_mini_print (myargv[0]);
6119
6120 return (-1);
6121 }
6122 }
6123 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6124 {
6125 if ((optind + 1) > myargc)
6126 {
6127 usage_mini_print (myargv[0]);
6128
6129 return (-1);
6130 }
6131 }
6132 else if (attack_kern == ATTACK_KERN_COMBI)
6133 {
6134 if ((optind + 3) != myargc)
6135 {
6136 usage_mini_print (myargv[0]);
6137
6138 return (-1);
6139 }
6140 }
6141 else if (attack_kern == ATTACK_KERN_BF)
6142 {
6143 if ((optind + 1) > myargc)
6144 {
6145 usage_mini_print (myargv[0]);
6146
6147 return (-1);
6148 }
6149 }
6150 else
6151 {
6152 usage_mini_print (myargv[0]);
6153
6154 return (-1);
6155 }
6156 }
6157 else
6158 {
6159 if (myargv[optind] != 0)
6160 {
6161 log_error ("ERROR: Invalid argument for benchmark mode specified");
6162
6163 return (-1);
6164 }
6165
6166 if (attack_mode_chgd == 1)
6167 {
6168 if (attack_mode != ATTACK_MODE_BF)
6169 {
6170 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6171
6172 return (-1);
6173 }
6174 }
6175
6176 if (benchmark_mode == 0)
6177 {
6178 // nothing to do
6179 }
6180 else if (benchmark_mode == 1)
6181 {
6182 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6183 {
6184 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6185
6186 return (-1);
6187 }
6188 }
6189 else
6190 {
6191 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6192
6193 return (-1);
6194 }
6195 }
6196
6197 if (skip != 0 && limit != 0)
6198 {
6199 limit += skip;
6200 }
6201
6202 if (keyspace == 1)
6203 {
6204 if (show == 1)
6205 {
6206 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6207
6208 return (-1);
6209 }
6210 else if (left == 1)
6211 {
6212 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6213
6214 return (-1);
6215 }
6216
6217 potfile_disable = 1;
6218
6219 restore_disable = 1;
6220
6221 restore = 0;
6222
6223 weak_hash_threshold = 0;
6224
6225 quiet = 1;
6226 }
6227
6228 if (remove_timer_chgd == 1)
6229 {
6230 if (remove == 0)
6231 {
6232 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6233
6234 return (-1);
6235 }
6236
6237 if (remove_timer < 1)
6238 {
6239 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6240
6241 return (-1);
6242 }
6243 }
6244
6245 if (loopback == 1)
6246 {
6247 if (attack_mode == ATTACK_MODE_BF)
6248 {
6249 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6250
6251 return (-1);
6252 }
6253 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6254 {
6255 if ((rp_files_cnt == 0) && (rp_gen == 0))
6256 {
6257 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6258
6259 return (-1);
6260 }
6261 }
6262 }
6263
6264 if (debug_mode > 0)
6265 {
6266 if (attack_mode != ATTACK_MODE_STRAIGHT)
6267 {
6268 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6269
6270 return (-1);
6271 }
6272
6273 if ((rp_files_cnt == 0) && (rp_gen == 0))
6274 {
6275 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6276
6277 return (-1);
6278 }
6279 }
6280
6281 if (debug_mode > 4)
6282 {
6283 log_error ("ERROR: Invalid debug-mode specified");
6284
6285 return (-1);
6286 }
6287
6288 if (debug_file != NULL)
6289 {
6290 if (debug_mode < 1)
6291 {
6292 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6293
6294 return (-1);
6295 }
6296 }
6297
6298 if (induction_dir != NULL)
6299 {
6300 if (attack_mode == ATTACK_MODE_BF)
6301 {
6302 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6303
6304 return (-1);
6305 }
6306 }
6307
6308 if (attack_mode != ATTACK_MODE_STRAIGHT)
6309 {
6310 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6311 {
6312 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6313
6314 return (-1);
6315 }
6316
6317 weak_hash_threshold = 0;
6318 }
6319
6320 /**
6321 * induction directory
6322 */
6323
6324 char *induction_directory = NULL;
6325
6326 if (attack_mode != ATTACK_MODE_BF)
6327 {
6328 if (induction_dir == NULL)
6329 {
6330 induction_directory = (char *) mymalloc (session_size);
6331
6332 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6333
6334 // create induction folder if it does not already exist
6335
6336 if (keyspace == 0)
6337 {
6338 if (rmdir (induction_directory) == -1)
6339 {
6340 if (errno == ENOENT)
6341 {
6342 // good, we can ignore
6343 }
6344 else if (errno == ENOTEMPTY)
6345 {
6346 char *induction_directory_mv = (char *) mymalloc (session_size);
6347
6348 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6349
6350 if (rename (induction_directory, induction_directory_mv) != 0)
6351 {
6352 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6353
6354 return (-1);
6355 }
6356 }
6357 else
6358 {
6359 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6360
6361 return (-1);
6362 }
6363 }
6364
6365 if (mkdir (induction_directory, 0700) == -1)
6366 {
6367 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6368
6369 return (-1);
6370 }
6371 }
6372 }
6373 else
6374 {
6375 induction_directory = induction_dir;
6376 }
6377 }
6378
6379 data.induction_directory = induction_directory;
6380
6381 /**
6382 * loopback
6383 */
6384
6385 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6386
6387 char *loopback_file = (char *) mymalloc (loopback_size);
6388
6389 /**
6390 * outfile-check directory
6391 */
6392
6393 char *outfile_check_directory = NULL;
6394
6395 if (outfile_check_dir == NULL)
6396 {
6397 outfile_check_directory = (char *) mymalloc (session_size);
6398
6399 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6400 }
6401 else
6402 {
6403 outfile_check_directory = outfile_check_dir;
6404 }
6405
6406 data.outfile_check_directory = outfile_check_directory;
6407
6408 if (keyspace == 0)
6409 {
6410 struct stat outfile_check_stat;
6411
6412 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6413 {
6414 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6415
6416 if (is_dir == 0)
6417 {
6418 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6419
6420 return (-1);
6421 }
6422 }
6423 else if (outfile_check_dir == NULL)
6424 {
6425 if (mkdir (outfile_check_directory, 0700) == -1)
6426 {
6427 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6428
6429 return (-1);
6430 }
6431 }
6432 }
6433
6434 /**
6435 * special other stuff
6436 */
6437
6438 if (hash_mode == 9710)
6439 {
6440 outfile_format = 5;
6441 outfile_format_chgd = 1;
6442 }
6443
6444 if (hash_mode == 9810)
6445 {
6446 outfile_format = 5;
6447 outfile_format_chgd = 1;
6448 }
6449
6450 if (hash_mode == 10410)
6451 {
6452 outfile_format = 5;
6453 outfile_format_chgd = 1;
6454 }
6455
6456 /**
6457 * store stuff
6458 */
6459
6460 data.hash_mode = hash_mode;
6461 data.restore = restore;
6462 data.restore_timer = restore_timer;
6463 data.restore_disable = restore_disable;
6464 data.status = status;
6465 data.status_timer = status_timer;
6466 data.status_automat = status_automat;
6467 data.loopback = loopback;
6468 data.runtime = runtime;
6469 data.remove = remove;
6470 data.remove_timer = remove_timer;
6471 data.debug_mode = debug_mode;
6472 data.debug_file = debug_file;
6473 data.username = username;
6474 data.quiet = quiet;
6475 data.outfile = outfile;
6476 data.outfile_format = outfile_format;
6477 data.outfile_autohex = outfile_autohex;
6478 data.hex_charset = hex_charset;
6479 data.hex_salt = hex_salt;
6480 data.hex_wordlist = hex_wordlist;
6481 data.separator = separator;
6482 data.rp_files = rp_files;
6483 data.rp_files_cnt = rp_files_cnt;
6484 data.rp_gen = rp_gen;
6485 data.rp_gen_seed = rp_gen_seed;
6486 data.force = force;
6487 data.benchmark = benchmark;
6488 data.skip = skip;
6489 data.limit = limit;
6490 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6491 data.powertune_enable = powertune_enable;
6492 #endif
6493 data.logfile_disable = logfile_disable;
6494 data.truecrypt_keyfiles = truecrypt_keyfiles;
6495 data.scrypt_tmto = scrypt_tmto;
6496
6497 /**
6498 * cpu affinity
6499 */
6500
6501 if (cpu_affinity)
6502 {
6503 set_cpu_affinity (cpu_affinity);
6504 }
6505
6506 if (rp_gen_seed_chgd == 0)
6507 {
6508 srand (proc_start);
6509 }
6510 else
6511 {
6512 srand (rp_gen_seed);
6513 }
6514
6515 /**
6516 * logfile init
6517 */
6518
6519 if (logfile_disable == 0)
6520 {
6521 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6522
6523 char *logfile = (char *) mymalloc (logfile_size);
6524
6525 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6526
6527 data.logfile = logfile;
6528
6529 char *topid = logfile_generate_topid ();
6530
6531 data.topid = topid;
6532 }
6533
6534 // logfile_append() checks for logfile_disable internally to make it easier from here
6535
6536 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6537 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6538 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6539 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6540 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6541 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6542 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6543 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6544 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6545 #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));
6546
6547 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6548 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6549 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6550 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6551 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6552 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6553 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6554 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6555
6556 logfile_top_msg ("START");
6557
6558 logfile_top_uint (attack_mode);
6559 logfile_top_uint (attack_kern);
6560 logfile_top_uint (benchmark);
6561 logfile_top_uint (benchmark_mode);
6562 logfile_top_uint (bitmap_min);
6563 logfile_top_uint (bitmap_max);
6564 logfile_top_uint (debug_mode);
6565 logfile_top_uint (force);
6566 logfile_top_uint (kernel_accel);
6567 logfile_top_uint (kernel_loops);
6568 logfile_top_uint (gpu_temp_disable);
6569 #ifdef HAVE_HWMON
6570 logfile_top_uint (gpu_temp_abort);
6571 logfile_top_uint (gpu_temp_retain);
6572 #endif
6573 logfile_top_uint (hash_mode);
6574 logfile_top_uint (hex_charset);
6575 logfile_top_uint (hex_salt);
6576 logfile_top_uint (hex_wordlist);
6577 logfile_top_uint (increment);
6578 logfile_top_uint (increment_max);
6579 logfile_top_uint (increment_min);
6580 logfile_top_uint (keyspace);
6581 logfile_top_uint (left);
6582 logfile_top_uint (logfile_disable);
6583 logfile_top_uint (loopback);
6584 logfile_top_uint (markov_classic);
6585 logfile_top_uint (markov_disable);
6586 logfile_top_uint (markov_threshold);
6587 logfile_top_uint (outfile_autohex);
6588 logfile_top_uint (outfile_check_timer);
6589 logfile_top_uint (outfile_format);
6590 logfile_top_uint (potfile_disable);
6591 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6592 logfile_top_uint (powertune_enable);
6593 #endif
6594 logfile_top_uint (scrypt_tmto);
6595 logfile_top_uint (quiet);
6596 logfile_top_uint (remove);
6597 logfile_top_uint (remove_timer);
6598 logfile_top_uint (restore);
6599 logfile_top_uint (restore_disable);
6600 logfile_top_uint (restore_timer);
6601 logfile_top_uint (rp_gen);
6602 logfile_top_uint (rp_gen_func_max);
6603 logfile_top_uint (rp_gen_func_min);
6604 logfile_top_uint (rp_gen_seed);
6605 logfile_top_uint (runtime);
6606 logfile_top_uint (segment_size);
6607 logfile_top_uint (show);
6608 logfile_top_uint (status);
6609 logfile_top_uint (status_automat);
6610 logfile_top_uint (status_timer);
6611 logfile_top_uint (usage);
6612 logfile_top_uint (username);
6613 logfile_top_uint (version);
6614 logfile_top_uint (weak_hash_threshold);
6615 logfile_top_uint (workload_profile);
6616 logfile_top_uint64 (limit);
6617 logfile_top_uint64 (skip);
6618 logfile_top_char (separator);
6619 logfile_top_string (cpu_affinity);
6620 logfile_top_string (custom_charset_1);
6621 logfile_top_string (custom_charset_2);
6622 logfile_top_string (custom_charset_3);
6623 logfile_top_string (custom_charset_4);
6624 logfile_top_string (debug_file);
6625 logfile_top_string (opencl_devices);
6626 logfile_top_string (opencl_platforms);
6627 logfile_top_string (opencl_device_types);
6628 logfile_top_uint (opencl_vector_width);
6629 logfile_top_string (induction_dir);
6630 logfile_top_string (markov_hcstat);
6631 logfile_top_string (outfile);
6632 logfile_top_string (outfile_check_dir);
6633 logfile_top_string (rule_buf_l);
6634 logfile_top_string (rule_buf_r);
6635 logfile_top_string (session);
6636 logfile_top_string (truecrypt_keyfiles);
6637
6638 /**
6639 * Init OpenCL library loader
6640 */
6641
6642 if (keyspace == 0)
6643 {
6644 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6645
6646 ocl_init (ocl);
6647
6648 data.ocl = ocl;
6649 }
6650
6651 /**
6652 * OpenCL platform selection
6653 */
6654
6655 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6656
6657 /**
6658 * OpenCL device selection
6659 */
6660
6661 u32 devices_filter = setup_devices_filter (opencl_devices);
6662
6663 /**
6664 * OpenCL device type selection
6665 */
6666
6667 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6668
6669 /**
6670 * benchmark
6671 */
6672
6673 if (benchmark == 1)
6674 {
6675 /**
6676 * disable useless stuff for benchmark
6677 */
6678
6679 restore_timer = 0;
6680 status_timer = 0;
6681 restore_disable = 1;
6682 potfile_disable = 1;
6683 weak_hash_threshold = 0;
6684
6685 data.restore_timer = restore_timer;
6686 data.status_timer = status_timer;
6687 data.restore_disable = restore_disable;
6688
6689 if (benchmark_mode == 1)
6690 {
6691 markov_disable = 1;
6692 }
6693
6694 /**
6695 * force attack mode to be bruteforce
6696 */
6697
6698 attack_mode = ATTACK_MODE_BF;
6699 attack_kern = ATTACK_KERN_BF;
6700
6701 if (runtime_chgd == 0)
6702 {
6703 runtime = 8;
6704
6705 if (benchmark_mode == 1) runtime = 17;
6706
6707 data.runtime = runtime;
6708 }
6709 }
6710
6711 /**
6712 * config
6713 */
6714
6715 uint hash_type = 0;
6716 uint salt_type = 0;
6717 uint attack_exec = 0;
6718 uint opts_type = 0;
6719 uint kern_type = 0;
6720 uint dgst_size = 0;
6721 uint esalt_size = 0;
6722 uint opti_type = 0;
6723 uint dgst_pos0 = -1;
6724 uint dgst_pos1 = -1;
6725 uint dgst_pos2 = -1;
6726 uint dgst_pos3 = -1;
6727
6728 int (*parse_func) (char *, uint, hash_t *);
6729 int (*sort_by_digest) (const void *, const void *);
6730
6731 uint algorithm_pos = 0;
6732 uint algorithm_max = 1;
6733
6734 uint *algorithms = default_benchmark_algorithms;
6735
6736 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6737
6738 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6739 {
6740 /*
6741 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6742 * the following algos are skipped entirely
6743 */
6744
6745 if (algorithm_pos > 0)
6746 {
6747 local_free (rd);
6748
6749 rd = init_restore (argc, argv);
6750
6751 data.rd = rd;
6752 }
6753
6754 /**
6755 * update hash_mode in case of multihash benchmark
6756 */
6757
6758 if (benchmark == 1)
6759 {
6760 if (hash_mode_chgd == 0)
6761 {
6762 hash_mode = algorithms[algorithm_pos];
6763
6764 data.hash_mode = hash_mode;
6765 }
6766
6767 quiet = 1;
6768
6769 data.quiet = quiet;
6770 }
6771
6772 switch (hash_mode)
6773 {
6774 case 0: hash_type = HASH_TYPE_MD5;
6775 salt_type = SALT_TYPE_NONE;
6776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6777 opts_type = OPTS_TYPE_PT_GENERATE_LE
6778 | OPTS_TYPE_PT_ADD80
6779 | OPTS_TYPE_PT_ADDBITS14;
6780 kern_type = KERN_TYPE_MD5;
6781 dgst_size = DGST_SIZE_4_4;
6782 parse_func = md5_parse_hash;
6783 sort_by_digest = sort_by_digest_4_4;
6784 opti_type = OPTI_TYPE_ZERO_BYTE
6785 | OPTI_TYPE_PRECOMPUTE_INIT
6786 | OPTI_TYPE_PRECOMPUTE_MERKLE
6787 | OPTI_TYPE_MEET_IN_MIDDLE
6788 | OPTI_TYPE_EARLY_SKIP
6789 | OPTI_TYPE_NOT_ITERATED
6790 | OPTI_TYPE_NOT_SALTED
6791 | OPTI_TYPE_RAW_HASH;
6792 dgst_pos0 = 0;
6793 dgst_pos1 = 3;
6794 dgst_pos2 = 2;
6795 dgst_pos3 = 1;
6796 break;
6797
6798 case 10: hash_type = HASH_TYPE_MD5;
6799 salt_type = SALT_TYPE_INTERN;
6800 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6801 opts_type = OPTS_TYPE_PT_GENERATE_LE
6802 | OPTS_TYPE_ST_ADD80
6803 | OPTS_TYPE_ST_ADDBITS14;
6804 kern_type = KERN_TYPE_MD5_PWSLT;
6805 dgst_size = DGST_SIZE_4_4;
6806 parse_func = md5s_parse_hash;
6807 sort_by_digest = sort_by_digest_4_4;
6808 opti_type = OPTI_TYPE_ZERO_BYTE
6809 | OPTI_TYPE_PRECOMPUTE_INIT
6810 | OPTI_TYPE_PRECOMPUTE_MERKLE
6811 | OPTI_TYPE_MEET_IN_MIDDLE
6812 | OPTI_TYPE_EARLY_SKIP
6813 | OPTI_TYPE_NOT_ITERATED
6814 | OPTI_TYPE_APPENDED_SALT
6815 | OPTI_TYPE_RAW_HASH;
6816 dgst_pos0 = 0;
6817 dgst_pos1 = 3;
6818 dgst_pos2 = 2;
6819 dgst_pos3 = 1;
6820 break;
6821
6822 case 11: hash_type = HASH_TYPE_MD5;
6823 salt_type = SALT_TYPE_INTERN;
6824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6825 opts_type = OPTS_TYPE_PT_GENERATE_LE
6826 | OPTS_TYPE_ST_ADD80
6827 | OPTS_TYPE_ST_ADDBITS14;
6828 kern_type = KERN_TYPE_MD5_PWSLT;
6829 dgst_size = DGST_SIZE_4_4;
6830 parse_func = joomla_parse_hash;
6831 sort_by_digest = sort_by_digest_4_4;
6832 opti_type = OPTI_TYPE_ZERO_BYTE
6833 | OPTI_TYPE_PRECOMPUTE_INIT
6834 | OPTI_TYPE_PRECOMPUTE_MERKLE
6835 | OPTI_TYPE_MEET_IN_MIDDLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_APPENDED_SALT
6839 | OPTI_TYPE_RAW_HASH;
6840 dgst_pos0 = 0;
6841 dgst_pos1 = 3;
6842 dgst_pos2 = 2;
6843 dgst_pos3 = 1;
6844 break;
6845
6846 case 12: hash_type = HASH_TYPE_MD5;
6847 salt_type = SALT_TYPE_INTERN;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_LE
6850 | OPTS_TYPE_ST_ADD80
6851 | OPTS_TYPE_ST_ADDBITS14;
6852 kern_type = KERN_TYPE_MD5_PWSLT;
6853 dgst_size = DGST_SIZE_4_4;
6854 parse_func = postgresql_parse_hash;
6855 sort_by_digest = sort_by_digest_4_4;
6856 opti_type = OPTI_TYPE_ZERO_BYTE
6857 | OPTI_TYPE_PRECOMPUTE_INIT
6858 | OPTI_TYPE_PRECOMPUTE_MERKLE
6859 | OPTI_TYPE_MEET_IN_MIDDLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_APPENDED_SALT
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 0;
6865 dgst_pos1 = 3;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 20: hash_type = HASH_TYPE_MD5;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_LE
6874 | OPTS_TYPE_PT_ADD80
6875 | OPTS_TYPE_PT_ADDBITS14;
6876 kern_type = KERN_TYPE_MD5_SLTPW;
6877 dgst_size = DGST_SIZE_4_4;
6878 parse_func = md5s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_4;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_PREPENDED_SALT
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 0;
6888 dgst_pos1 = 3;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 21: hash_type = HASH_TYPE_MD5;
6894 salt_type = SALT_TYPE_INTERN;
6895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6896 opts_type = OPTS_TYPE_PT_GENERATE_LE
6897 | OPTS_TYPE_PT_ADD80
6898 | OPTS_TYPE_PT_ADDBITS14;
6899 kern_type = KERN_TYPE_MD5_SLTPW;
6900 dgst_size = DGST_SIZE_4_4;
6901 parse_func = osc_parse_hash;
6902 sort_by_digest = sort_by_digest_4_4;
6903 opti_type = OPTI_TYPE_ZERO_BYTE
6904 | OPTI_TYPE_PRECOMPUTE_INIT
6905 | OPTI_TYPE_PRECOMPUTE_MERKLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_PREPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 0;
6911 dgst_pos1 = 3;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 22: hash_type = HASH_TYPE_MD5;
6917 salt_type = SALT_TYPE_EMBEDDED;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_LE
6920 | OPTS_TYPE_PT_ADD80
6921 | OPTS_TYPE_PT_ADDBITS14;
6922 kern_type = KERN_TYPE_MD5_SLTPW;
6923 dgst_size = DGST_SIZE_4_4;
6924 parse_func = netscreen_parse_hash;
6925 sort_by_digest = sort_by_digest_4_4;
6926 opti_type = OPTI_TYPE_ZERO_BYTE
6927 | OPTI_TYPE_PRECOMPUTE_INIT
6928 | OPTI_TYPE_PRECOMPUTE_MERKLE
6929 | OPTI_TYPE_EARLY_SKIP
6930 | OPTI_TYPE_NOT_ITERATED
6931 | OPTI_TYPE_PREPENDED_SALT
6932 | OPTI_TYPE_RAW_HASH;
6933 dgst_pos0 = 0;
6934 dgst_pos1 = 3;
6935 dgst_pos2 = 2;
6936 dgst_pos3 = 1;
6937 break;
6938
6939 case 23: hash_type = HASH_TYPE_MD5;
6940 salt_type = SALT_TYPE_EMBEDDED;
6941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6942 opts_type = OPTS_TYPE_PT_GENERATE_LE
6943 | OPTS_TYPE_PT_ADD80
6944 | OPTS_TYPE_PT_ADDBITS14;
6945 kern_type = KERN_TYPE_MD5_SLTPW;
6946 dgst_size = DGST_SIZE_4_4;
6947 parse_func = skype_parse_hash;
6948 sort_by_digest = sort_by_digest_4_4;
6949 opti_type = OPTI_TYPE_ZERO_BYTE
6950 | OPTI_TYPE_PRECOMPUTE_INIT
6951 | OPTI_TYPE_PRECOMPUTE_MERKLE
6952 | OPTI_TYPE_EARLY_SKIP
6953 | OPTI_TYPE_NOT_ITERATED
6954 | OPTI_TYPE_PREPENDED_SALT
6955 | OPTI_TYPE_RAW_HASH;
6956 dgst_pos0 = 0;
6957 dgst_pos1 = 3;
6958 dgst_pos2 = 2;
6959 dgst_pos3 = 1;
6960 break;
6961
6962 case 30: hash_type = HASH_TYPE_MD5;
6963 salt_type = SALT_TYPE_INTERN;
6964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6965 opts_type = OPTS_TYPE_PT_GENERATE_LE
6966 | OPTS_TYPE_PT_UNICODE
6967 | OPTS_TYPE_ST_ADD80
6968 | OPTS_TYPE_ST_ADDBITS14;
6969 kern_type = KERN_TYPE_MD5_PWUSLT;
6970 dgst_size = DGST_SIZE_4_4;
6971 parse_func = md5s_parse_hash;
6972 sort_by_digest = sort_by_digest_4_4;
6973 opti_type = OPTI_TYPE_ZERO_BYTE
6974 | OPTI_TYPE_PRECOMPUTE_INIT
6975 | OPTI_TYPE_PRECOMPUTE_MERKLE
6976 | OPTI_TYPE_MEET_IN_MIDDLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_APPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 0;
6982 dgst_pos1 = 3;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 40: hash_type = HASH_TYPE_MD5;
6988 salt_type = SALT_TYPE_INTERN;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_LE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS14
6993 | OPTS_TYPE_PT_UNICODE;
6994 kern_type = KERN_TYPE_MD5_SLTPWU;
6995 dgst_size = DGST_SIZE_4_4;
6996 parse_func = md5s_parse_hash;
6997 sort_by_digest = sort_by_digest_4_4;
6998 opti_type = OPTI_TYPE_ZERO_BYTE
6999 | OPTI_TYPE_PRECOMPUTE_INIT
7000 | OPTI_TYPE_PRECOMPUTE_MERKLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_PREPENDED_SALT
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 0;
7006 dgst_pos1 = 3;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 50: hash_type = HASH_TYPE_MD5;
7012 salt_type = SALT_TYPE_INTERN;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_LE
7015 | OPTS_TYPE_ST_ADD80
7016 | OPTS_TYPE_ST_ADDBITS14;
7017 kern_type = KERN_TYPE_HMACMD5_PW;
7018 dgst_size = DGST_SIZE_4_4;
7019 parse_func = hmacmd5_parse_hash;
7020 sort_by_digest = sort_by_digest_4_4;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_NOT_ITERATED;
7023 dgst_pos0 = 0;
7024 dgst_pos1 = 3;
7025 dgst_pos2 = 2;
7026 dgst_pos3 = 1;
7027 break;
7028
7029 case 60: hash_type = HASH_TYPE_MD5;
7030 salt_type = SALT_TYPE_INTERN;
7031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7032 opts_type = OPTS_TYPE_PT_GENERATE_LE
7033 | OPTS_TYPE_PT_ADD80
7034 | OPTS_TYPE_PT_ADDBITS14;
7035 kern_type = KERN_TYPE_HMACMD5_SLT;
7036 dgst_size = DGST_SIZE_4_4;
7037 parse_func = hmacmd5_parse_hash;
7038 sort_by_digest = sort_by_digest_4_4;
7039 opti_type = OPTI_TYPE_ZERO_BYTE
7040 | OPTI_TYPE_NOT_ITERATED;
7041 dgst_pos0 = 0;
7042 dgst_pos1 = 3;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 100: hash_type = HASH_TYPE_SHA1;
7048 salt_type = SALT_TYPE_NONE;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_BE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS15;
7053 kern_type = KERN_TYPE_SHA1;
7054 dgst_size = DGST_SIZE_4_5;
7055 parse_func = sha1_parse_hash;
7056 sort_by_digest = sort_by_digest_4_5;
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_NOT_SALTED
7063 | OPTI_TYPE_RAW_HASH;
7064 dgst_pos0 = 3;
7065 dgst_pos1 = 4;
7066 dgst_pos2 = 2;
7067 dgst_pos3 = 1;
7068 break;
7069
7070 case 101: hash_type = HASH_TYPE_SHA1;
7071 salt_type = SALT_TYPE_NONE;
7072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7073 opts_type = OPTS_TYPE_PT_GENERATE_BE
7074 | OPTS_TYPE_PT_ADD80
7075 | OPTS_TYPE_PT_ADDBITS15;
7076 kern_type = KERN_TYPE_SHA1;
7077 dgst_size = DGST_SIZE_4_5;
7078 parse_func = sha1b64_parse_hash;
7079 sort_by_digest = sort_by_digest_4_5;
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_NOT_SALTED
7086 | OPTI_TYPE_RAW_HASH;
7087 dgst_pos0 = 3;
7088 dgst_pos1 = 4;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 110: hash_type = HASH_TYPE_SHA1;
7094 salt_type = SALT_TYPE_INTERN;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_BE
7097 | OPTS_TYPE_ST_ADD80
7098 | OPTS_TYPE_ST_ADDBITS15;
7099 kern_type = KERN_TYPE_SHA1_PWSLT;
7100 dgst_size = DGST_SIZE_4_5;
7101 parse_func = sha1s_parse_hash;
7102 sort_by_digest = sort_by_digest_4_5;
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_APPENDED_SALT
7109 | OPTI_TYPE_RAW_HASH;
7110 dgst_pos0 = 3;
7111 dgst_pos1 = 4;
7112 dgst_pos2 = 2;
7113 dgst_pos3 = 1;
7114 break;
7115
7116 case 111: hash_type = HASH_TYPE_SHA1;
7117 salt_type = SALT_TYPE_EMBEDDED;
7118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7119 opts_type = OPTS_TYPE_PT_GENERATE_BE
7120 | OPTS_TYPE_ST_ADD80
7121 | OPTS_TYPE_ST_ADDBITS15;
7122 kern_type = KERN_TYPE_SHA1_PWSLT;
7123 dgst_size = DGST_SIZE_4_5;
7124 parse_func = sha1b64s_parse_hash;
7125 sort_by_digest = sort_by_digest_4_5;
7126 opti_type = OPTI_TYPE_ZERO_BYTE
7127 | OPTI_TYPE_PRECOMPUTE_INIT
7128 | OPTI_TYPE_PRECOMPUTE_MERKLE
7129 | OPTI_TYPE_EARLY_SKIP
7130 | OPTI_TYPE_NOT_ITERATED
7131 | OPTI_TYPE_APPENDED_SALT
7132 | OPTI_TYPE_RAW_HASH;
7133 dgst_pos0 = 3;
7134 dgst_pos1 = 4;
7135 dgst_pos2 = 2;
7136 dgst_pos3 = 1;
7137 break;
7138
7139 case 112: hash_type = HASH_TYPE_SHA1;
7140 salt_type = SALT_TYPE_INTERN;
7141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7142 opts_type = OPTS_TYPE_PT_GENERATE_BE
7143 | OPTS_TYPE_ST_ADD80
7144 | OPTS_TYPE_ST_ADDBITS15
7145 | OPTS_TYPE_ST_HEX;
7146 kern_type = KERN_TYPE_SHA1_PWSLT;
7147 dgst_size = DGST_SIZE_4_5;
7148 parse_func = oracles_parse_hash;
7149 sort_by_digest = sort_by_digest_4_5;
7150 opti_type = OPTI_TYPE_ZERO_BYTE
7151 | OPTI_TYPE_PRECOMPUTE_INIT
7152 | OPTI_TYPE_PRECOMPUTE_MERKLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED
7155 | OPTI_TYPE_APPENDED_SALT
7156 | OPTI_TYPE_RAW_HASH;
7157 dgst_pos0 = 3;
7158 dgst_pos1 = 4;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 120: hash_type = HASH_TYPE_SHA1;
7164 salt_type = SALT_TYPE_INTERN;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_BE
7167 | OPTS_TYPE_PT_ADD80
7168 | OPTS_TYPE_PT_ADDBITS15;
7169 kern_type = KERN_TYPE_SHA1_SLTPW;
7170 dgst_size = DGST_SIZE_4_5;
7171 parse_func = sha1s_parse_hash;
7172 sort_by_digest = sort_by_digest_4_5;
7173 opti_type = OPTI_TYPE_ZERO_BYTE
7174 | OPTI_TYPE_PRECOMPUTE_INIT
7175 | OPTI_TYPE_PRECOMPUTE_MERKLE
7176 | OPTI_TYPE_EARLY_SKIP
7177 | OPTI_TYPE_NOT_ITERATED
7178 | OPTI_TYPE_PREPENDED_SALT
7179 | OPTI_TYPE_RAW_HASH;
7180 dgst_pos0 = 3;
7181 dgst_pos1 = 4;
7182 dgst_pos2 = 2;
7183 dgst_pos3 = 1;
7184 break;
7185
7186 case 121: hash_type = HASH_TYPE_SHA1;
7187 salt_type = SALT_TYPE_INTERN;
7188 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7189 opts_type = OPTS_TYPE_PT_GENERATE_BE
7190 | OPTS_TYPE_PT_ADD80
7191 | OPTS_TYPE_PT_ADDBITS15
7192 | OPTS_TYPE_ST_LOWER;
7193 kern_type = KERN_TYPE_SHA1_SLTPW;
7194 dgst_size = DGST_SIZE_4_5;
7195 parse_func = smf_parse_hash;
7196 sort_by_digest = sort_by_digest_4_5;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_PRECOMPUTE_INIT
7199 | OPTI_TYPE_PRECOMPUTE_MERKLE
7200 | OPTI_TYPE_EARLY_SKIP
7201 | OPTI_TYPE_NOT_ITERATED
7202 | OPTI_TYPE_PREPENDED_SALT
7203 | OPTI_TYPE_RAW_HASH;
7204 dgst_pos0 = 3;
7205 dgst_pos1 = 4;
7206 dgst_pos2 = 2;
7207 dgst_pos3 = 1;
7208 break;
7209
7210 case 122: hash_type = HASH_TYPE_SHA1;
7211 salt_type = SALT_TYPE_EMBEDDED;
7212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7213 opts_type = OPTS_TYPE_PT_GENERATE_BE
7214 | OPTS_TYPE_PT_ADD80
7215 | OPTS_TYPE_PT_ADDBITS15
7216 | OPTS_TYPE_ST_HEX;
7217 kern_type = KERN_TYPE_SHA1_SLTPW;
7218 dgst_size = DGST_SIZE_4_5;
7219 parse_func = osx1_parse_hash;
7220 sort_by_digest = sort_by_digest_4_5;
7221 opti_type = OPTI_TYPE_ZERO_BYTE
7222 | OPTI_TYPE_PRECOMPUTE_INIT
7223 | OPTI_TYPE_PRECOMPUTE_MERKLE
7224 | OPTI_TYPE_EARLY_SKIP
7225 | OPTI_TYPE_NOT_ITERATED
7226 | OPTI_TYPE_PREPENDED_SALT
7227 | OPTI_TYPE_RAW_HASH;
7228 dgst_pos0 = 3;
7229 dgst_pos1 = 4;
7230 dgst_pos2 = 2;
7231 dgst_pos3 = 1;
7232 break;
7233
7234 case 124: hash_type = HASH_TYPE_SHA1;
7235 salt_type = SALT_TYPE_EMBEDDED;
7236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7237 opts_type = OPTS_TYPE_PT_GENERATE_BE
7238 | OPTS_TYPE_PT_ADD80
7239 | OPTS_TYPE_PT_ADDBITS15;
7240 kern_type = KERN_TYPE_SHA1_SLTPW;
7241 dgst_size = DGST_SIZE_4_5;
7242 parse_func = djangosha1_parse_hash;
7243 sort_by_digest = sort_by_digest_4_5;
7244 opti_type = OPTI_TYPE_ZERO_BYTE
7245 | OPTI_TYPE_PRECOMPUTE_INIT
7246 | OPTI_TYPE_PRECOMPUTE_MERKLE
7247 | OPTI_TYPE_EARLY_SKIP
7248 | OPTI_TYPE_NOT_ITERATED
7249 | OPTI_TYPE_PREPENDED_SALT
7250 | OPTI_TYPE_RAW_HASH;
7251 dgst_pos0 = 3;
7252 dgst_pos1 = 4;
7253 dgst_pos2 = 2;
7254 dgst_pos3 = 1;
7255 break;
7256
7257 case 130: hash_type = HASH_TYPE_SHA1;
7258 salt_type = SALT_TYPE_INTERN;
7259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7260 opts_type = OPTS_TYPE_PT_GENERATE_BE
7261 | OPTS_TYPE_PT_UNICODE
7262 | OPTS_TYPE_ST_ADD80
7263 | OPTS_TYPE_ST_ADDBITS15;
7264 kern_type = KERN_TYPE_SHA1_PWUSLT;
7265 dgst_size = DGST_SIZE_4_5;
7266 parse_func = sha1s_parse_hash;
7267 sort_by_digest = sort_by_digest_4_5;
7268 opti_type = OPTI_TYPE_ZERO_BYTE
7269 | OPTI_TYPE_PRECOMPUTE_INIT
7270 | OPTI_TYPE_PRECOMPUTE_MERKLE
7271 | OPTI_TYPE_EARLY_SKIP
7272 | OPTI_TYPE_NOT_ITERATED
7273 | OPTI_TYPE_APPENDED_SALT
7274 | OPTI_TYPE_RAW_HASH;
7275 dgst_pos0 = 3;
7276 dgst_pos1 = 4;
7277 dgst_pos2 = 2;
7278 dgst_pos3 = 1;
7279 break;
7280
7281 case 131: hash_type = HASH_TYPE_SHA1;
7282 salt_type = SALT_TYPE_EMBEDDED;
7283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7284 opts_type = OPTS_TYPE_PT_GENERATE_BE
7285 | OPTS_TYPE_PT_UNICODE
7286 | OPTS_TYPE_PT_UPPER
7287 | OPTS_TYPE_ST_ADD80
7288 | OPTS_TYPE_ST_ADDBITS15
7289 | OPTS_TYPE_ST_HEX;
7290 kern_type = KERN_TYPE_SHA1_PWUSLT;
7291 dgst_size = DGST_SIZE_4_5;
7292 parse_func = mssql2000_parse_hash;
7293 sort_by_digest = sort_by_digest_4_5;
7294 opti_type = OPTI_TYPE_ZERO_BYTE
7295 | OPTI_TYPE_PRECOMPUTE_INIT
7296 | OPTI_TYPE_PRECOMPUTE_MERKLE
7297 | OPTI_TYPE_EARLY_SKIP
7298 | OPTI_TYPE_NOT_ITERATED
7299 | OPTI_TYPE_APPENDED_SALT
7300 | OPTI_TYPE_RAW_HASH;
7301 dgst_pos0 = 3;
7302 dgst_pos1 = 4;
7303 dgst_pos2 = 2;
7304 dgst_pos3 = 1;
7305 break;
7306
7307 case 132: hash_type = HASH_TYPE_SHA1;
7308 salt_type = SALT_TYPE_EMBEDDED;
7309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7310 opts_type = OPTS_TYPE_PT_GENERATE_BE
7311 | OPTS_TYPE_PT_UNICODE
7312 | OPTS_TYPE_ST_ADD80
7313 | OPTS_TYPE_ST_ADDBITS15
7314 | OPTS_TYPE_ST_HEX;
7315 kern_type = KERN_TYPE_SHA1_PWUSLT;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = mssql2005_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_APPENDED_SALT
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 133: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_EMBEDDED;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_UNICODE
7337 | OPTS_TYPE_ST_ADD80
7338 | OPTS_TYPE_ST_ADDBITS15;
7339 kern_type = KERN_TYPE_SHA1_PWUSLT;
7340 dgst_size = DGST_SIZE_4_5;
7341 parse_func = peoplesoft_parse_hash;
7342 sort_by_digest = sort_by_digest_4_5;
7343 opti_type = OPTI_TYPE_ZERO_BYTE
7344 | OPTI_TYPE_PRECOMPUTE_INIT
7345 | OPTI_TYPE_PRECOMPUTE_MERKLE
7346 | OPTI_TYPE_EARLY_SKIP
7347 | OPTI_TYPE_NOT_ITERATED
7348 | OPTI_TYPE_APPENDED_SALT
7349 | OPTI_TYPE_RAW_HASH;
7350 dgst_pos0 = 3;
7351 dgst_pos1 = 4;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 140: hash_type = HASH_TYPE_SHA1;
7357 salt_type = SALT_TYPE_INTERN;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_PT_ADD80
7361 | OPTS_TYPE_PT_ADDBITS15
7362 | OPTS_TYPE_PT_UNICODE;
7363 kern_type = KERN_TYPE_SHA1_SLTPWU;
7364 dgst_size = DGST_SIZE_4_5;
7365 parse_func = sha1s_parse_hash;
7366 sort_by_digest = sort_by_digest_4_5;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_EARLY_SKIP
7371 | OPTI_TYPE_NOT_ITERATED
7372 | OPTI_TYPE_PREPENDED_SALT
7373 | OPTI_TYPE_RAW_HASH;
7374 dgst_pos0 = 3;
7375 dgst_pos1 = 4;
7376 dgst_pos2 = 2;
7377 dgst_pos3 = 1;
7378 break;
7379
7380 case 141: hash_type = HASH_TYPE_SHA1;
7381 salt_type = SALT_TYPE_EMBEDDED;
7382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7383 opts_type = OPTS_TYPE_PT_GENERATE_BE
7384 | OPTS_TYPE_PT_ADD80
7385 | OPTS_TYPE_PT_ADDBITS15
7386 | OPTS_TYPE_PT_UNICODE
7387 | OPTS_TYPE_ST_BASE64;
7388 kern_type = KERN_TYPE_SHA1_SLTPWU;
7389 dgst_size = DGST_SIZE_4_5;
7390 parse_func = episerver_parse_hash;
7391 sort_by_digest = sort_by_digest_4_5;
7392 opti_type = OPTI_TYPE_ZERO_BYTE
7393 | OPTI_TYPE_PRECOMPUTE_INIT
7394 | OPTI_TYPE_PRECOMPUTE_MERKLE
7395 | OPTI_TYPE_EARLY_SKIP
7396 | OPTI_TYPE_NOT_ITERATED
7397 | OPTI_TYPE_PREPENDED_SALT
7398 | OPTI_TYPE_RAW_HASH;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 150: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_INTERN;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_ST_ADD80
7410 | OPTS_TYPE_ST_ADDBITS15;
7411 kern_type = KERN_TYPE_HMACSHA1_PW;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = hmacsha1_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_NOT_ITERATED;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 160: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_PT_ADD80
7428 | OPTS_TYPE_PT_ADDBITS15;
7429 kern_type = KERN_TYPE_HMACSHA1_SLT;
7430 dgst_size = DGST_SIZE_4_5;
7431 parse_func = hmacsha1_parse_hash;
7432 sort_by_digest = sort_by_digest_4_5;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_NOT_ITERATED;
7435 dgst_pos0 = 3;
7436 dgst_pos1 = 4;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 1;
7439 break;
7440
7441 case 190: hash_type = HASH_TYPE_SHA1;
7442 salt_type = SALT_TYPE_NONE;
7443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7444 opts_type = OPTS_TYPE_PT_GENERATE_BE
7445 | OPTS_TYPE_PT_ADD80
7446 | OPTS_TYPE_PT_ADDBITS15;
7447 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7448 dgst_size = DGST_SIZE_4_5;
7449 parse_func = sha1linkedin_parse_hash;
7450 sort_by_digest = sort_by_digest_4_5;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_EARLY_SKIP
7454 | OPTI_TYPE_NOT_ITERATED
7455 | OPTI_TYPE_NOT_SALTED;
7456 dgst_pos0 = 0;
7457 dgst_pos1 = 4;
7458 dgst_pos2 = 3;
7459 dgst_pos3 = 2;
7460 break;
7461
7462 case 200: hash_type = HASH_TYPE_MYSQL;
7463 salt_type = SALT_TYPE_NONE;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = 0;
7466 kern_type = KERN_TYPE_MYSQL;
7467 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7468 parse_func = mysql323_parse_hash;
7469 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7470 opti_type = OPTI_TYPE_ZERO_BYTE;
7471 dgst_pos0 = 0;
7472 dgst_pos1 = 1;
7473 dgst_pos2 = 2;
7474 dgst_pos3 = 3;
7475 break;
7476
7477 case 300: hash_type = HASH_TYPE_SHA1;
7478 salt_type = SALT_TYPE_NONE;
7479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7480 opts_type = OPTS_TYPE_PT_GENERATE_BE
7481 | OPTS_TYPE_PT_ADD80
7482 | OPTS_TYPE_PT_ADDBITS15;
7483 kern_type = KERN_TYPE_MYSQL41;
7484 dgst_size = DGST_SIZE_4_5;
7485 parse_func = sha1_parse_hash;
7486 sort_by_digest = sort_by_digest_4_5;
7487 opti_type = OPTI_TYPE_ZERO_BYTE
7488 | OPTI_TYPE_PRECOMPUTE_INIT
7489 | OPTI_TYPE_PRECOMPUTE_MERKLE
7490 | OPTI_TYPE_EARLY_SKIP
7491 | OPTI_TYPE_NOT_ITERATED
7492 | OPTI_TYPE_NOT_SALTED;
7493 dgst_pos0 = 3;
7494 dgst_pos1 = 4;
7495 dgst_pos2 = 2;
7496 dgst_pos3 = 1;
7497 break;
7498
7499 case 400: hash_type = HASH_TYPE_MD5;
7500 salt_type = SALT_TYPE_EMBEDDED;
7501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7503 kern_type = KERN_TYPE_PHPASS;
7504 dgst_size = DGST_SIZE_4_4;
7505 parse_func = phpass_parse_hash;
7506 sort_by_digest = sort_by_digest_4_4;
7507 opti_type = OPTI_TYPE_ZERO_BYTE;
7508 dgst_pos0 = 0;
7509 dgst_pos1 = 1;
7510 dgst_pos2 = 2;
7511 dgst_pos3 = 3;
7512 break;
7513
7514 case 500: hash_type = HASH_TYPE_MD5;
7515 salt_type = SALT_TYPE_EMBEDDED;
7516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7518 kern_type = KERN_TYPE_MD5CRYPT;
7519 dgst_size = DGST_SIZE_4_4;
7520 parse_func = md5crypt_parse_hash;
7521 sort_by_digest = sort_by_digest_4_4;
7522 opti_type = OPTI_TYPE_ZERO_BYTE;
7523 dgst_pos0 = 0;
7524 dgst_pos1 = 1;
7525 dgst_pos2 = 2;
7526 dgst_pos3 = 3;
7527 break;
7528
7529 case 501: hash_type = HASH_TYPE_MD5;
7530 salt_type = SALT_TYPE_EMBEDDED;
7531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7532 opts_type = OPTS_TYPE_PT_GENERATE_LE
7533 | OPTS_TYPE_HASH_COPY;
7534 kern_type = KERN_TYPE_MD5CRYPT;
7535 dgst_size = DGST_SIZE_4_4;
7536 parse_func = juniper_parse_hash;
7537 sort_by_digest = sort_by_digest_4_4;
7538 opti_type = OPTI_TYPE_ZERO_BYTE;
7539 dgst_pos0 = 0;
7540 dgst_pos1 = 1;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 3;
7543 break;
7544
7545 case 900: hash_type = HASH_TYPE_MD4;
7546 salt_type = SALT_TYPE_NONE;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_LE
7549 | OPTS_TYPE_PT_ADD80
7550 | OPTS_TYPE_PT_ADDBITS14;
7551 kern_type = KERN_TYPE_MD4;
7552 dgst_size = DGST_SIZE_4_4;
7553 parse_func = md4_parse_hash;
7554 sort_by_digest = sort_by_digest_4_4;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_PRECOMPUTE_INIT
7557 | OPTI_TYPE_PRECOMPUTE_MERKLE
7558 | OPTI_TYPE_MEET_IN_MIDDLE
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_NOT_SALTED
7562 | OPTI_TYPE_RAW_HASH;
7563 dgst_pos0 = 0;
7564 dgst_pos1 = 3;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 1000: hash_type = HASH_TYPE_MD4;
7570 salt_type = SALT_TYPE_NONE;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_LE
7573 | OPTS_TYPE_PT_ADD80
7574 | OPTS_TYPE_PT_ADDBITS14
7575 | OPTS_TYPE_PT_UNICODE;
7576 kern_type = KERN_TYPE_MD4_PWU;
7577 dgst_size = DGST_SIZE_4_4;
7578 parse_func = md4_parse_hash;
7579 sort_by_digest = sort_by_digest_4_4;
7580 opti_type = OPTI_TYPE_ZERO_BYTE
7581 | OPTI_TYPE_PRECOMPUTE_INIT
7582 | OPTI_TYPE_PRECOMPUTE_MERKLE
7583 | OPTI_TYPE_MEET_IN_MIDDLE
7584 | OPTI_TYPE_EARLY_SKIP
7585 | OPTI_TYPE_NOT_ITERATED
7586 | OPTI_TYPE_NOT_SALTED
7587 | OPTI_TYPE_RAW_HASH;
7588 dgst_pos0 = 0;
7589 dgst_pos1 = 3;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 1;
7592 break;
7593
7594 case 1100: hash_type = HASH_TYPE_MD4;
7595 salt_type = SALT_TYPE_INTERN;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_LE
7598 | OPTS_TYPE_PT_ADD80
7599 | OPTS_TYPE_PT_ADDBITS14
7600 | OPTS_TYPE_PT_UNICODE
7601 | OPTS_TYPE_ST_ADD80
7602 | OPTS_TYPE_ST_UNICODE
7603 | OPTS_TYPE_ST_LOWER;
7604 kern_type = KERN_TYPE_MD44_PWUSLT;
7605 dgst_size = DGST_SIZE_4_4;
7606 parse_func = dcc_parse_hash;
7607 sort_by_digest = sort_by_digest_4_4;
7608 opti_type = OPTI_TYPE_ZERO_BYTE
7609 | OPTI_TYPE_PRECOMPUTE_INIT
7610 | OPTI_TYPE_PRECOMPUTE_MERKLE
7611 | OPTI_TYPE_EARLY_SKIP
7612 | OPTI_TYPE_NOT_ITERATED;
7613 dgst_pos0 = 0;
7614 dgst_pos1 = 3;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 1;
7617 break;
7618
7619 case 1400: hash_type = HASH_TYPE_SHA256;
7620 salt_type = SALT_TYPE_NONE;
7621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_BE
7623 | OPTS_TYPE_PT_ADD80
7624 | OPTS_TYPE_PT_ADDBITS15;
7625 kern_type = KERN_TYPE_SHA256;
7626 dgst_size = DGST_SIZE_4_8;
7627 parse_func = sha256_parse_hash;
7628 sort_by_digest = sort_by_digest_4_8;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_NOT_SALTED
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 3;
7637 dgst_pos1 = 7;
7638 dgst_pos2 = 2;
7639 dgst_pos3 = 6;
7640 break;
7641
7642 case 1410: hash_type = HASH_TYPE_SHA256;
7643 salt_type = SALT_TYPE_INTERN;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_BE
7646 | OPTS_TYPE_ST_ADD80
7647 | OPTS_TYPE_ST_ADDBITS15;
7648 kern_type = KERN_TYPE_SHA256_PWSLT;
7649 dgst_size = DGST_SIZE_4_8;
7650 parse_func = sha256s_parse_hash;
7651 sort_by_digest = sort_by_digest_4_8;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED
7657 | OPTI_TYPE_APPENDED_SALT
7658 | OPTI_TYPE_RAW_HASH;
7659 dgst_pos0 = 3;
7660 dgst_pos1 = 7;
7661 dgst_pos2 = 2;
7662 dgst_pos3 = 6;
7663 break;
7664
7665 case 1420: hash_type = HASH_TYPE_SHA256;
7666 salt_type = SALT_TYPE_INTERN;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_BE
7669 | OPTS_TYPE_PT_ADD80
7670 | OPTS_TYPE_PT_ADDBITS15;
7671 kern_type = KERN_TYPE_SHA256_SLTPW;
7672 dgst_size = DGST_SIZE_4_8;
7673 parse_func = sha256s_parse_hash;
7674 sort_by_digest = sort_by_digest_4_8;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 7;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 6;
7686 break;
7687
7688 case 1421: hash_type = HASH_TYPE_SHA256;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15;
7694 kern_type = KERN_TYPE_SHA256_SLTPW;
7695 dgst_size = DGST_SIZE_4_8;
7696 parse_func = hmailserver_parse_hash;
7697 sort_by_digest = sort_by_digest_4_8;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_PRECOMPUTE_INIT
7700 | OPTI_TYPE_PRECOMPUTE_MERKLE
7701 | OPTI_TYPE_EARLY_SKIP
7702 | OPTI_TYPE_NOT_ITERATED
7703 | OPTI_TYPE_PREPENDED_SALT
7704 | OPTI_TYPE_RAW_HASH;
7705 dgst_pos0 = 3;
7706 dgst_pos1 = 7;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 6;
7709 break;
7710
7711 case 1430: hash_type = HASH_TYPE_SHA256;
7712 salt_type = SALT_TYPE_INTERN;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_UNICODE
7716 | OPTS_TYPE_ST_ADD80
7717 | OPTS_TYPE_ST_ADDBITS15;
7718 kern_type = KERN_TYPE_SHA256_PWUSLT;
7719 dgst_size = DGST_SIZE_4_8;
7720 parse_func = sha256s_parse_hash;
7721 sort_by_digest = sort_by_digest_4_8;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_PRECOMPUTE_INIT
7724 | OPTI_TYPE_PRECOMPUTE_MERKLE
7725 | OPTI_TYPE_EARLY_SKIP
7726 | OPTI_TYPE_NOT_ITERATED
7727 | OPTI_TYPE_APPENDED_SALT
7728 | OPTI_TYPE_RAW_HASH;
7729 dgst_pos0 = 3;
7730 dgst_pos1 = 7;
7731 dgst_pos2 = 2;
7732 dgst_pos3 = 6;
7733 break;
7734
7735 case 1440: hash_type = HASH_TYPE_SHA256;
7736 salt_type = SALT_TYPE_INTERN;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_BE
7739 | OPTS_TYPE_PT_ADD80
7740 | OPTS_TYPE_PT_ADDBITS15
7741 | OPTS_TYPE_PT_UNICODE;
7742 kern_type = KERN_TYPE_SHA256_SLTPWU;
7743 dgst_size = DGST_SIZE_4_8;
7744 parse_func = sha256s_parse_hash;
7745 sort_by_digest = sort_by_digest_4_8;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_PREPENDED_SALT
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 3;
7754 dgst_pos1 = 7;
7755 dgst_pos2 = 2;
7756 dgst_pos3 = 6;
7757 break;
7758
7759 case 1441: hash_type = HASH_TYPE_SHA256;
7760 salt_type = SALT_TYPE_EMBEDDED;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_PT_ADD80
7764 | OPTS_TYPE_PT_ADDBITS15
7765 | OPTS_TYPE_PT_UNICODE
7766 | OPTS_TYPE_ST_BASE64;
7767 kern_type = KERN_TYPE_SHA256_SLTPWU;
7768 dgst_size = DGST_SIZE_4_8;
7769 parse_func = episerver4_parse_hash;
7770 sort_by_digest = sort_by_digest_4_8;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_PREPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 7;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 6;
7782 break;
7783
7784 case 1450: hash_type = HASH_TYPE_SHA256;
7785 salt_type = SALT_TYPE_INTERN;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_ST_ADD80;
7789 kern_type = KERN_TYPE_HMACSHA256_PW;
7790 dgst_size = DGST_SIZE_4_8;
7791 parse_func = hmacsha256_parse_hash;
7792 sort_by_digest = sort_by_digest_4_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_NOT_ITERATED;
7795 dgst_pos0 = 3;
7796 dgst_pos1 = 7;
7797 dgst_pos2 = 2;
7798 dgst_pos3 = 6;
7799 break;
7800
7801 case 1460: hash_type = HASH_TYPE_SHA256;
7802 salt_type = SALT_TYPE_INTERN;
7803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_BE
7805 | OPTS_TYPE_PT_ADD80
7806 | OPTS_TYPE_PT_ADDBITS15;
7807 kern_type = KERN_TYPE_HMACSHA256_SLT;
7808 dgst_size = DGST_SIZE_4_8;
7809 parse_func = hmacsha256_parse_hash;
7810 sort_by_digest = sort_by_digest_4_8;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_NOT_ITERATED;
7813 dgst_pos0 = 3;
7814 dgst_pos1 = 7;
7815 dgst_pos2 = 2;
7816 dgst_pos3 = 6;
7817 break;
7818
7819 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7820 salt_type = SALT_TYPE_EMBEDDED;
7821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7822 opts_type = OPTS_TYPE_PT_GENERATE_LE
7823 | OPTS_TYPE_PT_BITSLICE;
7824 kern_type = KERN_TYPE_DESCRYPT;
7825 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7826 parse_func = descrypt_parse_hash;
7827 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7828 opti_type = OPTI_TYPE_ZERO_BYTE
7829 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7830 dgst_pos0 = 0;
7831 dgst_pos1 = 1;
7832 dgst_pos2 = 2;
7833 dgst_pos3 = 3;
7834 break;
7835
7836 case 1600: hash_type = HASH_TYPE_MD5;
7837 salt_type = SALT_TYPE_EMBEDDED;
7838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7839 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7840 kern_type = KERN_TYPE_APR1CRYPT;
7841 dgst_size = DGST_SIZE_4_4;
7842 parse_func = md5apr1_parse_hash;
7843 sort_by_digest = sort_by_digest_4_4;
7844 opti_type = OPTI_TYPE_ZERO_BYTE;
7845 dgst_pos0 = 0;
7846 dgst_pos1 = 1;
7847 dgst_pos2 = 2;
7848 dgst_pos3 = 3;
7849 break;
7850
7851 case 1700: hash_type = HASH_TYPE_SHA512;
7852 salt_type = SALT_TYPE_NONE;
7853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7854 opts_type = OPTS_TYPE_PT_GENERATE_BE
7855 | OPTS_TYPE_PT_ADD80
7856 | OPTS_TYPE_PT_ADDBITS15;
7857 kern_type = KERN_TYPE_SHA512;
7858 dgst_size = DGST_SIZE_8_8;
7859 parse_func = sha512_parse_hash;
7860 sort_by_digest = sort_by_digest_8_8;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED
7866 | OPTI_TYPE_NOT_SALTED
7867 | OPTI_TYPE_USES_BITS_64
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 14;
7870 dgst_pos1 = 15;
7871 dgst_pos2 = 6;
7872 dgst_pos3 = 7;
7873 break;
7874
7875 case 1710: hash_type = HASH_TYPE_SHA512;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_ST_ADD80
7880 | OPTS_TYPE_ST_ADDBITS15;
7881 kern_type = KERN_TYPE_SHA512_PWSLT;
7882 dgst_size = DGST_SIZE_8_8;
7883 parse_func = sha512s_parse_hash;
7884 sort_by_digest = sort_by_digest_8_8;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_PRECOMPUTE_INIT
7887 | OPTI_TYPE_PRECOMPUTE_MERKLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_APPENDED_SALT
7891 | OPTI_TYPE_USES_BITS_64
7892 | OPTI_TYPE_RAW_HASH;
7893 dgst_pos0 = 14;
7894 dgst_pos1 = 15;
7895 dgst_pos2 = 6;
7896 dgst_pos3 = 7;
7897 break;
7898
7899 case 1711: hash_type = HASH_TYPE_SHA512;
7900 salt_type = SALT_TYPE_EMBEDDED;
7901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7902 opts_type = OPTS_TYPE_PT_GENERATE_BE
7903 | OPTS_TYPE_ST_ADD80
7904 | OPTS_TYPE_ST_ADDBITS15;
7905 kern_type = KERN_TYPE_SHA512_PWSLT;
7906 dgst_size = DGST_SIZE_8_8;
7907 parse_func = sha512b64s_parse_hash;
7908 sort_by_digest = sort_by_digest_8_8;
7909 opti_type = OPTI_TYPE_ZERO_BYTE
7910 | OPTI_TYPE_PRECOMPUTE_INIT
7911 | OPTI_TYPE_PRECOMPUTE_MERKLE
7912 | OPTI_TYPE_EARLY_SKIP
7913 | OPTI_TYPE_NOT_ITERATED
7914 | OPTI_TYPE_APPENDED_SALT
7915 | OPTI_TYPE_USES_BITS_64
7916 | OPTI_TYPE_RAW_HASH;
7917 dgst_pos0 = 14;
7918 dgst_pos1 = 15;
7919 dgst_pos2 = 6;
7920 dgst_pos3 = 7;
7921 break;
7922
7923 case 1720: hash_type = HASH_TYPE_SHA512;
7924 salt_type = SALT_TYPE_INTERN;
7925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_BE
7927 | OPTS_TYPE_PT_ADD80
7928 | OPTS_TYPE_PT_ADDBITS15;
7929 kern_type = KERN_TYPE_SHA512_SLTPW;
7930 dgst_size = DGST_SIZE_8_8;
7931 parse_func = sha512s_parse_hash;
7932 sort_by_digest = sort_by_digest_8_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_INIT
7935 | OPTI_TYPE_PRECOMPUTE_MERKLE
7936 | OPTI_TYPE_EARLY_SKIP
7937 | OPTI_TYPE_NOT_ITERATED
7938 | OPTI_TYPE_PREPENDED_SALT
7939 | OPTI_TYPE_USES_BITS_64
7940 | OPTI_TYPE_RAW_HASH;
7941 dgst_pos0 = 14;
7942 dgst_pos1 = 15;
7943 dgst_pos2 = 6;
7944 dgst_pos3 = 7;
7945 break;
7946
7947 case 1722: hash_type = HASH_TYPE_SHA512;
7948 salt_type = SALT_TYPE_EMBEDDED;
7949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7950 opts_type = OPTS_TYPE_PT_GENERATE_BE
7951 | OPTS_TYPE_PT_ADD80
7952 | OPTS_TYPE_PT_ADDBITS15
7953 | OPTS_TYPE_ST_HEX;
7954 kern_type = KERN_TYPE_SHA512_SLTPW;
7955 dgst_size = DGST_SIZE_8_8;
7956 parse_func = osx512_parse_hash;
7957 sort_by_digest = sort_by_digest_8_8;
7958 opti_type = OPTI_TYPE_ZERO_BYTE
7959 | OPTI_TYPE_PRECOMPUTE_INIT
7960 | OPTI_TYPE_PRECOMPUTE_MERKLE
7961 | OPTI_TYPE_EARLY_SKIP
7962 | OPTI_TYPE_NOT_ITERATED
7963 | OPTI_TYPE_PREPENDED_SALT
7964 | OPTI_TYPE_USES_BITS_64
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 14;
7967 dgst_pos1 = 15;
7968 dgst_pos2 = 6;
7969 dgst_pos3 = 7;
7970 break;
7971
7972 case 1730: hash_type = HASH_TYPE_SHA512;
7973 salt_type = SALT_TYPE_INTERN;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_UNICODE
7977 | OPTS_TYPE_ST_ADD80
7978 | OPTS_TYPE_ST_ADDBITS15;
7979 kern_type = KERN_TYPE_SHA512_PWSLTU;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = sha512s_parse_hash;
7982 sort_by_digest = sort_by_digest_8_8;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_PRECOMPUTE_INIT
7985 | OPTI_TYPE_PRECOMPUTE_MERKLE
7986 | OPTI_TYPE_EARLY_SKIP
7987 | OPTI_TYPE_NOT_ITERATED
7988 | OPTI_TYPE_APPENDED_SALT
7989 | OPTI_TYPE_USES_BITS_64
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 14;
7992 dgst_pos1 = 15;
7993 dgst_pos2 = 6;
7994 dgst_pos3 = 7;
7995 break;
7996
7997 case 1731: hash_type = HASH_TYPE_SHA512;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_UNICODE
8002 | OPTS_TYPE_ST_ADD80
8003 | OPTS_TYPE_ST_ADDBITS15
8004 | OPTS_TYPE_ST_HEX;
8005 kern_type = KERN_TYPE_SHA512_PWSLTU;
8006 dgst_size = DGST_SIZE_8_8;
8007 parse_func = mssql2012_parse_hash;
8008 sort_by_digest = sort_by_digest_8_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_APPENDED_SALT
8015 | OPTI_TYPE_USES_BITS_64
8016 | OPTI_TYPE_RAW_HASH;
8017 dgst_pos0 = 14;
8018 dgst_pos1 = 15;
8019 dgst_pos2 = 6;
8020 dgst_pos3 = 7;
8021 break;
8022
8023 case 1740: hash_type = HASH_TYPE_SHA512;
8024 salt_type = SALT_TYPE_INTERN;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_BE
8027 | OPTS_TYPE_PT_ADD80
8028 | OPTS_TYPE_PT_ADDBITS15
8029 | OPTS_TYPE_PT_UNICODE;
8030 kern_type = KERN_TYPE_SHA512_SLTPWU;
8031 dgst_size = DGST_SIZE_8_8;
8032 parse_func = sha512s_parse_hash;
8033 sort_by_digest = sort_by_digest_8_8;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP
8038 | OPTI_TYPE_NOT_ITERATED
8039 | OPTI_TYPE_PREPENDED_SALT
8040 | OPTI_TYPE_USES_BITS_64
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 14;
8043 dgst_pos1 = 15;
8044 dgst_pos2 = 6;
8045 dgst_pos3 = 7;
8046 break;
8047
8048 case 1750: hash_type = HASH_TYPE_SHA512;
8049 salt_type = SALT_TYPE_INTERN;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_ST_ADD80;
8053 kern_type = KERN_TYPE_HMACSHA512_PW;
8054 dgst_size = DGST_SIZE_8_8;
8055 parse_func = hmacsha512_parse_hash;
8056 sort_by_digest = sort_by_digest_8_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_USES_BITS_64
8059 | OPTI_TYPE_NOT_ITERATED;
8060 dgst_pos0 = 14;
8061 dgst_pos1 = 15;
8062 dgst_pos2 = 6;
8063 dgst_pos3 = 7;
8064 break;
8065
8066 case 1760: hash_type = HASH_TYPE_SHA512;
8067 salt_type = SALT_TYPE_INTERN;
8068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8069 opts_type = OPTS_TYPE_PT_GENERATE_BE
8070 | OPTS_TYPE_PT_ADD80
8071 | OPTS_TYPE_PT_ADDBITS15;
8072 kern_type = KERN_TYPE_HMACSHA512_SLT;
8073 dgst_size = DGST_SIZE_8_8;
8074 parse_func = hmacsha512_parse_hash;
8075 sort_by_digest = sort_by_digest_8_8;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_USES_BITS_64
8078 | OPTI_TYPE_NOT_ITERATED;
8079 dgst_pos0 = 14;
8080 dgst_pos1 = 15;
8081 dgst_pos2 = 6;
8082 dgst_pos3 = 7;
8083 break;
8084
8085 case 1800: hash_type = HASH_TYPE_SHA512;
8086 salt_type = SALT_TYPE_EMBEDDED;
8087 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8089 kern_type = KERN_TYPE_SHA512CRYPT;
8090 dgst_size = DGST_SIZE_8_8;
8091 parse_func = sha512crypt_parse_hash;
8092 sort_by_digest = sort_by_digest_8_8;
8093 opti_type = OPTI_TYPE_ZERO_BYTE
8094 | OPTI_TYPE_USES_BITS_64;
8095 dgst_pos0 = 0;
8096 dgst_pos1 = 1;
8097 dgst_pos2 = 2;
8098 dgst_pos3 = 3;
8099 break;
8100
8101 case 2100: hash_type = HASH_TYPE_DCC2;
8102 salt_type = SALT_TYPE_EMBEDDED;
8103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_ST_LOWER
8106 | OPTS_TYPE_ST_UNICODE;
8107 kern_type = KERN_TYPE_DCC2;
8108 dgst_size = DGST_SIZE_4_4;
8109 parse_func = dcc2_parse_hash;
8110 sort_by_digest = sort_by_digest_4_4;
8111 opti_type = OPTI_TYPE_ZERO_BYTE;
8112 dgst_pos0 = 0;
8113 dgst_pos1 = 1;
8114 dgst_pos2 = 2;
8115 dgst_pos3 = 3;
8116 break;
8117
8118 case 2400: hash_type = HASH_TYPE_MD5;
8119 salt_type = SALT_TYPE_NONE;
8120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8122 kern_type = KERN_TYPE_MD5PIX;
8123 dgst_size = DGST_SIZE_4_4;
8124 parse_func = md5pix_parse_hash;
8125 sort_by_digest = sort_by_digest_4_4;
8126 opti_type = OPTI_TYPE_ZERO_BYTE
8127 | OPTI_TYPE_PRECOMPUTE_INIT
8128 | OPTI_TYPE_PRECOMPUTE_MERKLE
8129 | OPTI_TYPE_EARLY_SKIP
8130 | OPTI_TYPE_NOT_ITERATED
8131 | OPTI_TYPE_NOT_SALTED;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 3;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 1;
8136 break;
8137
8138 case 2410: hash_type = HASH_TYPE_MD5;
8139 salt_type = SALT_TYPE_INTERN;
8140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8142 kern_type = KERN_TYPE_MD5ASA;
8143 dgst_size = DGST_SIZE_4_4;
8144 parse_func = md5asa_parse_hash;
8145 sort_by_digest = sort_by_digest_4_4;
8146 opti_type = OPTI_TYPE_ZERO_BYTE
8147 | OPTI_TYPE_PRECOMPUTE_INIT
8148 | OPTI_TYPE_PRECOMPUTE_MERKLE
8149 | OPTI_TYPE_EARLY_SKIP
8150 | OPTI_TYPE_NOT_ITERATED;
8151 dgst_pos0 = 0;
8152 dgst_pos1 = 3;
8153 dgst_pos2 = 2;
8154 dgst_pos3 = 1;
8155 break;
8156
8157 case 2500: hash_type = HASH_TYPE_WPA;
8158 salt_type = SALT_TYPE_EMBEDDED;
8159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8161 kern_type = KERN_TYPE_WPA;
8162 dgst_size = DGST_SIZE_4_4;
8163 parse_func = wpa_parse_hash;
8164 sort_by_digest = sort_by_digest_4_4;
8165 opti_type = OPTI_TYPE_ZERO_BYTE;
8166 dgst_pos0 = 0;
8167 dgst_pos1 = 1;
8168 dgst_pos2 = 2;
8169 dgst_pos3 = 3;
8170 break;
8171
8172 case 2600: hash_type = HASH_TYPE_MD5;
8173 salt_type = SALT_TYPE_VIRTUAL;
8174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8175 opts_type = OPTS_TYPE_PT_GENERATE_LE
8176 | OPTS_TYPE_PT_ADD80
8177 | OPTS_TYPE_PT_ADDBITS14
8178 | OPTS_TYPE_ST_ADD80;
8179 kern_type = KERN_TYPE_MD55_PWSLT1;
8180 dgst_size = DGST_SIZE_4_4;
8181 parse_func = md5md5_parse_hash;
8182 sort_by_digest = sort_by_digest_4_4;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_PRECOMPUTE_INIT
8185 | OPTI_TYPE_PRECOMPUTE_MERKLE
8186 | OPTI_TYPE_EARLY_SKIP;
8187 dgst_pos0 = 0;
8188 dgst_pos1 = 3;
8189 dgst_pos2 = 2;
8190 dgst_pos3 = 1;
8191 break;
8192
8193 case 2611: hash_type = HASH_TYPE_MD5;
8194 salt_type = SALT_TYPE_INTERN;
8195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8196 opts_type = OPTS_TYPE_PT_GENERATE_LE
8197 | OPTS_TYPE_PT_ADD80
8198 | OPTS_TYPE_PT_ADDBITS14
8199 | OPTS_TYPE_ST_ADD80;
8200 kern_type = KERN_TYPE_MD55_PWSLT1;
8201 dgst_size = DGST_SIZE_4_4;
8202 parse_func = vb3_parse_hash;
8203 sort_by_digest = sort_by_digest_4_4;
8204 opti_type = OPTI_TYPE_ZERO_BYTE
8205 | OPTI_TYPE_PRECOMPUTE_INIT
8206 | OPTI_TYPE_PRECOMPUTE_MERKLE
8207 | OPTI_TYPE_EARLY_SKIP;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 3;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 2612: hash_type = HASH_TYPE_MD5;
8215 salt_type = SALT_TYPE_EMBEDDED;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE
8218 | OPTS_TYPE_PT_ADD80
8219 | OPTS_TYPE_PT_ADDBITS14
8220 | OPTS_TYPE_ST_ADD80
8221 | OPTS_TYPE_ST_HEX;
8222 kern_type = KERN_TYPE_MD55_PWSLT1;
8223 dgst_size = DGST_SIZE_4_4;
8224 parse_func = phps_parse_hash;
8225 sort_by_digest = sort_by_digest_4_4;
8226 opti_type = OPTI_TYPE_ZERO_BYTE
8227 | OPTI_TYPE_PRECOMPUTE_INIT
8228 | OPTI_TYPE_PRECOMPUTE_MERKLE
8229 | OPTI_TYPE_EARLY_SKIP;
8230 dgst_pos0 = 0;
8231 dgst_pos1 = 3;
8232 dgst_pos2 = 2;
8233 dgst_pos3 = 1;
8234 break;
8235
8236 case 2711: hash_type = HASH_TYPE_MD5;
8237 salt_type = SALT_TYPE_INTERN;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_LE
8240 | OPTS_TYPE_PT_ADD80
8241 | OPTS_TYPE_PT_ADDBITS14
8242 | OPTS_TYPE_ST_ADD80;
8243 kern_type = KERN_TYPE_MD55_PWSLT2;
8244 dgst_size = DGST_SIZE_4_4;
8245 parse_func = vb30_parse_hash;
8246 sort_by_digest = sort_by_digest_4_4;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_EARLY_SKIP;
8250 dgst_pos0 = 0;
8251 dgst_pos1 = 3;
8252 dgst_pos2 = 2;
8253 dgst_pos3 = 1;
8254 break;
8255
8256 case 2811: hash_type = HASH_TYPE_MD5;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_LE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS14;
8262 kern_type = KERN_TYPE_MD55_SLTPW;
8263 dgst_size = DGST_SIZE_4_4;
8264 parse_func = ipb2_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4;
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_INIT
8268 | OPTI_TYPE_EARLY_SKIP;
8269 dgst_pos0 = 0;
8270 dgst_pos1 = 3;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 1;
8273 break;
8274
8275 case 3000: hash_type = HASH_TYPE_LM;
8276 salt_type = SALT_TYPE_NONE;
8277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_LE
8279 | OPTS_TYPE_PT_UPPER
8280 | OPTS_TYPE_PT_BITSLICE;
8281 kern_type = KERN_TYPE_LM;
8282 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8283 parse_func = lm_parse_hash;
8284 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 1;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 3;
8291 break;
8292
8293 case 3100: hash_type = HASH_TYPE_ORACLEH;
8294 salt_type = SALT_TYPE_INTERN;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_LE
8297 | OPTS_TYPE_PT_UPPER
8298 | OPTS_TYPE_ST_UPPER;
8299 kern_type = KERN_TYPE_ORACLEH;
8300 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8301 parse_func = oracleh_parse_hash;
8302 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8303 opti_type = OPTI_TYPE_ZERO_BYTE;
8304 dgst_pos0 = 0;
8305 dgst_pos1 = 1;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 3;
8308 break;
8309
8310 case 3200: hash_type = HASH_TYPE_BCRYPT;
8311 salt_type = SALT_TYPE_EMBEDDED;
8312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE
8314 | OPTS_TYPE_ST_GENERATE_LE;
8315 kern_type = KERN_TYPE_BCRYPT;
8316 dgst_size = DGST_SIZE_4_6;
8317 parse_func = bcrypt_parse_hash;
8318 sort_by_digest = sort_by_digest_4_6;
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 3710: hash_type = HASH_TYPE_MD5;
8327 salt_type = SALT_TYPE_INTERN;
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 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8333 dgst_size = DGST_SIZE_4_4;
8334 parse_func = md5s_parse_hash;
8335 sort_by_digest = sort_by_digest_4_4;
8336 opti_type = OPTI_TYPE_ZERO_BYTE
8337 | OPTI_TYPE_PRECOMPUTE_INIT
8338 | OPTI_TYPE_PRECOMPUTE_MERKLE
8339 | OPTI_TYPE_EARLY_SKIP;
8340 dgst_pos0 = 0;
8341 dgst_pos1 = 3;
8342 dgst_pos2 = 2;
8343 dgst_pos3 = 1;
8344 break;
8345
8346 case 3711: hash_type = HASH_TYPE_MD5;
8347 salt_type = SALT_TYPE_EMBEDDED;
8348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8349 opts_type = OPTS_TYPE_PT_GENERATE_LE
8350 | OPTS_TYPE_PT_ADD80
8351 | OPTS_TYPE_PT_ADDBITS14;
8352 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = mediawiki_b_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_PRECOMPUTE_MERKLE
8359 | OPTI_TYPE_EARLY_SKIP;
8360 dgst_pos0 = 0;
8361 dgst_pos1 = 3;
8362 dgst_pos2 = 2;
8363 dgst_pos3 = 1;
8364 break;
8365
8366 case 3800: hash_type = HASH_TYPE_MD5;
8367 salt_type = SALT_TYPE_INTERN;
8368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8369 opts_type = OPTS_TYPE_PT_GENERATE_LE
8370 | OPTS_TYPE_ST_ADDBITS14;
8371 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8372 dgst_size = DGST_SIZE_4_4;
8373 parse_func = md5s_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_PRECOMPUTE_MERKLE
8378 | OPTI_TYPE_EARLY_SKIP
8379 | OPTI_TYPE_NOT_ITERATED
8380 | OPTI_TYPE_RAW_HASH;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 3;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 1;
8385 break;
8386
8387 case 4300: hash_type = HASH_TYPE_MD5;
8388 salt_type = SALT_TYPE_VIRTUAL;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_LE
8391 | OPTS_TYPE_PT_ADD80
8392 | OPTS_TYPE_PT_ADDBITS14
8393 | OPTS_TYPE_ST_ADD80;
8394 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8395 dgst_size = DGST_SIZE_4_4;
8396 parse_func = md5md5_parse_hash;
8397 sort_by_digest = sort_by_digest_4_4;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_PRECOMPUTE_INIT
8400 | OPTI_TYPE_PRECOMPUTE_MERKLE
8401 | OPTI_TYPE_EARLY_SKIP;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 3;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 1;
8406 break;
8407
8408
8409 case 4400: hash_type = HASH_TYPE_MD5;
8410 salt_type = SALT_TYPE_NONE;
8411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8412 opts_type = OPTS_TYPE_PT_GENERATE_BE
8413 | OPTS_TYPE_PT_ADD80
8414 | OPTS_TYPE_PT_ADDBITS15;
8415 kern_type = KERN_TYPE_MD5_SHA1;
8416 dgst_size = DGST_SIZE_4_4;
8417 parse_func = md5_parse_hash;
8418 sort_by_digest = sort_by_digest_4_4;
8419 opti_type = OPTI_TYPE_ZERO_BYTE
8420 | OPTI_TYPE_PRECOMPUTE_INIT
8421 | OPTI_TYPE_PRECOMPUTE_MERKLE
8422 | OPTI_TYPE_EARLY_SKIP
8423 | OPTI_TYPE_NOT_ITERATED
8424 | OPTI_TYPE_NOT_SALTED
8425 | OPTI_TYPE_RAW_HASH;
8426 dgst_pos0 = 0;
8427 dgst_pos1 = 3;
8428 dgst_pos2 = 2;
8429 dgst_pos3 = 1;
8430 break;
8431
8432 case 4500: hash_type = HASH_TYPE_SHA1;
8433 salt_type = SALT_TYPE_NONE;
8434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_BE
8436 | OPTS_TYPE_PT_ADD80
8437 | OPTS_TYPE_PT_ADDBITS15;
8438 kern_type = KERN_TYPE_SHA11;
8439 dgst_size = DGST_SIZE_4_5;
8440 parse_func = sha1_parse_hash;
8441 sort_by_digest = sort_by_digest_4_5;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_PRECOMPUTE_INIT
8444 | OPTI_TYPE_PRECOMPUTE_MERKLE
8445 | OPTI_TYPE_EARLY_SKIP
8446 | OPTI_TYPE_NOT_SALTED;
8447 dgst_pos0 = 3;
8448 dgst_pos1 = 4;
8449 dgst_pos2 = 2;
8450 dgst_pos3 = 1;
8451 break;
8452
8453 case 4700: hash_type = HASH_TYPE_SHA1;
8454 salt_type = SALT_TYPE_NONE;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_LE
8457 | OPTS_TYPE_PT_ADD80
8458 | OPTS_TYPE_PT_ADDBITS14;
8459 kern_type = KERN_TYPE_SHA1_MD5;
8460 dgst_size = DGST_SIZE_4_5;
8461 parse_func = sha1_parse_hash;
8462 sort_by_digest = sort_by_digest_4_5;
8463 opti_type = OPTI_TYPE_ZERO_BYTE
8464 | OPTI_TYPE_PRECOMPUTE_INIT
8465 | OPTI_TYPE_PRECOMPUTE_MERKLE
8466 | OPTI_TYPE_EARLY_SKIP
8467 | OPTI_TYPE_NOT_ITERATED
8468 | OPTI_TYPE_NOT_SALTED
8469 | OPTI_TYPE_RAW_HASH;
8470 dgst_pos0 = 3;
8471 dgst_pos1 = 4;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 1;
8474 break;
8475
8476 case 4800: hash_type = HASH_TYPE_MD5;
8477 salt_type = SALT_TYPE_EMBEDDED;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_LE
8480 | OPTS_TYPE_PT_ADDBITS14;
8481 kern_type = KERN_TYPE_MD5_CHAP;
8482 dgst_size = DGST_SIZE_4_4;
8483 parse_func = chap_parse_hash;
8484 sort_by_digest = sort_by_digest_4_4;
8485 opti_type = OPTI_TYPE_ZERO_BYTE
8486 | OPTI_TYPE_PRECOMPUTE_INIT
8487 | OPTI_TYPE_PRECOMPUTE_MERKLE
8488 | OPTI_TYPE_MEET_IN_MIDDLE
8489 | OPTI_TYPE_EARLY_SKIP
8490 | OPTI_TYPE_NOT_ITERATED
8491 | OPTI_TYPE_RAW_HASH;
8492 dgst_pos0 = 0;
8493 dgst_pos1 = 3;
8494 dgst_pos2 = 2;
8495 dgst_pos3 = 1;
8496 break;
8497
8498 case 4900: hash_type = HASH_TYPE_SHA1;
8499 salt_type = SALT_TYPE_INTERN;
8500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8502 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8503 dgst_size = DGST_SIZE_4_5;
8504 parse_func = sha1s_parse_hash;
8505 sort_by_digest = sort_by_digest_4_5;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP;
8510 dgst_pos0 = 3;
8511 dgst_pos1 = 4;
8512 dgst_pos2 = 2;
8513 dgst_pos3 = 1;
8514 break;
8515
8516 case 5000: hash_type = HASH_TYPE_KECCAK;
8517 salt_type = SALT_TYPE_EMBEDDED;
8518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8519 opts_type = OPTS_TYPE_PT_GENERATE_LE
8520 | OPTS_TYPE_PT_ADD01;
8521 kern_type = KERN_TYPE_KECCAK;
8522 dgst_size = DGST_SIZE_8_25;
8523 parse_func = keccak_parse_hash;
8524 sort_by_digest = sort_by_digest_8_25;
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_USES_BITS_64
8527 | OPTI_TYPE_RAW_HASH;
8528 dgst_pos0 = 2;
8529 dgst_pos1 = 3;
8530 dgst_pos2 = 4;
8531 dgst_pos3 = 5;
8532 break;
8533
8534 case 5100: hash_type = HASH_TYPE_MD5H;
8535 salt_type = SALT_TYPE_NONE;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE
8538 | OPTS_TYPE_PT_ADD80
8539 | OPTS_TYPE_PT_ADDBITS14;
8540 kern_type = KERN_TYPE_MD5H;
8541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8542 parse_func = md5half_parse_hash;
8543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_RAW_HASH;
8546 dgst_pos0 = 0;
8547 dgst_pos1 = 1;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 3;
8550 break;
8551
8552 case 5200: hash_type = HASH_TYPE_SHA256;
8553 salt_type = SALT_TYPE_EMBEDDED;
8554 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8556 kern_type = KERN_TYPE_PSAFE3;
8557 dgst_size = DGST_SIZE_4_8;
8558 parse_func = psafe3_parse_hash;
8559 sort_by_digest = sort_by_digest_4_8;
8560 opti_type = OPTI_TYPE_ZERO_BYTE;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 1;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 3;
8565 break;
8566
8567 case 5300: hash_type = HASH_TYPE_MD5;
8568 salt_type = SALT_TYPE_EMBEDDED;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_ST_ADD80;
8572 kern_type = KERN_TYPE_IKEPSK_MD5;
8573 dgst_size = DGST_SIZE_4_4;
8574 parse_func = ikepsk_md5_parse_hash;
8575 sort_by_digest = sort_by_digest_4_4;
8576 opti_type = OPTI_TYPE_ZERO_BYTE;
8577 dgst_pos0 = 0;
8578 dgst_pos1 = 3;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 1;
8581 break;
8582
8583 case 5400: hash_type = HASH_TYPE_SHA1;
8584 salt_type = SALT_TYPE_EMBEDDED;
8585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_BE
8587 | OPTS_TYPE_ST_ADD80;
8588 kern_type = KERN_TYPE_IKEPSK_SHA1;
8589 dgst_size = DGST_SIZE_4_5;
8590 parse_func = ikepsk_sha1_parse_hash;
8591 sort_by_digest = sort_by_digest_4_5;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 3;
8594 dgst_pos1 = 4;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 1;
8597 break;
8598
8599 case 5500: hash_type = HASH_TYPE_NETNTLM;
8600 salt_type = SALT_TYPE_EMBEDDED;
8601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE
8603 | OPTS_TYPE_PT_ADD80
8604 | OPTS_TYPE_PT_ADDBITS14
8605 | OPTS_TYPE_PT_UNICODE
8606 | OPTS_TYPE_ST_HEX;
8607 kern_type = KERN_TYPE_NETNTLMv1;
8608 dgst_size = DGST_SIZE_4_4;
8609 parse_func = netntlmv1_parse_hash;
8610 sort_by_digest = sort_by_digest_4_4;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 1;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 3;
8617 break;
8618
8619 case 5600: hash_type = HASH_TYPE_MD5;
8620 salt_type = SALT_TYPE_EMBEDDED;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_LE
8623 | OPTS_TYPE_PT_ADD80
8624 | OPTS_TYPE_PT_ADDBITS14
8625 | OPTS_TYPE_PT_UNICODE;
8626 kern_type = KERN_TYPE_NETNTLMv2;
8627 dgst_size = DGST_SIZE_4_4;
8628 parse_func = netntlmv2_parse_hash;
8629 sort_by_digest = sort_by_digest_4_4;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 3;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 1;
8635 break;
8636
8637 case 5700: hash_type = HASH_TYPE_SHA256;
8638 salt_type = SALT_TYPE_NONE;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_BE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS15;
8643 kern_type = KERN_TYPE_SHA256;
8644 dgst_size = DGST_SIZE_4_8;
8645 parse_func = cisco4_parse_hash;
8646 sort_by_digest = sort_by_digest_4_8;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP
8651 | OPTI_TYPE_NOT_ITERATED
8652 | OPTI_TYPE_NOT_SALTED
8653 | OPTI_TYPE_RAW_HASH;
8654 dgst_pos0 = 3;
8655 dgst_pos1 = 7;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 6;
8658 break;
8659
8660 case 5800: hash_type = HASH_TYPE_SHA1;
8661 salt_type = SALT_TYPE_INTERN;
8662 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8664 | OPTS_TYPE_ST_ADD80;
8665 kern_type = KERN_TYPE_ANDROIDPIN;
8666 dgst_size = DGST_SIZE_4_5;
8667 parse_func = androidpin_parse_hash;
8668 sort_by_digest = sort_by_digest_4_5;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8677 salt_type = SALT_TYPE_NONE;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE
8680 | OPTS_TYPE_PT_ADD80;
8681 kern_type = KERN_TYPE_RIPEMD160;
8682 dgst_size = DGST_SIZE_4_5;
8683 parse_func = ripemd160_parse_hash;
8684 sort_by_digest = sort_by_digest_4_5;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8693 salt_type = SALT_TYPE_NONE;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_BE
8696 | OPTS_TYPE_PT_ADD80;
8697 kern_type = KERN_TYPE_WHIRLPOOL;
8698 dgst_size = DGST_SIZE_4_16;
8699 parse_func = whirlpool_parse_hash;
8700 sort_by_digest = sort_by_digest_4_16;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 1;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 3;
8706 break;
8707
8708 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8712 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8713 dgst_size = DGST_SIZE_4_5;
8714 parse_func = truecrypt_parse_hash_2k;
8715 sort_by_digest = sort_by_digest_4_5;
8716 opti_type = OPTI_TYPE_ZERO_BYTE;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 1;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 3;
8721 break;
8722
8723 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8724 salt_type = SALT_TYPE_EMBEDDED;
8725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8727 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = truecrypt_parse_hash_2k;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 1;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 3;
8736 break;
8737
8738 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8739 salt_type = SALT_TYPE_EMBEDDED;
8740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8742 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8743 dgst_size = DGST_SIZE_4_5;
8744 parse_func = truecrypt_parse_hash_2k;
8745 sort_by_digest = sort_by_digest_4_5;
8746 opti_type = OPTI_TYPE_ZERO_BYTE;
8747 dgst_pos0 = 0;
8748 dgst_pos1 = 1;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 3;
8751 break;
8752
8753 case 6221: hash_type = HASH_TYPE_SHA512;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8757 kern_type = KERN_TYPE_TCSHA512_XTS512;
8758 dgst_size = DGST_SIZE_8_8;
8759 parse_func = truecrypt_parse_hash_1k;
8760 sort_by_digest = sort_by_digest_8_8;
8761 opti_type = OPTI_TYPE_ZERO_BYTE
8762 | OPTI_TYPE_USES_BITS_64;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 6222: hash_type = HASH_TYPE_SHA512;
8770 salt_type = SALT_TYPE_EMBEDDED;
8771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8773 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8774 dgst_size = DGST_SIZE_8_8;
8775 parse_func = truecrypt_parse_hash_1k;
8776 sort_by_digest = sort_by_digest_8_8;
8777 opti_type = OPTI_TYPE_ZERO_BYTE
8778 | OPTI_TYPE_USES_BITS_64;
8779 dgst_pos0 = 0;
8780 dgst_pos1 = 1;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 3;
8783 break;
8784
8785 case 6223: hash_type = HASH_TYPE_SHA512;
8786 salt_type = SALT_TYPE_EMBEDDED;
8787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8789 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8790 dgst_size = DGST_SIZE_8_8;
8791 parse_func = truecrypt_parse_hash_1k;
8792 sort_by_digest = sort_by_digest_8_8;
8793 opti_type = OPTI_TYPE_ZERO_BYTE
8794 | OPTI_TYPE_USES_BITS_64;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8805 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8806 dgst_size = DGST_SIZE_4_8;
8807 parse_func = truecrypt_parse_hash_1k;
8808 sort_by_digest = sort_by_digest_4_8;
8809 opti_type = OPTI_TYPE_ZERO_BYTE;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8817 salt_type = SALT_TYPE_EMBEDDED;
8818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8820 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8821 dgst_size = DGST_SIZE_4_8;
8822 parse_func = truecrypt_parse_hash_1k;
8823 sort_by_digest = sort_by_digest_4_8;
8824 opti_type = OPTI_TYPE_ZERO_BYTE;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 1;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 3;
8829 break;
8830
8831 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8835 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8836 dgst_size = DGST_SIZE_4_8;
8837 parse_func = truecrypt_parse_hash_1k;
8838 sort_by_digest = sort_by_digest_4_8;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
8847 salt_type = SALT_TYPE_EMBEDDED;
8848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8850 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8851 dgst_size = DGST_SIZE_4_5;
8852 parse_func = truecrypt_parse_hash_1k;
8853 sort_by_digest = sort_by_digest_4_5;
8854 opti_type = OPTI_TYPE_ZERO_BYTE;
8855 dgst_pos0 = 0;
8856 dgst_pos1 = 1;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 3;
8859 break;
8860
8861 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8865 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8866 dgst_size = DGST_SIZE_4_5;
8867 parse_func = truecrypt_parse_hash_1k;
8868 sort_by_digest = sort_by_digest_4_5;
8869 opti_type = OPTI_TYPE_ZERO_BYTE;
8870 dgst_pos0 = 0;
8871 dgst_pos1 = 1;
8872 dgst_pos2 = 2;
8873 dgst_pos3 = 3;
8874 break;
8875
8876 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8877 salt_type = SALT_TYPE_EMBEDDED;
8878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8880 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8881 dgst_size = DGST_SIZE_4_5;
8882 parse_func = truecrypt_parse_hash_1k;
8883 sort_by_digest = sort_by_digest_4_5;
8884 opti_type = OPTI_TYPE_ZERO_BYTE;
8885 dgst_pos0 = 0;
8886 dgst_pos1 = 1;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 3;
8889 break;
8890
8891 case 6300: hash_type = HASH_TYPE_MD5;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8895 kern_type = KERN_TYPE_MD5AIX;
8896 dgst_size = DGST_SIZE_4_4;
8897 parse_func = md5aix_parse_hash;
8898 sort_by_digest = sort_by_digest_4_4;
8899 opti_type = OPTI_TYPE_ZERO_BYTE;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6400: hash_type = HASH_TYPE_SHA256;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8910 kern_type = KERN_TYPE_SHA256AIX;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = sha256aix_parse_hash;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6500: hash_type = HASH_TYPE_SHA512;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8925 kern_type = KERN_TYPE_SHA512AIX;
8926 dgst_size = DGST_SIZE_8_8;
8927 parse_func = sha512aix_parse_hash;
8928 sort_by_digest = sort_by_digest_8_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE
8930 | OPTI_TYPE_USES_BITS_64;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6600: hash_type = HASH_TYPE_AES;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_AGILEKEY;
8942 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8943 parse_func = agilekey_parse_hash;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6700: hash_type = HASH_TYPE_SHA1;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8956 kern_type = KERN_TYPE_SHA1AIX;
8957 dgst_size = DGST_SIZE_4_5;
8958 parse_func = sha1aix_parse_hash;
8959 sort_by_digest = sort_by_digest_4_5;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6800: hash_type = HASH_TYPE_AES;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_LASTPASS;
8972 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8973 parse_func = lastpass_parse_hash;
8974 sort_by_digest = sort_by_digest_4_8;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6900: hash_type = HASH_TYPE_GOST;
8983 salt_type = SALT_TYPE_NONE;
8984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_GOST;
8987 dgst_size = DGST_SIZE_4_8;
8988 parse_func = gost_parse_hash;
8989 sort_by_digest = sort_by_digest_4_8;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 7100: hash_type = HASH_TYPE_SHA512;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9001 kern_type = KERN_TYPE_PBKDF2_SHA512;
9002 dgst_size = DGST_SIZE_8_16;
9003 parse_func = sha512osx_parse_hash;
9004 sort_by_digest = sort_by_digest_8_16;
9005 opti_type = OPTI_TYPE_ZERO_BYTE
9006 | OPTI_TYPE_USES_BITS_64;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 7200: hash_type = HASH_TYPE_SHA512;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9017 kern_type = KERN_TYPE_PBKDF2_SHA512;
9018 dgst_size = DGST_SIZE_8_16;
9019 parse_func = sha512grub_parse_hash;
9020 sort_by_digest = sort_by_digest_8_16;
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_USES_BITS_64;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 7300: hash_type = HASH_TYPE_SHA1;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_BE
9033 | OPTS_TYPE_ST_ADD80
9034 | OPTS_TYPE_ST_ADDBITS15;
9035 kern_type = KERN_TYPE_RAKP;
9036 dgst_size = DGST_SIZE_4_5;
9037 parse_func = rakp_parse_hash;
9038 sort_by_digest = sort_by_digest_4_5;
9039 opti_type = OPTI_TYPE_ZERO_BYTE
9040 | OPTI_TYPE_NOT_ITERATED;
9041 dgst_pos0 = 3;
9042 dgst_pos1 = 4;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 1;
9045 break;
9046
9047 case 7400: hash_type = HASH_TYPE_SHA256;
9048 salt_type = SALT_TYPE_EMBEDDED;
9049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9051 kern_type = KERN_TYPE_SHA256CRYPT;
9052 dgst_size = DGST_SIZE_4_8;
9053 parse_func = sha256crypt_parse_hash;
9054 sort_by_digest = sort_by_digest_4_8;
9055 opti_type = OPTI_TYPE_ZERO_BYTE;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 7500: hash_type = HASH_TYPE_KRB5PA;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9066 kern_type = KERN_TYPE_KRB5PA;
9067 dgst_size = DGST_SIZE_4_4;
9068 parse_func = krb5pa_parse_hash;
9069 sort_by_digest = sort_by_digest_4_4;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_NOT_ITERATED;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 1;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 3;
9076 break;
9077
9078 case 7600: hash_type = HASH_TYPE_SHA1;
9079 salt_type = SALT_TYPE_INTERN;
9080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_BE
9082 | OPTS_TYPE_PT_ADD80
9083 | OPTS_TYPE_PT_ADDBITS15;
9084 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9085 dgst_size = DGST_SIZE_4_5;
9086 parse_func = redmine_parse_hash;
9087 sort_by_digest = sort_by_digest_4_5;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_PRECOMPUTE_INIT
9090 | OPTI_TYPE_EARLY_SKIP
9091 | OPTI_TYPE_NOT_ITERATED
9092 | OPTI_TYPE_PREPENDED_SALT;
9093 dgst_pos0 = 3;
9094 dgst_pos1 = 4;
9095 dgst_pos2 = 2;
9096 dgst_pos3 = 1;
9097 break;
9098
9099 case 7700: hash_type = HASH_TYPE_SAPB;
9100 salt_type = SALT_TYPE_EMBEDDED;
9101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9102 opts_type = OPTS_TYPE_PT_GENERATE_LE
9103 | OPTS_TYPE_PT_UPPER
9104 | OPTS_TYPE_ST_UPPER;
9105 kern_type = KERN_TYPE_SAPB;
9106 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9107 parse_func = sapb_parse_hash;
9108 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9109 opti_type = OPTI_TYPE_ZERO_BYTE
9110 | OPTI_TYPE_PRECOMPUTE_INIT
9111 | OPTI_TYPE_NOT_ITERATED;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7800: hash_type = HASH_TYPE_SAPG;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_BE
9122 | OPTS_TYPE_ST_ADD80
9123 | OPTS_TYPE_ST_UPPER;
9124 kern_type = KERN_TYPE_SAPG;
9125 dgst_size = DGST_SIZE_4_5;
9126 parse_func = sapg_parse_hash;
9127 sort_by_digest = sort_by_digest_4_5;
9128 opti_type = OPTI_TYPE_ZERO_BYTE
9129 | OPTI_TYPE_PRECOMPUTE_INIT
9130 | OPTI_TYPE_NOT_ITERATED;
9131 dgst_pos0 = 3;
9132 dgst_pos1 = 4;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 1;
9135 break;
9136
9137 case 7900: hash_type = HASH_TYPE_SHA512;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9141 kern_type = KERN_TYPE_DRUPAL7;
9142 dgst_size = DGST_SIZE_8_8;
9143 parse_func = drupal7_parse_hash;
9144 sort_by_digest = sort_by_digest_8_8;
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_USES_BITS_64;
9147 dgst_pos0 = 0;
9148 dgst_pos1 = 1;
9149 dgst_pos2 = 2;
9150 dgst_pos3 = 3;
9151 break;
9152
9153 case 8000: hash_type = HASH_TYPE_SHA256;
9154 salt_type = SALT_TYPE_EMBEDDED;
9155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9156 opts_type = OPTS_TYPE_PT_GENERATE_BE
9157 | OPTS_TYPE_PT_UNICODE
9158 | OPTS_TYPE_ST_ADD80
9159 | OPTS_TYPE_ST_HEX;
9160 kern_type = KERN_TYPE_SYBASEASE;
9161 dgst_size = DGST_SIZE_4_8;
9162 parse_func = sybasease_parse_hash;
9163 sort_by_digest = sort_by_digest_4_8;
9164 opti_type = OPTI_TYPE_ZERO_BYTE
9165 | OPTI_TYPE_PRECOMPUTE_INIT
9166 | OPTI_TYPE_EARLY_SKIP
9167 | OPTI_TYPE_NOT_ITERATED
9168 | OPTI_TYPE_RAW_HASH;
9169 dgst_pos0 = 3;
9170 dgst_pos1 = 7;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 6;
9173 break;
9174
9175 case 8100: hash_type = HASH_TYPE_SHA1;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9179 kern_type = KERN_TYPE_NETSCALER;
9180 dgst_size = DGST_SIZE_4_5;
9181 parse_func = netscaler_parse_hash;
9182 sort_by_digest = sort_by_digest_4_5;
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_INIT
9185 | OPTI_TYPE_PRECOMPUTE_MERKLE
9186 | OPTI_TYPE_EARLY_SKIP
9187 | OPTI_TYPE_NOT_ITERATED
9188 | OPTI_TYPE_PREPENDED_SALT
9189 | OPTI_TYPE_RAW_HASH;
9190 dgst_pos0 = 3;
9191 dgst_pos1 = 4;
9192 dgst_pos2 = 2;
9193 dgst_pos3 = 1;
9194 break;
9195
9196 case 8200: hash_type = HASH_TYPE_SHA256;
9197 salt_type = SALT_TYPE_EMBEDDED;
9198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9199 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9200 kern_type = KERN_TYPE_CLOUDKEY;
9201 dgst_size = DGST_SIZE_4_8;
9202 parse_func = cloudkey_parse_hash;
9203 sort_by_digest = sort_by_digest_4_8;
9204 opti_type = OPTI_TYPE_ZERO_BYTE;
9205 dgst_pos0 = 0;
9206 dgst_pos1 = 1;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 3;
9209 break;
9210
9211 case 8300: hash_type = HASH_TYPE_SHA1;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_LE
9215 | OPTS_TYPE_ST_HEX
9216 | OPTS_TYPE_ST_ADD80;
9217 kern_type = KERN_TYPE_NSEC3;
9218 dgst_size = DGST_SIZE_4_5;
9219 parse_func = nsec3_parse_hash;
9220 sort_by_digest = sort_by_digest_4_5;
9221 opti_type = OPTI_TYPE_ZERO_BYTE;
9222 dgst_pos0 = 3;
9223 dgst_pos1 = 4;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 1;
9226 break;
9227
9228 case 8400: hash_type = HASH_TYPE_SHA1;
9229 salt_type = SALT_TYPE_INTERN;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_BE
9232 | OPTS_TYPE_PT_ADD80
9233 | OPTS_TYPE_PT_ADDBITS15;
9234 kern_type = KERN_TYPE_WBB3;
9235 dgst_size = DGST_SIZE_4_5;
9236 parse_func = wbb3_parse_hash;
9237 sort_by_digest = sort_by_digest_4_5;
9238 opti_type = OPTI_TYPE_ZERO_BYTE
9239 | OPTI_TYPE_PRECOMPUTE_INIT
9240 | OPTI_TYPE_NOT_ITERATED;
9241 dgst_pos0 = 3;
9242 dgst_pos1 = 4;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 1;
9245 break;
9246
9247 case 8500: hash_type = HASH_TYPE_DESRACF;
9248 salt_type = SALT_TYPE_EMBEDDED;
9249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_LE
9251 | OPTS_TYPE_ST_UPPER;
9252 kern_type = KERN_TYPE_RACF;
9253 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9254 parse_func = racf_parse_hash;
9255 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 1;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 3;
9262 break;
9263
9264 case 8600: hash_type = HASH_TYPE_LOTUS5;
9265 salt_type = SALT_TYPE_NONE;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9268 kern_type = KERN_TYPE_LOTUS5;
9269 dgst_size = DGST_SIZE_4_4;
9270 parse_func = lotus5_parse_hash;
9271 sort_by_digest = sort_by_digest_4_4;
9272 opti_type = OPTI_TYPE_EARLY_SKIP
9273 | OPTI_TYPE_NOT_ITERATED
9274 | OPTI_TYPE_NOT_SALTED
9275 | OPTI_TYPE_RAW_HASH;
9276 dgst_pos0 = 0;
9277 dgst_pos1 = 1;
9278 dgst_pos2 = 2;
9279 dgst_pos3 = 3;
9280 break;
9281
9282 case 8700: hash_type = HASH_TYPE_LOTUS6;
9283 salt_type = SALT_TYPE_EMBEDDED;
9284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9286 kern_type = KERN_TYPE_LOTUS6;
9287 dgst_size = DGST_SIZE_4_4;
9288 parse_func = lotus6_parse_hash;
9289 sort_by_digest = sort_by_digest_4_4;
9290 opti_type = OPTI_TYPE_EARLY_SKIP
9291 | OPTI_TYPE_NOT_ITERATED
9292 | OPTI_TYPE_RAW_HASH;
9293 dgst_pos0 = 0;
9294 dgst_pos1 = 1;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 3;
9297 break;
9298
9299 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9300 salt_type = SALT_TYPE_EMBEDDED;
9301 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9302 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9303 kern_type = KERN_TYPE_ANDROIDFDE;
9304 dgst_size = DGST_SIZE_4_4;
9305 parse_func = androidfde_parse_hash;
9306 sort_by_digest = sort_by_digest_4_4;
9307 opti_type = OPTI_TYPE_ZERO_BYTE;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 8900: hash_type = HASH_TYPE_SCRYPT;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9318 kern_type = KERN_TYPE_SCRYPT;
9319 dgst_size = DGST_SIZE_4_8;
9320 parse_func = scrypt_parse_hash;
9321 sort_by_digest = sort_by_digest_4_8;
9322 opti_type = OPTI_TYPE_ZERO_BYTE;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 9000: hash_type = HASH_TYPE_SHA1;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE
9333 | OPTS_TYPE_ST_GENERATE_LE;
9334 kern_type = KERN_TYPE_PSAFE2;
9335 dgst_size = DGST_SIZE_4_5;
9336 parse_func = psafe2_parse_hash;
9337 sort_by_digest = sort_by_digest_4_5;
9338 opti_type = OPTI_TYPE_ZERO_BYTE;
9339 dgst_pos0 = 0;
9340 dgst_pos1 = 1;
9341 dgst_pos2 = 2;
9342 dgst_pos3 = 3;
9343 break;
9344
9345 case 9100: hash_type = HASH_TYPE_LOTUS8;
9346 salt_type = SALT_TYPE_EMBEDDED;
9347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9349 kern_type = KERN_TYPE_LOTUS8;
9350 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9351 parse_func = lotus8_parse_hash;
9352 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9353 opti_type = OPTI_TYPE_ZERO_BYTE;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 1;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 3;
9358 break;
9359
9360 case 9200: hash_type = HASH_TYPE_SHA256;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9364 kern_type = KERN_TYPE_PBKDF2_SHA256;
9365 dgst_size = DGST_SIZE_4_32;
9366 parse_func = cisco8_parse_hash;
9367 sort_by_digest = sort_by_digest_4_32;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 9300: hash_type = HASH_TYPE_SCRYPT;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_SCRYPT;
9380 dgst_size = DGST_SIZE_4_8;
9381 parse_func = cisco9_parse_hash;
9382 sort_by_digest = sort_by_digest_4_8;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_OFFICE2007;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = office2007_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_OFFICE2010;
9410 dgst_size = DGST_SIZE_4_4;
9411 parse_func = office2010_parse_hash;
9412 sort_by_digest = sort_by_digest_4_4;
9413 opti_type = OPTI_TYPE_ZERO_BYTE;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_OFFICE2013;
9425 dgst_size = DGST_SIZE_4_4;
9426 parse_func = office2013_parse_hash;
9427 sort_by_digest = sort_by_digest_4_4;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE
9439 | OPTS_TYPE_PT_ADD80
9440 | OPTS_TYPE_PT_UNICODE;
9441 kern_type = KERN_TYPE_OLDOFFICE01;
9442 dgst_size = DGST_SIZE_4_4;
9443 parse_func = oldoffice01_parse_hash;
9444 sort_by_digest = sort_by_digest_4_4;
9445 opti_type = OPTI_TYPE_ZERO_BYTE
9446 | OPTI_TYPE_PRECOMPUTE_INIT
9447 | OPTI_TYPE_NOT_ITERATED;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE
9458 | OPTS_TYPE_PT_ADD80;
9459 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9460 dgst_size = DGST_SIZE_4_4;
9461 parse_func = oldoffice01cm1_parse_hash;
9462 sort_by_digest = sort_by_digest_4_4;
9463 opti_type = OPTI_TYPE_ZERO_BYTE
9464 | OPTI_TYPE_PRECOMPUTE_INIT
9465 | OPTI_TYPE_NOT_ITERATED;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE
9476 | OPTS_TYPE_PT_ADD80
9477 | OPTS_TYPE_PT_UNICODE
9478 | OPTS_TYPE_PT_NEVERCRACK;
9479 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = oldoffice01cm2_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_PRECOMPUTE_INIT
9485 | OPTI_TYPE_NOT_ITERATED;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_BE
9496 | OPTS_TYPE_PT_ADD80
9497 | OPTS_TYPE_PT_UNICODE;
9498 kern_type = KERN_TYPE_OLDOFFICE34;
9499 dgst_size = DGST_SIZE_4_4;
9500 parse_func = oldoffice34_parse_hash;
9501 sort_by_digest = sort_by_digest_4_4;
9502 opti_type = OPTI_TYPE_ZERO_BYTE
9503 | OPTI_TYPE_PRECOMPUTE_INIT
9504 | OPTI_TYPE_NOT_ITERATED;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9516 dgst_size = DGST_SIZE_4_4;
9517 parse_func = oldoffice34cm1_parse_hash;
9518 sort_by_digest = sort_by_digest_4_4;
9519 opti_type = OPTI_TYPE_ZERO_BYTE
9520 | OPTI_TYPE_PRECOMPUTE_INIT
9521 | OPTI_TYPE_NOT_ITERATED;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 1;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 3;
9526 break;
9527
9528 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9529 salt_type = SALT_TYPE_EMBEDDED;
9530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9531 opts_type = OPTS_TYPE_PT_GENERATE_BE
9532 | OPTS_TYPE_PT_ADD80
9533 | OPTS_TYPE_PT_UNICODE
9534 | OPTS_TYPE_PT_NEVERCRACK;
9535 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9536 dgst_size = DGST_SIZE_4_4;
9537 parse_func = oldoffice34cm2_parse_hash;
9538 sort_by_digest = sort_by_digest_4_4;
9539 opti_type = OPTI_TYPE_ZERO_BYTE
9540 | OPTI_TYPE_PRECOMPUTE_INIT
9541 | OPTI_TYPE_NOT_ITERATED;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 9900: hash_type = HASH_TYPE_MD5;
9549 salt_type = SALT_TYPE_NONE;
9550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_RADMIN2;
9553 dgst_size = DGST_SIZE_4_4;
9554 parse_func = radmin2_parse_hash;
9555 sort_by_digest = sort_by_digest_4_4;
9556 opti_type = OPTI_TYPE_ZERO_BYTE
9557 | OPTI_TYPE_PRECOMPUTE_INIT
9558 | OPTI_TYPE_EARLY_SKIP
9559 | OPTI_TYPE_NOT_ITERATED
9560 | OPTI_TYPE_NOT_SALTED;
9561 dgst_pos0 = 0;
9562 dgst_pos1 = 3;
9563 dgst_pos2 = 2;
9564 dgst_pos3 = 1;
9565 break;
9566
9567 case 10000: hash_type = HASH_TYPE_SHA256;
9568 salt_type = SALT_TYPE_EMBEDDED;
9569 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9570 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9571 kern_type = KERN_TYPE_PBKDF2_SHA256;
9572 dgst_size = DGST_SIZE_4_32;
9573 parse_func = djangopbkdf2_parse_hash;
9574 sort_by_digest = sort_by_digest_4_32;
9575 opti_type = OPTI_TYPE_ZERO_BYTE;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 10100: hash_type = HASH_TYPE_SIPHASH;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9586 kern_type = KERN_TYPE_SIPHASH;
9587 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9588 parse_func = siphash_parse_hash;
9589 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9590 opti_type = OPTI_TYPE_ZERO_BYTE
9591 | OPTI_TYPE_NOT_ITERATED
9592 | OPTI_TYPE_RAW_HASH;
9593 dgst_pos0 = 0;
9594 dgst_pos1 = 1;
9595 dgst_pos2 = 2;
9596 dgst_pos3 = 3;
9597 break;
9598
9599 case 10200: hash_type = HASH_TYPE_MD5;
9600 salt_type = SALT_TYPE_EMBEDDED;
9601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9602 opts_type = OPTS_TYPE_PT_GENERATE_LE
9603 | OPTS_TYPE_ST_ADD80
9604 | OPTS_TYPE_ST_ADDBITS14;
9605 kern_type = KERN_TYPE_HMACMD5_PW;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = crammd5_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE
9610 | OPTI_TYPE_NOT_ITERATED;
9611 dgst_pos0 = 0;
9612 dgst_pos1 = 3;
9613 dgst_pos2 = 2;
9614 dgst_pos3 = 1;
9615 break;
9616
9617 case 10300: hash_type = HASH_TYPE_SHA1;
9618 salt_type = SALT_TYPE_EMBEDDED;
9619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9621 kern_type = KERN_TYPE_SAPH_SHA1;
9622 dgst_size = DGST_SIZE_4_5;
9623 parse_func = saph_sha1_parse_hash;
9624 sort_by_digest = sort_by_digest_4_5;
9625 opti_type = OPTI_TYPE_ZERO_BYTE;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 10400: hash_type = HASH_TYPE_PDFU16;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_PDF11;
9637 dgst_size = DGST_SIZE_4_4;
9638 parse_func = pdf11_parse_hash;
9639 sort_by_digest = sort_by_digest_4_4;
9640 opti_type = OPTI_TYPE_ZERO_BYTE
9641 | OPTI_TYPE_NOT_ITERATED;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 10410: hash_type = HASH_TYPE_PDFU16;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9652 kern_type = KERN_TYPE_PDF11CM1;
9653 dgst_size = DGST_SIZE_4_4;
9654 parse_func = pdf11cm1_parse_hash;
9655 sort_by_digest = sort_by_digest_4_4;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_NOT_ITERATED;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 10420: hash_type = HASH_TYPE_PDFU16;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_PDF11CM2;
9669 dgst_size = DGST_SIZE_4_4;
9670 parse_func = pdf11cm2_parse_hash;
9671 sort_by_digest = sort_by_digest_4_4;
9672 opti_type = OPTI_TYPE_ZERO_BYTE
9673 | OPTI_TYPE_NOT_ITERATED;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 10500: hash_type = HASH_TYPE_PDFU16;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9684 kern_type = KERN_TYPE_PDF14;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = pdf14_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_NOT_ITERATED;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 10600: hash_type = HASH_TYPE_SHA256;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_BE
9700 | OPTS_TYPE_ST_ADD80
9701 | OPTS_TYPE_ST_ADDBITS15
9702 | OPTS_TYPE_HASH_COPY;
9703 kern_type = KERN_TYPE_SHA256_PWSLT;
9704 dgst_size = DGST_SIZE_4_8;
9705 parse_func = pdf17l3_parse_hash;
9706 sort_by_digest = sort_by_digest_4_8;
9707 opti_type = OPTI_TYPE_ZERO_BYTE
9708 | OPTI_TYPE_PRECOMPUTE_INIT
9709 | OPTI_TYPE_PRECOMPUTE_MERKLE
9710 | OPTI_TYPE_EARLY_SKIP
9711 | OPTI_TYPE_NOT_ITERATED
9712 | OPTI_TYPE_APPENDED_SALT
9713 | OPTI_TYPE_RAW_HASH;
9714 dgst_pos0 = 3;
9715 dgst_pos1 = 7;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 6;
9718 break;
9719
9720 case 10700: hash_type = HASH_TYPE_PDFU32;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE
9724 | OPTS_TYPE_HASH_COPY;
9725 kern_type = KERN_TYPE_PDF17L8;
9726 dgst_size = DGST_SIZE_4_8;
9727 parse_func = pdf17l8_parse_hash;
9728 sort_by_digest = sort_by_digest_4_8;
9729 opti_type = OPTI_TYPE_ZERO_BYTE
9730 | OPTI_TYPE_NOT_ITERATED;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 10800: hash_type = HASH_TYPE_SHA384;
9738 salt_type = SALT_TYPE_NONE;
9739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_BE
9741 | OPTS_TYPE_PT_ADD80
9742 | OPTS_TYPE_PT_ADDBITS15;
9743 kern_type = KERN_TYPE_SHA384;
9744 dgst_size = DGST_SIZE_8_8;
9745 parse_func = sha384_parse_hash;
9746 sort_by_digest = sort_by_digest_8_8;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_PRECOMPUTE_INIT
9749 | OPTI_TYPE_PRECOMPUTE_MERKLE
9750 | OPTI_TYPE_EARLY_SKIP
9751 | OPTI_TYPE_NOT_ITERATED
9752 | OPTI_TYPE_NOT_SALTED
9753 | OPTI_TYPE_USES_BITS_64
9754 | OPTI_TYPE_RAW_HASH;
9755 dgst_pos0 = 6;
9756 dgst_pos1 = 7;
9757 dgst_pos2 = 4;
9758 dgst_pos3 = 5;
9759 break;
9760
9761 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE
9765 | OPTS_TYPE_ST_BASE64
9766 | OPTS_TYPE_HASH_COPY;
9767 kern_type = KERN_TYPE_PBKDF2_SHA256;
9768 dgst_size = DGST_SIZE_4_32;
9769 parse_func = pbkdf2_sha256_parse_hash;
9770 sort_by_digest = sort_by_digest_4_32;
9771 opti_type = OPTI_TYPE_ZERO_BYTE;
9772 dgst_pos0 = 0;
9773 dgst_pos1 = 1;
9774 dgst_pos2 = 2;
9775 dgst_pos3 = 3;
9776 break;
9777
9778 case 11000: hash_type = HASH_TYPE_MD5;
9779 salt_type = SALT_TYPE_INTERN;
9780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9781 opts_type = OPTS_TYPE_PT_GENERATE_LE
9782 | OPTS_TYPE_PT_ADD80;
9783 kern_type = KERN_TYPE_PRESTASHOP;
9784 dgst_size = DGST_SIZE_4_4;
9785 parse_func = prestashop_parse_hash;
9786 sort_by_digest = sort_by_digest_4_4;
9787 opti_type = OPTI_TYPE_ZERO_BYTE
9788 | OPTI_TYPE_PRECOMPUTE_INIT
9789 | OPTI_TYPE_NOT_ITERATED
9790 | OPTI_TYPE_PREPENDED_SALT;
9791 dgst_pos0 = 0;
9792 dgst_pos1 = 3;
9793 dgst_pos2 = 2;
9794 dgst_pos3 = 1;
9795 break;
9796
9797 case 11100: hash_type = HASH_TYPE_MD5;
9798 salt_type = SALT_TYPE_EMBEDDED;
9799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9800 opts_type = OPTS_TYPE_PT_GENERATE_LE
9801 | OPTS_TYPE_ST_ADD80;
9802 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9803 dgst_size = DGST_SIZE_4_4;
9804 parse_func = postgresql_auth_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_PRECOMPUTE_INIT
9808 | OPTI_TYPE_PRECOMPUTE_MERKLE
9809 | OPTI_TYPE_EARLY_SKIP;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 3;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 1;
9814 break;
9815
9816 case 11200: hash_type = HASH_TYPE_SHA1;
9817 salt_type = SALT_TYPE_EMBEDDED;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_BE
9820 | OPTS_TYPE_PT_ADD80
9821 | OPTS_TYPE_ST_HEX;
9822 kern_type = KERN_TYPE_MYSQL_AUTH;
9823 dgst_size = DGST_SIZE_4_5;
9824 parse_func = mysql_auth_parse_hash;
9825 sort_by_digest = sort_by_digest_4_5;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_EARLY_SKIP;
9828 dgst_pos0 = 3;
9829 dgst_pos1 = 4;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 1;
9832 break;
9833
9834 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE
9838 | OPTS_TYPE_ST_HEX
9839 | OPTS_TYPE_ST_ADD80;
9840 kern_type = KERN_TYPE_BITCOIN_WALLET;
9841 dgst_size = DGST_SIZE_4_4;
9842 parse_func = bitcoin_wallet_parse_hash;
9843 sort_by_digest = sort_by_digest_4_4;
9844 opti_type = OPTI_TYPE_ZERO_BYTE;
9845 dgst_pos0 = 0;
9846 dgst_pos1 = 1;
9847 dgst_pos2 = 2;
9848 dgst_pos3 = 3;
9849 break;
9850
9851 case 11400: hash_type = HASH_TYPE_MD5;
9852 salt_type = SALT_TYPE_EMBEDDED;
9853 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9854 opts_type = OPTS_TYPE_PT_GENERATE_LE
9855 | OPTS_TYPE_PT_ADD80
9856 | OPTS_TYPE_HASH_COPY;
9857 kern_type = KERN_TYPE_SIP_AUTH;
9858 dgst_size = DGST_SIZE_4_4;
9859 parse_func = sip_auth_parse_hash;
9860 sort_by_digest = sort_by_digest_4_4;
9861 opti_type = OPTI_TYPE_ZERO_BYTE;
9862 dgst_pos0 = 0;
9863 dgst_pos1 = 3;
9864 dgst_pos2 = 2;
9865 dgst_pos3 = 1;
9866 break;
9867
9868 case 11500: hash_type = HASH_TYPE_CRC32;
9869 salt_type = SALT_TYPE_INTERN;
9870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9871 opts_type = OPTS_TYPE_PT_GENERATE_LE
9872 | OPTS_TYPE_ST_GENERATE_LE
9873 | OPTS_TYPE_ST_HEX;
9874 kern_type = KERN_TYPE_CRC32;
9875 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9876 parse_func = crc32_parse_hash;
9877 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9878 opti_type = OPTI_TYPE_ZERO_BYTE;
9879 dgst_pos0 = 0;
9880 dgst_pos1 = 1;
9881 dgst_pos2 = 2;
9882 dgst_pos3 = 3;
9883 break;
9884
9885 case 11600: hash_type = HASH_TYPE_AES;
9886 salt_type = SALT_TYPE_EMBEDDED;
9887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9888 opts_type = OPTS_TYPE_PT_GENERATE_LE
9889 | OPTS_TYPE_PT_NEVERCRACK;
9890 kern_type = KERN_TYPE_SEVEN_ZIP;
9891 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9892 parse_func = seven_zip_parse_hash;
9893 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9894 opti_type = OPTI_TYPE_ZERO_BYTE;
9895 dgst_pos0 = 0;
9896 dgst_pos1 = 1;
9897 dgst_pos2 = 2;
9898 dgst_pos3 = 3;
9899 break;
9900
9901 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9902 salt_type = SALT_TYPE_NONE;
9903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_PT_ADD01;
9906 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9907 dgst_size = DGST_SIZE_4_8;
9908 parse_func = gost2012sbog_256_parse_hash;
9909 sort_by_digest = sort_by_digest_4_8;
9910 opti_type = OPTI_TYPE_ZERO_BYTE;
9911 dgst_pos0 = 0;
9912 dgst_pos1 = 1;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 3;
9915 break;
9916
9917 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9918 salt_type = SALT_TYPE_NONE;
9919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_LE
9921 | OPTS_TYPE_PT_ADD01;
9922 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9923 dgst_size = DGST_SIZE_4_16;
9924 parse_func = gost2012sbog_512_parse_hash;
9925 sort_by_digest = sort_by_digest_4_16;
9926 opti_type = OPTI_TYPE_ZERO_BYTE;
9927 dgst_pos0 = 0;
9928 dgst_pos1 = 1;
9929 dgst_pos2 = 2;
9930 dgst_pos3 = 3;
9931 break;
9932
9933 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9934 salt_type = SALT_TYPE_EMBEDDED;
9935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9936 opts_type = OPTS_TYPE_PT_GENERATE_LE
9937 | OPTS_TYPE_ST_BASE64
9938 | OPTS_TYPE_HASH_COPY;
9939 kern_type = KERN_TYPE_PBKDF2_MD5;
9940 dgst_size = DGST_SIZE_4_32;
9941 parse_func = pbkdf2_md5_parse_hash;
9942 sort_by_digest = sort_by_digest_4_32;
9943 opti_type = OPTI_TYPE_ZERO_BYTE;
9944 dgst_pos0 = 0;
9945 dgst_pos1 = 1;
9946 dgst_pos2 = 2;
9947 dgst_pos3 = 3;
9948 break;
9949
9950 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9951 salt_type = SALT_TYPE_EMBEDDED;
9952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9953 opts_type = OPTS_TYPE_PT_GENERATE_LE
9954 | OPTS_TYPE_ST_BASE64
9955 | OPTS_TYPE_HASH_COPY;
9956 kern_type = KERN_TYPE_PBKDF2_SHA1;
9957 dgst_size = DGST_SIZE_4_32;
9958 parse_func = pbkdf2_sha1_parse_hash;
9959 sort_by_digest = sort_by_digest_4_32;
9960 opti_type = OPTI_TYPE_ZERO_BYTE;
9961 dgst_pos0 = 0;
9962 dgst_pos1 = 1;
9963 dgst_pos2 = 2;
9964 dgst_pos3 = 3;
9965 break;
9966
9967 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9968 salt_type = SALT_TYPE_EMBEDDED;
9969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970 opts_type = OPTS_TYPE_PT_GENERATE_LE
9971 | OPTS_TYPE_ST_BASE64
9972 | OPTS_TYPE_HASH_COPY;
9973 kern_type = KERN_TYPE_PBKDF2_SHA512;
9974 dgst_size = DGST_SIZE_8_16;
9975 parse_func = pbkdf2_sha512_parse_hash;
9976 sort_by_digest = sort_by_digest_8_16;
9977 opti_type = OPTI_TYPE_ZERO_BYTE
9978 | OPTI_TYPE_USES_BITS_64;
9979 dgst_pos0 = 0;
9980 dgst_pos1 = 1;
9981 dgst_pos2 = 2;
9982 dgst_pos3 = 3;
9983 break;
9984
9985 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9986 salt_type = SALT_TYPE_EMBEDDED;
9987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9989 kern_type = KERN_TYPE_ECRYPTFS;
9990 dgst_size = DGST_SIZE_8_8;
9991 parse_func = ecryptfs_parse_hash;
9992 sort_by_digest = sort_by_digest_8_8;
9993 opti_type = OPTI_TYPE_ZERO_BYTE
9994 | OPTI_TYPE_USES_BITS_64;
9995 dgst_pos0 = 0;
9996 dgst_pos1 = 1;
9997 dgst_pos2 = 2;
9998 dgst_pos3 = 3;
9999 break;
10000
10001 case 12300: hash_type = HASH_TYPE_ORACLET;
10002 salt_type = SALT_TYPE_EMBEDDED;
10003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10005 kern_type = KERN_TYPE_ORACLET;
10006 dgst_size = DGST_SIZE_8_16;
10007 parse_func = oraclet_parse_hash;
10008 sort_by_digest = sort_by_digest_8_16;
10009 opti_type = OPTI_TYPE_ZERO_BYTE
10010 | OPTI_TYPE_USES_BITS_64;
10011 dgst_pos0 = 0;
10012 dgst_pos1 = 1;
10013 dgst_pos2 = 2;
10014 dgst_pos3 = 3;
10015 break;
10016
10017 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10018 salt_type = SALT_TYPE_EMBEDDED;
10019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10020 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10021 kern_type = KERN_TYPE_BSDICRYPT;
10022 dgst_size = DGST_SIZE_4_4;
10023 parse_func = bsdicrypt_parse_hash;
10024 sort_by_digest = sort_by_digest_4_4;
10025 opti_type = OPTI_TYPE_ZERO_BYTE
10026 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 12500: hash_type = HASH_TYPE_RAR3HP;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10037 kern_type = KERN_TYPE_RAR3;
10038 dgst_size = DGST_SIZE_4_4;
10039 parse_func = rar3hp_parse_hash;
10040 sort_by_digest = sort_by_digest_4_4;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 12600: hash_type = HASH_TYPE_SHA256;
10049 salt_type = SALT_TYPE_INTERN;
10050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_BE
10052 | OPTS_TYPE_PT_ADD80;
10053 kern_type = KERN_TYPE_CF10;
10054 dgst_size = DGST_SIZE_4_8;
10055 parse_func = cf10_parse_hash;
10056 sort_by_digest = sort_by_digest_4_8;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_PRECOMPUTE_INIT
10059 | OPTI_TYPE_EARLY_SKIP
10060 | OPTI_TYPE_NOT_ITERATED;
10061 dgst_pos0 = 3;
10062 dgst_pos1 = 7;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 6;
10065 break;
10066
10067 case 12700: hash_type = HASH_TYPE_AES;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE
10071 | OPTS_TYPE_HASH_COPY;
10072 kern_type = KERN_TYPE_MYWALLET;
10073 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10074 parse_func = mywallet_parse_hash;
10075 sort_by_digest = sort_by_digest_4_5;
10076 opti_type = OPTI_TYPE_ZERO_BYTE;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10087 kern_type = KERN_TYPE_MS_DRSR;
10088 dgst_size = DGST_SIZE_4_8;
10089 parse_func = ms_drsr_parse_hash;
10090 sort_by_digest = sort_by_digest_4_8;
10091 opti_type = OPTI_TYPE_ZERO_BYTE;
10092 dgst_pos0 = 0;
10093 dgst_pos1 = 1;
10094 dgst_pos2 = 2;
10095 dgst_pos3 = 3;
10096 break;
10097
10098 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10099 salt_type = SALT_TYPE_EMBEDDED;
10100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10102 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10103 dgst_size = DGST_SIZE_4_8;
10104 parse_func = androidfde_samsung_parse_hash;
10105 sort_by_digest = sort_by_digest_4_8;
10106 opti_type = OPTI_TYPE_ZERO_BYTE;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 1;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 3;
10111 break;
10112
10113 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10117 kern_type = KERN_TYPE_RAR5;
10118 dgst_size = DGST_SIZE_4_4;
10119 parse_func = rar5_parse_hash;
10120 sort_by_digest = sort_by_digest_4_4;
10121 opti_type = OPTI_TYPE_ZERO_BYTE;
10122 dgst_pos0 = 0;
10123 dgst_pos1 = 1;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 3;
10126 break;
10127
10128 default: usage_mini_print (PROGNAME); return (-1);
10129 }
10130
10131 /**
10132 * transpose
10133 */
10134
10135 data.parse_func = parse_func;
10136
10137 /**
10138 * misc stuff
10139 */
10140
10141 if (hex_salt)
10142 {
10143 if (salt_type == SALT_TYPE_INTERN)
10144 {
10145 opts_type |= OPTS_TYPE_ST_HEX;
10146 }
10147 else
10148 {
10149 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10150
10151 return (-1);
10152 }
10153 }
10154
10155 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10156 | (salt_type == SALT_TYPE_EXTERN)
10157 | (salt_type == SALT_TYPE_EMBEDDED)
10158 | (salt_type == SALT_TYPE_VIRTUAL));
10159
10160 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10161
10162 data.hash_type = hash_type;
10163 data.attack_mode = attack_mode;
10164 data.attack_kern = attack_kern;
10165 data.attack_exec = attack_exec;
10166 data.kern_type = kern_type;
10167 data.opts_type = opts_type;
10168 data.dgst_size = dgst_size;
10169 data.salt_type = salt_type;
10170 data.isSalted = isSalted;
10171 data.sort_by_digest = sort_by_digest;
10172 data.dgst_pos0 = dgst_pos0;
10173 data.dgst_pos1 = dgst_pos1;
10174 data.dgst_pos2 = dgst_pos2;
10175 data.dgst_pos3 = dgst_pos3;
10176
10177 esalt_size = 0;
10178
10179 switch (hash_mode)
10180 {
10181 case 2500: esalt_size = sizeof (wpa_t); break;
10182 case 5300: esalt_size = sizeof (ikepsk_t); break;
10183 case 5400: esalt_size = sizeof (ikepsk_t); break;
10184 case 5500: esalt_size = sizeof (netntlm_t); break;
10185 case 5600: esalt_size = sizeof (netntlm_t); break;
10186 case 6211:
10187 case 6212:
10188 case 6213:
10189 case 6221:
10190 case 6222:
10191 case 6223:
10192 case 6231:
10193 case 6232:
10194 case 6233:
10195 case 6241:
10196 case 6242:
10197 case 6243: esalt_size = sizeof (tc_t); break;
10198 case 6600: esalt_size = sizeof (agilekey_t); break;
10199 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10200 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10201 case 7300: esalt_size = sizeof (rakp_t); break;
10202 case 7500: esalt_size = sizeof (krb5pa_t); break;
10203 case 8200: esalt_size = sizeof (cloudkey_t); break;
10204 case 8800: esalt_size = sizeof (androidfde_t); break;
10205 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10206 case 9400: esalt_size = sizeof (office2007_t); break;
10207 case 9500: esalt_size = sizeof (office2010_t); break;
10208 case 9600: esalt_size = sizeof (office2013_t); break;
10209 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10210 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10211 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10212 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10213 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10214 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10215 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10216 case 10200: esalt_size = sizeof (cram_md5_t); break;
10217 case 10400: esalt_size = sizeof (pdf_t); break;
10218 case 10410: esalt_size = sizeof (pdf_t); break;
10219 case 10420: esalt_size = sizeof (pdf_t); break;
10220 case 10500: esalt_size = sizeof (pdf_t); break;
10221 case 10600: esalt_size = sizeof (pdf_t); break;
10222 case 10700: esalt_size = sizeof (pdf_t); break;
10223 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10224 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10225 case 11400: esalt_size = sizeof (sip_t); break;
10226 case 11600: esalt_size = sizeof (seven_zip_t); break;
10227 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10228 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10229 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10230 case 13000: esalt_size = sizeof (rar5_t); break;
10231 }
10232
10233 data.esalt_size = esalt_size;
10234
10235 /**
10236 * choose dictionary parser
10237 */
10238
10239 if (hash_type == HASH_TYPE_LM)
10240 {
10241 get_next_word_func = get_next_word_lm;
10242 }
10243 else if (opts_type & OPTS_TYPE_PT_UPPER)
10244 {
10245 get_next_word_func = get_next_word_uc;
10246 }
10247 else
10248 {
10249 get_next_word_func = get_next_word_std;
10250 }
10251
10252 /**
10253 * dictstat
10254 */
10255
10256 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10257
10258 #ifdef _POSIX
10259 size_t dictstat_nmemb = 0;
10260 #endif
10261
10262 #ifdef _WIN
10263 uint dictstat_nmemb = 0;
10264 #endif
10265
10266 char dictstat[256] = { 0 };
10267
10268 FILE *dictstat_fp = NULL;
10269
10270 if (keyspace == 0)
10271 {
10272 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10273
10274 dictstat_fp = fopen (dictstat, "rb");
10275
10276 if (dictstat_fp)
10277 {
10278 #ifdef _POSIX
10279 struct stat tmpstat;
10280
10281 fstat (fileno (dictstat_fp), &tmpstat);
10282 #endif
10283
10284 #ifdef _WIN
10285 struct stat64 tmpstat;
10286
10287 _fstat64 (fileno (dictstat_fp), &tmpstat);
10288 #endif
10289
10290 if (tmpstat.st_mtime < COMPTIME)
10291 {
10292 /* with v0.15 the format changed so we have to ensure user is using a good version
10293 since there is no version-header in the dictstat file */
10294
10295 fclose (dictstat_fp);
10296
10297 unlink (dictstat);
10298 }
10299 else
10300 {
10301 while (!feof (dictstat_fp))
10302 {
10303 dictstat_t d;
10304
10305 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10306
10307 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10308
10309 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10310 {
10311 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10312
10313 return -1;
10314 }
10315 }
10316
10317 fclose (dictstat_fp);
10318 }
10319 }
10320 }
10321
10322 /**
10323 * potfile
10324 */
10325
10326 char potfile[256] = { 0 };
10327
10328 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10329
10330 data.pot_fp = NULL;
10331
10332 FILE *out_fp = NULL;
10333 FILE *pot_fp = NULL;
10334
10335 if (show == 1 || left == 1)
10336 {
10337 pot_fp = fopen (potfile, "rb");
10338
10339 if (pot_fp == NULL)
10340 {
10341 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10342
10343 return (-1);
10344 }
10345
10346 if (outfile != NULL)
10347 {
10348 if ((out_fp = fopen (outfile, "ab")) == NULL)
10349 {
10350 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10351
10352 fclose (pot_fp);
10353
10354 return (-1);
10355 }
10356 }
10357 else
10358 {
10359 out_fp = stdout;
10360 }
10361 }
10362 else
10363 {
10364 if (potfile_disable == 0)
10365 {
10366 pot_fp = fopen (potfile, "ab");
10367
10368 if (pot_fp == NULL)
10369 {
10370 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10371
10372 return (-1);
10373 }
10374
10375 data.pot_fp = pot_fp;
10376 }
10377 }
10378
10379 pot_t *pot = NULL;
10380
10381 uint pot_cnt = 0;
10382 uint pot_avail = 0;
10383
10384 if (show == 1 || left == 1)
10385 {
10386 SUPPRESS_OUTPUT = 1;
10387
10388 pot_avail = count_lines (pot_fp);
10389
10390 rewind (pot_fp);
10391
10392 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10393
10394 uint pot_hashes_avail = 0;
10395
10396 uint line_num = 0;
10397
10398 while (!feof (pot_fp))
10399 {
10400 line_num++;
10401
10402 char line_buf[BUFSIZ] = { 0 };
10403
10404 int line_len = fgetl (pot_fp, line_buf);
10405
10406 if (line_len == 0) continue;
10407
10408 char *plain_buf = line_buf + line_len;
10409
10410 pot_t *pot_ptr = &pot[pot_cnt];
10411
10412 hash_t *hashes_buf = &pot_ptr->hash;
10413
10414 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10415 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10416
10417 if (pot_cnt == pot_hashes_avail)
10418 {
10419 uint pos = 0;
10420
10421 for (pos = 0; pos < INCR_POT; pos++)
10422 {
10423 if ((pot_cnt + pos) >= pot_avail) break;
10424
10425 pot_t *tmp_pot = &pot[pot_cnt + pos];
10426
10427 hash_t *tmp_hash = &tmp_pot->hash;
10428
10429 tmp_hash->digest = mymalloc (dgst_size);
10430
10431 if (isSalted)
10432 {
10433 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10434 }
10435
10436 if (esalt_size)
10437 {
10438 tmp_hash->esalt = mymalloc (esalt_size);
10439 }
10440
10441 pot_hashes_avail++;
10442 }
10443 }
10444
10445 int plain_len = 0;
10446
10447 int parser_status;
10448
10449 int iter = MAX_CUT_TRIES;
10450
10451 do
10452 {
10453 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10454 {
10455 if (line_buf[i] == ':')
10456 {
10457 line_len--;
10458
10459 break;
10460 }
10461 }
10462
10463 if (data.hash_mode != 2500)
10464 {
10465 parser_status = parse_func (line_buf, line_len, hashes_buf);
10466 }
10467 else
10468 {
10469 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10470
10471 if (line_len > max_salt_size)
10472 {
10473 parser_status = PARSER_GLOBAL_LENGTH;
10474 }
10475 else
10476 {
10477 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10478
10479 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10480
10481 hashes_buf->salt->salt_len = line_len;
10482
10483 parser_status = PARSER_OK;
10484 }
10485 }
10486
10487 // if NOT parsed without error, we add the ":" to the plain
10488
10489 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10490 {
10491 plain_len++;
10492 plain_buf--;
10493 }
10494
10495 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10496
10497 if (parser_status < PARSER_GLOBAL_ZERO)
10498 {
10499 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10500
10501 continue;
10502 }
10503
10504 if (plain_len >= 255) continue;
10505
10506 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10507
10508 pot_ptr->plain_len = plain_len;
10509
10510 pot_cnt++;
10511 }
10512
10513 fclose (pot_fp);
10514
10515 SUPPRESS_OUTPUT = 0;
10516
10517 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10518 }
10519
10520 /**
10521 * word len
10522 */
10523
10524 uint pw_min = PW_MIN;
10525 uint pw_max = PW_MAX;
10526
10527 switch (hash_mode)
10528 {
10529 case 400: if (pw_max > 40) pw_max = 40;
10530 break;
10531 case 500: if (pw_max > 16) pw_max = 16;
10532 break;
10533 case 1500: if (pw_max > 8) pw_max = 8;
10534 break;
10535 case 1600: if (pw_max > 16) pw_max = 16;
10536 break;
10537 case 1800: if (pw_max > 16) pw_max = 16;
10538 break;
10539 case 2100: if (pw_max > 16) pw_max = 16;
10540 break;
10541 case 2500: if (pw_min < 8) pw_min = 8;
10542 break;
10543 case 3000: if (pw_max > 7) pw_max = 7;
10544 break;
10545 case 5200: if (pw_max > 24) pw_max = 24;
10546 break;
10547 case 5800: if (pw_max > 16) pw_max = 16;
10548 break;
10549 case 6300: if (pw_max > 16) pw_max = 16;
10550 break;
10551 case 7400: if (pw_max > 16) pw_max = 16;
10552 break;
10553 case 7900: if (pw_max > 48) pw_max = 48;
10554 break;
10555 case 8500: if (pw_max > 8) pw_max = 8;
10556 break;
10557 case 8600: if (pw_max > 16) pw_max = 16;
10558 break;
10559 case 9710: pw_min = 5;
10560 pw_max = 5;
10561 break;
10562 case 9810: pw_min = 5;
10563 pw_max = 5;
10564 break;
10565 case 10410: pw_min = 5;
10566 pw_max = 5;
10567 break;
10568 case 10300: if (pw_max < 3) pw_min = 3;
10569 if (pw_max > 40) pw_max = 40;
10570 break;
10571 case 10500: if (pw_max < 3) pw_min = 3;
10572 if (pw_max > 40) pw_max = 40;
10573 break;
10574 case 10700: if (pw_max > 16) pw_max = 16;
10575 break;
10576 case 11300: if (pw_max > 40) pw_max = 40;
10577 break;
10578 case 12500: if (pw_max > 20) pw_max = 20;
10579 break;
10580 case 12800: if (pw_max > 24) pw_max = 24;
10581 break;
10582 }
10583
10584 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10585 {
10586 switch (attack_kern)
10587 {
10588 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10589 break;
10590 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10591 break;
10592 }
10593 }
10594
10595 /**
10596 * charsets : keep them together for more easy maintainnce
10597 */
10598
10599 cs_t mp_sys[6] = { { { 0 }, 0 } };
10600 cs_t mp_usr[4] = { { { 0 }, 0 } };
10601
10602 mp_setup_sys (mp_sys);
10603
10604 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10605 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10606 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10607 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10608
10609 /**
10610 * load hashes, part I: find input mode, count hashes
10611 */
10612
10613 uint hashlist_mode = 0;
10614 uint hashlist_format = HLFMT_HASHCAT;
10615
10616 uint hashes_avail = 0;
10617
10618 if (benchmark == 0)
10619 {
10620 struct stat f;
10621
10622 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10623
10624 if ((hash_mode == 2500) ||
10625 (hash_mode == 5200) ||
10626 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10627 (hash_mode == 9000))
10628 {
10629 hashlist_mode = HL_MODE_ARG;
10630
10631 char *hashfile = myargv[optind];
10632
10633 data.hashfile = hashfile;
10634
10635 logfile_top_var_string ("target", hashfile);
10636 }
10637
10638 if (hashlist_mode == HL_MODE_ARG)
10639 {
10640 if (hash_mode == 2500)
10641 {
10642 struct stat st;
10643
10644 if (stat (data.hashfile, &st) == -1)
10645 {
10646 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10647
10648 return (-1);
10649 }
10650
10651 hashes_avail = st.st_size / sizeof (hccap_t);
10652 }
10653 else
10654 {
10655 hashes_avail = 1;
10656 }
10657 }
10658 else if (hashlist_mode == HL_MODE_FILE)
10659 {
10660 char *hashfile = myargv[optind];
10661
10662 data.hashfile = hashfile;
10663
10664 logfile_top_var_string ("target", hashfile);
10665
10666 FILE *fp = NULL;
10667
10668 if ((fp = fopen (hashfile, "rb")) == NULL)
10669 {
10670 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10671
10672 return (-1);
10673 }
10674
10675 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10676
10677 hashes_avail = count_lines (fp);
10678
10679 rewind (fp);
10680
10681 if (hashes_avail == 0)
10682 {
10683 log_error ("ERROR: hashfile is empty or corrupt");
10684
10685 fclose (fp);
10686
10687 return (-1);
10688 }
10689
10690 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10691
10692 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10693 {
10694 log_error ("ERROR: remove not supported in native hashfile-format mode");
10695
10696 fclose (fp);
10697
10698 return (-1);
10699 }
10700
10701 fclose (fp);
10702 }
10703 }
10704 else
10705 {
10706 hashlist_mode = HL_MODE_ARG;
10707
10708 hashes_avail = 1;
10709 }
10710
10711 if (hash_mode == 3000) hashes_avail *= 2;
10712
10713 data.hashlist_mode = hashlist_mode;
10714 data.hashlist_format = hashlist_format;
10715
10716 logfile_top_uint (hashlist_mode);
10717 logfile_top_uint (hashlist_format);
10718
10719 /**
10720 * load hashes, part II: allocate required memory, set pointers
10721 */
10722
10723 hash_t *hashes_buf = NULL;
10724 void *digests_buf = NULL;
10725 salt_t *salts_buf = NULL;
10726 void *esalts_buf = NULL;
10727
10728 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10729
10730 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10731
10732 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10733 {
10734 u32 hash_pos;
10735
10736 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10737 {
10738 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10739
10740 hashes_buf[hash_pos].hash_info = hash_info;
10741
10742 if (username && (remove || show || left))
10743 {
10744 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10745 }
10746
10747 if (benchmark)
10748 {
10749 hash_info->orighash = (char *) mymalloc (256);
10750 }
10751 }
10752 }
10753
10754 if (isSalted)
10755 {
10756 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10757
10758 if (esalt_size)
10759 {
10760 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10761 }
10762 }
10763 else
10764 {
10765 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10766 }
10767
10768 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10769 {
10770 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10771
10772 if (isSalted)
10773 {
10774 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10775
10776 if (esalt_size)
10777 {
10778 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10779 }
10780 }
10781 else
10782 {
10783 hashes_buf[hash_pos].salt = &salts_buf[0];
10784 }
10785 }
10786
10787 /**
10788 * load hashes, part III: parse hashes or generate them if benchmark
10789 */
10790
10791 uint hashes_cnt = 0;
10792
10793 if (benchmark == 0)
10794 {
10795 if (keyspace == 1)
10796 {
10797 // useless to read hash file for keyspace, cheat a little bit w/ optind
10798 }
10799 else if (hashes_avail == 0)
10800 {
10801 }
10802 else if (hashlist_mode == HL_MODE_ARG)
10803 {
10804 char *input_buf = myargv[optind];
10805
10806 uint input_len = strlen (input_buf);
10807
10808 logfile_top_var_string ("target", input_buf);
10809
10810 char *hash_buf = NULL;
10811 int hash_len = 0;
10812
10813 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10814
10815 if (hash_len)
10816 {
10817 if (opts_type & OPTS_TYPE_HASH_COPY)
10818 {
10819 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10820
10821 hash_info_tmp->orighash = mystrdup (hash_buf);
10822 }
10823
10824 if (isSalted)
10825 {
10826 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10827 }
10828
10829 int parser_status = PARSER_OK;
10830
10831 if (hash_mode == 2500)
10832 {
10833 if (hash_len == 0)
10834 {
10835 log_error ("ERROR: hccap file not specified");
10836
10837 return (-1);
10838 }
10839
10840 hashlist_mode = HL_MODE_FILE;
10841
10842 data.hashlist_mode = hashlist_mode;
10843
10844 FILE *fp = fopen (hash_buf, "rb");
10845
10846 if (fp == NULL)
10847 {
10848 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10849
10850 return (-1);
10851 }
10852
10853 if (hashes_avail < 1)
10854 {
10855 log_error ("ERROR: hccap file is empty or corrupt");
10856
10857 fclose (fp);
10858
10859 return (-1);
10860 }
10861
10862 uint hccap_size = sizeof (hccap_t);
10863
10864 char *in = (char *) mymalloc (hccap_size);
10865
10866 while (!feof (fp))
10867 {
10868 int n = fread (in, hccap_size, 1, fp);
10869
10870 if (n != 1)
10871 {
10872 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10873
10874 break;
10875 }
10876
10877 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10878
10879 if (parser_status != PARSER_OK)
10880 {
10881 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10882
10883 continue;
10884 }
10885
10886 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10887
10888 if ((show == 1) || (left == 1))
10889 {
10890 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10891
10892 char *salt_ptr = (char *) tmp_salt->salt_buf;
10893
10894 int cur_pos = tmp_salt->salt_len;
10895 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10896
10897 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10898
10899 u8 *pke_ptr = (u8 *) wpa->pke;
10900
10901 // do the appending task
10902
10903 snprintf (salt_ptr + cur_pos,
10904 rem_len,
10905 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10906 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10907 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10908
10909
10910 // memset () the remaining part of the salt
10911
10912 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10913 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10914
10915 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10916
10917 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10918 }
10919
10920 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);
10921 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);
10922
10923 hashes_cnt++;
10924 }
10925
10926 fclose (fp);
10927
10928 myfree (in);
10929 }
10930 else if (hash_mode == 3000)
10931 {
10932 if (hash_len == 32)
10933 {
10934 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10935
10936 hash_t *lm_hash_left = NULL;
10937
10938 if (parser_status == PARSER_OK)
10939 {
10940 lm_hash_left = &hashes_buf[hashes_cnt];
10941
10942 hashes_cnt++;
10943 }
10944 else
10945 {
10946 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10947 }
10948
10949 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10950
10951 hash_t *lm_hash_right = NULL;
10952
10953 if (parser_status == PARSER_OK)
10954 {
10955 lm_hash_right = &hashes_buf[hashes_cnt];
10956
10957 hashes_cnt++;
10958 }
10959 else
10960 {
10961 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10962 }
10963
10964 // show / left
10965
10966 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10967 {
10968 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);
10969 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);
10970 }
10971 }
10972 else
10973 {
10974 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10975
10976 if (parser_status == PARSER_OK)
10977 {
10978 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10979 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10980 }
10981
10982 if (parser_status == PARSER_OK)
10983 {
10984 hashes_cnt++;
10985 }
10986 else
10987 {
10988 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10989 }
10990 }
10991 }
10992 else
10993 {
10994 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10995
10996 if (parser_status == PARSER_OK)
10997 {
10998 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10999 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11000 }
11001
11002 if (parser_status == PARSER_OK)
11003 {
11004 hashes_cnt++;
11005 }
11006 else
11007 {
11008 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11009 }
11010 }
11011 }
11012 }
11013 else if (hashlist_mode == HL_MODE_FILE)
11014 {
11015 char *hashfile = data.hashfile;
11016
11017 FILE *fp;
11018
11019 if ((fp = fopen (hashfile, "rb")) == NULL)
11020 {
11021 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11022
11023 return (-1);
11024 }
11025
11026 uint line_num = 0;
11027
11028 while (!feof (fp))
11029 {
11030 line_num++;
11031
11032 char line_buf[BUFSIZ] = { 0 };
11033
11034 int line_len = fgetl (fp, line_buf);
11035
11036 if (line_len == 0) continue;
11037
11038 char *hash_buf = NULL;
11039 int hash_len = 0;
11040
11041 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11042
11043 if (username)
11044 {
11045 char *user_buf = NULL;
11046 int user_len = 0;
11047
11048 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11049
11050 if (remove || show)
11051 {
11052 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11053
11054 *user = (user_t *) mymalloc (sizeof (user_t));
11055
11056 user_t *user_ptr = *user;
11057
11058 if (user_buf != NULL)
11059 {
11060 user_ptr->user_name = mystrdup (user_buf);
11061 }
11062 else
11063 {
11064 user_ptr->user_name = mystrdup ("");
11065 }
11066
11067 user_ptr->user_len = user_len;
11068 }
11069 }
11070
11071 if (opts_type & OPTS_TYPE_HASH_COPY)
11072 {
11073 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11074
11075 hash_info_tmp->orighash = mystrdup (hash_buf);
11076 }
11077
11078 if (isSalted)
11079 {
11080 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11081 }
11082
11083 if (hash_mode == 3000)
11084 {
11085 if (hash_len == 32)
11086 {
11087 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11088
11089 if (parser_status < PARSER_GLOBAL_ZERO)
11090 {
11091 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11092
11093 continue;
11094 }
11095
11096 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11097
11098 hashes_cnt++;
11099
11100 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11101
11102 if (parser_status < PARSER_GLOBAL_ZERO)
11103 {
11104 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11105
11106 continue;
11107 }
11108
11109 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11110
11111 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);
11112
11113 hashes_cnt++;
11114
11115 // show / left
11116
11117 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);
11118 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);
11119 }
11120 else
11121 {
11122 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11123
11124 if (parser_status < PARSER_GLOBAL_ZERO)
11125 {
11126 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11127
11128 continue;
11129 }
11130
11131 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);
11132
11133 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11134 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11135
11136 hashes_cnt++;
11137 }
11138 }
11139 else
11140 {
11141 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11142
11143 if (parser_status < PARSER_GLOBAL_ZERO)
11144 {
11145 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11146
11147 continue;
11148 }
11149
11150 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);
11151
11152 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11153 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11154
11155 hashes_cnt++;
11156 }
11157 }
11158
11159 fclose (fp);
11160
11161 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11162
11163 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11164 }
11165 }
11166 else
11167 {
11168 if (isSalted)
11169 {
11170 hashes_buf[0].salt->salt_len = 8;
11171
11172 // special salt handling
11173
11174 switch (hash_mode)
11175 {
11176 case 1500: hashes_buf[0].salt->salt_len = 2;
11177 break;
11178 case 1731: hashes_buf[0].salt->salt_len = 4;
11179 break;
11180 case 2410: hashes_buf[0].salt->salt_len = 4;
11181 break;
11182 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11183 break;
11184 case 3100: hashes_buf[0].salt->salt_len = 1;
11185 break;
11186 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11187 break;
11188 case 5800: hashes_buf[0].salt->salt_len = 16;
11189 break;
11190 case 6800: hashes_buf[0].salt->salt_len = 32;
11191 break;
11192 case 8400: hashes_buf[0].salt->salt_len = 40;
11193 break;
11194 case 8800: hashes_buf[0].salt->salt_len = 16;
11195 break;
11196 case 8900: hashes_buf[0].salt->salt_len = 16;
11197 hashes_buf[0].salt->scrypt_N = 1024;
11198 hashes_buf[0].salt->scrypt_r = 1;
11199 hashes_buf[0].salt->scrypt_p = 1;
11200 break;
11201 case 9100: hashes_buf[0].salt->salt_len = 16;
11202 break;
11203 case 9300: hashes_buf[0].salt->salt_len = 14;
11204 hashes_buf[0].salt->scrypt_N = 16384;
11205 hashes_buf[0].salt->scrypt_r = 1;
11206 hashes_buf[0].salt->scrypt_p = 1;
11207 break;
11208 case 9400: hashes_buf[0].salt->salt_len = 16;
11209 break;
11210 case 9500: hashes_buf[0].salt->salt_len = 16;
11211 break;
11212 case 9600: hashes_buf[0].salt->salt_len = 16;
11213 break;
11214 case 9700: hashes_buf[0].salt->salt_len = 16;
11215 break;
11216 case 9710: hashes_buf[0].salt->salt_len = 16;
11217 break;
11218 case 9720: hashes_buf[0].salt->salt_len = 16;
11219 break;
11220 case 9800: hashes_buf[0].salt->salt_len = 16;
11221 break;
11222 case 9810: hashes_buf[0].salt->salt_len = 16;
11223 break;
11224 case 9820: hashes_buf[0].salt->salt_len = 16;
11225 break;
11226 case 10300: hashes_buf[0].salt->salt_len = 12;
11227 break;
11228 case 11500: hashes_buf[0].salt->salt_len = 4;
11229 break;
11230 case 11600: hashes_buf[0].salt->salt_len = 4;
11231 break;
11232 case 12400: hashes_buf[0].salt->salt_len = 4;
11233 break;
11234 case 12500: hashes_buf[0].salt->salt_len = 8;
11235 break;
11236 case 12600: hashes_buf[0].salt->salt_len = 64;
11237 break;
11238 }
11239
11240 // special esalt handling
11241
11242 switch (hash_mode)
11243 {
11244 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11245 break;
11246 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11247 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11248 break;
11249 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11250 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11251 break;
11252 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11253 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11254 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11255 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11256 break;
11257 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11258 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11259 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11260 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11261 break;
11262 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11263 break;
11264 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11265 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11266 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11267 break;
11268 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11269 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11270 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11271 break;
11272 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11273 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11274 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11275 break;
11276 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11277 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11278 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11279 break;
11280 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11281 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11282 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11283 break;
11284 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11285 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11286 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11287 break;
11288 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11289 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11290 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11291 break;
11292 }
11293 }
11294
11295 // set hashfile
11296
11297 switch (hash_mode)
11298 {
11299 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11300 break;
11301 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11302 break;
11303 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11304 break;
11305 case 6211:
11306 case 6212:
11307 case 6213:
11308 case 6221:
11309 case 6222:
11310 case 6223:
11311 case 6231:
11312 case 6232:
11313 case 6233:
11314 case 6241:
11315 case 6242:
11316 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11317 break;
11318 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11319 break;
11320 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11321 break;
11322 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11323 break;
11324 }
11325
11326 // set default iterations
11327
11328 switch (hash_mode)
11329 {
11330 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11331 break;
11332 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11333 break;
11334 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11335 break;
11336 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11337 break;
11338 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11339 break;
11340 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11341 break;
11342 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11343 break;
11344 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11345 break;
11346 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11347 break;
11348 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11349 break;
11350 case 6211:
11351 case 6212:
11352 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11353 break;
11354 case 6221:
11355 case 6222:
11356 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11357 break;
11358 case 6231:
11359 case 6232:
11360 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11361 break;
11362 case 6241:
11363 case 6242:
11364 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11365 break;
11366 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11367 break;
11368 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11369 break;
11370 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11371 break;
11372 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11373 break;
11374 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11375 break;
11376 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11377 break;
11378 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11379 break;
11380 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11381 break;
11382 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11383 break;
11384 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11385 break;
11386 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11387 break;
11388 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11389 break;
11390 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11391 break;
11392 case 8900: hashes_buf[0].salt->salt_iter = 1;
11393 break;
11394 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11395 break;
11396 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11397 break;
11398 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11399 break;
11400 case 9300: hashes_buf[0].salt->salt_iter = 1;
11401 break;
11402 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11403 break;
11404 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11405 break;
11406 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11407 break;
11408 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11409 break;
11410 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11411 break;
11412 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11413 break;
11414 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11415 break;
11416 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11417 break;
11418 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11419 break;
11420 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11421 break;
11422 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11423 break;
11424 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11425 break;
11426 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11427 break;
11428 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11429 break;
11430 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11431 break;
11432 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11433 break;
11434 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11435 break;
11436 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11437 break;
11438 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11439 break;
11440 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11441 break;
11442 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11443 break;
11444 }
11445
11446 hashes_cnt = 1;
11447 }
11448
11449 if (show == 1 || left == 1)
11450 {
11451 for (uint i = 0; i < pot_cnt; i++)
11452 {
11453 pot_t *pot_ptr = &pot[i];
11454
11455 hash_t *hashes_buf = &pot_ptr->hash;
11456
11457 local_free (hashes_buf->digest);
11458
11459 if (isSalted)
11460 {
11461 local_free (hashes_buf->salt);
11462 }
11463 }
11464
11465 local_free (pot);
11466
11467 if (data.quiet == 0) log_info_nn ("");
11468
11469 return (0);
11470 }
11471
11472 if (keyspace == 0)
11473 {
11474 if (hashes_cnt == 0)
11475 {
11476 log_error ("ERROR: No hashes loaded");
11477
11478 return (-1);
11479 }
11480 }
11481
11482 /**
11483 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11484 */
11485
11486 if (data.outfile != NULL)
11487 {
11488 if (data.hashfile != NULL)
11489 {
11490 #ifdef _POSIX
11491 struct stat tmpstat_outfile;
11492 struct stat tmpstat_hashfile;
11493 #endif
11494
11495 #ifdef _WIN
11496 struct stat64 tmpstat_outfile;
11497 struct stat64 tmpstat_hashfile;
11498 #endif
11499
11500 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11501
11502 if (tmp_outfile_fp)
11503 {
11504 #ifdef _POSIX
11505 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11506 #endif
11507
11508 #ifdef _WIN
11509 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11510 #endif
11511
11512 fclose (tmp_outfile_fp);
11513 }
11514
11515 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11516
11517 if (tmp_hashfile_fp)
11518 {
11519 #ifdef _POSIX
11520 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11521 #endif
11522
11523 #ifdef _WIN
11524 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11525 #endif
11526
11527 fclose (tmp_hashfile_fp);
11528 }
11529
11530 if (tmp_outfile_fp && tmp_outfile_fp)
11531 {
11532 tmpstat_outfile.st_mode = 0;
11533 tmpstat_outfile.st_nlink = 0;
11534 tmpstat_outfile.st_uid = 0;
11535 tmpstat_outfile.st_gid = 0;
11536 tmpstat_outfile.st_rdev = 0;
11537 tmpstat_outfile.st_atime = 0;
11538
11539 tmpstat_hashfile.st_mode = 0;
11540 tmpstat_hashfile.st_nlink = 0;
11541 tmpstat_hashfile.st_uid = 0;
11542 tmpstat_hashfile.st_gid = 0;
11543 tmpstat_hashfile.st_rdev = 0;
11544 tmpstat_hashfile.st_atime = 0;
11545
11546 #ifdef _POSIX
11547 tmpstat_outfile.st_blksize = 0;
11548 tmpstat_outfile.st_blocks = 0;
11549
11550 tmpstat_hashfile.st_blksize = 0;
11551 tmpstat_hashfile.st_blocks = 0;
11552 #endif
11553
11554 #ifdef _POSIX
11555 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11556 {
11557 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11558
11559 return (-1);
11560 }
11561 #endif
11562
11563 #ifdef _WIN
11564 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11565 {
11566 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11567
11568 return (-1);
11569 }
11570 #endif
11571 }
11572 }
11573 }
11574
11575 /**
11576 * Remove duplicates
11577 */
11578
11579 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11580
11581 if (isSalted)
11582 {
11583 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11584 }
11585 else
11586 {
11587 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11588 }
11589
11590 uint hashes_cnt_orig = hashes_cnt;
11591
11592 hashes_cnt = 1;
11593
11594 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11595 {
11596 if (isSalted)
11597 {
11598 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11599 {
11600 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11601 }
11602 }
11603 else
11604 {
11605 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11606 }
11607
11608 if (hashes_pos > hashes_cnt)
11609 {
11610 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11611 }
11612
11613 hashes_cnt++;
11614 }
11615
11616 /**
11617 * Potfile removes
11618 */
11619
11620 uint potfile_remove_cracks = 0;
11621
11622 if (potfile_disable == 0)
11623 {
11624 hash_t hash_buf;
11625
11626 hash_buf.digest = mymalloc (dgst_size);
11627 hash_buf.salt = NULL;
11628 hash_buf.esalt = NULL;
11629 hash_buf.hash_info = NULL;
11630 hash_buf.cracked = 0;
11631
11632 if (isSalted)
11633 {
11634 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11635 }
11636
11637 if (esalt_size)
11638 {
11639 hash_buf.esalt = mymalloc (esalt_size);
11640 }
11641
11642 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11643
11644 // no solution for these special hash types (for instane because they use hashfile in output etc)
11645 if ((hash_mode != 5200) &&
11646 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11647 (hash_mode != 9000))
11648 {
11649 FILE *fp = fopen (potfile, "rb");
11650
11651 if (fp != NULL)
11652 {
11653 while (!feof (fp))
11654 {
11655 char line_buf[BUFSIZ] = { 0 };
11656
11657 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11658
11659 if (ptr == NULL) break;
11660
11661 int line_len = strlen (line_buf);
11662
11663 if (line_len == 0) continue;
11664
11665 int iter = MAX_CUT_TRIES;
11666
11667 for (int i = line_len - 1; i && iter; i--, line_len--)
11668 {
11669 if (line_buf[i] != ':') continue;
11670
11671 if (isSalted)
11672 {
11673 memset (hash_buf.salt, 0, sizeof (salt_t));
11674 }
11675
11676 hash_t *found = NULL;
11677
11678 if (hash_mode == 6800)
11679 {
11680 if (i < 64) // 64 = 16 * uint in salt_buf[]
11681 {
11682 // manipulate salt_buf
11683 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11684
11685 hash_buf.salt->salt_len = i;
11686
11687 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11688 }
11689 }
11690 else if (hash_mode == 2500)
11691 {
11692 if (i < 64) // 64 = 16 * uint in salt_buf[]
11693 {
11694 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11695 // manipulate salt_buf
11696
11697 // to be safe work with a copy (because of line_len loop, i etc)
11698
11699 char line_buf_cpy[BUFSIZ] = { 0 };
11700
11701 memcpy (line_buf_cpy, line_buf, i);
11702
11703 char *mac2_pos = strrchr (line_buf_cpy, ':');
11704
11705 if (mac2_pos == NULL) continue;
11706
11707 mac2_pos[0] = 0;
11708 mac2_pos++;
11709
11710 if (strlen (mac2_pos) != 12) continue;
11711
11712 char *mac1_pos = strrchr (line_buf_cpy, ':');
11713
11714 if (mac1_pos == NULL) continue;
11715
11716 mac1_pos[0] = 0;
11717 mac1_pos++;
11718
11719 if (strlen (mac1_pos) != 12) continue;
11720
11721 uint essid_length = mac1_pos - line_buf_cpy - 1;
11722
11723 // here we need the ESSID
11724 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11725
11726 hash_buf.salt->salt_len = essid_length;
11727
11728 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11729
11730 if (found)
11731 {
11732 wpa_t *wpa = (wpa_t *) found->esalt;
11733
11734 uint pke[25] = { 0 };
11735
11736 char *pke_ptr = (char *) pke;
11737
11738 for (uint i = 0; i < 25; i++)
11739 {
11740 pke[i] = byte_swap_32 (wpa->pke[i]);
11741 }
11742
11743 u8 mac1[6] = { 0 };
11744 u8 mac2[6] = { 0 };
11745
11746 memcpy (mac1, pke_ptr + 23, 6);
11747 memcpy (mac2, pke_ptr + 29, 6);
11748
11749 // compare hex string(s) vs binary MAC address(es)
11750
11751 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11752 {
11753 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11754 {
11755 found = NULL;
11756 break;
11757 }
11758 }
11759
11760 // early skip ;)
11761 if (!found) continue;
11762
11763 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11764 {
11765 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11766 {
11767 found = NULL;
11768 break;
11769 }
11770 }
11771 }
11772 }
11773 }
11774 else
11775 {
11776 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11777
11778 if (parser_status == PARSER_OK)
11779 {
11780 if (isSalted)
11781 {
11782 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11783 }
11784 else
11785 {
11786 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11787 }
11788 }
11789 }
11790
11791 if (found == NULL) continue;
11792
11793 if (!found->cracked) potfile_remove_cracks++;
11794
11795 found->cracked = 1;
11796
11797 if (found) break;
11798
11799 iter--;
11800 }
11801 }
11802
11803 fclose (fp);
11804 }
11805 }
11806
11807 if (esalt_size)
11808 {
11809 local_free (hash_buf.esalt);
11810 }
11811
11812 if (isSalted)
11813 {
11814 local_free (hash_buf.salt);
11815 }
11816
11817 local_free (hash_buf.digest);
11818 }
11819
11820 /**
11821 * Now generate all the buffers required for later
11822 */
11823
11824 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11825
11826 salt_t *salts_buf_new = NULL;
11827 void *esalts_buf_new = NULL;
11828
11829 if (isSalted)
11830 {
11831 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11832
11833 if (esalt_size)
11834 {
11835 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11836 }
11837 }
11838 else
11839 {
11840 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11841 }
11842
11843 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11844
11845 uint digests_cnt = hashes_cnt;
11846 uint digests_done = 0;
11847
11848 uint size_digests = digests_cnt * dgst_size;
11849 uint size_shown = digests_cnt * sizeof (uint);
11850
11851 uint *digests_shown = (uint *) mymalloc (size_shown);
11852 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11853
11854 uint salts_cnt = 0;
11855 uint salts_done = 0;
11856
11857 hashinfo_t **hash_info = NULL;
11858
11859 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11860 {
11861 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11862
11863 if (username && (remove || show))
11864 {
11865 uint user_pos;
11866
11867 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11868 {
11869 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11870
11871 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11872 }
11873 }
11874 }
11875
11876 uint *salts_shown = (uint *) mymalloc (size_shown);
11877
11878 salt_t *salt_buf;
11879
11880 {
11881 // copied from inner loop
11882
11883 salt_buf = &salts_buf_new[salts_cnt];
11884
11885 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11886
11887 if (esalt_size)
11888 {
11889 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11890 }
11891
11892 salt_buf->digests_cnt = 0;
11893 salt_buf->digests_done = 0;
11894 salt_buf->digests_offset = 0;
11895
11896 salts_cnt++;
11897 }
11898
11899 if (hashes_buf[0].cracked == 1)
11900 {
11901 digests_shown[0] = 1;
11902
11903 digests_done++;
11904
11905 salt_buf->digests_done++;
11906 }
11907
11908 salt_buf->digests_cnt++;
11909
11910 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11911
11912 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11913 {
11914 hash_info[0] = hashes_buf[0].hash_info;
11915 }
11916
11917 // copy from inner loop
11918
11919 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11920 {
11921 if (isSalted)
11922 {
11923 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11924 {
11925 salt_buf = &salts_buf_new[salts_cnt];
11926
11927 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11928
11929 if (esalt_size)
11930 {
11931 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11932 }
11933
11934 salt_buf->digests_cnt = 0;
11935 salt_buf->digests_done = 0;
11936 salt_buf->digests_offset = hashes_pos;
11937
11938 salts_cnt++;
11939 }
11940 }
11941
11942 if (hashes_buf[hashes_pos].cracked == 1)
11943 {
11944 digests_shown[hashes_pos] = 1;
11945
11946 digests_done++;
11947
11948 salt_buf->digests_done++;
11949 }
11950
11951 salt_buf->digests_cnt++;
11952
11953 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11954
11955 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11956 {
11957 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11958 }
11959 }
11960
11961 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11962 {
11963 salt_t *salt_buf = &salts_buf_new[salt_pos];
11964
11965 if (salt_buf->digests_done == salt_buf->digests_cnt)
11966 {
11967 salts_shown[salt_pos] = 1;
11968
11969 salts_done++;
11970 }
11971
11972 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11973 }
11974
11975 local_free (digests_buf);
11976 local_free (salts_buf);
11977 local_free (esalts_buf);
11978
11979 digests_buf = digests_buf_new;
11980 salts_buf = salts_buf_new;
11981 esalts_buf = esalts_buf_new;
11982
11983 local_free (hashes_buf);
11984
11985 /**
11986 * special modification not set from parser
11987 */
11988
11989 switch (hash_mode)
11990 {
11991 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11992 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11993 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11994 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11995 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11996 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11997 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11998 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11999 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12000 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12001 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12002 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12003 }
12004
12005 if (truecrypt_keyfiles)
12006 {
12007 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12008
12009 char *keyfiles = strdup (truecrypt_keyfiles);
12010
12011 char *keyfile = strtok (keyfiles, ",");
12012
12013 do
12014 {
12015 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12016
12017 } while ((keyfile = strtok (NULL, ",")) != NULL);
12018
12019 free (keyfiles);
12020 }
12021
12022 data.digests_cnt = digests_cnt;
12023 data.digests_done = digests_done;
12024 data.digests_buf = digests_buf;
12025 data.digests_shown = digests_shown;
12026 data.digests_shown_tmp = digests_shown_tmp;
12027
12028 data.salts_cnt = salts_cnt;
12029 data.salts_done = salts_done;
12030 data.salts_buf = salts_buf;
12031 data.salts_shown = salts_shown;
12032
12033 data.esalts_buf = esalts_buf;
12034 data.hash_info = hash_info;
12035
12036 /**
12037 * Automatic Optimizers
12038 */
12039
12040 if (salts_cnt == 1)
12041 opti_type |= OPTI_TYPE_SINGLE_SALT;
12042
12043 if (digests_cnt == 1)
12044 opti_type |= OPTI_TYPE_SINGLE_HASH;
12045
12046 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12047 opti_type |= OPTI_TYPE_NOT_ITERATED;
12048
12049 if (attack_mode == ATTACK_MODE_BF)
12050 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12051
12052 data.opti_type = opti_type;
12053
12054 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12055 {
12056 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12057 {
12058 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12059 {
12060 if (opts_type & OPTS_TYPE_ST_ADD80)
12061 {
12062 opts_type &= ~OPTS_TYPE_ST_ADD80;
12063 opts_type |= OPTS_TYPE_PT_ADD80;
12064 }
12065
12066 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12067 {
12068 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12069 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12070 }
12071
12072 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12073 {
12074 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12075 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12076 }
12077 }
12078 }
12079 }
12080
12081 /**
12082 * Some algorithm, like descrypt, can benefit from JIT compilation
12083 */
12084
12085 int force_jit_compilation = -1;
12086
12087 if (hash_mode == 8900)
12088 {
12089 force_jit_compilation = 8900;
12090 }
12091 else if (hash_mode == 9300)
12092 {
12093 force_jit_compilation = 8900;
12094 }
12095 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12096 {
12097 force_jit_compilation = 1500;
12098 }
12099
12100 /**
12101 * generate bitmap tables
12102 */
12103
12104 const uint bitmap_shift1 = 5;
12105 const uint bitmap_shift2 = 13;
12106
12107 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12108
12109 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12110 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12111 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12112 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12113 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12114 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12115 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12116 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12117
12118 uint bitmap_bits;
12119 uint bitmap_nums;
12120 uint bitmap_mask;
12121 uint bitmap_size;
12122
12123 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12124 {
12125 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12126
12127 bitmap_nums = 1 << bitmap_bits;
12128
12129 bitmap_mask = bitmap_nums - 1;
12130
12131 bitmap_size = bitmap_nums * sizeof (uint);
12132
12133 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12134
12135 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;
12136 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;
12137
12138 break;
12139 }
12140
12141 bitmap_nums = 1 << bitmap_bits;
12142
12143 bitmap_mask = bitmap_nums - 1;
12144
12145 bitmap_size = bitmap_nums * sizeof (uint);
12146
12147 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);
12148 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);
12149
12150 /**
12151 * prepare quick rule
12152 */
12153
12154 data.rule_buf_l = rule_buf_l;
12155 data.rule_buf_r = rule_buf_r;
12156
12157 int rule_len_l = (int) strlen (rule_buf_l);
12158 int rule_len_r = (int) strlen (rule_buf_r);
12159
12160 data.rule_len_l = rule_len_l;
12161 data.rule_len_r = rule_len_r;
12162
12163 /**
12164 * load rules
12165 */
12166
12167 uint *all_kernel_rules_cnt = NULL;
12168
12169 kernel_rule_t **all_kernel_rules_buf = NULL;
12170
12171 if (rp_files_cnt)
12172 {
12173 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12174
12175 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12176 }
12177
12178 char rule_buf[BUFSIZ] = { 0 };
12179
12180 int rule_len = 0;
12181
12182 for (uint i = 0; i < rp_files_cnt; i++)
12183 {
12184 uint kernel_rules_avail = 0;
12185
12186 uint kernel_rules_cnt = 0;
12187
12188 kernel_rule_t *kernel_rules_buf = NULL;
12189
12190 char *rp_file = rp_files[i];
12191
12192 char in[BLOCK_SIZE] = { 0 };
12193 char out[BLOCK_SIZE] = { 0 };
12194
12195 FILE *fp = NULL;
12196
12197 uint rule_line = 0;
12198
12199 if ((fp = fopen (rp_file, "rb")) == NULL)
12200 {
12201 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12202
12203 return (-1);
12204 }
12205
12206 while (!feof (fp))
12207 {
12208 memset (rule_buf, 0, BUFSIZ);
12209
12210 rule_len = fgetl (fp, rule_buf);
12211
12212 rule_line++;
12213
12214 if (rule_len == 0) continue;
12215
12216 if (rule_buf[0] == '#') continue;
12217
12218 if (kernel_rules_avail == kernel_rules_cnt)
12219 {
12220 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12221
12222 kernel_rules_avail += INCR_RULES;
12223 }
12224
12225 memset (in, 0, BLOCK_SIZE);
12226 memset (out, 0, BLOCK_SIZE);
12227
12228 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12229
12230 if (result == -1)
12231 {
12232 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12233
12234 continue;
12235 }
12236
12237 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12238 {
12239 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12240
12241 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12242
12243 continue;
12244 }
12245
12246 /* its so slow
12247 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12248 {
12249 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12250
12251 continue;
12252 }
12253 */
12254
12255 kernel_rules_cnt++;
12256 }
12257
12258 fclose (fp);
12259
12260 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12261
12262 all_kernel_rules_buf[i] = kernel_rules_buf;
12263 }
12264
12265 /**
12266 * merge rules or automatic rule generator
12267 */
12268
12269 uint kernel_rules_cnt = 0;
12270
12271 kernel_rule_t *kernel_rules_buf = NULL;
12272
12273 if (attack_mode == ATTACK_MODE_STRAIGHT)
12274 {
12275 if (rp_files_cnt)
12276 {
12277 kernel_rules_cnt = 1;
12278
12279 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12280
12281 repeats[0] = kernel_rules_cnt;
12282
12283 for (uint i = 0; i < rp_files_cnt; i++)
12284 {
12285 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12286
12287 repeats[i + 1] = kernel_rules_cnt;
12288 }
12289
12290 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12291
12292 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12293
12294 for (uint i = 0; i < kernel_rules_cnt; i++)
12295 {
12296 uint out_pos = 0;
12297
12298 kernel_rule_t *out = &kernel_rules_buf[i];
12299
12300 for (uint j = 0; j < rp_files_cnt; j++)
12301 {
12302 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12303 uint in_pos;
12304
12305 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12306
12307 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12308 {
12309 if (out_pos == RULES_MAX - 1)
12310 {
12311 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12312
12313 break;
12314 }
12315
12316 out->cmds[out_pos] = in->cmds[in_pos];
12317 }
12318 }
12319 }
12320
12321 local_free (repeats);
12322 }
12323 else if (rp_gen)
12324 {
12325 uint kernel_rules_avail = 0;
12326
12327 while (kernel_rules_cnt < rp_gen)
12328 {
12329 if (kernel_rules_avail == kernel_rules_cnt)
12330 {
12331 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12332
12333 kernel_rules_avail += INCR_RULES;
12334 }
12335
12336 memset (rule_buf, 0, BLOCK_SIZE);
12337
12338 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12339
12340 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12341
12342 kernel_rules_cnt++;
12343 }
12344 }
12345 }
12346
12347 /**
12348 * generate NOP rules
12349 */
12350
12351 if (kernel_rules_cnt == 0)
12352 {
12353 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12354
12355 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12356
12357 kernel_rules_cnt++;
12358 }
12359
12360 data.kernel_rules_cnt = kernel_rules_cnt;
12361 data.kernel_rules_buf = kernel_rules_buf;
12362
12363 /**
12364 * OpenCL platforms: detect
12365 */
12366
12367 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12368 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12369
12370 cl_uint platforms_cnt = 0;
12371 cl_uint platform_devices_cnt = 0;
12372
12373 if (keyspace == 0)
12374 {
12375 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12376
12377 if (platforms_cnt == 0)
12378 {
12379 log_error ("ERROR: No OpenCL compatible platform found");
12380
12381 return (-1);
12382 }
12383 }
12384
12385 /**
12386 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12387 */
12388
12389 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12390 {
12391 cl_platform_id platform = platforms[platform_id];
12392
12393 char platform_vendor[INFOSZ] = { 0 };
12394
12395 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12396
12397 #ifdef HAVE_HWMON
12398 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12399 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12400 {
12401 // make sure that we do not directly control the fan for NVidia
12402
12403 gpu_temp_retain = 0;
12404
12405 data.gpu_temp_retain = gpu_temp_retain;
12406 }
12407 #endif // HAVE_NVML || HAVE_NVAPI
12408 #endif
12409 }
12410
12411 /**
12412 * OpenCL devices: simply push all devices from all platforms into the same device array
12413 */
12414
12415 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12416
12417 data.devices_param = devices_param;
12418
12419 uint devices_cnt = 0;
12420
12421 uint devices_active = 0;
12422
12423 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12424 {
12425 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12426
12427 cl_platform_id platform = platforms[platform_id];
12428
12429 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12430
12431 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12432 {
12433 size_t param_value_size = 0;
12434
12435 const uint device_id = devices_cnt;
12436
12437 hc_device_param_t *device_param = &data.devices_param[device_id];
12438
12439 device_param->device = platform_devices[platform_devices_id];
12440
12441 device_param->device_id = device_id;
12442
12443 device_param->platform_devices_id = platform_devices_id;
12444
12445 // device_type
12446
12447 cl_device_type device_type;
12448
12449 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12450
12451 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12452
12453 device_param->device_type = device_type;
12454
12455 // vendor_id
12456
12457 cl_uint vendor_id = 0;
12458
12459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12460
12461 device_param->vendor_id = vendor_id;
12462
12463 // device_name
12464
12465 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12466
12467 char *device_name = (char *) mymalloc (param_value_size);
12468
12469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12470
12471 device_param->device_name = device_name;
12472
12473 // device_version
12474
12475 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12476
12477 char *device_version = (char *) mymalloc (param_value_size);
12478
12479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12480
12481 device_param->device_version = device_version;
12482
12483 // device_opencl_version
12484
12485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12486
12487 char *device_opencl_version = (char *) mymalloc (param_value_size);
12488
12489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12490
12491 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12492
12493 myfree (device_opencl_version);
12494
12495 if (strstr (device_version, "pocl"))
12496 {
12497 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12498 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12499
12500 cl_uint vendor_id = VENDOR_ID_GENERIC;
12501
12502 device_param->vendor_id = vendor_id;
12503 }
12504
12505 // max_compute_units
12506
12507 cl_uint vector_width;
12508
12509 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12510 {
12511 #ifndef OSX
12512 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12513 #else
12514 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
12515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12516 else
12517 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12518 #endif
12519
12520 int is_ti = 0;
12521
12522 const int device_name_len = strlen (device_name);
12523
12524 if (device_name[device_name_len - 2] == 't') is_ti++;
12525 if (device_name[device_name_len - 2] == 'T') is_ti++;
12526 if (device_name[device_name_len - 1] == 'i') is_ti++;
12527 if (device_name[device_name_len - 1] == 'I') is_ti++;
12528
12529 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12530 {
12531 // Yeah that's a super bad hack, but there's no other attribute we could use
12532
12533 if (vector_width < 2) vector_width *= 2;
12534 }
12535
12536 if (opti_type & OPTI_TYPE_USES_BITS_64)
12537 {
12538 if (vector_width > 1) vector_width /= 2;
12539 }
12540 }
12541 else
12542 {
12543 vector_width = opencl_vector_width;
12544 }
12545
12546 if (vector_width > 8) vector_width = 8;
12547
12548 device_param->vector_width = vector_width;
12549
12550 // max_compute_units
12551
12552 cl_uint device_processors;
12553
12554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12555
12556 device_param->device_processors = device_processors;
12557
12558 // max_mem_alloc_size
12559
12560 cl_ulong device_maxmem_alloc;
12561
12562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12563
12564 device_param->device_maxmem_alloc = device_maxmem_alloc;
12565
12566 // max_mem_alloc_size
12567
12568 cl_ulong device_global_mem;
12569
12570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12571
12572 device_param->device_global_mem = device_global_mem;
12573
12574 // max_clock_frequency
12575
12576 cl_uint device_maxclock_frequency;
12577
12578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12579
12580 device_param->device_maxclock_frequency = device_maxclock_frequency;
12581
12582 // skipped
12583
12584 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12585 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12586
12587 device_param->skipped = (skipped1 || skipped2);
12588
12589 // driver_version
12590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12591
12592 char *driver_version = (char *) mymalloc (param_value_size);
12593
12594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12595
12596 device_param->driver_version = driver_version;
12597
12598 // device_name_chksum
12599
12600 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12601
12602 #if __x86_64__
12603 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);
12604 #else
12605 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);
12606 #endif
12607
12608 uint device_name_digest[4] = { 0 };
12609
12610 md5_64 ((uint *) device_name_chksum, device_name_digest);
12611
12612 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12613
12614 device_param->device_name_chksum = device_name_chksum;
12615
12616 // device_processor_cores
12617
12618 if (device_type & CL_DEVICE_TYPE_CPU)
12619 {
12620 cl_uint device_processor_cores = 1;
12621
12622 device_param->device_processor_cores = device_processor_cores;
12623 }
12624
12625 if (device_type & CL_DEVICE_TYPE_GPU)
12626 {
12627 if (vendor_id == VENDOR_ID_AMD)
12628 {
12629 cl_uint device_processor_cores = 0;
12630
12631 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12632
12633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12634
12635 device_param->device_processor_cores = device_processor_cores;
12636 }
12637 else if (vendor_id == VENDOR_ID_NV)
12638 {
12639 cl_uint kernel_exec_timeout = 0;
12640
12641 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12642
12643 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12644
12645 device_param->kernel_exec_timeout = kernel_exec_timeout;
12646
12647 cl_uint device_processor_cores = 0;
12648
12649 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12650
12651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12652
12653 device_param->device_processor_cores = device_processor_cores;
12654
12655 cl_uint sm_minor = 0;
12656 cl_uint sm_major = 0;
12657
12658 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12659 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12660
12661 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12662 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12663
12664 device_param->sm_minor = sm_minor;
12665 device_param->sm_major = sm_major;
12666 }
12667 else
12668 {
12669 cl_uint device_processor_cores = 1;
12670
12671 device_param->device_processor_cores = device_processor_cores;
12672 }
12673 }
12674
12675 // display results
12676
12677 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12678 {
12679 if (device_param->skipped == 0)
12680 {
12681 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12682 device_id + 1,
12683 device_name,
12684 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12685 (unsigned int) (device_global_mem / 1024 / 1024),
12686 (unsigned int) (device_maxclock_frequency),
12687 (unsigned int) device_processors);
12688 }
12689 else
12690 {
12691 log_info ("Device #%u: %s, skipped",
12692 device_id + 1,
12693 device_name);
12694 }
12695 }
12696
12697 // common driver check
12698
12699 if (device_param->skipped == 0)
12700 {
12701 if (strstr (device_version, "pocl"))
12702 {
12703 if (force == 0)
12704 {
12705 log_info ("");
12706 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12707 log_info ("You are STRONGLY encouraged not to use it");
12708 log_info ("You can use --force to override this but do not post error reports if you do so");
12709 log_info ("");
12710
12711 return (-1);
12712 }
12713 }
12714
12715 if (device_type & CL_DEVICE_TYPE_GPU)
12716 {
12717 if (vendor_id == VENDOR_ID_NV)
12718 {
12719 if (device_param->kernel_exec_timeout != 0)
12720 {
12721 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);
12722 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12723 }
12724 }
12725 else if (vendor_id == VENDOR_ID_AMD)
12726 {
12727 int catalyst_check = (force == 1) ? 0 : 1;
12728
12729 int catalyst_warn = 0;
12730
12731 int catalyst_broken = 0;
12732
12733 if (catalyst_check == 1)
12734 {
12735 catalyst_warn = 1;
12736
12737 // v14.9 and higher
12738 if (atoi (device_param->driver_version) >= 1573)
12739 {
12740 catalyst_warn = 0;
12741 }
12742
12743 catalyst_check = 0;
12744 }
12745
12746 if (catalyst_broken == 1)
12747 {
12748 log_info ("");
12749 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12750 log_info ("It will pass over cracked hashes and does not report them as cracked");
12751 log_info ("You are STRONGLY encouraged not to use it");
12752 log_info ("You can use --force to override this but do not post error reports if you do so");
12753 log_info ("");
12754
12755 return (-1);
12756 }
12757
12758 if (catalyst_warn == 1)
12759 {
12760 log_info ("");
12761 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12762 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12763 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12764 #ifdef _WIN
12765 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12766 #endif
12767 log_info ("You can use --force to override this but do not post error reports if you do so");
12768 log_info ("");
12769
12770 return (-1);
12771 }
12772 }
12773 }
12774
12775 /**
12776 * kernel accel and loops auto adjustment
12777 */
12778
12779 uint _kernel_accel = kernel_accel;
12780 uint _kernel_loops = kernel_loops;
12781
12782 #ifndef OSX
12783 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode);
12784 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode);
12785 #else
12786 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12787 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12788 #endif
12789
12790 if (workload_profile == 1)
12791 {
12792 _kernel_loops /= 8;
12793 _kernel_accel /= 4;
12794
12795 if (_kernel_loops == 0) _kernel_loops = 8;
12796 if (_kernel_accel == 0) _kernel_accel = 2;
12797 }
12798 else if (workload_profile == 3)
12799 {
12800 _kernel_loops *= 8;
12801 _kernel_accel *= 4;
12802
12803 if (_kernel_loops > 1024) _kernel_loops = 1024;
12804 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
12805 }
12806
12807 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
12808
12809 if (benchmark == 1 && benchmark_mode == 1)
12810 {
12811 _kernel_loops *= 8;
12812 _kernel_accel *= 4;
12813
12814 #ifdef OSX
12815 bool isCpu = device_param->device_type & CL_DEVICE_TYPE_CPU;
12816
12817 if (!isCpu)
12818 {
12819 if (hash_mode == 7100 || hash_mode == 8200 || hash_mode == 9600 || \
12820 hash_mode == 11300 || hash_mode == 11600 || hash_mode == 12200)
12821 {
12822 _kernel_accel = 1;
12823 }
12824 else if (hash_mode == 7200 || hash_mode == 9300 || hash_mode == 13000)
12825 {
12826 _kernel_accel = 2;
12827 }
12828 else if (hash_mode == 3200)
12829 {
12830 _kernel_loops = ROUNDS_BCRYPT / 2;
12831 }
12832 else if (hash_mode == 6231)
12833 {
12834 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12835 _kernel_accel = 1;
12836 }
12837 else if (hash_mode == 6241)
12838 {
12839 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12840 _kernel_accel = 1;
12841 }
12842 }
12843 else
12844 {
12845 if (hash_mode == 3200)
12846 {
12847 _kernel_loops = ROUNDS_BCRYPT;
12848 }
12849 else if (hash_mode == 6231)
12850 {
12851 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12852 _kernel_accel = 8;
12853 }
12854 else if (hash_mode == 6241)
12855 {
12856 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12857 _kernel_accel = 128;
12858 }
12859 }
12860 #endif
12861
12862 switch (hash_mode)
12863 {
12864 case 400: _kernel_loops = ROUNDS_PHPASS;
12865 _kernel_accel = 32;
12866 break;
12867 case 500: _kernel_loops = ROUNDS_MD5CRYPT;
12868 _kernel_accel = 32;
12869 break;
12870 case 501: _kernel_loops = ROUNDS_MD5CRYPT;
12871 _kernel_accel = 32;
12872 break;
12873 case 1600: _kernel_loops = ROUNDS_MD5CRYPT;
12874 _kernel_accel = 32;
12875 break;
12876 case 1800: _kernel_loops = ROUNDS_SHA512CRYPT;
12877 #ifndef OSX
12878 _kernel_accel = 16;
12879 #else
12880 if (isCpu) _kernel_accel = 16;
12881 #endif
12882 break;
12883 case 2100: _kernel_loops = ROUNDS_DCC2;
12884 _kernel_accel = 16;
12885 break;
12886 case 2500: _kernel_loops = ROUNDS_WPA2;
12887 #ifndef OSX
12888 _kernel_accel = 32;
12889 #else
12890 if (isCpu) _kernel_accel = 32;
12891 #endif
12892 break;
12893 case 3200: _kernel_accel = 8;
12894 #ifndef OSX
12895 _kernel_loops = ROUNDS_BCRYPT;
12896 #endif
12897 break;
12898 case 5200: _kernel_loops = ROUNDS_PSAFE3;
12899 _kernel_accel = 16;
12900 break;
12901 case 5800: _kernel_loops = ROUNDS_ANDROIDPIN;
12902 _kernel_accel = 16;
12903 break;
12904 case 6211: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12905 #ifndef OSX
12906 _kernel_accel = 64;
12907 #else
12908 if (isCpu) _kernel_accel = 64;
12909 #endif
12910 break;
12911 case 6212: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12912 _kernel_accel = 32;
12913 break;
12914 case 6213: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12915 _kernel_accel = 32;
12916 break;
12917 case 6221: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12918 _kernel_accel = 8;
12919 break;
12920 case 6222: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12921 _kernel_accel = 8;
12922 break;
12923 case 6223: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12924 _kernel_accel = 8;
12925 break;
12926 #ifndef OSX
12927 case 6231: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12928 _kernel_accel = 8;
12929 break;
12930 #endif
12931 case 6232: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12932 _kernel_accel = 8;
12933 break;
12934 case 6233: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12935 _kernel_accel = 8;
12936 break;
12937 #ifndef OSX
12938 case 6241: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12939 _kernel_accel = 128;
12940 break;
12941 #endif
12942 case 6242: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12943 _kernel_accel = 64;
12944 break;
12945 case 6243: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12946 _kernel_accel = 64;
12947 break;
12948 case 6300: _kernel_loops = ROUNDS_MD5CRYPT;
12949 _kernel_accel = 32;
12950 break;
12951 case 6700: _kernel_loops = ROUNDS_SHA1AIX;
12952 _kernel_accel = 128;
12953 break;
12954 case 6400: _kernel_loops = ROUNDS_SHA256AIX;
12955 _kernel_accel = 128;
12956 break;
12957 case 6500: _kernel_loops = ROUNDS_SHA512AIX;
12958 _kernel_accel = 32;
12959 break;
12960 case 6600: _kernel_loops = ROUNDS_AGILEKEY;
12961 _kernel_accel = 64;
12962 break;
12963 case 6800: _kernel_loops = ROUNDS_LASTPASS;
12964 #ifndef OSX
12965 _kernel_accel = 64;
12966 #else
12967 if (isCpu) _kernel_accel = 64;
12968 #endif
12969 break;
12970 case 7100: _kernel_loops = ROUNDS_SHA512OSX;
12971 #ifndef OSX
12972 _kernel_accel = 8;
12973 #endif
12974 break;
12975 case 7200: _kernel_loops = ROUNDS_GRUB;
12976 #ifndef OSX
12977 _kernel_accel = 16;
12978 #endif
12979 break;
12980 case 7400: _kernel_loops = ROUNDS_SHA256CRYPT;
12981 _kernel_accel = 8;
12982 break;
12983 case 7900: _kernel_loops = ROUNDS_DRUPAL7;
12984 #ifndef OSX
12985 _kernel_accel = 8;
12986 #else
12987 if (isCpu) _kernel_accel = 8;
12988 #endif
12989 break;
12990 case 8200: _kernel_loops = ROUNDS_CLOUDKEY;
12991 #ifndef OSX
12992 _kernel_accel = 8;
12993 #endif
12994 break;
12995 case 8800: _kernel_loops = ROUNDS_ANDROIDFDE;
12996 _kernel_accel = 32;
12997 break;
12998 case 8900: _kernel_loops = 1;
12999 _kernel_accel = 64;
13000 break;
13001 case 9000: _kernel_loops = ROUNDS_PSAFE2;
13002 _kernel_accel = 16;
13003 break;
13004 case 9100: _kernel_loops = ROUNDS_LOTUS8;
13005 #ifndef OSX
13006 _kernel_accel = 64;
13007 #else
13008 if (isCpu) _kernel_accel = 64;
13009 #endif
13010 break;
13011 case 9200: _kernel_loops = ROUNDS_CISCO8;
13012 #ifndef OSX
13013 _kernel_accel = 8;
13014 #else
13015 if (isCpu) _kernel_accel = 8;
13016 #endif
13017 break;
13018 case 9300: _kernel_loops = 1;
13019 #ifndef OSX
13020 _kernel_accel = 4;
13021 #endif
13022 break;
13023 case 9400: _kernel_loops = ROUNDS_OFFICE2007;
13024 #ifndef OSX
13025 _kernel_accel = 32;
13026 #else
13027 if (isCpu) _kernel_accel = 32;
13028 #endif
13029 break;
13030 case 9500: _kernel_loops = ROUNDS_OFFICE2010;
13031 #ifndef OSX
13032 _kernel_accel = 32;
13033 #else
13034 if (isCpu) _kernel_accel = 32;
13035 #endif
13036 break;
13037 case 9600: _kernel_loops = ROUNDS_OFFICE2013;
13038 #ifndef OSX
13039 _kernel_accel = 8;
13040 #endif
13041 break;
13042 case 10000: _kernel_loops = ROUNDS_DJANGOPBKDF2;
13043 #ifndef OSX
13044 _kernel_accel = 8;
13045 #else
13046 if (isCpu) _kernel_accel = 8;
13047 #endif
13048 break;
13049 case 10300: _kernel_loops = ROUNDS_SAPH_SHA1;
13050 _kernel_accel = 16;
13051 break;
13052 case 10500: _kernel_loops = ROUNDS_PDF14;
13053 _kernel_accel = 256;
13054 break;
13055 case 10700: _kernel_loops = ROUNDS_PDF17L8;
13056 _kernel_accel = 8;
13057 break;
13058 case 10900: _kernel_loops = ROUNDS_PBKDF2_SHA256;
13059 _kernel_accel = 8;
13060 break;
13061 case 11300: _kernel_loops = ROUNDS_BITCOIN_WALLET;
13062 #ifndef OSX
13063 _kernel_accel = 8;
13064 #endif
13065 break;
13066 case 11600: _kernel_loops = ROUNDS_SEVEN_ZIP;
13067 #ifndef OSX
13068 _kernel_accel = 8;
13069 #endif
13070 break;
13071 case 11900: _kernel_loops = ROUNDS_PBKDF2_MD5;
13072 _kernel_accel = 8;
13073 break;
13074 case 12000: _kernel_loops = ROUNDS_PBKDF2_SHA1;
13075 _kernel_accel = 8;
13076 break;
13077 case 12100: _kernel_loops = ROUNDS_PBKDF2_SHA512;
13078 _kernel_accel = 8;
13079 break;
13080 case 12200: _kernel_loops = ROUNDS_ECRYPTFS;
13081 #ifndef OSX
13082 _kernel_accel = 8;
13083 #endif
13084 break;
13085 case 12300: _kernel_loops = ROUNDS_ORACLET;
13086 _kernel_accel = 8;
13087 break;
13088 case 12500: _kernel_loops = ROUNDS_RAR3;
13089 #ifndef OSX
13090 _kernel_accel = 32;
13091 #else
13092 if (isCpu) _kernel_accel = 32;
13093 #endif
13094 break;
13095 case 12700: _kernel_loops = ROUNDS_MYWALLET;
13096 _kernel_accel = 512;
13097 break;
13098 case 12800: _kernel_loops = ROUNDS_MS_DRSR;
13099 _kernel_accel = 512;
13100 break;
13101 case 12900: _kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
13102 _kernel_accel = 8;
13103 break;
13104 case 13000: _kernel_loops = ROUNDS_RAR5;
13105 #ifndef OSX
13106 _kernel_accel = 8;
13107 #endif
13108 break;
13109 }
13110
13111 // some algorithm collide too fast, make that impossible
13112
13113 switch (hash_mode)
13114 {
13115 case 11500: ((uint *) digests_buf)[1] = 1;
13116 break;
13117 }
13118
13119 if (_kernel_loops > 1024) _kernel_loops = 1024;
13120 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
13121 }
13122
13123 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13124 {
13125 _kernel_loops = 1024;
13126 }
13127
13128 if (hash_mode == 12500)
13129 {
13130 _kernel_loops = ROUNDS_RAR3 / 16;
13131 }
13132
13133 device_param->kernel_accel = _kernel_accel;
13134 device_param->kernel_loops = _kernel_loops;
13135
13136 devices_active++;
13137 }
13138
13139 // next please
13140
13141 devices_cnt++;
13142 }
13143 }
13144
13145 if (keyspace == 0 && devices_active == 0)
13146 {
13147 log_error ("ERROR: No devices found/left");
13148
13149 return (-1);
13150 }
13151
13152 data.devices_cnt = devices_cnt;
13153
13154 data.devices_active = devices_active;
13155
13156 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13157 {
13158 log_info ("");
13159 }
13160
13161 /**
13162 * HM devices: init
13163 */
13164
13165 #ifdef HAVE_HWMON
13166 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13167 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13168 #endif
13169
13170 #ifdef HAVE_ADL
13171 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13172 #endif
13173
13174 if (gpu_temp_disable == 0)
13175 {
13176 #if defined(WIN) && defined(HAVE_NVAPI)
13177 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13178
13179 if (nvapi_init (nvapi) == 0)
13180 data.hm_nv = nvapi;
13181
13182 if (data.hm_nv)
13183 {
13184 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13185 {
13186 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13187
13188 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13189
13190 int tmp_out = 0;
13191
13192 for (int i = 0; i < tmp_in; i++)
13193 {
13194 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13195 }
13196
13197 for (int i = 0; i < tmp_out; i++)
13198 {
13199 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13200
13201 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13202
13203 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;
13204 }
13205 }
13206 }
13207 #endif // WIN && HAVE_NVAPI
13208
13209 #if defined(LINUX) && defined(HAVE_NVML)
13210 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13211
13212 if (nvml_init (nvml) == 0)
13213 data.hm_nv = nvml;
13214
13215 if (data.hm_nv)
13216 {
13217 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13218 {
13219 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13220
13221 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13222
13223 int tmp_out = 0;
13224
13225 for (int i = 0; i < tmp_in; i++)
13226 {
13227 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13228 }
13229
13230 for (int i = 0; i < tmp_out; i++)
13231 {
13232 unsigned int speed;
13233
13234 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;
13235 }
13236 }
13237 }
13238 #endif // LINUX && HAVE_NVML
13239
13240 data.hm_amd = NULL;
13241
13242 #ifdef HAVE_ADL
13243 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13244
13245 if (adl_init (adl) == 0)
13246 data.hm_amd = adl;
13247
13248 if (data.hm_amd)
13249 {
13250 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13251 {
13252 // total number of adapters
13253
13254 int hm_adapters_num;
13255
13256 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13257
13258 // adapter info
13259
13260 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13261
13262 if (lpAdapterInfo == NULL) return (-1);
13263
13264 // get a list (of ids of) valid/usable adapters
13265
13266 int num_adl_adapters = 0;
13267
13268 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13269
13270 if (num_adl_adapters > 0)
13271 {
13272 hc_thread_mutex_lock (mux_adl);
13273
13274 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13275
13276 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13277
13278 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13279 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13280
13281 hc_thread_mutex_unlock (mux_adl);
13282 }
13283
13284 myfree (valid_adl_device_list);
13285 myfree (lpAdapterInfo);
13286 }
13287 }
13288 #endif // HAVE_ADL
13289
13290 if (data.hm_amd == NULL && data.hm_nv == NULL)
13291 {
13292 gpu_temp_disable = 1;
13293 }
13294 }
13295
13296 /**
13297 * OpenCL devices: allocate buffer for device specific information
13298 */
13299
13300 #ifdef HAVE_HWMON
13301 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13302
13303 #ifdef HAVE_ADL
13304 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13305
13306 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13307 #endif // ADL
13308 #endif
13309
13310 /**
13311 * enable custom signal handler(s)
13312 */
13313
13314 if (benchmark == 0)
13315 {
13316 hc_signal (sigHandler_default);
13317 }
13318 else
13319 {
13320 hc_signal (sigHandler_benchmark);
13321 }
13322
13323 /**
13324 * User-defined GPU temp handling
13325 */
13326
13327 #ifdef HAVE_HWMON
13328 if (gpu_temp_disable == 1)
13329 {
13330 gpu_temp_abort = 0;
13331 gpu_temp_retain = 0;
13332 }
13333
13334 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13335 {
13336 if (gpu_temp_abort < gpu_temp_retain)
13337 {
13338 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13339
13340 return (-1);
13341 }
13342 }
13343
13344 data.gpu_temp_disable = gpu_temp_disable;
13345 data.gpu_temp_abort = gpu_temp_abort;
13346 data.gpu_temp_retain = gpu_temp_retain;
13347 #endif
13348
13349 /**
13350 * inform the user
13351 */
13352
13353 if (data.quiet == 0)
13354 {
13355 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13356
13357 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);
13358
13359 if (attack_mode == ATTACK_MODE_STRAIGHT)
13360 {
13361 log_info ("Rules: %u", kernel_rules_cnt);
13362 }
13363
13364 if (opti_type)
13365 {
13366 log_info ("Applicable Optimizers:");
13367
13368 for (uint i = 0; i < 32; i++)
13369 {
13370 const uint opti_bit = 1u << i;
13371
13372 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13373 }
13374 }
13375
13376 /**
13377 * Watchdog and Temperature balance
13378 */
13379
13380 #ifdef HAVE_HWMON
13381 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13382 {
13383 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13384 }
13385
13386 if (gpu_temp_abort == 0)
13387 {
13388 log_info ("Watchdog: Temperature abort trigger disabled");
13389 }
13390 else
13391 {
13392 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13393 }
13394
13395 if (gpu_temp_retain == 0)
13396 {
13397 log_info ("Watchdog: Temperature retain trigger disabled");
13398 }
13399 else
13400 {
13401 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13402 }
13403 #endif
13404 }
13405
13406 if (data.quiet == 0) log_info ("");
13407
13408 /**
13409 * HM devices: copy
13410 */
13411
13412 if (gpu_temp_disable == 0)
13413 {
13414 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13415 {
13416 hc_device_param_t *device_param = &data.devices_param[device_id];
13417
13418 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13419
13420 if (device_param->skipped) continue;
13421
13422 const uint platform_devices_id = device_param->platform_devices_id;
13423
13424 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13425 if (device_param->vendor_id == VENDOR_ID_NV)
13426 {
13427 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13428 }
13429 #endif
13430
13431 #ifdef HAVE_ADL
13432 if (device_param->vendor_id == VENDOR_ID_AMD)
13433 {
13434 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13435 }
13436 #endif
13437 }
13438 }
13439
13440 /*
13441 * Temporary fix:
13442 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13443 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13444 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13445 * Driver / ADL bug?
13446 */
13447
13448 #ifdef HAVE_ADL
13449 if (powertune_enable == 1)
13450 {
13451 hc_thread_mutex_lock (mux_adl);
13452
13453 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13454 {
13455 hc_device_param_t *device_param = &data.devices_param[device_id];
13456
13457 if (device_param->skipped) continue;
13458
13459 if (data.hm_device[device_id].od_version == 6)
13460 {
13461 // set powertune value only
13462
13463 int powertune_supported = 0;
13464
13465 int ADL_rc = 0;
13466
13467 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13468 {
13469 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13470
13471 return (-1);
13472 }
13473
13474 if (powertune_supported != 0)
13475 {
13476 // powertune set
13477 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13478
13479 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13480 {
13481 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13482
13483 return (-1);
13484 }
13485
13486 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13487 {
13488 log_error ("ERROR: Failed to set new ADL PowerControl values");
13489
13490 return (-1);
13491 }
13492 }
13493 }
13494 }
13495
13496 hc_thread_mutex_unlock (mux_adl);
13497 }
13498 #endif // HAVE_ADK
13499 #endif // HAVE_HWMON
13500
13501 #ifdef OSX
13502 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13503 {
13504 if (force == 0)
13505 {
13506 log_info ("");
13507 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13508 log_info ("You can use --force to override this but do not post error reports if you do so");
13509 log_info ("");
13510
13511 continue;
13512 }
13513 }
13514 #endif
13515
13516 #ifdef DEBUG
13517 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13518 #endif
13519
13520 uint kernel_blocks_all = 0;
13521
13522 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13523 {
13524 /**
13525 * host buffer
13526 */
13527
13528 hc_device_param_t *device_param = &data.devices_param[device_id];
13529
13530 if (device_param->skipped) continue;
13531
13532 /**
13533 * device properties
13534 */
13535
13536 char *device_name_chksum = device_param->device_name_chksum;
13537
13538 uint device_processors = device_param->device_processors;
13539
13540 uint device_processor_cores = device_param->device_processor_cores;
13541
13542 cl_device_type device_type = device_param->device_type;
13543
13544 /**
13545 * create context for each device
13546 */
13547
13548 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13549
13550 /**
13551 * create command-queue
13552 */
13553
13554 // not supported with NV
13555 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13556
13557 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13558
13559 /**
13560 * create input buffers on device
13561 */
13562
13563 uint kernel_threads = KERNEL_THREADS;
13564
13565 // bcrypt
13566 if (hash_mode == 3200) kernel_threads = 8;
13567 if (hash_mode == 9000) kernel_threads = 8;
13568
13569 if (device_type & CL_DEVICE_TYPE_CPU)
13570 {
13571 if (benchmark_mode == 0)
13572 {
13573 if (device_param->kernel_accel > 16)
13574 {
13575 device_param->kernel_accel = 16;
13576 }
13577 }
13578 else
13579 {
13580 if (device_param->kernel_accel > 64)
13581 {
13582 device_param->kernel_accel = 64;
13583 }
13584 }
13585 }
13586
13587 uint kernel_power = device_processors * kernel_threads * device_param->kernel_accel;
13588 uint kernel_blocks = kernel_power;
13589
13590 device_param->kernel_threads = kernel_threads;
13591 device_param->kernel_power_user = kernel_power;
13592 device_param->kernel_blocks_user = kernel_blocks;
13593
13594 kernel_blocks_all += kernel_blocks;
13595
13596 uint size_pws = kernel_power * sizeof (pw_t);
13597
13598 uint size_tmps = 4;
13599
13600 switch (hash_mode)
13601 {
13602 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13603 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13604 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13605 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13606 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13607 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13608 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13609 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13610 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13611 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13612 case 6211:
13613 case 6212:
13614 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13615 case 6221:
13616 case 6222:
13617 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13618 case 6231:
13619 case 6232:
13620 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13621 case 6241:
13622 case 6242:
13623 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13624 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13625 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13626 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13627 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13628 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13629 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13630 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13631 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13632 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13633 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13634 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13635 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13636 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13637 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13638 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13639 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13640 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13641 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13642 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13643 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13644 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13645 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13646 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13647 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13648 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13649 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13650 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13651 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13652 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13653 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13654 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13655 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13656 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13657 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13658 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13659 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13660 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13661 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13662 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13663 };
13664
13665 uint size_hooks = 4;
13666
13667 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13668 {
13669 // insert correct hook size
13670 }
13671
13672 // we can optimize some stuff here...
13673
13674 device_param->size_pws = size_pws;
13675 device_param->size_tmps = size_tmps;
13676 device_param->size_hooks = size_hooks;
13677
13678 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13679 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13680
13681 device_param->size_root_css = size_root_css;
13682 device_param->size_markov_css = size_markov_css;
13683
13684 uint size_results = KERNEL_THREADS * sizeof (uint);
13685
13686 device_param->size_results = size_results;
13687
13688 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13689 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13690
13691 uint size_plains = digests_cnt * sizeof (plain_t);
13692 uint size_salts = salts_cnt * sizeof (salt_t);
13693 uint size_esalts = salts_cnt * esalt_size;
13694
13695 device_param->size_plains = size_plains;
13696 device_param->size_digests = size_digests;
13697 device_param->size_shown = size_shown;
13698 device_param->size_salts = size_salts;
13699
13700 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13701 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13702 uint size_tm = 32 * sizeof (bs_word_t);
13703
13704 u64 size_scryptV = 1;
13705
13706 if ((hash_mode == 8900) || (hash_mode == 9300))
13707 {
13708 uint tmto_start = 0;
13709 uint tmto_stop = 10;
13710
13711 if (scrypt_tmto)
13712 {
13713 tmto_start = scrypt_tmto;
13714 }
13715 else
13716 {
13717 // in case the user did not specify the tmto manually
13718 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13719 // but set the lower end only in case the user has a device with too less memory
13720
13721 if (hash_mode == 8900)
13722 {
13723 if (device_param->vendor_id == VENDOR_ID_AMD)
13724 {
13725 tmto_start = 1;
13726 }
13727 else if (device_param->vendor_id == VENDOR_ID_NV)
13728 {
13729 tmto_start = 3;
13730 }
13731 }
13732 else if (hash_mode == 9300)
13733 {
13734 if (device_param->vendor_id == VENDOR_ID_AMD)
13735 {
13736 tmto_start = 3;
13737 }
13738 else if (device_param->vendor_id == VENDOR_ID_NV)
13739 {
13740 tmto_start = 5;
13741 }
13742 }
13743 }
13744
13745 if (quiet == 0) log_info ("");
13746
13747 uint shader_per_mp = 1;
13748
13749 if (device_param->vendor_id == VENDOR_ID_AMD)
13750 {
13751 shader_per_mp = 8;
13752 }
13753 else if (device_param->vendor_id == VENDOR_ID_NV)
13754 {
13755 shader_per_mp = 32;
13756 }
13757
13758 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13759 {
13760 // TODO: in theory the following calculation needs to be done per salt, not global
13761 // we assume all hashes have the same scrypt settings
13762
13763 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13764
13765 size_scryptV /= 1 << tmto;
13766
13767 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13768
13769 if (size_scryptV > device_param->device_maxmem_alloc)
13770 {
13771 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13772
13773 continue;
13774 }
13775
13776 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13777 {
13778 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13779 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13780 }
13781
13782 break;
13783 }
13784
13785 if (data.salts_buf[0].scrypt_phy == 0)
13786 {
13787 log_error ("ERROR: can't allocate enough device memory");
13788
13789 return -1;
13790 }
13791
13792 if (quiet == 0) log_info ("");
13793 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13794 }
13795
13796 /**
13797 * default building options
13798 */
13799
13800 char build_opts[1024] = { 0 };
13801
13802 // we don't have sm_* on vendors not NV but it doesn't matter
13803
13804 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);
13805
13806 /**
13807 * main kernel
13808 */
13809
13810 {
13811 /**
13812 * kernel source filename
13813 */
13814
13815 char source_file[256] = { 0 };
13816
13817 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13818
13819 struct stat sst;
13820
13821 if (stat (source_file, &sst) == -1)
13822 {
13823 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13824
13825 return -1;
13826 }
13827
13828 /**
13829 * kernel cached filename
13830 */
13831
13832 char cached_file[256] = { 0 };
13833
13834 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13835
13836 int cached = 1;
13837
13838 struct stat cst;
13839
13840 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13841 {
13842 cached = 0;
13843 }
13844
13845 /**
13846 * kernel compile or load
13847 */
13848
13849 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13850
13851 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13852
13853 if (force_jit_compilation == -1)
13854 {
13855 if (cached == 0)
13856 {
13857 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13858
13859 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13860
13861 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13862
13863 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13864
13865 if (rc != 0)
13866 {
13867 device_param->skipped = true;
13868 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13869 continue;
13870 }
13871
13872 size_t binary_size;
13873
13874 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13875
13876 u8 *binary = (u8 *) mymalloc (binary_size);
13877
13878 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13879
13880 writeProgramBin (cached_file, binary, binary_size);
13881
13882 local_free (binary);
13883 }
13884 else
13885 {
13886 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13887
13888 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13889
13890 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13891
13892 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13893 }
13894 }
13895 else
13896 {
13897 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13898
13899 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13900
13901 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13902
13903 char build_opts_update[1024] = { 0 };
13904
13905 if (force_jit_compilation == 1500)
13906 {
13907 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13908 }
13909 else if (force_jit_compilation == 8900)
13910 {
13911 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);
13912 }
13913
13914 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13915
13916 if (rc != 0)
13917 {
13918 device_param->skipped = true;
13919 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13920 }
13921 }
13922
13923 local_free (kernel_lengths);
13924 local_free (kernel_sources[0]);
13925 local_free (kernel_sources);
13926 }
13927
13928 /**
13929 * word generator kernel
13930 */
13931
13932 if (attack_mode != ATTACK_MODE_STRAIGHT)
13933 {
13934 /**
13935 * kernel mp source filename
13936 */
13937
13938 char source_file[256] = { 0 };
13939
13940 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13941
13942 struct stat sst;
13943
13944 if (stat (source_file, &sst) == -1)
13945 {
13946 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13947
13948 return -1;
13949 }
13950
13951 /**
13952 * kernel mp cached filename
13953 */
13954
13955 char cached_file[256] = { 0 };
13956
13957 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13958
13959 int cached = 1;
13960
13961 struct stat cst;
13962
13963 if (stat (cached_file, &cst) == -1)
13964 {
13965 cached = 0;
13966 }
13967
13968 /**
13969 * kernel compile or load
13970 */
13971
13972 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13973
13974 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13975
13976 if (cached == 0)
13977 {
13978 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13979
13980 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13981
13982 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13983
13984 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13985
13986 if (rc != 0)
13987 {
13988 device_param->skipped = true;
13989 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13990 continue;
13991 }
13992
13993 size_t binary_size;
13994
13995 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13996
13997 u8 *binary = (u8 *) mymalloc (binary_size);
13998
13999 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14000
14001 writeProgramBin (cached_file, binary, binary_size);
14002
14003 local_free (binary);
14004 }
14005 else
14006 {
14007 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14008
14009 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14010
14011 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14012
14013 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14014 }
14015
14016 local_free (kernel_lengths);
14017 local_free (kernel_sources[0]);
14018 local_free (kernel_sources);
14019 }
14020
14021 /**
14022 * amplifier kernel
14023 */
14024
14025 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14026 {
14027
14028 }
14029 else
14030 {
14031 /**
14032 * kernel amp source filename
14033 */
14034
14035 char source_file[256] = { 0 };
14036
14037 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14038
14039 struct stat sst;
14040
14041 if (stat (source_file, &sst) == -1)
14042 {
14043 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14044
14045 return -1;
14046 }
14047
14048 /**
14049 * kernel amp cached filename
14050 */
14051
14052 char cached_file[256] = { 0 };
14053
14054 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14055
14056 int cached = 1;
14057
14058 struct stat cst;
14059
14060 if (stat (cached_file, &cst) == -1)
14061 {
14062 cached = 0;
14063 }
14064
14065 /**
14066 * kernel compile or load
14067 */
14068
14069 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14070
14071 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14072
14073 if (cached == 0)
14074 {
14075 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14076
14077 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14078
14079 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14080
14081 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14082
14083 if (rc != 0)
14084 {
14085 device_param->skipped = true;
14086 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14087 continue;
14088 }
14089
14090 size_t binary_size;
14091
14092 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14093
14094 u8 *binary = (u8 *) mymalloc (binary_size);
14095
14096 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14097
14098 writeProgramBin (cached_file, binary, binary_size);
14099
14100 local_free (binary);
14101 }
14102 else
14103 {
14104 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14105
14106 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14107
14108 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14109
14110 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14111 }
14112
14113 local_free (kernel_lengths);
14114 local_free (kernel_sources[0]);
14115 local_free (kernel_sources);
14116 }
14117
14118 /**
14119 * global buffers
14120 */
14121
14122 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14123 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14124 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14125 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14126 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14127 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14128 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14129 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14130 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14131 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14132 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14133 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14134 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14135 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14136 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14137 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14138 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14139 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14140
14141 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);
14142 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);
14143 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);
14144 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);
14145 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);
14146 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);
14147 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);
14148 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);
14149 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14150 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14151 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14152
14153 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14154 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14155 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14156 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14157 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14158 run_kernel_bzero (device_param, device_param->d_result, size_results);
14159
14160 /**
14161 * special buffers
14162 */
14163
14164 if (attack_kern == ATTACK_KERN_STRAIGHT)
14165 {
14166 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14167 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14168
14169 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14170
14171 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14172 }
14173 else if (attack_kern == ATTACK_KERN_COMBI)
14174 {
14175 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14176 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14177 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14178 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14179
14180 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14181 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14182 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14183 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14184 }
14185 else if (attack_kern == ATTACK_KERN_BF)
14186 {
14187 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14188 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14189 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14190 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14191 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14192
14193 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14194 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14195 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14196 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14197 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14198 }
14199
14200 if (size_esalts)
14201 {
14202 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14203
14204 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14205 }
14206
14207 /**
14208 * main host data
14209 */
14210
14211 uint *result = (uint *) mymalloc (size_results);
14212
14213 device_param->result = result;
14214
14215 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14216
14217 device_param->pws_buf = pws_buf;
14218
14219 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14220
14221 for (int i = 0; i < 64; i++)
14222 {
14223 pw_caches[i].pw_buf.pw_len = i;
14224 pw_caches[i].cnt = 0;
14225 }
14226
14227 device_param->pw_caches = pw_caches;
14228
14229 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14230
14231 device_param->combs_buf = combs_buf;
14232
14233 void *hooks_buf = mymalloc (size_hooks);
14234
14235 device_param->hooks_buf = hooks_buf;
14236
14237 device_param->pw_transpose = pw_transpose_to_hi1;
14238 device_param->pw_add = pw_add_to_hc1;
14239
14240 /**
14241 * kernel args
14242 */
14243
14244 device_param->kernel_params_buf32[21] = bitmap_mask;
14245 device_param->kernel_params_buf32[22] = bitmap_shift1;
14246 device_param->kernel_params_buf32[23] = bitmap_shift2;
14247 device_param->kernel_params_buf32[24] = 0; // salt_pos
14248 device_param->kernel_params_buf32[25] = 0; // loop_pos
14249 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14250 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14251 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14252 device_param->kernel_params_buf32[29] = 0; // digests_offset
14253 device_param->kernel_params_buf32[30] = 0; // combs_mode
14254 device_param->kernel_params_buf32[31] = 0; // gid_max
14255
14256 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14257 ? &device_param->d_pws_buf
14258 : &device_param->d_pws_amp_buf;
14259 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14260 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14261 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14262 device_param->kernel_params[ 4] = &device_param->d_tmps;
14263 device_param->kernel_params[ 5] = &device_param->d_hooks;
14264 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14265 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14266 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14267 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14268 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14269 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14270 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14271 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14272 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14273 device_param->kernel_params[15] = &device_param->d_digests_buf;
14274 device_param->kernel_params[16] = &device_param->d_digests_shown;
14275 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14276 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14277 device_param->kernel_params[19] = &device_param->d_result;
14278 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14279 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14280 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14281 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14282 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14283 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14284 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14285 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14286 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14287 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14288 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14289 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14290
14291 device_param->kernel_params_mp_buf64[3] = 0;
14292 device_param->kernel_params_mp_buf32[4] = 0;
14293 device_param->kernel_params_mp_buf32[5] = 0;
14294 device_param->kernel_params_mp_buf32[6] = 0;
14295 device_param->kernel_params_mp_buf32[7] = 0;
14296 device_param->kernel_params_mp_buf32[8] = 0;
14297
14298 device_param->kernel_params_mp[0] = NULL;
14299 device_param->kernel_params_mp[1] = NULL;
14300 device_param->kernel_params_mp[2] = NULL;
14301 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14302 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14303 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14304 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14305 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14306 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14307
14308 device_param->kernel_params_mp_l_buf64[3] = 0;
14309 device_param->kernel_params_mp_l_buf32[4] = 0;
14310 device_param->kernel_params_mp_l_buf32[5] = 0;
14311 device_param->kernel_params_mp_l_buf32[6] = 0;
14312 device_param->kernel_params_mp_l_buf32[7] = 0;
14313 device_param->kernel_params_mp_l_buf32[8] = 0;
14314 device_param->kernel_params_mp_l_buf32[9] = 0;
14315
14316 device_param->kernel_params_mp_l[0] = NULL;
14317 device_param->kernel_params_mp_l[1] = NULL;
14318 device_param->kernel_params_mp_l[2] = NULL;
14319 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14320 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14321 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14322 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14323 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14324 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14325 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14326
14327 device_param->kernel_params_mp_r_buf64[3] = 0;
14328 device_param->kernel_params_mp_r_buf32[4] = 0;
14329 device_param->kernel_params_mp_r_buf32[5] = 0;
14330 device_param->kernel_params_mp_r_buf32[6] = 0;
14331 device_param->kernel_params_mp_r_buf32[7] = 0;
14332 device_param->kernel_params_mp_r_buf32[8] = 0;
14333
14334 device_param->kernel_params_mp_r[0] = NULL;
14335 device_param->kernel_params_mp_r[1] = NULL;
14336 device_param->kernel_params_mp_r[2] = NULL;
14337 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14338 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14339 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14340 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14341 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14342 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14343
14344 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14345 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14346
14347 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14348 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14349 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14350 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14351 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14352 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14353 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14354
14355 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14356
14357 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14358 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14359
14360 /**
14361 * kernel name
14362 */
14363
14364 char kernel_name[64] = { 0 };
14365
14366 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14367 {
14368 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14369 {
14370 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14371
14372 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14373
14374 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14375
14376 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14377
14378 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14379
14380 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14381 }
14382 else
14383 {
14384 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14385
14386 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14387
14388 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14389
14390 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14391
14392 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14393
14394 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14395 }
14396
14397 if (data.attack_mode == ATTACK_MODE_BF)
14398 {
14399 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14400 {
14401 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14402
14403 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14404
14405 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14406
14407 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14408 }
14409 }
14410 }
14411 else
14412 {
14413 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14414
14415 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14416
14417 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14418
14419 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14420
14421 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14422
14423 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14424
14425 if (opts_type & OPTS_TYPE_HOOK12)
14426 {
14427 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14428
14429 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14430 }
14431
14432 if (opts_type & OPTS_TYPE_HOOK23)
14433 {
14434 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14435
14436 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14437 }
14438 }
14439
14440 for (uint i = 0; i <= 20; i++)
14441 {
14442 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14443 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14444 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14445
14446 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14447 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14448 }
14449
14450 for (uint i = 21; i <= 31; i++)
14451 {
14452 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14453 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14454 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14455
14456 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14457 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14458 }
14459
14460 if (attack_mode == ATTACK_MODE_BF)
14461 {
14462 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14463 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14464
14465 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14466 {
14467 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14468
14469 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14470 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14471 }
14472 }
14473 else if (attack_mode == ATTACK_MODE_HYBRID1)
14474 {
14475 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14476 }
14477 else if (attack_mode == ATTACK_MODE_HYBRID2)
14478 {
14479 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14480 }
14481
14482 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14483 {
14484 // nothing to do
14485 }
14486 else
14487 {
14488 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14489 }
14490
14491 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14492 {
14493 // nothing to do
14494 }
14495 else
14496 {
14497 for (uint i = 0; i < 5; i++)
14498 {
14499 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14500 }
14501
14502 for (uint i = 5; i < 7; i++)
14503 {
14504 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14505 }
14506 }
14507
14508 /**
14509 * Store initial fanspeed if gpu_temp_retain is enabled
14510 */
14511
14512 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14513 int gpu_temp_retain_set = 0;
14514
14515 if (gpu_temp_disable == 0)
14516 {
14517 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14518 {
14519 hc_thread_mutex_lock (mux_adl);
14520
14521 if (data.hm_device[device_id].fan_supported == 1)
14522 {
14523 if (gpu_temp_retain_chgd == 0)
14524 {
14525 uint cur_temp = 0;
14526 uint default_temp = 0;
14527
14528 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);
14529
14530 if (ADL_rc == ADL_OK)
14531 {
14532 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14533
14534 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14535
14536 // special case with multi gpu setups: always use minimum retain
14537
14538 if (gpu_temp_retain_set == 0)
14539 {
14540 gpu_temp_retain = gpu_temp_retain_target;
14541 gpu_temp_retain_set = 1;
14542 }
14543 else
14544 {
14545 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14546 }
14547
14548 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14549 }
14550 }
14551
14552 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14553
14554 temp_retain_fanspeed_value[device_id] = fan_speed;
14555
14556 if (fan_speed == -1)
14557 {
14558 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14559
14560 temp_retain_fanspeed_value[device_id] = 0;
14561 }
14562 }
14563
14564 hc_thread_mutex_unlock (mux_adl);
14565 }
14566 }
14567
14568 /**
14569 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14570 */
14571
14572 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14573 {
14574 hc_thread_mutex_lock (mux_adl);
14575
14576 if (data.hm_device[device_id].od_version == 6)
14577 {
14578 int ADL_rc;
14579
14580 // check powertune capabilities first, if not available then skip device
14581
14582 int powertune_supported = 0;
14583
14584 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14585 {
14586 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14587
14588 return (-1);
14589 }
14590
14591 if (powertune_supported != 0)
14592 {
14593 // powercontrol settings
14594
14595 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14596
14597 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14598 {
14599 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14600 }
14601
14602 if (ADL_rc != ADL_OK)
14603 {
14604 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14605
14606 return (-1);
14607 }
14608
14609 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14610 {
14611 log_error ("ERROR: Failed to set new ADL PowerControl values");
14612
14613 return (-1);
14614 }
14615
14616 // clocks
14617
14618 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14619
14620 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14621
14622 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)
14623 {
14624 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14625
14626 return (-1);
14627 }
14628
14629 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14630
14631 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14632
14633 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14634 {
14635 log_error ("ERROR: Failed to get ADL device capabilities");
14636
14637 return (-1);
14638 }
14639
14640 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14641 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14642
14643 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14644 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14645
14646 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14647 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14648
14649 // warning if profile has too low max values
14650
14651 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14652 {
14653 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14654 }
14655
14656 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14657 {
14658 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14659 }
14660
14661 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14662
14663 performance_state->iNumberOfPerformanceLevels = 2;
14664
14665 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14666 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14667 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14668 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14669
14670 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)
14671 {
14672 log_info ("ERROR: Failed to set ADL performance state");
14673
14674 return (-1);
14675 }
14676
14677 local_free (performance_state);
14678 }
14679 }
14680
14681 hc_thread_mutex_unlock (mux_adl);
14682 }
14683 #endif // HAVE_HWMON && HAVE_ADL
14684 }
14685
14686 data.kernel_blocks_all = kernel_blocks_all;
14687
14688 if (data.quiet == 0) log_info ("");
14689
14690 /**
14691 * Inform user which algorithm is checked and at which workload setting
14692 */
14693
14694 if (benchmark == 1)
14695 {
14696 quiet = 0;
14697
14698 data.quiet = quiet;
14699
14700 char *hash_type = strhashtype (data.hash_mode); // not a bug
14701
14702 log_info ("Hashtype: %s", hash_type);
14703 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14704 log_info ("");
14705 }
14706
14707 /**
14708 * keep track of the progress
14709 */
14710
14711 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14712 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14713 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14714
14715 /**
14716 * open filehandles
14717 */
14718
14719 #if _WIN
14720 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14721 {
14722 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14723
14724 return (-1);
14725 }
14726
14727 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14728 {
14729 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14730
14731 return (-1);
14732 }
14733
14734 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14735 {
14736 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14737
14738 return (-1);
14739 }
14740 #endif
14741
14742 /**
14743 * dictionary pad
14744 */
14745
14746 segment_size *= (1024 * 1024);
14747
14748 data.segment_size = segment_size;
14749
14750 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14751
14752 wl_data->buf = (char *) mymalloc (segment_size);
14753 wl_data->avail = segment_size;
14754 wl_data->incr = segment_size;
14755 wl_data->cnt = 0;
14756 wl_data->pos = 0;
14757
14758 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14759
14760 data.wordlist_mode = wordlist_mode;
14761
14762 cs_t *css_buf = NULL;
14763 uint css_cnt = 0;
14764 uint dictcnt = 0;
14765 uint maskcnt = 1;
14766 char **masks = NULL;
14767 char **dictfiles = NULL;
14768
14769 uint mask_from_file = 0;
14770
14771 if (attack_mode == ATTACK_MODE_STRAIGHT)
14772 {
14773 if (wordlist_mode == WL_MODE_FILE)
14774 {
14775 int wls_left = myargc - (optind + 1);
14776
14777 for (int i = 0; i < wls_left; i++)
14778 {
14779 char *l0_filename = myargv[optind + 1 + i];
14780
14781 struct stat l0_stat;
14782
14783 if (stat (l0_filename, &l0_stat) == -1)
14784 {
14785 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14786
14787 return (-1);
14788 }
14789
14790 uint is_dir = S_ISDIR (l0_stat.st_mode);
14791
14792 if (is_dir == 0)
14793 {
14794 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14795
14796 dictcnt++;
14797
14798 dictfiles[dictcnt - 1] = l0_filename;
14799 }
14800 else
14801 {
14802 // do not allow --keyspace w/ a directory
14803
14804 if (keyspace == 1)
14805 {
14806 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14807
14808 return (-1);
14809 }
14810
14811 char **dictionary_files = NULL;
14812
14813 dictionary_files = scan_directory (l0_filename);
14814
14815 if (dictionary_files != NULL)
14816 {
14817 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14818
14819 for (int d = 0; dictionary_files[d] != NULL; d++)
14820 {
14821 char *l1_filename = dictionary_files[d];
14822
14823 struct stat l1_stat;
14824
14825 if (stat (l1_filename, &l1_stat) == -1)
14826 {
14827 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14828
14829 return (-1);
14830 }
14831
14832 if (S_ISREG (l1_stat.st_mode))
14833 {
14834 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14835
14836 dictcnt++;
14837
14838 dictfiles[dictcnt - 1] = strdup (l1_filename);
14839 }
14840 }
14841 }
14842
14843 local_free (dictionary_files);
14844 }
14845 }
14846
14847 if (dictcnt < 1)
14848 {
14849 log_error ("ERROR: No usable dictionary file found.");
14850
14851 return (-1);
14852 }
14853 }
14854 else if (wordlist_mode == WL_MODE_STDIN)
14855 {
14856 dictcnt = 1;
14857 }
14858 }
14859 else if (attack_mode == ATTACK_MODE_COMBI)
14860 {
14861 // display
14862
14863 char *dictfile1 = myargv[optind + 1 + 0];
14864 char *dictfile2 = myargv[optind + 1 + 1];
14865
14866 // find the bigger dictionary and use as base
14867
14868 FILE *fp1 = NULL;
14869 FILE *fp2 = NULL;
14870
14871 struct stat tmp_stat;
14872
14873 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14874 {
14875 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14876
14877 return (-1);
14878 }
14879
14880 if (stat (dictfile1, &tmp_stat) == -1)
14881 {
14882 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14883
14884 fclose (fp1);
14885
14886 return (-1);
14887 }
14888
14889 if (S_ISDIR (tmp_stat.st_mode))
14890 {
14891 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14892
14893 fclose (fp1);
14894
14895 return (-1);
14896 }
14897
14898 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14899 {
14900 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14901
14902 fclose (fp1);
14903
14904 return (-1);
14905 }
14906
14907 if (stat (dictfile2, &tmp_stat) == -1)
14908 {
14909 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14910
14911 fclose (fp1);
14912 fclose (fp2);
14913
14914 return (-1);
14915 }
14916
14917 if (S_ISDIR (tmp_stat.st_mode))
14918 {
14919 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14920
14921 fclose (fp1);
14922 fclose (fp2);
14923
14924 return (-1);
14925 }
14926
14927 data.combs_cnt = 1;
14928
14929 data.quiet = 1;
14930
14931 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14932
14933 data.quiet = quiet;
14934
14935 if (words1_cnt == 0)
14936 {
14937 log_error ("ERROR: %s: empty file", dictfile1);
14938
14939 fclose (fp1);
14940 fclose (fp2);
14941
14942 return (-1);
14943 }
14944
14945 data.combs_cnt = 1;
14946
14947 data.quiet = 1;
14948
14949 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14950
14951 data.quiet = quiet;
14952
14953 if (words2_cnt == 0)
14954 {
14955 log_error ("ERROR: %s: empty file", dictfile2);
14956
14957 fclose (fp1);
14958 fclose (fp2);
14959
14960 return (-1);
14961 }
14962
14963 fclose (fp1);
14964 fclose (fp2);
14965
14966 data.dictfile = dictfile1;
14967 data.dictfile2 = dictfile2;
14968
14969 if (words1_cnt >= words2_cnt)
14970 {
14971 data.combs_cnt = words2_cnt;
14972 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14973
14974 dictfiles = &data.dictfile;
14975
14976 dictcnt = 1;
14977 }
14978 else
14979 {
14980 data.combs_cnt = words1_cnt;
14981 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14982
14983 dictfiles = &data.dictfile2;
14984
14985 dictcnt = 1;
14986
14987 // we also have to switch wordlist related rules!
14988
14989 char *tmpc = data.rule_buf_l;
14990
14991 data.rule_buf_l = data.rule_buf_r;
14992 data.rule_buf_r = tmpc;
14993
14994 int tmpi = data.rule_len_l;
14995
14996 data.rule_len_l = data.rule_len_r;
14997 data.rule_len_r = tmpi;
14998 }
14999 }
15000 else if (attack_mode == ATTACK_MODE_BF)
15001 {
15002 char *mask = NULL;
15003
15004 maskcnt = 0;
15005
15006 if (benchmark == 0)
15007 {
15008 mask = myargv[optind + 1];
15009
15010 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15011
15012 if ((optind + 2) <= myargc)
15013 {
15014 struct stat file_stat;
15015
15016 if (stat (mask, &file_stat) == -1)
15017 {
15018 maskcnt = 1;
15019
15020 masks[maskcnt - 1] = mystrdup (mask);
15021 }
15022 else
15023 {
15024 int wls_left = myargc - (optind + 1);
15025
15026 uint masks_avail = INCR_MASKS;
15027
15028 for (int i = 0; i < wls_left; i++)
15029 {
15030 if (i != 0)
15031 {
15032 mask = myargv[optind + 1 + i];
15033
15034 if (stat (mask, &file_stat) == -1)
15035 {
15036 log_error ("ERROR: %s: %s", mask, strerror (errno));
15037
15038 return (-1);
15039 }
15040 }
15041
15042 uint is_file = S_ISREG (file_stat.st_mode);
15043
15044 if (is_file == 1)
15045 {
15046 FILE *mask_fp;
15047
15048 if ((mask_fp = fopen (mask, "r")) == NULL)
15049 {
15050 log_error ("ERROR: %s: %s", mask, strerror (errno));
15051
15052 return (-1);
15053 }
15054
15055 char line_buf[BUFSIZ] = { 0 };
15056
15057 while (!feof (mask_fp))
15058 {
15059 memset (line_buf, 0, BUFSIZ);
15060
15061 int line_len = fgetl (mask_fp, line_buf);
15062
15063 if (line_len == 0) continue;
15064
15065 if (line_buf[0] == '#') continue;
15066
15067 if (masks_avail == maskcnt)
15068 {
15069 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15070
15071 masks_avail += INCR_MASKS;
15072 }
15073
15074 masks[maskcnt] = mystrdup (line_buf);
15075
15076 maskcnt++;
15077 }
15078
15079 fclose (mask_fp);
15080 }
15081 else
15082 {
15083 log_error ("ERROR: %s: unsupported file-type", mask);
15084
15085 return (-1);
15086 }
15087 }
15088
15089 mask_from_file = 1;
15090 }
15091 }
15092 else
15093 {
15094 custom_charset_1 = (char *) "?l?d?u";
15095 custom_charset_2 = (char *) "?l?d";
15096 custom_charset_3 = (char *) "?l?d*!$@_";
15097
15098 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15099 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15100 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15101
15102 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15103
15104 wordlist_mode = WL_MODE_MASK;
15105
15106 data.wordlist_mode = wordlist_mode;
15107
15108 increment = 1;
15109
15110 maskcnt = 1;
15111 }
15112 }
15113 else
15114 {
15115 /**
15116 * generate full masks and charsets
15117 */
15118
15119 masks = (char **) mymalloc (sizeof (char *));
15120
15121 switch (hash_mode)
15122 {
15123 case 1731: pw_min = 5;
15124 pw_max = 5;
15125 mask = mystrdup ("?b?b?b?b?b");
15126 break;
15127 case 12500: pw_min = 5;
15128 pw_max = 5;
15129 mask = mystrdup ("?b?b?b?b?b");
15130 break;
15131 default: pw_min = 7;
15132 pw_max = 7;
15133 mask = mystrdup ("?b?b?b?b?b?b?b");
15134 break;
15135 }
15136
15137 maskcnt = 1;
15138
15139 masks[maskcnt - 1] = mystrdup (mask);
15140
15141 wordlist_mode = WL_MODE_MASK;
15142
15143 data.wordlist_mode = wordlist_mode;
15144
15145 increment = 1;
15146 }
15147
15148 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15149
15150 if (increment)
15151 {
15152 if (increment_min > pw_min) pw_min = increment_min;
15153
15154 if (increment_max < pw_max) pw_max = increment_max;
15155 }
15156 }
15157 else if (attack_mode == ATTACK_MODE_HYBRID1)
15158 {
15159 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15160
15161 // display
15162
15163 char *mask = myargv[myargc - 1];
15164
15165 maskcnt = 0;
15166
15167 masks = (char **) mymalloc (1 * sizeof (char *));
15168
15169 // mod
15170
15171 struct stat file_stat;
15172
15173 if (stat (mask, &file_stat) == -1)
15174 {
15175 maskcnt = 1;
15176
15177 masks[maskcnt - 1] = mystrdup (mask);
15178 }
15179 else
15180 {
15181 uint is_file = S_ISREG (file_stat.st_mode);
15182
15183 if (is_file == 1)
15184 {
15185 FILE *mask_fp;
15186
15187 if ((mask_fp = fopen (mask, "r")) == NULL)
15188 {
15189 log_error ("ERROR: %s: %s", mask, strerror (errno));
15190
15191 return (-1);
15192 }
15193
15194 char line_buf[BUFSIZ] = { 0 };
15195
15196 uint masks_avail = 1;
15197
15198 while (!feof (mask_fp))
15199 {
15200 memset (line_buf, 0, BUFSIZ);
15201
15202 int line_len = fgetl (mask_fp, line_buf);
15203
15204 if (line_len == 0) continue;
15205
15206 if (line_buf[0] == '#') continue;
15207
15208 if (masks_avail == maskcnt)
15209 {
15210 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15211
15212 masks_avail += INCR_MASKS;
15213 }
15214
15215 masks[maskcnt] = mystrdup (line_buf);
15216
15217 maskcnt++;
15218 }
15219
15220 fclose (mask_fp);
15221
15222 mask_from_file = 1;
15223 }
15224 else
15225 {
15226 maskcnt = 1;
15227
15228 masks[maskcnt - 1] = mystrdup (mask);
15229 }
15230 }
15231
15232 // base
15233
15234 int wls_left = myargc - (optind + 2);
15235
15236 for (int i = 0; i < wls_left; i++)
15237 {
15238 char *filename = myargv[optind + 1 + i];
15239
15240 struct stat file_stat;
15241
15242 if (stat (filename, &file_stat) == -1)
15243 {
15244 log_error ("ERROR: %s: %s", filename, strerror (errno));
15245
15246 return (-1);
15247 }
15248
15249 uint is_dir = S_ISDIR (file_stat.st_mode);
15250
15251 if (is_dir == 0)
15252 {
15253 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15254
15255 dictcnt++;
15256
15257 dictfiles[dictcnt - 1] = filename;
15258 }
15259 else
15260 {
15261 // do not allow --keyspace w/ a directory
15262
15263 if (keyspace == 1)
15264 {
15265 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15266
15267 return (-1);
15268 }
15269
15270 char **dictionary_files = NULL;
15271
15272 dictionary_files = scan_directory (filename);
15273
15274 if (dictionary_files != NULL)
15275 {
15276 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15277
15278 for (int d = 0; dictionary_files[d] != NULL; d++)
15279 {
15280 char *l1_filename = dictionary_files[d];
15281
15282 struct stat l1_stat;
15283
15284 if (stat (l1_filename, &l1_stat) == -1)
15285 {
15286 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15287
15288 return (-1);
15289 }
15290
15291 if (S_ISREG (l1_stat.st_mode))
15292 {
15293 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15294
15295 dictcnt++;
15296
15297 dictfiles[dictcnt - 1] = strdup (l1_filename);
15298 }
15299 }
15300 }
15301
15302 local_free (dictionary_files);
15303 }
15304 }
15305
15306 if (dictcnt < 1)
15307 {
15308 log_error ("ERROR: No usable dictionary file found.");
15309
15310 return (-1);
15311 }
15312
15313 if (increment)
15314 {
15315 maskcnt = 0;
15316
15317 uint mask_min = increment_min; // we can't reject smaller masks here
15318 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15319
15320 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15321 {
15322 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15323
15324 if (cur_mask == NULL) break;
15325
15326 masks[maskcnt] = cur_mask;
15327
15328 maskcnt++;
15329
15330 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15331 }
15332 }
15333 }
15334 else if (attack_mode == ATTACK_MODE_HYBRID2)
15335 {
15336 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15337
15338 // display
15339
15340 char *mask = myargv[optind + 1 + 0];
15341
15342 maskcnt = 0;
15343
15344 masks = (char **) mymalloc (1 * sizeof (char *));
15345
15346 // mod
15347
15348 struct stat file_stat;
15349
15350 if (stat (mask, &file_stat) == -1)
15351 {
15352 maskcnt = 1;
15353
15354 masks[maskcnt - 1] = mystrdup (mask);
15355 }
15356 else
15357 {
15358 uint is_file = S_ISREG (file_stat.st_mode);
15359
15360 if (is_file == 1)
15361 {
15362 FILE *mask_fp;
15363
15364 if ((mask_fp = fopen (mask, "r")) == NULL)
15365 {
15366 log_error ("ERROR: %s: %s", mask, strerror (errno));
15367
15368 return (-1);
15369 }
15370
15371 char line_buf[BUFSIZ] = { 0 };
15372
15373 uint masks_avail = 1;
15374
15375 while (!feof (mask_fp))
15376 {
15377 memset (line_buf, 0, BUFSIZ);
15378
15379 int line_len = fgetl (mask_fp, line_buf);
15380
15381 if (line_len == 0) continue;
15382
15383 if (line_buf[0] == '#') continue;
15384
15385 if (masks_avail == maskcnt)
15386 {
15387 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15388
15389 masks_avail += INCR_MASKS;
15390 }
15391
15392 masks[maskcnt] = mystrdup (line_buf);
15393
15394 maskcnt++;
15395 }
15396
15397 fclose (mask_fp);
15398
15399 mask_from_file = 1;
15400 }
15401 else
15402 {
15403 maskcnt = 1;
15404
15405 masks[maskcnt - 1] = mystrdup (mask);
15406 }
15407 }
15408
15409 // base
15410
15411 int wls_left = myargc - (optind + 2);
15412
15413 for (int i = 0; i < wls_left; i++)
15414 {
15415 char *filename = myargv[optind + 2 + i];
15416
15417 struct stat file_stat;
15418
15419 if (stat (filename, &file_stat) == -1)
15420 {
15421 log_error ("ERROR: %s: %s", filename, strerror (errno));
15422
15423 return (-1);
15424 }
15425
15426 uint is_dir = S_ISDIR (file_stat.st_mode);
15427
15428 if (is_dir == 0)
15429 {
15430 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15431
15432 dictcnt++;
15433
15434 dictfiles[dictcnt - 1] = filename;
15435 }
15436 else
15437 {
15438 // do not allow --keyspace w/ a directory
15439
15440 if (keyspace == 1)
15441 {
15442 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15443
15444 return (-1);
15445 }
15446
15447 char **dictionary_files = NULL;
15448
15449 dictionary_files = scan_directory (filename);
15450
15451 if (dictionary_files != NULL)
15452 {
15453 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15454
15455 for (int d = 0; dictionary_files[d] != NULL; d++)
15456 {
15457 char *l1_filename = dictionary_files[d];
15458
15459 struct stat l1_stat;
15460
15461 if (stat (l1_filename, &l1_stat) == -1)
15462 {
15463 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15464
15465 return (-1);
15466 }
15467
15468 if (S_ISREG (l1_stat.st_mode))
15469 {
15470 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15471
15472 dictcnt++;
15473
15474 dictfiles[dictcnt - 1] = strdup (l1_filename);
15475 }
15476 }
15477 }
15478
15479 local_free (dictionary_files);
15480 }
15481 }
15482
15483 if (dictcnt < 1)
15484 {
15485 log_error ("ERROR: No usable dictionary file found.");
15486
15487 return (-1);
15488 }
15489
15490 if (increment)
15491 {
15492 maskcnt = 0;
15493
15494 uint mask_min = increment_min; // we can't reject smaller masks here
15495 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15496
15497 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15498 {
15499 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15500
15501 if (cur_mask == NULL) break;
15502
15503 masks[maskcnt] = cur_mask;
15504
15505 maskcnt++;
15506
15507 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15508 }
15509 }
15510 }
15511
15512 data.pw_min = pw_min;
15513 data.pw_max = pw_max;
15514
15515 /**
15516 * weak hash check
15517 */
15518
15519 if (weak_hash_threshold >= salts_cnt)
15520 {
15521 hc_device_param_t *device_param = NULL;
15522
15523 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15524 {
15525 device_param = &data.devices_param[device_id];
15526
15527 if (device_param->skipped) continue;
15528
15529 break;
15530 }
15531
15532 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15533
15534 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15535 {
15536 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15537 }
15538 }
15539
15540 // Display hack, guarantee that there is at least one \r before real start
15541
15542 if (data.quiet == 0) log_info_nn ("");
15543
15544 /**
15545 * status and monitor threads
15546 */
15547
15548 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15549
15550 hc_thread_t i_thread = 0;
15551
15552 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15553 {
15554 hc_thread_create (i_thread, thread_keypress, &benchmark);
15555 }
15556
15557 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15558
15559 uint ni_threads_cnt = 0;
15560
15561 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15562
15563 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15564
15565 ni_threads_cnt++;
15566
15567 /**
15568 * Outfile remove
15569 */
15570
15571 if (keyspace == 0)
15572 {
15573 if (outfile_check_timer != 0)
15574 {
15575 if (data.outfile_check_directory != NULL)
15576 {
15577 if ((hash_mode != 5200) &&
15578 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15579 (hash_mode != 9000))
15580 {
15581 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15582
15583 ni_threads_cnt++;
15584 }
15585 else
15586 {
15587 outfile_check_timer = 0;
15588 }
15589 }
15590 else
15591 {
15592 outfile_check_timer = 0;
15593 }
15594 }
15595 }
15596
15597 /**
15598 * Inform the user if we got some hashes remove because of the pot file remove feature
15599 */
15600
15601 if (data.quiet == 0)
15602 {
15603 if (potfile_remove_cracks > 0)
15604 {
15605 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15606 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15607 }
15608 }
15609
15610 data.outfile_check_timer = outfile_check_timer;
15611
15612 /**
15613 * main loop
15614 */
15615
15616 char **induction_dictionaries = NULL;
15617
15618 int induction_dictionaries_cnt = 0;
15619
15620 hcstat_table_t *root_table_buf = NULL;
15621 hcstat_table_t *markov_table_buf = NULL;
15622
15623 uint initial_restore_done = 0;
15624
15625 data.maskcnt = maskcnt;
15626
15627 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15628 {
15629 if (data.devices_status == STATUS_CRACKED) break;
15630
15631 data.devices_status = STATUS_INIT;
15632
15633 if (maskpos > rd->maskpos)
15634 {
15635 rd->dictpos = 0;
15636 }
15637
15638 rd->maskpos = maskpos;
15639 data.maskpos = maskpos;
15640
15641 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15642 {
15643 char *mask = masks[maskpos];
15644
15645 if (mask_from_file == 1)
15646 {
15647 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15648
15649 char *str_ptr;
15650 uint str_pos;
15651
15652 uint mask_offset = 0;
15653
15654 uint separator_cnt;
15655
15656 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15657 {
15658 str_ptr = strstr (mask + mask_offset, ",");
15659
15660 if (str_ptr == NULL) break;
15661
15662 str_pos = str_ptr - mask;
15663
15664 // escaped separator, i.e. "\,"
15665
15666 if (str_pos > 0)
15667 {
15668 if (mask[str_pos - 1] == '\\')
15669 {
15670 separator_cnt --;
15671
15672 mask_offset = str_pos + 1;
15673
15674 continue;
15675 }
15676 }
15677
15678 // reset the offset
15679
15680 mask_offset = 0;
15681
15682 mask[str_pos] = '\0';
15683
15684 switch (separator_cnt)
15685 {
15686 case 0:
15687 mp_reset_usr (mp_usr, 0);
15688
15689 custom_charset_1 = mask;
15690 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15691 break;
15692
15693 case 1:
15694 mp_reset_usr (mp_usr, 1);
15695
15696 custom_charset_2 = mask;
15697 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15698 break;
15699
15700 case 2:
15701 mp_reset_usr (mp_usr, 2);
15702
15703 custom_charset_3 = mask;
15704 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15705 break;
15706
15707 case 3:
15708 mp_reset_usr (mp_usr, 3);
15709
15710 custom_charset_4 = mask;
15711 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15712 break;
15713 }
15714
15715 mask = mask + str_pos + 1;
15716 }
15717 }
15718
15719 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15720 {
15721 if (maskpos > 0)
15722 {
15723 local_free (css_buf);
15724 local_free (data.root_css_buf);
15725 local_free (data.markov_css_buf);
15726
15727 local_free (masks[maskpos - 1]);
15728 }
15729
15730 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15731
15732 data.mask = mask;
15733 data.css_cnt = css_cnt;
15734 data.css_buf = css_buf;
15735
15736 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15737
15738 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15739
15740 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15741 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15742
15743 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15744
15745 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15746
15747 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15748 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15749
15750 data.root_css_buf = root_css_buf;
15751 data.markov_css_buf = markov_css_buf;
15752
15753 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15754
15755 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15756
15757 local_free (root_table_buf);
15758 local_free (markov_table_buf);
15759
15760 // args
15761
15762 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15763 {
15764 hc_device_param_t *device_param = &data.devices_param[device_id];
15765
15766 if (device_param->skipped) continue;
15767
15768 device_param->kernel_params_mp[0] = &device_param->d_combs;
15769 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15770 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15771
15772 device_param->kernel_params_mp_buf64[3] = 0;
15773 device_param->kernel_params_mp_buf32[4] = css_cnt;
15774 device_param->kernel_params_mp_buf32[5] = 0;
15775 device_param->kernel_params_mp_buf32[6] = 0;
15776 device_param->kernel_params_mp_buf32[7] = 0;
15777
15778 if (attack_mode == ATTACK_MODE_HYBRID1)
15779 {
15780 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15781 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15782 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15783 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15784 }
15785 else if (attack_mode == ATTACK_MODE_HYBRID2)
15786 {
15787 device_param->kernel_params_mp_buf32[5] = 0;
15788 device_param->kernel_params_mp_buf32[6] = 0;
15789 device_param->kernel_params_mp_buf32[7] = 0;
15790 }
15791
15792 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]);
15793 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]);
15794 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]);
15795
15796 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);
15797 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);
15798 }
15799 }
15800 else if (attack_mode == ATTACK_MODE_BF)
15801 {
15802 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15803
15804 if (increment)
15805 {
15806 for (uint i = 0; i < dictcnt; i++)
15807 {
15808 local_free (dictfiles[i]);
15809 }
15810
15811 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15812 {
15813 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15814
15815 if (l1_filename == NULL) break;
15816
15817 dictcnt++;
15818
15819 dictfiles[dictcnt - 1] = l1_filename;
15820 }
15821 }
15822 else
15823 {
15824 dictcnt++;
15825
15826 dictfiles[dictcnt - 1] = mask;
15827 }
15828
15829 if (dictcnt == 0)
15830 {
15831 log_error ("ERROR: Mask is too small");
15832
15833 return (-1);
15834 }
15835 }
15836 }
15837
15838 free (induction_dictionaries);
15839
15840 // induction_dictionaries_cnt = 0; // implied
15841
15842 if (attack_mode != ATTACK_MODE_BF)
15843 {
15844 if (keyspace == 0)
15845 {
15846 induction_dictionaries = scan_directory (induction_directory);
15847
15848 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15849 }
15850 }
15851
15852 if (induction_dictionaries_cnt)
15853 {
15854 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15855 }
15856
15857 /**
15858 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15859 */
15860 if (keyspace == 1)
15861 {
15862 if ((maskcnt > 1) || (dictcnt > 1))
15863 {
15864 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15865
15866 return (-1);
15867 }
15868 }
15869
15870 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15871 {
15872 char *subid = logfile_generate_subid ();
15873
15874 data.subid = subid;
15875
15876 logfile_sub_msg ("START");
15877
15878 data.devices_status = STATUS_INIT;
15879
15880 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15881 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15882 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15883
15884 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15885
15886 data.cpt_pos = 0;
15887
15888 data.cpt_start = time (NULL);
15889
15890 data.cpt_total = 0;
15891
15892 if (data.restore == 0)
15893 {
15894 rd->words_cur = skip;
15895
15896 skip = 0;
15897
15898 data.skip = 0;
15899 }
15900
15901 data.ms_paused = 0;
15902
15903 data.words_cur = rd->words_cur;
15904
15905 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15906 {
15907 hc_device_param_t *device_param = &data.devices_param[device_id];
15908
15909 if (device_param->skipped) continue;
15910
15911 device_param->speed_pos = 0;
15912
15913 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15914 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15915 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15916
15917 device_param->kernel_power = device_param->kernel_power_user;
15918 device_param->kernel_blocks = device_param->kernel_blocks_user;
15919
15920 device_param->outerloop_pos = 0;
15921 device_param->outerloop_left = 0;
15922 device_param->innerloop_pos = 0;
15923 device_param->innerloop_left = 0;
15924
15925 // some more resets:
15926
15927 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15928
15929 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15930
15931 device_param->pw_cnt = 0;
15932 device_param->pws_cnt = 0;
15933
15934 device_param->words_off = 0;
15935 device_param->words_done = 0;
15936 }
15937
15938 data.kernel_blocks_div = 0;
15939
15940 // figure out some workload
15941
15942 if (attack_mode == ATTACK_MODE_STRAIGHT)
15943 {
15944 if (data.wordlist_mode == WL_MODE_FILE)
15945 {
15946 char *dictfile = NULL;
15947
15948 if (induction_dictionaries_cnt)
15949 {
15950 dictfile = induction_dictionaries[0];
15951 }
15952 else
15953 {
15954 dictfile = dictfiles[dictpos];
15955 }
15956
15957 data.dictfile = dictfile;
15958
15959 logfile_sub_string (dictfile);
15960
15961 for (uint i = 0; i < rp_files_cnt; i++)
15962 {
15963 logfile_sub_var_string ("rulefile", rp_files[i]);
15964 }
15965
15966 FILE *fd2 = fopen (dictfile, "rb");
15967
15968 if (fd2 == NULL)
15969 {
15970 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15971
15972 return (-1);
15973 }
15974
15975 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15976
15977 fclose (fd2);
15978
15979 if (data.words_cnt == 0)
15980 {
15981 if (data.devices_status == STATUS_CRACKED) break;
15982 if (data.devices_status == STATUS_ABORTED) break;
15983
15984 dictpos++;
15985
15986 continue;
15987 }
15988 }
15989 }
15990 else if (attack_mode == ATTACK_MODE_COMBI)
15991 {
15992 char *dictfile = data.dictfile;
15993 char *dictfile2 = data.dictfile2;
15994
15995 logfile_sub_string (dictfile);
15996 logfile_sub_string (dictfile2);
15997
15998 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15999 {
16000 FILE *fd2 = fopen (dictfile, "rb");
16001
16002 if (fd2 == NULL)
16003 {
16004 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16005
16006 return (-1);
16007 }
16008
16009 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16010
16011 fclose (fd2);
16012 }
16013 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16014 {
16015 FILE *fd2 = fopen (dictfile2, "rb");
16016
16017 if (fd2 == NULL)
16018 {
16019 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16020
16021 return (-1);
16022 }
16023
16024 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16025
16026 fclose (fd2);
16027 }
16028
16029 if (data.words_cnt == 0)
16030 {
16031 if (data.devices_status == STATUS_CRACKED) break;
16032 if (data.devices_status == STATUS_ABORTED) break;
16033
16034 dictpos++;
16035
16036 continue;
16037 }
16038 }
16039 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16040 {
16041 char *dictfile = NULL;
16042
16043 if (induction_dictionaries_cnt)
16044 {
16045 dictfile = induction_dictionaries[0];
16046 }
16047 else
16048 {
16049 dictfile = dictfiles[dictpos];
16050 }
16051
16052 data.dictfile = dictfile;
16053
16054 char *mask = data.mask;
16055
16056 logfile_sub_string (dictfile);
16057 logfile_sub_string (mask);
16058
16059 FILE *fd2 = fopen (dictfile, "rb");
16060
16061 if (fd2 == NULL)
16062 {
16063 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16064
16065 return (-1);
16066 }
16067
16068 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16069
16070 fclose (fd2);
16071
16072 if (data.words_cnt == 0)
16073 {
16074 if (data.devices_status == STATUS_CRACKED) break;
16075 if (data.devices_status == STATUS_ABORTED) break;
16076
16077 dictpos++;
16078
16079 continue;
16080 }
16081 }
16082 else if (attack_mode == ATTACK_MODE_BF)
16083 {
16084 local_free (css_buf);
16085 local_free (data.root_css_buf);
16086 local_free (data.markov_css_buf);
16087
16088 char *mask = dictfiles[dictpos];
16089
16090 logfile_sub_string (mask);
16091
16092 // base
16093
16094 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16095
16096 if (opts_type & OPTS_TYPE_PT_UNICODE)
16097 {
16098 uint css_cnt_unicode = css_cnt * 2;
16099
16100 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16101
16102 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16103 {
16104 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16105
16106 css_buf_unicode[j + 1].cs_buf[0] = 0;
16107 css_buf_unicode[j + 1].cs_len = 1;
16108 }
16109
16110 free (css_buf);
16111
16112 css_buf = css_buf_unicode;
16113 css_cnt = css_cnt_unicode;
16114 }
16115
16116 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16117
16118 uint mask_min = pw_min;
16119 uint mask_max = pw_max;
16120
16121 if (opts_type & OPTS_TYPE_PT_UNICODE)
16122 {
16123 mask_min *= 2;
16124 mask_max *= 2;
16125 }
16126
16127 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16128 {
16129 if (css_cnt < mask_min)
16130 {
16131 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16132 }
16133
16134 if (css_cnt > mask_max)
16135 {
16136 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16137 }
16138
16139 // skip to next mask
16140
16141 dictpos++;
16142
16143 rd->dictpos = dictpos;
16144
16145 logfile_sub_msg ("STOP");
16146
16147 continue;
16148 }
16149
16150 uint save_css_cnt = css_cnt;
16151
16152 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16153 {
16154 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16155 {
16156 uint salt_len = (uint) data.salts_buf[0].salt_len;
16157 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16158
16159 uint css_cnt_salt = css_cnt + salt_len;
16160
16161 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16162
16163 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16164
16165 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16166 {
16167 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16168 css_buf_salt[j].cs_len = 1;
16169 }
16170
16171 free (css_buf);
16172
16173 css_buf = css_buf_salt;
16174 css_cnt = css_cnt_salt;
16175 }
16176 }
16177
16178 data.mask = mask;
16179 data.css_cnt = css_cnt;
16180 data.css_buf = css_buf;
16181
16182 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16183
16184 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16185
16186 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16187
16188 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16189 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16190
16191 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16192
16193 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16194
16195 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16196 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16197
16198 data.root_css_buf = root_css_buf;
16199 data.markov_css_buf = markov_css_buf;
16200
16201 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16202
16203 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16204
16205 local_free (root_table_buf);
16206 local_free (markov_table_buf);
16207
16208 // copy + args
16209
16210 uint css_cnt_l = css_cnt;
16211 uint css_cnt_r;
16212
16213 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16214 {
16215 if (save_css_cnt < 6)
16216 {
16217 css_cnt_r = 1;
16218 }
16219 else if (save_css_cnt == 6)
16220 {
16221 css_cnt_r = 2;
16222 }
16223 else
16224 {
16225 if (opts_type & OPTS_TYPE_PT_UNICODE)
16226 {
16227 if (save_css_cnt == 8 || save_css_cnt == 10)
16228 {
16229 css_cnt_r = 2;
16230 }
16231 else
16232 {
16233 css_cnt_r = 4;
16234 }
16235 }
16236 else
16237 {
16238 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16239 {
16240 css_cnt_r = 3;
16241 }
16242 else
16243 {
16244 css_cnt_r = 4;
16245 }
16246 }
16247 }
16248 }
16249 else
16250 {
16251 css_cnt_r = 1;
16252
16253 /* unfinished code?
16254 int sum = css_buf[css_cnt_r - 1].cs_len;
16255
16256 for (uint i = 1; i < 4 && i < css_cnt; i++)
16257 {
16258 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16259
16260 css_cnt_r++;
16261
16262 sum *= css_buf[css_cnt_r - 1].cs_len;
16263 }
16264 */
16265 }
16266
16267 css_cnt_l -= css_cnt_r;
16268
16269 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16270
16271 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16272 {
16273 hc_device_param_t *device_param = &data.devices_param[device_id];
16274
16275 if (device_param->skipped) continue;
16276
16277 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16278 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16279 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16280
16281 device_param->kernel_params_mp_l_buf64[3] = 0;
16282 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16283 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16284 device_param->kernel_params_mp_l_buf32[6] = 0;
16285 device_param->kernel_params_mp_l_buf32[7] = 0;
16286 device_param->kernel_params_mp_l_buf32[8] = 0;
16287
16288 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16289 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16290 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16291 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16292
16293 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16294 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16295 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16296
16297 device_param->kernel_params_mp_r_buf64[3] = 0;
16298 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16299 device_param->kernel_params_mp_r_buf32[5] = 0;
16300 device_param->kernel_params_mp_r_buf32[6] = 0;
16301 device_param->kernel_params_mp_r_buf32[7] = 0;
16302
16303 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]);
16304 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]);
16305 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]);
16306
16307 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]);
16308 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]);
16309 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]);
16310
16311 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);
16312 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);
16313 }
16314 }
16315
16316 u64 words_base = data.words_cnt;
16317
16318 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16319 {
16320 if (data.kernel_rules_cnt)
16321 {
16322 words_base /= data.kernel_rules_cnt;
16323 }
16324 }
16325 else if (data.attack_kern == ATTACK_KERN_COMBI)
16326 {
16327 if (data.combs_cnt)
16328 {
16329 words_base /= data.combs_cnt;
16330 }
16331 }
16332 else if (data.attack_kern == ATTACK_KERN_BF)
16333 {
16334 if (data.bfs_cnt)
16335 {
16336 words_base /= data.bfs_cnt;
16337 }
16338 }
16339
16340 data.words_base = words_base;
16341
16342 if (keyspace == 1)
16343 {
16344 log_info ("%llu", (unsigned long long int) words_base);
16345
16346 return (0);
16347 }
16348
16349 if (data.words_cur > data.words_base)
16350 {
16351 log_error ("ERROR: restore value greater keyspace");
16352
16353 return (-1);
16354 }
16355
16356 if (data.words_cur)
16357 {
16358 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16359 {
16360 for (uint i = 0; i < data.salts_cnt; i++)
16361 {
16362 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16363 }
16364 }
16365 else if (data.attack_kern == ATTACK_KERN_COMBI)
16366 {
16367 for (uint i = 0; i < data.salts_cnt; i++)
16368 {
16369 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16370 }
16371 }
16372 else if (data.attack_kern == ATTACK_KERN_BF)
16373 {
16374 for (uint i = 0; i < data.salts_cnt; i++)
16375 {
16376 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16377 }
16378 }
16379 }
16380
16381 /*
16382 * Inform user about possible slow speeds
16383 */
16384
16385 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16386 {
16387 if (data.words_base < kernel_blocks_all)
16388 {
16389 if (quiet == 0)
16390 {
16391 log_info ("");
16392 log_info ("ATTENTION!");
16393 log_info (" The wordlist or mask you are using is too small.");
16394 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16395 log_info (" The cracking speed will drop.");
16396 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16397 log_info ("");
16398 }
16399 }
16400 }
16401
16402 /*
16403 * Update loopback file
16404 */
16405
16406 if (loopback == 1)
16407 {
16408 time_t now;
16409
16410 time (&now);
16411
16412 uint random_num = get_random_num (0, 9999);
16413
16414 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16415
16416 data.loopback_file = loopback_file;
16417 }
16418
16419 /*
16420 * Update dictionary statistic
16421 */
16422
16423 if (keyspace == 0)
16424 {
16425 dictstat_fp = fopen (dictstat, "wb");
16426
16427 if (dictstat_fp)
16428 {
16429 lock_file (dictstat_fp);
16430
16431 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16432
16433 fclose (dictstat_fp);
16434 }
16435 }
16436
16437 data.devices_status = STATUS_RUNNING;
16438
16439 if (initial_restore_done == 0)
16440 {
16441 if (data.restore_disable == 0) cycle_restore ();
16442
16443 initial_restore_done = 1;
16444 }
16445
16446 hc_timer_set (&data.timer_running);
16447
16448 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16449 {
16450 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16451 {
16452 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16453 if (quiet == 0) fflush (stdout);
16454 }
16455 }
16456 else if (wordlist_mode == WL_MODE_STDIN)
16457 {
16458 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16459 if (data.quiet == 0) log_info ("");
16460 }
16461
16462 time_t runtime_start;
16463
16464 time (&runtime_start);
16465
16466 data.runtime_start = runtime_start;
16467
16468 /**
16469 * create cracker threads
16470 */
16471
16472 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16473
16474 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16475 {
16476 hc_device_param_t *device_param = &devices_param[device_id];
16477
16478 if (wordlist_mode == WL_MODE_STDIN)
16479 {
16480 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16481 }
16482 else
16483 {
16484 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16485 }
16486 }
16487
16488 // wait for crack threads to exit
16489
16490 hc_thread_wait (data.devices_cnt, c_threads);
16491
16492 local_free (c_threads);
16493
16494 data.restore = 0;
16495
16496 // finalize task
16497
16498 logfile_sub_var_uint ("status-after-work", data.devices_status);
16499
16500 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16501
16502 if (data.devices_status == STATUS_CRACKED) break;
16503 if (data.devices_status == STATUS_ABORTED) break;
16504
16505 if (data.devices_status == STATUS_BYPASS)
16506 {
16507 data.devices_status = STATUS_RUNNING;
16508 }
16509
16510 if (induction_dictionaries_cnt)
16511 {
16512 unlink (induction_dictionaries[0]);
16513 }
16514
16515 free (induction_dictionaries);
16516
16517 if (attack_mode != ATTACK_MODE_BF)
16518 {
16519 induction_dictionaries = scan_directory (induction_directory);
16520
16521 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16522 }
16523
16524 if (benchmark == 0)
16525 {
16526 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16527 {
16528 if (quiet == 0) clear_prompt ();
16529
16530 if (quiet == 0) log_info ("");
16531
16532 if (status == 1)
16533 {
16534 status_display ();
16535 }
16536 else
16537 {
16538 if (quiet == 0) status_display ();
16539 }
16540
16541 if (quiet == 0) log_info ("");
16542 }
16543 }
16544
16545 if (attack_mode == ATTACK_MODE_BF)
16546 {
16547 dictpos++;
16548
16549 rd->dictpos = dictpos;
16550 }
16551 else
16552 {
16553 if (induction_dictionaries_cnt)
16554 {
16555 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16556 }
16557 else
16558 {
16559 dictpos++;
16560
16561 rd->dictpos = dictpos;
16562 }
16563 }
16564
16565 time_t runtime_stop;
16566
16567 time (&runtime_stop);
16568
16569 data.runtime_stop = runtime_stop;
16570
16571 logfile_sub_uint (runtime_start);
16572 logfile_sub_uint (runtime_stop);
16573
16574 logfile_sub_msg ("STOP");
16575
16576 global_free (subid);
16577 }
16578
16579 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16580
16581 if (data.devices_status == STATUS_CRACKED) break;
16582 if (data.devices_status == STATUS_ABORTED) break;
16583 if (data.devices_status == STATUS_QUIT) break;
16584
16585 if (data.devices_status == STATUS_BYPASS)
16586 {
16587 data.devices_status = STATUS_RUNNING;
16588 }
16589 }
16590
16591 // 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
16592
16593 if (attack_mode == ATTACK_MODE_STRAIGHT)
16594 {
16595 if (data.wordlist_mode == WL_MODE_FILE)
16596 {
16597 if (data.dictfile == NULL)
16598 {
16599 if (dictfiles != NULL)
16600 {
16601 data.dictfile = dictfiles[0];
16602
16603 hc_timer_set (&data.timer_running);
16604 }
16605 }
16606 }
16607 }
16608 // NOTE: combi is okay because it is already set beforehand
16609 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16610 {
16611 if (data.dictfile == NULL)
16612 {
16613 if (dictfiles != NULL)
16614 {
16615 hc_timer_set (&data.timer_running);
16616
16617 data.dictfile = dictfiles[0];
16618 }
16619 }
16620 }
16621 else if (attack_mode == ATTACK_MODE_BF)
16622 {
16623 if (data.mask == NULL)
16624 {
16625 hc_timer_set (&data.timer_running);
16626
16627 data.mask = masks[0];
16628 }
16629 }
16630
16631 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16632 {
16633 data.devices_status = STATUS_EXHAUSTED;
16634 }
16635
16636 // if cracked / aborted remove last induction dictionary
16637
16638 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16639 {
16640 struct stat induct_stat;
16641
16642 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16643 {
16644 unlink (induction_dictionaries[file_pos]);
16645 }
16646 }
16647
16648 // wait for non-interactive threads
16649
16650 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16651 {
16652 hc_thread_wait (1, &ni_threads[thread_idx]);
16653 }
16654
16655 local_free (ni_threads);
16656
16657 // wait for interactive threads
16658
16659 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16660 {
16661 hc_thread_wait (1, &i_thread);
16662 }
16663
16664 // we dont need restore file anymore
16665 if (data.restore_disable == 0)
16666 {
16667 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16668 {
16669 unlink (eff_restore_file);
16670 unlink (new_restore_file);
16671 }
16672 else
16673 {
16674 cycle_restore ();
16675 }
16676 }
16677
16678 // finally save left hashes
16679
16680 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16681 {
16682 save_hash ();
16683 }
16684
16685 /**
16686 * Clean up
16687 */
16688
16689 if (benchmark == 1)
16690 {
16691 status_benchmark ();
16692
16693 log_info ("");
16694 }
16695 else
16696 {
16697 if (quiet == 0) clear_prompt ();
16698
16699 if (quiet == 0) log_info ("");
16700
16701 if (status == 1)
16702 {
16703 status_display ();
16704 }
16705 else
16706 {
16707 if (quiet == 0) status_display ();
16708 }
16709
16710 if (quiet == 0) log_info ("");
16711 }
16712
16713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16714 {
16715 hc_device_param_t *device_param = &data.devices_param[device_id];
16716
16717 if (device_param->skipped) continue;
16718
16719 local_free (device_param->result);
16720
16721 local_free (device_param->pw_caches);
16722
16723 local_free (device_param->combs_buf);
16724
16725 local_free (device_param->hooks_buf);
16726
16727 local_free (device_param->device_name);
16728
16729 local_free (device_param->device_name_chksum);
16730
16731 local_free (device_param->device_version);
16732
16733 local_free (device_param->driver_version);
16734
16735 if (device_param->pws_buf) myfree (device_param->pws_buf);
16736 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16737 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16738 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16739 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16740 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16741 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16742 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16743 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16744 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16745 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16746 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16747 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16748 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16749 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16750 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16751 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16752 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16753 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16754 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16755 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16756 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16757 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16758 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16759 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16760 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16761 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16762 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16763 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16764
16765 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16766 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16767 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16768 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16769 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16770 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16771 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16772 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16773 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16774 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16775 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16776
16777 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16778 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16779 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16780
16781 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16782 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16783 }
16784
16785 // reset default fan speed
16786
16787 #ifdef HAVE_HWMON
16788 if (gpu_temp_disable == 0)
16789 {
16790 #ifdef HAVE_ADL
16791 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16792 {
16793 hc_thread_mutex_lock (mux_adl);
16794
16795 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16796 {
16797 hc_device_param_t *device_param = &data.devices_param[device_id];
16798
16799 if (device_param->skipped) continue;
16800
16801 if (data.hm_device[device_id].fan_supported == 1)
16802 {
16803 int fanspeed = temp_retain_fanspeed_value[device_id];
16804
16805 if (fanspeed == -1) continue;
16806
16807 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16808
16809 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16810 }
16811 }
16812
16813 hc_thread_mutex_unlock (mux_adl);
16814 }
16815 #endif // HAVE_ADL
16816 }
16817
16818 #ifdef HAVE_ADL
16819 // reset power tuning
16820
16821 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16822 {
16823 hc_thread_mutex_lock (mux_adl);
16824
16825 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16826 {
16827 hc_device_param_t *device_param = &data.devices_param[device_id];
16828
16829 if (device_param->skipped) continue;
16830
16831 if (data.hm_device[device_id].od_version == 6)
16832 {
16833 // check powertune capabilities first, if not available then skip device
16834
16835 int powertune_supported = 0;
16836
16837 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16838 {
16839 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16840
16841 return (-1);
16842 }
16843
16844 if (powertune_supported != 0)
16845 {
16846 // powercontrol settings
16847
16848 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)
16849 {
16850 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16851
16852 return (-1);
16853 }
16854
16855 // clocks
16856
16857 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16858
16859 performance_state->iNumberOfPerformanceLevels = 2;
16860
16861 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16862 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16863 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16864 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16865
16866 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)
16867 {
16868 log_info ("ERROR: Failed to restore ADL performance state");
16869
16870 return (-1);
16871 }
16872
16873 local_free (performance_state);
16874 }
16875 }
16876 }
16877
16878 hc_thread_mutex_unlock (mux_adl);
16879 }
16880 #endif // HAVE_ADL
16881
16882 if (gpu_temp_disable == 0)
16883 {
16884 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16885 if (data.hm_nv)
16886 {
16887 #if defined(LINUX) && defined(HAVE_NVML)
16888
16889 hm_NVML_nvmlShutdown (data.hm_nv);
16890
16891 nvml_close (data.hm_nv);
16892
16893 #elif defined(WIN) && (HAVE_NVAPI)
16894
16895 hm_NvAPI_Unload (data.hm_nv);
16896
16897 nvapi_close (data.hm_nv);
16898
16899 #endif
16900
16901 data.hm_nv = NULL;
16902 }
16903 #endif
16904
16905 #ifdef HAVE_ADL
16906 if (data.hm_amd)
16907 {
16908 hm_ADL_Main_Control_Destroy (data.hm_amd);
16909
16910 adl_close (data.hm_amd);
16911 data.hm_amd = NULL;
16912 }
16913 #endif
16914 }
16915 #endif // HAVE_HWMON
16916
16917 // free memory
16918
16919 local_free (masks);
16920
16921 local_free (dictstat_base);
16922
16923 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16924 {
16925 pot_t *pot_ptr = &pot[pot_pos];
16926
16927 hash_t *hash = &pot_ptr->hash;
16928
16929 local_free (hash->digest);
16930
16931 if (isSalted)
16932 {
16933 local_free (hash->salt);
16934 }
16935 }
16936
16937 local_free (pot);
16938
16939 local_free (all_kernel_rules_cnt);
16940 local_free (all_kernel_rules_buf);
16941
16942 local_free (wl_data->buf);
16943 local_free (wl_data);
16944
16945 local_free (bitmap_s1_a);
16946 local_free (bitmap_s1_b);
16947 local_free (bitmap_s1_c);
16948 local_free (bitmap_s1_d);
16949 local_free (bitmap_s2_a);
16950 local_free (bitmap_s2_b);
16951 local_free (bitmap_s2_c);
16952 local_free (bitmap_s2_d);
16953
16954 #ifdef HAVE_HWMON
16955 local_free (temp_retain_fanspeed_value);
16956 #ifdef HAVE_ADL
16957 local_free (od_clock_mem_status);
16958 local_free (od_power_control_status);
16959 #endif // ADL
16960 #endif
16961
16962 global_free (devices_param);
16963
16964 global_free (kernel_rules_buf);
16965
16966 global_free (root_css_buf);
16967 global_free (markov_css_buf);
16968
16969 global_free (digests_buf);
16970 global_free (digests_shown);
16971 global_free (digests_shown_tmp);
16972
16973 global_free (salts_buf);
16974 global_free (salts_shown);
16975
16976 global_free (esalts_buf);
16977
16978 global_free (words_progress_done);
16979 global_free (words_progress_rejected);
16980 global_free (words_progress_restored);
16981
16982 if (pot_fp) fclose (pot_fp);
16983
16984 if (data.devices_status == STATUS_QUIT) break;
16985 }
16986
16987 // destroy others mutex
16988
16989 hc_thread_mutex_delete (mux_dispatcher);
16990 hc_thread_mutex_delete (mux_counter);
16991 hc_thread_mutex_delete (mux_display);
16992 hc_thread_mutex_delete (mux_adl);
16993
16994 // free memory
16995
16996 local_free (eff_restore_file);
16997 local_free (new_restore_file);
16998
16999 local_free (rd);
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