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