projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #204 from gm4tr1x/LoopAccelMod
[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 #ifndef OSX
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
395 #else
396 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
397 #endif
398 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
399 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
400 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
401 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
402 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
403 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
404 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 #ifdef HAVE_HWMON
407 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
408 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
409 #ifdef HAVE_ADL
410 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
411 #endif
412 #endif
413 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
414 "",
415 "* Distributed:",
416 "",
417 " -s, --skip=NUM Skip number of words",
418 " -l, --limit=NUM Limit number of words",
419 " --keyspace Show keyspace base:mod values and quit",
420 "",
421 "* Rules:",
422 "",
423 " -j, --rule-left=RULE Single rule applied to each word from left dict",
424 " -k, --rule-right=RULE Single rule applied to each word from right dict",
425 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
426 " -g, --generate-rules=NUM Generate NUM random rules",
427 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
428 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
429 " --generate-rules-seed=NUM Force RNG seed to NUM",
430 "",
431 "* Custom charsets:",
432 "",
433 " -1, --custom-charset1=CS User-defined charsets",
434 " -2, --custom-charset2=CS Example:",
435 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
436 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
437 "",
438 "* Increment:",
439 "",
440 " -i, --increment Enable increment mode",
441 " --increment-min=NUM Start incrementing at NUM",
442 " --increment-max=NUM Stop incrementing at NUM",
443 "",
444 "==========",
445 "References",
446 "==========",
447 "",
448 "* Workload Profile:",
449 "",
450 " 1 = Reduced performance profile (low latency desktop)",
451 " 2 = Default performance profile",
452 " 3 = Tuned performance profile (high latency desktop)",
453 "",
454 "* Benchmark Settings:",
455 "",
456 " 0 = Manual Tuning",
457 " 1 = Performance Tuning, default",
458 "",
459 "* OpenCL device-types:",
460 "",
461 " 1 = CPU devices",
462 " 2 = GPU devices",
463 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
464 "",
465 "* Outfile Formats:",
466 "",
467 " 1 = hash[:salt]",
468 " 2 = plain",
469 " 3 = hash[:salt]:plain",
470 " 4 = hex_plain",
471 " 5 = hash[:salt]:hex_plain",
472 " 6 = plain:hex_plain",
473 " 7 = hash[:salt]:plain:hex_plain",
474 " 8 = crackpos",
475 " 9 = hash[:salt]:crackpos",
476 " 10 = plain:crackpos",
477 " 11 = hash[:salt]:plain:crackpos",
478 " 12 = hex_plain:crackpos",
479 " 13 = hash[:salt]:hex_plain:crackpos",
480 " 14 = plain:hex_plain:crackpos",
481 " 15 = hash[:salt]:plain:hex_plain:crackpos",
482 "",
483 "* Debug mode output formats (for hybrid mode only, by using rules):",
484 "",
485 " 1 = save finding rule",
486 " 2 = save original word",
487 " 3 = save original word and finding rule",
488 " 4 = save original word, finding rule and modified plain",
489 "",
490 "* Built-in charsets:",
491 "",
492 " ?l = abcdefghijklmnopqrstuvwxyz",
493 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
494 " ?d = 0123456789",
495 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
496 " ?a = ?l?u?d?s",
497 " ?b = 0x00 - 0xff",
498 "",
499 "* Attack modes:",
500 "",
501 " 0 = Straight",
502 " 1 = Combination",
503 " 3 = Brute-force",
504 " 6 = Hybrid dict + mask",
505 " 7 = Hybrid mask + dict",
506 "",
507 "* Hash types:",
508 "",
509 "[[ Roll-your-own: Raw Hashes ]]",
510 "",
511 " 900 = MD4",
512 " 0 = MD5",
513 " 5100 = Half MD5",
514 " 100 = SHA1",
515 " 10800 = SHA-384",
516 " 1400 = SHA-256",
517 " 1700 = SHA-512",
518 " 5000 = SHA-3(Keccak)",
519 " 10100 = SipHash",
520 " 6000 = RipeMD160",
521 " 6100 = Whirlpool",
522 " 6900 = GOST R 34.11-94",
523 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
524 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
525 "",
526 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
527 "",
528 " 10 = md5($pass.$salt)",
529 " 20 = md5($salt.$pass)",
530 " 30 = md5(unicode($pass).$salt)",
531 " 40 = md5($salt.unicode($pass))",
532 " 3800 = md5($salt.$pass.$salt)",
533 " 3710 = md5($salt.md5($pass))",
534 " 2600 = md5(md5($pass)",
535 " 4300 = md5(strtoupper(md5($pass)))",
536 " 4400 = md5(sha1($pass))",
537 " 110 = sha1($pass.$salt)",
538 " 120 = sha1($salt.$pass)",
539 " 130 = sha1(unicode($pass).$salt)",
540 " 140 = sha1($salt.unicode($pass))",
541 " 4500 = sha1(sha1($pass)",
542 " 4700 = sha1(md5($pass))",
543 " 4900 = sha1($salt.$pass.$salt)",
544 " 1410 = sha256($pass.$salt)",
545 " 1420 = sha256($salt.$pass)",
546 " 1430 = sha256(unicode($pass).$salt)",
547 " 1440 = sha256($salt.unicode($pass))",
548 " 1710 = sha512($pass.$salt)",
549 " 1720 = sha512($salt.$pass)",
550 " 1730 = sha512(unicode($pass).$salt)",
551 " 1740 = sha512($salt.unicode($pass))",
552 "",
553 "[[ Roll-your-own: Authenticated Hashes ]]",
554 "",
555 " 50 = HMAC-MD5 (key = $pass)",
556 " 60 = HMAC-MD5 (key = $salt)",
557 " 150 = HMAC-SHA1 (key = $pass)",
558 " 160 = HMAC-SHA1 (key = $salt)",
559 " 1450 = HMAC-SHA256 (key = $pass)",
560 " 1460 = HMAC-SHA256 (key = $salt)",
561 " 1750 = HMAC-SHA512 (key = $pass)",
562 " 1760 = HMAC-SHA512 (key = $salt)",
563 "",
564 "[[ Generic KDF ]]",
565 "",
566 " 400 = phpass",
567 " 8900 = scrypt",
568 " 11900 = PBKDF2-HMAC-MD5",
569 " 12000 = PBKDF2-HMAC-SHA1",
570 " 10900 = PBKDF2-HMAC-SHA256",
571 " 12100 = PBKDF2-HMAC-SHA512",
572 "",
573 "[[ Network protocols, Challenge-Response ]]",
574 "",
575 " 23 = Skype",
576 " 2500 = WPA/WPA2",
577 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
578 " 5300 = IKE-PSK MD5",
579 " 5400 = IKE-PSK SHA1",
580 " 5500 = NetNTLMv1",
581 " 5500 = NetNTLMv1 + ESS",
582 " 5600 = NetNTLMv2",
583 " 7300 = IPMI2 RAKP HMAC-SHA1",
584 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
585 " 8300 = DNSSEC (NSEC3)",
586 " 10200 = Cram MD5",
587 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
588 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
589 " 11400 = SIP digest authentication (MD5)",
590 "",
591 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
592 "",
593 " 121 = SMF (Simple Machines Forum)",
594 " 400 = phpBB3",
595 " 2611 = vBulletin < v3.8.5",
596 " 2711 = vBulletin > v3.8.5",
597 " 2811 = MyBB",
598 " 2811 = IPB (Invison Power Board)",
599 " 8400 = WBB3 (Woltlab Burning Board)",
600 " 11 = Joomla < 2.5.18",
601 " 400 = Joomla > 2.5.18",
602 " 400 = Wordpress",
603 " 2612 = PHPS",
604 " 7900 = Drupal7",
605 " 21 = osCommerce",
606 " 21 = xt:Commerce",
607 " 11000 = PrestaShop",
608 " 124 = Django (SHA-1)",
609 " 10000 = Django (PBKDF2-SHA256)",
610 " 3711 = Mediawiki B type",
611 " 7600 = Redmine",
612 "",
613 "[[ Database Server ]]",
614 "",
615 " 12 = PostgreSQL",
616 " 131 = MSSQL(2000)",
617 " 132 = MSSQL(2005)",
618 " 1731 = MSSQL(2012)",
619 " 1731 = MSSQL(2014)",
620 " 200 = MySQL323",
621 " 300 = MySQL4.1/MySQL5",
622 " 3100 = Oracle H: Type (Oracle 7+)",
623 " 112 = Oracle S: Type (Oracle 11+)",
624 " 12300 = Oracle T: Type (Oracle 12+)",
625 " 8000 = Sybase ASE",
626 "",
627 "[[ HTTP, SMTP, LDAP Server ]]",
628 "",
629 " 141 = EPiServer 6.x < v4",
630 " 1441 = EPiServer 6.x > v4",
631 " 1600 = Apache $apr1$",
632 " 12600 = ColdFusion 10+",
633 " 1421 = hMailServer",
634 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
635 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
636 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
637 "",
638 "[[ Checksums ]]",
639 "",
640 " 11500 = CRC32",
641 "",
642 "[[ Operating-Systems ]]",
643 "",
644 " 3000 = LM",
645 " 1000 = NTLM",
646 " 1100 = Domain Cached Credentials (DCC), MS Cache",
647 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
648 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
649 " 1500 = descrypt, DES(Unix), Traditional DES",
650 " 12400 = BSDiCrypt, Extended DES",
651 " 500 = md5crypt $1$, MD5(Unix)",
652 " 3200 = bcrypt $2*$, Blowfish(Unix)",
653 " 7400 = sha256crypt $5$, SHA256(Unix)",
654 " 1800 = sha512crypt $6$, SHA512(Unix)",
655 " 122 = OSX v10.4",
656 " 122 = OSX v10.5",
657 " 122 = OSX v10.6",
658 " 1722 = OSX v10.7",
659 " 7100 = OSX v10.8",
660 " 7100 = OSX v10.9",
661 " 7100 = OSX v10.10",
662 " 6300 = AIX {smd5}",
663 " 6700 = AIX {ssha1}",
664 " 6400 = AIX {ssha256}",
665 " 6500 = AIX {ssha512}",
666 " 2400 = Cisco-PIX",
667 " 2410 = Cisco-ASA",
668 " 500 = Cisco-IOS $1$",
669 " 5700 = Cisco-IOS $4$",
670 " 9200 = Cisco-IOS $8$",
671 " 9300 = Cisco-IOS $9$",
672 " 22 = Juniper Netscreen/SSG (ScreenOS)",
673 " 501 = Juniper IVE",
674 " 5800 = Android PIN",
675 " 8100 = Citrix Netscaler",
676 " 8500 = RACF",
677 " 7200 = GRUB 2",
678 " 9900 = Radmin2",
679 "",
680 "[[ Enterprise Application Software (EAS) ]]",
681 "",
682 " 7700 = SAP CODVN B (BCODE)",
683 " 7800 = SAP CODVN F/G (PASSCODE)",
684 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
685 " 8600 = Lotus Notes/Domino 5",
686 " 8700 = Lotus Notes/Domino 6",
687 " 9100 = Lotus Notes/Domino 8",
688 " 133 = PeopleSoft",
689 "",
690 "[[ Archives ]]",
691 "",
692 " 11600 = 7-Zip",
693 " 12500 = RAR3-hp",
694 " 13000 = RAR5",
695 "",
696 "[[ Full-Disk encryptions (FDE) ]]",
697 "",
698 " 62XY = TrueCrypt 5.0+",
699 " X = 1 = PBKDF2-HMAC-RipeMD160",
700 " X = 2 = PBKDF2-HMAC-SHA512",
701 " X = 3 = PBKDF2-HMAC-Whirlpool",
702 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
703 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
704 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
705 " Y = 3 = XTS 1536 bit (Ciphers: All)",
706 " 8800 = Android FDE < v4.3",
707 " 12900 = Android FDE (Samsung DEK)",
708 " 12200 = eCryptfs",
709 "",
710 "[[ Documents ]]",
711 "",
712 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
713 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
714 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
715 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
716 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
717 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
718 " 9400 = MS Office 2007",
719 " 9500 = MS Office 2010",
720 " 9600 = MS Office 2013",
721 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
722 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
723 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
724 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
725 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
726 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
727 "",
728 "[[ Password Managers ]]",
729 "",
730 " 9000 = Password Safe v2",
731 " 5200 = Password Safe v3",
732 " 6800 = Lastpass",
733 " 6600 = 1Password, agilekeychain",
734 " 8200 = 1Password, cloudkeychain",
735 " 11300 = Bitcoin/Litecoin wallet.dat",
736 " 12700 = Blockchain, My Wallet",
737 "",
738 NULL
739 };
740
741 /**
742 * oclHashcat specific functions
743 */
744
745 void status_display_automat ()
746 {
747 FILE *out = stdout;
748
749 fprintf (out, "STATUS\t%u\t", data.devices_status);
750
751 /**
752 * speed new
753 */
754
755 fprintf (out, "SPEED\t");
756
757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
758 {
759 hc_device_param_t *device_param = &data.devices_param[device_id];
760
761 if (device_param->skipped) continue;
762
763 u64 speed_cnt = 0;
764 float speed_ms = 0;
765
766 for (int i = 0; i < SPEED_CACHE; i++)
767 {
768 float rec_ms;
769
770 hc_timer_get (device_param->speed_rec[i], rec_ms);
771
772 if (rec_ms > SPEED_MAXAGE) continue;
773
774 speed_cnt += device_param->speed_cnt[i];
775 speed_ms += device_param->speed_ms[i];
776 }
777
778 speed_cnt /= SPEED_CACHE;
779 speed_ms /= SPEED_CACHE;
780
781 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
782 }
783
784 /**
785 * words_cur
786 */
787
788 u64 words_cur = get_lowest_words_done ();
789
790 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
791
792 /**
793 * counter
794 */
795
796 uint salts_left = data.salts_cnt - data.salts_done;
797
798 if (salts_left == 0) salts_left = 1;
799
800 u64 progress_total = data.words_cnt * salts_left;
801
802 u64 all_done = 0;
803 u64 all_rejected = 0;
804 u64 all_restored = 0;
805
806 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
807 {
808 if (salts_left > 1)
809 {
810 // otherwise the final cracked status shows 0/XXX progress
811
812 if (data.salts_shown[salt_pos] == 1) continue;
813 }
814
815 all_done += data.words_progress_done[salt_pos];
816 all_rejected += data.words_progress_rejected[salt_pos];
817 all_restored += data.words_progress_restored[salt_pos];
818 }
819
820 u64 progress_cur = all_restored + all_done + all_rejected;
821 u64 progress_end = progress_total;
822
823 u64 progress_skip = 0;
824
825 if (data.skip)
826 {
827 progress_skip = MIN (data.skip, data.words_base) * salts_left;
828
829 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
830 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
831 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
832 }
833
834 if (data.limit)
835 {
836 progress_end = MIN (data.limit, data.words_base) * salts_left;
837
838 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
839 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
840 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
841 }
842
843 u64 progress_cur_relative_skip = progress_cur - progress_skip;
844 u64 progress_end_relative_skip = progress_end - progress_skip;
845
846 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
847
848 /**
849 * cracks
850 */
851
852 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
853 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
854
855 /**
856 * temperature
857 */
858
859 #ifdef HAVE_HWMON
860 if (data.gpu_temp_disable == 0)
861 {
862 fprintf (out, "TEMP\t");
863
864 hc_thread_mutex_lock (mux_adl);
865
866 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
867 {
868 hc_device_param_t *device_param = &data.devices_param[device_id];
869
870 if (device_param->skipped) continue;
871
872 int temp = hm_get_temperature_with_device_id (device_id);
873
874 fprintf (out, "%d\t", temp);
875 }
876
877 hc_thread_mutex_unlock (mux_adl);
878 }
879 #endif // HAVE_HWMON
880
881 #ifdef _WIN
882 fputc ('\r', out);
883 fputc ('\n', out);
884 #endif
885
886 #ifdef _POSIX
887 fputc ('\n', out);
888 #endif
889
890 fflush (out);
891 }
892
893 void status_display ()
894 {
895 if (data.devices_status == STATUS_INIT) return;
896 if (data.devices_status == STATUS_STARTING) return;
897 if (data.devices_status == STATUS_BYPASS) return;
898
899 if (data.status_automat == 1)
900 {
901 status_display_automat ();
902
903 return;
904 }
905
906 char tmp_buf[1000] = { 0 };
907
908 uint tmp_len = 0;
909
910 log_info ("Session.Name...: %s", data.session);
911
912 char *status_type = strstatus (data.devices_status);
913
914 uint hash_mode = data.hash_mode;
915
916 char *hash_type = strhashtype (hash_mode); // not a bug
917
918 log_info ("Status.........: %s", status_type);
919
920 /**
921 * show rules
922 */
923
924 if (data.rp_files_cnt)
925 {
926 uint i;
927
928 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
929 {
930 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
931 }
932
933 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
934
935 log_info ("Rules.Type.....: %s", tmp_buf);
936
937 tmp_len = 0;
938 }
939
940 if (data.rp_gen)
941 {
942 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
943
944 if (data.rp_gen_seed)
945 {
946 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
947 }
948 }
949
950 /**
951 * show input
952 */
953
954 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
955 {
956 if (data.wordlist_mode == WL_MODE_FILE)
957 {
958 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
959 }
960 else if (data.wordlist_mode == WL_MODE_STDIN)
961 {
962 log_info ("Input.Mode.....: Pipe");
963 }
964 }
965 else if (data.attack_mode == ATTACK_MODE_COMBI)
966 {
967 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
968 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
969 }
970 else if (data.attack_mode == ATTACK_MODE_BF)
971 {
972 char *mask = data.mask;
973
974 if (mask != NULL)
975 {
976 uint mask_len = data.css_cnt;
977
978 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
979
980 if (mask_len > 0)
981 {
982 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
983 {
984 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
985 {
986 mask_len -= data.salts_buf[0].salt_len;
987 }
988 }
989
990 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
991
992 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
993 }
994
995 if (data.maskcnt > 1)
996 {
997 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
998
999 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1000 }
1001
1002 log_info ("Input.Mode.....: %s", tmp_buf);
1003 }
1004
1005 tmp_len = 0;
1006 }
1007 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1008 {
1009 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1010 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 }
1012 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1013 {
1014 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1015 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1016 }
1017
1018 if (data.digests_cnt == 1)
1019 {
1020 if (data.hash_mode == 2500)
1021 {
1022 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1023
1024 uint pke[25] = { 0 };
1025
1026 char *pke_ptr = (char *) pke;
1027
1028 for (uint i = 0; i < 25; i++)
1029 {
1030 pke[i] = byte_swap_32 (wpa->pke[i]);
1031 }
1032
1033 char mac1[6] = { 0 };
1034 char mac2[6] = { 0 };
1035
1036 memcpy (mac1, pke_ptr + 23, 6);
1037 memcpy (mac2, pke_ptr + 29, 6);
1038
1039 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1040 (char *) data.salts_buf[0].salt_buf,
1041 mac1[0] & 0xff,
1042 mac1[1] & 0xff,
1043 mac1[2] & 0xff,
1044 mac1[3] & 0xff,
1045 mac1[4] & 0xff,
1046 mac1[5] & 0xff,
1047 mac2[0] & 0xff,
1048 mac2[1] & 0xff,
1049 mac2[2] & 0xff,
1050 mac2[3] & 0xff,
1051 mac2[4] & 0xff,
1052 mac2[5] & 0xff);
1053 }
1054 else if (data.hash_mode == 5200)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if (data.hash_mode == 9000)
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else
1067 {
1068 char out_buf[4096] = { 0 };
1069
1070 ascii_digest (out_buf, 0, 0);
1071
1072 // limit length
1073 if (strlen (out_buf) > 40)
1074 {
1075 out_buf[41] = '.';
1076 out_buf[42] = '.';
1077 out_buf[43] = '.';
1078 out_buf[44] = 0;
1079 }
1080
1081 log_info ("Hash.Target....: %s", out_buf);
1082 }
1083 }
1084 else
1085 {
1086 if (data.hash_mode == 3000)
1087 {
1088 char out_buf1[4096] = { 0 };
1089 char out_buf2[4096] = { 0 };
1090
1091 ascii_digest (out_buf1, 0, 0);
1092 ascii_digest (out_buf2, 0, 1);
1093
1094 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1095 }
1096 else
1097 {
1098 log_info ("Hash.Target....: File (%s)", data.hashfile);
1099 }
1100 }
1101
1102 log_info ("Hash.Type......: %s", hash_type);
1103
1104 /**
1105 * speed new
1106 */
1107
1108 u64 speed_cnt[DEVICES_MAX] = { 0 };
1109 float speed_ms[DEVICES_MAX] = { 0 };
1110
1111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1112 {
1113 hc_device_param_t *device_param = &data.devices_param[device_id];
1114
1115 if (device_param->skipped) continue;
1116
1117 // we need to clear values (set to 0) because in case the device does
1118 // not get new candidates it idles around but speed display would
1119 // show it as working.
1120 // if we instantly set it to 0 after reading it happens that the
1121 // speed can be shown as zero if the users refreshes too fast.
1122 // therefore, we add a timestamp when a stat was recorded and if its
1123 // too old we will not use it
1124
1125 speed_cnt[device_id] = 0;
1126 speed_ms[device_id] = 0;
1127
1128 for (int i = 0; i < SPEED_CACHE; i++)
1129 {
1130 float rec_ms;
1131
1132 hc_timer_get (device_param->speed_rec[i], rec_ms);
1133
1134 if (rec_ms > SPEED_MAXAGE) continue;
1135
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 float hashes_all_ms = 0;
1145
1146 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * timers
1166 */
1167
1168 float ms_running = 0;
1169
1170 hc_timer_get (data.timer_running, ms_running);
1171
1172 float ms_paused = data.ms_paused;
1173
1174 if (data.devices_status == STATUS_PAUSED)
1175 {
1176 float ms_paused_tmp = 0;
1177
1178 hc_timer_get (data.timer_paused, ms_paused_tmp);
1179
1180 ms_paused += ms_paused_tmp;
1181 }
1182
1183 #ifdef WIN
1184
1185 __time64_t sec_run = ms_running / 1000;
1186
1187 #else
1188
1189 time_t sec_run = ms_running / 1000;
1190
1191 #endif
1192
1193 if (sec_run)
1194 {
1195 char display_run[32] = { 0 };
1196
1197 struct tm tm_run;
1198
1199 struct tm *tmp = NULL;
1200
1201 #ifdef WIN
1202
1203 tmp = _gmtime64 (&sec_run);
1204
1205 #else
1206
1207 tmp = gmtime (&sec_run);
1208
1209 #endif
1210
1211 if (tmp != NULL)
1212 {
1213 memset (&tm_run, 0, sizeof (tm_run));
1214
1215 memcpy (&tm_run, tmp, sizeof (tm_run));
1216
1217 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1218
1219 char *start = ctime (&data.proc_start);
1220
1221 size_t start_len = strlen (start);
1222
1223 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1224 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1225
1226 log_info ("Time.Started...: %s (%s)", start, display_run);
1227 }
1228 }
1229 else
1230 {
1231 log_info ("Time.Started...: 0 secs");
1232 }
1233
1234 /**
1235 * counters
1236 */
1237
1238 uint salts_left = data.salts_cnt - data.salts_done;
1239
1240 if (salts_left == 0) salts_left = 1;
1241
1242 u64 progress_total = data.words_cnt * salts_left;
1243
1244 u64 all_done = 0;
1245 u64 all_rejected = 0;
1246 u64 all_restored = 0;
1247
1248 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1249 {
1250 if (salts_left > 1)
1251 {
1252 // otherwise the final cracked status shows 0/XXX progress
1253
1254 if (data.salts_shown[salt_pos] == 1) continue;
1255 }
1256
1257 all_done += data.words_progress_done[salt_pos];
1258 all_rejected += data.words_progress_rejected[salt_pos];
1259 all_restored += data.words_progress_restored[salt_pos];
1260 }
1261
1262 u64 progress_cur = all_restored + all_done + all_rejected;
1263 u64 progress_end = progress_total;
1264
1265 u64 progress_skip = 0;
1266
1267 if (data.skip)
1268 {
1269 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1270
1271 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1272 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1273 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1274 }
1275
1276 if (data.limit)
1277 {
1278 progress_end = MIN (data.limit, data.words_base) * salts_left;
1279
1280 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1281 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1282 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1283 }
1284
1285 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1286 u64 progress_end_relative_skip = progress_end - progress_skip;
1287
1288 float speed_ms_real = ms_running - ms_paused;
1289 u64 speed_plains_real = all_done;
1290
1291 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1292 {
1293 if (data.devices_status != STATUS_CRACKED)
1294 {
1295 u64 words_per_ms = 0;
1296
1297 if (speed_plains_real && speed_ms_real)
1298 {
1299 words_per_ms = speed_plains_real / speed_ms_real;
1300 }
1301
1302 #ifdef WIN
1303 __time64_t sec_etc = 0;
1304 #else
1305 time_t sec_etc = 0;
1306 #endif
1307
1308 if (words_per_ms)
1309 {
1310 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1311
1312 u64 ms_left = progress_left_relative_skip / words_per_ms;
1313
1314 sec_etc = ms_left / 1000;
1315 }
1316
1317 if (sec_etc == 0)
1318 {
1319 log_info ("Time.Estimated.: 0 secs");
1320 }
1321 else if ((u64) sec_etc > ETC_MAX)
1322 {
1323 log_info ("Time.Estimated.: > 10 Years");
1324 }
1325 else
1326 {
1327 char display_etc[32] = { 0 };
1328
1329 struct tm tm_etc;
1330
1331 struct tm *tmp = NULL;
1332
1333 #ifdef WIN
1334
1335 tmp = _gmtime64 (&sec_etc);
1336
1337 #else
1338
1339 tmp = gmtime (&sec_etc);
1340
1341 #endif
1342
1343 if (tmp != NULL)
1344 {
1345 memset (&tm_etc, 0, sizeof (tm_etc));
1346
1347 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1348
1349 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1350
1351 time_t now;
1352
1353 time (&now);
1354
1355 now += sec_etc;
1356
1357 char *etc = ctime (&now);
1358
1359 size_t etc_len = strlen (etc);
1360
1361 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1362 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1363
1364 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1365 }
1366 }
1367 }
1368 }
1369
1370 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1371 {
1372 hc_device_param_t *device_param = &data.devices_param[device_id];
1373
1374 if (device_param->skipped) continue;
1375
1376 char display_dev_cur[16] = { 0 };
1377
1378 strncpy (display_dev_cur, "0.00", 4);
1379
1380 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1381
1382 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1383 }
1384
1385 char display_all_cur[16] = { 0 };
1386
1387 strncpy (display_all_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1390
1391 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1392
1393 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1394 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1395
1396 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);
1397
1398 // crack-per-time
1399
1400 if (data.digests_cnt > 100)
1401 {
1402 time_t now = time (NULL);
1403
1404 int cpt_cur_min = 0;
1405 int cpt_cur_hour = 0;
1406 int cpt_cur_day = 0;
1407
1408 for (int i = 0; i < CPT_BUF; i++)
1409 {
1410 const uint cracked = data.cpt_buf[i].cracked;
1411 const time_t timestamp = data.cpt_buf[i].timestamp;
1412
1413 if ((timestamp + 60) > now)
1414 {
1415 cpt_cur_min += cracked;
1416 }
1417
1418 if ((timestamp + 3600) > now)
1419 {
1420 cpt_cur_hour += cracked;
1421 }
1422
1423 if ((timestamp + 86400) > now)
1424 {
1425 cpt_cur_day += cracked;
1426 }
1427 }
1428
1429 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1430 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1431 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1432
1433 if ((data.cpt_start + 86400) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_cur_hour,
1438 cpt_cur_day,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else if ((data.cpt_start + 3600) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_avg_min,
1449 cpt_avg_hour,
1450 cpt_avg_day);
1451 }
1452 else if ((data.cpt_start + 60) < now)
1453 {
1454 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1455 cpt_cur_min,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else
1461 {
1462 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 }
1468
1469 // Restore point
1470
1471 u64 restore_point = get_lowest_words_done ();
1472
1473 u64 restore_total = data.words_base;
1474
1475 float percent_restore = 0;
1476
1477 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1478
1479 if (progress_end_relative_skip)
1480 {
1481 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1482 {
1483 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1484 float percent_rejected = 0.0;
1485
1486 if (progress_cur)
1487 {
1488 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1489 }
1490
1491 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);
1492 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1493
1494 if (data.restore_disable == 0)
1495 {
1496 if (percent_finished != 1)
1497 {
1498 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1499 }
1500 }
1501 }
1502 }
1503 else
1504 {
1505 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1506 {
1507 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509
1510 if (data.restore_disable == 0)
1511 {
1512 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513 }
1514 }
1515 else
1516 {
1517 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1518 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1519
1520 // --restore not allowed if stdin is used -- really? why?
1521
1522 //if (data.restore_disable == 0)
1523 //{
1524 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1525 //}
1526 }
1527 }
1528
1529 #ifdef HAVE_HWMON
1530 if (data.gpu_temp_disable == 0)
1531 {
1532 hc_thread_mutex_lock (mux_adl);
1533
1534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1535 {
1536 hc_device_param_t *device_param = &data.devices_param[device_id];
1537
1538 if (device_param->skipped) continue;
1539
1540 #define HM_STR_BUF_SIZE 255
1541
1542 if (data.hm_device[device_id].fan_supported == 1)
1543 {
1544 char utilization[HM_STR_BUF_SIZE] = { 0 };
1545 char temperature[HM_STR_BUF_SIZE] = { 0 };
1546 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1547
1548 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1549 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1550
1551 if (device_param->vendor_id == VENDOR_ID_AMD)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555 else if (device_param->vendor_id == VENDOR_ID_NV)
1556 {
1557 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1558 }
1559
1560 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1561 }
1562 else
1563 {
1564 char utilization[HM_STR_BUF_SIZE] = { 0 };
1565 char temperature[HM_STR_BUF_SIZE] = { 0 };
1566
1567 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1568 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1569
1570 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1571 }
1572 }
1573
1574 hc_thread_mutex_unlock (mux_adl);
1575 }
1576 #endif // HAVE_HWMON
1577 }
1578
1579 static void status_benchmark ()
1580 {
1581 if (data.devices_status == STATUS_INIT) return;
1582 if (data.devices_status == STATUS_STARTING) return;
1583
1584 if (data.words_cnt == 0) return;
1585
1586 u64 speed_cnt[DEVICES_MAX] = { 0 };
1587 float speed_ms[DEVICES_MAX] = { 0 };
1588
1589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1590 {
1591 hc_device_param_t *device_param = &data.devices_param[device_id];
1592
1593 if (device_param->skipped) continue;
1594
1595 speed_cnt[device_id] = 0;
1596 speed_ms[device_id] = 0;
1597
1598 for (int i = 0; i < SPEED_CACHE; i++)
1599 {
1600 speed_cnt[device_id] += device_param->speed_cnt[i];
1601 speed_ms[device_id] += device_param->speed_ms[i];
1602 }
1603
1604 speed_cnt[device_id] /= SPEED_CACHE;
1605 speed_ms[device_id] /= SPEED_CACHE;
1606 }
1607
1608 float hashes_all_ms = 0;
1609
1610 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1611
1612 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1613 {
1614 hc_device_param_t *device_param = &data.devices_param[device_id];
1615
1616 if (device_param->skipped) continue;
1617
1618 hashes_dev_ms[device_id] = 0;
1619
1620 if (speed_ms[device_id])
1621 {
1622 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1623
1624 hashes_all_ms += hashes_dev_ms[device_id];
1625 }
1626 }
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 char display_dev_cur[16] = { 0 };
1635
1636 strncpy (display_dev_cur, "0.00", 4);
1637
1638 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1639
1640 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1641 }
1642
1643 char display_all_cur[16] = { 0 };
1644
1645 strncpy (display_all_cur, "0.00", 4);
1646
1647 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1648
1649 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1650 }
1651
1652 /**
1653 * oclHashcat -only- functions
1654 */
1655
1656 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1657 {
1658 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1659 {
1660 if (attack_kern == ATTACK_KERN_STRAIGHT)
1661 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1662 else if (attack_kern == ATTACK_KERN_COMBI)
1663 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1664 else if (attack_kern == ATTACK_KERN_BF)
1665 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1666 }
1667 else
1668 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1669 }
1670
1671 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)
1672 {
1673 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1674 {
1675 if (attack_kern == ATTACK_KERN_STRAIGHT)
1676 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1677 else if (attack_kern == ATTACK_KERN_COMBI)
1678 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1679 else if (attack_kern == ATTACK_KERN_BF)
1680 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 }
1682 else
1683 {
1684 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1685 }
1686 }
1687
1688 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1689 {
1690 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1691 {
1692 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1693 }
1694 else
1695 {
1696 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1697 }
1698 }
1699
1700 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)
1701 {
1702 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1703 {
1704 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1705 }
1706 else
1707 {
1708 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1709 }
1710 }
1711
1712 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1713 {
1714 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1715 }
1716
1717 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1718 {
1719 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1720 }
1721
1722 static uint convert_from_hex (char *line_buf, const uint line_len)
1723 {
1724 if (line_len & 1) return (line_len); // not in hex
1725
1726 if (data.hex_wordlist == 1)
1727 {
1728 uint i;
1729 uint j;
1730
1731 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1732 {
1733 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1734 }
1735
1736 memset (line_buf + i, 0, line_len - i);
1737
1738 return (i);
1739 }
1740 else if (line_len >= 6) // $HEX[] = 6
1741 {
1742 if (line_buf[0] != '$') return (line_len);
1743 if (line_buf[1] != 'H') return (line_len);
1744 if (line_buf[2] != 'E') return (line_len);
1745 if (line_buf[3] != 'X') return (line_len);
1746 if (line_buf[4] != '[') return (line_len);
1747 if (line_buf[line_len - 1] != ']') return (line_len);
1748
1749 uint i;
1750 uint j;
1751
1752 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1753 {
1754 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1755 }
1756
1757 memset (line_buf + i, 0, line_len - i);
1758
1759 return (i);
1760 }
1761
1762 return (line_len);
1763 }
1764
1765 static uint count_lines (FILE *fd)
1766 {
1767 uint cnt = 0;
1768
1769 char *buf = (char *) mymalloc (BUFSIZ + 1);
1770
1771 size_t nread_tmp = 0;
1772
1773 char *ptr = buf;
1774
1775 while (!feof (fd))
1776 {
1777 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1778 nread_tmp = nread;
1779
1780 if (nread < 1) continue;
1781
1782 ptr = buf;
1783
1784 do
1785 {
1786 if (*ptr++ == '\n') cnt++;
1787
1788 } while (nread--);
1789 }
1790
1791 // special case (if last line did not contain a newline char ... at the very end of the file)
1792
1793 if (nread_tmp > 3)
1794 {
1795 ptr -= 2;
1796
1797 if (*ptr != '\n')
1798 {
1799 ptr--;
1800
1801 if (*ptr != '\n') // needed ? different on windows systems?
1802 {
1803 cnt++;
1804 }
1805 }
1806 }
1807
1808 myfree (buf);
1809
1810 return cnt;
1811 }
1812
1813 static void clear_prompt ()
1814 {
1815 fputc ('\r', stdout);
1816
1817 for (size_t i = 0; i < strlen (PROMPT); i++)
1818 {
1819 fputc (' ', stdout);
1820 }
1821
1822 fputc ('\r', stdout);
1823
1824 fflush (stdout);
1825 }
1826
1827 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1828 {
1829 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);
1830 }
1831
1832 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1833 {
1834 char *outfile = data.outfile;
1835 uint quiet = data.quiet;
1836 FILE *pot_fp = data.pot_fp;
1837 uint loopback = data.loopback;
1838 uint debug_mode = data.debug_mode;
1839 char *debug_file = data.debug_file;
1840
1841 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1842 int debug_rule_len = 0; // -1 error
1843 uint debug_plain_len = 0;
1844
1845 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1846
1847 // hash
1848
1849 char out_buf[4096] = { 0 };
1850
1851 ascii_digest (out_buf, salt_pos, digest_pos);
1852
1853 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1854
1855 // plain
1856
1857 plain_t plain;
1858
1859 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);
1860
1861 uint gidvid = plain.gidvid;
1862 uint il_pos = plain.il_pos;
1863
1864 u64 crackpos = device_param->words_off;
1865
1866 uint plain_buf[16] = { 0 };
1867
1868 u8 *plain_ptr = (u8 *) plain_buf;
1869 unsigned int plain_len = 0;
1870
1871 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1872 {
1873 u64 gidd = gidvid;
1874 u64 gidm = 0;
1875
1876 pw_t pw;
1877
1878 gidd_to_pw_t (device_param, gidd, &pw);
1879
1880 for (int i = 0, j = gidm; i < 16; i++, j++)
1881 {
1882 plain_buf[i] = pw.h.hi1[0][j];
1883 }
1884
1885 plain_len = pw.pw_len;
1886
1887 const uint off = device_param->innerloop_pos + il_pos;
1888
1889 if (debug_mode > 0)
1890 {
1891 debug_rule_len = 0;
1892
1893 // save rule
1894 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1897
1898 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1899 }
1900
1901 // save plain
1902 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1903 {
1904 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1905
1906 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1907
1908 debug_plain_len = plain_len;
1909 }
1910 }
1911
1912 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1913
1914 crackpos += gidvid;
1915 crackpos *= data.kernel_rules_cnt;
1916 crackpos += device_param->innerloop_pos + il_pos;
1917
1918 if (plain_len > data.pw_max) plain_len = data.pw_max;
1919 }
1920 else if (data.attack_mode == ATTACK_MODE_COMBI)
1921 {
1922 u64 gidd = gidvid;
1923 u64 gidm = 0;
1924
1925 pw_t pw;
1926
1927 gidd_to_pw_t (device_param, gidd, &pw);
1928
1929 for (int i = 0, j = gidm; i < 16; i++, j++)
1930 {
1931 plain_buf[i] = pw.h.hi1[0][j];
1932 }
1933
1934 plain_len = pw.pw_len;
1935
1936 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1937 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1938
1939 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1940 {
1941 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1942 }
1943 else
1944 {
1945 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1946
1947 memcpy (plain_ptr, comb_buf, comb_len);
1948 }
1949
1950 plain_len += comb_len;
1951
1952 crackpos += gidvid;
1953 crackpos *= data.combs_cnt;
1954 crackpos += device_param->innerloop_pos + il_pos;
1955
1956 if (data.pw_max != PW_DICTMAX1)
1957 {
1958 if (plain_len > data.pw_max) plain_len = data.pw_max;
1959 }
1960 }
1961 else if (data.attack_mode == ATTACK_MODE_BF)
1962 {
1963 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1964 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1965
1966 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1967 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1968
1969 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1970 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1971
1972 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1973 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1974
1975 plain_len = data.css_cnt;
1976
1977 crackpos += gidvid;
1978 crackpos *= data.bfs_cnt;
1979 crackpos += device_param->innerloop_pos + il_pos;
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1982 {
1983 u64 gidd = gidvid;
1984 u64 gidm = 0;
1985
1986 pw_t pw;
1987
1988 gidd_to_pw_t (device_param, gidd, &pw);
1989
1990 for (int i = 0, j = gidm; i < 16; i++, j++)
1991 {
1992 plain_buf[i] = pw.h.hi1[0][j];
1993 }
1994
1995 plain_len = pw.pw_len;
1996
1997 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1998
1999 uint start = 0;
2000 uint stop = device_param->kernel_params_mp_buf32[4];
2001
2002 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2003
2004 plain_len += start + stop;
2005
2006 crackpos += gidvid;
2007 crackpos *= data.combs_cnt;
2008 crackpos += device_param->innerloop_pos + il_pos;
2009
2010 if (data.pw_max != PW_DICTMAX1)
2011 {
2012 if (plain_len > data.pw_max) plain_len = data.pw_max;
2013 }
2014 }
2015 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2016 {
2017 u64 gidd = gidvid;
2018 u64 gidm = 0;
2019
2020 pw_t pw;
2021
2022 gidd_to_pw_t (device_param, gidd, &pw);
2023
2024 for (int i = 0, j = gidm; i < 16; i++, j++)
2025 {
2026 plain_buf[i] = pw.h.hi1[0][j];
2027 }
2028
2029 plain_len = pw.pw_len;
2030
2031 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2032
2033 uint start = 0;
2034 uint stop = device_param->kernel_params_mp_buf32[4];
2035
2036 memmove (plain_ptr + stop, plain_ptr, plain_len);
2037
2038 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051
2052 if (data.attack_mode == ATTACK_MODE_BF)
2053 {
2054 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2055 {
2056 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2057 {
2058 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2059 {
2060 plain_len = plain_len - data.salts_buf[0].salt_len;
2061 }
2062 }
2063
2064 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2065 {
2066 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2067 {
2068 plain_ptr[j] = plain_ptr[i];
2069 }
2070
2071 plain_len = plain_len / 2;
2072 }
2073 }
2074 }
2075
2076 // if enabled, update also the potfile
2077
2078 if (pot_fp)
2079 {
2080 lock_file (pot_fp);
2081
2082 fprintf (pot_fp, "%s:", out_buf);
2083
2084 format_plain (pot_fp, plain_ptr, plain_len, 1);
2085
2086 fputc ('\n', pot_fp);
2087
2088 fflush (pot_fp);
2089
2090 unlock_file (pot_fp);
2091 }
2092
2093 // outfile
2094
2095 FILE *out_fp = NULL;
2096
2097 if (outfile != NULL)
2098 {
2099 if ((out_fp = fopen (outfile, "ab")) == NULL)
2100 {
2101 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2102
2103 out_fp = stdout;
2104 }
2105 lock_file (out_fp);
2106 }
2107 else
2108 {
2109 out_fp = stdout;
2110
2111 if (quiet == 0) clear_prompt ();
2112 }
2113
2114 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2115
2116 if (outfile != NULL)
2117 {
2118 if (out_fp != stdout)
2119 {
2120 fclose (out_fp);
2121 }
2122 }
2123 else
2124 {
2125 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2126 {
2127 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2128 {
2129 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2130 if (quiet == 0) fflush (stdout);
2131 }
2132 }
2133 }
2134
2135 // loopback
2136
2137 if (loopback)
2138 {
2139 char *loopback_file = data.loopback_file;
2140
2141 FILE *fb_fp = NULL;
2142
2143 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2144 {
2145 lock_file (fb_fp);
2146
2147 format_plain (fb_fp, plain_ptr, plain_len, 1);
2148
2149 fputc ('\n', fb_fp);
2150
2151 fclose (fb_fp);
2152 }
2153 }
2154
2155 // (rule) debug mode
2156
2157 // the next check implies that:
2158 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2159 // - debug_mode > 0
2160
2161 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2162 {
2163 if (debug_rule_len < 0) debug_rule_len = 0;
2164
2165 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2166
2167 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2168
2169 if ((quiet == 0) && (debug_file == NULL))
2170 {
2171 fprintf (stdout, "%s", PROMPT);
2172 fflush (stdout);
2173 }
2174 }
2175 }
2176
2177 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2178 {
2179 salt_t *salt_buf = &data.salts_buf[salt_pos];
2180
2181 int found = 0;
2182
2183 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);
2184
2185 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2186
2187 if (found == 1)
2188 {
2189 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2190
2191 log_info_nn ("");
2192
2193 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);
2194
2195 uint cpt_cracked = 0;
2196
2197 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2198 {
2199 uint idx = salt_buf->digests_offset + digest_pos;
2200
2201 if (data.digests_shown_tmp[idx] == 0) continue;
2202
2203 if (data.digests_shown[idx] == 1) continue;
2204
2205 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2206 {
2207 data.digests_shown[idx] = 1;
2208
2209 data.digests_done++;
2210
2211 cpt_cracked++;
2212
2213 salt_buf->digests_done++;
2214
2215 if (salt_buf->digests_done == salt_buf->digests_cnt)
2216 {
2217 data.salts_shown[salt_pos] = 1;
2218
2219 data.salts_done++;
2220 }
2221 }
2222
2223 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2224
2225 check_hash (device_param, salt_pos, digest_pos);
2226 }
2227
2228 if (cpt_cracked > 0)
2229 {
2230 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2231 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2232
2233 data.cpt_pos++;
2234
2235 data.cpt_total += cpt_cracked;
2236
2237 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2238 }
2239
2240 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2241 {
2242 // we need to reset cracked state on the device
2243 // otherwise host thinks again and again the hash was cracked
2244 // and returns invalid password each time
2245
2246 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2247
2248 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);
2249 }
2250
2251 memset (device_param->result, 0, device_param->size_results);
2252
2253 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);
2254 }
2255 }
2256
2257 static void save_hash ()
2258 {
2259 char *hashfile = data.hashfile;
2260
2261 char new_hashfile[256] = { 0 };
2262 char old_hashfile[256] = { 0 };
2263
2264 snprintf (new_hashfile, 255, "%s.new", hashfile);
2265 snprintf (old_hashfile, 255, "%s.old", hashfile);
2266
2267 unlink (new_hashfile);
2268
2269 char separator = data.separator;
2270
2271 FILE *fp = fopen (new_hashfile, "wb");
2272
2273 if (fp == NULL)
2274 {
2275 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2276
2277 exit (-1);
2278 }
2279
2280 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2281 {
2282 if (data.salts_shown[salt_pos] == 1) continue;
2283
2284 salt_t *salt_buf = &data.salts_buf[salt_pos];
2285
2286 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2287 {
2288 uint idx = salt_buf->digests_offset + digest_pos;
2289
2290 if (data.digests_shown[idx] == 1) continue;
2291
2292 if (data.hash_mode != 2500)
2293 {
2294 char out_buf[4096] = { 0 };
2295
2296 if (data.username == 1)
2297 {
2298 user_t *user = data.hash_info[idx]->user;
2299
2300 uint i;
2301
2302 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2303
2304 fputc (separator, fp);
2305 }
2306
2307 ascii_digest (out_buf, salt_pos, digest_pos);
2308
2309 fputs (out_buf, fp);
2310
2311 log_out (fp, "");
2312 }
2313 else
2314 {
2315 hccap_t hccap;
2316
2317 to_hccap_t (&hccap, salt_pos, digest_pos);
2318
2319 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2320 }
2321 }
2322 }
2323
2324 fflush (fp);
2325
2326 fclose (fp);
2327
2328 unlink (old_hashfile);
2329
2330 if (rename (hashfile, old_hashfile) != 0)
2331 {
2332 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2333
2334 exit (-1);
2335 }
2336
2337 unlink (hashfile);
2338
2339 if (rename (new_hashfile, hashfile) != 0)
2340 {
2341 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2342
2343 exit (-1);
2344 }
2345
2346 unlink (old_hashfile);
2347 }
2348
2349 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2350 {
2351 // function called only in case kernel_blocks_all > words_left)
2352
2353 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2354
2355 kernel_blocks_div += kernel_blocks_div / 100;
2356
2357 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2358
2359 while (kernel_blocks_new < total_left)
2360 {
2361 kernel_blocks_div += kernel_blocks_div / 100;
2362
2363 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2364 }
2365
2366 if (data.quiet == 0)
2367 {
2368 clear_prompt ();
2369
2370 log_info ("");
2371
2372 log_info ("INFO: approaching final keyspace, workload adjusted");
2373
2374 log_info ("");
2375
2376 fprintf (stdout, "%s", PROMPT);
2377
2378 fflush (stdout);
2379 }
2380
2381 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2382
2383 return kernel_blocks_div;
2384 }
2385
2386 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2387 {
2388 uint num_elements = num;
2389
2390 device_param->kernel_params_buf32[30] = data.combs_mode;
2391 device_param->kernel_params_buf32[31] = num;
2392
2393 uint kernel_threads = device_param->kernel_threads;
2394
2395 while (num_elements % kernel_threads) num_elements++;
2396
2397 cl_kernel kernel = NULL;
2398
2399 switch (kern_run)
2400 {
2401 case KERN_RUN_1: kernel = device_param->kernel1; break;
2402 case KERN_RUN_12: kernel = device_param->kernel12; break;
2403 case KERN_RUN_2: kernel = device_param->kernel2; break;
2404 case KERN_RUN_23: kernel = device_param->kernel23; break;
2405 case KERN_RUN_3: kernel = device_param->kernel3; break;
2406 }
2407
2408 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2409 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2410 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2411 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2412 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2413 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2414 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2415 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2416 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2417 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2418 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2419
2420 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2421 {
2422 const size_t global_work_size[3] = { num_elements, 32, 1 };
2423 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2424
2425 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2426 }
2427 else
2428 {
2429 const size_t global_work_size[3] = { num_elements, 1, 1 };
2430 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2431
2432 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);
2433
2434 if (rc != CL_SUCCESS)
2435 {
2436 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2437
2438 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2439 }
2440 }
2441
2442 hc_clFlush (data.ocl, device_param->command_queue);
2443
2444 hc_clFinish (data.ocl, device_param->command_queue);
2445 }
2446
2447 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2448 {
2449 uint num_elements = num;
2450
2451 switch (kern_run)
2452 {
2453 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2454 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2455 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2456 }
2457
2458 // causes problems with special threads like in bcrypt
2459 // const uint kernel_threads = device_param->kernel_threads;
2460
2461 const uint kernel_threads = KERNEL_THREADS;
2462
2463 while (num_elements % kernel_threads) num_elements++;
2464
2465 cl_kernel kernel = NULL;
2466
2467 switch (kern_run)
2468 {
2469 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2470 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2471 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2472 }
2473
2474 switch (kern_run)
2475 {
2476 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2477 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2478 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2479 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2480 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2481 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2482 break;
2483 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2484 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2485 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2486 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2487 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2488 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2489 break;
2490 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2491 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2492 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2493 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2494 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2495 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2496 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2497 break;
2498 }
2499
2500 const size_t global_work_size[3] = { num_elements, 1, 1 };
2501 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2502
2503 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);
2504
2505 if (rc != CL_SUCCESS)
2506 {
2507 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2508
2509 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2510 }
2511
2512 hc_clFlush (data.ocl, device_param->command_queue);
2513
2514 hc_clFinish (data.ocl, device_param->command_queue);
2515 }
2516
2517 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2518 {
2519 uint num_elements = num;
2520
2521 uint kernel_threads = device_param->kernel_threads;
2522
2523 while (num_elements % kernel_threads) num_elements++;
2524
2525 cl_kernel kernel = device_param->kernel_tb;
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2531
2532 hc_clFlush (data.ocl, device_param->command_queue);
2533
2534 hc_clFinish (data.ocl, device_param->command_queue);
2535 }
2536
2537 static void run_kernel_tm (hc_device_param_t *device_param)
2538 {
2539 const uint num_elements = 1024; // fixed
2540
2541 const uint kernel_threads = 32;
2542
2543 cl_kernel kernel = device_param->kernel_tm;
2544
2545 const size_t global_work_size[3] = { num_elements, 1, 1 };
2546 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2547
2548 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2549
2550 hc_clFlush (data.ocl, device_param->command_queue);
2551
2552 hc_clFinish (data.ocl, device_param->command_queue);
2553 }
2554
2555 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2556 {
2557 uint num_elements = num;
2558
2559 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2560 device_param->kernel_params_amp_buf32[6] = num_elements;
2561
2562 // causes problems with special threads like in bcrypt
2563 // const uint kernel_threads = device_param->kernel_threads;
2564
2565 const uint kernel_threads = KERNEL_THREADS;
2566
2567 while (num_elements % kernel_threads) num_elements++;
2568
2569 cl_kernel kernel = device_param->kernel_amp;
2570
2571 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2572 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2573
2574 const size_t global_work_size[3] = { num_elements, 1, 1 };
2575 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2576
2577 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2578
2579 hc_clFlush (data.ocl, device_param->command_queue);
2580
2581 hc_clFinish (data.ocl, device_param->command_queue);
2582 }
2583
2584 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2585 {
2586 int rc = -1;
2587
2588 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2589 {
2590 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2591
2592 const cl_uchar zero = 0;
2593
2594 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2595 }
2596
2597 if (rc != 0)
2598 {
2599 // NOTE: clEnqueueFillBuffer () always fails with -59
2600 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2601 // How's that possible, OpenCL 1.2 support is advertised??
2602 // We need to workaround...
2603
2604 #define FILLSZ 0x100000
2605
2606 char *tmp = (char *) mymalloc (FILLSZ);
2607
2608 for (uint i = 0; i < size; i += FILLSZ)
2609 {
2610 const int left = size - i;
2611
2612 const int fillsz = MIN (FILLSZ, left);
2613
2614 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2615 }
2616
2617 myfree (tmp);
2618 }
2619 }
2620
2621 static int run_rule_engine (const int rule_len, const char *rule_buf)
2622 {
2623 if (rule_len == 0)
2624 {
2625 return 0;
2626 }
2627 else if (rule_len == 1)
2628 {
2629 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2630 }
2631
2632 return 1;
2633 }
2634
2635 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2636 {
2637 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2638 {
2639 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);
2640 }
2641 else if (data.attack_kern == ATTACK_KERN_COMBI)
2642 {
2643 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);
2644 }
2645 else if (data.attack_kern == ATTACK_KERN_BF)
2646 {
2647 const u64 off = device_param->words_off;
2648
2649 device_param->kernel_params_mp_l_buf64[3] = off;
2650
2651 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2652 }
2653 }
2654
2655 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2656 {
2657 const uint kernel_loops = device_param->kernel_loops;
2658
2659 if (data.quiet == 0)
2660 log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2661
2662 // init speed timer
2663
2664 uint speed_pos = device_param->speed_pos;
2665
2666 #ifdef _POSIX
2667 if (device_param->timer_speed.tv_sec == 0)
2668 {
2669 hc_timer_set (&device_param->timer_speed);
2670 }
2671 #endif
2672
2673 #ifdef _WIN
2674 if (device_param->timer_speed.QuadPart == 0)
2675 {
2676 hc_timer_set (&device_param->timer_speed);
2677 }
2678 #endif
2679
2680 // find higest password length, this is for optimization stuff
2681
2682 uint highest_pw_len = 0;
2683
2684 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2685 {
2686 }
2687 else if (data.attack_kern == ATTACK_KERN_COMBI)
2688 {
2689 }
2690 else if (data.attack_kern == ATTACK_KERN_BF)
2691 {
2692 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2693 + device_param->kernel_params_mp_l_buf32[5];
2694 }
2695
2696 // bitslice optimization stuff
2697
2698 if (data.attack_mode == ATTACK_MODE_BF)
2699 {
2700 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2701 {
2702 run_kernel_tb (device_param, pws_cnt);
2703 }
2704 }
2705
2706 // iteration type
2707
2708 uint innerloop_step = 0;
2709 uint innerloop_cnt = 0;
2710
2711 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2712 else innerloop_step = 1;
2713
2714 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2715 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2716 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2717
2718 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2719
2720 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2721 {
2722 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2723
2724 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2725
2726 if (data.devices_status == STATUS_CRACKED) break;
2727 if (data.devices_status == STATUS_ABORTED) break;
2728 if (data.devices_status == STATUS_QUIT) break;
2729 if (data.devices_status == STATUS_BYPASS) break;
2730
2731 if (data.salts_shown[salt_pos] == 1) continue;
2732
2733 salt_t *salt_buf = &data.salts_buf[salt_pos];
2734
2735 device_param->kernel_params_buf32[24] = salt_pos;
2736 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2737 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2738
2739 FILE *combs_fp = device_param->combs_fp;
2740
2741 if (data.attack_mode == ATTACK_MODE_COMBI)
2742 {
2743 rewind (combs_fp);
2744 }
2745
2746 // innerloops
2747
2748 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2749 {
2750 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2751
2752 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2753
2754 if (data.devices_status == STATUS_CRACKED) break;
2755 if (data.devices_status == STATUS_ABORTED) break;
2756 if (data.devices_status == STATUS_QUIT) break;
2757 if (data.devices_status == STATUS_BYPASS) break;
2758
2759 uint innerloop_left = innerloop_cnt - innerloop_pos;
2760
2761 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2762
2763 device_param->innerloop_pos = innerloop_pos;
2764 device_param->innerloop_left = innerloop_left;
2765
2766 device_param->kernel_params_buf32[27] = innerloop_left;
2767
2768 if (innerloop_left == 0) continue;
2769
2770 // initialize amplifiers
2771
2772 if (data.attack_mode == ATTACK_MODE_COMBI)
2773 {
2774 char line_buf[BUFSIZ] = { 0 };
2775
2776 uint i = 0;
2777
2778 while (i < innerloop_left)
2779 {
2780 if (feof (combs_fp)) break;
2781
2782 int line_len = fgetl (combs_fp, line_buf);
2783
2784 if (line_len >= PW_MAX1) continue;
2785
2786 line_len = convert_from_hex (line_buf, line_len);
2787
2788 char *line_buf_new = line_buf;
2789
2790 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2791 {
2792 char rule_buf_out[BLOCK_SIZE] = { 0 };
2793
2794 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2795
2796 if (rule_len_out < 0)
2797 {
2798 data.words_progress_rejected[salt_pos] += pw_cnt;
2799
2800 continue;
2801 }
2802
2803 line_len = rule_len_out;
2804
2805 line_buf_new = rule_buf_out;
2806 }
2807
2808 line_len = MIN (line_len, PW_DICTMAX);
2809
2810 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2811
2812 memcpy (ptr, line_buf_new, line_len);
2813
2814 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2815
2816 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2817 {
2818 uppercase (ptr, line_len);
2819 }
2820
2821 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2822 {
2823 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2824 {
2825 ptr[line_len] = 0x80;
2826 }
2827
2828 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2829 {
2830 ptr[line_len] = 0x01;
2831 }
2832 }
2833
2834 device_param->combs_buf[i].pw_len = line_len;
2835
2836 i++;
2837 }
2838
2839 for (uint j = i; j < innerloop_left; j++)
2840 {
2841 device_param->combs_buf[j].i[0] = 0;
2842 device_param->combs_buf[j].i[1] = 0;
2843 device_param->combs_buf[j].i[2] = 0;
2844 device_param->combs_buf[j].i[3] = 0;
2845 device_param->combs_buf[j].i[4] = 0;
2846 device_param->combs_buf[j].i[5] = 0;
2847 device_param->combs_buf[j].i[6] = 0;
2848 device_param->combs_buf[j].i[7] = 0;
2849
2850 device_param->combs_buf[j].pw_len = 0;
2851 }
2852
2853 innerloop_left = i;
2854 }
2855 else if (data.attack_mode == ATTACK_MODE_BF)
2856 {
2857 u64 off = innerloop_pos;
2858
2859 device_param->kernel_params_mp_r_buf64[3] = off;
2860
2861 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2862 }
2863 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2864 {
2865 u64 off = innerloop_pos;
2866
2867 device_param->kernel_params_mp_buf64[3] = off;
2868
2869 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 u64 off = innerloop_pos;
2874
2875 device_param->kernel_params_mp_buf64[3] = off;
2876
2877 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2878 }
2879
2880 // copy amplifiers
2881
2882 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2883 {
2884 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);
2885 }
2886 else if (data.attack_mode == ATTACK_MODE_COMBI)
2887 {
2888 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);
2889 }
2890 else if (data.attack_mode == ATTACK_MODE_BF)
2891 {
2892 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);
2893 }
2894 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2895 {
2896 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);
2897 }
2898 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2899 {
2900 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);
2901 }
2902
2903 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2904 {
2905 if (data.attack_mode == ATTACK_MODE_BF)
2906 {
2907 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2908 {
2909 const uint size_tm = 32 * sizeof (bs_word_t);
2910
2911 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2912
2913 run_kernel_tm (device_param);
2914
2915 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);
2916 }
2917 }
2918
2919 if (highest_pw_len < 16)
2920 {
2921 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2922 }
2923 else if (highest_pw_len < 32)
2924 {
2925 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2926 }
2927 else
2928 {
2929 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2930 }
2931 }
2932 else
2933 {
2934 run_kernel_amp (device_param, pws_cnt);
2935
2936 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2937
2938 if (data.opts_type & OPTS_TYPE_HOOK12)
2939 {
2940 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2941 }
2942
2943 uint iter = salt_buf->salt_iter;
2944
2945 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2946 {
2947 uint loop_left = iter - loop_pos;
2948
2949 loop_left = MIN (loop_left, kernel_loops);
2950
2951 device_param->kernel_params_buf32[25] = loop_pos;
2952 device_param->kernel_params_buf32[26] = loop_left;
2953
2954 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2955
2956 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2957
2958 if (data.devices_status == STATUS_CRACKED) break;
2959 if (data.devices_status == STATUS_ABORTED) break;
2960 if (data.devices_status == STATUS_QUIT) break;
2961 }
2962
2963 if (data.opts_type & OPTS_TYPE_HOOK23)
2964 {
2965 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2966
2967 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);
2968
2969 // do something with data
2970
2971 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);
2972 }
2973
2974 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2975 }
2976
2977 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2978
2979 if (data.devices_status == STATUS_CRACKED) break;
2980 if (data.devices_status == STATUS_ABORTED) break;
2981 if (data.devices_status == STATUS_QUIT) break;
2982
2983 /**
2984 * result
2985 */
2986
2987 hc_thread_mutex_lock (mux_display);
2988
2989 check_cracked (device_param, salt_pos);
2990
2991 hc_thread_mutex_unlock (mux_display);
2992
2993 /**
2994 * progress
2995 */
2996
2997 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2998
2999 hc_thread_mutex_lock (mux_counter);
3000
3001 data.words_progress_done[salt_pos] += perf_sum_all;
3002
3003 hc_thread_mutex_unlock (mux_counter);
3004
3005 /**
3006 * speed
3007 */
3008
3009 float speed_ms;
3010
3011 hc_timer_get (device_param->timer_speed, speed_ms);
3012
3013 hc_timer_set (&device_param->timer_speed);
3014
3015 hc_thread_mutex_lock (mux_display);
3016
3017 device_param->speed_cnt[speed_pos] = perf_sum_all;
3018
3019 device_param->speed_ms[speed_pos] = speed_ms;
3020
3021 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3022
3023 hc_thread_mutex_unlock (mux_display);
3024
3025 speed_pos++;
3026
3027 if (speed_pos == SPEED_CACHE)
3028 {
3029 speed_pos = 0;
3030 }
3031 }
3032 }
3033
3034 device_param->speed_pos = speed_pos;
3035 }
3036
3037 static void load_segment (wl_data_t *wl_data, FILE *fd)
3038 {
3039 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3040
3041 wl_data->pos = 0;
3042
3043 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3044
3045 wl_data->buf[wl_data->cnt] = 0;
3046
3047 if (wl_data->cnt == 0) return;
3048
3049 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3050
3051 while (!feof (fd))
3052 {
3053 if (wl_data->cnt == wl_data->avail)
3054 {
3055 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3056
3057 wl_data->avail += wl_data->incr;
3058 }
3059
3060 const int c = fgetc (fd);
3061
3062 if (c == EOF) break;
3063
3064 wl_data->buf[wl_data->cnt] = (char) c;
3065
3066 wl_data->cnt++;
3067
3068 if (c == '\n') break;
3069 }
3070
3071 // ensure stream ends with a newline
3072
3073 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3074 {
3075 wl_data->cnt++;
3076
3077 wl_data->buf[wl_data->cnt - 1] = '\n';
3078 }
3079
3080 return;
3081 }
3082
3083 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3084 {
3085 char *ptr = buf;
3086
3087 for (u32 i = 0; i < sz; i++, ptr++)
3088 {
3089 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3090
3091 if (i == 7)
3092 {
3093 *off = i;
3094 *len = i;
3095
3096 return;
3097 }
3098
3099 if (*ptr != '\n') continue;
3100
3101 *off = i + 1;
3102
3103 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3104
3105 *len = i;
3106
3107 return;
3108 }
3109
3110 *off = sz;
3111 *len = sz;
3112 }
3113
3114 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3115 {
3116 char *ptr = buf;
3117
3118 for (u32 i = 0; i < sz; i++, ptr++)
3119 {
3120 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3121
3122 if (*ptr != '\n') continue;
3123
3124 *off = i + 1;
3125
3126 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3127
3128 *len = i;
3129
3130 return;
3131 }
3132
3133 *off = sz;
3134 *len = sz;
3135 }
3136
3137 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3138 {
3139 char *ptr = buf;
3140
3141 for (u32 i = 0; i < sz; i++, ptr++)
3142 {
3143 if (*ptr != '\n') continue;
3144
3145 *off = i + 1;
3146
3147 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3148
3149 *len = i;
3150
3151 return;
3152 }
3153
3154 *off = sz;
3155 *len = sz;
3156 }
3157
3158 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3159 {
3160 while (wl_data->pos < wl_data->cnt)
3161 {
3162 uint off;
3163 uint len;
3164
3165 char *ptr = wl_data->buf + wl_data->pos;
3166
3167 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3168
3169 wl_data->pos += off;
3170
3171 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3172 {
3173 char rule_buf_out[BLOCK_SIZE] = { 0 };
3174
3175 int rule_len_out = -1;
3176
3177 if (len < BLOCK_SIZE)
3178 {
3179 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3180 }
3181
3182 if (rule_len_out < 0)
3183 {
3184 continue;
3185 }
3186
3187 if (rule_len_out > PW_MAX)
3188 {
3189 continue;
3190 }
3191 }
3192 else
3193 {
3194 if (len > PW_MAX)
3195 {
3196 continue;
3197 }
3198 }
3199
3200 *out_buf = ptr;
3201 *out_len = len;
3202
3203 return;
3204 }
3205
3206 if (feof (fd))
3207 {
3208 fprintf (stderr, "bug!!\n");
3209
3210 return;
3211 }
3212
3213 load_segment (wl_data, fd);
3214
3215 get_next_word (wl_data, fd, out_buf, out_len);
3216 }
3217
3218 #ifdef _POSIX
3219 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3220 #endif
3221
3222 #ifdef _WIN
3223 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3224 #endif
3225 {
3226 hc_signal (NULL);
3227
3228 dictstat_t d;
3229
3230 d.cnt = 0;
3231
3232 #ifdef _POSIX
3233 fstat (fileno (fd), &d.stat);
3234 #endif
3235
3236 #ifdef _WIN
3237 _fstat64 (fileno (fd), &d.stat);
3238 #endif
3239
3240 d.stat.st_mode = 0;
3241 d.stat.st_nlink = 0;
3242 d.stat.st_uid = 0;
3243 d.stat.st_gid = 0;
3244 d.stat.st_rdev = 0;
3245 d.stat.st_atime = 0;
3246
3247 #ifdef _POSIX
3248 d.stat.st_blksize = 0;
3249 d.stat.st_blocks = 0;
3250 #endif
3251
3252 if (d.stat.st_size == 0) return 0;
3253
3254 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3255
3256 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3257 {
3258 if (d_cache)
3259 {
3260 u64 cnt = d_cache->cnt;
3261
3262 u64 keyspace = cnt;
3263
3264 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3265 {
3266 keyspace *= data.kernel_rules_cnt;
3267 }
3268 else if (data.attack_kern == ATTACK_KERN_COMBI)
3269 {
3270 keyspace *= data.combs_cnt;
3271 }
3272
3273 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);
3274 if (data.quiet == 0) log_info ("");
3275
3276 hc_signal (sigHandler_default);
3277
3278 return (keyspace);
3279 }
3280 }
3281
3282 time_t now = 0;
3283 time_t prev = 0;
3284
3285 u64 comp = 0;
3286 u64 cnt = 0;
3287 u64 cnt2 = 0;
3288
3289 while (!feof (fd))
3290 {
3291 load_segment (wl_data, fd);
3292
3293 comp += wl_data->cnt;
3294
3295 u32 i = 0;
3296
3297 while (i < wl_data->cnt)
3298 {
3299 u32 len;
3300 u32 off;
3301
3302 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3303
3304 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3305 {
3306 char rule_buf_out[BLOCK_SIZE] = { 0 };
3307
3308 int rule_len_out = -1;
3309
3310 if (len < BLOCK_SIZE)
3311 {
3312 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3313 }
3314
3315 if (rule_len_out < 0)
3316 {
3317 len = PW_MAX1;
3318 }
3319 else
3320 {
3321 len = rule_len_out;
3322 }
3323 }
3324
3325 if (len < PW_MAX1)
3326 {
3327 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3328 {
3329 cnt += data.kernel_rules_cnt;
3330 }
3331 else if (data.attack_kern == ATTACK_KERN_COMBI)
3332 {
3333 cnt += data.combs_cnt;
3334 }
3335
3336 d.cnt++;
3337 }
3338
3339 i += off;
3340
3341 cnt2++;
3342 }
3343
3344 time (&now);
3345
3346 if ((now - prev) == 0) continue;
3347
3348 float percent = (float) comp / (float) d.stat.st_size;
3349
3350 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);
3351
3352 time (&prev);
3353 }
3354
3355 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);
3356 if (data.quiet == 0) log_info ("");
3357
3358 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3359
3360 hc_signal (sigHandler_default);
3361
3362 return (cnt);
3363 }
3364
3365 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3366 {
3367 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3368 }
3369
3370 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3371 {
3372 if (data.devices_status == STATUS_BYPASS) return 0;
3373
3374 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3375
3376 uint cache_cnt = pw_cache->cnt;
3377
3378 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3379
3380 memcpy (pw_hc1, pw_buf, pw_len);
3381
3382 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3383
3384 uint pws_cnt = device_param->pws_cnt;
3385
3386 cache_cnt++;
3387
3388 pw_t *pw = device_param->pws_buf + pws_cnt;
3389
3390 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3391
3392 pw->pw_len = pw_len;
3393
3394 pws_cnt++;
3395
3396 device_param->pws_cnt = pws_cnt;
3397 device_param->pw_cnt = pws_cnt * 1;
3398
3399 cache_cnt = 0;
3400
3401 pw_cache->cnt = cache_cnt;
3402
3403 return pws_cnt;
3404 }
3405
3406 static void *thread_monitor (void *p)
3407 {
3408 uint runtime_check = 0;
3409 uint remove_check = 0;
3410 uint status_check = 0;
3411 uint restore_check = 0;
3412
3413 uint restore_left = data.restore_timer;
3414 uint remove_left = data.remove_timer;
3415 uint status_left = data.status_timer;
3416
3417 #ifdef HAVE_HWMON
3418 uint hwmon_check = 0;
3419
3420 // these variables are mainly used for fan control (AMD only)
3421
3422 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3423
3424 // temperature controller "loopback" values
3425
3426 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3427 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3428
3429 #ifdef HAVE_ADL
3430 int temp_threshold = 1; // degrees celcius
3431
3432 int fan_speed_min = 15; // in percentage
3433 int fan_speed_max = 100;
3434 #endif // HAVE_ADL
3435
3436 time_t last_temp_check_time;
3437 #endif // HAVE_HWMON
3438
3439 uint sleep_time = 1;
3440
3441 if (data.runtime)
3442 {
3443 runtime_check = 1;
3444 }
3445
3446 if (data.restore_timer)
3447 {
3448 restore_check = 1;
3449 }
3450
3451 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3452 {
3453 remove_check = 1;
3454 }
3455
3456 if (data.status == 1)
3457 {
3458 status_check = 1;
3459 }
3460
3461 #ifdef HAVE_HWMON
3462 if (data.gpu_temp_disable == 0)
3463 {
3464 time (&last_temp_check_time);
3465
3466 hwmon_check = 1;
3467 }
3468 #endif
3469
3470 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3471 {
3472 #ifdef HAVE_HWMON
3473 if (hwmon_check == 0)
3474 #endif
3475 return (p);
3476 }
3477
3478 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3479 {
3480 hc_sleep (sleep_time);
3481
3482 if (data.devices_status != STATUS_RUNNING) continue;
3483
3484 #ifdef HAVE_HWMON
3485 if (hwmon_check == 1)
3486 {
3487 hc_thread_mutex_lock (mux_adl);
3488
3489 time_t temp_check_time;
3490
3491 time (&temp_check_time);
3492
3493 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3494
3495 if (Ta == 0) Ta = 1;
3496
3497 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3498 {
3499 hc_device_param_t *device_param = &data.devices_param[device_id];
3500
3501 if (device_param->skipped) continue;
3502
3503 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3504
3505 const int temperature = hm_get_temperature_with_device_id (device_id);
3506
3507 if (temperature > (int) data.gpu_temp_abort)
3508 {
3509 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3510
3511 if (data.devices_status != STATUS_QUIT) myabort ();
3512
3513 break;
3514 }
3515
3516 #ifdef HAVE_ADL
3517 const int gpu_temp_retain = data.gpu_temp_retain;
3518
3519 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3520 {
3521 if (data.hm_device[device_id].fan_supported == 1)
3522 {
3523 int temp_cur = temperature;
3524
3525 int temp_diff_new = gpu_temp_retain - temp_cur;
3526
3527 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3528
3529 // calculate Ta value (time difference in seconds between the last check and this check)
3530
3531 last_temp_check_time = temp_check_time;
3532
3533 float Kp = 1.8;
3534 float Ki = 0.005;
3535 float Kd = 6;
3536
3537 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3538
3539 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);
3540
3541 if (abs (fan_diff_required) >= temp_threshold)
3542 {
3543 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3544
3545 int fan_speed_level = fan_speed_cur;
3546
3547 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3548
3549 int fan_speed_new = fan_speed_level - fan_diff_required;
3550
3551 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3552 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3553
3554 if (fan_speed_new != fan_speed_cur)
3555 {
3556 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3557 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3558
3559 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3560 {
3561 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3562
3563 fan_speed_chgd[device_id] = 1;
3564 }
3565
3566 temp_diff_old[device_id] = temp_diff_new;
3567 }
3568 }
3569 }
3570 }
3571 #endif // HAVE_ADL
3572 }
3573
3574 hc_thread_mutex_unlock (mux_adl);
3575 }
3576 #endif // HAVE_HWMON
3577
3578 if (restore_check == 1)
3579 {
3580 restore_left--;
3581
3582 if (restore_left == 0)
3583 {
3584 if (data.restore_disable == 0) cycle_restore ();
3585
3586 restore_left = data.restore_timer;
3587 }
3588 }
3589
3590 if ((runtime_check == 1) && (data.runtime_start > 0))
3591 {
3592 time_t runtime_cur;
3593
3594 time (&runtime_cur);
3595
3596 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3597
3598 if (runtime_left <= 0)
3599 {
3600 if (data.benchmark == 0)
3601 {
3602 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3603 }
3604
3605 if (data.devices_status != STATUS_QUIT) myabort ();
3606 }
3607 }
3608
3609 if (remove_check == 1)
3610 {
3611 remove_left--;
3612
3613 if (remove_left == 0)
3614 {
3615 if (data.digests_saved != data.digests_done)
3616 {
3617 data.digests_saved = data.digests_done;
3618
3619 save_hash ();
3620 }
3621
3622 remove_left = data.remove_timer;
3623 }
3624 }
3625
3626 if (status_check == 1)
3627 {
3628 status_left--;
3629
3630 if (status_left == 0)
3631 {
3632 hc_thread_mutex_lock (mux_display);
3633
3634 if (data.quiet == 0) clear_prompt ();
3635
3636 if (data.quiet == 0) log_info ("");
3637
3638 status_display ();
3639
3640 if (data.quiet == 0) log_info ("");
3641
3642 hc_thread_mutex_unlock (mux_display);
3643
3644 status_left = data.status_timer;
3645 }
3646 }
3647 }
3648
3649 #ifdef HAVE_HWMON
3650 myfree (fan_speed_chgd);
3651
3652 myfree (temp_diff_old);
3653 myfree (temp_diff_sum);
3654 #endif
3655
3656 p = NULL;
3657
3658 return (p);
3659 }
3660
3661 static void *thread_outfile_remove (void *p)
3662 {
3663 // some hash-dependent constants
3664 char *outfile_dir = data.outfile_check_directory;
3665 uint dgst_size = data.dgst_size;
3666 uint isSalted = data.isSalted;
3667 uint esalt_size = data.esalt_size;
3668 uint hash_mode = data.hash_mode;
3669
3670 uint outfile_check_timer = data.outfile_check_timer;
3671
3672 char separator = data.separator;
3673
3674 // some hash-dependent functions
3675 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3676 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3677
3678 // buffers
3679 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3680
3681 hash_buf.digest = mymalloc (dgst_size);
3682
3683 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3684
3685 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3686
3687 uint digest_buf[64] = { 0 };
3688
3689 outfile_data_t *out_info = NULL;
3690
3691 char **out_files = NULL;
3692
3693 time_t folder_mtime = 0;
3694
3695 int out_cnt = 0;
3696
3697 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3698
3699 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3700 {
3701 hc_sleep (1);
3702
3703 if (data.devices_status != STATUS_RUNNING) continue;
3704
3705 check_left--;
3706
3707 if (check_left == 0)
3708 {
3709 struct stat outfile_check_stat;
3710
3711 if (stat (outfile_dir, &outfile_check_stat) == 0)
3712 {
3713 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3714
3715 if (is_dir == 1)
3716 {
3717 if (outfile_check_stat.st_mtime > folder_mtime)
3718 {
3719 char **out_files_new = scan_directory (outfile_dir);
3720
3721 int out_cnt_new = count_dictionaries (out_files_new);
3722
3723 outfile_data_t *out_info_new = NULL;
3724
3725 if (out_cnt_new > 0)
3726 {
3727 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3728
3729 for (int i = 0; i < out_cnt_new; i++)
3730 {
3731 out_info_new[i].file_name = out_files_new[i];
3732
3733 // check if there are files that we have seen/checked before (and not changed)
3734
3735 for (int j = 0; j < out_cnt; j++)
3736 {
3737 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3738 {
3739 struct stat outfile_stat;
3740
3741 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3742 {
3743 if (outfile_stat.st_ctime == out_info[j].ctime)
3744 {
3745 out_info_new[i].ctime = out_info[j].ctime;
3746 out_info_new[i].seek = out_info[j].seek;
3747 }
3748 }
3749 }
3750 }
3751 }
3752 }
3753
3754 local_free (out_info);
3755 local_free (out_files);
3756
3757 out_files = out_files_new;
3758 out_cnt = out_cnt_new;
3759 out_info = out_info_new;
3760
3761 folder_mtime = outfile_check_stat.st_mtime;
3762 }
3763
3764 for (int j = 0; j < out_cnt; j++)
3765 {
3766 FILE *fp = fopen (out_info[j].file_name, "rb");
3767
3768 if (fp != NULL)
3769 {
3770 //hc_thread_mutex_lock (mux_display);
3771
3772 #ifdef _POSIX
3773 struct stat outfile_stat;
3774
3775 fstat (fileno (fp), &outfile_stat);
3776 #endif
3777
3778 #ifdef _WIN
3779 struct stat64 outfile_stat;
3780
3781 _fstat64 (fileno (fp), &outfile_stat);
3782 #endif
3783
3784 if (outfile_stat.st_ctime > out_info[j].ctime)
3785 {
3786 out_info[j].ctime = outfile_stat.st_ctime;
3787 out_info[j].seek = 0;
3788 }
3789
3790 fseek (fp, out_info[j].seek, SEEK_SET);
3791
3792 while (!feof (fp))
3793 {
3794 char line_buf[BUFSIZ] = { 0 };
3795
3796 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3797
3798 if (ptr == NULL) break;
3799
3800 int line_len = strlen (line_buf);
3801
3802 if (line_len <= 0) continue;
3803
3804 int iter = MAX_CUT_TRIES;
3805
3806 for (uint i = line_len - 1; i && iter; i--, line_len--)
3807 {
3808 if (line_buf[i] != separator) continue;
3809
3810 int parser_status = PARSER_OK;
3811
3812 if ((hash_mode != 2500) && (hash_mode != 6800))
3813 {
3814 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3815 }
3816
3817 uint found = 0;
3818
3819 if (parser_status == PARSER_OK)
3820 {
3821 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3822 {
3823 if (data.salts_shown[salt_pos] == 1) continue;
3824
3825 salt_t *salt_buf = &data.salts_buf[salt_pos];
3826
3827 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3828 {
3829 uint idx = salt_buf->digests_offset + digest_pos;
3830
3831 if (data.digests_shown[idx] == 1) continue;
3832
3833 uint cracked = 0;
3834
3835 if (hash_mode == 6800)
3836 {
3837 if (i == salt_buf->salt_len)
3838 {
3839 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3840 }
3841 }
3842 else if (hash_mode == 2500)
3843 {
3844 // BSSID : MAC1 : MAC2 (:plain)
3845 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3846 {
3847 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3848
3849 if (!cracked) continue;
3850
3851 // now compare MAC1 and MAC2 too, since we have this additional info
3852 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3853 char *mac2_pos = mac1_pos + 12 + 1;
3854
3855 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3856 wpa_t *wpa = &wpas[salt_pos];
3857
3858 uint pke[25] = { 0 };
3859
3860 char *pke_ptr = (char *) pke;
3861
3862 for (uint i = 0; i < 25; i++)
3863 {
3864 pke[i] = byte_swap_32 (wpa->pke[i]);
3865 }
3866
3867 u8 mac1[6] = { 0 };
3868 u8 mac2[6] = { 0 };
3869
3870 memcpy (mac1, pke_ptr + 23, 6);
3871 memcpy (mac2, pke_ptr + 29, 6);
3872
3873 // compare hex string(s) vs binary MAC address(es)
3874
3875 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3876 {
3877 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3878 {
3879 cracked = 0;
3880 break;
3881 }
3882 }
3883
3884 // early skip ;)
3885 if (!cracked) continue;
3886
3887 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3888 {
3889 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3890 {
3891 cracked = 0;
3892 break;
3893 }
3894 }
3895 }
3896 }
3897 else
3898 {
3899 char *digests_buf_ptr = (char *) data.digests_buf;
3900
3901 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3902
3903 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3904 }
3905
3906 if (cracked == 1)
3907 {
3908 found = 1;
3909
3910 data.digests_shown[idx] = 1;
3911
3912 data.digests_done++;
3913
3914 salt_buf->digests_done++;
3915
3916 if (salt_buf->digests_done == salt_buf->digests_cnt)
3917 {
3918 data.salts_shown[salt_pos] = 1;
3919
3920 data.salts_done++;
3921
3922 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3923 }
3924 }
3925 }
3926
3927 if (data.devices_status == STATUS_CRACKED) break;
3928 }
3929 }
3930
3931 if (found) break;
3932
3933 if (data.devices_status == STATUS_CRACKED) break;
3934
3935 iter--;
3936 }
3937
3938 if (data.devices_status == STATUS_CRACKED) break;
3939 }
3940
3941 out_info[j].seek = ftell (fp);
3942
3943 //hc_thread_mutex_unlock (mux_display);
3944
3945 fclose (fp);
3946 }
3947 }
3948 }
3949 }
3950
3951 check_left = outfile_check_timer;
3952 }
3953 }
3954
3955 if (esalt_size) local_free (hash_buf.esalt);
3956
3957 if (isSalted) local_free (hash_buf.salt);
3958
3959 local_free (hash_buf.digest);
3960
3961 local_free (out_info);
3962
3963 local_free (out_files);
3964
3965 p = NULL;
3966
3967 return (p);
3968 }
3969
3970 static uint get_work (hc_device_param_t *device_param, const u64 max)
3971 {
3972 hc_thread_mutex_lock (mux_dispatcher);
3973
3974 const u64 words_cur = data.words_cur;
3975 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3976
3977 device_param->words_off = words_cur;
3978
3979 const u64 words_left = words_base - words_cur;
3980
3981 if (data.kernel_blocks_all > words_left)
3982 {
3983 if (data.kernel_blocks_div == 0)
3984 {
3985 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3986 }
3987 }
3988
3989 if (data.kernel_blocks_div)
3990 {
3991 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3992 {
3993 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3994 const u32 kernel_power_new = kernel_blocks_new;
3995
3996 if (kernel_blocks_new < device_param->kernel_blocks)
3997 {
3998 device_param->kernel_blocks = kernel_blocks_new;
3999 device_param->kernel_power = kernel_power_new;
4000 }
4001 }
4002 }
4003
4004 const uint kernel_blocks = device_param->kernel_blocks;
4005
4006 uint work = MIN (words_left, kernel_blocks);
4007
4008 work = MIN (work, max);
4009
4010 data.words_cur += work;
4011
4012 hc_thread_mutex_unlock (mux_dispatcher);
4013
4014 return work;
4015 }
4016
4017 static void *thread_calc_stdin (void *p)
4018 {
4019 hc_device_param_t *device_param = (hc_device_param_t *) p;
4020
4021 if (device_param->skipped) return NULL;
4022
4023 const uint attack_kern = data.attack_kern;
4024
4025 const uint kernel_blocks = device_param->kernel_blocks;
4026
4027 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4028 {
4029 hc_thread_mutex_lock (mux_dispatcher);
4030
4031 if (feof (stdin) != 0)
4032 {
4033 hc_thread_mutex_unlock (mux_dispatcher);
4034
4035 break;
4036 }
4037
4038 uint words_cur = 0;
4039
4040 while (words_cur < kernel_blocks)
4041 {
4042 char buf[BUFSIZ] = { 0 };
4043
4044 char *line_buf = fgets (buf, sizeof (buf), stdin);
4045
4046 if (line_buf == NULL) break;
4047
4048 uint line_len = in_superchop (line_buf);
4049
4050 line_len = convert_from_hex (line_buf, line_len);
4051
4052 // post-process rule engine
4053
4054 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4055 {
4056 char rule_buf_out[BLOCK_SIZE] = { 0 };
4057
4058 int rule_len_out = -1;
4059
4060 if (line_len < BLOCK_SIZE)
4061 {
4062 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4063 }
4064
4065 if (rule_len_out < 0) continue;
4066
4067 line_buf = rule_buf_out;
4068 line_len = rule_len_out;
4069 }
4070
4071 if (line_len > PW_MAX)
4072 {
4073 continue;
4074 }
4075
4076 if (attack_kern == ATTACK_KERN_STRAIGHT)
4077 {
4078 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4079 {
4080 hc_thread_mutex_lock (mux_counter);
4081
4082 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4083 {
4084 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4085 }
4086
4087 hc_thread_mutex_unlock (mux_counter);
4088
4089 continue;
4090 }
4091 }
4092 else if (attack_kern == ATTACK_KERN_COMBI)
4093 {
4094 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4095 // since we still need to combine the plains
4096
4097 if (line_len > data.pw_max)
4098 {
4099 hc_thread_mutex_lock (mux_counter);
4100
4101 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4102 {
4103 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4104 }
4105
4106 hc_thread_mutex_unlock (mux_counter);
4107
4108 continue;
4109 }
4110 }
4111
4112 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4113
4114 words_cur++;
4115
4116 if (data.devices_status == STATUS_CRACKED) break;
4117 if (data.devices_status == STATUS_ABORTED) break;
4118 if (data.devices_status == STATUS_QUIT) break;
4119 if (data.devices_status == STATUS_BYPASS) break;
4120 }
4121
4122 hc_thread_mutex_unlock (mux_dispatcher);
4123
4124 if (data.devices_status == STATUS_CRACKED) break;
4125 if (data.devices_status == STATUS_ABORTED) break;
4126 if (data.devices_status == STATUS_QUIT) break;
4127 if (data.devices_status == STATUS_BYPASS) break;
4128
4129 // we need 2 flushing because we have two independant caches and it can occur
4130 // that one buffer is already at threshold plus for that length also exists
4131 // more data in the 2nd buffer so it would overflow
4132
4133 // flush session 1
4134
4135 {
4136 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4137 {
4138 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4139
4140 const uint pw_cache_cnt = pw_cache->cnt;
4141
4142 if (pw_cache_cnt == 0) continue;
4143
4144 pw_cache->cnt = 0;
4145
4146 uint pws_cnt = device_param->pws_cnt;
4147
4148 pw_t *pw = device_param->pws_buf + pws_cnt;
4149
4150 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4151
4152 pw->pw_len = pw_len;
4153
4154 uint pw_cnt = device_param->pw_cnt;
4155
4156 pw_cnt += pw_cache_cnt;
4157
4158 device_param->pw_cnt = pw_cnt;
4159
4160 pws_cnt++;
4161
4162 device_param->pws_cnt = pws_cnt;
4163
4164 if (pws_cnt == device_param->kernel_power_user) break;
4165 }
4166
4167 const uint pw_cnt = device_param->pw_cnt;
4168 const uint pws_cnt = device_param->pws_cnt;
4169
4170 if (pws_cnt)
4171 {
4172 run_copy (device_param, pws_cnt);
4173
4174 run_cracker (device_param, pw_cnt, pws_cnt);
4175
4176 device_param->pw_cnt = 0;
4177 device_param->pws_cnt = 0;
4178 }
4179 }
4180
4181 // flush session 2
4182
4183 {
4184 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4185 {
4186 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4187
4188 const uint pw_cache_cnt = pw_cache->cnt;
4189
4190 if (pw_cache_cnt == 0) continue;
4191
4192 pw_cache->cnt = 0;
4193
4194 uint pws_cnt = device_param->pws_cnt;
4195
4196 pw_t *pw = device_param->pws_buf + pws_cnt;
4197
4198 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4199
4200 pw->pw_len = pw_len;
4201
4202 uint pw_cnt = device_param->pw_cnt;
4203
4204 pw_cnt += pw_cache_cnt;
4205
4206 device_param->pw_cnt = pw_cnt;
4207
4208 pws_cnt++;
4209
4210 device_param->pws_cnt = pws_cnt;
4211 }
4212
4213 const uint pw_cnt = device_param->pw_cnt;
4214 const uint pws_cnt = device_param->pws_cnt;
4215
4216 if (pws_cnt)
4217 {
4218 run_copy (device_param, pws_cnt);
4219
4220 run_cracker (device_param, pw_cnt, pws_cnt);
4221
4222 device_param->pw_cnt = 0;
4223 device_param->pws_cnt = 0;
4224 }
4225 }
4226 }
4227
4228 return NULL;
4229 }
4230
4231 static void *thread_calc (void *p)
4232 {
4233 hc_device_param_t *device_param = (hc_device_param_t *) p;
4234
4235 if (device_param->skipped) return NULL;
4236
4237 const uint attack_mode = data.attack_mode;
4238 const uint attack_kern = data.attack_kern;
4239
4240 if (attack_mode == ATTACK_MODE_BF)
4241 {
4242 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4243 {
4244 const uint work = get_work (device_param, -1);
4245
4246 if (work == 0) break;
4247
4248 const u64 words_off = device_param->words_off;
4249 const u64 words_fin = words_off + work;
4250
4251 const uint pw_cnt = work;
4252 const uint pws_cnt = work;
4253
4254 device_param->pw_cnt = pw_cnt;
4255 device_param->pws_cnt = pws_cnt;
4256
4257 if (pws_cnt)
4258 {
4259 run_copy (device_param, pws_cnt);
4260
4261 run_cracker (device_param, pw_cnt, pws_cnt);
4262
4263 device_param->pw_cnt = 0;
4264 device_param->pws_cnt = 0;
4265 }
4266
4267 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4268
4269 if (data.devices_status == STATUS_CRACKED) break;
4270 if (data.devices_status == STATUS_ABORTED) break;
4271 if (data.devices_status == STATUS_QUIT) break;
4272 if (data.devices_status == STATUS_BYPASS) break;
4273
4274 device_param->words_done = words_fin;
4275 }
4276 }
4277 else
4278 {
4279 const uint segment_size = data.segment_size;
4280
4281 char *dictfile = data.dictfile;
4282
4283 if (attack_mode == ATTACK_MODE_COMBI)
4284 {
4285 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4286 {
4287 dictfile = data.dictfile2;
4288 }
4289 }
4290
4291 FILE *fd = fopen (dictfile, "rb");
4292
4293 if (fd == NULL)
4294 {
4295 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4296
4297 return NULL;
4298 }
4299
4300 if (attack_mode == ATTACK_MODE_COMBI)
4301 {
4302 const uint combs_mode = data.combs_mode;
4303
4304 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4305 {
4306 const char *dictfilec = data.dictfile2;
4307
4308 FILE *combs_fp = fopen (dictfilec, "rb");
4309
4310 if (combs_fp == NULL)
4311 {
4312 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4313
4314 fclose (fd);
4315
4316 return NULL;
4317 }
4318
4319 device_param->combs_fp = combs_fp;
4320 }
4321 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4322 {
4323 const char *dictfilec = data.dictfile;
4324
4325 FILE *combs_fp = fopen (dictfilec, "rb");
4326
4327 if (combs_fp == NULL)
4328 {
4329 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4330
4331 fclose (fd);
4332
4333 return NULL;
4334 }
4335
4336 device_param->combs_fp = combs_fp;
4337 }
4338 }
4339
4340 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4341
4342 wl_data->buf = (char *) mymalloc (segment_size);
4343 wl_data->avail = segment_size;
4344 wl_data->incr = segment_size;
4345 wl_data->cnt = 0;
4346 wl_data->pos = 0;
4347
4348 u64 words_cur = 0;
4349
4350 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4351 {
4352 u64 words_off = 0;
4353 u64 words_fin = 0;
4354
4355 u64 max = -1;
4356
4357 while (max)
4358 {
4359 const uint work = get_work (device_param, max);
4360
4361 if (work == 0) break;
4362
4363 words_off = device_param->words_off;
4364 words_fin = words_off + work;
4365
4366 char *line_buf;
4367 uint line_len;
4368
4369 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4370
4371 max = 0;
4372
4373 for ( ; words_cur < words_fin; words_cur++)
4374 {
4375 get_next_word (wl_data, fd, &line_buf, &line_len);
4376
4377 line_len = convert_from_hex (line_buf, line_len);
4378
4379 // post-process rule engine
4380
4381 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4382 {
4383 char rule_buf_out[BLOCK_SIZE] = { 0 };
4384
4385 int rule_len_out = -1;
4386
4387 if (line_len < BLOCK_SIZE)
4388 {
4389 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4390 }
4391
4392 if (rule_len_out < 0) continue;
4393
4394 line_buf = rule_buf_out;
4395 line_len = rule_len_out;
4396 }
4397
4398 if (attack_kern == ATTACK_KERN_STRAIGHT)
4399 {
4400 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4401 {
4402 max++;
4403
4404 hc_thread_mutex_lock (mux_counter);
4405
4406 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4407 {
4408 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4409 }
4410
4411 hc_thread_mutex_unlock (mux_counter);
4412
4413 continue;
4414 }
4415 }
4416 else if (attack_kern == ATTACK_KERN_COMBI)
4417 {
4418 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4419 // since we still need to combine the plains
4420
4421 if (line_len > data.pw_max)
4422 {
4423 max++;
4424
4425 hc_thread_mutex_lock (mux_counter);
4426
4427 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4428 {
4429 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4430 }
4431
4432 hc_thread_mutex_unlock (mux_counter);
4433
4434 continue;
4435 }
4436 }
4437
4438 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4439
4440 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4441
4442 if (data.devices_status == STATUS_CRACKED) break;
4443 if (data.devices_status == STATUS_ABORTED) break;
4444 if (data.devices_status == STATUS_QUIT) break;
4445 if (data.devices_status == STATUS_BYPASS) break;
4446 }
4447
4448 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4449
4450 if (data.devices_status == STATUS_CRACKED) break;
4451 if (data.devices_status == STATUS_ABORTED) break;
4452 if (data.devices_status == STATUS_QUIT) break;
4453 if (data.devices_status == STATUS_BYPASS) break;
4454 }
4455
4456 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4457
4458 if (data.devices_status == STATUS_CRACKED) break;
4459 if (data.devices_status == STATUS_ABORTED) break;
4460 if (data.devices_status == STATUS_QUIT) break;
4461 if (data.devices_status == STATUS_BYPASS) break;
4462
4463 // we need 2 flushing because we have two independant caches and it can occur
4464 // that one buffer is already at threshold plus for that length also exists
4465 // more data in the 2nd buffer so it would overflow
4466
4467 //
4468 // flush session 1
4469 //
4470
4471 {
4472 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4473 {
4474 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4475
4476 const uint pw_cache_cnt = pw_cache->cnt;
4477
4478 if (pw_cache_cnt == 0) continue;
4479
4480 pw_cache->cnt = 0;
4481
4482 uint pws_cnt = device_param->pws_cnt;
4483
4484 pw_t *pw = device_param->pws_buf + pws_cnt;
4485
4486 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4487
4488 pw->pw_len = pw_len;
4489
4490 uint pw_cnt = device_param->pw_cnt;
4491
4492 pw_cnt += pw_cache_cnt;
4493
4494 device_param->pw_cnt = pw_cnt;
4495
4496 pws_cnt++;
4497
4498 device_param->pws_cnt = pws_cnt;
4499
4500 if (pws_cnt == device_param->kernel_power_user) break;
4501 }
4502
4503 const uint pw_cnt = device_param->pw_cnt;
4504 const uint pws_cnt = device_param->pws_cnt;
4505
4506 if (pws_cnt)
4507 {
4508 run_copy (device_param, pws_cnt);
4509
4510 run_cracker (device_param, pw_cnt, pws_cnt);
4511
4512 device_param->pw_cnt = 0;
4513 device_param->pws_cnt = 0;
4514 }
4515
4516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4517
4518 if (data.devices_status == STATUS_CRACKED) break;
4519 if (data.devices_status == STATUS_ABORTED) break;
4520 if (data.devices_status == STATUS_QUIT) break;
4521 if (data.devices_status == STATUS_BYPASS) break;
4522 }
4523
4524 //
4525 // flush session 2
4526 //
4527
4528 {
4529 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4530 {
4531 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4532
4533 const uint pw_cache_cnt = pw_cache->cnt;
4534
4535 if (pw_cache_cnt == 0) continue;
4536
4537 pw_cache->cnt = 0;
4538
4539 uint pws_cnt = device_param->pws_cnt;
4540
4541 pw_t *pw = device_param->pws_buf + pws_cnt;
4542
4543 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4544
4545 pw->pw_len = pw_len;
4546
4547 uint pw_cnt = device_param->pw_cnt;
4548
4549 pw_cnt += pw_cache_cnt;
4550
4551 device_param->pw_cnt = pw_cnt;
4552
4553 pws_cnt++;
4554
4555 device_param->pws_cnt = pws_cnt;
4556 }
4557
4558 const uint pw_cnt = device_param->pw_cnt;
4559 const uint pws_cnt = device_param->pws_cnt;
4560
4561 if (pws_cnt)
4562 {
4563 run_copy (device_param, pws_cnt);
4564
4565 run_cracker (device_param, pw_cnt, pws_cnt);
4566
4567 device_param->pw_cnt = 0;
4568 device_param->pws_cnt = 0;
4569 }
4570
4571 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4572
4573 if (data.devices_status == STATUS_CRACKED) break;
4574 if (data.devices_status == STATUS_ABORTED) break;
4575 if (data.devices_status == STATUS_QUIT) break;
4576 if (data.devices_status == STATUS_BYPASS) break;
4577 }
4578
4579 if (words_fin == 0) break;
4580
4581 device_param->words_done = words_fin;
4582 }
4583
4584 if (attack_mode == ATTACK_MODE_COMBI)
4585 {
4586 fclose (device_param->combs_fp);
4587 }
4588
4589 free (wl_data->buf);
4590 free (wl_data);
4591
4592 fclose (fd);
4593 }
4594
4595 return NULL;
4596 }
4597
4598 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4599 {
4600 if (!device_param)
4601 {
4602 log_error ("ERROR: %s : Invalid argument", __func__);
4603
4604 exit (-1);
4605 }
4606
4607 salt_t *salt_buf = &data.salts_buf[salt_pos];
4608
4609 device_param->kernel_params_buf32[24] = salt_pos;
4610 device_param->kernel_params_buf32[27] = 1;
4611 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4612 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4613 device_param->kernel_params_buf32[30] = 0;
4614 device_param->kernel_params_buf32[31] = 1;
4615
4616 char *dictfile_old = data.dictfile;
4617
4618 const char *weak_hash_check = "weak-hash-check";
4619
4620 data.dictfile = (char *) weak_hash_check;
4621
4622 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4623
4624 data.kernel_rules_buf[0].cmds[0] = 0;
4625
4626 /**
4627 * run the kernel
4628 */
4629
4630 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4631 {
4632 run_kernel (KERN_RUN_1, device_param, 1);
4633 }
4634 else
4635 {
4636 run_kernel (KERN_RUN_1, device_param, 1);
4637
4638 const uint iter = salt_buf->salt_iter;
4639
4640 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4641 {
4642 uint loop_left = iter - loop_pos;
4643
4644 loop_left = MIN (loop_left, kernel_loops);
4645
4646 device_param->kernel_params_buf32[25] = loop_pos;
4647 device_param->kernel_params_buf32[26] = loop_left;
4648
4649 run_kernel (KERN_RUN_2, device_param, 1);
4650 }
4651
4652 run_kernel (KERN_RUN_3, device_param, 1);
4653 }
4654
4655 /**
4656 * result
4657 */
4658
4659 check_cracked (device_param, salt_pos);
4660
4661 /**
4662 * cleanup
4663 */
4664
4665 device_param->kernel_params_buf32[24] = 0;
4666 device_param->kernel_params_buf32[25] = 0;
4667 device_param->kernel_params_buf32[26] = 0;
4668 device_param->kernel_params_buf32[27] = 0;
4669 device_param->kernel_params_buf32[28] = 0;
4670 device_param->kernel_params_buf32[29] = 0;
4671 device_param->kernel_params_buf32[30] = 0;
4672 device_param->kernel_params_buf32[31] = 0;
4673
4674 data.dictfile = dictfile_old;
4675
4676 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4677 }
4678
4679 // hlfmt hashcat
4680
4681 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4682 {
4683 if (data.username == 0)
4684 {
4685 *hashbuf_pos = line_buf;
4686 *hashbuf_len = line_len;
4687 }
4688 else
4689 {
4690 char *pos = line_buf;
4691 int len = line_len;
4692
4693 for (int i = 0; i < line_len; i++, pos++, len--)
4694 {
4695 if (line_buf[i] == data.separator)
4696 {
4697 pos++;
4698
4699 len--;
4700
4701 break;
4702 }
4703 }
4704
4705 *hashbuf_pos = pos;
4706 *hashbuf_len = len;
4707 }
4708 }
4709
4710 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4711 {
4712 char *pos = NULL;
4713 int len = 0;
4714
4715 int sep_cnt = 0;
4716
4717 for (int i = 0; i < line_len; i++)
4718 {
4719 if (line_buf[i] == data.separator)
4720 {
4721 sep_cnt++;
4722
4723 continue;
4724 }
4725
4726 if (sep_cnt == 0)
4727 {
4728 if (pos == NULL) pos = line_buf + i;
4729
4730 len++;
4731 }
4732 }
4733
4734 *userbuf_pos = pos;
4735 *userbuf_len = len;
4736 }
4737
4738 // hlfmt pwdump
4739
4740 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4741 {
4742 int sep_cnt = 0;
4743
4744 int sep2_len = 0;
4745 int sep3_len = 0;
4746
4747 for (int i = 0; i < line_len; i++)
4748 {
4749 if (line_buf[i] == ':')
4750 {
4751 sep_cnt++;
4752
4753 continue;
4754 }
4755
4756 if (sep_cnt == 2) sep2_len++;
4757 if (sep_cnt == 3) sep3_len++;
4758 }
4759
4760 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4761
4762 return 0;
4763 }
4764
4765 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4766 {
4767 char *pos = NULL;
4768 int len = 0;
4769
4770 int sep_cnt = 0;
4771
4772 for (int i = 0; i < line_len; i++)
4773 {
4774 if (line_buf[i] == ':')
4775 {
4776 sep_cnt++;
4777
4778 continue;
4779 }
4780
4781 if (data.hash_mode == 1000)
4782 {
4783 if (sep_cnt == 3)
4784 {
4785 if (pos == NULL) pos = line_buf + i;
4786
4787 len++;
4788 }
4789 }
4790 else if (data.hash_mode == 3000)
4791 {
4792 if (sep_cnt == 2)
4793 {
4794 if (pos == NULL) pos = line_buf + i;
4795
4796 len++;
4797 }
4798 }
4799 }
4800
4801 *hashbuf_pos = pos;
4802 *hashbuf_len = len;
4803 }
4804
4805 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4806 {
4807 char *pos = NULL;
4808 int len = 0;
4809
4810 int sep_cnt = 0;
4811
4812 for (int i = 0; i < line_len; i++)
4813 {
4814 if (line_buf[i] == ':')
4815 {
4816 sep_cnt++;
4817
4818 continue;
4819 }
4820
4821 if (sep_cnt == 0)
4822 {
4823 if (pos == NULL) pos = line_buf + i;
4824
4825 len++;
4826 }
4827 }
4828
4829 *userbuf_pos = pos;
4830 *userbuf_len = len;
4831 }
4832
4833 // hlfmt passwd
4834
4835 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4836 {
4837 int sep_cnt = 0;
4838
4839 char sep5_first = 0;
4840 char sep6_first = 0;
4841
4842 for (int i = 0; i < line_len; i++)
4843 {
4844 if (line_buf[i] == ':')
4845 {
4846 sep_cnt++;
4847
4848 continue;
4849 }
4850
4851 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4852 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4853 }
4854
4855 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4856
4857 return 0;
4858 }
4859
4860 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 char *pos = NULL;
4863 int len = 0;
4864
4865 int sep_cnt = 0;
4866
4867 for (int i = 0; i < line_len; i++)
4868 {
4869 if (line_buf[i] == ':')
4870 {
4871 sep_cnt++;
4872
4873 continue;
4874 }
4875
4876 if (sep_cnt == 1)
4877 {
4878 if (pos == NULL) pos = line_buf + i;
4879
4880 len++;
4881 }
4882 }
4883
4884 *hashbuf_pos = pos;
4885 *hashbuf_len = len;
4886 }
4887
4888 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4889 {
4890 char *pos = NULL;
4891 int len = 0;
4892
4893 int sep_cnt = 0;
4894
4895 for (int i = 0; i < line_len; i++)
4896 {
4897 if (line_buf[i] == ':')
4898 {
4899 sep_cnt++;
4900
4901 continue;
4902 }
4903
4904 if (sep_cnt == 0)
4905 {
4906 if (pos == NULL) pos = line_buf + i;
4907
4908 len++;
4909 }
4910 }
4911
4912 *userbuf_pos = pos;
4913 *userbuf_len = len;
4914 }
4915
4916 // hlfmt shadow
4917
4918 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4919 {
4920 int sep_cnt = 0;
4921
4922 for (int i = 0; i < line_len; i++)
4923 {
4924 if (line_buf[i] == ':') sep_cnt++;
4925 }
4926
4927 if (sep_cnt == 8) return 1;
4928
4929 return 0;
4930 }
4931
4932 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4933 {
4934 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4935 }
4936
4937 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4938 {
4939 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4940 }
4941
4942 // hlfmt main
4943
4944 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4945 {
4946 switch (hashfile_format)
4947 {
4948 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4949 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4950 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4951 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4952 }
4953 }
4954
4955 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4956 {
4957 switch (hashfile_format)
4958 {
4959 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4960 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4961 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4962 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4963 }
4964 }
4965
4966 static uint hlfmt_detect (FILE *fp, uint max_check)
4967 {
4968 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4969
4970 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4971 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4972
4973 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4974
4975 uint num_check = 0;
4976
4977 while (!feof (fp))
4978 {
4979 char line_buf[BUFSIZ] = { 0 };
4980
4981 int line_len = fgetl (fp, line_buf);
4982
4983 if (line_len == 0) continue;
4984
4985 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4986 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4987 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4988
4989 if (num_check == max_check) break;
4990
4991 num_check++;
4992 }
4993
4994 uint hashlist_format = HLFMT_HASHCAT;
4995
4996 for (int i = 1; i < HLFMTS_CNT; i++)
4997 {
4998 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4999
5000 hashlist_format = i;
5001 }
5002
5003 free (formats_cnt);
5004
5005 return hashlist_format;
5006 }
5007
5008 /**
5009 * some further helper function
5010 */
5011
5012 // wrapper around mymalloc for ADL
5013
5014 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5015 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5016 {
5017 return mymalloc (iSize);
5018 }
5019 #endif
5020
5021 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)
5022 {
5023 u64 collisions = 0;
5024
5025 const uint dgst_pos0 = data.dgst_pos0;
5026 const uint dgst_pos1 = data.dgst_pos1;
5027 const uint dgst_pos2 = data.dgst_pos2;
5028 const uint dgst_pos3 = data.dgst_pos3;
5029
5030 memset (bitmap_a, 0, bitmap_size);
5031 memset (bitmap_b, 0, bitmap_size);
5032 memset (bitmap_c, 0, bitmap_size);
5033 memset (bitmap_d, 0, bitmap_size);
5034
5035 for (uint i = 0; i < digests_cnt; i++)
5036 {
5037 uint *digest_ptr = (uint *) digests_buf_ptr;
5038
5039 digests_buf_ptr += dgst_size;
5040
5041 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5042 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5043 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5044 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5045
5046 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5047 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5048 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5049 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5050
5051 if (bitmap_a[idx0] & val0) collisions++;
5052 if (bitmap_b[idx1] & val1) collisions++;
5053 if (bitmap_c[idx2] & val2) collisions++;
5054 if (bitmap_d[idx3] & val3) collisions++;
5055
5056 bitmap_a[idx0] |= val0;
5057 bitmap_b[idx1] |= val1;
5058 bitmap_c[idx2] |= val2;
5059 bitmap_d[idx3] |= val3;
5060
5061 if (collisions >= collisions_max) return 0x7fffffff;
5062 }
5063
5064 return collisions;
5065 }
5066
5067 /**
5068 * main
5069 */
5070
5071 int main (int argc, char **argv)
5072 {
5073 /**
5074 * To help users a bit
5075 */
5076
5077 char *compute = getenv ("COMPUTE");
5078
5079 if (compute)
5080 {
5081 static char display[100];
5082
5083 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5084
5085 putenv (display);
5086 }
5087 else
5088 {
5089 if (getenv ("DISPLAY") == NULL)
5090 putenv ((char *) "DISPLAY=:0");
5091 }
5092
5093 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5094 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5095
5096 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5097 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5098
5099 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5100 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5101
5102 /**
5103 * Real init
5104 */
5105
5106 memset (&data, 0, sizeof (hc_global_data_t));
5107
5108 time_t proc_start;
5109
5110 time (&proc_start);
5111
5112 data.proc_start = proc_start;
5113
5114 int myargc = argc;
5115 char **myargv = argv;
5116
5117 hc_thread_mutex_init (mux_dispatcher);
5118 hc_thread_mutex_init (mux_counter);
5119 hc_thread_mutex_init (mux_display);
5120 hc_thread_mutex_init (mux_adl);
5121
5122 /**
5123 * commandline parameters
5124 */
5125
5126 uint usage = USAGE;
5127 uint version = VERSION;
5128 uint quiet = QUIET;
5129 uint benchmark = BENCHMARK;
5130 uint benchmark_mode = BENCHMARK_MODE;
5131 uint show = SHOW;
5132 uint left = LEFT;
5133 uint username = USERNAME;
5134 uint remove = REMOVE;
5135 uint remove_timer = REMOVE_TIMER;
5136 u64 skip = SKIP;
5137 u64 limit = LIMIT;
5138 uint keyspace = KEYSPACE;
5139 uint potfile_disable = POTFILE_DISABLE;
5140 uint debug_mode = DEBUG_MODE;
5141 char *debug_file = NULL;
5142 char *induction_dir = NULL;
5143 char *outfile_check_dir = NULL;
5144 uint force = FORCE;
5145 uint runtime = RUNTIME;
5146 uint hash_mode = HASH_MODE;
5147 uint attack_mode = ATTACK_MODE;
5148 uint markov_disable = MARKOV_DISABLE;
5149 uint markov_classic = MARKOV_CLASSIC;
5150 uint markov_threshold = MARKOV_THRESHOLD;
5151 char *markov_hcstat = NULL;
5152 char *outfile = NULL;
5153 uint outfile_format = OUTFILE_FORMAT;
5154 uint outfile_autohex = OUTFILE_AUTOHEX;
5155 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5156 uint restore = RESTORE;
5157 uint restore_timer = RESTORE_TIMER;
5158 uint restore_disable = RESTORE_DISABLE;
5159 uint status = STATUS;
5160 uint status_timer = STATUS_TIMER;
5161 uint status_automat = STATUS_AUTOMAT;
5162 uint loopback = LOOPBACK;
5163 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5164 char *session = NULL;
5165 uint hex_charset = HEX_CHARSET;
5166 uint hex_salt = HEX_SALT;
5167 uint hex_wordlist = HEX_WORDLIST;
5168 uint rp_gen = RP_GEN;
5169 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5170 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5171 uint rp_gen_seed = RP_GEN_SEED;
5172 char *rule_buf_l = (char *) RULE_BUF_L;
5173 char *rule_buf_r = (char *) RULE_BUF_R;
5174 uint increment = INCREMENT;
5175 uint increment_min = INCREMENT_MIN;
5176 uint increment_max = INCREMENT_MAX;
5177 #ifndef OSX
5178 char *cpu_affinity = NULL;
5179 #endif
5180 OCL_PTR *ocl = NULL;
5181 char *opencl_devices = NULL;
5182 char *opencl_platforms = NULL;
5183 char *opencl_device_types = NULL;
5184 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5185 char *truecrypt_keyfiles = NULL;
5186 uint workload_profile = WORKLOAD_PROFILE;
5187 uint kernel_accel = KERNEL_ACCEL;
5188 uint kernel_loops = KERNEL_LOOPS;
5189 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5190 #ifdef HAVE_HWMON
5191 uint gpu_temp_abort = GPU_TEMP_ABORT;
5192 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5193 #ifdef HAVE_ADL
5194 uint powertune_enable = POWERTUNE_ENABLE;
5195 #endif
5196 #endif
5197 uint logfile_disable = LOGFILE_DISABLE;
5198 uint segment_size = SEGMENT_SIZE;
5199 uint scrypt_tmto = SCRYPT_TMTO;
5200 char separator = SEPARATOR;
5201 uint bitmap_min = BITMAP_MIN;
5202 uint bitmap_max = BITMAP_MAX;
5203 char *custom_charset_1 = NULL;
5204 char *custom_charset_2 = NULL;
5205 char *custom_charset_3 = NULL;
5206 char *custom_charset_4 = NULL;
5207
5208 #define IDX_HELP 'h'
5209 #define IDX_VERSION 'V'
5210 #define IDX_VERSION_LOWER 'v'
5211 #define IDX_QUIET 0xff02
5212 #define IDX_SHOW 0xff03
5213 #define IDX_LEFT 0xff04
5214 #define IDX_REMOVE 0xff05
5215 #define IDX_REMOVE_TIMER 0xff37
5216 #define IDX_SKIP 's'
5217 #define IDX_LIMIT 'l'
5218 #define IDX_KEYSPACE 0xff35
5219 #define IDX_POTFILE_DISABLE 0xff06
5220 #define IDX_DEBUG_MODE 0xff43
5221 #define IDX_DEBUG_FILE 0xff44
5222 #define IDX_INDUCTION_DIR 0xff46
5223 #define IDX_OUTFILE_CHECK_DIR 0xff47
5224 #define IDX_USERNAME 0xff07
5225 #define IDX_FORCE 0xff08
5226 #define IDX_RUNTIME 0xff09
5227 #define IDX_BENCHMARK 'b'
5228 #define IDX_BENCHMARK_MODE 0xff32
5229 #define IDX_HASH_MODE 'm'
5230 #define IDX_ATTACK_MODE 'a'
5231 #define IDX_RP_FILE 'r'
5232 #define IDX_RP_GEN 'g'
5233 #define IDX_RP_GEN_FUNC_MIN 0xff10
5234 #define IDX_RP_GEN_FUNC_MAX 0xff11
5235 #define IDX_RP_GEN_SEED 0xff34
5236 #define IDX_RULE_BUF_L 'j'
5237 #define IDX_RULE_BUF_R 'k'
5238 #define IDX_INCREMENT 'i'
5239 #define IDX_INCREMENT_MIN 0xff12
5240 #define IDX_INCREMENT_MAX 0xff13
5241 #define IDX_OUTFILE 'o'
5242 #define IDX_OUTFILE_FORMAT 0xff14
5243 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5244 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5245 #define IDX_RESTORE 0xff15
5246 #define IDX_RESTORE_DISABLE 0xff27
5247 #define IDX_STATUS 0xff17
5248 #define IDX_STATUS_TIMER 0xff18
5249 #define IDX_STATUS_AUTOMAT 0xff50
5250 #define IDX_LOOPBACK 0xff38
5251 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5252 #define IDX_SESSION 0xff19
5253 #define IDX_HEX_CHARSET 0xff20
5254 #define IDX_HEX_SALT 0xff21
5255 #define IDX_HEX_WORDLIST 0xff40
5256 #define IDX_MARKOV_DISABLE 0xff22
5257 #define IDX_MARKOV_CLASSIC 0xff23
5258 #define IDX_MARKOV_THRESHOLD 't'
5259 #define IDX_MARKOV_HCSTAT 0xff24
5260 #define IDX_CPU_AFFINITY 0xff25
5261 #define IDX_OPENCL_DEVICES 'd'
5262 #define IDX_OPENCL_PLATFORMS 0xff72
5263 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5264 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5265 #define IDX_WORKLOAD_PROFILE 'w'
5266 #define IDX_KERNEL_ACCEL 'n'
5267 #define IDX_KERNEL_LOOPS 'u'
5268 #define IDX_GPU_TEMP_DISABLE 0xff29
5269 #define IDX_GPU_TEMP_ABORT 0xff30
5270 #define IDX_GPU_TEMP_RETAIN 0xff31
5271 #define IDX_POWERTUNE_ENABLE 0xff41
5272 #define IDX_LOGFILE_DISABLE 0xff51
5273 #define IDX_TRUECRYPT_KEYFILES 0xff52
5274 #define IDX_SCRYPT_TMTO 0xff61
5275 #define IDX_SEGMENT_SIZE 'c'
5276 #define IDX_SEPARATOR 'p'
5277 #define IDX_BITMAP_MIN 0xff70
5278 #define IDX_BITMAP_MAX 0xff71
5279 #define IDX_CUSTOM_CHARSET_1 '1'
5280 #define IDX_CUSTOM_CHARSET_2 '2'
5281 #define IDX_CUSTOM_CHARSET_3 '3'
5282 #define IDX_CUSTOM_CHARSET_4 '4'
5283
5284 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5285
5286 struct option long_options[] =
5287 {
5288 {"help", no_argument, 0, IDX_HELP},
5289 {"version", no_argument, 0, IDX_VERSION},
5290 {"quiet", no_argument, 0, IDX_QUIET},
5291 {"show", no_argument, 0, IDX_SHOW},
5292 {"left", no_argument, 0, IDX_LEFT},
5293 {"username", no_argument, 0, IDX_USERNAME},
5294 {"remove", no_argument, 0, IDX_REMOVE},
5295 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5296 {"skip", required_argument, 0, IDX_SKIP},
5297 {"limit", required_argument, 0, IDX_LIMIT},
5298 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5299 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5300 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5301 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5302 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5303 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5304 {"force", no_argument, 0, IDX_FORCE},
5305 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5306 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5307 {"restore", no_argument, 0, IDX_RESTORE},
5308 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5309 {"status", no_argument, 0, IDX_STATUS},
5310 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5311 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5312 {"loopback", no_argument, 0, IDX_LOOPBACK},
5313 {"weak-hash-threshold",
5314 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5315 {"session", required_argument, 0, IDX_SESSION},
5316 {"runtime", required_argument, 0, IDX_RUNTIME},
5317 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5318 {"generate-rules-func-min",
5319 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5320 {"generate-rules-func-max",
5321 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5322 {"generate-rules-seed",
5323 required_argument, 0, IDX_RP_GEN_SEED},
5324 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5325 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5326 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5327 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5328 {"rules-file", required_argument, 0, IDX_RP_FILE},
5329 {"outfile", required_argument, 0, IDX_OUTFILE},
5330 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5331 {"outfile-autohex-disable",
5332 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5333 {"outfile-check-timer",
5334 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5335 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5336 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5337 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5338 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5339 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5340 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5341 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5342 #ifndef OSX
5343 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5344 #endif
5345 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5346 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5347 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5348 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5349 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5350 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5351 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5352 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5353 #ifdef HAVE_HWMON
5354 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5355 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5356 #ifdef HAVE_ADL
5357 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5358 #endif
5359 #endif // HAVE_HWMON
5360 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5361 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5362 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5363 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5364 // deprecated
5365 {"seperator", required_argument, 0, IDX_SEPARATOR},
5366 {"separator", required_argument, 0, IDX_SEPARATOR},
5367 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5368 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5369 {"increment", no_argument, 0, IDX_INCREMENT},
5370 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5371 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5372 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5373 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5374 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5375 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5376
5377 {0, 0, 0, 0}
5378 };
5379
5380 uint rp_files_cnt = 0;
5381
5382 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5383
5384 int option_index = 0;
5385 int c = -1;
5386
5387 optind = 1;
5388 optopt = 0;
5389
5390 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5391 {
5392 switch (c)
5393 {
5394 case IDX_HELP: usage = 1; break;
5395 case IDX_VERSION:
5396 case IDX_VERSION_LOWER: version = 1; break;
5397 case IDX_RESTORE: restore = 1; break;
5398 case IDX_SESSION: session = optarg; break;
5399 case IDX_SHOW: show = 1; break;
5400 case IDX_LEFT: left = 1; break;
5401 case '?': return (-1);
5402 }
5403 }
5404
5405 if (optopt != 0)
5406 {
5407 log_error ("ERROR: Invalid argument specified");
5408
5409 return (-1);
5410 }
5411
5412 /**
5413 * exit functions
5414 */
5415
5416 if (version)
5417 {
5418 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5419
5420 return (0);
5421 }
5422
5423 if (usage)
5424 {
5425 usage_big_print (PROGNAME);
5426
5427 return (0);
5428 }
5429
5430 /**
5431 * session needs to be set, always!
5432 */
5433
5434 if (session == NULL) session = (char *) PROGNAME;
5435
5436 /**
5437 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5438 */
5439
5440 char *exec_path = get_exec_path ();
5441
5442 #ifdef LINUX
5443
5444 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5445 char *resolved_exec_path = realpath (exec_path, NULL);
5446
5447 char *install_dir = get_install_dir (resolved_exec_path);
5448 char *profile_dir = NULL;
5449 char *session_dir = NULL;
5450 char *shared_dir = NULL;
5451
5452 if (strcmp (install_dir, resolved_install_folder) == 0)
5453 {
5454 struct passwd *pw = getpwuid (getuid ());
5455
5456 const char *homedir = pw->pw_dir;
5457
5458 profile_dir = get_profile_dir (homedir);
5459 session_dir = get_session_dir (profile_dir);
5460 shared_dir = strdup (SHARED_FOLDER);
5461
5462 mkdir (profile_dir, 0700);
5463 mkdir (session_dir, 0700);
5464 }
5465 else
5466 {
5467 profile_dir = install_dir;
5468 session_dir = install_dir;
5469 shared_dir = install_dir;
5470 }
5471
5472 myfree (resolved_install_folder);
5473 myfree (resolved_exec_path);
5474
5475 #else
5476
5477 char *install_dir = get_install_dir (exec_path);
5478 char *profile_dir = install_dir;
5479 char *session_dir = install_dir;
5480 char *shared_dir = install_dir;
5481
5482 #endif
5483
5484 data.install_dir = install_dir;
5485 data.profile_dir = profile_dir;
5486 data.session_dir = session_dir;
5487 data.shared_dir = shared_dir;
5488
5489 myfree (exec_path);
5490
5491 /**
5492 * kernel cache, we need to make sure folder exist
5493 */
5494
5495 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5496
5497 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5498
5499 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5500
5501 mkdir (kernels_folder, 0700);
5502
5503 myfree (kernels_folder);
5504
5505 /**
5506 * session
5507 */
5508
5509 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5510
5511 data.session = session;
5512
5513 char *eff_restore_file = (char *) mymalloc (session_size);
5514 char *new_restore_file = (char *) mymalloc (session_size);
5515
5516 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5517 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5518
5519 data.eff_restore_file = eff_restore_file;
5520 data.new_restore_file = new_restore_file;
5521
5522 if (((show == 1) || (left == 1)) && (restore == 1))
5523 {
5524 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5525 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5526
5527 return (-1);
5528 }
5529
5530 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5531 if ((show == 1) || (left == 1))
5532 {
5533 restore_disable = 1;
5534
5535 restore = 0;
5536 }
5537
5538 data.restore_disable = restore_disable;
5539
5540 restore_data_t *rd = init_restore (argc, argv);
5541
5542 data.rd = rd;
5543
5544 /**
5545 * restore file
5546 */
5547
5548 if (restore == 1)
5549 {
5550 read_restore (eff_restore_file, rd);
5551
5552 if (rd->version_bin < RESTORE_MIN)
5553 {
5554 log_error ("ERROR: Incompatible restore-file version");
5555
5556 return (-1);
5557 }
5558
5559 myargc = rd->argc;
5560 myargv = rd->argv;
5561
5562 #ifdef _POSIX
5563 rd->pid = getpid ();
5564 #elif _WIN
5565 rd->pid = GetCurrentProcessId ();
5566 #endif
5567 }
5568
5569 uint hash_mode_chgd = 0;
5570 uint runtime_chgd = 0;
5571 uint kernel_loops_chgd = 0;
5572 uint kernel_accel_chgd = 0;
5573 uint attack_mode_chgd = 0;
5574 uint outfile_format_chgd = 0;
5575 uint rp_gen_seed_chgd = 0;
5576 uint remove_timer_chgd = 0;
5577 uint increment_min_chgd = 0;
5578 uint increment_max_chgd = 0;
5579 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5580 uint gpu_temp_retain_chgd = 0;
5581 uint gpu_temp_abort_chgd = 0;
5582 #endif
5583
5584 optind = 1;
5585 optopt = 0;
5586 option_index = 0;
5587
5588 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5589 {
5590 switch (c)
5591 {
5592 //case IDX_HELP: usage = 1; break;
5593 //case IDX_VERSION: version = 1; break;
5594 //case IDX_RESTORE: restore = 1; break;
5595 case IDX_QUIET: quiet = 1; break;
5596 //case IDX_SHOW: show = 1; break;
5597 case IDX_SHOW: break;
5598 //case IDX_LEFT: left = 1; break;
5599 case IDX_LEFT: break;
5600 case IDX_USERNAME: username = 1; break;
5601 case IDX_REMOVE: remove = 1; break;
5602 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5603 remove_timer_chgd = 1; break;
5604 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5605 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5606 case IDX_DEBUG_FILE: debug_file = optarg; break;
5607 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5608 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5609 case IDX_FORCE: force = 1; break;
5610 case IDX_SKIP: skip = atoll (optarg); break;
5611 case IDX_LIMIT: limit = atoll (optarg); break;
5612 case IDX_KEYSPACE: keyspace = 1; break;
5613 case IDX_BENCHMARK: benchmark = 1; break;
5614 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5615 case IDX_RESTORE: break;
5616 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5617 case IDX_STATUS: status = 1; break;
5618 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5619 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5620 case IDX_LOOPBACK: loopback = 1; break;
5621 case IDX_WEAK_HASH_THRESHOLD:
5622 weak_hash_threshold = atoi (optarg); break;
5623 //case IDX_SESSION: session = optarg; break;
5624 case IDX_SESSION: break;
5625 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5626 hash_mode_chgd = 1; break;
5627 case IDX_RUNTIME: runtime = atoi (optarg);
5628 runtime_chgd = 1; break;
5629 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5630 attack_mode_chgd = 1; break;
5631 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5632 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5633 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5634 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5635 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5636 rp_gen_seed_chgd = 1; break;
5637 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5638 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5639 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5640 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5641 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5642 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5643 case IDX_OUTFILE: outfile = optarg; break;
5644 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5645 outfile_format_chgd = 1; break;
5646 case IDX_OUTFILE_AUTOHEX_DISABLE:
5647 outfile_autohex = 0; break;
5648 case IDX_OUTFILE_CHECK_TIMER:
5649 outfile_check_timer = atoi (optarg); break;
5650 case IDX_HEX_CHARSET: hex_charset = 1; break;
5651 case IDX_HEX_SALT: hex_salt = 1; break;
5652 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5653 #ifndef OSX
5654 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5655 #endif
5656 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5657 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5658 case IDX_OPENCL_DEVICE_TYPES:
5659 opencl_device_types = optarg; break;
5660 case IDX_OPENCL_VECTOR_WIDTH:
5661 opencl_vector_width = atoi (optarg); break;
5662 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5663 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5664 kernel_accel_chgd = 1; break;
5665 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5666 kernel_loops_chgd = 1; break;
5667 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5668 #ifdef HAVE_HWMON
5669 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5670 #ifdef HAVE_ADL
5671 gpu_temp_abort_chgd = 1;
5672 #endif
5673 break;
5674 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5675 #ifdef HAVE_ADL
5676 gpu_temp_retain_chgd = 1;
5677 #endif
5678 break;
5679 #ifdef HAVE_ADL
5680 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5681 #endif
5682 #endif // HAVE_HWMON
5683 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5684 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5685 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5686 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5687 case IDX_SEPARATOR: separator = optarg[0]; break;
5688 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5689 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5690 case IDX_INCREMENT: increment = 1; break;
5691 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5692 increment_min_chgd = 1; break;
5693 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5694 increment_max_chgd = 1; break;
5695 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5696 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5697 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5698 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5699
5700 default:
5701 log_error ("ERROR: Invalid argument specified");
5702 return (-1);
5703 }
5704 }
5705
5706 if (optopt != 0)
5707 {
5708 log_error ("ERROR: Invalid argument specified");
5709
5710 return (-1);
5711 }
5712
5713 /**
5714 * Inform user things getting started,
5715 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5716 * - we do not need to check algorithm_pos
5717 */
5718
5719 if (quiet == 0)
5720 {
5721 if (benchmark == 1)
5722 {
5723 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5724
5725 log_info ("");
5726 }
5727 else if (restore == 1)
5728 {
5729 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5730
5731 log_info ("");
5732 }
5733 else
5734 {
5735 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5736
5737 log_info ("");
5738 }
5739 }
5740
5741 /**
5742 * sanity check
5743 */
5744
5745 if (attack_mode > 7)
5746 {
5747 log_error ("ERROR: Invalid attack-mode specified");
5748
5749 return (-1);
5750 }
5751
5752 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5753 {
5754 log_error ("ERROR: Invalid runtime specified");
5755
5756 return (-1);
5757 }
5758
5759 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5760 {
5761 log_error ("ERROR: Invalid hash-type specified");
5762
5763 return (-1);
5764 }
5765
5766 // renamed hash modes
5767
5768 if (hash_mode_chgd)
5769 {
5770 int n = -1;
5771
5772 switch (hash_mode)
5773 {
5774 case 123: n = 124;
5775 break;
5776 }
5777
5778 if (n >= 0)
5779 {
5780 log_error ("Old -m specified, use -m %d instead", n);
5781
5782 return (-1);
5783 }
5784 }
5785
5786 if (username == 1)
5787 {
5788 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5789 {
5790 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5791
5792 return (-1);
5793 }
5794 }
5795
5796 if (outfile_format > 16)
5797 {
5798 log_error ("ERROR: Invalid outfile-format specified");
5799
5800 return (-1);
5801 }
5802
5803 if (left == 1)
5804 {
5805 if (outfile_format_chgd == 1)
5806 {
5807 if (outfile_format > 1)
5808 {
5809 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5810
5811 return (-1);
5812 }
5813 }
5814 else
5815 {
5816 outfile_format = OUTFILE_FMT_HASH;
5817 }
5818 }
5819
5820 if (show == 1)
5821 {
5822 if (outfile_format_chgd == 1)
5823 {
5824 if ((outfile_format > 7) && (outfile_format < 16))
5825 {
5826 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5827
5828 return (-1);
5829 }
5830 }
5831 }
5832
5833 if (increment_min < INCREMENT_MIN)
5834 {
5835 log_error ("ERROR: Invalid increment-min specified");
5836
5837 return (-1);
5838 }
5839
5840 if (increment_max > INCREMENT_MAX)
5841 {
5842 log_error ("ERROR: Invalid increment-max specified");
5843
5844 return (-1);
5845 }
5846
5847 if (increment_min > increment_max)
5848 {
5849 log_error ("ERROR: Invalid increment-min specified");
5850
5851 return (-1);
5852 }
5853
5854 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5855 {
5856 log_error ("ERROR: increment is not allowed in attack-mode 0");
5857
5858 return (-1);
5859 }
5860
5861 if ((increment == 0) && (increment_min_chgd == 1))
5862 {
5863 log_error ("ERROR: increment-min is only supported together with increment switch");
5864
5865 return (-1);
5866 }
5867
5868 if ((increment == 0) && (increment_max_chgd == 1))
5869 {
5870 log_error ("ERROR: increment-max is only supported together with increment switch");
5871
5872 return (-1);
5873 }
5874
5875 if (rp_files_cnt && rp_gen)
5876 {
5877 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5878
5879 return (-1);
5880 }
5881
5882 if (rp_files_cnt || rp_gen)
5883 {
5884 if (attack_mode != ATTACK_MODE_STRAIGHT)
5885 {
5886 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5887
5888 return (-1);
5889 }
5890 }
5891
5892 if (rp_gen_func_min > rp_gen_func_max)
5893 {
5894 log_error ("ERROR: Invalid rp-gen-func-min specified");
5895
5896 return (-1);
5897 }
5898
5899 if (kernel_accel_chgd == 1)
5900 {
5901 if (workload_profile != WORKLOAD_PROFILE)
5902 {
5903 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5904
5905 return (-1);
5906 }
5907
5908 if (kernel_accel < 1)
5909 {
5910 log_error ("ERROR: Invalid kernel-accel specified");
5911
5912 return (-1);
5913 }
5914
5915 if (kernel_accel > 800)
5916 {
5917 log_error ("ERROR: Invalid kernel-accel specified");
5918
5919 return (-1);
5920 }
5921 }
5922
5923 if (kernel_loops_chgd == 1)
5924 {
5925 if (workload_profile != WORKLOAD_PROFILE)
5926 {
5927 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5928
5929 return (-1);
5930 }
5931
5932 if (kernel_loops < 1)
5933 {
5934 log_error ("ERROR: Invalid kernel-loops specified");
5935
5936 return (-1);
5937 }
5938
5939 if (kernel_loops > 1024)
5940 {
5941 log_error ("ERROR: Invalid kernel-loops specified");
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (benchmark == 1)
5948 {
5949 if (workload_profile != WORKLOAD_PROFILE)
5950 {
5951 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5952
5953 return (-1);
5954 }
5955 }
5956
5957 if ((workload_profile < 1) || (workload_profile > 3))
5958 {
5959 log_error ("ERROR: workload-profile %i not available", workload_profile);
5960
5961 return (-1);
5962 }
5963
5964 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5965 {
5966 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5967
5968 return (-1);
5969 }
5970
5971 if (show == 1 || left == 1)
5972 {
5973 attack_mode = ATTACK_MODE_NONE;
5974
5975 if (remove == 1)
5976 {
5977 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5978
5979 return (-1);
5980 }
5981
5982 if (potfile_disable == 1)
5983 {
5984 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5985
5986 return (-1);
5987 }
5988 }
5989
5990 uint attack_kern = ATTACK_KERN_NONE;
5991
5992 switch (attack_mode)
5993 {
5994 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5995 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5996 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5997 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5998 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5999 }
6000
6001 if (benchmark == 0)
6002 {
6003 if (keyspace == 1)
6004 {
6005 int num_additional_params = 1;
6006
6007 if (attack_kern == ATTACK_KERN_COMBI)
6008 {
6009 num_additional_params = 2;
6010 }
6011
6012 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6013
6014 if (keyspace_wordlist_specified == 0) optind--;
6015 }
6016
6017 if (attack_kern == ATTACK_KERN_NONE)
6018 {
6019 if ((optind + 1) != myargc)
6020 {
6021 usage_mini_print (myargv[0]);
6022
6023 return (-1);
6024 }
6025 }
6026 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6027 {
6028 if ((optind + 1) > myargc)
6029 {
6030 usage_mini_print (myargv[0]);
6031
6032 return (-1);
6033 }
6034 }
6035 else if (attack_kern == ATTACK_KERN_COMBI)
6036 {
6037 if ((optind + 3) != myargc)
6038 {
6039 usage_mini_print (myargv[0]);
6040
6041 return (-1);
6042 }
6043 }
6044 else if (attack_kern == ATTACK_KERN_BF)
6045 {
6046 if ((optind + 1) > myargc)
6047 {
6048 usage_mini_print (myargv[0]);
6049
6050 return (-1);
6051 }
6052 }
6053 else
6054 {
6055 usage_mini_print (myargv[0]);
6056
6057 return (-1);
6058 }
6059 }
6060 else
6061 {
6062 if (myargv[optind] != 0)
6063 {
6064 log_error ("ERROR: Invalid argument for benchmark mode specified");
6065
6066 return (-1);
6067 }
6068
6069 if (attack_mode_chgd == 1)
6070 {
6071 if (attack_mode != ATTACK_MODE_BF)
6072 {
6073 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6074
6075 return (-1);
6076 }
6077 }
6078
6079 if (benchmark_mode == 0)
6080 {
6081 // nothing to do
6082 }
6083 else if (benchmark_mode == 1)
6084 {
6085 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6086 {
6087 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6088
6089 return (-1);
6090 }
6091 }
6092 else
6093 {
6094 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (skip != 0 && limit != 0)
6101 {
6102 limit += skip;
6103 }
6104
6105 if (keyspace == 1)
6106 {
6107 if (show == 1)
6108 {
6109 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6110
6111 return (-1);
6112 }
6113 else if (left == 1)
6114 {
6115 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6116
6117 return (-1);
6118 }
6119
6120 potfile_disable = 1;
6121
6122 restore_disable = 1;
6123
6124 restore = 0;
6125
6126 weak_hash_threshold = 0;
6127
6128 quiet = 1;
6129 }
6130
6131 if (remove_timer_chgd == 1)
6132 {
6133 if (remove == 0)
6134 {
6135 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6136
6137 return (-1);
6138 }
6139
6140 if (remove_timer < 1)
6141 {
6142 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6143
6144 return (-1);
6145 }
6146 }
6147
6148 if (loopback == 1)
6149 {
6150 if (attack_mode == ATTACK_MODE_BF)
6151 {
6152 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6153
6154 return (-1);
6155 }
6156 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6157 {
6158 if ((rp_files_cnt == 0) && (rp_gen == 0))
6159 {
6160 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6161
6162 return (-1);
6163 }
6164 }
6165 }
6166
6167 if (debug_mode > 0)
6168 {
6169 if (attack_mode != ATTACK_MODE_STRAIGHT)
6170 {
6171 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6172
6173 return (-1);
6174 }
6175
6176 if ((rp_files_cnt == 0) && (rp_gen == 0))
6177 {
6178 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6179
6180 return (-1);
6181 }
6182 }
6183
6184 if (debug_mode > 4)
6185 {
6186 log_error ("ERROR: Invalid debug-mode specified");
6187
6188 return (-1);
6189 }
6190
6191 if (debug_file != NULL)
6192 {
6193 if (debug_mode < 1)
6194 {
6195 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6196
6197 return (-1);
6198 }
6199 }
6200
6201 if (induction_dir != NULL)
6202 {
6203 if (attack_mode == ATTACK_MODE_BF)
6204 {
6205 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6206
6207 return (-1);
6208 }
6209 }
6210
6211 if (attack_mode != ATTACK_MODE_STRAIGHT)
6212 {
6213 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6214 {
6215 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6216
6217 return (-1);
6218 }
6219
6220 weak_hash_threshold = 0;
6221 }
6222
6223 /**
6224 * induction directory
6225 */
6226
6227 char *induction_directory = NULL;
6228
6229 if (attack_mode != ATTACK_MODE_BF)
6230 {
6231 if (induction_dir == NULL)
6232 {
6233 induction_directory = (char *) mymalloc (session_size);
6234
6235 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6236
6237 // create induction folder if it does not already exist
6238
6239 if (keyspace == 0)
6240 {
6241 if (rmdir (induction_directory) == -1)
6242 {
6243 if (errno == ENOENT)
6244 {
6245 // good, we can ignore
6246 }
6247 else if (errno == ENOTEMPTY)
6248 {
6249 char *induction_directory_mv = (char *) mymalloc (session_size);
6250
6251 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6252
6253 if (rename (induction_directory, induction_directory_mv) != 0)
6254 {
6255 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6256
6257 return (-1);
6258 }
6259 }
6260 else
6261 {
6262 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6263
6264 return (-1);
6265 }
6266 }
6267
6268 if (mkdir (induction_directory, 0700) == -1)
6269 {
6270 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6271
6272 return (-1);
6273 }
6274 }
6275 }
6276 else
6277 {
6278 induction_directory = induction_dir;
6279 }
6280 }
6281
6282 data.induction_directory = induction_directory;
6283
6284 /**
6285 * loopback
6286 */
6287
6288 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6289
6290 char *loopback_file = (char *) mymalloc (loopback_size);
6291
6292 /**
6293 * outfile-check directory
6294 */
6295
6296 char *outfile_check_directory = NULL;
6297
6298 if (outfile_check_dir == NULL)
6299 {
6300 outfile_check_directory = (char *) mymalloc (session_size);
6301
6302 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6303 }
6304 else
6305 {
6306 outfile_check_directory = outfile_check_dir;
6307 }
6308
6309 data.outfile_check_directory = outfile_check_directory;
6310
6311 if (keyspace == 0)
6312 {
6313 struct stat outfile_check_stat;
6314
6315 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6316 {
6317 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6318
6319 if (is_dir == 0)
6320 {
6321 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6322
6323 return (-1);
6324 }
6325 }
6326 else if (outfile_check_dir == NULL)
6327 {
6328 if (mkdir (outfile_check_directory, 0700) == -1)
6329 {
6330 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6331
6332 return (-1);
6333 }
6334 }
6335 }
6336
6337 /**
6338 * special other stuff
6339 */
6340
6341 if (hash_mode == 9710)
6342 {
6343 outfile_format = 5;
6344 outfile_format_chgd = 1;
6345 }
6346
6347 if (hash_mode == 9810)
6348 {
6349 outfile_format = 5;
6350 outfile_format_chgd = 1;
6351 }
6352
6353 if (hash_mode == 10410)
6354 {
6355 outfile_format = 5;
6356 outfile_format_chgd = 1;
6357 }
6358
6359 /**
6360 * store stuff
6361 */
6362
6363 data.hash_mode = hash_mode;
6364 data.restore = restore;
6365 data.restore_timer = restore_timer;
6366 data.restore_disable = restore_disable;
6367 data.status = status;
6368 data.status_timer = status_timer;
6369 data.status_automat = status_automat;
6370 data.loopback = loopback;
6371 data.runtime = runtime;
6372 data.remove = remove;
6373 data.remove_timer = remove_timer;
6374 data.debug_mode = debug_mode;
6375 data.debug_file = debug_file;
6376 data.username = username;
6377 data.quiet = quiet;
6378 data.outfile = outfile;
6379 data.outfile_format = outfile_format;
6380 data.outfile_autohex = outfile_autohex;
6381 data.hex_charset = hex_charset;
6382 data.hex_salt = hex_salt;
6383 data.hex_wordlist = hex_wordlist;
6384 data.separator = separator;
6385 data.rp_files = rp_files;
6386 data.rp_files_cnt = rp_files_cnt;
6387 data.rp_gen = rp_gen;
6388 data.rp_gen_seed = rp_gen_seed;
6389 data.force = force;
6390 data.benchmark = benchmark;
6391 data.skip = skip;
6392 data.limit = limit;
6393 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6394 data.powertune_enable = powertune_enable;
6395 #endif
6396 data.logfile_disable = logfile_disable;
6397 data.truecrypt_keyfiles = truecrypt_keyfiles;
6398 data.scrypt_tmto = scrypt_tmto;
6399
6400 /**
6401 * cpu affinity
6402 */
6403
6404 #ifndef OSX
6405 if (cpu_affinity)
6406 {
6407 set_cpu_affinity (cpu_affinity);
6408 }
6409 #endif
6410
6411 if (rp_gen_seed_chgd == 0)
6412 {
6413 srand (proc_start);
6414 }
6415 else
6416 {
6417 srand (rp_gen_seed);
6418 }
6419
6420 /**
6421 * logfile init
6422 */
6423
6424 if (logfile_disable == 0)
6425 {
6426 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6427
6428 char *logfile = (char *) mymalloc (logfile_size);
6429
6430 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6431
6432 data.logfile = logfile;
6433
6434 char *topid = logfile_generate_topid ();
6435
6436 data.topid = topid;
6437 }
6438
6439 // logfile_append() checks for logfile_disable internally to make it easier from here
6440
6441 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6442 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6443 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6444 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6445 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6446 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6447 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6448 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6449 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6450 #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));
6451
6452 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6453 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6454 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6455 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6456 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6457 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6458 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6459 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6460
6461 logfile_top_msg ("START");
6462
6463 logfile_top_uint (attack_mode);
6464 logfile_top_uint (attack_kern);
6465 logfile_top_uint (benchmark);
6466 logfile_top_uint (benchmark_mode);
6467 logfile_top_uint (bitmap_min);
6468 logfile_top_uint (bitmap_max);
6469 logfile_top_uint (debug_mode);
6470 logfile_top_uint (force);
6471 logfile_top_uint (kernel_accel);
6472 logfile_top_uint (kernel_loops);
6473 logfile_top_uint (gpu_temp_disable);
6474 #ifdef HAVE_HWMON
6475 logfile_top_uint (gpu_temp_abort);
6476 logfile_top_uint (gpu_temp_retain);
6477 #endif
6478 logfile_top_uint (hash_mode);
6479 logfile_top_uint (hex_charset);
6480 logfile_top_uint (hex_salt);
6481 logfile_top_uint (hex_wordlist);
6482 logfile_top_uint (increment);
6483 logfile_top_uint (increment_max);
6484 logfile_top_uint (increment_min);
6485 logfile_top_uint (keyspace);
6486 logfile_top_uint (left);
6487 logfile_top_uint (logfile_disable);
6488 logfile_top_uint (loopback);
6489 logfile_top_uint (markov_classic);
6490 logfile_top_uint (markov_disable);
6491 logfile_top_uint (markov_threshold);
6492 logfile_top_uint (outfile_autohex);
6493 logfile_top_uint (outfile_check_timer);
6494 logfile_top_uint (outfile_format);
6495 logfile_top_uint (potfile_disable);
6496 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6497 logfile_top_uint (powertune_enable);
6498 #endif
6499 logfile_top_uint (scrypt_tmto);
6500 logfile_top_uint (quiet);
6501 logfile_top_uint (remove);
6502 logfile_top_uint (remove_timer);
6503 logfile_top_uint (restore);
6504 logfile_top_uint (restore_disable);
6505 logfile_top_uint (restore_timer);
6506 logfile_top_uint (rp_gen);
6507 logfile_top_uint (rp_gen_func_max);
6508 logfile_top_uint (rp_gen_func_min);
6509 logfile_top_uint (rp_gen_seed);
6510 logfile_top_uint (runtime);
6511 logfile_top_uint (segment_size);
6512 logfile_top_uint (show);
6513 logfile_top_uint (status);
6514 logfile_top_uint (status_automat);
6515 logfile_top_uint (status_timer);
6516 logfile_top_uint (usage);
6517 logfile_top_uint (username);
6518 logfile_top_uint (version);
6519 logfile_top_uint (weak_hash_threshold);
6520 logfile_top_uint (workload_profile);
6521 logfile_top_uint64 (limit);
6522 logfile_top_uint64 (skip);
6523 logfile_top_char (separator);
6524 #ifndef OSX
6525 logfile_top_string (cpu_affinity);
6526 #endif
6527 logfile_top_string (custom_charset_1);
6528 logfile_top_string (custom_charset_2);
6529 logfile_top_string (custom_charset_3);
6530 logfile_top_string (custom_charset_4);
6531 logfile_top_string (debug_file);
6532 logfile_top_string (opencl_devices);
6533 logfile_top_string (opencl_platforms);
6534 logfile_top_string (opencl_device_types);
6535 logfile_top_uint (opencl_vector_width);
6536 logfile_top_string (induction_dir);
6537 logfile_top_string (markov_hcstat);
6538 logfile_top_string (outfile);
6539 logfile_top_string (outfile_check_dir);
6540 logfile_top_string (rule_buf_l);
6541 logfile_top_string (rule_buf_r);
6542 logfile_top_string (session);
6543 logfile_top_string (truecrypt_keyfiles);
6544
6545 /**
6546 * Init OpenCL library loader
6547 */
6548
6549 if (keyspace == 0)
6550 {
6551 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6552
6553 ocl_init (ocl);
6554
6555 data.ocl = ocl;
6556 }
6557
6558 /**
6559 * OpenCL platform selection
6560 */
6561
6562 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6563
6564 /**
6565 * OpenCL device selection
6566 */
6567
6568 u32 devices_filter = setup_devices_filter (opencl_devices);
6569
6570 /**
6571 * OpenCL device type selection
6572 */
6573
6574 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6575
6576 /**
6577 * benchmark
6578 */
6579
6580 if (benchmark == 1)
6581 {
6582 /**
6583 * disable useless stuff for benchmark
6584 */
6585
6586 restore_timer = 0;
6587 status_timer = 0;
6588 restore_disable = 1;
6589 potfile_disable = 1;
6590 weak_hash_threshold = 0;
6591
6592 data.restore_timer = restore_timer;
6593 data.status_timer = status_timer;
6594 data.restore_disable = restore_disable;
6595
6596 if (benchmark_mode == 1)
6597 {
6598 markov_disable = 1;
6599 }
6600
6601 /**
6602 * force attack mode to be bruteforce
6603 */
6604
6605 attack_mode = ATTACK_MODE_BF;
6606 attack_kern = ATTACK_KERN_BF;
6607
6608 if (runtime_chgd == 0)
6609 {
6610 runtime = 8;
6611
6612 if (benchmark_mode == 1) runtime = 17;
6613
6614 data.runtime = runtime;
6615 }
6616 }
6617
6618 /**
6619 * config
6620 */
6621
6622 uint hash_type = 0;
6623 uint salt_type = 0;
6624 uint attack_exec = 0;
6625 uint opts_type = 0;
6626 uint kern_type = 0;
6627 uint dgst_size = 0;
6628 uint esalt_size = 0;
6629 uint opti_type = 0;
6630 uint dgst_pos0 = -1;
6631 uint dgst_pos1 = -1;
6632 uint dgst_pos2 = -1;
6633 uint dgst_pos3 = -1;
6634
6635 int (*parse_func) (char *, uint, hash_t *);
6636 int (*sort_by_digest) (const void *, const void *);
6637
6638 uint algorithm_pos = 0;
6639 uint algorithm_max = 1;
6640
6641 uint *algorithms = default_benchmark_algorithms;
6642
6643 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6644
6645 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6646 {
6647 /*
6648 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6649 * the following algos are skipped entirely
6650 */
6651
6652 if (algorithm_pos > 0)
6653 {
6654 local_free (rd);
6655
6656 rd = init_restore (argc, argv);
6657
6658 data.rd = rd;
6659 }
6660
6661 /**
6662 * update hash_mode in case of multihash benchmark
6663 */
6664
6665 if (benchmark == 1)
6666 {
6667 if (hash_mode_chgd == 0)
6668 {
6669 hash_mode = algorithms[algorithm_pos];
6670
6671 data.hash_mode = hash_mode;
6672 }
6673
6674 quiet = 1;
6675
6676 data.quiet = quiet;
6677 }
6678
6679 switch (hash_mode)
6680 {
6681 case 0: hash_type = HASH_TYPE_MD5;
6682 salt_type = SALT_TYPE_NONE;
6683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6684 opts_type = OPTS_TYPE_PT_GENERATE_LE
6685 | OPTS_TYPE_PT_ADD80
6686 | OPTS_TYPE_PT_ADDBITS14;
6687 kern_type = KERN_TYPE_MD5;
6688 dgst_size = DGST_SIZE_4_4;
6689 parse_func = md5_parse_hash;
6690 sort_by_digest = sort_by_digest_4_4;
6691 opti_type = OPTI_TYPE_ZERO_BYTE
6692 | OPTI_TYPE_PRECOMPUTE_INIT
6693 | OPTI_TYPE_PRECOMPUTE_MERKLE
6694 | OPTI_TYPE_MEET_IN_MIDDLE
6695 | OPTI_TYPE_EARLY_SKIP
6696 | OPTI_TYPE_NOT_ITERATED
6697 | OPTI_TYPE_NOT_SALTED
6698 | OPTI_TYPE_RAW_HASH;
6699 dgst_pos0 = 0;
6700 dgst_pos1 = 3;
6701 dgst_pos2 = 2;
6702 dgst_pos3 = 1;
6703 break;
6704
6705 case 10: hash_type = HASH_TYPE_MD5;
6706 salt_type = SALT_TYPE_INTERN;
6707 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6708 opts_type = OPTS_TYPE_PT_GENERATE_LE
6709 | OPTS_TYPE_ST_ADD80
6710 | OPTS_TYPE_ST_ADDBITS14;
6711 kern_type = KERN_TYPE_MD5_PWSLT;
6712 dgst_size = DGST_SIZE_4_4;
6713 parse_func = md5s_parse_hash;
6714 sort_by_digest = sort_by_digest_4_4;
6715 opti_type = OPTI_TYPE_ZERO_BYTE
6716 | OPTI_TYPE_PRECOMPUTE_INIT
6717 | OPTI_TYPE_PRECOMPUTE_MERKLE
6718 | OPTI_TYPE_MEET_IN_MIDDLE
6719 | OPTI_TYPE_EARLY_SKIP
6720 | OPTI_TYPE_NOT_ITERATED
6721 | OPTI_TYPE_APPENDED_SALT
6722 | OPTI_TYPE_RAW_HASH;
6723 dgst_pos0 = 0;
6724 dgst_pos1 = 3;
6725 dgst_pos2 = 2;
6726 dgst_pos3 = 1;
6727 break;
6728
6729 case 11: hash_type = HASH_TYPE_MD5;
6730 salt_type = SALT_TYPE_INTERN;
6731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6732 opts_type = OPTS_TYPE_PT_GENERATE_LE
6733 | OPTS_TYPE_ST_ADD80
6734 | OPTS_TYPE_ST_ADDBITS14;
6735 kern_type = KERN_TYPE_MD5_PWSLT;
6736 dgst_size = DGST_SIZE_4_4;
6737 parse_func = joomla_parse_hash;
6738 sort_by_digest = sort_by_digest_4_4;
6739 opti_type = OPTI_TYPE_ZERO_BYTE
6740 | OPTI_TYPE_PRECOMPUTE_INIT
6741 | OPTI_TYPE_PRECOMPUTE_MERKLE
6742 | OPTI_TYPE_MEET_IN_MIDDLE
6743 | OPTI_TYPE_EARLY_SKIP
6744 | OPTI_TYPE_NOT_ITERATED
6745 | OPTI_TYPE_APPENDED_SALT
6746 | OPTI_TYPE_RAW_HASH;
6747 dgst_pos0 = 0;
6748 dgst_pos1 = 3;
6749 dgst_pos2 = 2;
6750 dgst_pos3 = 1;
6751 break;
6752
6753 case 12: hash_type = HASH_TYPE_MD5;
6754 salt_type = SALT_TYPE_INTERN;
6755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6756 opts_type = OPTS_TYPE_PT_GENERATE_LE
6757 | OPTS_TYPE_ST_ADD80
6758 | OPTS_TYPE_ST_ADDBITS14;
6759 kern_type = KERN_TYPE_MD5_PWSLT;
6760 dgst_size = DGST_SIZE_4_4;
6761 parse_func = postgresql_parse_hash;
6762 sort_by_digest = sort_by_digest_4_4;
6763 opti_type = OPTI_TYPE_ZERO_BYTE
6764 | OPTI_TYPE_PRECOMPUTE_INIT
6765 | OPTI_TYPE_PRECOMPUTE_MERKLE
6766 | OPTI_TYPE_MEET_IN_MIDDLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_APPENDED_SALT
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 0;
6772 dgst_pos1 = 3;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 20: hash_type = HASH_TYPE_MD5;
6778 salt_type = SALT_TYPE_INTERN;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_LE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS14;
6783 kern_type = KERN_TYPE_MD5_SLTPW;
6784 dgst_size = DGST_SIZE_4_4;
6785 parse_func = md5s_parse_hash;
6786 sort_by_digest = sort_by_digest_4_4;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_PREPENDED_SALT
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 0;
6795 dgst_pos1 = 3;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 21: hash_type = HASH_TYPE_MD5;
6801 salt_type = SALT_TYPE_INTERN;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_LE
6804 | OPTS_TYPE_PT_ADD80
6805 | OPTS_TYPE_PT_ADDBITS14;
6806 kern_type = KERN_TYPE_MD5_SLTPW;
6807 dgst_size = DGST_SIZE_4_4;
6808 parse_func = osc_parse_hash;
6809 sort_by_digest = sort_by_digest_4_4;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_PREPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 0;
6818 dgst_pos1 = 3;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 22: hash_type = HASH_TYPE_MD5;
6824 salt_type = SALT_TYPE_EMBEDDED;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_LE
6827 | OPTS_TYPE_PT_ADD80
6828 | OPTS_TYPE_PT_ADDBITS14;
6829 kern_type = KERN_TYPE_MD5_SLTPW;
6830 dgst_size = DGST_SIZE_4_4;
6831 parse_func = netscreen_parse_hash;
6832 sort_by_digest = sort_by_digest_4_4;
6833 opti_type = OPTI_TYPE_ZERO_BYTE
6834 | OPTI_TYPE_PRECOMPUTE_INIT
6835 | OPTI_TYPE_PRECOMPUTE_MERKLE
6836 | OPTI_TYPE_EARLY_SKIP
6837 | OPTI_TYPE_NOT_ITERATED
6838 | OPTI_TYPE_PREPENDED_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 23: hash_type = HASH_TYPE_MD5;
6847 salt_type = SALT_TYPE_EMBEDDED;
6848 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6849 opts_type = OPTS_TYPE_PT_GENERATE_LE
6850 | OPTS_TYPE_PT_ADD80
6851 | OPTS_TYPE_PT_ADDBITS14;
6852 kern_type = KERN_TYPE_MD5_SLTPW;
6853 dgst_size = DGST_SIZE_4_4;
6854 parse_func = skype_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_EARLY_SKIP
6860 | OPTI_TYPE_NOT_ITERATED
6861 | OPTI_TYPE_PREPENDED_SALT
6862 | OPTI_TYPE_RAW_HASH;
6863 dgst_pos0 = 0;
6864 dgst_pos1 = 3;
6865 dgst_pos2 = 2;
6866 dgst_pos3 = 1;
6867 break;
6868
6869 case 30: hash_type = HASH_TYPE_MD5;
6870 salt_type = SALT_TYPE_INTERN;
6871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6872 opts_type = OPTS_TYPE_PT_GENERATE_LE
6873 | OPTS_TYPE_PT_UNICODE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS14;
6876 kern_type = KERN_TYPE_MD5_PWUSLT;
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_MEET_IN_MIDDLE
6884 | OPTI_TYPE_EARLY_SKIP
6885 | OPTI_TYPE_NOT_ITERATED
6886 | OPTI_TYPE_APPENDED_SALT
6887 | OPTI_TYPE_RAW_HASH;
6888 dgst_pos0 = 0;
6889 dgst_pos1 = 3;
6890 dgst_pos2 = 2;
6891 dgst_pos3 = 1;
6892 break;
6893
6894 case 40: hash_type = HASH_TYPE_MD5;
6895 salt_type = SALT_TYPE_INTERN;
6896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6897 opts_type = OPTS_TYPE_PT_GENERATE_LE
6898 | OPTS_TYPE_PT_ADD80
6899 | OPTS_TYPE_PT_ADDBITS14
6900 | OPTS_TYPE_PT_UNICODE;
6901 kern_type = KERN_TYPE_MD5_SLTPWU;
6902 dgst_size = DGST_SIZE_4_4;
6903 parse_func = md5s_parse_hash;
6904 sort_by_digest = sort_by_digest_4_4;
6905 opti_type = OPTI_TYPE_ZERO_BYTE
6906 | OPTI_TYPE_PRECOMPUTE_INIT
6907 | OPTI_TYPE_PRECOMPUTE_MERKLE
6908 | OPTI_TYPE_EARLY_SKIP
6909 | OPTI_TYPE_NOT_ITERATED
6910 | OPTI_TYPE_PREPENDED_SALT
6911 | OPTI_TYPE_RAW_HASH;
6912 dgst_pos0 = 0;
6913 dgst_pos1 = 3;
6914 dgst_pos2 = 2;
6915 dgst_pos3 = 1;
6916 break;
6917
6918 case 50: hash_type = HASH_TYPE_MD5;
6919 salt_type = SALT_TYPE_INTERN;
6920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6921 opts_type = OPTS_TYPE_PT_GENERATE_LE
6922 | OPTS_TYPE_ST_ADD80
6923 | OPTS_TYPE_ST_ADDBITS14;
6924 kern_type = KERN_TYPE_HMACMD5_PW;
6925 dgst_size = DGST_SIZE_4_4;
6926 parse_func = hmacmd5_parse_hash;
6927 sort_by_digest = sort_by_digest_4_4;
6928 opti_type = OPTI_TYPE_ZERO_BYTE
6929 | OPTI_TYPE_NOT_ITERATED;
6930 dgst_pos0 = 0;
6931 dgst_pos1 = 3;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 60: hash_type = HASH_TYPE_MD5;
6937 salt_type = SALT_TYPE_INTERN;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_LE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS14;
6942 kern_type = KERN_TYPE_HMACMD5_SLT;
6943 dgst_size = DGST_SIZE_4_4;
6944 parse_func = hmacmd5_parse_hash;
6945 sort_by_digest = sort_by_digest_4_4;
6946 opti_type = OPTI_TYPE_ZERO_BYTE
6947 | OPTI_TYPE_NOT_ITERATED;
6948 dgst_pos0 = 0;
6949 dgst_pos1 = 3;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 100: hash_type = HASH_TYPE_SHA1;
6955 salt_type = SALT_TYPE_NONE;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_BE
6958 | OPTS_TYPE_PT_ADD80
6959 | OPTS_TYPE_PT_ADDBITS15;
6960 kern_type = KERN_TYPE_SHA1;
6961 dgst_size = DGST_SIZE_4_5;
6962 parse_func = sha1_parse_hash;
6963 sort_by_digest = sort_by_digest_4_5;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_NOT_SALTED
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 3;
6972 dgst_pos1 = 4;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 101: hash_type = HASH_TYPE_SHA1;
6978 salt_type = SALT_TYPE_NONE;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_BE
6981 | OPTS_TYPE_PT_ADD80
6982 | OPTS_TYPE_PT_ADDBITS15;
6983 kern_type = KERN_TYPE_SHA1;
6984 dgst_size = DGST_SIZE_4_5;
6985 parse_func = sha1b64_parse_hash;
6986 sort_by_digest = sort_by_digest_4_5;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_NOT_SALTED
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 3;
6995 dgst_pos1 = 4;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 110: hash_type = HASH_TYPE_SHA1;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_BE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS15;
7006 kern_type = KERN_TYPE_SHA1_PWSLT;
7007 dgst_size = DGST_SIZE_4_5;
7008 parse_func = sha1s_parse_hash;
7009 sort_by_digest = sort_by_digest_4_5;
7010 opti_type = OPTI_TYPE_ZERO_BYTE
7011 | OPTI_TYPE_PRECOMPUTE_INIT
7012 | OPTI_TYPE_PRECOMPUTE_MERKLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_APPENDED_SALT
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 3;
7018 dgst_pos1 = 4;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 111: hash_type = HASH_TYPE_SHA1;
7024 salt_type = SALT_TYPE_EMBEDDED;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_BE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS15;
7029 kern_type = KERN_TYPE_SHA1_PWSLT;
7030 dgst_size = DGST_SIZE_4_5;
7031 parse_func = sha1b64s_parse_hash;
7032 sort_by_digest = sort_by_digest_4_5;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_PRECOMPUTE_INIT
7035 | OPTI_TYPE_PRECOMPUTE_MERKLE
7036 | OPTI_TYPE_EARLY_SKIP
7037 | OPTI_TYPE_NOT_ITERATED
7038 | OPTI_TYPE_APPENDED_SALT
7039 | OPTI_TYPE_RAW_HASH;
7040 dgst_pos0 = 3;
7041 dgst_pos1 = 4;
7042 dgst_pos2 = 2;
7043 dgst_pos3 = 1;
7044 break;
7045
7046 case 112: hash_type = HASH_TYPE_SHA1;
7047 salt_type = SALT_TYPE_INTERN;
7048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7049 opts_type = OPTS_TYPE_PT_GENERATE_BE
7050 | OPTS_TYPE_ST_ADD80
7051 | OPTS_TYPE_ST_ADDBITS15
7052 | OPTS_TYPE_ST_HEX;
7053 kern_type = KERN_TYPE_SHA1_PWSLT;
7054 dgst_size = DGST_SIZE_4_5;
7055 parse_func = oracles_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_APPENDED_SALT
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 120: hash_type = HASH_TYPE_SHA1;
7071 salt_type = SALT_TYPE_INTERN;
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_SLTPW;
7077 dgst_size = DGST_SIZE_4_5;
7078 parse_func = sha1s_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_PREPENDED_SALT
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 121: 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_PT_ADD80
7098 | OPTS_TYPE_PT_ADDBITS15
7099 | OPTS_TYPE_ST_LOWER;
7100 kern_type = KERN_TYPE_SHA1_SLTPW;
7101 dgst_size = DGST_SIZE_4_5;
7102 parse_func = smf_parse_hash;
7103 sort_by_digest = sort_by_digest_4_5;
7104 opti_type = OPTI_TYPE_ZERO_BYTE
7105 | OPTI_TYPE_PRECOMPUTE_INIT
7106 | OPTI_TYPE_PRECOMPUTE_MERKLE
7107 | OPTI_TYPE_EARLY_SKIP
7108 | OPTI_TYPE_NOT_ITERATED
7109 | OPTI_TYPE_PREPENDED_SALT
7110 | OPTI_TYPE_RAW_HASH;
7111 dgst_pos0 = 3;
7112 dgst_pos1 = 4;
7113 dgst_pos2 = 2;
7114 dgst_pos3 = 1;
7115 break;
7116
7117 case 122: hash_type = HASH_TYPE_SHA1;
7118 salt_type = SALT_TYPE_EMBEDDED;
7119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7120 opts_type = OPTS_TYPE_PT_GENERATE_BE
7121 | OPTS_TYPE_PT_ADD80
7122 | OPTS_TYPE_PT_ADDBITS15
7123 | OPTS_TYPE_ST_HEX;
7124 kern_type = KERN_TYPE_SHA1_SLTPW;
7125 dgst_size = DGST_SIZE_4_5;
7126 parse_func = osx1_parse_hash;
7127 sort_by_digest = sort_by_digest_4_5;
7128 opti_type = OPTI_TYPE_ZERO_BYTE
7129 | OPTI_TYPE_PRECOMPUTE_INIT
7130 | OPTI_TYPE_PRECOMPUTE_MERKLE
7131 | OPTI_TYPE_EARLY_SKIP
7132 | OPTI_TYPE_NOT_ITERATED
7133 | OPTI_TYPE_PREPENDED_SALT
7134 | OPTI_TYPE_RAW_HASH;
7135 dgst_pos0 = 3;
7136 dgst_pos1 = 4;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 124: hash_type = HASH_TYPE_SHA1;
7142 salt_type = SALT_TYPE_EMBEDDED;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_BE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS15;
7147 kern_type = KERN_TYPE_SHA1_SLTPW;
7148 dgst_size = DGST_SIZE_4_5;
7149 parse_func = djangosha1_parse_hash;
7150 sort_by_digest = sort_by_digest_4_5;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_PREPENDED_SALT
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 3;
7159 dgst_pos1 = 4;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 130: hash_type = HASH_TYPE_SHA1;
7165 salt_type = SALT_TYPE_INTERN;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_BE
7168 | OPTS_TYPE_PT_UNICODE
7169 | OPTS_TYPE_ST_ADD80
7170 | OPTS_TYPE_ST_ADDBITS15;
7171 kern_type = KERN_TYPE_SHA1_PWUSLT;
7172 dgst_size = DGST_SIZE_4_5;
7173 parse_func = sha1s_parse_hash;
7174 sort_by_digest = sort_by_digest_4_5;
7175 opti_type = OPTI_TYPE_ZERO_BYTE
7176 | OPTI_TYPE_PRECOMPUTE_INIT
7177 | OPTI_TYPE_PRECOMPUTE_MERKLE
7178 | OPTI_TYPE_EARLY_SKIP
7179 | OPTI_TYPE_NOT_ITERATED
7180 | OPTI_TYPE_APPENDED_SALT
7181 | OPTI_TYPE_RAW_HASH;
7182 dgst_pos0 = 3;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 2;
7185 dgst_pos3 = 1;
7186 break;
7187
7188 case 131: hash_type = HASH_TYPE_SHA1;
7189 salt_type = SALT_TYPE_EMBEDDED;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = OPTS_TYPE_PT_GENERATE_BE
7192 | OPTS_TYPE_PT_UNICODE
7193 | OPTS_TYPE_PT_UPPER
7194 | OPTS_TYPE_ST_ADD80
7195 | OPTS_TYPE_ST_ADDBITS15
7196 | OPTS_TYPE_ST_HEX;
7197 kern_type = KERN_TYPE_SHA1_PWUSLT;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = mssql2000_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_APPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 132: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_EMBEDDED;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_PT_UNICODE
7219 | OPTS_TYPE_ST_ADD80
7220 | OPTS_TYPE_ST_ADDBITS15
7221 | OPTS_TYPE_ST_HEX;
7222 kern_type = KERN_TYPE_SHA1_PWUSLT;
7223 dgst_size = DGST_SIZE_4_5;
7224 parse_func = mssql2005_parse_hash;
7225 sort_by_digest = sort_by_digest_4_5;
7226 opti_type = OPTI_TYPE_ZERO_BYTE
7227 | OPTI_TYPE_PRECOMPUTE_INIT
7228 | OPTI_TYPE_PRECOMPUTE_MERKLE
7229 | OPTI_TYPE_EARLY_SKIP
7230 | OPTI_TYPE_NOT_ITERATED
7231 | OPTI_TYPE_APPENDED_SALT
7232 | OPTI_TYPE_RAW_HASH;
7233 dgst_pos0 = 3;
7234 dgst_pos1 = 4;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 1;
7237 break;
7238
7239 case 133: hash_type = HASH_TYPE_SHA1;
7240 salt_type = SALT_TYPE_EMBEDDED;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = OPTS_TYPE_PT_GENERATE_BE
7243 | OPTS_TYPE_PT_UNICODE
7244 | OPTS_TYPE_ST_ADD80
7245 | OPTS_TYPE_ST_ADDBITS15;
7246 kern_type = KERN_TYPE_SHA1_PWUSLT;
7247 dgst_size = DGST_SIZE_4_5;
7248 parse_func = peoplesoft_parse_hash;
7249 sort_by_digest = sort_by_digest_4_5;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_PRECOMPUTE_INIT
7252 | OPTI_TYPE_PRECOMPUTE_MERKLE
7253 | OPTI_TYPE_EARLY_SKIP
7254 | OPTI_TYPE_NOT_ITERATED
7255 | OPTI_TYPE_APPENDED_SALT
7256 | OPTI_TYPE_RAW_HASH;
7257 dgst_pos0 = 3;
7258 dgst_pos1 = 4;
7259 dgst_pos2 = 2;
7260 dgst_pos3 = 1;
7261 break;
7262
7263 case 140: hash_type = HASH_TYPE_SHA1;
7264 salt_type = SALT_TYPE_INTERN;
7265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7266 opts_type = OPTS_TYPE_PT_GENERATE_BE
7267 | OPTS_TYPE_PT_ADD80
7268 | OPTS_TYPE_PT_ADDBITS15
7269 | OPTS_TYPE_PT_UNICODE;
7270 kern_type = KERN_TYPE_SHA1_SLTPWU;
7271 dgst_size = DGST_SIZE_4_5;
7272 parse_func = sha1s_parse_hash;
7273 sort_by_digest = sort_by_digest_4_5;
7274 opti_type = OPTI_TYPE_ZERO_BYTE
7275 | OPTI_TYPE_PRECOMPUTE_INIT
7276 | OPTI_TYPE_PRECOMPUTE_MERKLE
7277 | OPTI_TYPE_EARLY_SKIP
7278 | OPTI_TYPE_NOT_ITERATED
7279 | OPTI_TYPE_PREPENDED_SALT
7280 | OPTI_TYPE_RAW_HASH;
7281 dgst_pos0 = 3;
7282 dgst_pos1 = 4;
7283 dgst_pos2 = 2;
7284 dgst_pos3 = 1;
7285 break;
7286
7287 case 141: hash_type = HASH_TYPE_SHA1;
7288 salt_type = SALT_TYPE_EMBEDDED;
7289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7290 opts_type = OPTS_TYPE_PT_GENERATE_BE
7291 | OPTS_TYPE_PT_ADD80
7292 | OPTS_TYPE_PT_ADDBITS15
7293 | OPTS_TYPE_PT_UNICODE
7294 | OPTS_TYPE_ST_BASE64;
7295 kern_type = KERN_TYPE_SHA1_SLTPWU;
7296 dgst_size = DGST_SIZE_4_5;
7297 parse_func = episerver_parse_hash;
7298 sort_by_digest = sort_by_digest_4_5;
7299 opti_type = OPTI_TYPE_ZERO_BYTE
7300 | OPTI_TYPE_PRECOMPUTE_INIT
7301 | OPTI_TYPE_PRECOMPUTE_MERKLE
7302 | OPTI_TYPE_EARLY_SKIP
7303 | OPTI_TYPE_NOT_ITERATED
7304 | OPTI_TYPE_PREPENDED_SALT
7305 | OPTI_TYPE_RAW_HASH;
7306 dgst_pos0 = 3;
7307 dgst_pos1 = 4;
7308 dgst_pos2 = 2;
7309 dgst_pos3 = 1;
7310 break;
7311
7312 case 150: hash_type = HASH_TYPE_SHA1;
7313 salt_type = SALT_TYPE_INTERN;
7314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7315 opts_type = OPTS_TYPE_PT_GENERATE_BE
7316 | OPTS_TYPE_ST_ADD80
7317 | OPTS_TYPE_ST_ADDBITS15;
7318 kern_type = KERN_TYPE_HMACSHA1_PW;
7319 dgst_size = DGST_SIZE_4_5;
7320 parse_func = hmacsha1_parse_hash;
7321 sort_by_digest = sort_by_digest_4_5;
7322 opti_type = OPTI_TYPE_ZERO_BYTE
7323 | OPTI_TYPE_NOT_ITERATED;
7324 dgst_pos0 = 3;
7325 dgst_pos1 = 4;
7326 dgst_pos2 = 2;
7327 dgst_pos3 = 1;
7328 break;
7329
7330 case 160: hash_type = HASH_TYPE_SHA1;
7331 salt_type = SALT_TYPE_INTERN;
7332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7333 opts_type = OPTS_TYPE_PT_GENERATE_BE
7334 | OPTS_TYPE_PT_ADD80
7335 | OPTS_TYPE_PT_ADDBITS15;
7336 kern_type = KERN_TYPE_HMACSHA1_SLT;
7337 dgst_size = DGST_SIZE_4_5;
7338 parse_func = hmacsha1_parse_hash;
7339 sort_by_digest = sort_by_digest_4_5;
7340 opti_type = OPTI_TYPE_ZERO_BYTE
7341 | OPTI_TYPE_NOT_ITERATED;
7342 dgst_pos0 = 3;
7343 dgst_pos1 = 4;
7344 dgst_pos2 = 2;
7345 dgst_pos3 = 1;
7346 break;
7347
7348 case 190: hash_type = HASH_TYPE_SHA1;
7349 salt_type = SALT_TYPE_NONE;
7350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7351 opts_type = OPTS_TYPE_PT_GENERATE_BE
7352 | OPTS_TYPE_PT_ADD80
7353 | OPTS_TYPE_PT_ADDBITS15;
7354 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = sha1linkedin_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_EARLY_SKIP
7361 | OPTI_TYPE_NOT_ITERATED
7362 | OPTI_TYPE_NOT_SALTED;
7363 dgst_pos0 = 0;
7364 dgst_pos1 = 4;
7365 dgst_pos2 = 3;
7366 dgst_pos3 = 2;
7367 break;
7368
7369 case 200: hash_type = HASH_TYPE_MYSQL;
7370 salt_type = SALT_TYPE_NONE;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = 0;
7373 kern_type = KERN_TYPE_MYSQL;
7374 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7375 parse_func = mysql323_parse_hash;
7376 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7377 opti_type = OPTI_TYPE_ZERO_BYTE;
7378 dgst_pos0 = 0;
7379 dgst_pos1 = 1;
7380 dgst_pos2 = 2;
7381 dgst_pos3 = 3;
7382 break;
7383
7384 case 300: hash_type = HASH_TYPE_SHA1;
7385 salt_type = SALT_TYPE_NONE;
7386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7387 opts_type = OPTS_TYPE_PT_GENERATE_BE
7388 | OPTS_TYPE_PT_ADD80
7389 | OPTS_TYPE_PT_ADDBITS15;
7390 kern_type = KERN_TYPE_MYSQL41;
7391 dgst_size = DGST_SIZE_4_5;
7392 parse_func = sha1_parse_hash;
7393 sort_by_digest = sort_by_digest_4_5;
7394 opti_type = OPTI_TYPE_ZERO_BYTE
7395 | OPTI_TYPE_PRECOMPUTE_INIT
7396 | OPTI_TYPE_PRECOMPUTE_MERKLE
7397 | OPTI_TYPE_EARLY_SKIP
7398 | OPTI_TYPE_NOT_ITERATED
7399 | OPTI_TYPE_NOT_SALTED;
7400 dgst_pos0 = 3;
7401 dgst_pos1 = 4;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 1;
7404 break;
7405
7406 case 400: hash_type = HASH_TYPE_MD5;
7407 salt_type = SALT_TYPE_EMBEDDED;
7408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7410 kern_type = KERN_TYPE_PHPASS;
7411 dgst_size = DGST_SIZE_4_4;
7412 parse_func = phpass_parse_hash;
7413 sort_by_digest = sort_by_digest_4_4;
7414 opti_type = OPTI_TYPE_ZERO_BYTE;
7415 dgst_pos0 = 0;
7416 dgst_pos1 = 1;
7417 dgst_pos2 = 2;
7418 dgst_pos3 = 3;
7419 break;
7420
7421 case 500: hash_type = HASH_TYPE_MD5;
7422 salt_type = SALT_TYPE_EMBEDDED;
7423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7425 kern_type = KERN_TYPE_MD5CRYPT;
7426 dgst_size = DGST_SIZE_4_4;
7427 parse_func = md5crypt_parse_hash;
7428 sort_by_digest = sort_by_digest_4_4;
7429 opti_type = OPTI_TYPE_ZERO_BYTE;
7430 dgst_pos0 = 0;
7431 dgst_pos1 = 1;
7432 dgst_pos2 = 2;
7433 dgst_pos3 = 3;
7434 break;
7435
7436 case 501: hash_type = HASH_TYPE_MD5;
7437 salt_type = SALT_TYPE_EMBEDDED;
7438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7439 opts_type = OPTS_TYPE_PT_GENERATE_LE
7440 | OPTS_TYPE_HASH_COPY;
7441 kern_type = KERN_TYPE_MD5CRYPT;
7442 dgst_size = DGST_SIZE_4_4;
7443 parse_func = juniper_parse_hash;
7444 sort_by_digest = sort_by_digest_4_4;
7445 opti_type = OPTI_TYPE_ZERO_BYTE;
7446 dgst_pos0 = 0;
7447 dgst_pos1 = 1;
7448 dgst_pos2 = 2;
7449 dgst_pos3 = 3;
7450 break;
7451
7452 case 900: hash_type = HASH_TYPE_MD4;
7453 salt_type = SALT_TYPE_NONE;
7454 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7455 opts_type = OPTS_TYPE_PT_GENERATE_LE
7456 | OPTS_TYPE_PT_ADD80
7457 | OPTS_TYPE_PT_ADDBITS14;
7458 kern_type = KERN_TYPE_MD4;
7459 dgst_size = DGST_SIZE_4_4;
7460 parse_func = md4_parse_hash;
7461 sort_by_digest = sort_by_digest_4_4;
7462 opti_type = OPTI_TYPE_ZERO_BYTE
7463 | OPTI_TYPE_PRECOMPUTE_INIT
7464 | OPTI_TYPE_PRECOMPUTE_MERKLE
7465 | OPTI_TYPE_MEET_IN_MIDDLE
7466 | OPTI_TYPE_EARLY_SKIP
7467 | OPTI_TYPE_NOT_ITERATED
7468 | OPTI_TYPE_NOT_SALTED
7469 | OPTI_TYPE_RAW_HASH;
7470 dgst_pos0 = 0;
7471 dgst_pos1 = 3;
7472 dgst_pos2 = 2;
7473 dgst_pos3 = 1;
7474 break;
7475
7476 case 1000: hash_type = HASH_TYPE_MD4;
7477 salt_type = SALT_TYPE_NONE;
7478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7479 opts_type = OPTS_TYPE_PT_GENERATE_LE
7480 | OPTS_TYPE_PT_ADD80
7481 | OPTS_TYPE_PT_ADDBITS14
7482 | OPTS_TYPE_PT_UNICODE;
7483 kern_type = KERN_TYPE_MD4_PWU;
7484 dgst_size = DGST_SIZE_4_4;
7485 parse_func = md4_parse_hash;
7486 sort_by_digest = sort_by_digest_4_4;
7487 opti_type = OPTI_TYPE_ZERO_BYTE
7488 | OPTI_TYPE_PRECOMPUTE_INIT
7489 | OPTI_TYPE_PRECOMPUTE_MERKLE
7490 | OPTI_TYPE_MEET_IN_MIDDLE
7491 | OPTI_TYPE_EARLY_SKIP
7492 | OPTI_TYPE_NOT_ITERATED
7493 | OPTI_TYPE_NOT_SALTED
7494 | OPTI_TYPE_RAW_HASH;
7495 dgst_pos0 = 0;
7496 dgst_pos1 = 3;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 1;
7499 break;
7500
7501 case 1100: hash_type = HASH_TYPE_MD4;
7502 salt_type = SALT_TYPE_INTERN;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_LE
7505 | OPTS_TYPE_PT_ADD80
7506 | OPTS_TYPE_PT_ADDBITS14
7507 | OPTS_TYPE_PT_UNICODE
7508 | OPTS_TYPE_ST_ADD80
7509 | OPTS_TYPE_ST_UNICODE
7510 | OPTS_TYPE_ST_LOWER;
7511 kern_type = KERN_TYPE_MD44_PWUSLT;
7512 dgst_size = DGST_SIZE_4_4;
7513 parse_func = dcc_parse_hash;
7514 sort_by_digest = sort_by_digest_4_4;
7515 opti_type = OPTI_TYPE_ZERO_BYTE
7516 | OPTI_TYPE_PRECOMPUTE_INIT
7517 | OPTI_TYPE_PRECOMPUTE_MERKLE
7518 | OPTI_TYPE_EARLY_SKIP
7519 | OPTI_TYPE_NOT_ITERATED;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 3;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 1;
7524 break;
7525
7526 case 1400: hash_type = HASH_TYPE_SHA256;
7527 salt_type = SALT_TYPE_NONE;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_BE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS15;
7532 kern_type = KERN_TYPE_SHA256;
7533 dgst_size = DGST_SIZE_4_8;
7534 parse_func = sha256_parse_hash;
7535 sort_by_digest = sort_by_digest_4_8;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_EARLY_SKIP
7540 | OPTI_TYPE_NOT_ITERATED
7541 | OPTI_TYPE_NOT_SALTED
7542 | OPTI_TYPE_RAW_HASH;
7543 dgst_pos0 = 3;
7544 dgst_pos1 = 7;
7545 dgst_pos2 = 2;
7546 dgst_pos3 = 6;
7547 break;
7548
7549 case 1410: hash_type = HASH_TYPE_SHA256;
7550 salt_type = SALT_TYPE_INTERN;
7551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7552 opts_type = OPTS_TYPE_PT_GENERATE_BE
7553 | OPTS_TYPE_ST_ADD80
7554 | OPTS_TYPE_ST_ADDBITS15;
7555 kern_type = KERN_TYPE_SHA256_PWSLT;
7556 dgst_size = DGST_SIZE_4_8;
7557 parse_func = sha256s_parse_hash;
7558 sort_by_digest = sort_by_digest_4_8;
7559 opti_type = OPTI_TYPE_ZERO_BYTE
7560 | OPTI_TYPE_PRECOMPUTE_INIT
7561 | OPTI_TYPE_PRECOMPUTE_MERKLE
7562 | OPTI_TYPE_EARLY_SKIP
7563 | OPTI_TYPE_NOT_ITERATED
7564 | OPTI_TYPE_APPENDED_SALT
7565 | OPTI_TYPE_RAW_HASH;
7566 dgst_pos0 = 3;
7567 dgst_pos1 = 7;
7568 dgst_pos2 = 2;
7569 dgst_pos3 = 6;
7570 break;
7571
7572 case 1420: hash_type = HASH_TYPE_SHA256;
7573 salt_type = SALT_TYPE_INTERN;
7574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7575 opts_type = OPTS_TYPE_PT_GENERATE_BE
7576 | OPTS_TYPE_PT_ADD80
7577 | OPTS_TYPE_PT_ADDBITS15;
7578 kern_type = KERN_TYPE_SHA256_SLTPW;
7579 dgst_size = DGST_SIZE_4_8;
7580 parse_func = sha256s_parse_hash;
7581 sort_by_digest = sort_by_digest_4_8;
7582 opti_type = OPTI_TYPE_ZERO_BYTE
7583 | OPTI_TYPE_PRECOMPUTE_INIT
7584 | OPTI_TYPE_PRECOMPUTE_MERKLE
7585 | OPTI_TYPE_EARLY_SKIP
7586 | OPTI_TYPE_NOT_ITERATED
7587 | OPTI_TYPE_PREPENDED_SALT
7588 | OPTI_TYPE_RAW_HASH;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 7;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 6;
7593 break;
7594
7595 case 1421: hash_type = HASH_TYPE_SHA256;
7596 salt_type = SALT_TYPE_EMBEDDED;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_ADD80
7600 | OPTS_TYPE_PT_ADDBITS15;
7601 kern_type = KERN_TYPE_SHA256_SLTPW;
7602 dgst_size = DGST_SIZE_4_8;
7603 parse_func = hmailserver_parse_hash;
7604 sort_by_digest = sort_by_digest_4_8;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_PRECOMPUTE_MERKLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_PREPENDED_SALT
7611 | OPTI_TYPE_RAW_HASH;
7612 dgst_pos0 = 3;
7613 dgst_pos1 = 7;
7614 dgst_pos2 = 2;
7615 dgst_pos3 = 6;
7616 break;
7617
7618 case 1430: hash_type = HASH_TYPE_SHA256;
7619 salt_type = SALT_TYPE_INTERN;
7620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7621 opts_type = OPTS_TYPE_PT_GENERATE_BE
7622 | OPTS_TYPE_PT_UNICODE
7623 | OPTS_TYPE_ST_ADD80
7624 | OPTS_TYPE_ST_ADDBITS15;
7625 kern_type = KERN_TYPE_SHA256_PWUSLT;
7626 dgst_size = DGST_SIZE_4_8;
7627 parse_func = sha256s_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_APPENDED_SALT
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 1440: 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_PT_ADD80
7647 | OPTS_TYPE_PT_ADDBITS15
7648 | OPTS_TYPE_PT_UNICODE;
7649 kern_type = KERN_TYPE_SHA256_SLTPWU;
7650 dgst_size = DGST_SIZE_4_8;
7651 parse_func = sha256s_parse_hash;
7652 sort_by_digest = sort_by_digest_4_8;
7653 opti_type = OPTI_TYPE_ZERO_BYTE
7654 | OPTI_TYPE_PRECOMPUTE_INIT
7655 | OPTI_TYPE_PRECOMPUTE_MERKLE
7656 | OPTI_TYPE_EARLY_SKIP
7657 | OPTI_TYPE_NOT_ITERATED
7658 | OPTI_TYPE_PREPENDED_SALT
7659 | OPTI_TYPE_RAW_HASH;
7660 dgst_pos0 = 3;
7661 dgst_pos1 = 7;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 6;
7664 break;
7665
7666 case 1441: hash_type = HASH_TYPE_SHA256;
7667 salt_type = SALT_TYPE_EMBEDDED;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS15
7672 | OPTS_TYPE_PT_UNICODE
7673 | OPTS_TYPE_ST_BASE64;
7674 kern_type = KERN_TYPE_SHA256_SLTPWU;
7675 dgst_size = DGST_SIZE_4_8;
7676 parse_func = episerver4_parse_hash;
7677 sort_by_digest = sort_by_digest_4_8;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_EARLY_SKIP
7682 | OPTI_TYPE_NOT_ITERATED
7683 | OPTI_TYPE_PREPENDED_SALT
7684 | OPTI_TYPE_RAW_HASH;
7685 dgst_pos0 = 3;
7686 dgst_pos1 = 7;
7687 dgst_pos2 = 2;
7688 dgst_pos3 = 6;
7689 break;
7690
7691 case 1450: hash_type = HASH_TYPE_SHA256;
7692 salt_type = SALT_TYPE_INTERN;
7693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7694 opts_type = OPTS_TYPE_PT_GENERATE_BE
7695 | OPTS_TYPE_ST_ADD80;
7696 kern_type = KERN_TYPE_HMACSHA256_PW;
7697 dgst_size = DGST_SIZE_4_8;
7698 parse_func = hmacsha256_parse_hash;
7699 sort_by_digest = sort_by_digest_4_8;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_NOT_ITERATED;
7702 dgst_pos0 = 3;
7703 dgst_pos1 = 7;
7704 dgst_pos2 = 2;
7705 dgst_pos3 = 6;
7706 break;
7707
7708 case 1460: hash_type = HASH_TYPE_SHA256;
7709 salt_type = SALT_TYPE_INTERN;
7710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7711 opts_type = OPTS_TYPE_PT_GENERATE_BE
7712 | OPTS_TYPE_PT_ADD80
7713 | OPTS_TYPE_PT_ADDBITS15;
7714 kern_type = KERN_TYPE_HMACSHA256_SLT;
7715 dgst_size = DGST_SIZE_4_8;
7716 parse_func = hmacsha256_parse_hash;
7717 sort_by_digest = sort_by_digest_4_8;
7718 opti_type = OPTI_TYPE_ZERO_BYTE
7719 | OPTI_TYPE_NOT_ITERATED;
7720 dgst_pos0 = 3;
7721 dgst_pos1 = 7;
7722 dgst_pos2 = 2;
7723 dgst_pos3 = 6;
7724 break;
7725
7726 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7727 salt_type = SALT_TYPE_EMBEDDED;
7728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7729 opts_type = OPTS_TYPE_PT_GENERATE_LE
7730 | OPTS_TYPE_PT_BITSLICE;
7731 kern_type = KERN_TYPE_DESCRYPT;
7732 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7733 parse_func = descrypt_parse_hash;
7734 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7737 dgst_pos0 = 0;
7738 dgst_pos1 = 1;
7739 dgst_pos2 = 2;
7740 dgst_pos3 = 3;
7741 break;
7742
7743 case 1600: hash_type = HASH_TYPE_MD5;
7744 salt_type = SALT_TYPE_EMBEDDED;
7745 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7747 kern_type = KERN_TYPE_APR1CRYPT;
7748 dgst_size = DGST_SIZE_4_4;
7749 parse_func = md5apr1_parse_hash;
7750 sort_by_digest = sort_by_digest_4_4;
7751 opti_type = OPTI_TYPE_ZERO_BYTE;
7752 dgst_pos0 = 0;
7753 dgst_pos1 = 1;
7754 dgst_pos2 = 2;
7755 dgst_pos3 = 3;
7756 break;
7757
7758 case 1700: hash_type = HASH_TYPE_SHA512;
7759 salt_type = SALT_TYPE_NONE;
7760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7761 opts_type = OPTS_TYPE_PT_GENERATE_BE
7762 | OPTS_TYPE_PT_ADD80
7763 | OPTS_TYPE_PT_ADDBITS15;
7764 kern_type = KERN_TYPE_SHA512;
7765 dgst_size = DGST_SIZE_8_8;
7766 parse_func = sha512_parse_hash;
7767 sort_by_digest = sort_by_digest_8_8;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED
7773 | OPTI_TYPE_NOT_SALTED
7774 | OPTI_TYPE_USES_BITS_64
7775 | OPTI_TYPE_RAW_HASH;
7776 dgst_pos0 = 14;
7777 dgst_pos1 = 15;
7778 dgst_pos2 = 6;
7779 dgst_pos3 = 7;
7780 break;
7781
7782 case 1710: hash_type = HASH_TYPE_SHA512;
7783 salt_type = SALT_TYPE_INTERN;
7784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_BE
7786 | OPTS_TYPE_ST_ADD80
7787 | OPTS_TYPE_ST_ADDBITS15;
7788 kern_type = KERN_TYPE_SHA512_PWSLT;
7789 dgst_size = DGST_SIZE_8_8;
7790 parse_func = sha512s_parse_hash;
7791 sort_by_digest = sort_by_digest_8_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_INIT
7794 | OPTI_TYPE_PRECOMPUTE_MERKLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_APPENDED_SALT
7798 | OPTI_TYPE_USES_BITS_64
7799 | OPTI_TYPE_RAW_HASH;
7800 dgst_pos0 = 14;
7801 dgst_pos1 = 15;
7802 dgst_pos2 = 6;
7803 dgst_pos3 = 7;
7804 break;
7805
7806 case 1711: hash_type = HASH_TYPE_SHA512;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_BE
7810 | OPTS_TYPE_ST_ADD80
7811 | OPTS_TYPE_ST_ADDBITS15;
7812 kern_type = KERN_TYPE_SHA512_PWSLT;
7813 dgst_size = DGST_SIZE_8_8;
7814 parse_func = sha512b64s_parse_hash;
7815 sort_by_digest = sort_by_digest_8_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_EARLY_SKIP
7820 | OPTI_TYPE_NOT_ITERATED
7821 | OPTI_TYPE_APPENDED_SALT
7822 | OPTI_TYPE_USES_BITS_64
7823 | OPTI_TYPE_RAW_HASH;
7824 dgst_pos0 = 14;
7825 dgst_pos1 = 15;
7826 dgst_pos2 = 6;
7827 dgst_pos3 = 7;
7828 break;
7829
7830 case 1720: hash_type = HASH_TYPE_SHA512;
7831 salt_type = SALT_TYPE_INTERN;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_BE
7834 | OPTS_TYPE_PT_ADD80
7835 | OPTS_TYPE_PT_ADDBITS15;
7836 kern_type = KERN_TYPE_SHA512_SLTPW;
7837 dgst_size = DGST_SIZE_8_8;
7838 parse_func = sha512s_parse_hash;
7839 sort_by_digest = sort_by_digest_8_8;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_PREPENDED_SALT
7846 | OPTI_TYPE_USES_BITS_64
7847 | OPTI_TYPE_RAW_HASH;
7848 dgst_pos0 = 14;
7849 dgst_pos1 = 15;
7850 dgst_pos2 = 6;
7851 dgst_pos3 = 7;
7852 break;
7853
7854 case 1722: hash_type = HASH_TYPE_SHA512;
7855 salt_type = SALT_TYPE_EMBEDDED;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_BE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS15
7860 | OPTS_TYPE_ST_HEX;
7861 kern_type = KERN_TYPE_SHA512_SLTPW;
7862 dgst_size = DGST_SIZE_8_8;
7863 parse_func = osx512_parse_hash;
7864 sort_by_digest = sort_by_digest_8_8;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_PREPENDED_SALT
7871 | OPTI_TYPE_USES_BITS_64
7872 | OPTI_TYPE_RAW_HASH;
7873 dgst_pos0 = 14;
7874 dgst_pos1 = 15;
7875 dgst_pos2 = 6;
7876 dgst_pos3 = 7;
7877 break;
7878
7879 case 1730: hash_type = HASH_TYPE_SHA512;
7880 salt_type = SALT_TYPE_INTERN;
7881 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7882 opts_type = OPTS_TYPE_PT_GENERATE_BE
7883 | OPTS_TYPE_PT_UNICODE
7884 | OPTS_TYPE_ST_ADD80
7885 | OPTS_TYPE_ST_ADDBITS15;
7886 kern_type = KERN_TYPE_SHA512_PWSLTU;
7887 dgst_size = DGST_SIZE_8_8;
7888 parse_func = sha512s_parse_hash;
7889 sort_by_digest = sort_by_digest_8_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_PRECOMPUTE_INIT
7892 | OPTI_TYPE_PRECOMPUTE_MERKLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_APPENDED_SALT
7896 | OPTI_TYPE_USES_BITS_64
7897 | OPTI_TYPE_RAW_HASH;
7898 dgst_pos0 = 14;
7899 dgst_pos1 = 15;
7900 dgst_pos2 = 6;
7901 dgst_pos3 = 7;
7902 break;
7903
7904 case 1731: hash_type = HASH_TYPE_SHA512;
7905 salt_type = SALT_TYPE_EMBEDDED;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_BE
7908 | OPTS_TYPE_PT_UNICODE
7909 | OPTS_TYPE_ST_ADD80
7910 | OPTS_TYPE_ST_ADDBITS15
7911 | OPTS_TYPE_ST_HEX;
7912 kern_type = KERN_TYPE_SHA512_PWSLTU;
7913 dgst_size = DGST_SIZE_8_8;
7914 parse_func = mssql2012_parse_hash;
7915 sort_by_digest = sort_by_digest_8_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_APPENDED_SALT
7922 | OPTI_TYPE_USES_BITS_64
7923 | OPTI_TYPE_RAW_HASH;
7924 dgst_pos0 = 14;
7925 dgst_pos1 = 15;
7926 dgst_pos2 = 6;
7927 dgst_pos3 = 7;
7928 break;
7929
7930 case 1740: hash_type = HASH_TYPE_SHA512;
7931 salt_type = SALT_TYPE_INTERN;
7932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7933 opts_type = OPTS_TYPE_PT_GENERATE_BE
7934 | OPTS_TYPE_PT_ADD80
7935 | OPTS_TYPE_PT_ADDBITS15
7936 | OPTS_TYPE_PT_UNICODE;
7937 kern_type = KERN_TYPE_SHA512_SLTPWU;
7938 dgst_size = DGST_SIZE_8_8;
7939 parse_func = sha512s_parse_hash;
7940 sort_by_digest = sort_by_digest_8_8;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP
7945 | OPTI_TYPE_NOT_ITERATED
7946 | OPTI_TYPE_PREPENDED_SALT
7947 | OPTI_TYPE_USES_BITS_64
7948 | OPTI_TYPE_RAW_HASH;
7949 dgst_pos0 = 14;
7950 dgst_pos1 = 15;
7951 dgst_pos2 = 6;
7952 dgst_pos3 = 7;
7953 break;
7954
7955 case 1750: hash_type = HASH_TYPE_SHA512;
7956 salt_type = SALT_TYPE_INTERN;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_ST_ADD80;
7960 kern_type = KERN_TYPE_HMACSHA512_PW;
7961 dgst_size = DGST_SIZE_8_8;
7962 parse_func = hmacsha512_parse_hash;
7963 sort_by_digest = sort_by_digest_8_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_USES_BITS_64
7966 | OPTI_TYPE_NOT_ITERATED;
7967 dgst_pos0 = 14;
7968 dgst_pos1 = 15;
7969 dgst_pos2 = 6;
7970 dgst_pos3 = 7;
7971 break;
7972
7973 case 1760: hash_type = HASH_TYPE_SHA512;
7974 salt_type = SALT_TYPE_INTERN;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_PT_ADD80
7978 | OPTS_TYPE_PT_ADDBITS15;
7979 kern_type = KERN_TYPE_HMACSHA512_SLT;
7980 dgst_size = DGST_SIZE_8_8;
7981 parse_func = hmacsha512_parse_hash;
7982 sort_by_digest = sort_by_digest_8_8;
7983 opti_type = OPTI_TYPE_ZERO_BYTE
7984 | OPTI_TYPE_USES_BITS_64
7985 | OPTI_TYPE_NOT_ITERATED;
7986 dgst_pos0 = 14;
7987 dgst_pos1 = 15;
7988 dgst_pos2 = 6;
7989 dgst_pos3 = 7;
7990 break;
7991
7992 case 1800: hash_type = HASH_TYPE_SHA512;
7993 salt_type = SALT_TYPE_EMBEDDED;
7994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7995 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7996 kern_type = KERN_TYPE_SHA512CRYPT;
7997 dgst_size = DGST_SIZE_8_8;
7998 parse_func = sha512crypt_parse_hash;
7999 sort_by_digest = sort_by_digest_8_8;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_USES_BITS_64;
8002 dgst_pos0 = 0;
8003 dgst_pos1 = 1;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 3;
8006 break;
8007
8008 case 2100: hash_type = HASH_TYPE_DCC2;
8009 salt_type = SALT_TYPE_EMBEDDED;
8010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8012 | OPTS_TYPE_ST_LOWER
8013 | OPTS_TYPE_ST_UNICODE;
8014 kern_type = KERN_TYPE_DCC2;
8015 dgst_size = DGST_SIZE_4_4;
8016 parse_func = dcc2_parse_hash;
8017 sort_by_digest = sort_by_digest_4_4;
8018 opti_type = OPTI_TYPE_ZERO_BYTE;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 1;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 3;
8023 break;
8024
8025 case 2400: hash_type = HASH_TYPE_MD5;
8026 salt_type = SALT_TYPE_NONE;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8029 kern_type = KERN_TYPE_MD5PIX;
8030 dgst_size = DGST_SIZE_4_4;
8031 parse_func = md5pix_parse_hash;
8032 sort_by_digest = sort_by_digest_4_4;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP
8037 | OPTI_TYPE_NOT_ITERATED
8038 | OPTI_TYPE_NOT_SALTED;
8039 dgst_pos0 = 0;
8040 dgst_pos1 = 3;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 1;
8043 break;
8044
8045 case 2410: hash_type = HASH_TYPE_MD5;
8046 salt_type = SALT_TYPE_INTERN;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8049 kern_type = KERN_TYPE_MD5ASA;
8050 dgst_size = DGST_SIZE_4_4;
8051 parse_func = md5asa_parse_hash;
8052 sort_by_digest = sort_by_digest_4_4;
8053 opti_type = OPTI_TYPE_ZERO_BYTE
8054 | OPTI_TYPE_PRECOMPUTE_INIT
8055 | OPTI_TYPE_PRECOMPUTE_MERKLE
8056 | OPTI_TYPE_EARLY_SKIP
8057 | OPTI_TYPE_NOT_ITERATED;
8058 dgst_pos0 = 0;
8059 dgst_pos1 = 3;
8060 dgst_pos2 = 2;
8061 dgst_pos3 = 1;
8062 break;
8063
8064 case 2500: hash_type = HASH_TYPE_WPA;
8065 salt_type = SALT_TYPE_EMBEDDED;
8066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8068 kern_type = KERN_TYPE_WPA;
8069 dgst_size = DGST_SIZE_4_4;
8070 parse_func = wpa_parse_hash;
8071 sort_by_digest = sort_by_digest_4_4;
8072 opti_type = OPTI_TYPE_ZERO_BYTE;
8073 dgst_pos0 = 0;
8074 dgst_pos1 = 1;
8075 dgst_pos2 = 2;
8076 dgst_pos3 = 3;
8077 break;
8078
8079 case 2600: hash_type = HASH_TYPE_MD5;
8080 salt_type = SALT_TYPE_VIRTUAL;
8081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8082 opts_type = OPTS_TYPE_PT_GENERATE_LE
8083 | OPTS_TYPE_PT_ADD80
8084 | OPTS_TYPE_PT_ADDBITS14
8085 | OPTS_TYPE_ST_ADD80;
8086 kern_type = KERN_TYPE_MD55_PWSLT1;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = md5md5_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP;
8094 dgst_pos0 = 0;
8095 dgst_pos1 = 3;
8096 dgst_pos2 = 2;
8097 dgst_pos3 = 1;
8098 break;
8099
8100 case 2611: hash_type = HASH_TYPE_MD5;
8101 salt_type = SALT_TYPE_INTERN;
8102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8103 opts_type = OPTS_TYPE_PT_GENERATE_LE
8104 | OPTS_TYPE_PT_ADD80
8105 | OPTS_TYPE_PT_ADDBITS14
8106 | OPTS_TYPE_ST_ADD80;
8107 kern_type = KERN_TYPE_MD55_PWSLT1;
8108 dgst_size = DGST_SIZE_4_4;
8109 parse_func = vb3_parse_hash;
8110 sort_by_digest = sort_by_digest_4_4;
8111 opti_type = OPTI_TYPE_ZERO_BYTE
8112 | OPTI_TYPE_PRECOMPUTE_INIT
8113 | OPTI_TYPE_PRECOMPUTE_MERKLE
8114 | OPTI_TYPE_EARLY_SKIP;
8115 dgst_pos0 = 0;
8116 dgst_pos1 = 3;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 1;
8119 break;
8120
8121 case 2612: hash_type = HASH_TYPE_MD5;
8122 salt_type = SALT_TYPE_EMBEDDED;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_LE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS14
8127 | OPTS_TYPE_ST_ADD80
8128 | OPTS_TYPE_ST_HEX;
8129 kern_type = KERN_TYPE_MD55_PWSLT1;
8130 dgst_size = DGST_SIZE_4_4;
8131 parse_func = phps_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4;
8133 opti_type = OPTI_TYPE_ZERO_BYTE
8134 | OPTI_TYPE_PRECOMPUTE_INIT
8135 | OPTI_TYPE_PRECOMPUTE_MERKLE
8136 | OPTI_TYPE_EARLY_SKIP;
8137 dgst_pos0 = 0;
8138 dgst_pos1 = 3;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 1;
8141 break;
8142
8143 case 2711: hash_type = HASH_TYPE_MD5;
8144 salt_type = SALT_TYPE_INTERN;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_LE
8147 | OPTS_TYPE_PT_ADD80
8148 | OPTS_TYPE_PT_ADDBITS14
8149 | OPTS_TYPE_ST_ADD80;
8150 kern_type = KERN_TYPE_MD55_PWSLT2;
8151 dgst_size = DGST_SIZE_4_4;
8152 parse_func = vb30_parse_hash;
8153 sort_by_digest = sort_by_digest_4_4;
8154 opti_type = OPTI_TYPE_ZERO_BYTE
8155 | OPTI_TYPE_PRECOMPUTE_INIT
8156 | OPTI_TYPE_EARLY_SKIP;
8157 dgst_pos0 = 0;
8158 dgst_pos1 = 3;
8159 dgst_pos2 = 2;
8160 dgst_pos3 = 1;
8161 break;
8162
8163 case 2811: hash_type = HASH_TYPE_MD5;
8164 salt_type = SALT_TYPE_INTERN;
8165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8166 opts_type = OPTS_TYPE_PT_GENERATE_LE
8167 | OPTS_TYPE_PT_ADD80
8168 | OPTS_TYPE_PT_ADDBITS14;
8169 kern_type = KERN_TYPE_MD55_SLTPW;
8170 dgst_size = DGST_SIZE_4_4;
8171 parse_func = ipb2_parse_hash;
8172 sort_by_digest = sort_by_digest_4_4;
8173 opti_type = OPTI_TYPE_ZERO_BYTE
8174 | OPTI_TYPE_PRECOMPUTE_INIT
8175 | OPTI_TYPE_EARLY_SKIP;
8176 dgst_pos0 = 0;
8177 dgst_pos1 = 3;
8178 dgst_pos2 = 2;
8179 dgst_pos3 = 1;
8180 break;
8181
8182 case 3000: hash_type = HASH_TYPE_LM;
8183 salt_type = SALT_TYPE_NONE;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_LE
8186 | OPTS_TYPE_PT_UPPER
8187 | OPTS_TYPE_PT_BITSLICE;
8188 kern_type = KERN_TYPE_LM;
8189 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8190 parse_func = lm_parse_hash;
8191 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8192 opti_type = OPTI_TYPE_ZERO_BYTE
8193 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8194 dgst_pos0 = 0;
8195 dgst_pos1 = 1;
8196 dgst_pos2 = 2;
8197 dgst_pos3 = 3;
8198 break;
8199
8200 case 3100: hash_type = HASH_TYPE_ORACLEH;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_LE
8204 | OPTS_TYPE_PT_UPPER
8205 | OPTS_TYPE_ST_UPPER;
8206 kern_type = KERN_TYPE_ORACLEH;
8207 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8208 parse_func = oracleh_parse_hash;
8209 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8210 opti_type = OPTI_TYPE_ZERO_BYTE;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 1;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 3;
8215 break;
8216
8217 case 3200: hash_type = HASH_TYPE_BCRYPT;
8218 salt_type = SALT_TYPE_EMBEDDED;
8219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE
8221 | OPTS_TYPE_ST_GENERATE_LE;
8222 kern_type = KERN_TYPE_BCRYPT;
8223 dgst_size = DGST_SIZE_4_6;
8224 parse_func = bcrypt_parse_hash;
8225 sort_by_digest = sort_by_digest_4_6;
8226 opti_type = OPTI_TYPE_ZERO_BYTE;
8227 dgst_pos0 = 0;
8228 dgst_pos1 = 1;
8229 dgst_pos2 = 2;
8230 dgst_pos3 = 3;
8231 break;
8232
8233 case 3710: hash_type = HASH_TYPE_MD5;
8234 salt_type = SALT_TYPE_INTERN;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_LE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS14;
8239 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8240 dgst_size = DGST_SIZE_4_4;
8241 parse_func = md5s_parse_hash;
8242 sort_by_digest = sort_by_digest_4_4;
8243 opti_type = OPTI_TYPE_ZERO_BYTE
8244 | OPTI_TYPE_PRECOMPUTE_INIT
8245 | OPTI_TYPE_PRECOMPUTE_MERKLE
8246 | OPTI_TYPE_EARLY_SKIP;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 3;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 1;
8251 break;
8252
8253 case 3711: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_EMBEDDED;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE
8257 | OPTS_TYPE_PT_ADD80
8258 | OPTS_TYPE_PT_ADDBITS14;
8259 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8260 dgst_size = DGST_SIZE_4_4;
8261 parse_func = mediawiki_b_parse_hash;
8262 sort_by_digest = sort_by_digest_4_4;
8263 opti_type = OPTI_TYPE_ZERO_BYTE
8264 | OPTI_TYPE_PRECOMPUTE_INIT
8265 | OPTI_TYPE_PRECOMPUTE_MERKLE
8266 | OPTI_TYPE_EARLY_SKIP;
8267 dgst_pos0 = 0;
8268 dgst_pos1 = 3;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 3800: hash_type = HASH_TYPE_MD5;
8274 salt_type = SALT_TYPE_INTERN;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE
8277 | OPTS_TYPE_ST_ADDBITS14;
8278 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8279 dgst_size = DGST_SIZE_4_4;
8280 parse_func = md5s_parse_hash;
8281 sort_by_digest = sort_by_digest_4_4;
8282 opti_type = OPTI_TYPE_ZERO_BYTE
8283 | OPTI_TYPE_PRECOMPUTE_INIT
8284 | OPTI_TYPE_PRECOMPUTE_MERKLE
8285 | OPTI_TYPE_EARLY_SKIP
8286 | OPTI_TYPE_NOT_ITERATED
8287 | OPTI_TYPE_RAW_HASH;
8288 dgst_pos0 = 0;
8289 dgst_pos1 = 3;
8290 dgst_pos2 = 2;
8291 dgst_pos3 = 1;
8292 break;
8293
8294 case 4300: hash_type = HASH_TYPE_MD5;
8295 salt_type = SALT_TYPE_VIRTUAL;
8296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8297 opts_type = OPTS_TYPE_PT_GENERATE_LE
8298 | OPTS_TYPE_PT_ADD80
8299 | OPTS_TYPE_PT_ADDBITS14
8300 | OPTS_TYPE_ST_ADD80;
8301 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8302 dgst_size = DGST_SIZE_4_4;
8303 parse_func = md5md5_parse_hash;
8304 sort_by_digest = sort_by_digest_4_4;
8305 opti_type = OPTI_TYPE_ZERO_BYTE
8306 | OPTI_TYPE_PRECOMPUTE_INIT
8307 | OPTI_TYPE_PRECOMPUTE_MERKLE
8308 | OPTI_TYPE_EARLY_SKIP;
8309 dgst_pos0 = 0;
8310 dgst_pos1 = 3;
8311 dgst_pos2 = 2;
8312 dgst_pos3 = 1;
8313 break;
8314
8315
8316 case 4400: hash_type = HASH_TYPE_MD5;
8317 salt_type = SALT_TYPE_NONE;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_BE
8320 | OPTS_TYPE_PT_ADD80
8321 | OPTS_TYPE_PT_ADDBITS15;
8322 kern_type = KERN_TYPE_MD5_SHA1;
8323 dgst_size = DGST_SIZE_4_4;
8324 parse_func = md5_parse_hash;
8325 sort_by_digest = sort_by_digest_4_4;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_NOT_SALTED
8332 | OPTI_TYPE_RAW_HASH;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 3;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 1;
8337 break;
8338
8339 case 4500: hash_type = HASH_TYPE_SHA1;
8340 salt_type = SALT_TYPE_NONE;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_BE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS15;
8345 kern_type = KERN_TYPE_SHA11;
8346 dgst_size = DGST_SIZE_4_5;
8347 parse_func = sha1_parse_hash;
8348 sort_by_digest = sort_by_digest_4_5;
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_PRECOMPUTE_INIT
8351 | OPTI_TYPE_PRECOMPUTE_MERKLE
8352 | OPTI_TYPE_EARLY_SKIP
8353 | OPTI_TYPE_NOT_SALTED;
8354 dgst_pos0 = 3;
8355 dgst_pos1 = 4;
8356 dgst_pos2 = 2;
8357 dgst_pos3 = 1;
8358 break;
8359
8360 case 4700: hash_type = HASH_TYPE_SHA1;
8361 salt_type = SALT_TYPE_NONE;
8362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8363 opts_type = OPTS_TYPE_PT_GENERATE_LE
8364 | OPTS_TYPE_PT_ADD80
8365 | OPTS_TYPE_PT_ADDBITS14;
8366 kern_type = KERN_TYPE_SHA1_MD5;
8367 dgst_size = DGST_SIZE_4_5;
8368 parse_func = sha1_parse_hash;
8369 sort_by_digest = sort_by_digest_4_5;
8370 opti_type = OPTI_TYPE_ZERO_BYTE
8371 | OPTI_TYPE_PRECOMPUTE_INIT
8372 | OPTI_TYPE_PRECOMPUTE_MERKLE
8373 | OPTI_TYPE_EARLY_SKIP
8374 | OPTI_TYPE_NOT_ITERATED
8375 | OPTI_TYPE_NOT_SALTED
8376 | OPTI_TYPE_RAW_HASH;
8377 dgst_pos0 = 3;
8378 dgst_pos1 = 4;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 1;
8381 break;
8382
8383 case 4800: hash_type = HASH_TYPE_MD5;
8384 salt_type = SALT_TYPE_EMBEDDED;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE
8387 | OPTS_TYPE_PT_ADDBITS14;
8388 kern_type = KERN_TYPE_MD5_CHAP;
8389 dgst_size = DGST_SIZE_4_4;
8390 parse_func = chap_parse_hash;
8391 sort_by_digest = sort_by_digest_4_4;
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_PRECOMPUTE_INIT
8394 | OPTI_TYPE_PRECOMPUTE_MERKLE
8395 | OPTI_TYPE_MEET_IN_MIDDLE
8396 | OPTI_TYPE_EARLY_SKIP
8397 | OPTI_TYPE_NOT_ITERATED
8398 | OPTI_TYPE_RAW_HASH;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 3;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 1;
8403 break;
8404
8405 case 4900: hash_type = HASH_TYPE_SHA1;
8406 salt_type = SALT_TYPE_INTERN;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8409 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8410 dgst_size = DGST_SIZE_4_5;
8411 parse_func = sha1s_parse_hash;
8412 sort_by_digest = sort_by_digest_4_5;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_PRECOMPUTE_INIT
8415 | OPTI_TYPE_PRECOMPUTE_MERKLE
8416 | OPTI_TYPE_EARLY_SKIP;
8417 dgst_pos0 = 3;
8418 dgst_pos1 = 4;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 1;
8421 break;
8422
8423 case 5000: hash_type = HASH_TYPE_KECCAK;
8424 salt_type = SALT_TYPE_EMBEDDED;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE
8427 | OPTS_TYPE_PT_ADD01;
8428 kern_type = KERN_TYPE_KECCAK;
8429 dgst_size = DGST_SIZE_8_25;
8430 parse_func = keccak_parse_hash;
8431 sort_by_digest = sort_by_digest_8_25;
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_USES_BITS_64
8434 | OPTI_TYPE_RAW_HASH;
8435 dgst_pos0 = 2;
8436 dgst_pos1 = 3;
8437 dgst_pos2 = 4;
8438 dgst_pos3 = 5;
8439 break;
8440
8441 case 5100: hash_type = HASH_TYPE_MD5H;
8442 salt_type = SALT_TYPE_NONE;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_PT_ADD80
8446 | OPTS_TYPE_PT_ADDBITS14;
8447 kern_type = KERN_TYPE_MD5H;
8448 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8449 parse_func = md5half_parse_hash;
8450 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8451 opti_type = OPTI_TYPE_ZERO_BYTE
8452 | OPTI_TYPE_RAW_HASH;
8453 dgst_pos0 = 0;
8454 dgst_pos1 = 1;
8455 dgst_pos2 = 2;
8456 dgst_pos3 = 3;
8457 break;
8458
8459 case 5200: hash_type = HASH_TYPE_SHA256;
8460 salt_type = SALT_TYPE_EMBEDDED;
8461 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8462 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8463 kern_type = KERN_TYPE_PSAFE3;
8464 dgst_size = DGST_SIZE_4_8;
8465 parse_func = psafe3_parse_hash;
8466 sort_by_digest = sort_by_digest_4_8;
8467 opti_type = OPTI_TYPE_ZERO_BYTE;
8468 dgst_pos0 = 0;
8469 dgst_pos1 = 1;
8470 dgst_pos2 = 2;
8471 dgst_pos3 = 3;
8472 break;
8473
8474 case 5300: hash_type = HASH_TYPE_MD5;
8475 salt_type = SALT_TYPE_EMBEDDED;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_LE
8478 | OPTS_TYPE_ST_ADD80;
8479 kern_type = KERN_TYPE_IKEPSK_MD5;
8480 dgst_size = DGST_SIZE_4_4;
8481 parse_func = ikepsk_md5_parse_hash;
8482 sort_by_digest = sort_by_digest_4_4;
8483 opti_type = OPTI_TYPE_ZERO_BYTE;
8484 dgst_pos0 = 0;
8485 dgst_pos1 = 3;
8486 dgst_pos2 = 2;
8487 dgst_pos3 = 1;
8488 break;
8489
8490 case 5400: hash_type = HASH_TYPE_SHA1;
8491 salt_type = SALT_TYPE_EMBEDDED;
8492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8493 opts_type = OPTS_TYPE_PT_GENERATE_BE
8494 | OPTS_TYPE_ST_ADD80;
8495 kern_type = KERN_TYPE_IKEPSK_SHA1;
8496 dgst_size = DGST_SIZE_4_5;
8497 parse_func = ikepsk_sha1_parse_hash;
8498 sort_by_digest = sort_by_digest_4_5;
8499 opti_type = OPTI_TYPE_ZERO_BYTE;
8500 dgst_pos0 = 3;
8501 dgst_pos1 = 4;
8502 dgst_pos2 = 2;
8503 dgst_pos3 = 1;
8504 break;
8505
8506 case 5500: hash_type = HASH_TYPE_NETNTLM;
8507 salt_type = SALT_TYPE_EMBEDDED;
8508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8509 opts_type = OPTS_TYPE_PT_GENERATE_LE
8510 | OPTS_TYPE_PT_ADD80
8511 | OPTS_TYPE_PT_ADDBITS14
8512 | OPTS_TYPE_PT_UNICODE
8513 | OPTS_TYPE_ST_HEX;
8514 kern_type = KERN_TYPE_NETNTLMv1;
8515 dgst_size = DGST_SIZE_4_4;
8516 parse_func = netntlmv1_parse_hash;
8517 sort_by_digest = sort_by_digest_4_4;
8518 opti_type = OPTI_TYPE_ZERO_BYTE
8519 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 1;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 3;
8524 break;
8525
8526 case 5600: hash_type = HASH_TYPE_MD5;
8527 salt_type = SALT_TYPE_EMBEDDED;
8528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE
8530 | OPTS_TYPE_PT_ADD80
8531 | OPTS_TYPE_PT_ADDBITS14
8532 | OPTS_TYPE_PT_UNICODE;
8533 kern_type = KERN_TYPE_NETNTLMv2;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = netntlmv2_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544 case 5700: hash_type = HASH_TYPE_SHA256;
8545 salt_type = SALT_TYPE_NONE;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_BE
8548 | OPTS_TYPE_PT_ADD80
8549 | OPTS_TYPE_PT_ADDBITS15;
8550 kern_type = KERN_TYPE_SHA256;
8551 dgst_size = DGST_SIZE_4_8;
8552 parse_func = cisco4_parse_hash;
8553 sort_by_digest = sort_by_digest_4_8;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_PRECOMPUTE_MERKLE
8557 | OPTI_TYPE_EARLY_SKIP
8558 | OPTI_TYPE_NOT_ITERATED
8559 | OPTI_TYPE_NOT_SALTED
8560 | OPTI_TYPE_RAW_HASH;
8561 dgst_pos0 = 3;
8562 dgst_pos1 = 7;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 6;
8565 break;
8566
8567 case 5800: hash_type = HASH_TYPE_SHA1;
8568 salt_type = SALT_TYPE_INTERN;
8569 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8571 | OPTS_TYPE_ST_ADD80;
8572 kern_type = KERN_TYPE_ANDROIDPIN;
8573 dgst_size = DGST_SIZE_4_5;
8574 parse_func = androidpin_parse_hash;
8575 sort_by_digest = sort_by_digest_4_5;
8576 opti_type = OPTI_TYPE_ZERO_BYTE;
8577 dgst_pos0 = 0;
8578 dgst_pos1 = 1;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 3;
8581 break;
8582
8583 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8584 salt_type = SALT_TYPE_NONE;
8585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE
8587 | OPTS_TYPE_PT_ADD80;
8588 kern_type = KERN_TYPE_RIPEMD160;
8589 dgst_size = DGST_SIZE_4_5;
8590 parse_func = ripemd160_parse_hash;
8591 sort_by_digest = sort_by_digest_4_5;
8592 opti_type = OPTI_TYPE_ZERO_BYTE;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8600 salt_type = SALT_TYPE_NONE;
8601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_BE
8603 | OPTS_TYPE_PT_ADD80;
8604 kern_type = KERN_TYPE_WHIRLPOOL;
8605 dgst_size = DGST_SIZE_4_16;
8606 parse_func = whirlpool_parse_hash;
8607 sort_by_digest = sort_by_digest_4_16;
8608 opti_type = OPTI_TYPE_ZERO_BYTE;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 1;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 3;
8613 break;
8614
8615 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8616 salt_type = SALT_TYPE_EMBEDDED;
8617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8619 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8620 dgst_size = DGST_SIZE_4_5;
8621 parse_func = truecrypt_parse_hash_2k;
8622 sort_by_digest = sort_by_digest_4_5;
8623 opti_type = OPTI_TYPE_ZERO_BYTE;
8624 dgst_pos0 = 0;
8625 dgst_pos1 = 1;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 3;
8628 break;
8629
8630 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8631 salt_type = SALT_TYPE_EMBEDDED;
8632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8634 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8635 dgst_size = DGST_SIZE_4_5;
8636 parse_func = truecrypt_parse_hash_2k;
8637 sort_by_digest = sort_by_digest_4_5;
8638 opti_type = OPTI_TYPE_ZERO_BYTE;
8639 dgst_pos0 = 0;
8640 dgst_pos1 = 1;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 3;
8643 break;
8644
8645 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8646 salt_type = SALT_TYPE_EMBEDDED;
8647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8649 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8650 dgst_size = DGST_SIZE_4_5;
8651 parse_func = truecrypt_parse_hash_2k;
8652 sort_by_digest = sort_by_digest_4_5;
8653 opti_type = OPTI_TYPE_ZERO_BYTE;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 1;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 3;
8658 break;
8659
8660 case 6221: hash_type = HASH_TYPE_SHA512;
8661 salt_type = SALT_TYPE_EMBEDDED;
8662 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8664 kern_type = KERN_TYPE_TCSHA512_XTS512;
8665 dgst_size = DGST_SIZE_8_8;
8666 parse_func = truecrypt_parse_hash_1k;
8667 sort_by_digest = sort_by_digest_8_8;
8668 opti_type = OPTI_TYPE_ZERO_BYTE
8669 | OPTI_TYPE_USES_BITS_64;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 6222: hash_type = HASH_TYPE_SHA512;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8680 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8681 dgst_size = DGST_SIZE_8_8;
8682 parse_func = truecrypt_parse_hash_1k;
8683 sort_by_digest = sort_by_digest_8_8;
8684 opti_type = OPTI_TYPE_ZERO_BYTE
8685 | OPTI_TYPE_USES_BITS_64;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6223: hash_type = HASH_TYPE_SHA512;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8696 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8697 dgst_size = DGST_SIZE_8_8;
8698 parse_func = truecrypt_parse_hash_1k;
8699 sort_by_digest = sort_by_digest_8_8;
8700 opti_type = OPTI_TYPE_ZERO_BYTE
8701 | OPTI_TYPE_USES_BITS_64;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 1;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 3;
8706 break;
8707
8708 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
8713 dgst_size = DGST_SIZE_4_8;
8714 parse_func = truecrypt_parse_hash_1k;
8715 sort_by_digest = sort_by_digest_4_8;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
8728 dgst_size = DGST_SIZE_4_8;
8729 parse_func = truecrypt_parse_hash_1k;
8730 sort_by_digest = sort_by_digest_4_8;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
8743 dgst_size = DGST_SIZE_4_8;
8744 parse_func = truecrypt_parse_hash_1k;
8745 sort_by_digest = sort_by_digest_4_8;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8757 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8758 dgst_size = DGST_SIZE_4_5;
8759 parse_func = truecrypt_parse_hash_1k;
8760 sort_by_digest = sort_by_digest_4_5;
8761 opti_type = OPTI_TYPE_ZERO_BYTE;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 1;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 3;
8766 break;
8767
8768 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8772 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8773 dgst_size = DGST_SIZE_4_5;
8774 parse_func = truecrypt_parse_hash_1k;
8775 sort_by_digest = sort_by_digest_4_5;
8776 opti_type = OPTI_TYPE_ZERO_BYTE;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8784 salt_type = SALT_TYPE_EMBEDDED;
8785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8787 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8788 dgst_size = DGST_SIZE_4_5;
8789 parse_func = truecrypt_parse_hash_1k;
8790 sort_by_digest = sort_by_digest_4_5;
8791 opti_type = OPTI_TYPE_ZERO_BYTE;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6300: hash_type = HASH_TYPE_MD5;
8799 salt_type = SALT_TYPE_EMBEDDED;
8800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8802 kern_type = KERN_TYPE_MD5AIX;
8803 dgst_size = DGST_SIZE_4_4;
8804 parse_func = md5aix_parse_hash;
8805 sort_by_digest = sort_by_digest_4_4;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6400: hash_type = HASH_TYPE_SHA256;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8817 kern_type = KERN_TYPE_SHA256AIX;
8818 dgst_size = DGST_SIZE_4_8;
8819 parse_func = sha256aix_parse_hash;
8820 sort_by_digest = sort_by_digest_4_8;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6500: hash_type = HASH_TYPE_SHA512;
8829 salt_type = SALT_TYPE_EMBEDDED;
8830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8832 kern_type = KERN_TYPE_SHA512AIX;
8833 dgst_size = DGST_SIZE_8_8;
8834 parse_func = sha512aix_parse_hash;
8835 sort_by_digest = sort_by_digest_8_8;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6600: hash_type = HASH_TYPE_AES;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_AGILEKEY;
8849 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8850 parse_func = agilekey_parse_hash;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6700: hash_type = HASH_TYPE_SHA1;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8863 kern_type = KERN_TYPE_SHA1AIX;
8864 dgst_size = DGST_SIZE_4_5;
8865 parse_func = sha1aix_parse_hash;
8866 sort_by_digest = sort_by_digest_4_5;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6800: hash_type = HASH_TYPE_AES;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8878 kern_type = KERN_TYPE_LASTPASS;
8879 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8880 parse_func = lastpass_parse_hash;
8881 sort_by_digest = sort_by_digest_4_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 1;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 3;
8887 break;
8888
8889 case 6900: hash_type = HASH_TYPE_GOST;
8890 salt_type = SALT_TYPE_NONE;
8891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8893 kern_type = KERN_TYPE_GOST;
8894 dgst_size = DGST_SIZE_4_8;
8895 parse_func = gost_parse_hash;
8896 sort_by_digest = sort_by_digest_4_8;
8897 opti_type = OPTI_TYPE_ZERO_BYTE;
8898 dgst_pos0 = 0;
8899 dgst_pos1 = 1;
8900 dgst_pos2 = 2;
8901 dgst_pos3 = 3;
8902 break;
8903
8904 case 7100: hash_type = HASH_TYPE_SHA512;
8905 salt_type = SALT_TYPE_EMBEDDED;
8906 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8907 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8908 kern_type = KERN_TYPE_PBKDF2_SHA512;
8909 dgst_size = DGST_SIZE_8_16;
8910 parse_func = sha512osx_parse_hash;
8911 sort_by_digest = sort_by_digest_8_16;
8912 opti_type = OPTI_TYPE_ZERO_BYTE
8913 | OPTI_TYPE_USES_BITS_64;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 7200: hash_type = HASH_TYPE_SHA512;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8924 kern_type = KERN_TYPE_PBKDF2_SHA512;
8925 dgst_size = DGST_SIZE_8_16;
8926 parse_func = sha512grub_parse_hash;
8927 sort_by_digest = sort_by_digest_8_16;
8928 opti_type = OPTI_TYPE_ZERO_BYTE
8929 | OPTI_TYPE_USES_BITS_64;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 7300: hash_type = HASH_TYPE_SHA1;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_BE
8940 | OPTS_TYPE_ST_ADD80
8941 | OPTS_TYPE_ST_ADDBITS15;
8942 kern_type = KERN_TYPE_RAKP;
8943 dgst_size = DGST_SIZE_4_5;
8944 parse_func = rakp_parse_hash;
8945 sort_by_digest = sort_by_digest_4_5;
8946 opti_type = OPTI_TYPE_ZERO_BYTE
8947 | OPTI_TYPE_NOT_ITERATED;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 7400: hash_type = HASH_TYPE_SHA256;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8958 kern_type = KERN_TYPE_SHA256CRYPT;
8959 dgst_size = DGST_SIZE_4_8;
8960 parse_func = sha256crypt_parse_hash;
8961 sort_by_digest = sort_by_digest_4_8;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 7500: hash_type = HASH_TYPE_KRB5PA;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8973 kern_type = KERN_TYPE_KRB5PA;
8974 dgst_size = DGST_SIZE_4_4;
8975 parse_func = krb5pa_parse_hash;
8976 sort_by_digest = sort_by_digest_4_4;
8977 opti_type = OPTI_TYPE_ZERO_BYTE
8978 | OPTI_TYPE_NOT_ITERATED;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 7600: hash_type = HASH_TYPE_SHA1;
8986 salt_type = SALT_TYPE_INTERN;
8987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_BE
8989 | OPTS_TYPE_PT_ADD80
8990 | OPTS_TYPE_PT_ADDBITS15;
8991 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8992 dgst_size = DGST_SIZE_4_5;
8993 parse_func = redmine_parse_hash;
8994 sort_by_digest = sort_by_digest_4_5;
8995 opti_type = OPTI_TYPE_ZERO_BYTE
8996 | OPTI_TYPE_PRECOMPUTE_INIT
8997 | OPTI_TYPE_EARLY_SKIP
8998 | OPTI_TYPE_NOT_ITERATED
8999 | OPTI_TYPE_PREPENDED_SALT;
9000 dgst_pos0 = 3;
9001 dgst_pos1 = 4;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 1;
9004 break;
9005
9006 case 7700: hash_type = HASH_TYPE_SAPB;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE
9010 | OPTS_TYPE_PT_UPPER
9011 | OPTS_TYPE_ST_UPPER;
9012 kern_type = KERN_TYPE_SAPB;
9013 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9014 parse_func = sapb_parse_hash;
9015 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9016 opti_type = OPTI_TYPE_ZERO_BYTE
9017 | OPTI_TYPE_PRECOMPUTE_INIT
9018 | OPTI_TYPE_NOT_ITERATED;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 7800: hash_type = HASH_TYPE_SAPG;
9026 salt_type = SALT_TYPE_EMBEDDED;
9027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_BE
9029 | OPTS_TYPE_ST_ADD80
9030 | OPTS_TYPE_ST_UPPER;
9031 kern_type = KERN_TYPE_SAPG;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = sapg_parse_hash;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE
9036 | OPTI_TYPE_PRECOMPUTE_INIT
9037 | OPTI_TYPE_NOT_ITERATED;
9038 dgst_pos0 = 3;
9039 dgst_pos1 = 4;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 1;
9042 break;
9043
9044 case 7900: hash_type = HASH_TYPE_SHA512;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9048 kern_type = KERN_TYPE_DRUPAL7;
9049 dgst_size = DGST_SIZE_8_8;
9050 parse_func = drupal7_parse_hash;
9051 sort_by_digest = sort_by_digest_8_8;
9052 opti_type = OPTI_TYPE_ZERO_BYTE
9053 | OPTI_TYPE_USES_BITS_64;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 8000: hash_type = HASH_TYPE_SHA256;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_BE
9064 | OPTS_TYPE_PT_UNICODE
9065 | OPTS_TYPE_ST_ADD80
9066 | OPTS_TYPE_ST_HEX;
9067 kern_type = KERN_TYPE_SYBASEASE;
9068 dgst_size = DGST_SIZE_4_8;
9069 parse_func = sybasease_parse_hash;
9070 sort_by_digest = sort_by_digest_4_8;
9071 opti_type = OPTI_TYPE_ZERO_BYTE
9072 | OPTI_TYPE_PRECOMPUTE_INIT
9073 | OPTI_TYPE_EARLY_SKIP
9074 | OPTI_TYPE_NOT_ITERATED
9075 | OPTI_TYPE_RAW_HASH;
9076 dgst_pos0 = 3;
9077 dgst_pos1 = 7;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 6;
9080 break;
9081
9082 case 8100: hash_type = HASH_TYPE_SHA1;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9086 kern_type = KERN_TYPE_NETSCALER;
9087 dgst_size = DGST_SIZE_4_5;
9088 parse_func = netscaler_parse_hash;
9089 sort_by_digest = sort_by_digest_4_5;
9090 opti_type = OPTI_TYPE_ZERO_BYTE
9091 | OPTI_TYPE_PRECOMPUTE_INIT
9092 | OPTI_TYPE_PRECOMPUTE_MERKLE
9093 | OPTI_TYPE_EARLY_SKIP
9094 | OPTI_TYPE_NOT_ITERATED
9095 | OPTI_TYPE_PREPENDED_SALT
9096 | OPTI_TYPE_RAW_HASH;
9097 dgst_pos0 = 3;
9098 dgst_pos1 = 4;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 1;
9101 break;
9102
9103 case 8200: hash_type = HASH_TYPE_SHA256;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9107 kern_type = KERN_TYPE_CLOUDKEY;
9108 dgst_size = DGST_SIZE_4_8;
9109 parse_func = cloudkey_parse_hash;
9110 sort_by_digest = sort_by_digest_4_8;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 8300: hash_type = HASH_TYPE_SHA1;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE
9122 | OPTS_TYPE_ST_HEX
9123 | OPTS_TYPE_ST_ADD80;
9124 kern_type = KERN_TYPE_NSEC3;
9125 dgst_size = DGST_SIZE_4_5;
9126 parse_func = nsec3_parse_hash;
9127 sort_by_digest = sort_by_digest_4_5;
9128 opti_type = OPTI_TYPE_ZERO_BYTE;
9129 dgst_pos0 = 3;
9130 dgst_pos1 = 4;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 1;
9133 break;
9134
9135 case 8400: hash_type = HASH_TYPE_SHA1;
9136 salt_type = SALT_TYPE_INTERN;
9137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_BE
9139 | OPTS_TYPE_PT_ADD80
9140 | OPTS_TYPE_PT_ADDBITS15;
9141 kern_type = KERN_TYPE_WBB3;
9142 dgst_size = DGST_SIZE_4_5;
9143 parse_func = wbb3_parse_hash;
9144 sort_by_digest = sort_by_digest_4_5;
9145 opti_type = OPTI_TYPE_ZERO_BYTE
9146 | OPTI_TYPE_PRECOMPUTE_INIT
9147 | OPTI_TYPE_NOT_ITERATED;
9148 dgst_pos0 = 3;
9149 dgst_pos1 = 4;
9150 dgst_pos2 = 2;
9151 dgst_pos3 = 1;
9152 break;
9153
9154 case 8500: hash_type = HASH_TYPE_DESRACF;
9155 salt_type = SALT_TYPE_EMBEDDED;
9156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9157 opts_type = OPTS_TYPE_PT_GENERATE_LE
9158 | OPTS_TYPE_ST_UPPER;
9159 kern_type = KERN_TYPE_RACF;
9160 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9161 parse_func = racf_parse_hash;
9162 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9163 opti_type = OPTI_TYPE_ZERO_BYTE
9164 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 8600: hash_type = HASH_TYPE_LOTUS5;
9172 salt_type = SALT_TYPE_NONE;
9173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9175 kern_type = KERN_TYPE_LOTUS5;
9176 dgst_size = DGST_SIZE_4_4;
9177 parse_func = lotus5_parse_hash;
9178 sort_by_digest = sort_by_digest_4_4;
9179 opti_type = OPTI_TYPE_EARLY_SKIP
9180 | OPTI_TYPE_NOT_ITERATED
9181 | OPTI_TYPE_NOT_SALTED
9182 | OPTI_TYPE_RAW_HASH;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 8700: hash_type = HASH_TYPE_LOTUS6;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9193 kern_type = KERN_TYPE_LOTUS6;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = lotus6_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_EARLY_SKIP
9198 | OPTI_TYPE_NOT_ITERATED
9199 | OPTI_TYPE_RAW_HASH;
9200 dgst_pos0 = 0;
9201 dgst_pos1 = 1;
9202 dgst_pos2 = 2;
9203 dgst_pos3 = 3;
9204 break;
9205
9206 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9207 salt_type = SALT_TYPE_EMBEDDED;
9208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9209 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9210 kern_type = KERN_TYPE_ANDROIDFDE;
9211 dgst_size = DGST_SIZE_4_4;
9212 parse_func = androidfde_parse_hash;
9213 sort_by_digest = sort_by_digest_4_4;
9214 opti_type = OPTI_TYPE_ZERO_BYTE;
9215 dgst_pos0 = 0;
9216 dgst_pos1 = 1;
9217 dgst_pos2 = 2;
9218 dgst_pos3 = 3;
9219 break;
9220
9221 case 8900: hash_type = HASH_TYPE_SCRYPT;
9222 salt_type = SALT_TYPE_EMBEDDED;
9223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9225 kern_type = KERN_TYPE_SCRYPT;
9226 dgst_size = DGST_SIZE_4_8;
9227 parse_func = scrypt_parse_hash;
9228 sort_by_digest = sort_by_digest_4_8;
9229 opti_type = OPTI_TYPE_ZERO_BYTE;
9230 dgst_pos0 = 0;
9231 dgst_pos1 = 1;
9232 dgst_pos2 = 2;
9233 dgst_pos3 = 3;
9234 break;
9235
9236 case 9000: hash_type = HASH_TYPE_SHA1;
9237 salt_type = SALT_TYPE_EMBEDDED;
9238 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9239 opts_type = OPTS_TYPE_PT_GENERATE_LE
9240 | OPTS_TYPE_ST_GENERATE_LE;
9241 kern_type = KERN_TYPE_PSAFE2;
9242 dgst_size = DGST_SIZE_4_5;
9243 parse_func = psafe2_parse_hash;
9244 sort_by_digest = sort_by_digest_4_5;
9245 opti_type = OPTI_TYPE_ZERO_BYTE;
9246 dgst_pos0 = 0;
9247 dgst_pos1 = 1;
9248 dgst_pos2 = 2;
9249 dgst_pos3 = 3;
9250 break;
9251
9252 case 9100: hash_type = HASH_TYPE_LOTUS8;
9253 salt_type = SALT_TYPE_EMBEDDED;
9254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9255 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9256 kern_type = KERN_TYPE_LOTUS8;
9257 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9258 parse_func = lotus8_parse_hash;
9259 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9260 opti_type = OPTI_TYPE_ZERO_BYTE;
9261 dgst_pos0 = 0;
9262 dgst_pos1 = 1;
9263 dgst_pos2 = 2;
9264 dgst_pos3 = 3;
9265 break;
9266
9267 case 9200: hash_type = HASH_TYPE_SHA256;
9268 salt_type = SALT_TYPE_EMBEDDED;
9269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9270 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9271 kern_type = KERN_TYPE_PBKDF2_SHA256;
9272 dgst_size = DGST_SIZE_4_32;
9273 parse_func = cisco8_parse_hash;
9274 sort_by_digest = sort_by_digest_4_32;
9275 opti_type = OPTI_TYPE_ZERO_BYTE;
9276 dgst_pos0 = 0;
9277 dgst_pos1 = 1;
9278 dgst_pos2 = 2;
9279 dgst_pos3 = 3;
9280 break;
9281
9282 case 9300: hash_type = HASH_TYPE_SCRYPT;
9283 salt_type = SALT_TYPE_EMBEDDED;
9284 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9286 kern_type = KERN_TYPE_SCRYPT;
9287 dgst_size = DGST_SIZE_4_8;
9288 parse_func = cisco9_parse_hash;
9289 sort_by_digest = sort_by_digest_4_8;
9290 opti_type = OPTI_TYPE_ZERO_BYTE;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 1;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 3;
9295 break;
9296
9297 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9301 kern_type = KERN_TYPE_OFFICE2007;
9302 dgst_size = DGST_SIZE_4_4;
9303 parse_func = office2007_parse_hash;
9304 sort_by_digest = sort_by_digest_4_4;
9305 opti_type = OPTI_TYPE_ZERO_BYTE;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9313 salt_type = SALT_TYPE_EMBEDDED;
9314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9316 kern_type = KERN_TYPE_OFFICE2010;
9317 dgst_size = DGST_SIZE_4_4;
9318 parse_func = office2010_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4;
9320 opti_type = OPTI_TYPE_ZERO_BYTE;
9321 dgst_pos0 = 0;
9322 dgst_pos1 = 1;
9323 dgst_pos2 = 2;
9324 dgst_pos3 = 3;
9325 break;
9326
9327 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9328 salt_type = SALT_TYPE_EMBEDDED;
9329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9331 kern_type = KERN_TYPE_OFFICE2013;
9332 dgst_size = DGST_SIZE_4_4;
9333 parse_func = office2013_parse_hash;
9334 sort_by_digest = sort_by_digest_4_4;
9335 opti_type = OPTI_TYPE_ZERO_BYTE;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE
9346 | OPTS_TYPE_PT_ADD80
9347 | OPTS_TYPE_PT_UNICODE;
9348 kern_type = KERN_TYPE_OLDOFFICE01;
9349 dgst_size = DGST_SIZE_4_4;
9350 parse_func = oldoffice01_parse_hash;
9351 sort_by_digest = sort_by_digest_4_4;
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_PRECOMPUTE_INIT
9354 | OPTI_TYPE_NOT_ITERATED;
9355 dgst_pos0 = 0;
9356 dgst_pos1 = 1;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 3;
9359 break;
9360
9361 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9362 salt_type = SALT_TYPE_EMBEDDED;
9363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9364 opts_type = OPTS_TYPE_PT_GENERATE_LE
9365 | OPTS_TYPE_PT_ADD80;
9366 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = oldoffice01cm1_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_ZERO_BYTE
9371 | OPTI_TYPE_PRECOMPUTE_INIT
9372 | OPTI_TYPE_NOT_ITERATED;
9373 dgst_pos0 = 0;
9374 dgst_pos1 = 1;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 3;
9377 break;
9378
9379 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE
9383 | OPTS_TYPE_PT_ADD80
9384 | OPTS_TYPE_PT_UNICODE
9385 | OPTS_TYPE_PT_NEVERCRACK;
9386 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9387 dgst_size = DGST_SIZE_4_4;
9388 parse_func = oldoffice01cm2_parse_hash;
9389 sort_by_digest = sort_by_digest_4_4;
9390 opti_type = OPTI_TYPE_ZERO_BYTE
9391 | OPTI_TYPE_PRECOMPUTE_INIT
9392 | OPTI_TYPE_NOT_ITERATED;
9393 dgst_pos0 = 0;
9394 dgst_pos1 = 1;
9395 dgst_pos2 = 2;
9396 dgst_pos3 = 3;
9397 break;
9398
9399 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9400 salt_type = SALT_TYPE_EMBEDDED;
9401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9402 opts_type = OPTS_TYPE_PT_GENERATE_BE
9403 | OPTS_TYPE_PT_ADD80
9404 | OPTS_TYPE_PT_UNICODE;
9405 kern_type = KERN_TYPE_OLDOFFICE34;
9406 dgst_size = DGST_SIZE_4_4;
9407 parse_func = oldoffice34_parse_hash;
9408 sort_by_digest = sort_by_digest_4_4;
9409 opti_type = OPTI_TYPE_ZERO_BYTE
9410 | OPTI_TYPE_PRECOMPUTE_INIT
9411 | OPTI_TYPE_NOT_ITERATED;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9422 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9423 dgst_size = DGST_SIZE_4_4;
9424 parse_func = oldoffice34cm1_parse_hash;
9425 sort_by_digest = sort_by_digest_4_4;
9426 opti_type = OPTI_TYPE_ZERO_BYTE
9427 | OPTI_TYPE_PRECOMPUTE_INIT
9428 | OPTI_TYPE_NOT_ITERATED;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_BE
9439 | OPTS_TYPE_PT_ADD80
9440 | OPTS_TYPE_PT_UNICODE
9441 | OPTS_TYPE_PT_NEVERCRACK;
9442 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9443 dgst_size = DGST_SIZE_4_4;
9444 parse_func = oldoffice34cm2_parse_hash;
9445 sort_by_digest = sort_by_digest_4_4;
9446 opti_type = OPTI_TYPE_ZERO_BYTE
9447 | OPTI_TYPE_PRECOMPUTE_INIT
9448 | OPTI_TYPE_NOT_ITERATED;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 9900: hash_type = HASH_TYPE_MD5;
9456 salt_type = SALT_TYPE_NONE;
9457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9459 kern_type = KERN_TYPE_RADMIN2;
9460 dgst_size = DGST_SIZE_4_4;
9461 parse_func = radmin2_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_EARLY_SKIP
9466 | OPTI_TYPE_NOT_ITERATED
9467 | OPTI_TYPE_NOT_SALTED;
9468 dgst_pos0 = 0;
9469 dgst_pos1 = 3;
9470 dgst_pos2 = 2;
9471 dgst_pos3 = 1;
9472 break;
9473
9474 case 10000: hash_type = HASH_TYPE_SHA256;
9475 salt_type = SALT_TYPE_EMBEDDED;
9476 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9477 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9478 kern_type = KERN_TYPE_PBKDF2_SHA256;
9479 dgst_size = DGST_SIZE_4_32;
9480 parse_func = djangopbkdf2_parse_hash;
9481 sort_by_digest = sort_by_digest_4_32;
9482 opti_type = OPTI_TYPE_ZERO_BYTE;
9483 dgst_pos0 = 0;
9484 dgst_pos1 = 1;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 3;
9487 break;
9488
9489 case 10100: hash_type = HASH_TYPE_SIPHASH;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9493 kern_type = KERN_TYPE_SIPHASH;
9494 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9495 parse_func = siphash_parse_hash;
9496 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9497 opti_type = OPTI_TYPE_ZERO_BYTE
9498 | OPTI_TYPE_NOT_ITERATED
9499 | OPTI_TYPE_RAW_HASH;
9500 dgst_pos0 = 0;
9501 dgst_pos1 = 1;
9502 dgst_pos2 = 2;
9503 dgst_pos3 = 3;
9504 break;
9505
9506 case 10200: hash_type = HASH_TYPE_MD5;
9507 salt_type = SALT_TYPE_EMBEDDED;
9508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE
9510 | OPTS_TYPE_ST_ADD80
9511 | OPTS_TYPE_ST_ADDBITS14;
9512 kern_type = KERN_TYPE_HMACMD5_PW;
9513 dgst_size = DGST_SIZE_4_4;
9514 parse_func = crammd5_parse_hash;
9515 sort_by_digest = sort_by_digest_4_4;
9516 opti_type = OPTI_TYPE_ZERO_BYTE
9517 | OPTI_TYPE_NOT_ITERATED;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 3;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 1;
9522 break;
9523
9524 case 10300: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9528 kern_type = KERN_TYPE_SAPH_SHA1;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = saph_sha1_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 10400: hash_type = HASH_TYPE_PDFU16;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9543 kern_type = KERN_TYPE_PDF11;
9544 dgst_size = DGST_SIZE_4_4;
9545 parse_func = pdf11_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4;
9547 opti_type = OPTI_TYPE_ZERO_BYTE
9548 | OPTI_TYPE_NOT_ITERATED;
9549 dgst_pos0 = 0;
9550 dgst_pos1 = 1;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 3;
9553 break;
9554
9555 case 10410: hash_type = HASH_TYPE_PDFU16;
9556 salt_type = SALT_TYPE_EMBEDDED;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9559 kern_type = KERN_TYPE_PDF11CM1;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = pdf11cm1_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_NOT_ITERATED;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 10420: hash_type = HASH_TYPE_PDFU16;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9575 kern_type = KERN_TYPE_PDF11CM2;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = pdf11cm2_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_NOT_ITERATED;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 10500: hash_type = HASH_TYPE_PDFU16;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9591 kern_type = KERN_TYPE_PDF14;
9592 dgst_size = DGST_SIZE_4_4;
9593 parse_func = pdf14_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4;
9595 opti_type = OPTI_TYPE_ZERO_BYTE
9596 | OPTI_TYPE_NOT_ITERATED;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 10600: hash_type = HASH_TYPE_SHA256;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_BE
9607 | OPTS_TYPE_ST_ADD80
9608 | OPTS_TYPE_ST_ADDBITS15
9609 | OPTS_TYPE_HASH_COPY;
9610 kern_type = KERN_TYPE_SHA256_PWSLT;
9611 dgst_size = DGST_SIZE_4_8;
9612 parse_func = pdf17l3_parse_hash;
9613 sort_by_digest = sort_by_digest_4_8;
9614 opti_type = OPTI_TYPE_ZERO_BYTE
9615 | OPTI_TYPE_PRECOMPUTE_INIT
9616 | OPTI_TYPE_PRECOMPUTE_MERKLE
9617 | OPTI_TYPE_EARLY_SKIP
9618 | OPTI_TYPE_NOT_ITERATED
9619 | OPTI_TYPE_APPENDED_SALT
9620 | OPTI_TYPE_RAW_HASH;
9621 dgst_pos0 = 3;
9622 dgst_pos1 = 7;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 6;
9625 break;
9626
9627 case 10700: hash_type = HASH_TYPE_PDFU32;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE
9631 | OPTS_TYPE_HASH_COPY;
9632 kern_type = KERN_TYPE_PDF17L8;
9633 dgst_size = DGST_SIZE_4_8;
9634 parse_func = pdf17l8_parse_hash;
9635 sort_by_digest = sort_by_digest_4_8;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 10800: hash_type = HASH_TYPE_SHA384;
9645 salt_type = SALT_TYPE_NONE;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_BE
9648 | OPTS_TYPE_PT_ADD80
9649 | OPTS_TYPE_PT_ADDBITS15;
9650 kern_type = KERN_TYPE_SHA384;
9651 dgst_size = DGST_SIZE_8_8;
9652 parse_func = sha384_parse_hash;
9653 sort_by_digest = sort_by_digest_8_8;
9654 opti_type = OPTI_TYPE_ZERO_BYTE
9655 | OPTI_TYPE_PRECOMPUTE_INIT
9656 | OPTI_TYPE_PRECOMPUTE_MERKLE
9657 | OPTI_TYPE_EARLY_SKIP
9658 | OPTI_TYPE_NOT_ITERATED
9659 | OPTI_TYPE_NOT_SALTED
9660 | OPTI_TYPE_USES_BITS_64
9661 | OPTI_TYPE_RAW_HASH;
9662 dgst_pos0 = 6;
9663 dgst_pos1 = 7;
9664 dgst_pos2 = 4;
9665 dgst_pos3 = 5;
9666 break;
9667
9668 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_LE
9672 | OPTS_TYPE_ST_BASE64
9673 | OPTS_TYPE_HASH_COPY;
9674 kern_type = KERN_TYPE_PBKDF2_SHA256;
9675 dgst_size = DGST_SIZE_4_32;
9676 parse_func = pbkdf2_sha256_parse_hash;
9677 sort_by_digest = sort_by_digest_4_32;
9678 opti_type = OPTI_TYPE_ZERO_BYTE;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 1;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 3;
9683 break;
9684
9685 case 11000: hash_type = HASH_TYPE_MD5;
9686 salt_type = SALT_TYPE_INTERN;
9687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE
9689 | OPTS_TYPE_PT_ADD80;
9690 kern_type = KERN_TYPE_PRESTASHOP;
9691 dgst_size = DGST_SIZE_4_4;
9692 parse_func = prestashop_parse_hash;
9693 sort_by_digest = sort_by_digest_4_4;
9694 opti_type = OPTI_TYPE_ZERO_BYTE
9695 | OPTI_TYPE_PRECOMPUTE_INIT
9696 | OPTI_TYPE_NOT_ITERATED
9697 | OPTI_TYPE_PREPENDED_SALT;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 3;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 1;
9702 break;
9703
9704 case 11100: hash_type = HASH_TYPE_MD5;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE
9708 | OPTS_TYPE_ST_ADD80;
9709 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9710 dgst_size = DGST_SIZE_4_4;
9711 parse_func = postgresql_auth_parse_hash;
9712 sort_by_digest = sort_by_digest_4_4;
9713 opti_type = OPTI_TYPE_ZERO_BYTE
9714 | OPTI_TYPE_PRECOMPUTE_INIT
9715 | OPTI_TYPE_PRECOMPUTE_MERKLE
9716 | OPTI_TYPE_EARLY_SKIP;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 3;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 1;
9721 break;
9722
9723 case 11200: hash_type = HASH_TYPE_SHA1;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_BE
9727 | OPTS_TYPE_PT_ADD80
9728 | OPTS_TYPE_ST_HEX;
9729 kern_type = KERN_TYPE_MYSQL_AUTH;
9730 dgst_size = DGST_SIZE_4_5;
9731 parse_func = mysql_auth_parse_hash;
9732 sort_by_digest = sort_by_digest_4_5;
9733 opti_type = OPTI_TYPE_ZERO_BYTE
9734 | OPTI_TYPE_EARLY_SKIP;
9735 dgst_pos0 = 3;
9736 dgst_pos1 = 4;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 1;
9739 break;
9740
9741 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE
9745 | OPTS_TYPE_ST_HEX
9746 | OPTS_TYPE_ST_ADD80;
9747 kern_type = KERN_TYPE_BITCOIN_WALLET;
9748 dgst_size = DGST_SIZE_4_4;
9749 parse_func = bitcoin_wallet_parse_hash;
9750 sort_by_digest = sort_by_digest_4_4;
9751 opti_type = OPTI_TYPE_ZERO_BYTE;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 1;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 3;
9756 break;
9757
9758 case 11400: hash_type = HASH_TYPE_MD5;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE
9762 | OPTS_TYPE_PT_ADD80
9763 | OPTS_TYPE_HASH_COPY;
9764 kern_type = KERN_TYPE_SIP_AUTH;
9765 dgst_size = DGST_SIZE_4_4;
9766 parse_func = sip_auth_parse_hash;
9767 sort_by_digest = sort_by_digest_4_4;
9768 opti_type = OPTI_TYPE_ZERO_BYTE;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 3;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 1;
9773 break;
9774
9775 case 11500: hash_type = HASH_TYPE_CRC32;
9776 salt_type = SALT_TYPE_INTERN;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_ST_GENERATE_LE
9780 | OPTS_TYPE_ST_HEX;
9781 kern_type = KERN_TYPE_CRC32;
9782 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9783 parse_func = crc32_parse_hash;
9784 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9785 opti_type = OPTI_TYPE_ZERO_BYTE;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 11600: hash_type = HASH_TYPE_AES;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_LE
9796 | OPTS_TYPE_PT_NEVERCRACK;
9797 kern_type = KERN_TYPE_SEVEN_ZIP;
9798 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9799 parse_func = seven_zip_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9801 opti_type = OPTI_TYPE_ZERO_BYTE;
9802 dgst_pos0 = 0;
9803 dgst_pos1 = 1;
9804 dgst_pos2 = 2;
9805 dgst_pos3 = 3;
9806 break;
9807
9808 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9809 salt_type = SALT_TYPE_NONE;
9810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9811 opts_type = OPTS_TYPE_PT_GENERATE_LE
9812 | OPTS_TYPE_PT_ADD01;
9813 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9814 dgst_size = DGST_SIZE_4_8;
9815 parse_func = gost2012sbog_256_parse_hash;
9816 sort_by_digest = sort_by_digest_4_8;
9817 opti_type = OPTI_TYPE_ZERO_BYTE;
9818 dgst_pos0 = 0;
9819 dgst_pos1 = 1;
9820 dgst_pos2 = 2;
9821 dgst_pos3 = 3;
9822 break;
9823
9824 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9825 salt_type = SALT_TYPE_NONE;
9826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9827 opts_type = OPTS_TYPE_PT_GENERATE_LE
9828 | OPTS_TYPE_PT_ADD01;
9829 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9830 dgst_size = DGST_SIZE_4_16;
9831 parse_func = gost2012sbog_512_parse_hash;
9832 sort_by_digest = sort_by_digest_4_16;
9833 opti_type = OPTI_TYPE_ZERO_BYTE;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9841 salt_type = SALT_TYPE_EMBEDDED;
9842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE
9844 | OPTS_TYPE_ST_BASE64
9845 | OPTS_TYPE_HASH_COPY;
9846 kern_type = KERN_TYPE_PBKDF2_MD5;
9847 dgst_size = DGST_SIZE_4_32;
9848 parse_func = pbkdf2_md5_parse_hash;
9849 sort_by_digest = sort_by_digest_4_32;
9850 opti_type = OPTI_TYPE_ZERO_BYTE;
9851 dgst_pos0 = 0;
9852 dgst_pos1 = 1;
9853 dgst_pos2 = 2;
9854 dgst_pos3 = 3;
9855 break;
9856
9857 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9858 salt_type = SALT_TYPE_EMBEDDED;
9859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE
9861 | OPTS_TYPE_ST_BASE64
9862 | OPTS_TYPE_HASH_COPY;
9863 kern_type = KERN_TYPE_PBKDF2_SHA1;
9864 dgst_size = DGST_SIZE_4_32;
9865 parse_func = pbkdf2_sha1_parse_hash;
9866 sort_by_digest = sort_by_digest_4_32;
9867 opti_type = OPTI_TYPE_ZERO_BYTE;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 1;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 3;
9872 break;
9873
9874 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_ST_BASE64
9879 | OPTS_TYPE_HASH_COPY;
9880 kern_type = KERN_TYPE_PBKDF2_SHA512;
9881 dgst_size = DGST_SIZE_8_16;
9882 parse_func = pbkdf2_sha512_parse_hash;
9883 sort_by_digest = sort_by_digest_8_16;
9884 opti_type = OPTI_TYPE_ZERO_BYTE
9885 | OPTI_TYPE_USES_BITS_64;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9896 kern_type = KERN_TYPE_ECRYPTFS;
9897 dgst_size = DGST_SIZE_8_8;
9898 parse_func = ecryptfs_parse_hash;
9899 sort_by_digest = sort_by_digest_8_8;
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_USES_BITS_64;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 12300: hash_type = HASH_TYPE_ORACLET;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9912 kern_type = KERN_TYPE_ORACLET;
9913 dgst_size = DGST_SIZE_8_16;
9914 parse_func = oraclet_parse_hash;
9915 sort_by_digest = sort_by_digest_8_16;
9916 opti_type = OPTI_TYPE_ZERO_BYTE
9917 | OPTI_TYPE_USES_BITS_64;
9918 dgst_pos0 = 0;
9919 dgst_pos1 = 1;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 3;
9922 break;
9923
9924 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9928 kern_type = KERN_TYPE_BSDICRYPT;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = bsdicrypt_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4;
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 12500: hash_type = HASH_TYPE_RAR3HP;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9944 kern_type = KERN_TYPE_RAR3;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = rar3hp_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4;
9948 opti_type = OPTI_TYPE_ZERO_BYTE;
9949 dgst_pos0 = 0;
9950 dgst_pos1 = 1;
9951 dgst_pos2 = 2;
9952 dgst_pos3 = 3;
9953 break;
9954
9955 case 12600: hash_type = HASH_TYPE_SHA256;
9956 salt_type = SALT_TYPE_INTERN;
9957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9958 opts_type = OPTS_TYPE_PT_GENERATE_BE
9959 | OPTS_TYPE_PT_ADD80;
9960 kern_type = KERN_TYPE_CF10;
9961 dgst_size = DGST_SIZE_4_8;
9962 parse_func = cf10_parse_hash;
9963 sort_by_digest = sort_by_digest_4_8;
9964 opti_type = OPTI_TYPE_ZERO_BYTE
9965 | OPTI_TYPE_PRECOMPUTE_INIT
9966 | OPTI_TYPE_EARLY_SKIP
9967 | OPTI_TYPE_NOT_ITERATED;
9968 dgst_pos0 = 3;
9969 dgst_pos1 = 7;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 6;
9972 break;
9973
9974 case 12700: hash_type = HASH_TYPE_AES;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE
9978 | OPTS_TYPE_HASH_COPY;
9979 kern_type = KERN_TYPE_MYWALLET;
9980 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9981 parse_func = mywallet_parse_hash;
9982 sort_by_digest = sort_by_digest_4_5;
9983 opti_type = OPTI_TYPE_ZERO_BYTE;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9994 kern_type = KERN_TYPE_MS_DRSR;
9995 dgst_size = DGST_SIZE_4_8;
9996 parse_func = ms_drsr_parse_hash;
9997 sort_by_digest = sort_by_digest_4_8;
9998 opti_type = OPTI_TYPE_ZERO_BYTE;
9999 dgst_pos0 = 0;
10000 dgst_pos1 = 1;
10001 dgst_pos2 = 2;
10002 dgst_pos3 = 3;
10003 break;
10004
10005 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10009 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10010 dgst_size = DGST_SIZE_4_8;
10011 parse_func = androidfde_samsung_parse_hash;
10012 sort_by_digest = sort_by_digest_4_8;
10013 opti_type = OPTI_TYPE_ZERO_BYTE;
10014 dgst_pos0 = 0;
10015 dgst_pos1 = 1;
10016 dgst_pos2 = 2;
10017 dgst_pos3 = 3;
10018 break;
10019
10020 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10021 salt_type = SALT_TYPE_EMBEDDED;
10022 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10023 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10024 kern_type = KERN_TYPE_RAR5;
10025 dgst_size = DGST_SIZE_4_4;
10026 parse_func = rar5_parse_hash;
10027 sort_by_digest = sort_by_digest_4_4;
10028 opti_type = OPTI_TYPE_ZERO_BYTE;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 default: usage_mini_print (PROGNAME); return (-1);
10036 }
10037
10038 /**
10039 * transpose
10040 */
10041
10042 data.parse_func = parse_func;
10043
10044 /**
10045 * misc stuff
10046 */
10047
10048 if (hex_salt)
10049 {
10050 if (salt_type == SALT_TYPE_INTERN)
10051 {
10052 opts_type |= OPTS_TYPE_ST_HEX;
10053 }
10054 else
10055 {
10056 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10057
10058 return (-1);
10059 }
10060 }
10061
10062 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10063 | (salt_type == SALT_TYPE_EXTERN)
10064 | (salt_type == SALT_TYPE_EMBEDDED)
10065 | (salt_type == SALT_TYPE_VIRTUAL));
10066
10067 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10068
10069 data.hash_type = hash_type;
10070 data.attack_mode = attack_mode;
10071 data.attack_kern = attack_kern;
10072 data.attack_exec = attack_exec;
10073 data.kern_type = kern_type;
10074 data.opts_type = opts_type;
10075 data.dgst_size = dgst_size;
10076 data.salt_type = salt_type;
10077 data.isSalted = isSalted;
10078 data.sort_by_digest = sort_by_digest;
10079 data.dgst_pos0 = dgst_pos0;
10080 data.dgst_pos1 = dgst_pos1;
10081 data.dgst_pos2 = dgst_pos2;
10082 data.dgst_pos3 = dgst_pos3;
10083
10084 esalt_size = 0;
10085
10086 switch (hash_mode)
10087 {
10088 case 2500: esalt_size = sizeof (wpa_t); break;
10089 case 5300: esalt_size = sizeof (ikepsk_t); break;
10090 case 5400: esalt_size = sizeof (ikepsk_t); break;
10091 case 5500: esalt_size = sizeof (netntlm_t); break;
10092 case 5600: esalt_size = sizeof (netntlm_t); break;
10093 case 6211:
10094 case 6212:
10095 case 6213:
10096 case 6221:
10097 case 6222:
10098 case 6223:
10099 case 6231:
10100 case 6232:
10101 case 6233:
10102 case 6241:
10103 case 6242:
10104 case 6243: esalt_size = sizeof (tc_t); break;
10105 case 6600: esalt_size = sizeof (agilekey_t); break;
10106 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10107 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10108 case 7300: esalt_size = sizeof (rakp_t); break;
10109 case 7500: esalt_size = sizeof (krb5pa_t); break;
10110 case 8200: esalt_size = sizeof (cloudkey_t); break;
10111 case 8800: esalt_size = sizeof (androidfde_t); break;
10112 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10113 case 9400: esalt_size = sizeof (office2007_t); break;
10114 case 9500: esalt_size = sizeof (office2010_t); break;
10115 case 9600: esalt_size = sizeof (office2013_t); break;
10116 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10117 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10118 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10119 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10120 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10121 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10122 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10123 case 10200: esalt_size = sizeof (cram_md5_t); break;
10124 case 10400: esalt_size = sizeof (pdf_t); break;
10125 case 10410: esalt_size = sizeof (pdf_t); break;
10126 case 10420: esalt_size = sizeof (pdf_t); break;
10127 case 10500: esalt_size = sizeof (pdf_t); break;
10128 case 10600: esalt_size = sizeof (pdf_t); break;
10129 case 10700: esalt_size = sizeof (pdf_t); break;
10130 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10131 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10132 case 11400: esalt_size = sizeof (sip_t); break;
10133 case 11600: esalt_size = sizeof (seven_zip_t); break;
10134 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10135 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10136 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10137 case 13000: esalt_size = sizeof (rar5_t); break;
10138 }
10139
10140 data.esalt_size = esalt_size;
10141
10142 /**
10143 * choose dictionary parser
10144 */
10145
10146 if (hash_type == HASH_TYPE_LM)
10147 {
10148 get_next_word_func = get_next_word_lm;
10149 }
10150 else if (opts_type & OPTS_TYPE_PT_UPPER)
10151 {
10152 get_next_word_func = get_next_word_uc;
10153 }
10154 else
10155 {
10156 get_next_word_func = get_next_word_std;
10157 }
10158
10159 /**
10160 * dictstat
10161 */
10162
10163 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10164
10165 #ifdef _POSIX
10166 size_t dictstat_nmemb = 0;
10167 #endif
10168
10169 #ifdef _WIN
10170 uint dictstat_nmemb = 0;
10171 #endif
10172
10173 char dictstat[256] = { 0 };
10174
10175 FILE *dictstat_fp = NULL;
10176
10177 if (keyspace == 0)
10178 {
10179 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10180
10181 dictstat_fp = fopen (dictstat, "rb");
10182
10183 if (dictstat_fp)
10184 {
10185 #ifdef _POSIX
10186 struct stat tmpstat;
10187
10188 fstat (fileno (dictstat_fp), &tmpstat);
10189 #endif
10190
10191 #ifdef _WIN
10192 struct stat64 tmpstat;
10193
10194 _fstat64 (fileno (dictstat_fp), &tmpstat);
10195 #endif
10196
10197 if (tmpstat.st_mtime < COMPTIME)
10198 {
10199 /* with v0.15 the format changed so we have to ensure user is using a good version
10200 since there is no version-header in the dictstat file */
10201
10202 fclose (dictstat_fp);
10203
10204 unlink (dictstat);
10205 }
10206 else
10207 {
10208 while (!feof (dictstat_fp))
10209 {
10210 dictstat_t d;
10211
10212 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10213
10214 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10215
10216 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10217 {
10218 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10219
10220 return -1;
10221 }
10222 }
10223
10224 fclose (dictstat_fp);
10225 }
10226 }
10227 }
10228
10229 /**
10230 * potfile
10231 */
10232
10233 char potfile[256] = { 0 };
10234
10235 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10236
10237 data.pot_fp = NULL;
10238
10239 FILE *out_fp = NULL;
10240 FILE *pot_fp = NULL;
10241
10242 if (show == 1 || left == 1)
10243 {
10244 pot_fp = fopen (potfile, "rb");
10245
10246 if (pot_fp == NULL)
10247 {
10248 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10249
10250 return (-1);
10251 }
10252
10253 if (outfile != NULL)
10254 {
10255 if ((out_fp = fopen (outfile, "ab")) == NULL)
10256 {
10257 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10258
10259 fclose (pot_fp);
10260
10261 return (-1);
10262 }
10263 }
10264 else
10265 {
10266 out_fp = stdout;
10267 }
10268 }
10269 else
10270 {
10271 if (potfile_disable == 0)
10272 {
10273 pot_fp = fopen (potfile, "ab");
10274
10275 if (pot_fp == NULL)
10276 {
10277 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10278
10279 return (-1);
10280 }
10281
10282 data.pot_fp = pot_fp;
10283 }
10284 }
10285
10286 pot_t *pot = NULL;
10287
10288 uint pot_cnt = 0;
10289 uint pot_avail = 0;
10290
10291 if (show == 1 || left == 1)
10292 {
10293 SUPPRESS_OUTPUT = 1;
10294
10295 pot_avail = count_lines (pot_fp);
10296
10297 rewind (pot_fp);
10298
10299 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10300
10301 uint pot_hashes_avail = 0;
10302
10303 uint line_num = 0;
10304
10305 while (!feof (pot_fp))
10306 {
10307 line_num++;
10308
10309 char line_buf[BUFSIZ] = { 0 };
10310
10311 int line_len = fgetl (pot_fp, line_buf);
10312
10313 if (line_len == 0) continue;
10314
10315 char *plain_buf = line_buf + line_len;
10316
10317 pot_t *pot_ptr = &pot[pot_cnt];
10318
10319 hash_t *hashes_buf = &pot_ptr->hash;
10320
10321 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10322 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10323
10324 if (pot_cnt == pot_hashes_avail)
10325 {
10326 uint pos = 0;
10327
10328 for (pos = 0; pos < INCR_POT; pos++)
10329 {
10330 if ((pot_cnt + pos) >= pot_avail) break;
10331
10332 pot_t *tmp_pot = &pot[pot_cnt + pos];
10333
10334 hash_t *tmp_hash = &tmp_pot->hash;
10335
10336 tmp_hash->digest = mymalloc (dgst_size);
10337
10338 if (isSalted)
10339 {
10340 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10341 }
10342
10343 if (esalt_size)
10344 {
10345 tmp_hash->esalt = mymalloc (esalt_size);
10346 }
10347
10348 pot_hashes_avail++;
10349 }
10350 }
10351
10352 int plain_len = 0;
10353
10354 int parser_status;
10355
10356 int iter = MAX_CUT_TRIES;
10357
10358 do
10359 {
10360 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10361 {
10362 if (line_buf[i] == ':')
10363 {
10364 line_len--;
10365
10366 break;
10367 }
10368 }
10369
10370 if (data.hash_mode != 2500)
10371 {
10372 parser_status = parse_func (line_buf, line_len, hashes_buf);
10373 }
10374 else
10375 {
10376 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10377
10378 if (line_len > max_salt_size)
10379 {
10380 parser_status = PARSER_GLOBAL_LENGTH;
10381 }
10382 else
10383 {
10384 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10385
10386 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10387
10388 hashes_buf->salt->salt_len = line_len;
10389
10390 parser_status = PARSER_OK;
10391 }
10392 }
10393
10394 // if NOT parsed without error, we add the ":" to the plain
10395
10396 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10397 {
10398 plain_len++;
10399 plain_buf--;
10400 }
10401
10402 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10403
10404 if (parser_status < PARSER_GLOBAL_ZERO)
10405 {
10406 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10407
10408 continue;
10409 }
10410
10411 if (plain_len >= 255) continue;
10412
10413 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10414
10415 pot_ptr->plain_len = plain_len;
10416
10417 pot_cnt++;
10418 }
10419
10420 fclose (pot_fp);
10421
10422 SUPPRESS_OUTPUT = 0;
10423
10424 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10425 }
10426
10427 /**
10428 * word len
10429 */
10430
10431 uint pw_min = PW_MIN;
10432 uint pw_max = PW_MAX;
10433
10434 switch (hash_mode)
10435 {
10436 case 400: if (pw_max > 40) pw_max = 40;
10437 break;
10438 case 500: if (pw_max > 16) pw_max = 16;
10439 break;
10440 case 1500: if (pw_max > 8) pw_max = 8;
10441 break;
10442 case 1600: if (pw_max > 16) pw_max = 16;
10443 break;
10444 case 1800: if (pw_max > 16) pw_max = 16;
10445 break;
10446 case 2100: if (pw_max > 16) pw_max = 16;
10447 break;
10448 case 2500: if (pw_min < 8) pw_min = 8;
10449 break;
10450 case 3000: if (pw_max > 7) pw_max = 7;
10451 break;
10452 case 5200: if (pw_max > 24) pw_max = 24;
10453 break;
10454 case 5800: if (pw_max > 16) pw_max = 16;
10455 break;
10456 case 6300: if (pw_max > 16) pw_max = 16;
10457 break;
10458 case 7400: if (pw_max > 16) pw_max = 16;
10459 break;
10460 case 7900: if (pw_max > 48) pw_max = 48;
10461 break;
10462 case 8500: if (pw_max > 8) pw_max = 8;
10463 break;
10464 case 8600: if (pw_max > 16) pw_max = 16;
10465 break;
10466 case 9710: pw_min = 5;
10467 pw_max = 5;
10468 break;
10469 case 9810: pw_min = 5;
10470 pw_max = 5;
10471 break;
10472 case 10410: pw_min = 5;
10473 pw_max = 5;
10474 break;
10475 case 10300: if (pw_max < 3) pw_min = 3;
10476 if (pw_max > 40) pw_max = 40;
10477 break;
10478 case 10500: if (pw_max < 3) pw_min = 3;
10479 if (pw_max > 40) pw_max = 40;
10480 break;
10481 case 10700: if (pw_max > 16) pw_max = 16;
10482 break;
10483 case 11300: if (pw_max > 40) pw_max = 40;
10484 break;
10485 case 12500: if (pw_max > 20) pw_max = 20;
10486 break;
10487 case 12800: if (pw_max > 24) pw_max = 24;
10488 break;
10489 }
10490
10491 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10492 {
10493 switch (attack_kern)
10494 {
10495 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10496 break;
10497 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10498 break;
10499 }
10500 }
10501
10502 /**
10503 * charsets : keep them together for more easy maintainnce
10504 */
10505
10506 cs_t mp_sys[6] = { { { 0 }, 0 } };
10507 cs_t mp_usr[4] = { { { 0 }, 0 } };
10508
10509 mp_setup_sys (mp_sys);
10510
10511 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10512 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10513 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10514 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10515
10516 /**
10517 * load hashes, part I: find input mode, count hashes
10518 */
10519
10520 uint hashlist_mode = 0;
10521 uint hashlist_format = HLFMT_HASHCAT;
10522
10523 uint hashes_avail = 0;
10524
10525 if (benchmark == 0)
10526 {
10527 struct stat f;
10528
10529 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10530
10531 if ((hash_mode == 2500) ||
10532 (hash_mode == 5200) ||
10533 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10534 (hash_mode == 9000))
10535 {
10536 hashlist_mode = HL_MODE_ARG;
10537
10538 char *hashfile = myargv[optind];
10539
10540 data.hashfile = hashfile;
10541
10542 logfile_top_var_string ("target", hashfile);
10543 }
10544
10545 if (hashlist_mode == HL_MODE_ARG)
10546 {
10547 if (hash_mode == 2500)
10548 {
10549 struct stat st;
10550
10551 if (stat (data.hashfile, &st) == -1)
10552 {
10553 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10554
10555 return (-1);
10556 }
10557
10558 hashes_avail = st.st_size / sizeof (hccap_t);
10559 }
10560 else
10561 {
10562 hashes_avail = 1;
10563 }
10564 }
10565 else if (hashlist_mode == HL_MODE_FILE)
10566 {
10567 char *hashfile = myargv[optind];
10568
10569 data.hashfile = hashfile;
10570
10571 logfile_top_var_string ("target", hashfile);
10572
10573 FILE *fp = NULL;
10574
10575 if ((fp = fopen (hashfile, "rb")) == NULL)
10576 {
10577 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10578
10579 return (-1);
10580 }
10581
10582 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10583
10584 hashes_avail = count_lines (fp);
10585
10586 rewind (fp);
10587
10588 if (hashes_avail == 0)
10589 {
10590 log_error ("ERROR: hashfile is empty or corrupt");
10591
10592 fclose (fp);
10593
10594 return (-1);
10595 }
10596
10597 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10598
10599 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10600 {
10601 log_error ("ERROR: remove not supported in native hashfile-format mode");
10602
10603 fclose (fp);
10604
10605 return (-1);
10606 }
10607
10608 fclose (fp);
10609 }
10610 }
10611 else
10612 {
10613 hashlist_mode = HL_MODE_ARG;
10614
10615 hashes_avail = 1;
10616 }
10617
10618 if (hash_mode == 3000) hashes_avail *= 2;
10619
10620 data.hashlist_mode = hashlist_mode;
10621 data.hashlist_format = hashlist_format;
10622
10623 logfile_top_uint (hashlist_mode);
10624 logfile_top_uint (hashlist_format);
10625
10626 /**
10627 * load hashes, part II: allocate required memory, set pointers
10628 */
10629
10630 hash_t *hashes_buf = NULL;
10631 void *digests_buf = NULL;
10632 salt_t *salts_buf = NULL;
10633 void *esalts_buf = NULL;
10634
10635 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10636
10637 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10638
10639 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10640 {
10641 u32 hash_pos;
10642
10643 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10644 {
10645 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10646
10647 hashes_buf[hash_pos].hash_info = hash_info;
10648
10649 if (username && (remove || show || left))
10650 {
10651 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10652 }
10653
10654 if (benchmark)
10655 {
10656 hash_info->orighash = (char *) mymalloc (256);
10657 }
10658 }
10659 }
10660
10661 if (isSalted)
10662 {
10663 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10664
10665 if (esalt_size)
10666 {
10667 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10668 }
10669 }
10670 else
10671 {
10672 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10673 }
10674
10675 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10676 {
10677 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10678
10679 if (isSalted)
10680 {
10681 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10682
10683 if (esalt_size)
10684 {
10685 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10686 }
10687 }
10688 else
10689 {
10690 hashes_buf[hash_pos].salt = &salts_buf[0];
10691 }
10692 }
10693
10694 /**
10695 * load hashes, part III: parse hashes or generate them if benchmark
10696 */
10697
10698 uint hashes_cnt = 0;
10699
10700 if (benchmark == 0)
10701 {
10702 if (keyspace == 1)
10703 {
10704 // useless to read hash file for keyspace, cheat a little bit w/ optind
10705 }
10706 else if (hashes_avail == 0)
10707 {
10708 }
10709 else if (hashlist_mode == HL_MODE_ARG)
10710 {
10711 char *input_buf = myargv[optind];
10712
10713 uint input_len = strlen (input_buf);
10714
10715 logfile_top_var_string ("target", input_buf);
10716
10717 char *hash_buf = NULL;
10718 int hash_len = 0;
10719
10720 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10721
10722 if (hash_len)
10723 {
10724 if (opts_type & OPTS_TYPE_HASH_COPY)
10725 {
10726 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10727
10728 hash_info_tmp->orighash = mystrdup (hash_buf);
10729 }
10730
10731 if (isSalted)
10732 {
10733 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10734 }
10735
10736 int parser_status = PARSER_OK;
10737
10738 if (hash_mode == 2500)
10739 {
10740 if (hash_len == 0)
10741 {
10742 log_error ("ERROR: hccap file not specified");
10743
10744 return (-1);
10745 }
10746
10747 hashlist_mode = HL_MODE_FILE;
10748
10749 data.hashlist_mode = hashlist_mode;
10750
10751 FILE *fp = fopen (hash_buf, "rb");
10752
10753 if (fp == NULL)
10754 {
10755 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10756
10757 return (-1);
10758 }
10759
10760 if (hashes_avail < 1)
10761 {
10762 log_error ("ERROR: hccap file is empty or corrupt");
10763
10764 fclose (fp);
10765
10766 return (-1);
10767 }
10768
10769 uint hccap_size = sizeof (hccap_t);
10770
10771 char *in = (char *) mymalloc (hccap_size);
10772
10773 while (!feof (fp))
10774 {
10775 int n = fread (in, hccap_size, 1, fp);
10776
10777 if (n != 1)
10778 {
10779 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10780
10781 break;
10782 }
10783
10784 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10785
10786 if (parser_status != PARSER_OK)
10787 {
10788 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10789
10790 continue;
10791 }
10792
10793 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10794
10795 if ((show == 1) || (left == 1))
10796 {
10797 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10798
10799 char *salt_ptr = (char *) tmp_salt->salt_buf;
10800
10801 int cur_pos = tmp_salt->salt_len;
10802 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10803
10804 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10805
10806 u8 *pke_ptr = (u8 *) wpa->pke;
10807
10808 // do the appending task
10809
10810 snprintf (salt_ptr + cur_pos,
10811 rem_len,
10812 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10813 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10814 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10815
10816
10817 // memset () the remaining part of the salt
10818
10819 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10820 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10821
10822 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10823
10824 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10825 }
10826
10827 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);
10828 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);
10829
10830 hashes_cnt++;
10831 }
10832
10833 fclose (fp);
10834
10835 myfree (in);
10836 }
10837 else if (hash_mode == 3000)
10838 {
10839 if (hash_len == 32)
10840 {
10841 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10842
10843 hash_t *lm_hash_left = NULL;
10844
10845 if (parser_status == PARSER_OK)
10846 {
10847 lm_hash_left = &hashes_buf[hashes_cnt];
10848
10849 hashes_cnt++;
10850 }
10851 else
10852 {
10853 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10854 }
10855
10856 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10857
10858 hash_t *lm_hash_right = NULL;
10859
10860 if (parser_status == PARSER_OK)
10861 {
10862 lm_hash_right = &hashes_buf[hashes_cnt];
10863
10864 hashes_cnt++;
10865 }
10866 else
10867 {
10868 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10869 }
10870
10871 // show / left
10872
10873 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10874 {
10875 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);
10876 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);
10877 }
10878 }
10879 else
10880 {
10881 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10882
10883 if (parser_status == PARSER_OK)
10884 {
10885 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10886 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10887 }
10888
10889 if (parser_status == PARSER_OK)
10890 {
10891 hashes_cnt++;
10892 }
10893 else
10894 {
10895 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10896 }
10897 }
10898 }
10899 else
10900 {
10901 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10902
10903 if (parser_status == PARSER_OK)
10904 {
10905 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10906 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10907 }
10908
10909 if (parser_status == PARSER_OK)
10910 {
10911 hashes_cnt++;
10912 }
10913 else
10914 {
10915 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10916 }
10917 }
10918 }
10919 }
10920 else if (hashlist_mode == HL_MODE_FILE)
10921 {
10922 char *hashfile = data.hashfile;
10923
10924 FILE *fp;
10925
10926 if ((fp = fopen (hashfile, "rb")) == NULL)
10927 {
10928 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10929
10930 return (-1);
10931 }
10932
10933 uint line_num = 0;
10934
10935 while (!feof (fp))
10936 {
10937 line_num++;
10938
10939 char line_buf[BUFSIZ] = { 0 };
10940
10941 int line_len = fgetl (fp, line_buf);
10942
10943 if (line_len == 0) continue;
10944
10945 char *hash_buf = NULL;
10946 int hash_len = 0;
10947
10948 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10949
10950 if (username)
10951 {
10952 char *user_buf = NULL;
10953 int user_len = 0;
10954
10955 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10956
10957 if (remove || show)
10958 {
10959 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10960
10961 *user = (user_t *) mymalloc (sizeof (user_t));
10962
10963 user_t *user_ptr = *user;
10964
10965 if (user_buf != NULL)
10966 {
10967 user_ptr->user_name = mystrdup (user_buf);
10968 }
10969 else
10970 {
10971 user_ptr->user_name = mystrdup ("");
10972 }
10973
10974 user_ptr->user_len = user_len;
10975 }
10976 }
10977
10978 if (opts_type & OPTS_TYPE_HASH_COPY)
10979 {
10980 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10981
10982 hash_info_tmp->orighash = mystrdup (hash_buf);
10983 }
10984
10985 if (isSalted)
10986 {
10987 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10988 }
10989
10990 if (hash_mode == 3000)
10991 {
10992 if (hash_len == 32)
10993 {
10994 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10995
10996 if (parser_status < PARSER_GLOBAL_ZERO)
10997 {
10998 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10999
11000 continue;
11001 }
11002
11003 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11004
11005 hashes_cnt++;
11006
11007 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11008
11009 if (parser_status < PARSER_GLOBAL_ZERO)
11010 {
11011 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11012
11013 continue;
11014 }
11015
11016 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11017
11018 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);
11019
11020 hashes_cnt++;
11021
11022 // show / left
11023
11024 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);
11025 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);
11026 }
11027 else
11028 {
11029 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11030
11031 if (parser_status < PARSER_GLOBAL_ZERO)
11032 {
11033 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11034
11035 continue;
11036 }
11037
11038 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);
11039
11040 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11041 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11042
11043 hashes_cnt++;
11044 }
11045 }
11046 else
11047 {
11048 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11049
11050 if (parser_status < PARSER_GLOBAL_ZERO)
11051 {
11052 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11053
11054 continue;
11055 }
11056
11057 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);
11058
11059 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11060 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11061
11062 hashes_cnt++;
11063 }
11064 }
11065
11066 fclose (fp);
11067
11068 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11069
11070 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11071 }
11072 }
11073 else
11074 {
11075 if (isSalted)
11076 {
11077 hashes_buf[0].salt->salt_len = 8;
11078
11079 // special salt handling
11080
11081 switch (hash_mode)
11082 {
11083 case 1500: hashes_buf[0].salt->salt_len = 2;
11084 break;
11085 case 1731: hashes_buf[0].salt->salt_len = 4;
11086 break;
11087 case 2410: hashes_buf[0].salt->salt_len = 4;
11088 break;
11089 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11090 break;
11091 case 3100: hashes_buf[0].salt->salt_len = 1;
11092 break;
11093 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11094 break;
11095 case 5800: hashes_buf[0].salt->salt_len = 16;
11096 break;
11097 case 6800: hashes_buf[0].salt->salt_len = 32;
11098 break;
11099 case 8400: hashes_buf[0].salt->salt_len = 40;
11100 break;
11101 case 8800: hashes_buf[0].salt->salt_len = 16;
11102 break;
11103 case 8900: hashes_buf[0].salt->salt_len = 16;
11104 hashes_buf[0].salt->scrypt_N = 1024;
11105 hashes_buf[0].salt->scrypt_r = 1;
11106 hashes_buf[0].salt->scrypt_p = 1;
11107 break;
11108 case 9100: hashes_buf[0].salt->salt_len = 16;
11109 break;
11110 case 9300: hashes_buf[0].salt->salt_len = 14;
11111 hashes_buf[0].salt->scrypt_N = 16384;
11112 hashes_buf[0].salt->scrypt_r = 1;
11113 hashes_buf[0].salt->scrypt_p = 1;
11114 break;
11115 case 9400: hashes_buf[0].salt->salt_len = 16;
11116 break;
11117 case 9500: hashes_buf[0].salt->salt_len = 16;
11118 break;
11119 case 9600: hashes_buf[0].salt->salt_len = 16;
11120 break;
11121 case 9700: hashes_buf[0].salt->salt_len = 16;
11122 break;
11123 case 9710: hashes_buf[0].salt->salt_len = 16;
11124 break;
11125 case 9720: hashes_buf[0].salt->salt_len = 16;
11126 break;
11127 case 9800: hashes_buf[0].salt->salt_len = 16;
11128 break;
11129 case 9810: hashes_buf[0].salt->salt_len = 16;
11130 break;
11131 case 9820: hashes_buf[0].salt->salt_len = 16;
11132 break;
11133 case 10300: hashes_buf[0].salt->salt_len = 12;
11134 break;
11135 case 11500: hashes_buf[0].salt->salt_len = 4;
11136 break;
11137 case 11600: hashes_buf[0].salt->salt_len = 4;
11138 break;
11139 case 12400: hashes_buf[0].salt->salt_len = 4;
11140 break;
11141 case 12500: hashes_buf[0].salt->salt_len = 8;
11142 break;
11143 case 12600: hashes_buf[0].salt->salt_len = 64;
11144 break;
11145 }
11146
11147 // special esalt handling
11148
11149 switch (hash_mode)
11150 {
11151 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11152 break;
11153 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11154 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11155 break;
11156 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11157 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11158 break;
11159 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11160 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11161 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11162 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11163 break;
11164 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11165 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11166 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11167 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11168 break;
11169 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11170 break;
11171 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11172 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11173 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11174 break;
11175 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11176 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11177 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11178 break;
11179 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11180 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11181 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11182 break;
11183 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11184 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11185 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11186 break;
11187 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11188 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11189 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11190 break;
11191 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11192 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11193 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11194 break;
11195 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11196 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11197 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11198 break;
11199 }
11200 }
11201
11202 // set hashfile
11203
11204 switch (hash_mode)
11205 {
11206 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11207 break;
11208 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11209 break;
11210 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11211 break;
11212 case 6211:
11213 case 6212:
11214 case 6213:
11215 case 6221:
11216 case 6222:
11217 case 6223:
11218 case 6231:
11219 case 6232:
11220 case 6233:
11221 case 6241:
11222 case 6242:
11223 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11224 break;
11225 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11226 break;
11227 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11228 break;
11229 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11230 break;
11231 }
11232
11233 // set default iterations
11234
11235 switch (hash_mode)
11236 {
11237 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11238 break;
11239 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11240 break;
11241 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11242 break;
11243 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11244 break;
11245 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11246 break;
11247 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11248 break;
11249 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11250 break;
11251 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11252 break;
11253 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11254 break;
11255 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11256 break;
11257 case 6211:
11258 case 6212:
11259 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11260 break;
11261 case 6221:
11262 case 6222:
11263 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11264 break;
11265 case 6231:
11266 case 6232:
11267 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11268 break;
11269 case 6241:
11270 case 6242:
11271 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11272 break;
11273 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11274 break;
11275 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11276 break;
11277 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11278 break;
11279 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11280 break;
11281 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11282 break;
11283 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11284 break;
11285 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11286 break;
11287 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11288 break;
11289 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11290 break;
11291 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11292 break;
11293 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11294 break;
11295 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11296 break;
11297 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11298 break;
11299 case 8900: hashes_buf[0].salt->salt_iter = 1;
11300 break;
11301 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11302 break;
11303 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11304 break;
11305 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11306 break;
11307 case 9300: hashes_buf[0].salt->salt_iter = 1;
11308 break;
11309 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11310 break;
11311 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11312 break;
11313 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11314 break;
11315 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11316 break;
11317 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11318 break;
11319 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11320 break;
11321 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11322 break;
11323 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11324 break;
11325 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11326 break;
11327 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11328 break;
11329 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11330 break;
11331 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11332 break;
11333 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11334 break;
11335 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11336 break;
11337 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11338 break;
11339 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11340 break;
11341 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11342 break;
11343 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11344 break;
11345 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11346 break;
11347 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11348 break;
11349 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11350 break;
11351 }
11352
11353 hashes_cnt = 1;
11354 }
11355
11356 if (show == 1 || left == 1)
11357 {
11358 for (uint i = 0; i < pot_cnt; i++)
11359 {
11360 pot_t *pot_ptr = &pot[i];
11361
11362 hash_t *hashes_buf = &pot_ptr->hash;
11363
11364 local_free (hashes_buf->digest);
11365
11366 if (isSalted)
11367 {
11368 local_free (hashes_buf->salt);
11369 }
11370 }
11371
11372 local_free (pot);
11373
11374 if (data.quiet == 0) log_info_nn ("");
11375
11376 return (0);
11377 }
11378
11379 if (keyspace == 0)
11380 {
11381 if (hashes_cnt == 0)
11382 {
11383 log_error ("ERROR: No hashes loaded");
11384
11385 return (-1);
11386 }
11387 }
11388
11389 /**
11390 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11391 */
11392
11393 if (data.outfile != NULL)
11394 {
11395 if (data.hashfile != NULL)
11396 {
11397 #ifdef _POSIX
11398 struct stat tmpstat_outfile;
11399 struct stat tmpstat_hashfile;
11400 #endif
11401
11402 #ifdef _WIN
11403 struct stat64 tmpstat_outfile;
11404 struct stat64 tmpstat_hashfile;
11405 #endif
11406
11407 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11408
11409 if (tmp_outfile_fp)
11410 {
11411 #ifdef _POSIX
11412 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11413 #endif
11414
11415 #ifdef _WIN
11416 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11417 #endif
11418
11419 fclose (tmp_outfile_fp);
11420 }
11421
11422 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11423
11424 if (tmp_hashfile_fp)
11425 {
11426 #ifdef _POSIX
11427 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11428 #endif
11429
11430 #ifdef _WIN
11431 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11432 #endif
11433
11434 fclose (tmp_hashfile_fp);
11435 }
11436
11437 if (tmp_outfile_fp && tmp_outfile_fp)
11438 {
11439 tmpstat_outfile.st_mode = 0;
11440 tmpstat_outfile.st_nlink = 0;
11441 tmpstat_outfile.st_uid = 0;
11442 tmpstat_outfile.st_gid = 0;
11443 tmpstat_outfile.st_rdev = 0;
11444 tmpstat_outfile.st_atime = 0;
11445
11446 tmpstat_hashfile.st_mode = 0;
11447 tmpstat_hashfile.st_nlink = 0;
11448 tmpstat_hashfile.st_uid = 0;
11449 tmpstat_hashfile.st_gid = 0;
11450 tmpstat_hashfile.st_rdev = 0;
11451 tmpstat_hashfile.st_atime = 0;
11452
11453 #ifdef _POSIX
11454 tmpstat_outfile.st_blksize = 0;
11455 tmpstat_outfile.st_blocks = 0;
11456
11457 tmpstat_hashfile.st_blksize = 0;
11458 tmpstat_hashfile.st_blocks = 0;
11459 #endif
11460
11461 #ifdef _POSIX
11462 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11463 {
11464 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11465
11466 return (-1);
11467 }
11468 #endif
11469
11470 #ifdef _WIN
11471 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11472 {
11473 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11474
11475 return (-1);
11476 }
11477 #endif
11478 }
11479 }
11480 }
11481
11482 /**
11483 * Remove duplicates
11484 */
11485
11486 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11487
11488 if (isSalted)
11489 {
11490 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11491 }
11492 else
11493 {
11494 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11495 }
11496
11497 uint hashes_cnt_orig = hashes_cnt;
11498
11499 hashes_cnt = 1;
11500
11501 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11502 {
11503 if (isSalted)
11504 {
11505 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11506 {
11507 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11508 }
11509 }
11510 else
11511 {
11512 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11513 }
11514
11515 if (hashes_pos > hashes_cnt)
11516 {
11517 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11518 }
11519
11520 hashes_cnt++;
11521 }
11522
11523 /**
11524 * Potfile removes
11525 */
11526
11527 uint potfile_remove_cracks = 0;
11528
11529 if (potfile_disable == 0)
11530 {
11531 hash_t hash_buf;
11532
11533 hash_buf.digest = mymalloc (dgst_size);
11534 hash_buf.salt = NULL;
11535 hash_buf.esalt = NULL;
11536 hash_buf.hash_info = NULL;
11537 hash_buf.cracked = 0;
11538
11539 if (isSalted)
11540 {
11541 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11542 }
11543
11544 if (esalt_size)
11545 {
11546 hash_buf.esalt = mymalloc (esalt_size);
11547 }
11548
11549 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11550
11551 // no solution for these special hash types (for instane because they use hashfile in output etc)
11552 if ((hash_mode != 5200) &&
11553 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11554 (hash_mode != 9000))
11555 {
11556 FILE *fp = fopen (potfile, "rb");
11557
11558 if (fp != NULL)
11559 {
11560 while (!feof (fp))
11561 {
11562 char line_buf[BUFSIZ] = { 0 };
11563
11564 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11565
11566 if (ptr == NULL) break;
11567
11568 int line_len = strlen (line_buf);
11569
11570 if (line_len == 0) continue;
11571
11572 int iter = MAX_CUT_TRIES;
11573
11574 for (int i = line_len - 1; i && iter; i--, line_len--)
11575 {
11576 if (line_buf[i] != ':') continue;
11577
11578 if (isSalted)
11579 {
11580 memset (hash_buf.salt, 0, sizeof (salt_t));
11581 }
11582
11583 hash_t *found = NULL;
11584
11585 if (hash_mode == 6800)
11586 {
11587 if (i < 48) // 48 = 12 * uint in salt_buf[]
11588 {
11589 // manipulate salt_buf
11590 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11591
11592 hash_buf.salt->salt_len = i;
11593
11594 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11595 }
11596 }
11597 else if (hash_mode == 2500)
11598 {
11599 if (i < 48) // 48 = 12 * uint in salt_buf[]
11600 {
11601 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11602 // manipulate salt_buf
11603
11604 // to be safe work with a copy (because of line_len loop, i etc)
11605
11606 char line_buf_cpy[BUFSIZ] = { 0 };
11607
11608 memcpy (line_buf_cpy, line_buf, i);
11609
11610 char *mac2_pos = strrchr (line_buf_cpy, ':');
11611
11612 if (mac2_pos == NULL) continue;
11613
11614 mac2_pos[0] = 0;
11615 mac2_pos++;
11616
11617 if (strlen (mac2_pos) != 12) continue;
11618
11619 char *mac1_pos = strrchr (line_buf_cpy, ':');
11620
11621 if (mac1_pos == NULL) continue;
11622
11623 mac1_pos[0] = 0;
11624 mac1_pos++;
11625
11626 if (strlen (mac1_pos) != 12) continue;
11627
11628 uint essid_length = mac1_pos - line_buf_cpy - 1;
11629
11630 // here we need the ESSID
11631 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11632
11633 hash_buf.salt->salt_len = essid_length;
11634
11635 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11636
11637 if (found)
11638 {
11639 wpa_t *wpa = (wpa_t *) found->esalt;
11640
11641 uint pke[25] = { 0 };
11642
11643 char *pke_ptr = (char *) pke;
11644
11645 for (uint i = 0; i < 25; i++)
11646 {
11647 pke[i] = byte_swap_32 (wpa->pke[i]);
11648 }
11649
11650 u8 mac1[6] = { 0 };
11651 u8 mac2[6] = { 0 };
11652
11653 memcpy (mac1, pke_ptr + 23, 6);
11654 memcpy (mac2, pke_ptr + 29, 6);
11655
11656 // compare hex string(s) vs binary MAC address(es)
11657
11658 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11659 {
11660 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11661 {
11662 found = NULL;
11663 break;
11664 }
11665 }
11666
11667 // early skip ;)
11668 if (!found) continue;
11669
11670 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11671 {
11672 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11673 {
11674 found = NULL;
11675 break;
11676 }
11677 }
11678 }
11679 }
11680 }
11681 else
11682 {
11683 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11684
11685 if (parser_status == PARSER_OK)
11686 {
11687 if (isSalted)
11688 {
11689 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11690 }
11691 else
11692 {
11693 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11694 }
11695 }
11696 }
11697
11698 if (found == NULL) continue;
11699
11700 if (!found->cracked) potfile_remove_cracks++;
11701
11702 found->cracked = 1;
11703
11704 if (found) break;
11705
11706 iter--;
11707 }
11708 }
11709
11710 fclose (fp);
11711 }
11712 }
11713
11714 if (esalt_size)
11715 {
11716 local_free (hash_buf.esalt);
11717 }
11718
11719 if (isSalted)
11720 {
11721 local_free (hash_buf.salt);
11722 }
11723
11724 local_free (hash_buf.digest);
11725 }
11726
11727 /**
11728 * Now generate all the buffers required for later
11729 */
11730
11731 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11732
11733 salt_t *salts_buf_new = NULL;
11734 void *esalts_buf_new = NULL;
11735
11736 if (isSalted)
11737 {
11738 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11739
11740 if (esalt_size)
11741 {
11742 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11743 }
11744 }
11745 else
11746 {
11747 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11748 }
11749
11750 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11751
11752 uint digests_cnt = hashes_cnt;
11753 uint digests_done = 0;
11754
11755 uint size_digests = digests_cnt * dgst_size;
11756 uint size_shown = digests_cnt * sizeof (uint);
11757
11758 uint *digests_shown = (uint *) mymalloc (size_shown);
11759 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11760
11761 uint salts_cnt = 0;
11762 uint salts_done = 0;
11763
11764 hashinfo_t **hash_info = NULL;
11765
11766 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11767 {
11768 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11769
11770 if (username && (remove || show))
11771 {
11772 uint user_pos;
11773
11774 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11775 {
11776 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11777
11778 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11779 }
11780 }
11781 }
11782
11783 uint *salts_shown = (uint *) mymalloc (size_shown);
11784
11785 salt_t *salt_buf;
11786
11787 {
11788 // copied from inner loop
11789
11790 salt_buf = &salts_buf_new[salts_cnt];
11791
11792 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11793
11794 if (esalt_size)
11795 {
11796 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11797 }
11798
11799 salt_buf->digests_cnt = 0;
11800 salt_buf->digests_done = 0;
11801 salt_buf->digests_offset = 0;
11802
11803 salts_cnt++;
11804 }
11805
11806 if (hashes_buf[0].cracked == 1)
11807 {
11808 digests_shown[0] = 1;
11809
11810 digests_done++;
11811
11812 salt_buf->digests_done++;
11813 }
11814
11815 salt_buf->digests_cnt++;
11816
11817 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11818
11819 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11820 {
11821 hash_info[0] = hashes_buf[0].hash_info;
11822 }
11823
11824 // copy from inner loop
11825
11826 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11827 {
11828 if (isSalted)
11829 {
11830 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11831 {
11832 salt_buf = &salts_buf_new[salts_cnt];
11833
11834 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11835
11836 if (esalt_size)
11837 {
11838 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11839 }
11840
11841 salt_buf->digests_cnt = 0;
11842 salt_buf->digests_done = 0;
11843 salt_buf->digests_offset = hashes_pos;
11844
11845 salts_cnt++;
11846 }
11847 }
11848
11849 if (hashes_buf[hashes_pos].cracked == 1)
11850 {
11851 digests_shown[hashes_pos] = 1;
11852
11853 digests_done++;
11854
11855 salt_buf->digests_done++;
11856 }
11857
11858 salt_buf->digests_cnt++;
11859
11860 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11861
11862 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11863 {
11864 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11865 }
11866 }
11867
11868 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11869 {
11870 salt_t *salt_buf = &salts_buf_new[salt_pos];
11871
11872 if (salt_buf->digests_done == salt_buf->digests_cnt)
11873 {
11874 salts_shown[salt_pos] = 1;
11875
11876 salts_done++;
11877 }
11878
11879 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11880 }
11881
11882 local_free (digests_buf);
11883 local_free (salts_buf);
11884 local_free (esalts_buf);
11885
11886 digests_buf = digests_buf_new;
11887 salts_buf = salts_buf_new;
11888 esalts_buf = esalts_buf_new;
11889
11890 local_free (hashes_buf);
11891
11892 /**
11893 * special modification not set from parser
11894 */
11895
11896 switch (hash_mode)
11897 {
11898 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11899 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11900 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11901 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11902 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11903 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11904 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11905 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11906 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11907 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11908 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11909 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11910 }
11911
11912 if (truecrypt_keyfiles)
11913 {
11914 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11915
11916 char *keyfiles = strdup (truecrypt_keyfiles);
11917
11918 char *keyfile = strtok (keyfiles, ",");
11919
11920 do
11921 {
11922 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
11923
11924 } while ((keyfile = strtok (NULL, ",")) != NULL);
11925
11926 free (keyfiles);
11927 }
11928
11929 data.digests_cnt = digests_cnt;
11930 data.digests_done = digests_done;
11931 data.digests_buf = digests_buf;
11932 data.digests_shown = digests_shown;
11933 data.digests_shown_tmp = digests_shown_tmp;
11934
11935 data.salts_cnt = salts_cnt;
11936 data.salts_done = salts_done;
11937 data.salts_buf = salts_buf;
11938 data.salts_shown = salts_shown;
11939
11940 data.esalts_buf = esalts_buf;
11941 data.hash_info = hash_info;
11942
11943 /**
11944 * Automatic Optimizers
11945 */
11946
11947 if (salts_cnt == 1)
11948 opti_type |= OPTI_TYPE_SINGLE_SALT;
11949
11950 if (digests_cnt == 1)
11951 opti_type |= OPTI_TYPE_SINGLE_HASH;
11952
11953 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11954 opti_type |= OPTI_TYPE_NOT_ITERATED;
11955
11956 if (attack_mode == ATTACK_MODE_BF)
11957 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11958
11959 data.opti_type = opti_type;
11960
11961 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11962 {
11963 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11964 {
11965 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11966 {
11967 if (opts_type & OPTS_TYPE_ST_ADD80)
11968 {
11969 opts_type &= ~OPTS_TYPE_ST_ADD80;
11970 opts_type |= OPTS_TYPE_PT_ADD80;
11971 }
11972
11973 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11974 {
11975 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11976 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11977 }
11978
11979 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11980 {
11981 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11982 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11983 }
11984 }
11985 }
11986 }
11987
11988 /**
11989 * Some algorithm, like descrypt, can benefit from JIT compilation
11990 */
11991
11992 int force_jit_compilation = -1;
11993
11994 if (hash_mode == 8900)
11995 {
11996 force_jit_compilation = 8900;
11997 }
11998 else if (hash_mode == 9300)
11999 {
12000 force_jit_compilation = 8900;
12001 }
12002 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12003 {
12004 force_jit_compilation = 1500;
12005 }
12006
12007 /**
12008 * generate bitmap tables
12009 */
12010
12011 const uint bitmap_shift1 = 5;
12012 const uint bitmap_shift2 = 13;
12013
12014 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12015
12016 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12017 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12018 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12019 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12020 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12021 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12022 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12023 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12024
12025 uint bitmap_bits;
12026 uint bitmap_nums;
12027 uint bitmap_mask;
12028 uint bitmap_size;
12029
12030 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12031 {
12032 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12033
12034 bitmap_nums = 1 << bitmap_bits;
12035
12036 bitmap_mask = bitmap_nums - 1;
12037
12038 bitmap_size = bitmap_nums * sizeof (uint);
12039
12040 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12041
12042 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;
12043 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;
12044
12045 break;
12046 }
12047
12048 bitmap_nums = 1 << bitmap_bits;
12049
12050 bitmap_mask = bitmap_nums - 1;
12051
12052 bitmap_size = bitmap_nums * sizeof (uint);
12053
12054 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);
12055 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);
12056
12057 /**
12058 * prepare quick rule
12059 */
12060
12061 data.rule_buf_l = rule_buf_l;
12062 data.rule_buf_r = rule_buf_r;
12063
12064 int rule_len_l = (int) strlen (rule_buf_l);
12065 int rule_len_r = (int) strlen (rule_buf_r);
12066
12067 data.rule_len_l = rule_len_l;
12068 data.rule_len_r = rule_len_r;
12069
12070 /**
12071 * load rules
12072 */
12073
12074 uint *all_kernel_rules_cnt = NULL;
12075
12076 kernel_rule_t **all_kernel_rules_buf = NULL;
12077
12078 if (rp_files_cnt)
12079 {
12080 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12081
12082 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12083 }
12084
12085 char rule_buf[BUFSIZ] = { 0 };
12086
12087 int rule_len = 0;
12088
12089 for (uint i = 0; i < rp_files_cnt; i++)
12090 {
12091 uint kernel_rules_avail = 0;
12092
12093 uint kernel_rules_cnt = 0;
12094
12095 kernel_rule_t *kernel_rules_buf = NULL;
12096
12097 char *rp_file = rp_files[i];
12098
12099 char in[BLOCK_SIZE] = { 0 };
12100 char out[BLOCK_SIZE] = { 0 };
12101
12102 FILE *fp = NULL;
12103
12104 uint rule_line = 0;
12105
12106 if ((fp = fopen (rp_file, "rb")) == NULL)
12107 {
12108 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12109
12110 return (-1);
12111 }
12112
12113 while (!feof (fp))
12114 {
12115 memset (rule_buf, 0, BUFSIZ);
12116
12117 rule_len = fgetl (fp, rule_buf);
12118
12119 rule_line++;
12120
12121 if (rule_len == 0) continue;
12122
12123 if (rule_buf[0] == '#') continue;
12124
12125 if (kernel_rules_avail == kernel_rules_cnt)
12126 {
12127 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12128
12129 kernel_rules_avail += INCR_RULES;
12130 }
12131
12132 memset (in, 0, BLOCK_SIZE);
12133 memset (out, 0, BLOCK_SIZE);
12134
12135 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12136
12137 if (result == -1)
12138 {
12139 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12140
12141 continue;
12142 }
12143
12144 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12145 {
12146 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12147
12148 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12149
12150 continue;
12151 }
12152
12153 /* its so slow
12154 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12155 {
12156 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12157
12158 continue;
12159 }
12160 */
12161
12162 kernel_rules_cnt++;
12163 }
12164
12165 fclose (fp);
12166
12167 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12168
12169 all_kernel_rules_buf[i] = kernel_rules_buf;
12170 }
12171
12172 /**
12173 * merge rules or automatic rule generator
12174 */
12175
12176 uint kernel_rules_cnt = 0;
12177
12178 kernel_rule_t *kernel_rules_buf = NULL;
12179
12180 if (attack_mode == ATTACK_MODE_STRAIGHT)
12181 {
12182 if (rp_files_cnt)
12183 {
12184 kernel_rules_cnt = 1;
12185
12186 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12187
12188 repeats[0] = kernel_rules_cnt;
12189
12190 for (uint i = 0; i < rp_files_cnt; i++)
12191 {
12192 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12193
12194 repeats[i + 1] = kernel_rules_cnt;
12195 }
12196
12197 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12198
12199 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12200
12201 for (uint i = 0; i < kernel_rules_cnt; i++)
12202 {
12203 uint out_pos = 0;
12204
12205 kernel_rule_t *out = &kernel_rules_buf[i];
12206
12207 for (uint j = 0; j < rp_files_cnt; j++)
12208 {
12209 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12210 uint in_pos;
12211
12212 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12213
12214 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12215 {
12216 if (out_pos == RULES_MAX - 1)
12217 {
12218 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12219
12220 break;
12221 }
12222
12223 out->cmds[out_pos] = in->cmds[in_pos];
12224 }
12225 }
12226 }
12227
12228 local_free (repeats);
12229 }
12230 else if (rp_gen)
12231 {
12232 uint kernel_rules_avail = 0;
12233
12234 while (kernel_rules_cnt < rp_gen)
12235 {
12236 if (kernel_rules_avail == kernel_rules_cnt)
12237 {
12238 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12239
12240 kernel_rules_avail += INCR_RULES;
12241 }
12242
12243 memset (rule_buf, 0, BLOCK_SIZE);
12244
12245 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12246
12247 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12248
12249 kernel_rules_cnt++;
12250 }
12251 }
12252 }
12253
12254 /**
12255 * generate NOP rules
12256 */
12257
12258 if (kernel_rules_cnt == 0)
12259 {
12260 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12261
12262 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12263
12264 kernel_rules_cnt++;
12265 }
12266
12267 data.kernel_rules_cnt = kernel_rules_cnt;
12268 data.kernel_rules_buf = kernel_rules_buf;
12269
12270 /**
12271 * OpenCL platforms: detect
12272 */
12273
12274 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12275 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12276
12277 cl_uint platforms_cnt = 0;
12278 cl_uint platform_devices_cnt = 0;
12279
12280 if (keyspace == 0)
12281 {
12282 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12283
12284 if (platforms_cnt == 0)
12285 {
12286 log_error ("ERROR: No OpenCL compatible platform found");
12287
12288 return (-1);
12289 }
12290 }
12291
12292 /**
12293 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12294 */
12295
12296 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12297 {
12298 cl_platform_id platform = platforms[platform_id];
12299
12300 char platform_vendor[INFOSZ] = { 0 };
12301
12302 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12303
12304 #ifdef HAVE_HWMON
12305 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12306 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12307 {
12308 // make sure that we do not directly control the fan for NVidia
12309
12310 gpu_temp_retain = 0;
12311
12312 data.gpu_temp_retain = gpu_temp_retain;
12313 }
12314 #endif // HAVE_NVML || HAVE_NVAPI
12315 #endif
12316 }
12317
12318 /**
12319 * OpenCL devices: simply push all devices from all platforms into the same device array
12320 */
12321
12322 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12323
12324 data.devices_param = devices_param;
12325
12326 uint devices_cnt = 0;
12327
12328 uint devices_active = 0;
12329
12330 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12331 {
12332 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12333
12334 cl_platform_id platform = platforms[platform_id];
12335
12336 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12337
12338 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12339 {
12340 size_t param_value_size = 0;
12341
12342 const uint device_id = devices_cnt;
12343
12344 hc_device_param_t *device_param = &data.devices_param[device_id];
12345
12346 device_param->device = platform_devices[platform_devices_id];
12347
12348 device_param->device_id = device_id;
12349
12350 device_param->platform_devices_id = platform_devices_id;
12351
12352 // device_type
12353
12354 cl_device_type device_type;
12355
12356 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12357
12358 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12359
12360 device_param->device_type = device_type;
12361
12362 // vendor_id
12363
12364 cl_uint vendor_id = 0;
12365
12366 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12367
12368 device_param->vendor_id = vendor_id;
12369
12370 // device_name
12371
12372 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12373
12374 char *device_name = (char *) mymalloc (param_value_size);
12375
12376 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12377
12378 device_param->device_name = device_name;
12379
12380 // device_version
12381
12382 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12383
12384 char *device_version = (char *) mymalloc (param_value_size);
12385
12386 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12387
12388 device_param->device_version = device_version;
12389
12390 // device_opencl_version
12391
12392 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12393
12394 char *device_opencl_version = (char *) mymalloc (param_value_size);
12395
12396 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12397
12398 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12399
12400 myfree (device_opencl_version);
12401
12402 if (strstr (device_version, "pocl"))
12403 {
12404 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12405 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12406
12407 cl_uint vendor_id = VENDOR_ID_GENERIC;
12408
12409 device_param->vendor_id = vendor_id;
12410 }
12411
12412 // max_compute_units
12413
12414 cl_uint vector_width;
12415
12416 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12417 {
12418 #ifndef OSX
12419 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12420 #else
12421 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
12422 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12423 else
12424 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12425 #endif
12426
12427 int is_ti = 0;
12428
12429 const int device_name_len = strlen (device_name);
12430
12431 if (device_name[device_name_len - 2] == 't') is_ti++;
12432 if (device_name[device_name_len - 2] == 'T') is_ti++;
12433 if (device_name[device_name_len - 1] == 'i') is_ti++;
12434 if (device_name[device_name_len - 1] == 'I') is_ti++;
12435
12436 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12437 {
12438 // Yeah that's a super bad hack, but there's no other attribute we could use
12439
12440 if (vector_width < 2) vector_width *= 2;
12441 }
12442
12443 if (opti_type & OPTI_TYPE_USES_BITS_64)
12444 {
12445 if (vector_width > 1) vector_width /= 2;
12446 }
12447 }
12448 else
12449 {
12450 vector_width = opencl_vector_width;
12451 }
12452
12453 if (vector_width > 8) vector_width = 8;
12454
12455 device_param->vector_width = vector_width;
12456
12457 // max_compute_units
12458
12459 cl_uint device_processors;
12460
12461 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12462
12463 device_param->device_processors = device_processors;
12464
12465 // max_mem_alloc_size
12466
12467 cl_ulong device_maxmem_alloc;
12468
12469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12470
12471 device_param->device_maxmem_alloc = device_maxmem_alloc;
12472
12473 // max_mem_alloc_size
12474
12475 cl_ulong device_global_mem;
12476
12477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12478
12479 device_param->device_global_mem = device_global_mem;
12480
12481 // max_clock_frequency
12482
12483 cl_uint device_maxclock_frequency;
12484
12485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12486
12487 device_param->device_maxclock_frequency = device_maxclock_frequency;
12488
12489 // skipped
12490
12491 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12492 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12493
12494 device_param->skipped = (skipped1 || skipped2);
12495
12496 // driver_version
12497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12498
12499 char *driver_version = (char *) mymalloc (param_value_size);
12500
12501 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12502
12503 device_param->driver_version = driver_version;
12504
12505 // device_name_chksum
12506
12507 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12508
12509 #if __x86_64__
12510 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);
12511 #else
12512 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);
12513 #endif
12514
12515 uint device_name_digest[4] = { 0 };
12516
12517 md5_64 ((uint *) device_name_chksum, device_name_digest);
12518
12519 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12520
12521 device_param->device_name_chksum = device_name_chksum;
12522
12523 // device_processor_cores
12524
12525 if (device_type & CL_DEVICE_TYPE_CPU)
12526 {
12527 cl_uint device_processor_cores = 1;
12528
12529 device_param->device_processor_cores = device_processor_cores;
12530 }
12531
12532 if (device_type & CL_DEVICE_TYPE_GPU)
12533 {
12534 if (vendor_id == VENDOR_ID_AMD)
12535 {
12536 cl_uint device_processor_cores = 0;
12537
12538 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12539
12540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12541
12542 device_param->device_processor_cores = device_processor_cores;
12543 }
12544 else if (vendor_id == VENDOR_ID_NV)
12545 {
12546 cl_uint kernel_exec_timeout = 0;
12547
12548 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12549
12550 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12551
12552 device_param->kernel_exec_timeout = kernel_exec_timeout;
12553
12554 cl_uint device_processor_cores = 0;
12555
12556 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12557
12558 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12559
12560 device_param->device_processor_cores = device_processor_cores;
12561
12562 cl_uint sm_minor = 0;
12563 cl_uint sm_major = 0;
12564
12565 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12566 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12567
12568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12569 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12570
12571 device_param->sm_minor = sm_minor;
12572 device_param->sm_major = sm_major;
12573 }
12574 else
12575 {
12576 cl_uint device_processor_cores = 1;
12577
12578 device_param->device_processor_cores = device_processor_cores;
12579 }
12580 }
12581
12582 // display results
12583
12584 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12585 {
12586 if (device_param->skipped == 0)
12587 {
12588 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12589 device_id + 1,
12590 device_name,
12591 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12592 (unsigned int) (device_global_mem / 1024 / 1024),
12593 (unsigned int) (device_maxclock_frequency),
12594 (unsigned int) device_processors);
12595 }
12596 else
12597 {
12598 log_info ("Device #%u: %s, skipped",
12599 device_id + 1,
12600 device_name);
12601 }
12602 }
12603
12604 // common driver check
12605
12606 if (device_param->skipped == 0)
12607 {
12608 if (strstr (device_version, "pocl"))
12609 {
12610 if (force == 0)
12611 {
12612 log_info ("");
12613 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12614 log_info ("You are STRONGLY encouraged not to use it");
12615 log_info ("You can use --force to override this but do not post error reports if you do so");
12616 log_info ("");
12617
12618 return (-1);
12619 }
12620 }
12621
12622 if (device_type & CL_DEVICE_TYPE_GPU)
12623 {
12624 if (vendor_id == VENDOR_ID_NV)
12625 {
12626 if (device_param->kernel_exec_timeout != 0)
12627 {
12628 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);
12629 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12630 }
12631 }
12632 else if (vendor_id == VENDOR_ID_AMD)
12633 {
12634 int catalyst_check = (force == 1) ? 0 : 1;
12635
12636 int catalyst_warn = 0;
12637
12638 int catalyst_broken = 0;
12639
12640 if (catalyst_check == 1)
12641 {
12642 catalyst_warn = 1;
12643
12644 // v14.9 and higher
12645 if (atoi (device_param->driver_version) >= 1573)
12646 {
12647 catalyst_warn = 0;
12648 }
12649
12650 catalyst_check = 0;
12651 }
12652
12653 if (catalyst_broken == 1)
12654 {
12655 log_info ("");
12656 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12657 log_info ("It will pass over cracked hashes and does not report them as cracked");
12658 log_info ("You are STRONGLY encouraged not to use it");
12659 log_info ("You can use --force to override this but do not post error reports if you do so");
12660 log_info ("");
12661
12662 return (-1);
12663 }
12664
12665 if (catalyst_warn == 1)
12666 {
12667 log_info ("");
12668 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12669 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12670 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12671 #ifdef _WIN
12672 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12673 #endif
12674 log_info ("You can use --force to override this but do not post error reports if you do so");
12675 log_info ("");
12676
12677 return (-1);
12678 }
12679 }
12680 }
12681
12682 /**
12683 * kernel accel and loops auto adjustment
12684 */
12685
12686 uint _kernel_accel = kernel_accel;
12687 uint _kernel_loops = kernel_loops;
12688
12689 #ifndef OSX
12690 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode);
12691 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode);
12692 #else
12693 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12694 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12695 #endif
12696
12697 if (workload_profile == 1)
12698 {
12699 _kernel_loops /= 8;
12700 _kernel_accel /= 4;
12701
12702 if (_kernel_loops == 0) _kernel_loops = 8;
12703 if (_kernel_accel == 0) _kernel_accel = 2;
12704 }
12705 else if (workload_profile == 3)
12706 {
12707 _kernel_loops *= 8;
12708 _kernel_accel *= 4;
12709
12710 if (_kernel_loops > 1024) _kernel_loops = 1024;
12711 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
12712 }
12713
12714 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
12715
12716 if (benchmark == 1 && benchmark_mode == 1)
12717 {
12718 _kernel_loops *= 8;
12719 _kernel_accel *= 4;
12720
12721 #ifdef OSX
12722 bool isCpu = device_param->device_type & CL_DEVICE_TYPE_CPU;
12723
12724 if (!isCpu)
12725 {
12726 if (hash_mode == 7100 || hash_mode == 8200 || hash_mode == 9600 || \
12727 hash_mode == 11300 || hash_mode == 11600 || hash_mode == 12200)
12728 {
12729 _kernel_accel = 1;
12730 }
12731 else if (hash_mode == 7200 || hash_mode == 9300 || hash_mode == 13000)
12732 {
12733 _kernel_accel = 2;
12734 }
12735 else if (hash_mode == 3200)
12736 {
12737 _kernel_loops = ROUNDS_BCRYPT / 2;
12738 }
12739 else if (hash_mode == 6231)
12740 {
12741 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12742 _kernel_accel = 1;
12743 }
12744 else if (hash_mode == 6241)
12745 {
12746 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12747 _kernel_accel = 1;
12748 }
12749 }
12750 else
12751 {
12752 if (hash_mode == 3200)
12753 {
12754 _kernel_loops = ROUNDS_BCRYPT;
12755 }
12756 else if (hash_mode == 6231)
12757 {
12758 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12759 _kernel_accel = 8;
12760 }
12761 else if (hash_mode == 6241)
12762 {
12763 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12764 _kernel_accel = 128;
12765 }
12766 }
12767 #endif
12768
12769 switch (hash_mode)
12770 {
12771 case 400: _kernel_loops = ROUNDS_PHPASS;
12772 _kernel_accel = 32;
12773 break;
12774 case 500: _kernel_loops = ROUNDS_MD5CRYPT;
12775 _kernel_accel = 32;
12776 break;
12777 case 501: _kernel_loops = ROUNDS_MD5CRYPT;
12778 _kernel_accel = 32;
12779 break;
12780 case 1600: _kernel_loops = ROUNDS_MD5CRYPT;
12781 _kernel_accel = 32;
12782 break;
12783 case 1800: _kernel_loops = ROUNDS_SHA512CRYPT;
12784 #ifndef OSX
12785 _kernel_accel = 16;
12786 #else
12787 if (isCpu) _kernel_accel = 16;
12788 #endif
12789 break;
12790 case 2100: _kernel_loops = ROUNDS_DCC2;
12791 _kernel_accel = 16;
12792 break;
12793 case 2500: _kernel_loops = ROUNDS_WPA2;
12794 #ifndef OSX
12795 _kernel_accel = 32;
12796 #else
12797 if (isCpu) _kernel_accel = 32;
12798 #endif
12799 break;
12800 case 3200: _kernel_accel = 8;
12801 #ifndef OSX
12802 _kernel_loops = ROUNDS_BCRYPT;
12803 #endif
12804 break;
12805 case 5200: _kernel_loops = ROUNDS_PSAFE3;
12806 _kernel_accel = 16;
12807 break;
12808 case 5800: _kernel_loops = ROUNDS_ANDROIDPIN;
12809 _kernel_accel = 16;
12810 break;
12811 case 6211: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12812 #ifndef OSX
12813 _kernel_accel = 64;
12814 #else
12815 if (isCpu) _kernel_accel = 64;
12816 #endif
12817 break;
12818 case 6212: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12819 _kernel_accel = 32;
12820 break;
12821 case 6213: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12822 _kernel_accel = 32;
12823 break;
12824 case 6221: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12825 _kernel_accel = 8;
12826 break;
12827 case 6222: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12828 _kernel_accel = 8;
12829 break;
12830 case 6223: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12831 _kernel_accel = 8;
12832 break;
12833 #ifndef OSX
12834 case 6231: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12835 _kernel_accel = 8;
12836 break;
12837 #endif
12838 case 6232: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12839 _kernel_accel = 8;
12840 break;
12841 case 6233: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12842 _kernel_accel = 8;
12843 break;
12844 #ifndef OSX
12845 case 6241: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12846 _kernel_accel = 128;
12847 break;
12848 #endif
12849 case 6242: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12850 _kernel_accel = 64;
12851 break;
12852 case 6243: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12853 _kernel_accel = 64;
12854 break;
12855 case 6300: _kernel_loops = ROUNDS_MD5CRYPT;
12856 _kernel_accel = 32;
12857 break;
12858 case 6700: _kernel_loops = ROUNDS_SHA1AIX;
12859 _kernel_accel = 128;
12860 break;
12861 case 6400: _kernel_loops = ROUNDS_SHA256AIX;
12862 _kernel_accel = 128;
12863 break;
12864 case 6500: _kernel_loops = ROUNDS_SHA512AIX;
12865 _kernel_accel = 32;
12866 break;
12867 case 6600: _kernel_loops = ROUNDS_AGILEKEY;
12868 _kernel_accel = 64;
12869 break;
12870 case 6800: _kernel_loops = ROUNDS_LASTPASS;
12871 #ifndef OSX
12872 _kernel_accel = 64;
12873 #else
12874 if (isCpu) _kernel_accel = 64;
12875 #endif
12876 break;
12877 case 7100: _kernel_loops = ROUNDS_SHA512OSX;
12878 #ifndef OSX
12879 _kernel_accel = 8;
12880 #endif
12881 break;
12882 case 7200: _kernel_loops = ROUNDS_GRUB;
12883 #ifndef OSX
12884 _kernel_accel = 16;
12885 #endif
12886 break;
12887 case 7400: _kernel_loops = ROUNDS_SHA256CRYPT;
12888 _kernel_accel = 8;
12889 break;
12890 case 7900: _kernel_loops = ROUNDS_DRUPAL7;
12891 #ifndef OSX
12892 _kernel_accel = 8;
12893 #else
12894 if (isCpu) _kernel_accel = 8;
12895 #endif
12896 break;
12897 case 8200: _kernel_loops = ROUNDS_CLOUDKEY;
12898 #ifndef OSX
12899 _kernel_accel = 8;
12900 #endif
12901 break;
12902 case 8800: _kernel_loops = ROUNDS_ANDROIDFDE;
12903 _kernel_accel = 32;
12904 break;
12905 case 8900: _kernel_loops = 1;
12906 _kernel_accel = 64;
12907 break;
12908 case 9000: _kernel_loops = ROUNDS_PSAFE2;
12909 _kernel_accel = 16;
12910 break;
12911 case 9100: _kernel_loops = ROUNDS_LOTUS8;
12912 #ifndef OSX
12913 _kernel_accel = 64;
12914 #else
12915 if (isCpu) _kernel_accel = 64;
12916 #endif
12917 break;
12918 case 9200: _kernel_loops = ROUNDS_CISCO8;
12919 #ifndef OSX
12920 _kernel_accel = 8;
12921 #else
12922 if (isCpu) _kernel_accel = 8;
12923 #endif
12924 break;
12925 case 9300: _kernel_loops = 1;
12926 #ifndef OSX
12927 _kernel_accel = 4;
12928 #endif
12929 break;
12930 case 9400: _kernel_loops = ROUNDS_OFFICE2007;
12931 #ifndef OSX
12932 _kernel_accel = 32;
12933 #else
12934 if (isCpu) _kernel_accel = 32;
12935 #endif
12936 break;
12937 case 9500: _kernel_loops = ROUNDS_OFFICE2010;
12938 #ifndef OSX
12939 _kernel_accel = 32;
12940 #else
12941 if (isCpu) _kernel_accel = 32;
12942 #endif
12943 break;
12944 case 9600: _kernel_loops = ROUNDS_OFFICE2013;
12945 #ifndef OSX
12946 _kernel_accel = 8;
12947 #endif
12948 break;
12949 case 10000: _kernel_loops = ROUNDS_DJANGOPBKDF2;
12950 #ifndef OSX
12951 _kernel_accel = 8;
12952 #else
12953 if (isCpu) _kernel_accel = 8;
12954 #endif
12955 break;
12956 case 10300: _kernel_loops = ROUNDS_SAPH_SHA1;
12957 _kernel_accel = 16;
12958 break;
12959 case 10500: _kernel_loops = ROUNDS_PDF14;
12960 _kernel_accel = 256;
12961 break;
12962 case 10700: _kernel_loops = ROUNDS_PDF17L8;
12963 _kernel_accel = 8;
12964 break;
12965 case 10900: _kernel_loops = ROUNDS_PBKDF2_SHA256;
12966 _kernel_accel = 8;
12967 break;
12968 case 11300: _kernel_loops = ROUNDS_BITCOIN_WALLET;
12969 #ifndef OSX
12970 _kernel_accel = 8;
12971 #endif
12972 break;
12973 case 11600: _kernel_loops = ROUNDS_SEVEN_ZIP;
12974 #ifndef OSX
12975 _kernel_accel = 8;
12976 #endif
12977 break;
12978 case 11900: _kernel_loops = ROUNDS_PBKDF2_MD5;
12979 _kernel_accel = 8;
12980 break;
12981 case 12000: _kernel_loops = ROUNDS_PBKDF2_SHA1;
12982 _kernel_accel = 8;
12983 break;
12984 case 12100: _kernel_loops = ROUNDS_PBKDF2_SHA512;
12985 _kernel_accel = 8;
12986 break;
12987 case 12200: _kernel_loops = ROUNDS_ECRYPTFS;
12988 #ifndef OSX
12989 _kernel_accel = 8;
12990 #endif
12991 break;
12992 case 12300: _kernel_loops = ROUNDS_ORACLET;
12993 _kernel_accel = 8;
12994 break;
12995 case 12500: _kernel_loops = ROUNDS_RAR3;
12996 #ifndef OSX
12997 _kernel_accel = 32;
12998 #else
12999 if (isCpu) _kernel_accel = 32;
13000 #endif
13001 break;
13002 case 12700: _kernel_loops = ROUNDS_MYWALLET;
13003 _kernel_accel = 512;
13004 break;
13005 case 12800: _kernel_loops = ROUNDS_MS_DRSR;
13006 _kernel_accel = 512;
13007 break;
13008 case 12900: _kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
13009 _kernel_accel = 8;
13010 break;
13011 case 13000: _kernel_loops = ROUNDS_RAR5;
13012 #ifndef OSX
13013 _kernel_accel = 8;
13014 #endif
13015 break;
13016 }
13017
13018 // some algorithm collide too fast, make that impossible
13019
13020 switch (hash_mode)
13021 {
13022 case 11500: ((uint *) digests_buf)[1] = 1;
13023 break;
13024 }
13025
13026 if (_kernel_loops > 1024) _kernel_loops = 1024;
13027 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
13028 }
13029
13030 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13031 {
13032 _kernel_loops = 1024;
13033 }
13034
13035 if (hash_mode == 12500)
13036 {
13037 _kernel_loops = ROUNDS_RAR3 / 16;
13038 }
13039
13040 device_param->kernel_accel = _kernel_accel;
13041 device_param->kernel_loops = _kernel_loops;
13042
13043 devices_active++;
13044 }
13045
13046 // next please
13047
13048 devices_cnt++;
13049 }
13050 }
13051
13052 if (keyspace == 0 && devices_active == 0)
13053 {
13054 log_error ("ERROR: No devices found/left");
13055
13056 return (-1);
13057 }
13058
13059 data.devices_cnt = devices_cnt;
13060
13061 data.devices_active = devices_active;
13062
13063 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13064 {
13065 log_info ("");
13066 }
13067
13068 /**
13069 * HM devices: init
13070 */
13071
13072 #ifdef HAVE_HWMON
13073 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13074 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13075 #endif
13076
13077 #ifdef HAVE_ADL
13078 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13079 #endif
13080
13081 if (gpu_temp_disable == 0)
13082 {
13083 #if defined(WIN) && defined(HAVE_NVAPI)
13084 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13085
13086 if (nvapi_init (nvapi) == 0)
13087 data.hm_nv = nvapi;
13088
13089 if (data.hm_nv)
13090 {
13091 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13092 {
13093 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13094
13095 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13096
13097 int tmp_out = 0;
13098
13099 for (int i = 0; i < tmp_in; i++)
13100 {
13101 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13102 }
13103
13104 for (int i = 0; i < tmp_out; i++)
13105 {
13106 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13107
13108 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13109
13110 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;
13111 }
13112 }
13113 }
13114 #endif // WIN && HAVE_NVAPI
13115
13116 #if defined(LINUX) && defined(HAVE_NVML)
13117 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13118
13119 if (nvml_init (nvml) == 0)
13120 data.hm_nv = nvml;
13121
13122 if (data.hm_nv)
13123 {
13124 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13125 {
13126 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13127
13128 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13129
13130 int tmp_out = 0;
13131
13132 for (int i = 0; i < tmp_in; i++)
13133 {
13134 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13135 }
13136
13137 for (int i = 0; i < tmp_out; i++)
13138 {
13139 unsigned int speed;
13140
13141 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;
13142 }
13143 }
13144 }
13145 #endif // LINUX && HAVE_NVML
13146
13147 data.hm_amd = NULL;
13148
13149 #ifdef HAVE_ADL
13150 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13151
13152 if (adl_init (adl) == 0)
13153 data.hm_amd = adl;
13154
13155 if (data.hm_amd)
13156 {
13157 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13158 {
13159 // total number of adapters
13160
13161 int hm_adapters_num;
13162
13163 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13164
13165 // adapter info
13166
13167 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13168
13169 if (lpAdapterInfo == NULL) return (-1);
13170
13171 // get a list (of ids of) valid/usable adapters
13172
13173 int num_adl_adapters = 0;
13174
13175 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13176
13177 if (num_adl_adapters > 0)
13178 {
13179 hc_thread_mutex_lock (mux_adl);
13180
13181 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13182
13183 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13184
13185 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13186 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13187
13188 hc_thread_mutex_unlock (mux_adl);
13189 }
13190
13191 myfree (valid_adl_device_list);
13192 myfree (lpAdapterInfo);
13193 }
13194 }
13195 #endif // HAVE_ADL
13196
13197 if (data.hm_amd == NULL && data.hm_nv == NULL)
13198 {
13199 gpu_temp_disable = 1;
13200 }
13201 }
13202
13203 /**
13204 * OpenCL devices: allocate buffer for device specific information
13205 */
13206
13207 #ifdef HAVE_HWMON
13208 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
13209
13210 #ifdef HAVE_ADL
13211 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
13212
13213 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
13214 #endif // ADL
13215 #endif
13216
13217 /**
13218 * enable custom signal handler(s)
13219 */
13220
13221 if (benchmark == 0)
13222 {
13223 hc_signal (sigHandler_default);
13224 }
13225 else
13226 {
13227 hc_signal (sigHandler_benchmark);
13228 }
13229
13230 /**
13231 * User-defined GPU temp handling
13232 */
13233
13234 #ifdef HAVE_HWMON
13235 if (gpu_temp_disable == 1)
13236 {
13237 gpu_temp_abort = 0;
13238 gpu_temp_retain = 0;
13239 }
13240
13241 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13242 {
13243 if (gpu_temp_abort < gpu_temp_retain)
13244 {
13245 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13246
13247 return (-1);
13248 }
13249 }
13250
13251 data.gpu_temp_disable = gpu_temp_disable;
13252 data.gpu_temp_abort = gpu_temp_abort;
13253 data.gpu_temp_retain = gpu_temp_retain;
13254 #endif
13255
13256 /**
13257 * inform the user
13258 */
13259
13260 if (data.quiet == 0)
13261 {
13262 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13263
13264 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);
13265
13266 if (attack_mode == ATTACK_MODE_STRAIGHT)
13267 {
13268 log_info ("Rules: %u", kernel_rules_cnt);
13269 }
13270
13271 if (opti_type)
13272 {
13273 log_info ("Applicable Optimizers:");
13274
13275 for (uint i = 0; i < 32; i++)
13276 {
13277 const uint opti_bit = 1u << i;
13278
13279 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13280 }
13281 }
13282
13283 /**
13284 * Watchdog and Temperature balance
13285 */
13286
13287 #ifdef HAVE_HWMON
13288 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13289 {
13290 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13291 }
13292
13293 if (gpu_temp_abort == 0)
13294 {
13295 log_info ("Watchdog: Temperature abort trigger disabled");
13296 }
13297 else
13298 {
13299 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13300 }
13301
13302 if (gpu_temp_retain == 0)
13303 {
13304 log_info ("Watchdog: Temperature retain trigger disabled");
13305 }
13306 else
13307 {
13308 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13309 }
13310 #endif
13311 }
13312
13313 if (data.quiet == 0) log_info ("");
13314
13315 /**
13316 * HM devices: copy
13317 */
13318
13319 if (gpu_temp_disable == 0)
13320 {
13321 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13322 {
13323 hc_device_param_t *device_param = &data.devices_param[device_id];
13324
13325 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13326
13327 if (device_param->skipped) continue;
13328
13329 const uint platform_devices_id = device_param->platform_devices_id;
13330
13331 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13332 if (device_param->vendor_id == VENDOR_ID_NV)
13333 {
13334 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13335 }
13336 #endif
13337
13338 #ifdef HAVE_ADL
13339 if (device_param->vendor_id == VENDOR_ID_AMD)
13340 {
13341 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13342 }
13343 #endif
13344 }
13345 }
13346
13347 /*
13348 * Temporary fix:
13349 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13350 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13351 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13352 * Driver / ADL bug?
13353 */
13354
13355 #ifdef HAVE_ADL
13356 if (powertune_enable == 1)
13357 {
13358 hc_thread_mutex_lock (mux_adl);
13359
13360 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13361 {
13362 hc_device_param_t *device_param = &data.devices_param[device_id];
13363
13364 if (device_param->skipped) continue;
13365
13366 if (data.hm_device[device_id].od_version == 6)
13367 {
13368 // set powertune value only
13369
13370 int powertune_supported = 0;
13371
13372 int ADL_rc = 0;
13373
13374 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13375 {
13376 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13377
13378 return (-1);
13379 }
13380
13381 if (powertune_supported != 0)
13382 {
13383 // powertune set
13384 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13385
13386 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13387 {
13388 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13389
13390 return (-1);
13391 }
13392
13393 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13394 {
13395 log_error ("ERROR: Failed to set new ADL PowerControl values");
13396
13397 return (-1);
13398 }
13399 }
13400 }
13401 }
13402
13403 hc_thread_mutex_unlock (mux_adl);
13404 }
13405 #endif // HAVE_ADK
13406 #endif // HAVE_HWMON
13407
13408 #ifdef OSX
13409 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13410 {
13411 if (force == 0)
13412 {
13413 log_info ("");
13414 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13415 log_info ("You can use --force to override this but do not post error reports if you do so");
13416 log_info ("");
13417
13418 continue;
13419 }
13420 }
13421 #endif
13422
13423 #ifdef DEBUG
13424 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13425 #endif
13426
13427 uint kernel_blocks_all = 0;
13428
13429 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13430 {
13431 /**
13432 * host buffer
13433 */
13434
13435 hc_device_param_t *device_param = &data.devices_param[device_id];
13436
13437 if (device_param->skipped) continue;
13438
13439 /**
13440 * device properties
13441 */
13442
13443 char *device_name_chksum = device_param->device_name_chksum;
13444
13445 uint device_processors = device_param->device_processors;
13446
13447 uint device_processor_cores = device_param->device_processor_cores;
13448
13449 cl_device_type device_type = device_param->device_type;
13450
13451 /**
13452 * create context for each device
13453 */
13454
13455 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13456
13457 /**
13458 * create command-queue
13459 */
13460
13461 // not supported with NV
13462 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13463
13464 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13465
13466 /**
13467 * create input buffers on device
13468 */
13469
13470 uint kernel_threads = KERNEL_THREADS;
13471
13472 // bcrypt
13473 if (hash_mode == 3200) kernel_threads = 8;
13474 if (hash_mode == 9000) kernel_threads = 8;
13475
13476 if (device_type & CL_DEVICE_TYPE_CPU)
13477 {
13478 if (benchmark_mode == 0)
13479 {
13480 if (device_param->kernel_accel > 16)
13481 {
13482 device_param->kernel_accel = 16;
13483 }
13484 }
13485 else
13486 {
13487 if (device_param->kernel_accel > 64)
13488 {
13489 device_param->kernel_accel = 64;
13490 }
13491 }
13492 }
13493
13494 uint kernel_power = device_processors * kernel_threads * device_param->kernel_accel;
13495 uint kernel_blocks = kernel_power;
13496
13497 device_param->kernel_threads = kernel_threads;
13498 device_param->kernel_power_user = kernel_power;
13499 device_param->kernel_blocks_user = kernel_blocks;
13500
13501 kernel_blocks_all += kernel_blocks;
13502
13503 uint size_pws = kernel_power * sizeof (pw_t);
13504
13505 uint size_tmps = 4;
13506
13507 switch (hash_mode)
13508 {
13509 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13510 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13511 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13512 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13513 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13514 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13515 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13516 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13517 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13518 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13519 case 6211:
13520 case 6212:
13521 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13522 case 6221:
13523 case 6222:
13524 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13525 case 6231:
13526 case 6232:
13527 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13528 case 6241:
13529 case 6242:
13530 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13531 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13532 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13533 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13534 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13535 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13536 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13537 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13538 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13539 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13540 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13541 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13542 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13543 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13544 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13545 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13546 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13547 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13548 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13549 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13550 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13551 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13552 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13553 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13554 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13555 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13556 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13557 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13558 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13559 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13560 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13561 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13562 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13563 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13564 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13565 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13566 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13567 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13568 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13569 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13570 };
13571
13572 uint size_hooks = 4;
13573
13574 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13575 {
13576 // insert correct hook size
13577 }
13578
13579 // we can optimize some stuff here...
13580
13581 device_param->size_pws = size_pws;
13582 device_param->size_tmps = size_tmps;
13583 device_param->size_hooks = size_hooks;
13584
13585 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13586 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13587
13588 device_param->size_root_css = size_root_css;
13589 device_param->size_markov_css = size_markov_css;
13590
13591 uint size_results = KERNEL_THREADS * sizeof (uint);
13592
13593 device_param->size_results = size_results;
13594
13595 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13596 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13597
13598 uint size_plains = digests_cnt * sizeof (plain_t);
13599 uint size_salts = salts_cnt * sizeof (salt_t);
13600 uint size_esalts = salts_cnt * esalt_size;
13601
13602 device_param->size_plains = size_plains;
13603 device_param->size_digests = size_digests;
13604 device_param->size_shown = size_shown;
13605 device_param->size_salts = size_salts;
13606
13607 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13608 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13609 uint size_tm = 32 * sizeof (bs_word_t);
13610
13611 u64 size_scryptV = 1;
13612
13613 if ((hash_mode == 8900) || (hash_mode == 9300))
13614 {
13615 uint tmto_start = 0;
13616 uint tmto_stop = 10;
13617
13618 if (scrypt_tmto)
13619 {
13620 tmto_start = scrypt_tmto;
13621 }
13622 else
13623 {
13624 // in case the user did not specify the tmto manually
13625 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13626 // but set the lower end only in case the user has a device with too less memory
13627
13628 if (hash_mode == 8900)
13629 {
13630 if (device_param->vendor_id == VENDOR_ID_AMD)
13631 {
13632 tmto_start = 1;
13633 }
13634 else if (device_param->vendor_id == VENDOR_ID_NV)
13635 {
13636 tmto_start = 3;
13637 }
13638 }
13639 else if (hash_mode == 9300)
13640 {
13641 if (device_param->vendor_id == VENDOR_ID_AMD)
13642 {
13643 tmto_start = 3;
13644 }
13645 else if (device_param->vendor_id == VENDOR_ID_NV)
13646 {
13647 tmto_start = 5;
13648 }
13649 }
13650 }
13651
13652 if (quiet == 0) log_info ("");
13653
13654 uint shader_per_mp = 1;
13655
13656 if (device_param->vendor_id == VENDOR_ID_AMD)
13657 {
13658 shader_per_mp = 8;
13659 }
13660 else if (device_param->vendor_id == VENDOR_ID_NV)
13661 {
13662 shader_per_mp = 32;
13663 }
13664
13665 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13666 {
13667 // TODO: in theory the following calculation needs to be done per salt, not global
13668 // we assume all hashes have the same scrypt settings
13669
13670 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13671
13672 size_scryptV /= 1 << tmto;
13673
13674 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13675
13676 if (size_scryptV > device_param->device_maxmem_alloc)
13677 {
13678 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13679
13680 continue;
13681 }
13682
13683 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13684 {
13685 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13686 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13687 }
13688
13689 break;
13690 }
13691
13692 if (data.salts_buf[0].scrypt_phy == 0)
13693 {
13694 log_error ("ERROR: can't allocate enough device memory");
13695
13696 return -1;
13697 }
13698
13699 if (quiet == 0) log_info ("");
13700 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13701 }
13702
13703 /**
13704 * default building options
13705 */
13706
13707 char build_opts[1024] = { 0 };
13708
13709 // we don't have sm_* on vendors not NV but it doesn't matter
13710
13711 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%d -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);
13712
13713 /**
13714 * main kernel
13715 */
13716
13717 {
13718 /**
13719 * kernel source filename
13720 */
13721
13722 char source_file[256] = { 0 };
13723
13724 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13725
13726 struct stat sst;
13727
13728 if (stat (source_file, &sst) == -1)
13729 {
13730 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13731
13732 return -1;
13733 }
13734
13735 /**
13736 * kernel cached filename
13737 */
13738
13739 char cached_file[256] = { 0 };
13740
13741 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13742
13743 int cached = 1;
13744
13745 struct stat cst;
13746
13747 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13748 {
13749 cached = 0;
13750 }
13751
13752 /**
13753 * kernel compile or load
13754 */
13755
13756 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13757
13758 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13759
13760 if (force_jit_compilation == -1)
13761 {
13762 if (cached == 0)
13763 {
13764 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13765
13766 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13767
13768 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13769
13770 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13771
13772 size_t binary_size;
13773
13774 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13775
13776 u8 *binary = (u8 *) mymalloc (binary_size);
13777
13778 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13779
13780 writeProgramBin (cached_file, binary, binary_size);
13781
13782 local_free (binary);
13783 }
13784 else
13785 {
13786 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13787
13788 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13789
13790 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13791
13792 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13793 }
13794 }
13795 else
13796 {
13797 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13798
13799 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13800
13801 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13802
13803 char build_opts_update[1024] = { 0 };
13804
13805 if (force_jit_compilation == 1500)
13806 {
13807 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13808 }
13809 else if (force_jit_compilation == 8900)
13810 {
13811 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);
13812 }
13813
13814 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
13815 }
13816
13817 local_free (kernel_lengths);
13818 local_free (kernel_sources[0]);
13819 local_free (kernel_sources);
13820 }
13821
13822 /**
13823 * word generator kernel
13824 */
13825
13826 if (attack_mode != ATTACK_MODE_STRAIGHT)
13827 {
13828 /**
13829 * kernel mp source filename
13830 */
13831
13832 char source_file[256] = { 0 };
13833
13834 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13835
13836 struct stat sst;
13837
13838 if (stat (source_file, &sst) == -1)
13839 {
13840 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13841
13842 return -1;
13843 }
13844
13845 /**
13846 * kernel mp cached filename
13847 */
13848
13849 char cached_file[256] = { 0 };
13850
13851 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13852
13853 int cached = 1;
13854
13855 struct stat cst;
13856
13857 if (stat (cached_file, &cst) == -1)
13858 {
13859 cached = 0;
13860 }
13861
13862 /**
13863 * kernel compile or load
13864 */
13865
13866 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13867
13868 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13869
13870 if (cached == 0)
13871 {
13872 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13873
13874 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13875
13876 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13877
13878 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13879
13880 size_t binary_size;
13881
13882 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13883
13884 u8 *binary = (u8 *) mymalloc (binary_size);
13885
13886 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13887
13888 writeProgramBin (cached_file, binary, binary_size);
13889
13890 local_free (binary);
13891 }
13892 else
13893 {
13894 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13895
13896 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13897
13898 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13899
13900 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13901 }
13902
13903 local_free (kernel_lengths);
13904 local_free (kernel_sources[0]);
13905 local_free (kernel_sources);
13906 }
13907
13908 /**
13909 * amplifier kernel
13910 */
13911
13912 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13913 {
13914
13915 }
13916 else
13917 {
13918 /**
13919 * kernel amp source filename
13920 */
13921
13922 char source_file[256] = { 0 };
13923
13924 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13925
13926 struct stat sst;
13927
13928 if (stat (source_file, &sst) == -1)
13929 {
13930 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13931
13932 return -1;
13933 }
13934
13935 /**
13936 * kernel amp cached filename
13937 */
13938
13939 char cached_file[256] = { 0 };
13940
13941 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13942
13943 int cached = 1;
13944
13945 struct stat cst;
13946
13947 if (stat (cached_file, &cst) == -1)
13948 {
13949 cached = 0;
13950 }
13951
13952 /**
13953 * kernel compile or load
13954 */
13955
13956 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13957
13958 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13959
13960 if (cached == 0)
13961 {
13962 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13963
13964 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13965
13966 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13967
13968 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13969
13970 size_t binary_size;
13971
13972 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13973
13974 u8 *binary = (u8 *) mymalloc (binary_size);
13975
13976 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13977
13978 writeProgramBin (cached_file, binary, binary_size);
13979
13980 local_free (binary);
13981 }
13982 else
13983 {
13984 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13985
13986 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13987
13988 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13989
13990 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13991 }
13992
13993 local_free (kernel_lengths);
13994 local_free (kernel_sources[0]);
13995 local_free (kernel_sources);
13996 }
13997
13998 /**
13999 * global buffers
14000 */
14001
14002 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14003 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14004 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14005 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14006 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14007 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14008 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14009 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14010 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14011 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14012 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14013 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14014 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14015 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14016 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14017 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14018 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14019 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14020
14021 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);
14022 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);
14023 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);
14024 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);
14025 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);
14026 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);
14027 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);
14028 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);
14029 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14030 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14031 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14032
14033 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14034 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14035 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14036 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14037 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14038 run_kernel_bzero (device_param, device_param->d_result, size_results);
14039
14040 /**
14041 * special buffers
14042 */
14043
14044 if (attack_kern == ATTACK_KERN_STRAIGHT)
14045 {
14046 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14047 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14048
14049 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14050
14051 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14052 }
14053 else if (attack_kern == ATTACK_KERN_COMBI)
14054 {
14055 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14056 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14057 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14058 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14059
14060 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14061 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14062 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14063 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14064 }
14065 else if (attack_kern == ATTACK_KERN_BF)
14066 {
14067 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14068 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14069 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14070 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14071 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14072
14073 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14074 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14075 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14076 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14077 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14078 }
14079
14080 if (size_esalts)
14081 {
14082 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14083
14084 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14085 }
14086
14087 /**
14088 * main host data
14089 */
14090
14091 uint *result = (uint *) mymalloc (size_results);
14092
14093 device_param->result = result;
14094
14095 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14096
14097 device_param->pws_buf = pws_buf;
14098
14099 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14100
14101 for (int i = 0; i < 64; i++)
14102 {
14103 pw_caches[i].pw_buf.pw_len = i;
14104 pw_caches[i].cnt = 0;
14105 }
14106
14107 device_param->pw_caches = pw_caches;
14108
14109 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14110
14111 device_param->combs_buf = combs_buf;
14112
14113 void *hooks_buf = mymalloc (size_hooks);
14114
14115 device_param->hooks_buf = hooks_buf;
14116
14117 device_param->pw_transpose = pw_transpose_to_hi1;
14118 device_param->pw_add = pw_add_to_hc1;
14119
14120 /**
14121 * kernel args
14122 */
14123
14124 device_param->kernel_params_buf32[21] = bitmap_mask;
14125 device_param->kernel_params_buf32[22] = bitmap_shift1;
14126 device_param->kernel_params_buf32[23] = bitmap_shift2;
14127 device_param->kernel_params_buf32[24] = 0; // salt_pos
14128 device_param->kernel_params_buf32[25] = 0; // loop_pos
14129 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14130 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14131 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14132 device_param->kernel_params_buf32[29] = 0; // digests_offset
14133 device_param->kernel_params_buf32[30] = 0; // combs_mode
14134 device_param->kernel_params_buf32[31] = 0; // gid_max
14135
14136 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14137 ? &device_param->d_pws_buf
14138 : &device_param->d_pws_amp_buf;
14139 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14140 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14141 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14142 device_param->kernel_params[ 4] = &device_param->d_tmps;
14143 device_param->kernel_params[ 5] = &device_param->d_hooks;
14144 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14145 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14146 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14147 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14148 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14149 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14150 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14151 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14152 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14153 device_param->kernel_params[15] = &device_param->d_digests_buf;
14154 device_param->kernel_params[16] = &device_param->d_digests_shown;
14155 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14156 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14157 device_param->kernel_params[19] = &device_param->d_result;
14158 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14159 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14160 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14161 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14162 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14163 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14164 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14165 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14166 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14167 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14168 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14169 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14170
14171 device_param->kernel_params_mp_buf64[3] = 0;
14172 device_param->kernel_params_mp_buf32[4] = 0;
14173 device_param->kernel_params_mp_buf32[5] = 0;
14174 device_param->kernel_params_mp_buf32[6] = 0;
14175 device_param->kernel_params_mp_buf32[7] = 0;
14176 device_param->kernel_params_mp_buf32[8] = 0;
14177
14178 device_param->kernel_params_mp[0] = NULL;
14179 device_param->kernel_params_mp[1] = NULL;
14180 device_param->kernel_params_mp[2] = NULL;
14181 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14182 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14183 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14184 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14185 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14186 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14187
14188 device_param->kernel_params_mp_l_buf64[3] = 0;
14189 device_param->kernel_params_mp_l_buf32[4] = 0;
14190 device_param->kernel_params_mp_l_buf32[5] = 0;
14191 device_param->kernel_params_mp_l_buf32[6] = 0;
14192 device_param->kernel_params_mp_l_buf32[7] = 0;
14193 device_param->kernel_params_mp_l_buf32[8] = 0;
14194 device_param->kernel_params_mp_l_buf32[9] = 0;
14195
14196 device_param->kernel_params_mp_l[0] = NULL;
14197 device_param->kernel_params_mp_l[1] = NULL;
14198 device_param->kernel_params_mp_l[2] = NULL;
14199 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14200 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14201 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14202 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14203 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14204 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14205 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14206
14207 device_param->kernel_params_mp_r_buf64[3] = 0;
14208 device_param->kernel_params_mp_r_buf32[4] = 0;
14209 device_param->kernel_params_mp_r_buf32[5] = 0;
14210 device_param->kernel_params_mp_r_buf32[6] = 0;
14211 device_param->kernel_params_mp_r_buf32[7] = 0;
14212 device_param->kernel_params_mp_r_buf32[8] = 0;
14213
14214 device_param->kernel_params_mp_r[0] = NULL;
14215 device_param->kernel_params_mp_r[1] = NULL;
14216 device_param->kernel_params_mp_r[2] = NULL;
14217 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14218 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14219 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14220 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14221 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14222 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14223
14224 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14225 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14226
14227 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14228 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14229 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14230 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14231 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14232 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14233 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14234
14235 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14236
14237 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14238 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14239
14240 /**
14241 * kernel name
14242 */
14243
14244 char kernel_name[64] = { 0 };
14245
14246 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14247 {
14248 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14249 {
14250 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14251
14252 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14253
14254 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14255
14256 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14257
14258 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14259
14260 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14261 }
14262 else
14263 {
14264 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14265
14266 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14267
14268 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14269
14270 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14271
14272 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14273
14274 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14275 }
14276
14277 if (data.attack_mode == ATTACK_MODE_BF)
14278 {
14279 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14280 {
14281 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14282
14283 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14284
14285 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14286
14287 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14288 }
14289 }
14290 }
14291 else
14292 {
14293 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14294
14295 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14296
14297 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14298
14299 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14300
14301 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14302
14303 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14304
14305 if (opts_type & OPTS_TYPE_HOOK12)
14306 {
14307 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14308
14309 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14310 }
14311
14312 if (opts_type & OPTS_TYPE_HOOK23)
14313 {
14314 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14315
14316 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14317 }
14318 }
14319
14320 for (uint i = 0; i <= 20; i++)
14321 {
14322 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14323 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14324 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14325
14326 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14327 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14328 }
14329
14330 for (uint i = 21; i <= 31; i++)
14331 {
14332 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14333 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14334 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14335
14336 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14337 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14338 }
14339
14340 if (attack_mode == ATTACK_MODE_BF)
14341 {
14342 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14343 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14344
14345 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14346 {
14347 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14348
14349 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14350 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14351 }
14352 }
14353 else if (attack_mode == ATTACK_MODE_HYBRID1)
14354 {
14355 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14356 }
14357 else if (attack_mode == ATTACK_MODE_HYBRID2)
14358 {
14359 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14360 }
14361
14362 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14363 {
14364 // nothing to do
14365 }
14366 else
14367 {
14368 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14369 }
14370
14371 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14372 {
14373 // nothing to do
14374 }
14375 else
14376 {
14377 for (uint i = 0; i < 5; i++)
14378 {
14379 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14380 }
14381
14382 for (uint i = 5; i < 7; i++)
14383 {
14384 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14385 }
14386 }
14387
14388 /**
14389 * Store initial fanspeed if gpu_temp_retain is enabled
14390 */
14391
14392 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14393 int gpu_temp_retain_set = 0;
14394
14395 if (gpu_temp_disable == 0)
14396 {
14397 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14398 {
14399 hc_thread_mutex_lock (mux_adl);
14400
14401 if (data.hm_device[device_id].fan_supported == 1)
14402 {
14403 if (gpu_temp_retain_chgd == 0)
14404 {
14405 uint cur_temp = 0;
14406 uint default_temp = 0;
14407
14408 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);
14409
14410 if (ADL_rc == ADL_OK)
14411 {
14412 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14413
14414 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14415
14416 // special case with multi gpu setups: always use minimum retain
14417
14418 if (gpu_temp_retain_set == 0)
14419 {
14420 gpu_temp_retain = gpu_temp_retain_target;
14421 gpu_temp_retain_set = 1;
14422 }
14423 else
14424 {
14425 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14426 }
14427
14428 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14429 }
14430 }
14431
14432 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14433
14434 temp_retain_fanspeed_value[device_id] = fan_speed;
14435
14436 if (fan_speed == -1)
14437 {
14438 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14439
14440 temp_retain_fanspeed_value[device_id] = 0;
14441 }
14442 }
14443
14444 hc_thread_mutex_unlock (mux_adl);
14445 }
14446 }
14447
14448 /**
14449 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14450 */
14451
14452 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14453 {
14454 hc_thread_mutex_lock (mux_adl);
14455
14456 if (data.hm_device[device_id].od_version == 6)
14457 {
14458 int ADL_rc;
14459
14460 // check powertune capabilities first, if not available then skip device
14461
14462 int powertune_supported = 0;
14463
14464 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14465 {
14466 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14467
14468 return (-1);
14469 }
14470
14471 if (powertune_supported != 0)
14472 {
14473 // powercontrol settings
14474
14475 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14476
14477 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14478 {
14479 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14480 }
14481
14482 if (ADL_rc != ADL_OK)
14483 {
14484 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14485
14486 return (-1);
14487 }
14488
14489 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14490 {
14491 log_error ("ERROR: Failed to set new ADL PowerControl values");
14492
14493 return (-1);
14494 }
14495
14496 // clocks
14497
14498 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14499
14500 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14501
14502 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)
14503 {
14504 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14505
14506 return (-1);
14507 }
14508
14509 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14510
14511 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14512
14513 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14514 {
14515 log_error ("ERROR: Failed to get ADL device capabilities");
14516
14517 return (-1);
14518 }
14519
14520 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14521 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14522
14523 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14524 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14525
14526 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14527 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14528
14529 // warning if profile has too low max values
14530
14531 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14532 {
14533 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14534 }
14535
14536 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14537 {
14538 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14539 }
14540
14541 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14542
14543 performance_state->iNumberOfPerformanceLevels = 2;
14544
14545 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14546 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14547 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14548 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14549
14550 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)
14551 {
14552 log_info ("ERROR: Failed to set ADL performance state");
14553
14554 return (-1);
14555 }
14556
14557 local_free (performance_state);
14558 }
14559 }
14560
14561 hc_thread_mutex_unlock (mux_adl);
14562 }
14563 #endif // HAVE_HWMON && HAVE_ADL
14564 }
14565
14566 data.kernel_blocks_all = kernel_blocks_all;
14567
14568 if (data.quiet == 0) log_info ("");
14569
14570 /**
14571 * Inform user which algorithm is checked and at which workload setting
14572 */
14573
14574 if (benchmark == 1)
14575 {
14576 quiet = 0;
14577
14578 data.quiet = quiet;
14579
14580 char *hash_type = strhashtype (data.hash_mode); // not a bug
14581
14582 log_info ("Hashtype: %s", hash_type);
14583 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14584 log_info ("");
14585 }
14586
14587 /**
14588 * keep track of the progress
14589 */
14590
14591 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14592 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14593 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14594
14595 /**
14596 * open filehandles
14597 */
14598
14599 #if _WIN
14600 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14601 {
14602 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14603
14604 return (-1);
14605 }
14606
14607 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14608 {
14609 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14610
14611 return (-1);
14612 }
14613
14614 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14615 {
14616 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14617
14618 return (-1);
14619 }
14620 #endif
14621
14622 /**
14623 * dictionary pad
14624 */
14625
14626 segment_size *= (1024 * 1024);
14627
14628 data.segment_size = segment_size;
14629
14630 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14631
14632 wl_data->buf = (char *) mymalloc (segment_size);
14633 wl_data->avail = segment_size;
14634 wl_data->incr = segment_size;
14635 wl_data->cnt = 0;
14636 wl_data->pos = 0;
14637
14638 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14639
14640 data.wordlist_mode = wordlist_mode;
14641
14642 cs_t *css_buf = NULL;
14643 uint css_cnt = 0;
14644 uint dictcnt = 0;
14645 uint maskcnt = 1;
14646 char **masks = NULL;
14647 char **dictfiles = NULL;
14648
14649 uint mask_from_file = 0;
14650
14651 if (attack_mode == ATTACK_MODE_STRAIGHT)
14652 {
14653 if (wordlist_mode == WL_MODE_FILE)
14654 {
14655 int wls_left = myargc - (optind + 1);
14656
14657 for (int i = 0; i < wls_left; i++)
14658 {
14659 char *l0_filename = myargv[optind + 1 + i];
14660
14661 struct stat l0_stat;
14662
14663 if (stat (l0_filename, &l0_stat) == -1)
14664 {
14665 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14666
14667 return (-1);
14668 }
14669
14670 uint is_dir = S_ISDIR (l0_stat.st_mode);
14671
14672 if (is_dir == 0)
14673 {
14674 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14675
14676 dictcnt++;
14677
14678 dictfiles[dictcnt - 1] = l0_filename;
14679 }
14680 else
14681 {
14682 // do not allow --keyspace w/ a directory
14683
14684 if (keyspace == 1)
14685 {
14686 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14687
14688 return (-1);
14689 }
14690
14691 char **dictionary_files = NULL;
14692
14693 dictionary_files = scan_directory (l0_filename);
14694
14695 if (dictionary_files != NULL)
14696 {
14697 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14698
14699 for (int d = 0; dictionary_files[d] != NULL; d++)
14700 {
14701 char *l1_filename = dictionary_files[d];
14702
14703 struct stat l1_stat;
14704
14705 if (stat (l1_filename, &l1_stat) == -1)
14706 {
14707 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14708
14709 return (-1);
14710 }
14711
14712 if (S_ISREG (l1_stat.st_mode))
14713 {
14714 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14715
14716 dictcnt++;
14717
14718 dictfiles[dictcnt - 1] = strdup (l1_filename);
14719 }
14720 }
14721 }
14722
14723 local_free (dictionary_files);
14724 }
14725 }
14726
14727 if (dictcnt < 1)
14728 {
14729 log_error ("ERROR: No usable dictionary file found.");
14730
14731 return (-1);
14732 }
14733 }
14734 else if (wordlist_mode == WL_MODE_STDIN)
14735 {
14736 dictcnt = 1;
14737 }
14738 }
14739 else if (attack_mode == ATTACK_MODE_COMBI)
14740 {
14741 // display
14742
14743 char *dictfile1 = myargv[optind + 1 + 0];
14744 char *dictfile2 = myargv[optind + 1 + 1];
14745
14746 // find the bigger dictionary and use as base
14747
14748 FILE *fp1 = NULL;
14749 FILE *fp2 = NULL;
14750
14751 struct stat tmp_stat;
14752
14753 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14754 {
14755 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14756
14757 return (-1);
14758 }
14759
14760 if (stat (dictfile1, &tmp_stat) == -1)
14761 {
14762 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14763
14764 fclose (fp1);
14765
14766 return (-1);
14767 }
14768
14769 if (S_ISDIR (tmp_stat.st_mode))
14770 {
14771 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14772
14773 fclose (fp1);
14774
14775 return (-1);
14776 }
14777
14778 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14779 {
14780 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14781
14782 fclose (fp1);
14783
14784 return (-1);
14785 }
14786
14787 if (stat (dictfile2, &tmp_stat) == -1)
14788 {
14789 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14790
14791 fclose (fp1);
14792 fclose (fp2);
14793
14794 return (-1);
14795 }
14796
14797 if (S_ISDIR (tmp_stat.st_mode))
14798 {
14799 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14800
14801 fclose (fp1);
14802 fclose (fp2);
14803
14804 return (-1);
14805 }
14806
14807 data.combs_cnt = 1;
14808
14809 data.quiet = 1;
14810
14811 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14812
14813 data.quiet = quiet;
14814
14815 if (words1_cnt == 0)
14816 {
14817 log_error ("ERROR: %s: empty file", dictfile1);
14818
14819 fclose (fp1);
14820 fclose (fp2);
14821
14822 return (-1);
14823 }
14824
14825 data.combs_cnt = 1;
14826
14827 data.quiet = 1;
14828
14829 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14830
14831 data.quiet = quiet;
14832
14833 if (words2_cnt == 0)
14834 {
14835 log_error ("ERROR: %s: empty file", dictfile2);
14836
14837 fclose (fp1);
14838 fclose (fp2);
14839
14840 return (-1);
14841 }
14842
14843 fclose (fp1);
14844 fclose (fp2);
14845
14846 data.dictfile = dictfile1;
14847 data.dictfile2 = dictfile2;
14848
14849 if (words1_cnt >= words2_cnt)
14850 {
14851 data.combs_cnt = words2_cnt;
14852 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14853
14854 dictfiles = &data.dictfile;
14855
14856 dictcnt = 1;
14857 }
14858 else
14859 {
14860 data.combs_cnt = words1_cnt;
14861 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14862
14863 dictfiles = &data.dictfile2;
14864
14865 dictcnt = 1;
14866
14867 // we also have to switch wordlist related rules!
14868
14869 char *tmpc = data.rule_buf_l;
14870
14871 data.rule_buf_l = data.rule_buf_r;
14872 data.rule_buf_r = tmpc;
14873
14874 int tmpi = data.rule_len_l;
14875
14876 data.rule_len_l = data.rule_len_r;
14877 data.rule_len_r = tmpi;
14878 }
14879 }
14880 else if (attack_mode == ATTACK_MODE_BF)
14881 {
14882 char *mask = NULL;
14883
14884 maskcnt = 0;
14885
14886 if (benchmark == 0)
14887 {
14888 mask = myargv[optind + 1];
14889
14890 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14891
14892 if ((optind + 2) <= myargc)
14893 {
14894 struct stat file_stat;
14895
14896 if (stat (mask, &file_stat) == -1)
14897 {
14898 maskcnt = 1;
14899
14900 masks[maskcnt - 1] = mystrdup (mask);
14901 }
14902 else
14903 {
14904 int wls_left = myargc - (optind + 1);
14905
14906 uint masks_avail = INCR_MASKS;
14907
14908 for (int i = 0; i < wls_left; i++)
14909 {
14910 if (i != 0)
14911 {
14912 mask = myargv[optind + 1 + i];
14913
14914 if (stat (mask, &file_stat) == -1)
14915 {
14916 log_error ("ERROR: %s: %s", mask, strerror (errno));
14917
14918 return (-1);
14919 }
14920 }
14921
14922 uint is_file = S_ISREG (file_stat.st_mode);
14923
14924 if (is_file == 1)
14925 {
14926 FILE *mask_fp;
14927
14928 if ((mask_fp = fopen (mask, "r")) == NULL)
14929 {
14930 log_error ("ERROR: %s: %s", mask, strerror (errno));
14931
14932 return (-1);
14933 }
14934
14935 char line_buf[BUFSIZ] = { 0 };
14936
14937 while (!feof (mask_fp))
14938 {
14939 memset (line_buf, 0, BUFSIZ);
14940
14941 int line_len = fgetl (mask_fp, line_buf);
14942
14943 if (line_len == 0) continue;
14944
14945 if (line_buf[0] == '#') continue;
14946
14947 if (masks_avail == maskcnt)
14948 {
14949 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14950
14951 masks_avail += INCR_MASKS;
14952 }
14953
14954 masks[maskcnt] = mystrdup (line_buf);
14955
14956 maskcnt++;
14957 }
14958
14959 fclose (mask_fp);
14960 }
14961 else
14962 {
14963 log_error ("ERROR: %s: unsupported file-type", mask);
14964
14965 return (-1);
14966 }
14967 }
14968
14969 mask_from_file = 1;
14970 }
14971 }
14972 else
14973 {
14974 custom_charset_1 = (char *) "?l?d?u";
14975 custom_charset_2 = (char *) "?l?d";
14976 custom_charset_3 = (char *) "?l?d*!$@_";
14977
14978 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14979 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14980 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14981
14982 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14983
14984 wordlist_mode = WL_MODE_MASK;
14985
14986 data.wordlist_mode = wordlist_mode;
14987
14988 increment = 1;
14989
14990 maskcnt = 1;
14991 }
14992 }
14993 else
14994 {
14995 /**
14996 * generate full masks and charsets
14997 */
14998
14999 masks = (char **) mymalloc (sizeof (char *));
15000
15001 switch (hash_mode)
15002 {
15003 case 1731: pw_min = 5;
15004 pw_max = 5;
15005 mask = mystrdup ("?b?b?b?b?b");
15006 break;
15007 case 12500: pw_min = 5;
15008 pw_max = 5;
15009 mask = mystrdup ("?b?b?b?b?b");
15010 break;
15011 default: pw_min = 7;
15012 pw_max = 7;
15013 mask = mystrdup ("?b?b?b?b?b?b?b");
15014 break;
15015 }
15016
15017 maskcnt = 1;
15018
15019 masks[maskcnt - 1] = mystrdup (mask);
15020
15021 wordlist_mode = WL_MODE_MASK;
15022
15023 data.wordlist_mode = wordlist_mode;
15024
15025 increment = 1;
15026 }
15027
15028 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15029
15030 if (increment)
15031 {
15032 if (increment_min > pw_min) pw_min = increment_min;
15033
15034 if (increment_max < pw_max) pw_max = increment_max;
15035 }
15036 }
15037 else if (attack_mode == ATTACK_MODE_HYBRID1)
15038 {
15039 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15040
15041 // display
15042
15043 char *mask = myargv[myargc - 1];
15044
15045 maskcnt = 0;
15046
15047 masks = (char **) mymalloc (1 * sizeof (char *));
15048
15049 // mod
15050
15051 struct stat file_stat;
15052
15053 if (stat (mask, &file_stat) == -1)
15054 {
15055 maskcnt = 1;
15056
15057 masks[maskcnt - 1] = mystrdup (mask);
15058 }
15059 else
15060 {
15061 uint is_file = S_ISREG (file_stat.st_mode);
15062
15063 if (is_file == 1)
15064 {
15065 FILE *mask_fp;
15066
15067 if ((mask_fp = fopen (mask, "r")) == NULL)
15068 {
15069 log_error ("ERROR: %s: %s", mask, strerror (errno));
15070
15071 return (-1);
15072 }
15073
15074 char line_buf[BUFSIZ] = { 0 };
15075
15076 uint masks_avail = 1;
15077
15078 while (!feof (mask_fp))
15079 {
15080 memset (line_buf, 0, BUFSIZ);
15081
15082 int line_len = fgetl (mask_fp, line_buf);
15083
15084 if (line_len == 0) continue;
15085
15086 if (line_buf[0] == '#') continue;
15087
15088 if (masks_avail == maskcnt)
15089 {
15090 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15091
15092 masks_avail += INCR_MASKS;
15093 }
15094
15095 masks[maskcnt] = mystrdup (line_buf);
15096
15097 maskcnt++;
15098 }
15099
15100 fclose (mask_fp);
15101
15102 mask_from_file = 1;
15103 }
15104 else
15105 {
15106 maskcnt = 1;
15107
15108 masks[maskcnt - 1] = mystrdup (mask);
15109 }
15110 }
15111
15112 // base
15113
15114 int wls_left = myargc - (optind + 2);
15115
15116 for (int i = 0; i < wls_left; i++)
15117 {
15118 char *filename = myargv[optind + 1 + i];
15119
15120 struct stat file_stat;
15121
15122 if (stat (filename, &file_stat) == -1)
15123 {
15124 log_error ("ERROR: %s: %s", filename, strerror (errno));
15125
15126 return (-1);
15127 }
15128
15129 uint is_dir = S_ISDIR (file_stat.st_mode);
15130
15131 if (is_dir == 0)
15132 {
15133 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15134
15135 dictcnt++;
15136
15137 dictfiles[dictcnt - 1] = filename;
15138 }
15139 else
15140 {
15141 // do not allow --keyspace w/ a directory
15142
15143 if (keyspace == 1)
15144 {
15145 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15146
15147 return (-1);
15148 }
15149
15150 char **dictionary_files = NULL;
15151
15152 dictionary_files = scan_directory (filename);
15153
15154 if (dictionary_files != NULL)
15155 {
15156 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15157
15158 for (int d = 0; dictionary_files[d] != NULL; d++)
15159 {
15160 char *l1_filename = dictionary_files[d];
15161
15162 struct stat l1_stat;
15163
15164 if (stat (l1_filename, &l1_stat) == -1)
15165 {
15166 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15167
15168 return (-1);
15169 }
15170
15171 if (S_ISREG (l1_stat.st_mode))
15172 {
15173 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15174
15175 dictcnt++;
15176
15177 dictfiles[dictcnt - 1] = strdup (l1_filename);
15178 }
15179 }
15180 }
15181
15182 local_free (dictionary_files);
15183 }
15184 }
15185
15186 if (dictcnt < 1)
15187 {
15188 log_error ("ERROR: No usable dictionary file found.");
15189
15190 return (-1);
15191 }
15192
15193 if (increment)
15194 {
15195 maskcnt = 0;
15196
15197 uint mask_min = increment_min; // we can't reject smaller masks here
15198 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15199
15200 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15201 {
15202 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15203
15204 if (cur_mask == NULL) break;
15205
15206 masks[maskcnt] = cur_mask;
15207
15208 maskcnt++;
15209
15210 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15211 }
15212 }
15213 }
15214 else if (attack_mode == ATTACK_MODE_HYBRID2)
15215 {
15216 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15217
15218 // display
15219
15220 char *mask = myargv[optind + 1 + 0];
15221
15222 maskcnt = 0;
15223
15224 masks = (char **) mymalloc (1 * sizeof (char *));
15225
15226 // mod
15227
15228 struct stat file_stat;
15229
15230 if (stat (mask, &file_stat) == -1)
15231 {
15232 maskcnt = 1;
15233
15234 masks[maskcnt - 1] = mystrdup (mask);
15235 }
15236 else
15237 {
15238 uint is_file = S_ISREG (file_stat.st_mode);
15239
15240 if (is_file == 1)
15241 {
15242 FILE *mask_fp;
15243
15244 if ((mask_fp = fopen (mask, "r")) == NULL)
15245 {
15246 log_error ("ERROR: %s: %s", mask, strerror (errno));
15247
15248 return (-1);
15249 }
15250
15251 char line_buf[BUFSIZ] = { 0 };
15252
15253 uint masks_avail = 1;
15254
15255 while (!feof (mask_fp))
15256 {
15257 memset (line_buf, 0, BUFSIZ);
15258
15259 int line_len = fgetl (mask_fp, line_buf);
15260
15261 if (line_len == 0) continue;
15262
15263 if (line_buf[0] == '#') continue;
15264
15265 if (masks_avail == maskcnt)
15266 {
15267 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15268
15269 masks_avail += INCR_MASKS;
15270 }
15271
15272 masks[maskcnt] = mystrdup (line_buf);
15273
15274 maskcnt++;
15275 }
15276
15277 fclose (mask_fp);
15278
15279 mask_from_file = 1;
15280 }
15281 else
15282 {
15283 maskcnt = 1;
15284
15285 masks[maskcnt - 1] = mystrdup (mask);
15286 }
15287 }
15288
15289 // base
15290
15291 int wls_left = myargc - (optind + 2);
15292
15293 for (int i = 0; i < wls_left; i++)
15294 {
15295 char *filename = myargv[optind + 2 + i];
15296
15297 struct stat file_stat;
15298
15299 if (stat (filename, &file_stat) == -1)
15300 {
15301 log_error ("ERROR: %s: %s", filename, strerror (errno));
15302
15303 return (-1);
15304 }
15305
15306 uint is_dir = S_ISDIR (file_stat.st_mode);
15307
15308 if (is_dir == 0)
15309 {
15310 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15311
15312 dictcnt++;
15313
15314 dictfiles[dictcnt - 1] = filename;
15315 }
15316 else
15317 {
15318 // do not allow --keyspace w/ a directory
15319
15320 if (keyspace == 1)
15321 {
15322 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15323
15324 return (-1);
15325 }
15326
15327 char **dictionary_files = NULL;
15328
15329 dictionary_files = scan_directory (filename);
15330
15331 if (dictionary_files != NULL)
15332 {
15333 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15334
15335 for (int d = 0; dictionary_files[d] != NULL; d++)
15336 {
15337 char *l1_filename = dictionary_files[d];
15338
15339 struct stat l1_stat;
15340
15341 if (stat (l1_filename, &l1_stat) == -1)
15342 {
15343 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15344
15345 return (-1);
15346 }
15347
15348 if (S_ISREG (l1_stat.st_mode))
15349 {
15350 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15351
15352 dictcnt++;
15353
15354 dictfiles[dictcnt - 1] = strdup (l1_filename);
15355 }
15356 }
15357 }
15358
15359 local_free (dictionary_files);
15360 }
15361 }
15362
15363 if (dictcnt < 1)
15364 {
15365 log_error ("ERROR: No usable dictionary file found.");
15366
15367 return (-1);
15368 }
15369
15370 if (increment)
15371 {
15372 maskcnt = 0;
15373
15374 uint mask_min = increment_min; // we can't reject smaller masks here
15375 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15376
15377 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15378 {
15379 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15380
15381 if (cur_mask == NULL) break;
15382
15383 masks[maskcnt] = cur_mask;
15384
15385 maskcnt++;
15386
15387 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15388 }
15389 }
15390 }
15391
15392 data.pw_min = pw_min;
15393 data.pw_max = pw_max;
15394
15395 /**
15396 * weak hash check
15397 */
15398
15399 if (weak_hash_threshold >= salts_cnt)
15400 {
15401 uint first_device_id = 0;
15402
15403 hc_device_param_t *device_param = NULL;
15404
15405 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15406 {
15407 device_param = &data.devices_param[device_id];
15408
15409 if (device_param->skipped) continue;
15410
15411 first_device_id = device_id;
15412
15413 break;
15414 }
15415
15416 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15417
15418 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15419 {
15420 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15421 }
15422 }
15423
15424 // Display hack, guarantee that there is at least one \r before real start
15425
15426 if (data.quiet == 0) log_info_nn ("");
15427
15428 /**
15429 * status and monitor threads
15430 */
15431
15432 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15433
15434 hc_thread_t i_thread = 0;
15435
15436 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15437 {
15438 hc_thread_create (i_thread, thread_keypress, &benchmark);
15439 }
15440
15441 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15442
15443 uint ni_threads_cnt = 0;
15444
15445 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15446
15447 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15448
15449 ni_threads_cnt++;
15450
15451 /**
15452 * Outfile remove
15453 */
15454
15455 if (keyspace == 0)
15456 {
15457 if (outfile_check_timer != 0)
15458 {
15459 if (data.outfile_check_directory != NULL)
15460 {
15461 if ((hash_mode != 5200) &&
15462 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15463 (hash_mode != 9000))
15464 {
15465 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15466
15467 ni_threads_cnt++;
15468 }
15469 else
15470 {
15471 outfile_check_timer = 0;
15472 }
15473 }
15474 else
15475 {
15476 outfile_check_timer = 0;
15477 }
15478 }
15479 }
15480
15481 /**
15482 * Inform the user if we got some hashes remove because of the pot file remove feature
15483 */
15484
15485 if (data.quiet == 0)
15486 {
15487 if (potfile_remove_cracks > 0)
15488 {
15489 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15490 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15491 }
15492 }
15493
15494 data.outfile_check_timer = outfile_check_timer;
15495
15496 /**
15497 * main loop
15498 */
15499
15500 char **induction_dictionaries = NULL;
15501
15502 int induction_dictionaries_cnt = 0;
15503
15504 hcstat_table_t *root_table_buf = NULL;
15505 hcstat_table_t *markov_table_buf = NULL;
15506
15507 uint initial_restore_done = 0;
15508
15509 data.maskcnt = maskcnt;
15510
15511 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15512 {
15513 if (data.devices_status == STATUS_CRACKED) break;
15514
15515 data.devices_status = STATUS_INIT;
15516
15517 if (maskpos > rd->maskpos)
15518 {
15519 rd->dictpos = 0;
15520 }
15521
15522 rd->maskpos = maskpos;
15523 data.maskpos = maskpos;
15524
15525 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15526 {
15527 char *mask = masks[maskpos];
15528
15529 if (mask_from_file == 1)
15530 {
15531 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15532
15533 char *str_ptr;
15534 uint str_pos;
15535
15536 uint mask_offset = 0;
15537
15538 uint separator_cnt;
15539
15540 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15541 {
15542 str_ptr = strstr (mask + mask_offset, ",");
15543
15544 if (str_ptr == NULL) break;
15545
15546 str_pos = str_ptr - mask;
15547
15548 // escaped separator, i.e. "\,"
15549
15550 if (str_pos > 0)
15551 {
15552 if (mask[str_pos - 1] == '\\')
15553 {
15554 separator_cnt --;
15555
15556 mask_offset = str_pos + 1;
15557
15558 continue;
15559 }
15560 }
15561
15562 // reset the offset
15563
15564 mask_offset = 0;
15565
15566 mask[str_pos] = '\0';
15567
15568 switch (separator_cnt)
15569 {
15570 case 0:
15571 mp_reset_usr (mp_usr, 0);
15572
15573 custom_charset_1 = mask;
15574 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15575 break;
15576
15577 case 1:
15578 mp_reset_usr (mp_usr, 1);
15579
15580 custom_charset_2 = mask;
15581 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15582 break;
15583
15584 case 2:
15585 mp_reset_usr (mp_usr, 2);
15586
15587 custom_charset_3 = mask;
15588 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15589 break;
15590
15591 case 3:
15592 mp_reset_usr (mp_usr, 3);
15593
15594 custom_charset_4 = mask;
15595 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15596 break;
15597 }
15598
15599 mask = mask + str_pos + 1;
15600 }
15601 }
15602
15603 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15604 {
15605 if (maskpos > 0)
15606 {
15607 local_free (css_buf);
15608 local_free (data.root_css_buf);
15609 local_free (data.markov_css_buf);
15610
15611 local_free (masks[maskpos - 1]);
15612 }
15613
15614 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15615
15616 data.mask = mask;
15617 data.css_cnt = css_cnt;
15618 data.css_buf = css_buf;
15619
15620 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15621
15622 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15623
15624 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15625 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15626
15627 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15628
15629 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15630
15631 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15632 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15633
15634 data.root_css_buf = root_css_buf;
15635 data.markov_css_buf = markov_css_buf;
15636
15637 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15638
15639 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15640
15641 local_free (root_table_buf);
15642 local_free (markov_table_buf);
15643
15644 // args
15645
15646 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15647 {
15648 hc_device_param_t *device_param = &data.devices_param[device_id];
15649
15650 if (device_param->skipped) continue;
15651
15652 device_param->kernel_params_mp[0] = &device_param->d_combs;
15653 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15654 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15655
15656 device_param->kernel_params_mp_buf64[3] = 0;
15657 device_param->kernel_params_mp_buf32[4] = css_cnt;
15658 device_param->kernel_params_mp_buf32[5] = 0;
15659 device_param->kernel_params_mp_buf32[6] = 0;
15660 device_param->kernel_params_mp_buf32[7] = 0;
15661
15662 if (attack_mode == ATTACK_MODE_HYBRID1)
15663 {
15664 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15665 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15666 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15667 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15668 }
15669 else if (attack_mode == ATTACK_MODE_HYBRID2)
15670 {
15671 device_param->kernel_params_mp_buf32[5] = 0;
15672 device_param->kernel_params_mp_buf32[6] = 0;
15673 device_param->kernel_params_mp_buf32[7] = 0;
15674 }
15675
15676 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]);
15677 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]);
15678 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]);
15679
15680 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);
15681 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);
15682 }
15683 }
15684 else if (attack_mode == ATTACK_MODE_BF)
15685 {
15686 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15687
15688 if (increment)
15689 {
15690 for (uint i = 0; i < dictcnt; i++)
15691 {
15692 local_free (dictfiles[i]);
15693 }
15694
15695 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15696 {
15697 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15698
15699 if (l1_filename == NULL) break;
15700
15701 dictcnt++;
15702
15703 dictfiles[dictcnt - 1] = l1_filename;
15704 }
15705 }
15706 else
15707 {
15708 dictcnt++;
15709
15710 dictfiles[dictcnt - 1] = mask;
15711 }
15712
15713 if (dictcnt == 0)
15714 {
15715 log_error ("ERROR: Mask is too small");
15716
15717 return (-1);
15718 }
15719 }
15720 }
15721
15722 free (induction_dictionaries);
15723
15724 // induction_dictionaries_cnt = 0; // implied
15725
15726 if (attack_mode != ATTACK_MODE_BF)
15727 {
15728 if (keyspace == 0)
15729 {
15730 induction_dictionaries = scan_directory (induction_directory);
15731
15732 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15733 }
15734 }
15735
15736 if (induction_dictionaries_cnt)
15737 {
15738 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15739 }
15740
15741 /**
15742 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15743 */
15744 if (keyspace == 1)
15745 {
15746 if ((maskcnt > 1) || (dictcnt > 1))
15747 {
15748 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15749
15750 return (-1);
15751 }
15752 }
15753
15754 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15755 {
15756 char *subid = logfile_generate_subid ();
15757
15758 data.subid = subid;
15759
15760 logfile_sub_msg ("START");
15761
15762 data.devices_status = STATUS_INIT;
15763
15764 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15765 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15766 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15767
15768 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15769
15770 data.cpt_pos = 0;
15771
15772 data.cpt_start = time (NULL);
15773
15774 data.cpt_total = 0;
15775
15776 if (data.restore == 0)
15777 {
15778 rd->words_cur = skip;
15779
15780 skip = 0;
15781
15782 data.skip = 0;
15783 }
15784
15785 data.ms_paused = 0;
15786
15787 data.words_cur = rd->words_cur;
15788
15789 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15790 {
15791 hc_device_param_t *device_param = &data.devices_param[device_id];
15792
15793 if (device_param->skipped) continue;
15794
15795 device_param->speed_pos = 0;
15796
15797 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15798 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15799 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15800
15801 device_param->kernel_power = device_param->kernel_power_user;
15802 device_param->kernel_blocks = device_param->kernel_blocks_user;
15803
15804 device_param->outerloop_pos = 0;
15805 device_param->outerloop_left = 0;
15806 device_param->innerloop_pos = 0;
15807 device_param->innerloop_left = 0;
15808
15809 // some more resets:
15810
15811 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15812
15813 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15814
15815 device_param->pw_cnt = 0;
15816 device_param->pws_cnt = 0;
15817
15818 device_param->words_off = 0;
15819 device_param->words_done = 0;
15820 }
15821
15822 data.kernel_blocks_div = 0;
15823
15824 // figure out some workload
15825
15826 if (attack_mode == ATTACK_MODE_STRAIGHT)
15827 {
15828 if (data.wordlist_mode == WL_MODE_FILE)
15829 {
15830 char *dictfile = NULL;
15831
15832 if (induction_dictionaries_cnt)
15833 {
15834 dictfile = induction_dictionaries[0];
15835 }
15836 else
15837 {
15838 dictfile = dictfiles[dictpos];
15839 }
15840
15841 data.dictfile = dictfile;
15842
15843 logfile_sub_string (dictfile);
15844
15845 for (uint i = 0; i < rp_files_cnt; i++)
15846 {
15847 logfile_sub_var_string ("rulefile", rp_files[i]);
15848 }
15849
15850 FILE *fd2 = fopen (dictfile, "rb");
15851
15852 if (fd2 == NULL)
15853 {
15854 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15855
15856 return (-1);
15857 }
15858
15859 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15860
15861 fclose (fd2);
15862
15863 if (data.words_cnt == 0)
15864 {
15865 if (data.devices_status == STATUS_CRACKED) break;
15866 if (data.devices_status == STATUS_ABORTED) break;
15867
15868 dictpos++;
15869
15870 continue;
15871 }
15872 }
15873 }
15874 else if (attack_mode == ATTACK_MODE_COMBI)
15875 {
15876 char *dictfile = data.dictfile;
15877 char *dictfile2 = data.dictfile2;
15878
15879 logfile_sub_string (dictfile);
15880 logfile_sub_string (dictfile2);
15881
15882 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15883 {
15884 FILE *fd2 = fopen (dictfile, "rb");
15885
15886 if (fd2 == NULL)
15887 {
15888 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15889
15890 return (-1);
15891 }
15892
15893 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15894
15895 fclose (fd2);
15896 }
15897 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15898 {
15899 FILE *fd2 = fopen (dictfile2, "rb");
15900
15901 if (fd2 == NULL)
15902 {
15903 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15904
15905 return (-1);
15906 }
15907
15908 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15909
15910 fclose (fd2);
15911 }
15912
15913 if (data.words_cnt == 0)
15914 {
15915 if (data.devices_status == STATUS_CRACKED) break;
15916 if (data.devices_status == STATUS_ABORTED) break;
15917
15918 dictpos++;
15919
15920 continue;
15921 }
15922 }
15923 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15924 {
15925 char *dictfile = NULL;
15926
15927 if (induction_dictionaries_cnt)
15928 {
15929 dictfile = induction_dictionaries[0];
15930 }
15931 else
15932 {
15933 dictfile = dictfiles[dictpos];
15934 }
15935
15936 data.dictfile = dictfile;
15937
15938 char *mask = data.mask;
15939
15940 logfile_sub_string (dictfile);
15941 logfile_sub_string (mask);
15942
15943 FILE *fd2 = fopen (dictfile, "rb");
15944
15945 if (fd2 == NULL)
15946 {
15947 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15948
15949 return (-1);
15950 }
15951
15952 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15953
15954 fclose (fd2);
15955
15956 if (data.words_cnt == 0)
15957 {
15958 if (data.devices_status == STATUS_CRACKED) break;
15959 if (data.devices_status == STATUS_ABORTED) break;
15960
15961 dictpos++;
15962
15963 continue;
15964 }
15965 }
15966 else if (attack_mode == ATTACK_MODE_BF)
15967 {
15968 local_free (css_buf);
15969 local_free (data.root_css_buf);
15970 local_free (data.markov_css_buf);
15971
15972 char *mask = dictfiles[dictpos];
15973
15974 logfile_sub_string (mask);
15975
15976 // base
15977
15978 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15979
15980 if (opts_type & OPTS_TYPE_PT_UNICODE)
15981 {
15982 uint css_cnt_unicode = css_cnt * 2;
15983
15984 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15985
15986 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15987 {
15988 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15989
15990 css_buf_unicode[j + 1].cs_buf[0] = 0;
15991 css_buf_unicode[j + 1].cs_len = 1;
15992 }
15993
15994 free (css_buf);
15995
15996 css_buf = css_buf_unicode;
15997 css_cnt = css_cnt_unicode;
15998 }
15999
16000 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16001
16002 uint mask_min = pw_min;
16003 uint mask_max = pw_max;
16004
16005 if (opts_type & OPTS_TYPE_PT_UNICODE)
16006 {
16007 mask_min *= 2;
16008 mask_max *= 2;
16009 }
16010
16011 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16012 {
16013 if (css_cnt < mask_min)
16014 {
16015 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16016 }
16017
16018 if (css_cnt > mask_max)
16019 {
16020 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16021 }
16022
16023 // skip to next mask
16024
16025 dictpos++;
16026
16027 rd->dictpos = dictpos;
16028
16029 logfile_sub_msg ("STOP");
16030
16031 continue;
16032 }
16033
16034 uint save_css_cnt = css_cnt;
16035
16036 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16037 {
16038 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16039 {
16040 uint salt_len = (uint) data.salts_buf[0].salt_len;
16041 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16042
16043 uint css_cnt_salt = css_cnt + salt_len;
16044
16045 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16046
16047 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16048
16049 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16050 {
16051 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16052 css_buf_salt[j].cs_len = 1;
16053 }
16054
16055 free (css_buf);
16056
16057 css_buf = css_buf_salt;
16058 css_cnt = css_cnt_salt;
16059 }
16060 }
16061
16062 data.mask = mask;
16063 data.css_cnt = css_cnt;
16064 data.css_buf = css_buf;
16065
16066 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16067
16068 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16069
16070 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16071
16072 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16073 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16074
16075 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16076
16077 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16078
16079 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16080 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16081
16082 data.root_css_buf = root_css_buf;
16083 data.markov_css_buf = markov_css_buf;
16084
16085 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16086
16087 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16088
16089 local_free (root_table_buf);
16090 local_free (markov_table_buf);
16091
16092 // copy + args
16093
16094 uint css_cnt_l = css_cnt;
16095 uint css_cnt_r;
16096
16097 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16098 {
16099 if (save_css_cnt < 6)
16100 {
16101 css_cnt_r = 1;
16102 }
16103 else if (save_css_cnt == 6)
16104 {
16105 css_cnt_r = 2;
16106 }
16107 else
16108 {
16109 if (opts_type & OPTS_TYPE_PT_UNICODE)
16110 {
16111 if (save_css_cnt == 8 || save_css_cnt == 10)
16112 {
16113 css_cnt_r = 2;
16114 }
16115 else
16116 {
16117 css_cnt_r = 4;
16118 }
16119 }
16120 else
16121 {
16122 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16123 {
16124 css_cnt_r = 3;
16125 }
16126 else
16127 {
16128 css_cnt_r = 4;
16129 }
16130 }
16131 }
16132 }
16133 else
16134 {
16135 css_cnt_r = 1;
16136
16137 /* unfinished code?
16138 int sum = css_buf[css_cnt_r - 1].cs_len;
16139
16140 for (uint i = 1; i < 4 && i < css_cnt; i++)
16141 {
16142 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16143
16144 css_cnt_r++;
16145
16146 sum *= css_buf[css_cnt_r - 1].cs_len;
16147 }
16148 */
16149 }
16150
16151 css_cnt_l -= css_cnt_r;
16152
16153 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16154
16155 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16156 {
16157 hc_device_param_t *device_param = &data.devices_param[device_id];
16158
16159 if (device_param->skipped) continue;
16160
16161 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16162 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16163 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16164
16165 device_param->kernel_params_mp_l_buf64[3] = 0;
16166 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16167 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16168 device_param->kernel_params_mp_l_buf32[6] = 0;
16169 device_param->kernel_params_mp_l_buf32[7] = 0;
16170 device_param->kernel_params_mp_l_buf32[8] = 0;
16171
16172 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16173 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16174 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16175 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16176
16177 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16178 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16179 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16180
16181 device_param->kernel_params_mp_r_buf64[3] = 0;
16182 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16183 device_param->kernel_params_mp_r_buf32[5] = 0;
16184 device_param->kernel_params_mp_r_buf32[6] = 0;
16185 device_param->kernel_params_mp_r_buf32[7] = 0;
16186
16187 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]);
16188 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]);
16189 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]);
16190
16191 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]);
16192 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]);
16193 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]);
16194
16195 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);
16196 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);
16197 }
16198 }
16199
16200 u64 words_base = data.words_cnt;
16201
16202 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16203 {
16204 if (data.kernel_rules_cnt)
16205 {
16206 words_base /= data.kernel_rules_cnt;
16207 }
16208 }
16209 else if (data.attack_kern == ATTACK_KERN_COMBI)
16210 {
16211 if (data.combs_cnt)
16212 {
16213 words_base /= data.combs_cnt;
16214 }
16215 }
16216 else if (data.attack_kern == ATTACK_KERN_BF)
16217 {
16218 if (data.bfs_cnt)
16219 {
16220 words_base /= data.bfs_cnt;
16221 }
16222 }
16223
16224 data.words_base = words_base;
16225
16226 if (keyspace == 1)
16227 {
16228 log_info ("%llu", (unsigned long long int) words_base);
16229
16230 return (0);
16231 }
16232
16233 if (data.words_cur > data.words_base)
16234 {
16235 log_error ("ERROR: restore value greater keyspace");
16236
16237 return (-1);
16238 }
16239
16240 if (data.words_cur)
16241 {
16242 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16243 {
16244 for (uint i = 0; i < data.salts_cnt; i++)
16245 {
16246 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16247 }
16248 }
16249 else if (data.attack_kern == ATTACK_KERN_COMBI)
16250 {
16251 for (uint i = 0; i < data.salts_cnt; i++)
16252 {
16253 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16254 }
16255 }
16256 else if (data.attack_kern == ATTACK_KERN_BF)
16257 {
16258 for (uint i = 0; i < data.salts_cnt; i++)
16259 {
16260 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16261 }
16262 }
16263 }
16264
16265 /*
16266 * Inform user about possible slow speeds
16267 */
16268
16269 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16270 {
16271 if (data.words_base < kernel_blocks_all)
16272 {
16273 if (quiet == 0)
16274 {
16275 log_info ("");
16276 log_info ("ATTENTION!");
16277 log_info (" The wordlist or mask you are using is too small.");
16278 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16279 log_info (" The cracking speed will drop.");
16280 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16281 log_info ("");
16282 }
16283 }
16284 }
16285
16286 /*
16287 * Update loopback file
16288 */
16289
16290 if (loopback == 1)
16291 {
16292 time_t now;
16293
16294 time (&now);
16295
16296 uint random_num = get_random_num (0, 9999);
16297
16298 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16299
16300 data.loopback_file = loopback_file;
16301 }
16302
16303 /*
16304 * Update dictionary statistic
16305 */
16306
16307 if (keyspace == 0)
16308 {
16309 dictstat_fp = fopen (dictstat, "wb");
16310
16311 if (dictstat_fp)
16312 {
16313 lock_file (dictstat_fp);
16314
16315 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16316
16317 fclose (dictstat_fp);
16318 }
16319 }
16320
16321 data.devices_status = STATUS_RUNNING;
16322
16323 if (initial_restore_done == 0)
16324 {
16325 if (data.restore_disable == 0) cycle_restore ();
16326
16327 initial_restore_done = 1;
16328 }
16329
16330 hc_timer_set (&data.timer_running);
16331
16332 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16333 {
16334 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16335 {
16336 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16337 if (quiet == 0) fflush (stdout);
16338 }
16339 }
16340 else if (wordlist_mode == WL_MODE_STDIN)
16341 {
16342 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16343 if (data.quiet == 0) log_info ("");
16344 }
16345
16346 time_t runtime_start;
16347
16348 time (&runtime_start);
16349
16350 data.runtime_start = runtime_start;
16351
16352 /**
16353 * create cracker threads
16354 */
16355
16356 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16357
16358 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16359 {
16360 hc_device_param_t *device_param = &devices_param[device_id];
16361
16362 if (wordlist_mode == WL_MODE_STDIN)
16363 {
16364 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16365 }
16366 else
16367 {
16368 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16369 }
16370 }
16371
16372 // wait for crack threads to exit
16373
16374 hc_thread_wait (devices_cnt, c_threads);
16375
16376 local_free (c_threads);
16377
16378 data.restore = 0;
16379
16380 // finalize task
16381
16382 logfile_sub_var_uint ("status-after-work", data.devices_status);
16383
16384 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16385
16386 if (data.devices_status == STATUS_CRACKED) break;
16387 if (data.devices_status == STATUS_ABORTED) break;
16388
16389 if (data.devices_status == STATUS_BYPASS)
16390 {
16391 data.devices_status = STATUS_RUNNING;
16392 }
16393
16394 if (induction_dictionaries_cnt)
16395 {
16396 unlink (induction_dictionaries[0]);
16397 }
16398
16399 free (induction_dictionaries);
16400
16401 if (attack_mode != ATTACK_MODE_BF)
16402 {
16403 induction_dictionaries = scan_directory (induction_directory);
16404
16405 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16406 }
16407
16408 if (benchmark == 0)
16409 {
16410 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16411 {
16412 if (quiet == 0) clear_prompt ();
16413
16414 if (quiet == 0) log_info ("");
16415
16416 if (status == 1)
16417 {
16418 status_display ();
16419 }
16420 else
16421 {
16422 if (quiet == 0) status_display ();
16423 }
16424
16425 if (quiet == 0) log_info ("");
16426 }
16427 }
16428
16429 if (attack_mode == ATTACK_MODE_BF)
16430 {
16431 dictpos++;
16432
16433 rd->dictpos = dictpos;
16434 }
16435 else
16436 {
16437 if (induction_dictionaries_cnt)
16438 {
16439 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16440 }
16441 else
16442 {
16443 dictpos++;
16444
16445 rd->dictpos = dictpos;
16446 }
16447 }
16448
16449 time_t runtime_stop;
16450
16451 time (&runtime_stop);
16452
16453 data.runtime_stop = runtime_stop;
16454
16455 logfile_sub_uint (runtime_start);
16456 logfile_sub_uint (runtime_stop);
16457
16458 logfile_sub_msg ("STOP");
16459
16460 global_free (subid);
16461 }
16462
16463 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16464
16465 if (data.devices_status == STATUS_CRACKED) break;
16466 if (data.devices_status == STATUS_ABORTED) break;
16467 if (data.devices_status == STATUS_QUIT) break;
16468
16469 if (data.devices_status == STATUS_BYPASS)
16470 {
16471 data.devices_status = STATUS_RUNNING;
16472 }
16473 }
16474
16475 // 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
16476
16477 if (attack_mode == ATTACK_MODE_STRAIGHT)
16478 {
16479 if (data.wordlist_mode == WL_MODE_FILE)
16480 {
16481 if (data.dictfile == NULL)
16482 {
16483 if (dictfiles != NULL)
16484 {
16485 data.dictfile = dictfiles[0];
16486
16487 hc_timer_set (&data.timer_running);
16488 }
16489 }
16490 }
16491 }
16492 // NOTE: combi is okay because it is already set beforehand
16493 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16494 {
16495 if (data.dictfile == NULL)
16496 {
16497 if (dictfiles != NULL)
16498 {
16499 hc_timer_set (&data.timer_running);
16500
16501 data.dictfile = dictfiles[0];
16502 }
16503 }
16504 }
16505 else if (attack_mode == ATTACK_MODE_BF)
16506 {
16507 if (data.mask == NULL)
16508 {
16509 hc_timer_set (&data.timer_running);
16510
16511 data.mask = masks[0];
16512 }
16513 }
16514
16515 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16516 {
16517 data.devices_status = STATUS_EXHAUSTED;
16518 }
16519
16520 // if cracked / aborted remove last induction dictionary
16521
16522 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16523 {
16524 struct stat induct_stat;
16525
16526 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16527 {
16528 unlink (induction_dictionaries[file_pos]);
16529 }
16530 }
16531
16532 // wait for non-interactive threads
16533
16534 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16535 {
16536 hc_thread_wait (1, &ni_threads[thread_idx]);
16537 }
16538
16539 local_free (ni_threads);
16540
16541 // wait for interactive threads
16542
16543 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16544 {
16545 hc_thread_wait (1, &i_thread);
16546 }
16547
16548 // we dont need restore file anymore
16549 if (data.restore_disable == 0)
16550 {
16551 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16552 {
16553 unlink (eff_restore_file);
16554 unlink (new_restore_file);
16555 }
16556 else
16557 {
16558 cycle_restore ();
16559 }
16560 }
16561
16562 // finally save left hashes
16563
16564 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16565 {
16566 save_hash ();
16567 }
16568
16569 /**
16570 * Clean up
16571 */
16572
16573 if (benchmark == 1)
16574 {
16575 status_benchmark ();
16576
16577 log_info ("");
16578 }
16579 else
16580 {
16581 if (quiet == 0) clear_prompt ();
16582
16583 if (quiet == 0) log_info ("");
16584
16585 if (status == 1)
16586 {
16587 status_display ();
16588 }
16589 else
16590 {
16591 if (quiet == 0) status_display ();
16592 }
16593
16594 if (quiet == 0) log_info ("");
16595 }
16596
16597 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16598 {
16599 hc_device_param_t *device_param = &data.devices_param[device_id];
16600
16601 if (device_param->skipped) continue;
16602
16603 local_free (device_param->result);
16604
16605 local_free (device_param->pw_caches);
16606
16607 local_free (device_param->combs_buf);
16608
16609 local_free (device_param->hooks_buf);
16610
16611 local_free (device_param->device_name);
16612
16613 local_free (device_param->device_name_chksum);
16614
16615 local_free (device_param->device_version);
16616
16617 local_free (device_param->driver_version);
16618
16619 if (device_param->pws_buf) myfree (device_param->pws_buf);
16620 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16621 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16622 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16623 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16624 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16625 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16626 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16627 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16628 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16629 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16630 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16631 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16632 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16633 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16634 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16635 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16636 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16637 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16638 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16639 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16640 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16641 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16642 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16643 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16644 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16645 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16646 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16647 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16648
16649 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16650 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16651 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16652 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16653 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16654 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16655 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16656 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16657 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16658 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16659 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16660
16661 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16662 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16663 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16664
16665 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16666 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16667 }
16668
16669 // reset default fan speed
16670
16671 #ifdef HAVE_HWMON
16672 if (gpu_temp_disable == 0)
16673 {
16674 #ifdef HAVE_ADL
16675 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16676 {
16677 hc_thread_mutex_lock (mux_adl);
16678
16679 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16680 {
16681 hc_device_param_t *device_param = &data.devices_param[device_id];
16682
16683 if (device_param->skipped) continue;
16684
16685 if (data.hm_device[device_id].fan_supported == 1)
16686 {
16687 int fanspeed = temp_retain_fanspeed_value[device_id];
16688
16689 if (fanspeed == -1) continue;
16690
16691 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16692
16693 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16694 }
16695 }
16696
16697 hc_thread_mutex_unlock (mux_adl);
16698 }
16699 #endif // HAVE_ADL
16700 }
16701
16702 #ifdef HAVE_ADL
16703 // reset power tuning
16704
16705 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16706 {
16707 hc_thread_mutex_lock (mux_adl);
16708
16709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16710 {
16711 hc_device_param_t *device_param = &data.devices_param[device_id];
16712
16713 if (device_param->skipped) continue;
16714
16715 if (data.hm_device[device_id].od_version == 6)
16716 {
16717 // check powertune capabilities first, if not available then skip device
16718
16719 int powertune_supported = 0;
16720
16721 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16722 {
16723 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16724
16725 return (-1);
16726 }
16727
16728 if (powertune_supported != 0)
16729 {
16730 // powercontrol settings
16731
16732 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)
16733 {
16734 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16735
16736 return (-1);
16737 }
16738
16739 // clocks
16740
16741 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16742
16743 performance_state->iNumberOfPerformanceLevels = 2;
16744
16745 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16746 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16747 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16748 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16749
16750 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)
16751 {
16752 log_info ("ERROR: Failed to restore ADL performance state");
16753
16754 return (-1);
16755 }
16756
16757 local_free (performance_state);
16758 }
16759 }
16760 }
16761
16762 hc_thread_mutex_unlock (mux_adl);
16763 }
16764 #endif // HAVE_ADL
16765
16766 if (gpu_temp_disable == 0)
16767 {
16768 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16769 if (data.hm_nv)
16770 {
16771 #if defined(LINUX) && defined(HAVE_NVML)
16772
16773 hm_NVML_nvmlShutdown (data.hm_nv);
16774
16775 nvml_close (data.hm_nv);
16776
16777 #elif defined(WIN) && (HAVE_NVAPI)
16778
16779 hm_NvAPI_Unload (data.hm_nv);
16780
16781 nvapi_close (data.hm_nv);
16782
16783 #endif
16784
16785 data.hm_nv = NULL;
16786 }
16787 #endif
16788
16789 #ifdef HAVE_ADL
16790 if (data.hm_amd)
16791 {
16792 hm_ADL_Main_Control_Destroy (data.hm_amd);
16793
16794 adl_close (data.hm_amd);
16795 data.hm_amd = NULL;
16796 }
16797 #endif
16798 }
16799 #endif // HAVE_HWMON
16800
16801 // free memory
16802
16803 local_free (masks);
16804
16805 local_free (dictstat_base);
16806
16807 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16808 {
16809 pot_t *pot_ptr = &pot[pot_pos];
16810
16811 hash_t *hash = &pot_ptr->hash;
16812
16813 local_free (hash->digest);
16814
16815 if (isSalted)
16816 {
16817 local_free (hash->salt);
16818 }
16819 }
16820
16821 local_free (pot);
16822
16823 local_free (all_kernel_rules_cnt);
16824 local_free (all_kernel_rules_buf);
16825
16826 local_free (wl_data->buf);
16827 local_free (wl_data);
16828
16829 local_free (bitmap_s1_a);
16830 local_free (bitmap_s1_b);
16831 local_free (bitmap_s1_c);
16832 local_free (bitmap_s1_d);
16833 local_free (bitmap_s2_a);
16834 local_free (bitmap_s2_b);
16835 local_free (bitmap_s2_c);
16836 local_free (bitmap_s2_d);
16837
16838 #ifdef HAVE_HWMON
16839 local_free (temp_retain_fanspeed_value);
16840 #ifdef HAVE_ADL
16841 local_free (od_clock_mem_status);
16842 local_free (od_power_control_status);
16843 #endif // ADL
16844 #endif
16845
16846 global_free (devices_param);
16847
16848 global_free (kernel_rules_buf);
16849
16850 global_free (root_css_buf);
16851 global_free (markov_css_buf);
16852
16853 global_free (digests_buf);
16854 global_free (digests_shown);
16855 global_free (digests_shown_tmp);
16856
16857 global_free (salts_buf);
16858 global_free (salts_shown);
16859
16860 global_free (esalts_buf);
16861
16862 global_free (words_progress_done);
16863 global_free (words_progress_rejected);
16864 global_free (words_progress_restored);
16865
16866 if (pot_fp) fclose (pot_fp);
16867
16868 if (data.devices_status == STATUS_QUIT) break;
16869 }
16870
16871 // destroy others mutex
16872
16873 hc_thread_mutex_delete (mux_dispatcher);
16874 hc_thread_mutex_delete (mux_counter);
16875 hc_thread_mutex_delete (mux_display);
16876 hc_thread_mutex_delete (mux_adl);
16877
16878 // free memory
16879
16880 local_free (eff_restore_file);
16881 local_free (new_restore_file);
16882
16883 local_free (rd);
16884
16885 // loopback
16886
16887 local_free (loopback_file);
16888
16889 if (loopback == 1) unlink (loopback_file);
16890
16891 // induction directory
16892
16893 if (induction_dir == NULL)
16894 {
16895 if (attack_mode != ATTACK_MODE_BF)
16896 {
16897 if (rmdir (induction_directory) == -1)
16898 {
16899 if (errno == ENOENT)
16900 {
16901 // good, we can ignore
16902 }
16903 else if (errno == ENOTEMPTY)
16904 {
16905 // good, we can ignore
16906 }
16907 else
16908 {
16909 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16910
16911 return (-1);
16912 }
16913 }
16914
16915 local_free (induction_directory);
16916 }
16917 }
16918
16919 // outfile-check directory
16920
16921 if (outfile_check_dir == NULL)
16922 {
16923 if (rmdir (outfile_check_directory) == -1)
16924 {
16925 if (errno == ENOENT)
16926 {
16927 // good, we can ignore
16928 }
16929 else if (errno == ENOTEMPTY)
16930 {
16931 // good, we can ignore
16932 }
16933 else
16934 {
16935 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16936
16937 return (-1);
16938 }
16939 }
16940
16941 local_free (outfile_check_directory);
16942 }
16943
16944 time_t proc_stop;
16945
16946 time (&proc_stop);
16947
16948 logfile_top_uint (proc_start);
16949 logfile_top_uint (proc_stop);
16950
16951 logfile_top_msg ("STOP");
16952
16953 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16954 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16955
16956 if (data.ocl) ocl_close (data.ocl);
16957
16958 if (data.devices_status == STATUS_ABORTED) return 2;
16959 if (data.devices_status == STATUS_QUIT) return 2;
16960 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16961 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16962 if (data.devices_status == STATUS_CRACKED) return 0;
16963
16964 return -1;
16965 }
Hashcat additions to support pwdhash