projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Revert "Use per-device timer resolution in total_time calculations"
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 *
5 * License.....: MIT
6 */
7
8 #ifdef OSX
9 #include <stdio.h>
10 #endif
11
12 #include <common.h>
13 #include <shared.h>
14 #include <rp_kernel_on_cpu.h>
15 #include <getopt.h>
16
17 const char *PROGNAME = "oclHashcat";
18 const uint VERSION_BIN = 210;
19 const uint RESTORE_MIN = 210;
20
21 #define INCR_RULES 10000
22 #define INCR_SALTS 100000
23 #define INCR_MASKS 1000
24 #define INCR_POT 1000
25
26 #define USAGE 0
27 #define VERSION 0
28 #define QUIET 0
29 #define MARKOV_THRESHOLD 0
30 #define MARKOV_DISABLE 0
31 #define MARKOV_CLASSIC 0
32 #define BENCHMARK 0
33 #define BENCHMARK_MODE 1
34 #define RESTORE 0
35 #define RESTORE_TIMER 60
36 #define RESTORE_DISABLE 0
37 #define STATUS 0
38 #define STATUS_TIMER 10
39 #define STATUS_AUTOMAT 0
40 #define LOOPBACK 0
41 #define WEAK_HASH_THRESHOLD 100
42 #define SHOW 0
43 #define LEFT 0
44 #define USERNAME 0
45 #define REMOVE 0
46 #define REMOVE_TIMER 60
47 #define SKIP 0
48 #define LIMIT 0
49 #define KEYSPACE 0
50 #define POTFILE_DISABLE 0
51 #define DEBUG_MODE 0
52 #define RP_GEN 0
53 #define RP_GEN_FUNC_MIN 1
54 #define RP_GEN_FUNC_MAX 4
55 #define RP_GEN_SEED 0
56 #define RULE_BUF_L ":"
57 #define RULE_BUF_R ":"
58 #define FORCE 0
59 #define RUNTIME 0
60 #define HEX_CHARSET 0
61 #define HEX_SALT 0
62 #define HEX_WORDLIST 0
63 #define OUTFILE_FORMAT 3
64 #define OUTFILE_AUTOHEX 1
65 #define OUTFILE_CHECK_TIMER 5
66 #define ATTACK_MODE 0
67 #define HASH_MODE 0
68 #define SEGMENT_SIZE 32
69 #define INCREMENT 0
70 #define INCREMENT_MIN 1
71 #define INCREMENT_MAX PW_MAX
72 #define SEPARATOR ':'
73 #define BITMAP_MIN 16
74 #define BITMAP_MAX 24
75 #define GPU_TEMP_DISABLE 0
76 #define GPU_TEMP_ABORT 90
77 #define GPU_TEMP_RETAIN 80
78 #define WORKLOAD_PROFILE 2
79 #define KERNEL_ACCEL 0
80 #define KERNEL_LOOPS 0
81 #define KERNEL_RULES 1024
82 #define KERNEL_COMBS 1024
83 #define KERNEL_BFS 1024
84 #define KERNEL_THREADS 64
85 #define POWERTUNE_ENABLE 0
86 #define LOGFILE_DISABLE 0
87 #define SCRYPT_TMTO 0
88 #define OPENCL_VECTOR_WIDTH 0
89
90 #define WL_MODE_STDIN 1
91 #define WL_MODE_FILE 2
92 #define WL_MODE_MASK 3
93
94 #define HL_MODE_FILE 4
95 #define HL_MODE_ARG 5
96
97 #define HLFMT_HASHCAT 0
98 #define HLFMT_PWDUMP 1
99 #define HLFMT_PASSWD 2
100 #define HLFMT_SHADOW 3
101 #define HLFMT_DCC 4
102 #define HLFMT_DCC2 5
103 #define HLFMT_NETNTLM1 7
104 #define HLFMT_NETNTLM2 8
105 #define HLFMT_NSLDAP 9
106 #define HLFMT_NSLDAPS 10
107 #define HLFMTS_CNT 11
108
109 #define ATTACK_MODE_STRAIGHT 0
110 #define ATTACK_MODE_COMBI 1
111 #define ATTACK_MODE_TOGGLE 2
112 #define ATTACK_MODE_BF 3
113 #define ATTACK_MODE_PERM 4
114 #define ATTACK_MODE_TABLE 5
115 #define ATTACK_MODE_HYBRID1 6
116 #define ATTACK_MODE_HYBRID2 7
117 #define ATTACK_MODE_NONE 100
118
119 #define ATTACK_KERN_STRAIGHT 0
120 #define ATTACK_KERN_COMBI 1
121 #define ATTACK_KERN_BF 3
122 #define ATTACK_KERN_NONE 100
123
124 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
125 #define ATTACK_EXEC_INSIDE_KERNEL 11
126
127 #define COMBINATOR_MODE_BASE_LEFT 10001
128 #define COMBINATOR_MODE_BASE_RIGHT 10002
129
130 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
131 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
132
133 #define MAX_CUT_TRIES 4
134
135 #define MAX_DICTSTAT 10000
136
137 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
138
139 #define global_free(attr) \
140 { \
141 myfree ((void *) data.attr); \
142 \
143 data.attr = NULL; \
144 }
145
146 #define local_free(attr) \
147 { \
148 myfree ((void *) attr); \
149 \
150 attr = NULL; \
151 }
152
153 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
154 {
155 900,
156 0,
157 5100,
158 100,
159 1400,
160 10800,
161 1700,
162 5000,
163 10100,
164 6000,
165 6100,
166 6900,
167 11700,
168 11800,
169 400,
170 8900,
171 11900,
172 12000,
173 10900,
174 12100,
175 23,
176 2500,
177 5300,
178 5400,
179 5500,
180 5600,
181 7300,
182 7500,
183 8300,
184 11100,
185 11200,
186 11400,
187 121,
188 2611,
189 2711,
190 2811,
191 8400,
192 11,
193 2612,
194 7900,
195 21,
196 11000,
197 124,
198 10000,
199 3711,
200 7600,
201 12,
202 131,
203 132,
204 1731,
205 200,
206 300,
207 3100,
208 112,
209 12300,
210 8000,
211 141,
212 1441,
213 1600,
214 12600,
215 1421,
216 101,
217 111,
218 1711,
219 3000, // broken in osx
220 1000,
221 1100,
222 2100,
223 12800,
224 1500, // broken in osx
225 12400,
226 500,
227 3200,
228 7400,
229 1800,
230 122,
231 1722,
232 7100,
233 6300,
234 6700,
235 6400,
236 6500,
237 2400,
238 2410,
239 5700,
240 9200,
241 9300,
242 22,
243 501,
244 5800,
245 8100,
246 8500,
247 7200,
248 9900,
249 7700,
250 7800,
251 10300,
252 8600,
253 8700,
254 9100,
255 133,
256 11600,
257 12500,
258 13000,
259 6211,
260 6221,
261 6231,
262 6241,
263 8800,
264 12900,
265 12200,
266 9700,
267 9710,
268 9800,
269 9810,
270 9400,
271 9500,
272 9600,
273 10400,
274 10410,
275 10500,
276 10600,
277 10700, // broken in osx
278 9000,
279 5200,
280 6800,
281 6600,
282 8200,
283 11300,
284 12700
285 };
286
287 /**
288 * types
289 */
290
291 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
292
293 /**
294 * globals
295 */
296
297 static unsigned int full01 = 0x01010101;
298 static unsigned int full80 = 0x80808080;
299
300 int SUPPRESS_OUTPUT = 0;
301
302 hc_thread_mutex_t mux_adl;
303 hc_thread_mutex_t mux_counter;
304 hc_thread_mutex_t mux_dispatcher;
305 hc_thread_mutex_t mux_display;
306
307 hc_global_data_t data;
308
309 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
310
311 const char *USAGE_MINI[] =
312 {
313 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
314 "",
315 "Try --help for more help.",
316 NULL
317 };
318
319 const char *USAGE_BIG[] =
320 {
321 "%s, advanced password recovery",
322 "",
323 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
324 "",
325 "=======",
326 "Options",
327 "=======",
328 "",
329 "* General:",
330 "",
331 " -m, --hash-type=NUM Hash-type, see references below",
332 " -a, --attack-mode=NUM Attack-mode, see references below",
333 " -V, --version Print version",
334 " -h, --help Print help",
335 " --quiet Suppress output",
336 "",
337 "* Benchmark:",
338 "",
339 " -b, --benchmark Run benchmark",
340 " --benchmark-mode=NUM Benchmark-mode, see references below",
341 "",
342 "* Misc:",
343 "",
344 " --hex-charset Assume charset is given in hex",
345 " --hex-salt Assume salt is given in hex",
346 " --hex-wordlist Assume words in wordlist is given in hex",
347 " --force Ignore warnings",
348 " --status Enable automatic update of the status-screen",
349 " --status-timer=NUM Seconds between status-screen update",
350 " --status-automat Display the status view in a machine readable format",
351 " --loopback Add new plains to induct directory",
352 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
353 "",
354 "* Markov:",
355 "",
356 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
357 " --markov-disable Disables markov-chains, emulates classic brute-force",
358 " --markov-classic Enables classic markov-chains, no per-position enhancement",
359 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
360 "",
361 "* Session:",
362 "",
363 " --runtime=NUM Abort session after NUM seconds of runtime",
364 " --session=STR Define specific session name",
365 " --restore Restore session from --session",
366 " --restore-disable Do not write restore file",
367 "",
368 "* Files:",
369 "",
370 " -o, --outfile=FILE Define outfile for recovered hash",
371 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
372 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
373 " --outfile-check-timer=NUM Seconds between outfile checks",
374 " -p, --separator=CHAR Separator char for hashlists and outfile",
375 " --show Show cracked passwords only",
376 " --left Show un-cracked passwords only",
377 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
378 " --remove Enable remove of hash once it is cracked",
379 " --remove-timer=NUM Update input hash file each NUM seconds",
380 " --potfile-disable Do not write potfile",
381 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
382 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
383 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
384 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
385 " --logfile-disable Disable the logfile",
386 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
387 "",
388 "* Resources:",
389 "",
390 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
391 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
392 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
395 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
396 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
397 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
398 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
399 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
400 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
401 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
402 #ifdef HAVE_HWMON
403 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
404 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
405 #ifdef HAVE_ADL
406 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
407 #endif
408 #endif
409 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
410 "",
411 "* Distributed:",
412 "",
413 " -s, --skip=NUM Skip number of words",
414 " -l, --limit=NUM Limit number of words",
415 " --keyspace Show keyspace base:mod values and quit",
416 "",
417 "* Rules:",
418 "",
419 " -j, --rule-left=RULE Single rule applied to each word from left dict",
420 " -k, --rule-right=RULE Single rule applied to each word from right dict",
421 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
422 " -g, --generate-rules=NUM Generate NUM random rules",
423 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
424 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
425 " --generate-rules-seed=NUM Force RNG seed to NUM",
426 "",
427 "* Custom charsets:",
428 "",
429 " -1, --custom-charset1=CS User-defined charsets",
430 " -2, --custom-charset2=CS Example:",
431 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
432 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
433 "",
434 "* Increment:",
435 "",
436 " -i, --increment Enable increment mode",
437 " --increment-min=NUM Start incrementing at NUM",
438 " --increment-max=NUM Stop incrementing at NUM",
439 "",
440 "==========",
441 "References",
442 "==========",
443 "",
444 "* Workload Profile:",
445 "",
446 " 1 = Reduced performance profile (low latency desktop)",
447 " 2 = Default performance profile",
448 " 3 = Tuned performance profile (high latency desktop)",
449 "",
450 "* Benchmark Settings:",
451 "",
452 " 0 = Manual Tuning",
453 " 1 = Performance Tuning, default",
454 "",
455 "* OpenCL device-types:",
456 "",
457 " 1 = CPU devices",
458 " 2 = GPU devices",
459 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
460 "",
461 "* Outfile Formats:",
462 "",
463 " 1 = hash[:salt]",
464 " 2 = plain",
465 " 3 = hash[:salt]:plain",
466 " 4 = hex_plain",
467 " 5 = hash[:salt]:hex_plain",
468 " 6 = plain:hex_plain",
469 " 7 = hash[:salt]:plain:hex_plain",
470 " 8 = crackpos",
471 " 9 = hash[:salt]:crackpos",
472 " 10 = plain:crackpos",
473 " 11 = hash[:salt]:plain:crackpos",
474 " 12 = hex_plain:crackpos",
475 " 13 = hash[:salt]:hex_plain:crackpos",
476 " 14 = plain:hex_plain:crackpos",
477 " 15 = hash[:salt]:plain:hex_plain:crackpos",
478 "",
479 "* Debug mode output formats (for hybrid mode only, by using rules):",
480 "",
481 " 1 = save finding rule",
482 " 2 = save original word",
483 " 3 = save original word and finding rule",
484 " 4 = save original word, finding rule and modified plain",
485 "",
486 "* Built-in charsets:",
487 "",
488 " ?l = abcdefghijklmnopqrstuvwxyz",
489 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
490 " ?d = 0123456789",
491 " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
492 " ?a = ?l?u?d?s",
493 " ?b = 0x00 - 0xff",
494 "",
495 "* Attack modes:",
496 "",
497 " 0 = Straight",
498 " 1 = Combination",
499 " 3 = Brute-force",
500 " 6 = Hybrid dict + mask",
501 " 7 = Hybrid mask + dict",
502 "",
503 "* Hash types:",
504 "",
505 "[[ Roll-your-own: Raw Hashes ]]",
506 "",
507 " 900 = MD4",
508 " 0 = MD5",
509 " 5100 = Half MD5",
510 " 100 = SHA1",
511 " 10800 = SHA-384",
512 " 1400 = SHA-256",
513 " 1700 = SHA-512",
514 " 5000 = SHA-3(Keccak)",
515 " 10100 = SipHash",
516 " 6000 = RipeMD160",
517 " 6100 = Whirlpool",
518 " 6900 = GOST R 34.11-94",
519 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
520 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
521 "",
522 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
523 "",
524 " 10 = md5($pass.$salt)",
525 " 20 = md5($salt.$pass)",
526 " 30 = md5(unicode($pass).$salt)",
527 " 40 = md5($salt.unicode($pass))",
528 " 3800 = md5($salt.$pass.$salt)",
529 " 3710 = md5($salt.md5($pass))",
530 " 2600 = md5(md5($pass)",
531 " 4300 = md5(strtoupper(md5($pass)))",
532 " 4400 = md5(sha1($pass))",
533 " 110 = sha1($pass.$salt)",
534 " 120 = sha1($salt.$pass)",
535 " 130 = sha1(unicode($pass).$salt)",
536 " 140 = sha1($salt.unicode($pass))",
537 " 4500 = sha1(sha1($pass)",
538 " 4700 = sha1(md5($pass))",
539 " 4900 = sha1($salt.$pass.$salt)",
540 " 1410 = sha256($pass.$salt)",
541 " 1420 = sha256($salt.$pass)",
542 " 1430 = sha256(unicode($pass).$salt)",
543 " 1440 = sha256($salt.unicode($pass))",
544 " 1710 = sha512($pass.$salt)",
545 " 1720 = sha512($salt.$pass)",
546 " 1730 = sha512(unicode($pass).$salt)",
547 " 1740 = sha512($salt.unicode($pass))",
548 "",
549 "[[ Roll-your-own: Authenticated Hashes ]]",
550 "",
551 " 50 = HMAC-MD5 (key = $pass)",
552 " 60 = HMAC-MD5 (key = $salt)",
553 " 150 = HMAC-SHA1 (key = $pass)",
554 " 160 = HMAC-SHA1 (key = $salt)",
555 " 1450 = HMAC-SHA256 (key = $pass)",
556 " 1460 = HMAC-SHA256 (key = $salt)",
557 " 1750 = HMAC-SHA512 (key = $pass)",
558 " 1760 = HMAC-SHA512 (key = $salt)",
559 "",
560 "[[ Generic KDF ]]",
561 "",
562 " 400 = phpass",
563 " 8900 = scrypt",
564 " 11900 = PBKDF2-HMAC-MD5",
565 " 12000 = PBKDF2-HMAC-SHA1",
566 " 10900 = PBKDF2-HMAC-SHA256",
567 " 12100 = PBKDF2-HMAC-SHA512",
568 "",
569 "[[ Network protocols, Challenge-Response ]]",
570 "",
571 " 23 = Skype",
572 " 2500 = WPA/WPA2",
573 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
574 " 5300 = IKE-PSK MD5",
575 " 5400 = IKE-PSK SHA1",
576 " 5500 = NetNTLMv1",
577 " 5500 = NetNTLMv1 + ESS",
578 " 5600 = NetNTLMv2",
579 " 7300 = IPMI2 RAKP HMAC-SHA1",
580 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
581 " 8300 = DNSSEC (NSEC3)",
582 " 10200 = Cram MD5",
583 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
584 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
585 " 11400 = SIP digest authentication (MD5)",
586 "",
587 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
588 "",
589 " 121 = SMF (Simple Machines Forum)",
590 " 400 = phpBB3",
591 " 2611 = vBulletin < v3.8.5",
592 " 2711 = vBulletin > v3.8.5",
593 " 2811 = MyBB",
594 " 2811 = IPB (Invison Power Board)",
595 " 8400 = WBB3 (Woltlab Burning Board)",
596 " 11 = Joomla < 2.5.18",
597 " 400 = Joomla > 2.5.18",
598 " 400 = Wordpress",
599 " 2612 = PHPS",
600 " 7900 = Drupal7",
601 " 21 = osCommerce",
602 " 21 = xt:Commerce",
603 " 11000 = PrestaShop",
604 " 124 = Django (SHA-1)",
605 " 10000 = Django (PBKDF2-SHA256)",
606 " 3711 = Mediawiki B type",
607 " 7600 = Redmine",
608 "",
609 "[[ Database Server ]]",
610 "",
611 " 12 = PostgreSQL",
612 " 131 = MSSQL(2000)",
613 " 132 = MSSQL(2005)",
614 " 1731 = MSSQL(2012)",
615 " 1731 = MSSQL(2014)",
616 " 200 = MySQL323",
617 " 300 = MySQL4.1/MySQL5",
618 " 3100 = Oracle H: Type (Oracle 7+)",
619 " 112 = Oracle S: Type (Oracle 11+)",
620 " 12300 = Oracle T: Type (Oracle 12+)",
621 " 8000 = Sybase ASE",
622 "",
623 "[[ HTTP, SMTP, LDAP Server ]]",
624 "",
625 " 141 = EPiServer 6.x < v4",
626 " 1441 = EPiServer 6.x > v4",
627 " 1600 = Apache $apr1$",
628 " 12600 = ColdFusion 10+",
629 " 1421 = hMailServer",
630 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
631 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
632 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
633 "",
634 "[[ Checksums ]]",
635 "",
636 " 11500 = CRC32",
637 "",
638 "[[ Operating-Systems ]]",
639 "",
640 " 3000 = LM",
641 " 1000 = NTLM",
642 " 1100 = Domain Cached Credentials (DCC), MS Cache",
643 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
644 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
645 " 1500 = descrypt, DES(Unix), Traditional DES",
646 " 12400 = BSDiCrypt, Extended DES",
647 " 500 = md5crypt $1$, MD5(Unix)",
648 " 3200 = bcrypt $2*$, Blowfish(Unix)",
649 " 7400 = sha256crypt $5$, SHA256(Unix)",
650 " 1800 = sha512crypt $6$, SHA512(Unix)",
651 " 122 = OSX v10.4",
652 " 122 = OSX v10.5",
653 " 122 = OSX v10.6",
654 " 1722 = OSX v10.7",
655 " 7100 = OSX v10.8",
656 " 7100 = OSX v10.9",
657 " 7100 = OSX v10.10",
658 " 6300 = AIX {smd5}",
659 " 6700 = AIX {ssha1}",
660 " 6400 = AIX {ssha256}",
661 " 6500 = AIX {ssha512}",
662 " 2400 = Cisco-PIX",
663 " 2410 = Cisco-ASA",
664 " 500 = Cisco-IOS $1$",
665 " 5700 = Cisco-IOS $4$",
666 " 9200 = Cisco-IOS $8$",
667 " 9300 = Cisco-IOS $9$",
668 " 22 = Juniper Netscreen/SSG (ScreenOS)",
669 " 501 = Juniper IVE",
670 " 5800 = Android PIN",
671 " 8100 = Citrix Netscaler",
672 " 8500 = RACF",
673 " 7200 = GRUB 2",
674 " 9900 = Radmin2",
675 "",
676 "[[ Enterprise Application Software (EAS) ]]",
677 "",
678 " 7700 = SAP CODVN B (BCODE)",
679 " 7800 = SAP CODVN F/G (PASSCODE)",
680 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
681 " 8600 = Lotus Notes/Domino 5",
682 " 8700 = Lotus Notes/Domino 6",
683 " 9100 = Lotus Notes/Domino 8",
684 " 133 = PeopleSoft",
685 "",
686 "[[ Archives ]]",
687 "",
688 " 11600 = 7-Zip",
689 " 12500 = RAR3-hp",
690 " 13000 = RAR5",
691 "",
692 "[[ Full-Disk encryptions (FDE) ]]",
693 "",
694 " 62XY = TrueCrypt 5.0+",
695 " X = 1 = PBKDF2-HMAC-RipeMD160",
696 " X = 2 = PBKDF2-HMAC-SHA512",
697 " X = 3 = PBKDF2-HMAC-Whirlpool",
698 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
699 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
700 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
701 " Y = 3 = XTS 1536 bit (Ciphers: All)",
702 " 8800 = Android FDE < v4.3",
703 " 12900 = Android FDE (Samsung DEK)",
704 " 12200 = eCryptfs",
705 "",
706 "[[ Documents ]]",
707 "",
708 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
709 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
710 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
711 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
712 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
713 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
714 " 9400 = MS Office 2007",
715 " 9500 = MS Office 2010",
716 " 9600 = MS Office 2013",
717 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
718 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
719 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
720 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
721 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
722 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
723 "",
724 "[[ Password Managers ]]",
725 "",
726 " 9000 = Password Safe v2",
727 " 5200 = Password Safe v3",
728 " 6800 = Lastpass",
729 " 6600 = 1Password, agilekeychain",
730 " 8200 = 1Password, cloudkeychain",
731 " 11300 = Bitcoin/Litecoin wallet.dat",
732 " 12700 = Blockchain, My Wallet",
733 "",
734 NULL
735 };
736
737 /**
738 * oclHashcat specific functions
739 */
740
741 void status_display_automat ()
742 {
743 FILE *out = stdout;
744
745 fprintf (out, "STATUS\t%u\t", data.devices_status);
746
747 /**
748 * speed new
749 */
750
751 fprintf (out, "SPEED\t");
752
753 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
754 {
755 hc_device_param_t *device_param = &data.devices_param[device_id];
756
757 if (device_param->skipped) continue;
758
759 u64 speed_cnt = 0;
760 float speed_ms = 0;
761
762 for (int i = 0; i < SPEED_CACHE; i++)
763 {
764 float rec_ms;
765
766 hc_timer_get (device_param->speed_rec[i], rec_ms);
767
768 if (rec_ms > SPEED_MAXAGE) continue;
769
770 speed_cnt += device_param->speed_cnt[i];
771 speed_ms += device_param->speed_ms[i];
772 }
773
774 speed_cnt /= SPEED_CACHE;
775 speed_ms /= SPEED_CACHE;
776
777 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
778 }
779
780 /**
781 * exec time
782 */
783
784 fprintf (out, "EXEC_RUNTIME\t");
785
786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
787 {
788 hc_device_param_t *device_param = &data.devices_param[device_id];
789
790 if (device_param->skipped) continue;
791
792 if (device_param->event == NULL) continue;
793
794 cl_ulong time_start;
795 cl_ulong time_end;
796
797 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
798 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
799
800 const double total_time = (time_end - time_start) / 1000000.0;
801
802 fprintf (out, "%f\t", total_time);
803 }
804
805 /**
806 * words_cur
807 */
808
809 u64 words_cur = get_lowest_words_done ();
810
811 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
812
813 /**
814 * counter
815 */
816
817 uint salts_left = data.salts_cnt - data.salts_done;
818
819 if (salts_left == 0) salts_left = 1;
820
821 u64 progress_total = data.words_cnt * salts_left;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 if (salts_left > 1)
830 {
831 // otherwise the final cracked status shows 0/XXX progress
832
833 if (data.salts_shown[salt_pos] == 1) continue;
834 }
835
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * salts_left;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * salts_left;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.status_automat == 1)
925 {
926 status_display_automat ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 uint pke[25] = { 0 };
1050
1051 char *pke_ptr = (char *) pke;
1052
1053 for (uint i = 0; i < 25; i++)
1054 {
1055 pke[i] = byte_swap_32 (wpa->pke[i]);
1056 }
1057
1058 char mac1[6] = { 0 };
1059 char mac2[6] = { 0 };
1060
1061 memcpy (mac1, pke_ptr + 23, 6);
1062 memcpy (mac2, pke_ptr + 29, 6);
1063
1064 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1065 (char *) data.salts_buf[0].salt_buf,
1066 mac1[0] & 0xff,
1067 mac1[1] & 0xff,
1068 mac1[2] & 0xff,
1069 mac1[3] & 0xff,
1070 mac1[4] & 0xff,
1071 mac1[5] & 0xff,
1072 mac2[0] & 0xff,
1073 mac2[1] & 0xff,
1074 mac2[2] & 0xff,
1075 mac2[3] & 0xff,
1076 mac2[4] & 0xff,
1077 mac2[5] & 0xff);
1078 }
1079 else if (data.hash_mode == 5200)
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if (data.hash_mode == 9000)
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else
1092 {
1093 char out_buf[4096] = { 0 };
1094
1095 ascii_digest (out_buf, 0, 0);
1096
1097 // limit length
1098 if (strlen (out_buf) > 40)
1099 {
1100 out_buf[41] = '.';
1101 out_buf[42] = '.';
1102 out_buf[43] = '.';
1103 out_buf[44] = 0;
1104 }
1105
1106 log_info ("Hash.Target....: %s", out_buf);
1107 }
1108 }
1109 else
1110 {
1111 if (data.hash_mode == 3000)
1112 {
1113 char out_buf1[4096] = { 0 };
1114 char out_buf2[4096] = { 0 };
1115
1116 ascii_digest (out_buf1, 0, 0);
1117 ascii_digest (out_buf2, 0, 1);
1118
1119 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120 }
1121 else
1122 {
1123 log_info ("Hash.Target....: File (%s)", data.hashfile);
1124 }
1125 }
1126
1127 log_info ("Hash.Type......: %s", hash_type);
1128
1129 /**
1130 * speed new
1131 */
1132
1133 u64 speed_cnt[DEVICES_MAX] = { 0 };
1134 float speed_ms[DEVICES_MAX] = { 0 };
1135
1136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137 {
1138 hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140 if (device_param->skipped) continue;
1141
1142 // we need to clear values (set to 0) because in case the device does
1143 // not get new candidates it idles around but speed display would
1144 // show it as working.
1145 // if we instantly set it to 0 after reading it happens that the
1146 // speed can be shown as zero if the users refreshes too fast.
1147 // therefore, we add a timestamp when a stat was recorded and if its
1148 // too old we will not use it
1149
1150 speed_cnt[device_id] = 0;
1151 speed_ms[device_id] = 0;
1152
1153 for (int i = 0; i < SPEED_CACHE; i++)
1154 {
1155 float rec_ms;
1156
1157 hc_timer_get (device_param->speed_rec[i], rec_ms);
1158
1159 if (rec_ms > SPEED_MAXAGE) continue;
1160
1161 speed_cnt[device_id] += device_param->speed_cnt[i];
1162 speed_ms[device_id] += device_param->speed_ms[i];
1163 }
1164
1165 speed_cnt[device_id] /= SPEED_CACHE;
1166 speed_ms[device_id] /= SPEED_CACHE;
1167 }
1168
1169 float hashes_all_ms = 0;
1170
1171 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1172
1173 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1174 {
1175 hc_device_param_t *device_param = &data.devices_param[device_id];
1176
1177 if (device_param->skipped) continue;
1178
1179 hashes_dev_ms[device_id] = 0;
1180
1181 if (speed_ms[device_id])
1182 {
1183 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1184
1185 hashes_all_ms += hashes_dev_ms[device_id];
1186 }
1187 }
1188
1189 /**
1190 * exec time
1191 */
1192
1193 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1194
1195 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1196 {
1197 hc_device_param_t *device_param = &data.devices_param[device_id];
1198
1199 if (device_param->skipped) continue;
1200
1201 if (device_param->event == NULL) continue;
1202
1203 cl_ulong time_start;
1204 cl_ulong time_end;
1205
1206 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1207 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1208
1209 const double total_time = (time_end - time_start) / 1000000.0;
1210
1211 exec_runtime_ms[device_id] = total_time;
1212 }
1213
1214 /**
1215 * timers
1216 */
1217
1218 float ms_running = 0;
1219
1220 hc_timer_get (data.timer_running, ms_running);
1221
1222 float ms_paused = data.ms_paused;
1223
1224 if (data.devices_status == STATUS_PAUSED)
1225 {
1226 float ms_paused_tmp = 0;
1227
1228 hc_timer_get (data.timer_paused, ms_paused_tmp);
1229
1230 ms_paused += ms_paused_tmp;
1231 }
1232
1233 #ifdef WIN
1234
1235 __time64_t sec_run = ms_running / 1000;
1236
1237 #else
1238
1239 time_t sec_run = ms_running / 1000;
1240
1241 #endif
1242
1243 if (sec_run)
1244 {
1245 char display_run[32] = { 0 };
1246
1247 struct tm tm_run;
1248
1249 struct tm *tmp = NULL;
1250
1251 #ifdef WIN
1252
1253 tmp = _gmtime64 (&sec_run);
1254
1255 #else
1256
1257 tmp = gmtime (&sec_run);
1258
1259 #endif
1260
1261 if (tmp != NULL)
1262 {
1263 memset (&tm_run, 0, sizeof (tm_run));
1264
1265 memcpy (&tm_run, tmp, sizeof (tm_run));
1266
1267 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1268
1269 char *start = ctime (&data.proc_start);
1270
1271 size_t start_len = strlen (start);
1272
1273 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1274 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1275
1276 log_info ("Time.Started...: %s (%s)", start, display_run);
1277 }
1278 }
1279 else
1280 {
1281 log_info ("Time.Started...: 0 secs");
1282 }
1283
1284 /**
1285 * counters
1286 */
1287
1288 uint salts_left = data.salts_cnt - data.salts_done;
1289
1290 if (salts_left == 0) salts_left = 1;
1291
1292 u64 progress_total = data.words_cnt * salts_left;
1293
1294 u64 all_done = 0;
1295 u64 all_rejected = 0;
1296 u64 all_restored = 0;
1297
1298 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1299 {
1300 if (salts_left > 1)
1301 {
1302 // otherwise the final cracked status shows 0/XXX progress
1303
1304 if (data.salts_shown[salt_pos] == 1) continue;
1305 }
1306
1307 all_done += data.words_progress_done[salt_pos];
1308 all_rejected += data.words_progress_rejected[salt_pos];
1309 all_restored += data.words_progress_restored[salt_pos];
1310 }
1311
1312 u64 progress_cur = all_restored + all_done + all_rejected;
1313 u64 progress_end = progress_total;
1314
1315 u64 progress_skip = 0;
1316
1317 if (data.skip)
1318 {
1319 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1320
1321 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1322 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1323 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1324 }
1325
1326 if (data.limit)
1327 {
1328 progress_end = MIN (data.limit, data.words_base) * salts_left;
1329
1330 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1331 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1332 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1333 }
1334
1335 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1336 u64 progress_end_relative_skip = progress_end - progress_skip;
1337
1338 float speed_ms_real = ms_running - ms_paused;
1339 u64 speed_plains_real = all_done;
1340
1341 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1342 {
1343 if (data.devices_status != STATUS_CRACKED)
1344 {
1345 u64 words_per_ms = 0;
1346
1347 if (speed_plains_real && speed_ms_real)
1348 {
1349 words_per_ms = speed_plains_real / speed_ms_real;
1350 }
1351
1352 #ifdef WIN
1353 __time64_t sec_etc = 0;
1354 #else
1355 time_t sec_etc = 0;
1356 #endif
1357
1358 if (words_per_ms)
1359 {
1360 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1361
1362 u64 ms_left = progress_left_relative_skip / words_per_ms;
1363
1364 sec_etc = ms_left / 1000;
1365 }
1366
1367 if (sec_etc == 0)
1368 {
1369 log_info ("Time.Estimated.: 0 secs");
1370 }
1371 else if ((u64) sec_etc > ETC_MAX)
1372 {
1373 log_info ("Time.Estimated.: > 10 Years");
1374 }
1375 else
1376 {
1377 char display_etc[32] = { 0 };
1378
1379 struct tm tm_etc;
1380
1381 struct tm *tmp = NULL;
1382
1383 #ifdef WIN
1384
1385 tmp = _gmtime64 (&sec_etc);
1386
1387 #else
1388
1389 tmp = gmtime (&sec_etc);
1390
1391 #endif
1392
1393 if (tmp != NULL)
1394 {
1395 memset (&tm_etc, 0, sizeof (tm_etc));
1396
1397 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1398
1399 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1400
1401 time_t now;
1402
1403 time (&now);
1404
1405 now += sec_etc;
1406
1407 char *etc = ctime (&now);
1408
1409 size_t etc_len = strlen (etc);
1410
1411 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1412 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1413
1414 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1480 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1481 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1482
1483 if ((data.cpt_start + 86400) < now)
1484 {
1485 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_cur_min,
1487 cpt_cur_hour,
1488 cpt_cur_day,
1489 cpt_avg_min,
1490 cpt_avg_hour,
1491 cpt_avg_day);
1492 }
1493 else if ((data.cpt_start + 3600) < now)
1494 {
1495 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1496 cpt_cur_min,
1497 cpt_cur_hour,
1498 cpt_avg_min,
1499 cpt_avg_hour,
1500 cpt_avg_day);
1501 }
1502 else if ((data.cpt_start + 60) < now)
1503 {
1504 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1505 cpt_cur_min,
1506 cpt_avg_min,
1507 cpt_avg_hour,
1508 cpt_avg_day);
1509 }
1510 else
1511 {
1512 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1513 cpt_avg_min,
1514 cpt_avg_hour,
1515 cpt_avg_day);
1516 }
1517 }
1518
1519 // Restore point
1520
1521 u64 restore_point = get_lowest_words_done ();
1522
1523 u64 restore_total = data.words_base;
1524
1525 float percent_restore = 0;
1526
1527 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1528
1529 if (progress_end_relative_skip)
1530 {
1531 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1532 {
1533 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1534 float percent_rejected = 0.0;
1535
1536 if (progress_cur)
1537 {
1538 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1539 }
1540
1541 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1542 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1543
1544 if (data.restore_disable == 0)
1545 {
1546 if (percent_finished != 1)
1547 {
1548 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1549 }
1550 }
1551 }
1552 }
1553 else
1554 {
1555 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1556 {
1557 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1558 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1559
1560 if (data.restore_disable == 0)
1561 {
1562 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1563 }
1564 }
1565 else
1566 {
1567 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1568 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1569
1570 // --restore not allowed if stdin is used -- really? why?
1571
1572 //if (data.restore_disable == 0)
1573 //{
1574 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1575 //}
1576 }
1577 }
1578
1579 #ifdef HAVE_HWMON
1580 if (data.gpu_temp_disable == 0)
1581 {
1582 hc_thread_mutex_lock (mux_adl);
1583
1584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1585 {
1586 hc_device_param_t *device_param = &data.devices_param[device_id];
1587
1588 if (device_param->skipped) continue;
1589
1590 #define HM_STR_BUF_SIZE 255
1591
1592 if (data.hm_device[device_id].fan_supported == 1)
1593 {
1594 char utilization[HM_STR_BUF_SIZE] = { 0 };
1595 char temperature[HM_STR_BUF_SIZE] = { 0 };
1596 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1597
1598 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1599 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1600
1601 if (device_param->vendor_id == VENDOR_ID_AMD)
1602 {
1603 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1604 }
1605 else if (device_param->vendor_id == VENDOR_ID_NV)
1606 {
1607 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1608 }
1609
1610 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1611 }
1612 else
1613 {
1614 char utilization[HM_STR_BUF_SIZE] = { 0 };
1615 char temperature[HM_STR_BUF_SIZE] = { 0 };
1616
1617 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1618 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1619
1620 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1621 }
1622 }
1623
1624 hc_thread_mutex_unlock (mux_adl);
1625 }
1626 #endif // HAVE_HWMON
1627 }
1628
1629 static void status_benchmark ()
1630 {
1631 if (data.devices_status == STATUS_INIT) return;
1632 if (data.devices_status == STATUS_STARTING) return;
1633
1634 if (data.words_cnt == 0) return;
1635
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 float speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = 0;
1646 speed_ms[device_id] = 0;
1647
1648 for (int i = 0; i < SPEED_CACHE; i++)
1649 {
1650 speed_cnt[device_id] += device_param->speed_cnt[i];
1651 speed_ms[device_id] += device_param->speed_ms[i];
1652 }
1653
1654 speed_cnt[device_id] /= SPEED_CACHE;
1655 speed_ms[device_id] /= SPEED_CACHE;
1656 }
1657
1658 float hashes_all_ms = 0;
1659
1660 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1661
1662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1663 {
1664 hc_device_param_t *device_param = &data.devices_param[device_id];
1665
1666 if (device_param->skipped) continue;
1667
1668 hashes_dev_ms[device_id] = 0;
1669
1670 if (speed_ms[device_id])
1671 {
1672 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1673
1674 hashes_all_ms += hashes_dev_ms[device_id];
1675 }
1676 }
1677
1678 /**
1679 * exec time
1680 */
1681
1682 double exec_runtime_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 if (device_param->event == NULL) continue;
1691
1692 cl_ulong time_start;
1693 cl_ulong time_end;
1694
1695 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
1696 hc_clGetEventProfilingInfo (data.ocl, device_param->event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
1697
1698 const double total_time = (time_end - time_start) / 1000000.0;
1699
1700 exec_runtime_ms[device_id] = total_time;
1701 }
1702
1703 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1704 {
1705 hc_device_param_t *device_param = &data.devices_param[device_id];
1706
1707 if (device_param->skipped) continue;
1708
1709 char display_dev_cur[16] = { 0 };
1710
1711 strncpy (display_dev_cur, "0.00", 4);
1712
1713 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1714
1715 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_runtime_ms[device_id]);
1716 }
1717
1718 char display_all_cur[16] = { 0 };
1719
1720 strncpy (display_all_cur, "0.00", 4);
1721
1722 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1723
1724 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1725 }
1726
1727 /**
1728 * oclHashcat -only- functions
1729 */
1730
1731 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1732 {
1733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1734 {
1735 if (attack_kern == ATTACK_KERN_STRAIGHT)
1736 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1737 else if (attack_kern == ATTACK_KERN_COMBI)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_BF)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1741 }
1742 else
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1744 }
1745
1746 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1747 {
1748 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1749 {
1750 if (attack_kern == ATTACK_KERN_STRAIGHT)
1751 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1752 else if (attack_kern == ATTACK_KERN_COMBI)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_BF)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 }
1757 else
1758 {
1759 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1760 }
1761 }
1762
1763 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1764 {
1765 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1766 {
1767 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1768 }
1769 else
1770 {
1771 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1772 }
1773 }
1774
1775 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1776 {
1777 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1778 {
1779 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1788 {
1789 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1790 }
1791
1792 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1795 }
1796
1797 static uint convert_from_hex (char *line_buf, const uint line_len)
1798 {
1799 if (line_len & 1) return (line_len); // not in hex
1800
1801 if (data.hex_wordlist == 1)
1802 {
1803 uint i;
1804 uint j;
1805
1806 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1807 {
1808 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1809 }
1810
1811 memset (line_buf + i, 0, line_len - i);
1812
1813 return (i);
1814 }
1815 else if (line_len >= 6) // $HEX[] = 6
1816 {
1817 if (line_buf[0] != '$') return (line_len);
1818 if (line_buf[1] != 'H') return (line_len);
1819 if (line_buf[2] != 'E') return (line_len);
1820 if (line_buf[3] != 'X') return (line_len);
1821 if (line_buf[4] != '[') return (line_len);
1822 if (line_buf[line_len - 1] != ']') return (line_len);
1823
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836
1837 return (line_len);
1838 }
1839
1840 static void clear_prompt ()
1841 {
1842 fputc ('\r', stdout);
1843
1844 for (size_t i = 0; i < strlen (PROMPT); i++)
1845 {
1846 fputc (' ', stdout);
1847 }
1848
1849 fputc ('\r', stdout);
1850
1851 fflush (stdout);
1852 }
1853
1854 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1855 {
1856 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1857 }
1858
1859 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1860 {
1861 char *outfile = data.outfile;
1862 uint quiet = data.quiet;
1863 FILE *pot_fp = data.pot_fp;
1864 uint loopback = data.loopback;
1865 uint debug_mode = data.debug_mode;
1866 char *debug_file = data.debug_file;
1867
1868 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1869 int debug_rule_len = 0; // -1 error
1870 uint debug_plain_len = 0;
1871
1872 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1873
1874 // hash
1875
1876 char out_buf[4096] = { 0 };
1877
1878 ascii_digest (out_buf, salt_pos, digest_pos);
1879
1880 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1881
1882 // plain
1883
1884 plain_t plain;
1885
1886 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1887
1888 uint gidvid = plain.gidvid;
1889 uint il_pos = plain.il_pos;
1890
1891 u64 crackpos = device_param->words_off;
1892
1893 uint plain_buf[16] = { 0 };
1894
1895 u8 *plain_ptr = (u8 *) plain_buf;
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 u64 gidd = gidvid;
1901 u64 gidm = 0;
1902
1903 pw_t pw;
1904
1905 gidd_to_pw_t (device_param, gidd, &pw);
1906
1907 for (int i = 0, j = gidm; i < 16; i++, j++)
1908 {
1909 plain_buf[i] = pw.h.hi1[0][j];
1910 }
1911
1912 plain_len = pw.pw_len;
1913
1914 const uint off = device_param->innerloop_pos + il_pos;
1915
1916 if (debug_mode > 0)
1917 {
1918 debug_rule_len = 0;
1919
1920 // save rule
1921 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1922 {
1923 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1924
1925 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1926 }
1927
1928 // save plain
1929 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1930 {
1931 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1932
1933 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1934
1935 debug_plain_len = plain_len;
1936 }
1937 }
1938
1939 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1940
1941 crackpos += gidvid;
1942 crackpos *= data.kernel_rules_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (plain_len > data.pw_max) plain_len = data.pw_max;
1946 }
1947 else if (data.attack_mode == ATTACK_MODE_COMBI)
1948 {
1949 u64 gidd = gidvid;
1950 u64 gidm = 0;
1951
1952 pw_t pw;
1953
1954 gidd_to_pw_t (device_param, gidd, &pw);
1955
1956 for (int i = 0, j = gidm; i < 16; i++, j++)
1957 {
1958 plain_buf[i] = pw.h.hi1[0][j];
1959 }
1960
1961 plain_len = pw.pw_len;
1962
1963 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1964 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1965
1966 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1967 {
1968 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1969 }
1970 else
1971 {
1972 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1973
1974 memcpy (plain_ptr, comb_buf, comb_len);
1975 }
1976
1977 plain_len += comb_len;
1978
1979 crackpos += gidvid;
1980 crackpos *= data.combs_cnt;
1981 crackpos += device_param->innerloop_pos + il_pos;
1982
1983 if (data.pw_max != PW_DICTMAX1)
1984 {
1985 if (plain_len > data.pw_max) plain_len = data.pw_max;
1986 }
1987 }
1988 else if (data.attack_mode == ATTACK_MODE_BF)
1989 {
1990 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1991 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1992
1993 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1994 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1995
1996 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1997 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1998
1999 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2000 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2001
2002 plain_len = data.css_cnt;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.bfs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2009 {
2010 u64 gidd = gidvid;
2011 u64 gidm = 0;
2012
2013 pw_t pw;
2014
2015 gidd_to_pw_t (device_param, gidd, &pw);
2016
2017 for (int i = 0, j = gidm; i < 16; i++, j++)
2018 {
2019 plain_buf[i] = pw.h.hi1[0][j];
2020 }
2021
2022 plain_len = pw.pw_len;
2023
2024 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2025
2026 uint start = 0;
2027 uint stop = device_param->kernel_params_mp_buf32[4];
2028
2029 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2043 {
2044 u64 gidd = gidvid;
2045 u64 gidm = 0;
2046
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidd, &pw);
2050
2051 for (int i = 0, j = gidm; i < 16; i++, j++)
2052 {
2053 plain_buf[i] = pw.h.hi1[0][j];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2059
2060 uint start = 0;
2061 uint stop = device_param->kernel_params_mp_buf32[4];
2062
2063 memmove (plain_ptr + stop, plain_ptr, plain_len);
2064
2065 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2066
2067 plain_len += start + stop;
2068
2069 crackpos += gidvid;
2070 crackpos *= data.combs_cnt;
2071 crackpos += device_param->innerloop_pos + il_pos;
2072
2073 if (data.pw_max != PW_DICTMAX1)
2074 {
2075 if (plain_len > data.pw_max) plain_len = data.pw_max;
2076 }
2077 }
2078
2079 if (data.attack_mode == ATTACK_MODE_BF)
2080 {
2081 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2082 {
2083 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2084 {
2085 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2086 {
2087 plain_len = plain_len - data.salts_buf[0].salt_len;
2088 }
2089 }
2090
2091 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2092 {
2093 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2094 {
2095 plain_ptr[j] = plain_ptr[i];
2096 }
2097
2098 plain_len = plain_len / 2;
2099 }
2100 }
2101 }
2102
2103 // if enabled, update also the potfile
2104
2105 if (pot_fp)
2106 {
2107 lock_file (pot_fp);
2108
2109 fprintf (pot_fp, "%s:", out_buf);
2110
2111 format_plain (pot_fp, plain_ptr, plain_len, 1);
2112
2113 fputc ('\n', pot_fp);
2114
2115 fflush (pot_fp);
2116
2117 unlock_file (pot_fp);
2118 }
2119
2120 // outfile
2121
2122 FILE *out_fp = NULL;
2123
2124 if (outfile != NULL)
2125 {
2126 if ((out_fp = fopen (outfile, "ab")) == NULL)
2127 {
2128 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2129
2130 out_fp = stdout;
2131 }
2132 lock_file (out_fp);
2133 }
2134 else
2135 {
2136 out_fp = stdout;
2137
2138 if (quiet == 0) clear_prompt ();
2139 }
2140
2141 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2142
2143 if (outfile != NULL)
2144 {
2145 if (out_fp != stdout)
2146 {
2147 fclose (out_fp);
2148 }
2149 }
2150 else
2151 {
2152 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2153 {
2154 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2155 {
2156 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2157 if (quiet == 0) fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 // loopback
2163
2164 if (loopback)
2165 {
2166 char *loopback_file = data.loopback_file;
2167
2168 FILE *fb_fp = NULL;
2169
2170 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2171 {
2172 lock_file (fb_fp);
2173
2174 format_plain (fb_fp, plain_ptr, plain_len, 1);
2175
2176 fputc ('\n', fb_fp);
2177
2178 fclose (fb_fp);
2179 }
2180 }
2181
2182 // (rule) debug mode
2183
2184 // the next check implies that:
2185 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2186 // - debug_mode > 0
2187
2188 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2189 {
2190 if (debug_rule_len < 0) debug_rule_len = 0;
2191
2192 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2193
2194 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2195
2196 if ((quiet == 0) && (debug_file == NULL))
2197 {
2198 fprintf (stdout, "%s", PROMPT);
2199 fflush (stdout);
2200 }
2201 }
2202 }
2203
2204 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2205 {
2206 salt_t *salt_buf = &data.salts_buf[salt_pos];
2207
2208 int found = 0;
2209
2210 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2211
2212 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2213
2214 if (found == 1)
2215 {
2216 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2217
2218 log_info_nn ("");
2219
2220 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2221
2222 uint cpt_cracked = 0;
2223
2224 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2225 {
2226 uint idx = salt_buf->digests_offset + digest_pos;
2227
2228 if (data.digests_shown_tmp[idx] == 0) continue;
2229
2230 if (data.digests_shown[idx] == 1) continue;
2231
2232 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2233 {
2234 data.digests_shown[idx] = 1;
2235
2236 data.digests_done++;
2237
2238 cpt_cracked++;
2239
2240 salt_buf->digests_done++;
2241
2242 if (salt_buf->digests_done == salt_buf->digests_cnt)
2243 {
2244 data.salts_shown[salt_pos] = 1;
2245
2246 data.salts_done++;
2247 }
2248 }
2249
2250 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2251
2252 check_hash (device_param, salt_pos, digest_pos);
2253 }
2254
2255 if (cpt_cracked > 0)
2256 {
2257 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2258 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2259
2260 data.cpt_pos++;
2261
2262 data.cpt_total += cpt_cracked;
2263
2264 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2265 }
2266
2267 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2268 {
2269 // we need to reset cracked state on the device
2270 // otherwise host thinks again and again the hash was cracked
2271 // and returns invalid password each time
2272
2273 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2274
2275 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2276 }
2277
2278 memset (device_param->result, 0, device_param->size_results);
2279
2280 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2281 }
2282 }
2283
2284 static void save_hash ()
2285 {
2286 char *hashfile = data.hashfile;
2287
2288 char new_hashfile[256] = { 0 };
2289 char old_hashfile[256] = { 0 };
2290
2291 snprintf (new_hashfile, 255, "%s.new", hashfile);
2292 snprintf (old_hashfile, 255, "%s.old", hashfile);
2293
2294 unlink (new_hashfile);
2295
2296 char separator = data.separator;
2297
2298 FILE *fp = fopen (new_hashfile, "wb");
2299
2300 if (fp == NULL)
2301 {
2302 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2303
2304 exit (-1);
2305 }
2306
2307 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2308 {
2309 if (data.salts_shown[salt_pos] == 1) continue;
2310
2311 salt_t *salt_buf = &data.salts_buf[salt_pos];
2312
2313 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2314 {
2315 uint idx = salt_buf->digests_offset + digest_pos;
2316
2317 if (data.digests_shown[idx] == 1) continue;
2318
2319 if (data.hash_mode != 2500)
2320 {
2321 char out_buf[4096] = { 0 };
2322
2323 if (data.username == 1)
2324 {
2325 user_t *user = data.hash_info[idx]->user;
2326
2327 uint i;
2328
2329 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2330
2331 fputc (separator, fp);
2332 }
2333
2334 ascii_digest (out_buf, salt_pos, digest_pos);
2335
2336 fputs (out_buf, fp);
2337
2338 log_out (fp, "");
2339 }
2340 else
2341 {
2342 hccap_t hccap;
2343
2344 to_hccap_t (&hccap, salt_pos, digest_pos);
2345
2346 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2347 }
2348 }
2349 }
2350
2351 fflush (fp);
2352
2353 fclose (fp);
2354
2355 unlink (old_hashfile);
2356
2357 if (rename (hashfile, old_hashfile) != 0)
2358 {
2359 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2360
2361 exit (-1);
2362 }
2363
2364 unlink (hashfile);
2365
2366 if (rename (new_hashfile, hashfile) != 0)
2367 {
2368 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2369
2370 exit (-1);
2371 }
2372
2373 unlink (old_hashfile);
2374 }
2375
2376 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2377 {
2378 // function called only in case kernel_blocks_all > words_left)
2379
2380 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2381
2382 kernel_blocks_div += kernel_blocks_div / 100;
2383
2384 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2385
2386 while (kernel_blocks_new < total_left)
2387 {
2388 kernel_blocks_div += kernel_blocks_div / 100;
2389
2390 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2391 }
2392
2393 if (data.quiet == 0)
2394 {
2395 clear_prompt ();
2396
2397 log_info ("");
2398
2399 log_info ("INFO: approaching final keyspace, workload adjusted");
2400
2401 log_info ("");
2402
2403 fprintf (stdout, "%s", PROMPT);
2404
2405 fflush (stdout);
2406 }
2407
2408 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2409
2410 return kernel_blocks_div;
2411 }
2412
2413 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2414 {
2415 uint num_elements = num;
2416
2417 device_param->kernel_params_buf32[30] = data.combs_mode;
2418 device_param->kernel_params_buf32[31] = num;
2419
2420 uint kernel_threads = device_param->kernel_threads;
2421
2422 while (num_elements % kernel_threads) num_elements++;
2423
2424 cl_kernel kernel = NULL;
2425
2426 switch (kern_run)
2427 {
2428 case KERN_RUN_1: kernel = device_param->kernel1; break;
2429 case KERN_RUN_12: kernel = device_param->kernel12; break;
2430 case KERN_RUN_2: kernel = device_param->kernel2; break;
2431 case KERN_RUN_23: kernel = device_param->kernel23; break;
2432 case KERN_RUN_3: kernel = device_param->kernel3; break;
2433 }
2434
2435 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2436 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2437 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2438 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2439 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2440 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2441 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2442 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2443 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2444 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2445 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2446
2447 cl_event event;
2448
2449 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2450 {
2451 const size_t global_work_size[3] = { num_elements, 32, 1 };
2452 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2453
2454 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event, true);
2455 }
2456 else
2457 {
2458 const size_t global_work_size[3] = { num_elements, 1, 1 };
2459 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2460
2461 const cl_int rc = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event, false);
2462
2463 if (rc != CL_SUCCESS)
2464 {
2465 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2466
2467 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, &event, true);
2468 }
2469 }
2470
2471 hc_clFlush (data.ocl, device_param->command_queue);
2472
2473 //hc_clFinish (data.ocl, device_param->command_queue);
2474
2475 hc_clWaitForEvents (data.ocl, 1, &event);
2476
2477 if (event_update) device_param->event = event;
2478 }
2479
2480 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2481 {
2482 uint num_elements = num;
2483
2484 switch (kern_run)
2485 {
2486 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2487 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2488 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2489 }
2490
2491 // causes problems with special threads like in bcrypt
2492 // const uint kernel_threads = device_param->kernel_threads;
2493
2494 const uint kernel_threads = KERNEL_THREADS;
2495
2496 while (num_elements % kernel_threads) num_elements++;
2497
2498 cl_kernel kernel = NULL;
2499
2500 switch (kern_run)
2501 {
2502 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2503 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2504 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2505 }
2506
2507 switch (kern_run)
2508 {
2509 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2510 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2511 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2512 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2513 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2514 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2515 break;
2516 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2517 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2518 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2519 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2520 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2521 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2522 break;
2523 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2524 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2525 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2526 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2527 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2528 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2529 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2530 break;
2531 }
2532
2533 const size_t global_work_size[3] = { num_elements, 1, 1 };
2534 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2535
2536 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);
2537
2538 if (rc != CL_SUCCESS)
2539 {
2540 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2541
2542 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2543 }
2544
2545 hc_clFlush (data.ocl, device_param->command_queue);
2546
2547 hc_clFinish (data.ocl, device_param->command_queue);
2548 }
2549
2550 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2551 {
2552 uint num_elements = num;
2553
2554 uint kernel_threads = device_param->kernel_threads;
2555
2556 while (num_elements % kernel_threads) num_elements++;
2557
2558 cl_kernel kernel = device_param->kernel_tb;
2559
2560 const size_t global_work_size[3] = { num_elements, 1, 1 };
2561 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2562
2563 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);
2564
2565 if (rc != CL_SUCCESS)
2566 {
2567 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2568
2569 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2570 }
2571
2572 hc_clFlush (data.ocl, device_param->command_queue);
2573
2574 hc_clFinish (data.ocl, device_param->command_queue);
2575 }
2576
2577 static void run_kernel_tm (hc_device_param_t *device_param)
2578 {
2579 const uint num_elements = 1024; // fixed
2580
2581 const uint kernel_threads = 32;
2582
2583 cl_kernel kernel = device_param->kernel_tm;
2584
2585 const size_t global_work_size[3] = { num_elements, 1, 1 };
2586 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2587
2588 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);
2589
2590 if (rc != CL_SUCCESS)
2591 {
2592 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2593
2594 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2595 }
2596
2597 hc_clFlush (data.ocl, device_param->command_queue);
2598
2599 hc_clFinish (data.ocl, device_param->command_queue);
2600 }
2601
2602 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2603 {
2604 uint num_elements = num;
2605
2606 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2607 device_param->kernel_params_amp_buf32[6] = num_elements;
2608
2609 // causes problems with special threads like in bcrypt
2610 // const uint kernel_threads = device_param->kernel_threads;
2611
2612 const uint kernel_threads = KERNEL_THREADS;
2613
2614 while (num_elements % kernel_threads) num_elements++;
2615
2616 cl_kernel kernel = device_param->kernel_amp;
2617
2618 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2619 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2620
2621 const size_t global_work_size[3] = { num_elements, 1, 1 };
2622 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2623
2624 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);
2625
2626 if (rc != CL_SUCCESS)
2627 {
2628 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2629
2630 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2631 }
2632
2633 hc_clFlush (data.ocl, device_param->command_queue);
2634
2635 hc_clFinish (data.ocl, device_param->command_queue);
2636 }
2637
2638 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2639 {
2640 int rc = -1;
2641
2642 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2643 {
2644 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2645
2646 const cl_uchar zero = 0;
2647
2648 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2649 }
2650
2651 if (rc != 0)
2652 {
2653 // NOTE: clEnqueueFillBuffer () always fails with -59
2654 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2655 // How's that possible, OpenCL 1.2 support is advertised??
2656 // We need to workaround...
2657
2658 #define FILLSZ 0x100000
2659
2660 char *tmp = (char *) mymalloc (FILLSZ);
2661
2662 for (uint i = 0; i < size; i += FILLSZ)
2663 {
2664 const int left = size - i;
2665
2666 const int fillsz = MIN (FILLSZ, left);
2667
2668 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2669 }
2670
2671 myfree (tmp);
2672 }
2673 }
2674
2675 static int run_rule_engine (const int rule_len, const char *rule_buf)
2676 {
2677 if (rule_len == 0)
2678 {
2679 return 0;
2680 }
2681 else if (rule_len == 1)
2682 {
2683 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2684 }
2685
2686 return 1;
2687 }
2688
2689 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2690 {
2691 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2692 {
2693 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);
2694 }
2695 else if (data.attack_kern == ATTACK_KERN_COMBI)
2696 {
2697 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);
2698 }
2699 else if (data.attack_kern == ATTACK_KERN_BF)
2700 {
2701 const u64 off = device_param->words_off;
2702
2703 device_param->kernel_params_mp_l_buf64[3] = off;
2704
2705 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2706 }
2707 }
2708
2709 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2710 {
2711 const uint kernel_loops = device_param->kernel_loops;
2712
2713 //only useful in debug
2714 //if (data.quiet == 0)
2715 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2716
2717 // init speed timer
2718
2719 uint speed_pos = device_param->speed_pos;
2720
2721 #ifdef _POSIX
2722 if (device_param->timer_speed.tv_sec == 0)
2723 {
2724 hc_timer_set (&device_param->timer_speed);
2725 }
2726 #endif
2727
2728 #ifdef _WIN
2729 if (device_param->timer_speed.QuadPart == 0)
2730 {
2731 hc_timer_set (&device_param->timer_speed);
2732 }
2733 #endif
2734
2735 // find higest password length, this is for optimization stuff
2736
2737 uint highest_pw_len = 0;
2738
2739 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2740 {
2741 }
2742 else if (data.attack_kern == ATTACK_KERN_COMBI)
2743 {
2744 }
2745 else if (data.attack_kern == ATTACK_KERN_BF)
2746 {
2747 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2748 + device_param->kernel_params_mp_l_buf32[5];
2749 }
2750
2751 // bitslice optimization stuff
2752
2753 if (data.attack_mode == ATTACK_MODE_BF)
2754 {
2755 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2756 {
2757 run_kernel_tb (device_param, pws_cnt);
2758 }
2759 }
2760
2761 // iteration type
2762
2763 uint innerloop_step = 0;
2764 uint innerloop_cnt = 0;
2765
2766 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2767 else innerloop_step = 1;
2768
2769 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2770 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2771 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2772
2773 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2774
2775 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2776 {
2777 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2778
2779 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2780
2781 if (data.devices_status == STATUS_CRACKED) break;
2782 if (data.devices_status == STATUS_ABORTED) break;
2783 if (data.devices_status == STATUS_QUIT) break;
2784 if (data.devices_status == STATUS_BYPASS) break;
2785
2786 if (data.salts_shown[salt_pos] == 1) continue;
2787
2788 salt_t *salt_buf = &data.salts_buf[salt_pos];
2789
2790 device_param->kernel_params_buf32[24] = salt_pos;
2791 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2792 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2793
2794 FILE *combs_fp = device_param->combs_fp;
2795
2796 if (data.attack_mode == ATTACK_MODE_COMBI)
2797 {
2798 rewind (combs_fp);
2799 }
2800
2801 // innerloops
2802
2803 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2804 {
2805 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2806
2807 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2808
2809 if (data.devices_status == STATUS_CRACKED) break;
2810 if (data.devices_status == STATUS_ABORTED) break;
2811 if (data.devices_status == STATUS_QUIT) break;
2812 if (data.devices_status == STATUS_BYPASS) break;
2813
2814 uint innerloop_left = innerloop_cnt - innerloop_pos;
2815
2816 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2817
2818 device_param->innerloop_pos = innerloop_pos;
2819 device_param->innerloop_left = innerloop_left;
2820
2821 device_param->kernel_params_buf32[27] = innerloop_left;
2822
2823 if (innerloop_left == 0) continue;
2824
2825 // initialize amplifiers
2826
2827 if (data.attack_mode == ATTACK_MODE_COMBI)
2828 {
2829 char line_buf[BUFSIZ] = { 0 };
2830
2831 uint i = 0;
2832
2833 while (i < innerloop_left)
2834 {
2835 if (feof (combs_fp)) break;
2836
2837 int line_len = fgetl (combs_fp, line_buf);
2838
2839 if (line_len >= PW_MAX1) continue;
2840
2841 line_len = convert_from_hex (line_buf, line_len);
2842
2843 char *line_buf_new = line_buf;
2844
2845 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2846 {
2847 char rule_buf_out[BLOCK_SIZE] = { 0 };
2848
2849 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2850
2851 if (rule_len_out < 0)
2852 {
2853 data.words_progress_rejected[salt_pos] += pw_cnt;
2854
2855 continue;
2856 }
2857
2858 line_len = rule_len_out;
2859
2860 line_buf_new = rule_buf_out;
2861 }
2862
2863 line_len = MIN (line_len, PW_DICTMAX);
2864
2865 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2866
2867 memcpy (ptr, line_buf_new, line_len);
2868
2869 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2870
2871 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2872 {
2873 uppercase (ptr, line_len);
2874 }
2875
2876 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2877 {
2878 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2879 {
2880 ptr[line_len] = 0x80;
2881 }
2882
2883 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2884 {
2885 ptr[line_len] = 0x01;
2886 }
2887 }
2888
2889 device_param->combs_buf[i].pw_len = line_len;
2890
2891 i++;
2892 }
2893
2894 for (uint j = i; j < innerloop_left; j++)
2895 {
2896 device_param->combs_buf[j].i[0] = 0;
2897 device_param->combs_buf[j].i[1] = 0;
2898 device_param->combs_buf[j].i[2] = 0;
2899 device_param->combs_buf[j].i[3] = 0;
2900 device_param->combs_buf[j].i[4] = 0;
2901 device_param->combs_buf[j].i[5] = 0;
2902 device_param->combs_buf[j].i[6] = 0;
2903 device_param->combs_buf[j].i[7] = 0;
2904
2905 device_param->combs_buf[j].pw_len = 0;
2906 }
2907
2908 innerloop_left = i;
2909 }
2910 else if (data.attack_mode == ATTACK_MODE_BF)
2911 {
2912 u64 off = innerloop_pos;
2913
2914 device_param->kernel_params_mp_r_buf64[3] = off;
2915
2916 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2917 }
2918 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2919 {
2920 u64 off = innerloop_pos;
2921
2922 device_param->kernel_params_mp_buf64[3] = off;
2923
2924 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2925 }
2926 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2927 {
2928 u64 off = innerloop_pos;
2929
2930 device_param->kernel_params_mp_buf64[3] = off;
2931
2932 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2933 }
2934
2935 // copy amplifiers
2936
2937 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2938 {
2939 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);
2940 }
2941 else if (data.attack_mode == ATTACK_MODE_COMBI)
2942 {
2943 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);
2944 }
2945 else if (data.attack_mode == ATTACK_MODE_BF)
2946 {
2947 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);
2948 }
2949 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2950 {
2951 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);
2952 }
2953 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2954 {
2955 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);
2956 }
2957
2958 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2959 {
2960 if (data.attack_mode == ATTACK_MODE_BF)
2961 {
2962 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2963 {
2964 const uint size_tm = 32 * sizeof (bs_word_t);
2965
2966 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2967
2968 run_kernel_tm (device_param);
2969
2970 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);
2971 }
2972 }
2973
2974 if (highest_pw_len < 16)
2975 {
2976 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2977 }
2978 else if (highest_pw_len < 32)
2979 {
2980 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2981 }
2982 else
2983 {
2984 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2985 }
2986 }
2987 else
2988 {
2989 run_kernel_amp (device_param, pws_cnt);
2990
2991 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2992
2993 if (data.opts_type & OPTS_TYPE_HOOK12)
2994 {
2995 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2996 }
2997
2998 uint iter = salt_buf->salt_iter;
2999
3000 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
3001 {
3002 uint loop_left = iter - loop_pos;
3003
3004 loop_left = MIN (loop_left, kernel_loops);
3005
3006 device_param->kernel_params_buf32[25] = loop_pos;
3007 device_param->kernel_params_buf32[26] = loop_left;
3008
3009 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
3010
3011 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3012
3013 if (data.devices_status == STATUS_CRACKED) break;
3014 if (data.devices_status == STATUS_ABORTED) break;
3015 if (data.devices_status == STATUS_QUIT) break;
3016 }
3017
3018 if (data.opts_type & OPTS_TYPE_HOOK23)
3019 {
3020 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
3021
3022 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);
3023
3024 // do something with data
3025
3026 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);
3027 }
3028
3029 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
3030 }
3031
3032 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3033
3034 if (data.devices_status == STATUS_CRACKED) break;
3035 if (data.devices_status == STATUS_ABORTED) break;
3036 if (data.devices_status == STATUS_QUIT) break;
3037
3038 /**
3039 * result
3040 */
3041
3042 hc_thread_mutex_lock (mux_display);
3043
3044 check_cracked (device_param, salt_pos);
3045
3046 hc_thread_mutex_unlock (mux_display);
3047
3048 /**
3049 * progress
3050 */
3051
3052 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3053
3054 hc_thread_mutex_lock (mux_counter);
3055
3056 data.words_progress_done[salt_pos] += perf_sum_all;
3057
3058 hc_thread_mutex_unlock (mux_counter);
3059
3060 /**
3061 * speed
3062 */
3063
3064 float speed_ms;
3065
3066 hc_timer_get (device_param->timer_speed, speed_ms);
3067
3068 hc_timer_set (&device_param->timer_speed);
3069
3070 hc_thread_mutex_lock (mux_display);
3071
3072 device_param->speed_cnt[speed_pos] = perf_sum_all;
3073
3074 device_param->speed_ms[speed_pos] = speed_ms;
3075
3076 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3077
3078 hc_thread_mutex_unlock (mux_display);
3079
3080 speed_pos++;
3081
3082 if (speed_pos == SPEED_CACHE)
3083 {
3084 speed_pos = 0;
3085 }
3086 }
3087 }
3088
3089 device_param->speed_pos = speed_pos;
3090 }
3091
3092 static void load_segment (wl_data_t *wl_data, FILE *fd)
3093 {
3094 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3095
3096 wl_data->pos = 0;
3097
3098 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3099
3100 wl_data->buf[wl_data->cnt] = 0;
3101
3102 if (wl_data->cnt == 0) return;
3103
3104 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3105
3106 while (!feof (fd))
3107 {
3108 if (wl_data->cnt == wl_data->avail)
3109 {
3110 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3111
3112 wl_data->avail += wl_data->incr;
3113 }
3114
3115 const int c = fgetc (fd);
3116
3117 if (c == EOF) break;
3118
3119 wl_data->buf[wl_data->cnt] = (char) c;
3120
3121 wl_data->cnt++;
3122
3123 if (c == '\n') break;
3124 }
3125
3126 // ensure stream ends with a newline
3127
3128 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3129 {
3130 wl_data->cnt++;
3131
3132 wl_data->buf[wl_data->cnt - 1] = '\n';
3133 }
3134
3135 return;
3136 }
3137
3138 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3139 {
3140 char *ptr = buf;
3141
3142 for (u32 i = 0; i < sz; i++, ptr++)
3143 {
3144 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3145
3146 if (i == 7)
3147 {
3148 *off = i;
3149 *len = i;
3150
3151 return;
3152 }
3153
3154 if (*ptr != '\n') continue;
3155
3156 *off = i + 1;
3157
3158 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3159
3160 *len = i;
3161
3162 return;
3163 }
3164
3165 *off = sz;
3166 *len = sz;
3167 }
3168
3169 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3170 {
3171 char *ptr = buf;
3172
3173 for (u32 i = 0; i < sz; i++, ptr++)
3174 {
3175 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3176
3177 if (*ptr != '\n') continue;
3178
3179 *off = i + 1;
3180
3181 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3182
3183 *len = i;
3184
3185 return;
3186 }
3187
3188 *off = sz;
3189 *len = sz;
3190 }
3191
3192 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3193 {
3194 char *ptr = buf;
3195
3196 for (u32 i = 0; i < sz; i++, ptr++)
3197 {
3198 if (*ptr != '\n') continue;
3199
3200 *off = i + 1;
3201
3202 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3203
3204 *len = i;
3205
3206 return;
3207 }
3208
3209 *off = sz;
3210 *len = sz;
3211 }
3212
3213 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3214 {
3215 while (wl_data->pos < wl_data->cnt)
3216 {
3217 uint off;
3218 uint len;
3219
3220 char *ptr = wl_data->buf + wl_data->pos;
3221
3222 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3223
3224 wl_data->pos += off;
3225
3226 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3227 {
3228 char rule_buf_out[BLOCK_SIZE] = { 0 };
3229
3230 int rule_len_out = -1;
3231
3232 if (len < BLOCK_SIZE)
3233 {
3234 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3235 }
3236
3237 if (rule_len_out < 0)
3238 {
3239 continue;
3240 }
3241
3242 if (rule_len_out > PW_MAX)
3243 {
3244 continue;
3245 }
3246 }
3247 else
3248 {
3249 if (len > PW_MAX)
3250 {
3251 continue;
3252 }
3253 }
3254
3255 *out_buf = ptr;
3256 *out_len = len;
3257
3258 return;
3259 }
3260
3261 if (feof (fd))
3262 {
3263 fprintf (stderr, "bug!!\n");
3264
3265 return;
3266 }
3267
3268 load_segment (wl_data, fd);
3269
3270 get_next_word (wl_data, fd, out_buf, out_len);
3271 }
3272
3273 #ifdef _POSIX
3274 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3275 #endif
3276
3277 #ifdef _WIN
3278 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3279 #endif
3280 {
3281 hc_signal (NULL);
3282
3283 dictstat_t d;
3284
3285 d.cnt = 0;
3286
3287 #ifdef _POSIX
3288 fstat (fileno (fd), &d.stat);
3289 #endif
3290
3291 #ifdef _WIN
3292 _fstat64 (fileno (fd), &d.stat);
3293 #endif
3294
3295 d.stat.st_mode = 0;
3296 d.stat.st_nlink = 0;
3297 d.stat.st_uid = 0;
3298 d.stat.st_gid = 0;
3299 d.stat.st_rdev = 0;
3300 d.stat.st_atime = 0;
3301
3302 #ifdef _POSIX
3303 d.stat.st_blksize = 0;
3304 d.stat.st_blocks = 0;
3305 #endif
3306
3307 if (d.stat.st_size == 0) return 0;
3308
3309 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3310
3311 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3312 {
3313 if (d_cache)
3314 {
3315 u64 cnt = d_cache->cnt;
3316
3317 u64 keyspace = cnt;
3318
3319 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3320 {
3321 keyspace *= data.kernel_rules_cnt;
3322 }
3323 else if (data.attack_kern == ATTACK_KERN_COMBI)
3324 {
3325 keyspace *= data.combs_cnt;
3326 }
3327
3328 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);
3329 if (data.quiet == 0) log_info ("");
3330
3331 hc_signal (sigHandler_default);
3332
3333 return (keyspace);
3334 }
3335 }
3336
3337 time_t now = 0;
3338 time_t prev = 0;
3339
3340 u64 comp = 0;
3341 u64 cnt = 0;
3342 u64 cnt2 = 0;
3343
3344 while (!feof (fd))
3345 {
3346 load_segment (wl_data, fd);
3347
3348 comp += wl_data->cnt;
3349
3350 u32 i = 0;
3351
3352 while (i < wl_data->cnt)
3353 {
3354 u32 len;
3355 u32 off;
3356
3357 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3358
3359 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3360 {
3361 char rule_buf_out[BLOCK_SIZE] = { 0 };
3362
3363 int rule_len_out = -1;
3364
3365 if (len < BLOCK_SIZE)
3366 {
3367 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3368 }
3369
3370 if (rule_len_out < 0)
3371 {
3372 len = PW_MAX1;
3373 }
3374 else
3375 {
3376 len = rule_len_out;
3377 }
3378 }
3379
3380 if (len < PW_MAX1)
3381 {
3382 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3383 {
3384 cnt += data.kernel_rules_cnt;
3385 }
3386 else if (data.attack_kern == ATTACK_KERN_COMBI)
3387 {
3388 cnt += data.combs_cnt;
3389 }
3390
3391 d.cnt++;
3392 }
3393
3394 i += off;
3395
3396 cnt2++;
3397 }
3398
3399 time (&now);
3400
3401 if ((now - prev) == 0) continue;
3402
3403 float percent = (float) comp / (float) d.stat.st_size;
3404
3405 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);
3406
3407 time (&prev);
3408 }
3409
3410 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);
3411 if (data.quiet == 0) log_info ("");
3412
3413 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3414
3415 hc_signal (sigHandler_default);
3416
3417 return (cnt);
3418 }
3419
3420 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3421 {
3422 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3423 }
3424
3425 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3426 {
3427 if (data.devices_status == STATUS_BYPASS) return 0;
3428
3429 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3430
3431 uint cache_cnt = pw_cache->cnt;
3432
3433 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3434
3435 memcpy (pw_hc1, pw_buf, pw_len);
3436
3437 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3438
3439 uint pws_cnt = device_param->pws_cnt;
3440
3441 cache_cnt++;
3442
3443 pw_t *pw = device_param->pws_buf + pws_cnt;
3444
3445 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3446
3447 pw->pw_len = pw_len;
3448
3449 pws_cnt++;
3450
3451 device_param->pws_cnt = pws_cnt;
3452 device_param->pw_cnt = pws_cnt * 1;
3453
3454 cache_cnt = 0;
3455
3456 pw_cache->cnt = cache_cnt;
3457
3458 return pws_cnt;
3459 }
3460
3461 static void *thread_monitor (void *p)
3462 {
3463 uint runtime_check = 0;
3464 uint remove_check = 0;
3465 uint status_check = 0;
3466 uint restore_check = 0;
3467
3468 uint restore_left = data.restore_timer;
3469 uint remove_left = data.remove_timer;
3470 uint status_left = data.status_timer;
3471
3472 #ifdef HAVE_HWMON
3473 uint hwmon_check = 0;
3474
3475 // these variables are mainly used for fan control (AMD only)
3476
3477 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3478
3479 // temperature controller "loopback" values
3480
3481 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3482 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3483
3484 #ifdef HAVE_ADL
3485 int temp_threshold = 1; // degrees celcius
3486
3487 int fan_speed_min = 15; // in percentage
3488 int fan_speed_max = 100;
3489 #endif // HAVE_ADL
3490
3491 time_t last_temp_check_time;
3492 #endif // HAVE_HWMON
3493
3494 uint sleep_time = 1;
3495
3496 if (data.runtime)
3497 {
3498 runtime_check = 1;
3499 }
3500
3501 if (data.restore_timer)
3502 {
3503 restore_check = 1;
3504 }
3505
3506 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3507 {
3508 remove_check = 1;
3509 }
3510
3511 if (data.status == 1)
3512 {
3513 status_check = 1;
3514 }
3515
3516 #ifdef HAVE_HWMON
3517 if (data.gpu_temp_disable == 0)
3518 {
3519 time (&last_temp_check_time);
3520
3521 hwmon_check = 1;
3522 }
3523 #endif
3524
3525 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3526 {
3527 #ifdef HAVE_HWMON
3528 if (hwmon_check == 0)
3529 #endif
3530 return (p);
3531 }
3532
3533 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3534 {
3535 hc_sleep (sleep_time);
3536
3537 if (data.devices_status != STATUS_RUNNING) continue;
3538
3539 #ifdef HAVE_HWMON
3540 if (hwmon_check == 1)
3541 {
3542 hc_thread_mutex_lock (mux_adl);
3543
3544 time_t temp_check_time;
3545
3546 time (&temp_check_time);
3547
3548 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3549
3550 if (Ta == 0) Ta = 1;
3551
3552 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3553 {
3554 hc_device_param_t *device_param = &data.devices_param[device_id];
3555
3556 if (device_param->skipped) continue;
3557
3558 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3559
3560 const int temperature = hm_get_temperature_with_device_id (device_id);
3561
3562 if (temperature > (int) data.gpu_temp_abort)
3563 {
3564 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3565
3566 if (data.devices_status != STATUS_QUIT) myabort ();
3567
3568 break;
3569 }
3570
3571 #ifdef HAVE_ADL
3572 const int gpu_temp_retain = data.gpu_temp_retain;
3573
3574 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3575 {
3576 if (data.hm_device[device_id].fan_supported == 1)
3577 {
3578 int temp_cur = temperature;
3579
3580 int temp_diff_new = gpu_temp_retain - temp_cur;
3581
3582 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3583
3584 // calculate Ta value (time difference in seconds between the last check and this check)
3585
3586 last_temp_check_time = temp_check_time;
3587
3588 float Kp = 1.8;
3589 float Ki = 0.005;
3590 float Kd = 6;
3591
3592 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3593
3594 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);
3595
3596 if (abs (fan_diff_required) >= temp_threshold)
3597 {
3598 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3599
3600 int fan_speed_level = fan_speed_cur;
3601
3602 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3603
3604 int fan_speed_new = fan_speed_level - fan_diff_required;
3605
3606 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3607 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3608
3609 if (fan_speed_new != fan_speed_cur)
3610 {
3611 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3612 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3613
3614 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3615 {
3616 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3617
3618 fan_speed_chgd[device_id] = 1;
3619 }
3620
3621 temp_diff_old[device_id] = temp_diff_new;
3622 }
3623 }
3624 }
3625 }
3626 #endif // HAVE_ADL
3627 }
3628
3629 hc_thread_mutex_unlock (mux_adl);
3630 }
3631 #endif // HAVE_HWMON
3632
3633 if (restore_check == 1)
3634 {
3635 restore_left--;
3636
3637 if (restore_left == 0)
3638 {
3639 if (data.restore_disable == 0) cycle_restore ();
3640
3641 restore_left = data.restore_timer;
3642 }
3643 }
3644
3645 if ((runtime_check == 1) && (data.runtime_start > 0))
3646 {
3647 time_t runtime_cur;
3648
3649 time (&runtime_cur);
3650
3651 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3652
3653 if (runtime_left <= 0)
3654 {
3655 if (data.benchmark == 0)
3656 {
3657 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3658 }
3659
3660 if (data.devices_status != STATUS_QUIT) myabort ();
3661 }
3662 }
3663
3664 if (remove_check == 1)
3665 {
3666 remove_left--;
3667
3668 if (remove_left == 0)
3669 {
3670 if (data.digests_saved != data.digests_done)
3671 {
3672 data.digests_saved = data.digests_done;
3673
3674 save_hash ();
3675 }
3676
3677 remove_left = data.remove_timer;
3678 }
3679 }
3680
3681 if (status_check == 1)
3682 {
3683 status_left--;
3684
3685 if (status_left == 0)
3686 {
3687 hc_thread_mutex_lock (mux_display);
3688
3689 if (data.quiet == 0) clear_prompt ();
3690
3691 if (data.quiet == 0) log_info ("");
3692
3693 status_display ();
3694
3695 if (data.quiet == 0) log_info ("");
3696
3697 hc_thread_mutex_unlock (mux_display);
3698
3699 status_left = data.status_timer;
3700 }
3701 }
3702 }
3703
3704 #ifdef HAVE_HWMON
3705 myfree (fan_speed_chgd);
3706
3707 myfree (temp_diff_old);
3708 myfree (temp_diff_sum);
3709 #endif
3710
3711 p = NULL;
3712
3713 return (p);
3714 }
3715
3716 static void *thread_outfile_remove (void *p)
3717 {
3718 // some hash-dependent constants
3719 char *outfile_dir = data.outfile_check_directory;
3720 uint dgst_size = data.dgst_size;
3721 uint isSalted = data.isSalted;
3722 uint esalt_size = data.esalt_size;
3723 uint hash_mode = data.hash_mode;
3724
3725 uint outfile_check_timer = data.outfile_check_timer;
3726
3727 char separator = data.separator;
3728
3729 // some hash-dependent functions
3730 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3731 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3732
3733 // buffers
3734 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3735
3736 hash_buf.digest = mymalloc (dgst_size);
3737
3738 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3739
3740 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3741
3742 uint digest_buf[64] = { 0 };
3743
3744 outfile_data_t *out_info = NULL;
3745
3746 char **out_files = NULL;
3747
3748 time_t folder_mtime = 0;
3749
3750 int out_cnt = 0;
3751
3752 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3753
3754 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3755 {
3756 hc_sleep (1);
3757
3758 if (data.devices_status != STATUS_RUNNING) continue;
3759
3760 check_left--;
3761
3762 if (check_left == 0)
3763 {
3764 struct stat outfile_check_stat;
3765
3766 if (stat (outfile_dir, &outfile_check_stat) == 0)
3767 {
3768 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3769
3770 if (is_dir == 1)
3771 {
3772 if (outfile_check_stat.st_mtime > folder_mtime)
3773 {
3774 char **out_files_new = scan_directory (outfile_dir);
3775
3776 int out_cnt_new = count_dictionaries (out_files_new);
3777
3778 outfile_data_t *out_info_new = NULL;
3779
3780 if (out_cnt_new > 0)
3781 {
3782 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3783
3784 for (int i = 0; i < out_cnt_new; i++)
3785 {
3786 out_info_new[i].file_name = out_files_new[i];
3787
3788 // check if there are files that we have seen/checked before (and not changed)
3789
3790 for (int j = 0; j < out_cnt; j++)
3791 {
3792 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3793 {
3794 struct stat outfile_stat;
3795
3796 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3797 {
3798 if (outfile_stat.st_ctime == out_info[j].ctime)
3799 {
3800 out_info_new[i].ctime = out_info[j].ctime;
3801 out_info_new[i].seek = out_info[j].seek;
3802 }
3803 }
3804 }
3805 }
3806 }
3807 }
3808
3809 local_free (out_info);
3810 local_free (out_files);
3811
3812 out_files = out_files_new;
3813 out_cnt = out_cnt_new;
3814 out_info = out_info_new;
3815
3816 folder_mtime = outfile_check_stat.st_mtime;
3817 }
3818
3819 for (int j = 0; j < out_cnt; j++)
3820 {
3821 FILE *fp = fopen (out_info[j].file_name, "rb");
3822
3823 if (fp != NULL)
3824 {
3825 //hc_thread_mutex_lock (mux_display);
3826
3827 #ifdef _POSIX
3828 struct stat outfile_stat;
3829
3830 fstat (fileno (fp), &outfile_stat);
3831 #endif
3832
3833 #ifdef _WIN
3834 struct stat64 outfile_stat;
3835
3836 _fstat64 (fileno (fp), &outfile_stat);
3837 #endif
3838
3839 if (outfile_stat.st_ctime > out_info[j].ctime)
3840 {
3841 out_info[j].ctime = outfile_stat.st_ctime;
3842 out_info[j].seek = 0;
3843 }
3844
3845 fseek (fp, out_info[j].seek, SEEK_SET);
3846
3847 while (!feof (fp))
3848 {
3849 char line_buf[BUFSIZ] = { 0 };
3850
3851 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3852
3853 if (ptr == NULL) break;
3854
3855 int line_len = strlen (line_buf);
3856
3857 if (line_len <= 0) continue;
3858
3859 int iter = MAX_CUT_TRIES;
3860
3861 for (uint i = line_len - 1; i && iter; i--, line_len--)
3862 {
3863 if (line_buf[i] != separator) continue;
3864
3865 int parser_status = PARSER_OK;
3866
3867 if ((hash_mode != 2500) && (hash_mode != 6800))
3868 {
3869 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3870 }
3871
3872 uint found = 0;
3873
3874 if (parser_status == PARSER_OK)
3875 {
3876 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3877 {
3878 if (data.salts_shown[salt_pos] == 1) continue;
3879
3880 salt_t *salt_buf = &data.salts_buf[salt_pos];
3881
3882 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3883 {
3884 uint idx = salt_buf->digests_offset + digest_pos;
3885
3886 if (data.digests_shown[idx] == 1) continue;
3887
3888 uint cracked = 0;
3889
3890 if (hash_mode == 6800)
3891 {
3892 if (i == salt_buf->salt_len)
3893 {
3894 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3895 }
3896 }
3897 else if (hash_mode == 2500)
3898 {
3899 // BSSID : MAC1 : MAC2 (:plain)
3900 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3901 {
3902 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3903
3904 if (!cracked) continue;
3905
3906 // now compare MAC1 and MAC2 too, since we have this additional info
3907 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3908 char *mac2_pos = mac1_pos + 12 + 1;
3909
3910 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3911 wpa_t *wpa = &wpas[salt_pos];
3912
3913 uint pke[25] = { 0 };
3914
3915 char *pke_ptr = (char *) pke;
3916
3917 for (uint i = 0; i < 25; i++)
3918 {
3919 pke[i] = byte_swap_32 (wpa->pke[i]);
3920 }
3921
3922 u8 mac1[6] = { 0 };
3923 u8 mac2[6] = { 0 };
3924
3925 memcpy (mac1, pke_ptr + 23, 6);
3926 memcpy (mac2, pke_ptr + 29, 6);
3927
3928 // compare hex string(s) vs binary MAC address(es)
3929
3930 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3931 {
3932 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3933 {
3934 cracked = 0;
3935 break;
3936 }
3937 }
3938
3939 // early skip ;)
3940 if (!cracked) continue;
3941
3942 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3943 {
3944 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3945 {
3946 cracked = 0;
3947 break;
3948 }
3949 }
3950 }
3951 }
3952 else
3953 {
3954 char *digests_buf_ptr = (char *) data.digests_buf;
3955
3956 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3957
3958 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3959 }
3960
3961 if (cracked == 1)
3962 {
3963 found = 1;
3964
3965 data.digests_shown[idx] = 1;
3966
3967 data.digests_done++;
3968
3969 salt_buf->digests_done++;
3970
3971 if (salt_buf->digests_done == salt_buf->digests_cnt)
3972 {
3973 data.salts_shown[salt_pos] = 1;
3974
3975 data.salts_done++;
3976
3977 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3978 }
3979 }
3980 }
3981
3982 if (data.devices_status == STATUS_CRACKED) break;
3983 }
3984 }
3985
3986 if (found) break;
3987
3988 if (data.devices_status == STATUS_CRACKED) break;
3989
3990 iter--;
3991 }
3992
3993 if (data.devices_status == STATUS_CRACKED) break;
3994 }
3995
3996 out_info[j].seek = ftell (fp);
3997
3998 //hc_thread_mutex_unlock (mux_display);
3999
4000 fclose (fp);
4001 }
4002 }
4003 }
4004 }
4005
4006 check_left = outfile_check_timer;
4007 }
4008 }
4009
4010 if (esalt_size) local_free (hash_buf.esalt);
4011
4012 if (isSalted) local_free (hash_buf.salt);
4013
4014 local_free (hash_buf.digest);
4015
4016 local_free (out_info);
4017
4018 local_free (out_files);
4019
4020 p = NULL;
4021
4022 return (p);
4023 }
4024
4025 static uint get_work (hc_device_param_t *device_param, const u64 max)
4026 {
4027 hc_thread_mutex_lock (mux_dispatcher);
4028
4029 const u64 words_cur = data.words_cur;
4030 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4031
4032 device_param->words_off = words_cur;
4033
4034 const u64 words_left = words_base - words_cur;
4035
4036 if (data.kernel_blocks_all > words_left)
4037 {
4038 if (data.kernel_blocks_div == 0)
4039 {
4040 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4041 }
4042 }
4043
4044 if (data.kernel_blocks_div)
4045 {
4046 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4047 {
4048 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4049 const u32 kernel_power_new = kernel_blocks_new;
4050
4051 if (kernel_blocks_new < device_param->kernel_blocks)
4052 {
4053 device_param->kernel_blocks = kernel_blocks_new;
4054 device_param->kernel_power = kernel_power_new;
4055 }
4056 }
4057 }
4058
4059 const uint kernel_blocks = device_param->kernel_blocks;
4060
4061 uint work = MIN (words_left, kernel_blocks);
4062
4063 work = MIN (work, max);
4064
4065 data.words_cur += work;
4066
4067 hc_thread_mutex_unlock (mux_dispatcher);
4068
4069 return work;
4070 }
4071
4072 static void *thread_calc_stdin (void *p)
4073 {
4074 hc_device_param_t *device_param = (hc_device_param_t *) p;
4075
4076 if (device_param->skipped) return NULL;
4077
4078 const uint attack_kern = data.attack_kern;
4079
4080 const uint kernel_blocks = device_param->kernel_blocks;
4081
4082 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4083 {
4084 hc_thread_mutex_lock (mux_dispatcher);
4085
4086 if (feof (stdin) != 0)
4087 {
4088 hc_thread_mutex_unlock (mux_dispatcher);
4089
4090 break;
4091 }
4092
4093 uint words_cur = 0;
4094
4095 while (words_cur < kernel_blocks)
4096 {
4097 char buf[BUFSIZ] = { 0 };
4098
4099 char *line_buf = fgets (buf, sizeof (buf), stdin);
4100
4101 if (line_buf == NULL) break;
4102
4103 uint line_len = in_superchop (line_buf);
4104
4105 line_len = convert_from_hex (line_buf, line_len);
4106
4107 // post-process rule engine
4108
4109 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4110 {
4111 char rule_buf_out[BLOCK_SIZE] = { 0 };
4112
4113 int rule_len_out = -1;
4114
4115 if (line_len < BLOCK_SIZE)
4116 {
4117 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4118 }
4119
4120 if (rule_len_out < 0) continue;
4121
4122 line_buf = rule_buf_out;
4123 line_len = rule_len_out;
4124 }
4125
4126 if (line_len > PW_MAX)
4127 {
4128 continue;
4129 }
4130
4131 if (attack_kern == ATTACK_KERN_STRAIGHT)
4132 {
4133 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4134 {
4135 hc_thread_mutex_lock (mux_counter);
4136
4137 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4138 {
4139 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4140 }
4141
4142 hc_thread_mutex_unlock (mux_counter);
4143
4144 continue;
4145 }
4146 }
4147 else if (attack_kern == ATTACK_KERN_COMBI)
4148 {
4149 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4150 // since we still need to combine the plains
4151
4152 if (line_len > data.pw_max)
4153 {
4154 hc_thread_mutex_lock (mux_counter);
4155
4156 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4157 {
4158 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4159 }
4160
4161 hc_thread_mutex_unlock (mux_counter);
4162
4163 continue;
4164 }
4165 }
4166
4167 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4168
4169 words_cur++;
4170
4171 if (data.devices_status == STATUS_CRACKED) break;
4172 if (data.devices_status == STATUS_ABORTED) break;
4173 if (data.devices_status == STATUS_QUIT) break;
4174 if (data.devices_status == STATUS_BYPASS) break;
4175 }
4176
4177 hc_thread_mutex_unlock (mux_dispatcher);
4178
4179 if (data.devices_status == STATUS_CRACKED) break;
4180 if (data.devices_status == STATUS_ABORTED) break;
4181 if (data.devices_status == STATUS_QUIT) break;
4182 if (data.devices_status == STATUS_BYPASS) break;
4183
4184 // we need 2 flushing because we have two independant caches and it can occur
4185 // that one buffer is already at threshold plus for that length also exists
4186 // more data in the 2nd buffer so it would overflow
4187
4188 // flush session 1
4189
4190 {
4191 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4192 {
4193 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4194
4195 const uint pw_cache_cnt = pw_cache->cnt;
4196
4197 if (pw_cache_cnt == 0) continue;
4198
4199 pw_cache->cnt = 0;
4200
4201 uint pws_cnt = device_param->pws_cnt;
4202
4203 pw_t *pw = device_param->pws_buf + pws_cnt;
4204
4205 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4206
4207 pw->pw_len = pw_len;
4208
4209 uint pw_cnt = device_param->pw_cnt;
4210
4211 pw_cnt += pw_cache_cnt;
4212
4213 device_param->pw_cnt = pw_cnt;
4214
4215 pws_cnt++;
4216
4217 device_param->pws_cnt = pws_cnt;
4218
4219 if (pws_cnt == device_param->kernel_power_user) break;
4220 }
4221
4222 const uint pw_cnt = device_param->pw_cnt;
4223 const uint pws_cnt = device_param->pws_cnt;
4224
4225 if (pws_cnt)
4226 {
4227 run_copy (device_param, pws_cnt);
4228
4229 run_cracker (device_param, pw_cnt, pws_cnt);
4230
4231 device_param->pw_cnt = 0;
4232 device_param->pws_cnt = 0;
4233 }
4234 }
4235
4236 // flush session 2
4237
4238 {
4239 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4240 {
4241 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4242
4243 const uint pw_cache_cnt = pw_cache->cnt;
4244
4245 if (pw_cache_cnt == 0) continue;
4246
4247 pw_cache->cnt = 0;
4248
4249 uint pws_cnt = device_param->pws_cnt;
4250
4251 pw_t *pw = device_param->pws_buf + pws_cnt;
4252
4253 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4254
4255 pw->pw_len = pw_len;
4256
4257 uint pw_cnt = device_param->pw_cnt;
4258
4259 pw_cnt += pw_cache_cnt;
4260
4261 device_param->pw_cnt = pw_cnt;
4262
4263 pws_cnt++;
4264
4265 device_param->pws_cnt = pws_cnt;
4266 }
4267
4268 const uint pw_cnt = device_param->pw_cnt;
4269 const uint pws_cnt = device_param->pws_cnt;
4270
4271 if (pws_cnt)
4272 {
4273 run_copy (device_param, pws_cnt);
4274
4275 run_cracker (device_param, pw_cnt, pws_cnt);
4276
4277 device_param->pw_cnt = 0;
4278 device_param->pws_cnt = 0;
4279 }
4280 }
4281 }
4282
4283 return NULL;
4284 }
4285
4286 static void *thread_calc (void *p)
4287 {
4288 hc_device_param_t *device_param = (hc_device_param_t *) p;
4289
4290 if (device_param->skipped) return NULL;
4291
4292 const uint attack_mode = data.attack_mode;
4293 const uint attack_kern = data.attack_kern;
4294
4295 if (attack_mode == ATTACK_MODE_BF)
4296 {
4297 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4298 {
4299 const uint work = get_work (device_param, -1);
4300
4301 if (work == 0) break;
4302
4303 const u64 words_off = device_param->words_off;
4304 const u64 words_fin = words_off + work;
4305
4306 const uint pw_cnt = work;
4307 const uint pws_cnt = work;
4308
4309 device_param->pw_cnt = pw_cnt;
4310 device_param->pws_cnt = pws_cnt;
4311
4312 if (pws_cnt)
4313 {
4314 run_copy (device_param, pws_cnt);
4315
4316 run_cracker (device_param, pw_cnt, pws_cnt);
4317
4318 device_param->pw_cnt = 0;
4319 device_param->pws_cnt = 0;
4320 }
4321
4322 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4323
4324 if (data.devices_status == STATUS_CRACKED) break;
4325 if (data.devices_status == STATUS_ABORTED) break;
4326 if (data.devices_status == STATUS_QUIT) break;
4327 if (data.devices_status == STATUS_BYPASS) break;
4328
4329 device_param->words_done = words_fin;
4330 }
4331 }
4332 else
4333 {
4334 const uint segment_size = data.segment_size;
4335
4336 char *dictfile = data.dictfile;
4337
4338 if (attack_mode == ATTACK_MODE_COMBI)
4339 {
4340 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4341 {
4342 dictfile = data.dictfile2;
4343 }
4344 }
4345
4346 FILE *fd = fopen (dictfile, "rb");
4347
4348 if (fd == NULL)
4349 {
4350 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4351
4352 return NULL;
4353 }
4354
4355 if (attack_mode == ATTACK_MODE_COMBI)
4356 {
4357 const uint combs_mode = data.combs_mode;
4358
4359 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4360 {
4361 const char *dictfilec = data.dictfile2;
4362
4363 FILE *combs_fp = fopen (dictfilec, "rb");
4364
4365 if (combs_fp == NULL)
4366 {
4367 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4368
4369 fclose (fd);
4370
4371 return NULL;
4372 }
4373
4374 device_param->combs_fp = combs_fp;
4375 }
4376 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4377 {
4378 const char *dictfilec = data.dictfile;
4379
4380 FILE *combs_fp = fopen (dictfilec, "rb");
4381
4382 if (combs_fp == NULL)
4383 {
4384 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4385
4386 fclose (fd);
4387
4388 return NULL;
4389 }
4390
4391 device_param->combs_fp = combs_fp;
4392 }
4393 }
4394
4395 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4396
4397 wl_data->buf = (char *) mymalloc (segment_size);
4398 wl_data->avail = segment_size;
4399 wl_data->incr = segment_size;
4400 wl_data->cnt = 0;
4401 wl_data->pos = 0;
4402
4403 u64 words_cur = 0;
4404
4405 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4406 {
4407 u64 words_off = 0;
4408 u64 words_fin = 0;
4409
4410 u64 max = -1;
4411
4412 while (max)
4413 {
4414 const uint work = get_work (device_param, max);
4415
4416 if (work == 0) break;
4417
4418 words_off = device_param->words_off;
4419 words_fin = words_off + work;
4420
4421 char *line_buf;
4422 uint line_len;
4423
4424 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4425
4426 max = 0;
4427
4428 for ( ; words_cur < words_fin; words_cur++)
4429 {
4430 get_next_word (wl_data, fd, &line_buf, &line_len);
4431
4432 line_len = convert_from_hex (line_buf, line_len);
4433
4434 // post-process rule engine
4435
4436 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4437 {
4438 char rule_buf_out[BLOCK_SIZE] = { 0 };
4439
4440 int rule_len_out = -1;
4441
4442 if (line_len < BLOCK_SIZE)
4443 {
4444 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4445 }
4446
4447 if (rule_len_out < 0) continue;
4448
4449 line_buf = rule_buf_out;
4450 line_len = rule_len_out;
4451 }
4452
4453 if (attack_kern == ATTACK_KERN_STRAIGHT)
4454 {
4455 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4456 {
4457 max++;
4458
4459 hc_thread_mutex_lock (mux_counter);
4460
4461 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4462 {
4463 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4464 }
4465
4466 hc_thread_mutex_unlock (mux_counter);
4467
4468 continue;
4469 }
4470 }
4471 else if (attack_kern == ATTACK_KERN_COMBI)
4472 {
4473 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4474 // since we still need to combine the plains
4475
4476 if (line_len > data.pw_max)
4477 {
4478 max++;
4479
4480 hc_thread_mutex_lock (mux_counter);
4481
4482 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4483 {
4484 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4485 }
4486
4487 hc_thread_mutex_unlock (mux_counter);
4488
4489 continue;
4490 }
4491 }
4492
4493 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4494
4495 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4496
4497 if (data.devices_status == STATUS_CRACKED) break;
4498 if (data.devices_status == STATUS_ABORTED) break;
4499 if (data.devices_status == STATUS_QUIT) break;
4500 if (data.devices_status == STATUS_BYPASS) break;
4501 }
4502
4503 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4504
4505 if (data.devices_status == STATUS_CRACKED) break;
4506 if (data.devices_status == STATUS_ABORTED) break;
4507 if (data.devices_status == STATUS_QUIT) break;
4508 if (data.devices_status == STATUS_BYPASS) break;
4509 }
4510
4511 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4512
4513 if (data.devices_status == STATUS_CRACKED) break;
4514 if (data.devices_status == STATUS_ABORTED) break;
4515 if (data.devices_status == STATUS_QUIT) break;
4516 if (data.devices_status == STATUS_BYPASS) break;
4517
4518 // we need 2 flushing because we have two independant caches and it can occur
4519 // that one buffer is already at threshold plus for that length also exists
4520 // more data in the 2nd buffer so it would overflow
4521
4522 //
4523 // flush session 1
4524 //
4525
4526 {
4527 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4528 {
4529 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4530
4531 const uint pw_cache_cnt = pw_cache->cnt;
4532
4533 if (pw_cache_cnt == 0) continue;
4534
4535 pw_cache->cnt = 0;
4536
4537 uint pws_cnt = device_param->pws_cnt;
4538
4539 pw_t *pw = device_param->pws_buf + pws_cnt;
4540
4541 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4542
4543 pw->pw_len = pw_len;
4544
4545 uint pw_cnt = device_param->pw_cnt;
4546
4547 pw_cnt += pw_cache_cnt;
4548
4549 device_param->pw_cnt = pw_cnt;
4550
4551 pws_cnt++;
4552
4553 device_param->pws_cnt = pws_cnt;
4554
4555 if (pws_cnt == device_param->kernel_power_user) break;
4556 }
4557
4558 const uint pw_cnt = device_param->pw_cnt;
4559 const uint pws_cnt = device_param->pws_cnt;
4560
4561 if (pws_cnt)
4562 {
4563 run_copy (device_param, pws_cnt);
4564
4565 run_cracker (device_param, pw_cnt, pws_cnt);
4566
4567 device_param->pw_cnt = 0;
4568 device_param->pws_cnt = 0;
4569 }
4570
4571 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4572
4573 if (data.devices_status == STATUS_CRACKED) break;
4574 if (data.devices_status == STATUS_ABORTED) break;
4575 if (data.devices_status == STATUS_QUIT) break;
4576 if (data.devices_status == STATUS_BYPASS) break;
4577 }
4578
4579 //
4580 // flush session 2
4581 //
4582
4583 {
4584 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4585 {
4586 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4587
4588 const uint pw_cache_cnt = pw_cache->cnt;
4589
4590 if (pw_cache_cnt == 0) continue;
4591
4592 pw_cache->cnt = 0;
4593
4594 uint pws_cnt = device_param->pws_cnt;
4595
4596 pw_t *pw = device_param->pws_buf + pws_cnt;
4597
4598 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4599
4600 pw->pw_len = pw_len;
4601
4602 uint pw_cnt = device_param->pw_cnt;
4603
4604 pw_cnt += pw_cache_cnt;
4605
4606 device_param->pw_cnt = pw_cnt;
4607
4608 pws_cnt++;
4609
4610 device_param->pws_cnt = pws_cnt;
4611 }
4612
4613 const uint pw_cnt = device_param->pw_cnt;
4614 const uint pws_cnt = device_param->pws_cnt;
4615
4616 if (pws_cnt)
4617 {
4618 run_copy (device_param, pws_cnt);
4619
4620 run_cracker (device_param, pw_cnt, pws_cnt);
4621
4622 device_param->pw_cnt = 0;
4623 device_param->pws_cnt = 0;
4624 }
4625
4626 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4627
4628 if (data.devices_status == STATUS_CRACKED) break;
4629 if (data.devices_status == STATUS_ABORTED) break;
4630 if (data.devices_status == STATUS_QUIT) break;
4631 if (data.devices_status == STATUS_BYPASS) break;
4632 }
4633
4634 if (words_fin == 0) break;
4635
4636 device_param->words_done = words_fin;
4637 }
4638
4639 if (attack_mode == ATTACK_MODE_COMBI)
4640 {
4641 fclose (device_param->combs_fp);
4642 }
4643
4644 free (wl_data->buf);
4645 free (wl_data);
4646
4647 fclose (fd);
4648 }
4649
4650 return NULL;
4651 }
4652
4653 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4654 {
4655 if (!device_param)
4656 {
4657 log_error ("ERROR: %s : Invalid argument", __func__);
4658
4659 exit (-1);
4660 }
4661
4662 salt_t *salt_buf = &data.salts_buf[salt_pos];
4663
4664 device_param->kernel_params_buf32[24] = salt_pos;
4665 device_param->kernel_params_buf32[27] = 1;
4666 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4667 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4668 device_param->kernel_params_buf32[30] = 0;
4669 device_param->kernel_params_buf32[31] = 1;
4670
4671 char *dictfile_old = data.dictfile;
4672
4673 const char *weak_hash_check = "weak-hash-check";
4674
4675 data.dictfile = (char *) weak_hash_check;
4676
4677 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4678
4679 data.kernel_rules_buf[0].cmds[0] = 0;
4680
4681 /**
4682 * run the kernel
4683 */
4684
4685 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4686 {
4687 run_kernel (KERN_RUN_1, device_param, 1, false);
4688 }
4689 else
4690 {
4691 run_kernel (KERN_RUN_1, device_param, 1, false);
4692
4693 const uint iter = salt_buf->salt_iter;
4694
4695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4696 {
4697 uint loop_left = iter - loop_pos;
4698
4699 loop_left = MIN (loop_left, kernel_loops);
4700
4701 device_param->kernel_params_buf32[25] = loop_pos;
4702 device_param->kernel_params_buf32[26] = loop_left;
4703
4704 run_kernel (KERN_RUN_2, device_param, 1, false);
4705 }
4706
4707 run_kernel (KERN_RUN_3, device_param, 1, false);
4708 }
4709
4710 /**
4711 * result
4712 */
4713
4714 check_cracked (device_param, salt_pos);
4715
4716 /**
4717 * cleanup
4718 */
4719
4720 device_param->kernel_params_buf32[24] = 0;
4721 device_param->kernel_params_buf32[25] = 0;
4722 device_param->kernel_params_buf32[26] = 0;
4723 device_param->kernel_params_buf32[27] = 0;
4724 device_param->kernel_params_buf32[28] = 0;
4725 device_param->kernel_params_buf32[29] = 0;
4726 device_param->kernel_params_buf32[30] = 0;
4727 device_param->kernel_params_buf32[31] = 0;
4728
4729 data.dictfile = dictfile_old;
4730
4731 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4732 }
4733
4734 // hlfmt hashcat
4735
4736 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4737 {
4738 if (data.username == 0)
4739 {
4740 *hashbuf_pos = line_buf;
4741 *hashbuf_len = line_len;
4742 }
4743 else
4744 {
4745 char *pos = line_buf;
4746 int len = line_len;
4747
4748 for (int i = 0; i < line_len; i++, pos++, len--)
4749 {
4750 if (line_buf[i] == data.separator)
4751 {
4752 pos++;
4753
4754 len--;
4755
4756 break;
4757 }
4758 }
4759
4760 *hashbuf_pos = pos;
4761 *hashbuf_len = len;
4762 }
4763 }
4764
4765 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4766 {
4767 char *pos = NULL;
4768 int len = 0;
4769
4770 int sep_cnt = 0;
4771
4772 for (int i = 0; i < line_len; i++)
4773 {
4774 if (line_buf[i] == data.separator)
4775 {
4776 sep_cnt++;
4777
4778 continue;
4779 }
4780
4781 if (sep_cnt == 0)
4782 {
4783 if (pos == NULL) pos = line_buf + i;
4784
4785 len++;
4786 }
4787 }
4788
4789 *userbuf_pos = pos;
4790 *userbuf_len = len;
4791 }
4792
4793 // hlfmt pwdump
4794
4795 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4796 {
4797 int sep_cnt = 0;
4798
4799 int sep2_len = 0;
4800 int sep3_len = 0;
4801
4802 for (int i = 0; i < line_len; i++)
4803 {
4804 if (line_buf[i] == ':')
4805 {
4806 sep_cnt++;
4807
4808 continue;
4809 }
4810
4811 if (sep_cnt == 2) sep2_len++;
4812 if (sep_cnt == 3) sep3_len++;
4813 }
4814
4815 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4816
4817 return 0;
4818 }
4819
4820 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4821 {
4822 char *pos = NULL;
4823 int len = 0;
4824
4825 int sep_cnt = 0;
4826
4827 for (int i = 0; i < line_len; i++)
4828 {
4829 if (line_buf[i] == ':')
4830 {
4831 sep_cnt++;
4832
4833 continue;
4834 }
4835
4836 if (data.hash_mode == 1000)
4837 {
4838 if (sep_cnt == 3)
4839 {
4840 if (pos == NULL) pos = line_buf + i;
4841
4842 len++;
4843 }
4844 }
4845 else if (data.hash_mode == 3000)
4846 {
4847 if (sep_cnt == 2)
4848 {
4849 if (pos == NULL) pos = line_buf + i;
4850
4851 len++;
4852 }
4853 }
4854 }
4855
4856 *hashbuf_pos = pos;
4857 *hashbuf_len = len;
4858 }
4859
4860 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4861 {
4862 char *pos = NULL;
4863 int len = 0;
4864
4865 int sep_cnt = 0;
4866
4867 for (int i = 0; i < line_len; i++)
4868 {
4869 if (line_buf[i] == ':')
4870 {
4871 sep_cnt++;
4872
4873 continue;
4874 }
4875
4876 if (sep_cnt == 0)
4877 {
4878 if (pos == NULL) pos = line_buf + i;
4879
4880 len++;
4881 }
4882 }
4883
4884 *userbuf_pos = pos;
4885 *userbuf_len = len;
4886 }
4887
4888 // hlfmt passwd
4889
4890 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4891 {
4892 int sep_cnt = 0;
4893
4894 char sep5_first = 0;
4895 char sep6_first = 0;
4896
4897 for (int i = 0; i < line_len; i++)
4898 {
4899 if (line_buf[i] == ':')
4900 {
4901 sep_cnt++;
4902
4903 continue;
4904 }
4905
4906 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4907 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4908 }
4909
4910 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4911
4912 return 0;
4913 }
4914
4915 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4916 {
4917 char *pos = NULL;
4918 int len = 0;
4919
4920 int sep_cnt = 0;
4921
4922 for (int i = 0; i < line_len; i++)
4923 {
4924 if (line_buf[i] == ':')
4925 {
4926 sep_cnt++;
4927
4928 continue;
4929 }
4930
4931 if (sep_cnt == 1)
4932 {
4933 if (pos == NULL) pos = line_buf + i;
4934
4935 len++;
4936 }
4937 }
4938
4939 *hashbuf_pos = pos;
4940 *hashbuf_len = len;
4941 }
4942
4943 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4944 {
4945 char *pos = NULL;
4946 int len = 0;
4947
4948 int sep_cnt = 0;
4949
4950 for (int i = 0; i < line_len; i++)
4951 {
4952 if (line_buf[i] == ':')
4953 {
4954 sep_cnt++;
4955
4956 continue;
4957 }
4958
4959 if (sep_cnt == 0)
4960 {
4961 if (pos == NULL) pos = line_buf + i;
4962
4963 len++;
4964 }
4965 }
4966
4967 *userbuf_pos = pos;
4968 *userbuf_len = len;
4969 }
4970
4971 // hlfmt shadow
4972
4973 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4974 {
4975 int sep_cnt = 0;
4976
4977 for (int i = 0; i < line_len; i++)
4978 {
4979 if (line_buf[i] == ':') sep_cnt++;
4980 }
4981
4982 if (sep_cnt == 8) return 1;
4983
4984 return 0;
4985 }
4986
4987 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4988 {
4989 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4990 }
4991
4992 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4993 {
4994 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4995 }
4996
4997 // hlfmt main
4998
4999 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
5000 {
5001 switch (hashfile_format)
5002 {
5003 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5004 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5005 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5006 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5007 }
5008 }
5009
5010 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
5011 {
5012 switch (hashfile_format)
5013 {
5014 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5015 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5016 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5017 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5018 }
5019 }
5020
5021 static uint hlfmt_detect (FILE *fp, uint max_check)
5022 {
5023 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5024
5025 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5026 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5027
5028 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5029
5030 uint num_check = 0;
5031
5032 while (!feof (fp))
5033 {
5034 char line_buf[BUFSIZ] = { 0 };
5035
5036 int line_len = fgetl (fp, line_buf);
5037
5038 if (line_len == 0) continue;
5039
5040 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5041 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5042 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5043
5044 if (num_check == max_check) break;
5045
5046 num_check++;
5047 }
5048
5049 uint hashlist_format = HLFMT_HASHCAT;
5050
5051 for (int i = 1; i < HLFMTS_CNT; i++)
5052 {
5053 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5054
5055 hashlist_format = i;
5056 }
5057
5058 free (formats_cnt);
5059
5060 return hashlist_format;
5061 }
5062
5063 /**
5064 * some further helper function
5065 */
5066
5067 // wrapper around mymalloc for ADL
5068
5069 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5070 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5071 {
5072 return mymalloc (iSize);
5073 }
5074 #endif
5075
5076 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)
5077 {
5078 u64 collisions = 0;
5079
5080 const uint dgst_pos0 = data.dgst_pos0;
5081 const uint dgst_pos1 = data.dgst_pos1;
5082 const uint dgst_pos2 = data.dgst_pos2;
5083 const uint dgst_pos3 = data.dgst_pos3;
5084
5085 memset (bitmap_a, 0, bitmap_size);
5086 memset (bitmap_b, 0, bitmap_size);
5087 memset (bitmap_c, 0, bitmap_size);
5088 memset (bitmap_d, 0, bitmap_size);
5089
5090 for (uint i = 0; i < digests_cnt; i++)
5091 {
5092 uint *digest_ptr = (uint *) digests_buf_ptr;
5093
5094 digests_buf_ptr += dgst_size;
5095
5096 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5097 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5098 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5099 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5100
5101 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5102 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5103 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5104 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5105
5106 if (bitmap_a[idx0] & val0) collisions++;
5107 if (bitmap_b[idx1] & val1) collisions++;
5108 if (bitmap_c[idx2] & val2) collisions++;
5109 if (bitmap_d[idx3] & val3) collisions++;
5110
5111 bitmap_a[idx0] |= val0;
5112 bitmap_b[idx1] |= val1;
5113 bitmap_c[idx2] |= val2;
5114 bitmap_d[idx3] |= val3;
5115
5116 if (collisions >= collisions_max) return 0x7fffffff;
5117 }
5118
5119 return collisions;
5120 }
5121
5122 /**
5123 * main
5124 */
5125
5126 int main (int argc, char **argv)
5127 {
5128 /**
5129 * To help users a bit
5130 */
5131
5132 char *compute = getenv ("COMPUTE");
5133
5134 if (compute)
5135 {
5136 static char display[100];
5137
5138 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5139
5140 putenv (display);
5141 }
5142 else
5143 {
5144 if (getenv ("DISPLAY") == NULL)
5145 putenv ((char *) "DISPLAY=:0");
5146 }
5147
5148 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5149 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5150
5151 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5152 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5153
5154 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5155 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5156
5157 /**
5158 * Real init
5159 */
5160
5161 memset (&data, 0, sizeof (hc_global_data_t));
5162
5163 time_t proc_start;
5164
5165 time (&proc_start);
5166
5167 data.proc_start = proc_start;
5168
5169 int myargc = argc;
5170 char **myargv = argv;
5171
5172 hc_thread_mutex_init (mux_dispatcher);
5173 hc_thread_mutex_init (mux_counter);
5174 hc_thread_mutex_init (mux_display);
5175 hc_thread_mutex_init (mux_adl);
5176
5177 /**
5178 * commandline parameters
5179 */
5180
5181 uint usage = USAGE;
5182 uint version = VERSION;
5183 uint quiet = QUIET;
5184 uint benchmark = BENCHMARK;
5185 uint benchmark_mode = BENCHMARK_MODE;
5186 uint show = SHOW;
5187 uint left = LEFT;
5188 uint username = USERNAME;
5189 uint remove = REMOVE;
5190 uint remove_timer = REMOVE_TIMER;
5191 u64 skip = SKIP;
5192 u64 limit = LIMIT;
5193 uint keyspace = KEYSPACE;
5194 uint potfile_disable = POTFILE_DISABLE;
5195 uint debug_mode = DEBUG_MODE;
5196 char *debug_file = NULL;
5197 char *induction_dir = NULL;
5198 char *outfile_check_dir = NULL;
5199 uint force = FORCE;
5200 uint runtime = RUNTIME;
5201 uint hash_mode = HASH_MODE;
5202 uint attack_mode = ATTACK_MODE;
5203 uint markov_disable = MARKOV_DISABLE;
5204 uint markov_classic = MARKOV_CLASSIC;
5205 uint markov_threshold = MARKOV_THRESHOLD;
5206 char *markov_hcstat = NULL;
5207 char *outfile = NULL;
5208 uint outfile_format = OUTFILE_FORMAT;
5209 uint outfile_autohex = OUTFILE_AUTOHEX;
5210 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5211 uint restore = RESTORE;
5212 uint restore_timer = RESTORE_TIMER;
5213 uint restore_disable = RESTORE_DISABLE;
5214 uint status = STATUS;
5215 uint status_timer = STATUS_TIMER;
5216 uint status_automat = STATUS_AUTOMAT;
5217 uint loopback = LOOPBACK;
5218 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5219 char *session = NULL;
5220 uint hex_charset = HEX_CHARSET;
5221 uint hex_salt = HEX_SALT;
5222 uint hex_wordlist = HEX_WORDLIST;
5223 uint rp_gen = RP_GEN;
5224 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5225 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5226 uint rp_gen_seed = RP_GEN_SEED;
5227 char *rule_buf_l = (char *) RULE_BUF_L;
5228 char *rule_buf_r = (char *) RULE_BUF_R;
5229 uint increment = INCREMENT;
5230 uint increment_min = INCREMENT_MIN;
5231 uint increment_max = INCREMENT_MAX;
5232 char *cpu_affinity = NULL;
5233 OCL_PTR *ocl = NULL;
5234 char *opencl_devices = NULL;
5235 char *opencl_platforms = NULL;
5236 char *opencl_device_types = NULL;
5237 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5238 char *truecrypt_keyfiles = NULL;
5239 uint workload_profile = WORKLOAD_PROFILE;
5240 uint kernel_accel = KERNEL_ACCEL;
5241 uint kernel_loops = KERNEL_LOOPS;
5242 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5243 #ifdef HAVE_HWMON
5244 uint gpu_temp_abort = GPU_TEMP_ABORT;
5245 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5246 #ifdef HAVE_ADL
5247 uint powertune_enable = POWERTUNE_ENABLE;
5248 #endif
5249 #endif
5250 uint logfile_disable = LOGFILE_DISABLE;
5251 uint segment_size = SEGMENT_SIZE;
5252 uint scrypt_tmto = SCRYPT_TMTO;
5253 char separator = SEPARATOR;
5254 uint bitmap_min = BITMAP_MIN;
5255 uint bitmap_max = BITMAP_MAX;
5256 char *custom_charset_1 = NULL;
5257 char *custom_charset_2 = NULL;
5258 char *custom_charset_3 = NULL;
5259 char *custom_charset_4 = NULL;
5260
5261 #define IDX_HELP 'h'
5262 #define IDX_VERSION 'V'
5263 #define IDX_VERSION_LOWER 'v'
5264 #define IDX_QUIET 0xff02
5265 #define IDX_SHOW 0xff03
5266 #define IDX_LEFT 0xff04
5267 #define IDX_REMOVE 0xff05
5268 #define IDX_REMOVE_TIMER 0xff37
5269 #define IDX_SKIP 's'
5270 #define IDX_LIMIT 'l'
5271 #define IDX_KEYSPACE 0xff35
5272 #define IDX_POTFILE_DISABLE 0xff06
5273 #define IDX_DEBUG_MODE 0xff43
5274 #define IDX_DEBUG_FILE 0xff44
5275 #define IDX_INDUCTION_DIR 0xff46
5276 #define IDX_OUTFILE_CHECK_DIR 0xff47
5277 #define IDX_USERNAME 0xff07
5278 #define IDX_FORCE 0xff08
5279 #define IDX_RUNTIME 0xff09
5280 #define IDX_BENCHMARK 'b'
5281 #define IDX_BENCHMARK_MODE 0xff32
5282 #define IDX_HASH_MODE 'm'
5283 #define IDX_ATTACK_MODE 'a'
5284 #define IDX_RP_FILE 'r'
5285 #define IDX_RP_GEN 'g'
5286 #define IDX_RP_GEN_FUNC_MIN 0xff10
5287 #define IDX_RP_GEN_FUNC_MAX 0xff11
5288 #define IDX_RP_GEN_SEED 0xff34
5289 #define IDX_RULE_BUF_L 'j'
5290 #define IDX_RULE_BUF_R 'k'
5291 #define IDX_INCREMENT 'i'
5292 #define IDX_INCREMENT_MIN 0xff12
5293 #define IDX_INCREMENT_MAX 0xff13
5294 #define IDX_OUTFILE 'o'
5295 #define IDX_OUTFILE_FORMAT 0xff14
5296 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5297 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5298 #define IDX_RESTORE 0xff15
5299 #define IDX_RESTORE_DISABLE 0xff27
5300 #define IDX_STATUS 0xff17
5301 #define IDX_STATUS_TIMER 0xff18
5302 #define IDX_STATUS_AUTOMAT 0xff50
5303 #define IDX_LOOPBACK 0xff38
5304 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5305 #define IDX_SESSION 0xff19
5306 #define IDX_HEX_CHARSET 0xff20
5307 #define IDX_HEX_SALT 0xff21
5308 #define IDX_HEX_WORDLIST 0xff40
5309 #define IDX_MARKOV_DISABLE 0xff22
5310 #define IDX_MARKOV_CLASSIC 0xff23
5311 #define IDX_MARKOV_THRESHOLD 't'
5312 #define IDX_MARKOV_HCSTAT 0xff24
5313 #define IDX_CPU_AFFINITY 0xff25
5314 #define IDX_OPENCL_DEVICES 'd'
5315 #define IDX_OPENCL_PLATFORMS 0xff72
5316 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5317 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5318 #define IDX_WORKLOAD_PROFILE 'w'
5319 #define IDX_KERNEL_ACCEL 'n'
5320 #define IDX_KERNEL_LOOPS 'u'
5321 #define IDX_GPU_TEMP_DISABLE 0xff29
5322 #define IDX_GPU_TEMP_ABORT 0xff30
5323 #define IDX_GPU_TEMP_RETAIN 0xff31
5324 #define IDX_POWERTUNE_ENABLE 0xff41
5325 #define IDX_LOGFILE_DISABLE 0xff51
5326 #define IDX_TRUECRYPT_KEYFILES 0xff52
5327 #define IDX_SCRYPT_TMTO 0xff61
5328 #define IDX_SEGMENT_SIZE 'c'
5329 #define IDX_SEPARATOR 'p'
5330 #define IDX_BITMAP_MIN 0xff70
5331 #define IDX_BITMAP_MAX 0xff71
5332 #define IDX_CUSTOM_CHARSET_1 '1'
5333 #define IDX_CUSTOM_CHARSET_2 '2'
5334 #define IDX_CUSTOM_CHARSET_3 '3'
5335 #define IDX_CUSTOM_CHARSET_4 '4'
5336
5337 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5338
5339 struct option long_options[] =
5340 {
5341 {"help", no_argument, 0, IDX_HELP},
5342 {"version", no_argument, 0, IDX_VERSION},
5343 {"quiet", no_argument, 0, IDX_QUIET},
5344 {"show", no_argument, 0, IDX_SHOW},
5345 {"left", no_argument, 0, IDX_LEFT},
5346 {"username", no_argument, 0, IDX_USERNAME},
5347 {"remove", no_argument, 0, IDX_REMOVE},
5348 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5349 {"skip", required_argument, 0, IDX_SKIP},
5350 {"limit", required_argument, 0, IDX_LIMIT},
5351 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5352 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5353 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5354 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5355 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5356 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5357 {"force", no_argument, 0, IDX_FORCE},
5358 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5359 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5360 {"restore", no_argument, 0, IDX_RESTORE},
5361 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5362 {"status", no_argument, 0, IDX_STATUS},
5363 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5364 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5365 {"loopback", no_argument, 0, IDX_LOOPBACK},
5366 {"weak-hash-threshold",
5367 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5368 {"session", required_argument, 0, IDX_SESSION},
5369 {"runtime", required_argument, 0, IDX_RUNTIME},
5370 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5371 {"generate-rules-func-min",
5372 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5373 {"generate-rules-func-max",
5374 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5375 {"generate-rules-seed",
5376 required_argument, 0, IDX_RP_GEN_SEED},
5377 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5378 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5379 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5380 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5381 {"rules-file", required_argument, 0, IDX_RP_FILE},
5382 {"outfile", required_argument, 0, IDX_OUTFILE},
5383 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5384 {"outfile-autohex-disable",
5385 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5386 {"outfile-check-timer",
5387 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5388 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5389 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5390 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5391 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5392 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5393 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5394 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5395 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5396 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5397 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5398 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5399 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5400 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5401 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5402 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5403 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5404 #ifdef HAVE_HWMON
5405 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5406 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5407 #ifdef HAVE_ADL
5408 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5409 #endif
5410 #endif // HAVE_HWMON
5411 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5412 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5413 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5414 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5415 // deprecated
5416 {"seperator", required_argument, 0, IDX_SEPARATOR},
5417 {"separator", required_argument, 0, IDX_SEPARATOR},
5418 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5419 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5420 {"increment", no_argument, 0, IDX_INCREMENT},
5421 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5422 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5423 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5424 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5425 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5426 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5427
5428 {0, 0, 0, 0}
5429 };
5430
5431 uint rp_files_cnt = 0;
5432
5433 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5434
5435 int option_index = 0;
5436 int c = -1;
5437
5438 optind = 1;
5439 optopt = 0;
5440
5441 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5442 {
5443 switch (c)
5444 {
5445 case IDX_HELP: usage = 1; break;
5446 case IDX_VERSION:
5447 case IDX_VERSION_LOWER: version = 1; break;
5448 case IDX_RESTORE: restore = 1; break;
5449 case IDX_SESSION: session = optarg; break;
5450 case IDX_SHOW: show = 1; break;
5451 case IDX_LEFT: left = 1; break;
5452 case '?': return (-1);
5453 }
5454 }
5455
5456 if (optopt != 0)
5457 {
5458 log_error ("ERROR: Invalid argument specified");
5459
5460 return (-1);
5461 }
5462
5463 /**
5464 * exit functions
5465 */
5466
5467 if (version)
5468 {
5469 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5470
5471 return (0);
5472 }
5473
5474 if (usage)
5475 {
5476 usage_big_print (PROGNAME);
5477
5478 return (0);
5479 }
5480
5481 /**
5482 * session needs to be set, always!
5483 */
5484
5485 if (session == NULL) session = (char *) PROGNAME;
5486
5487 /**
5488 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5489 */
5490
5491 char *exec_path = get_exec_path ();
5492
5493 #ifdef LINUX
5494
5495 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5496 char *resolved_exec_path = realpath (exec_path, NULL);
5497
5498 char *install_dir = get_install_dir (resolved_exec_path);
5499 char *profile_dir = NULL;
5500 char *session_dir = NULL;
5501 char *shared_dir = NULL;
5502
5503 if (strcmp (install_dir, resolved_install_folder) == 0)
5504 {
5505 struct passwd *pw = getpwuid (getuid ());
5506
5507 const char *homedir = pw->pw_dir;
5508
5509 profile_dir = get_profile_dir (homedir);
5510 session_dir = get_session_dir (profile_dir);
5511 shared_dir = strdup (SHARED_FOLDER);
5512
5513 mkdir (profile_dir, 0700);
5514 mkdir (session_dir, 0700);
5515 }
5516 else
5517 {
5518 profile_dir = install_dir;
5519 session_dir = install_dir;
5520 shared_dir = install_dir;
5521 }
5522
5523 myfree (resolved_install_folder);
5524 myfree (resolved_exec_path);
5525
5526 #else
5527
5528 char *install_dir = get_install_dir (exec_path);
5529 char *profile_dir = install_dir;
5530 char *session_dir = install_dir;
5531 char *shared_dir = install_dir;
5532
5533 #endif
5534
5535 data.install_dir = install_dir;
5536 data.profile_dir = profile_dir;
5537 data.session_dir = session_dir;
5538 data.shared_dir = shared_dir;
5539
5540 myfree (exec_path);
5541
5542 /**
5543 * kernel cache, we need to make sure folder exist
5544 */
5545
5546 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5547
5548 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5549
5550 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5551
5552 mkdir (kernels_folder, 0700);
5553
5554 myfree (kernels_folder);
5555
5556 /**
5557 * session
5558 */
5559
5560 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5561
5562 data.session = session;
5563
5564 char *eff_restore_file = (char *) mymalloc (session_size);
5565 char *new_restore_file = (char *) mymalloc (session_size);
5566
5567 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5568 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5569
5570 data.eff_restore_file = eff_restore_file;
5571 data.new_restore_file = new_restore_file;
5572
5573 if (((show == 1) || (left == 1)) && (restore == 1))
5574 {
5575 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5576 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5577
5578 return (-1);
5579 }
5580
5581 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5582 if ((show == 1) || (left == 1))
5583 {
5584 restore_disable = 1;
5585
5586 restore = 0;
5587 }
5588
5589 data.restore_disable = restore_disable;
5590
5591 restore_data_t *rd = init_restore (argc, argv);
5592
5593 data.rd = rd;
5594
5595 /**
5596 * restore file
5597 */
5598
5599 if (restore == 1)
5600 {
5601 read_restore (eff_restore_file, rd);
5602
5603 if (rd->version_bin < RESTORE_MIN)
5604 {
5605 log_error ("ERROR: Incompatible restore-file version");
5606
5607 return (-1);
5608 }
5609
5610 myargc = rd->argc;
5611 myargv = rd->argv;
5612
5613 #ifdef _POSIX
5614 rd->pid = getpid ();
5615 #elif _WIN
5616 rd->pid = GetCurrentProcessId ();
5617 #endif
5618 }
5619
5620 uint hash_mode_chgd = 0;
5621 uint runtime_chgd = 0;
5622 uint kernel_loops_chgd = 0;
5623 uint kernel_accel_chgd = 0;
5624 uint attack_mode_chgd = 0;
5625 uint outfile_format_chgd = 0;
5626 uint rp_gen_seed_chgd = 0;
5627 uint remove_timer_chgd = 0;
5628 uint increment_min_chgd = 0;
5629 uint increment_max_chgd = 0;
5630 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5631 uint gpu_temp_retain_chgd = 0;
5632 uint gpu_temp_abort_chgd = 0;
5633 #endif
5634
5635 optind = 1;
5636 optopt = 0;
5637 option_index = 0;
5638
5639 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5640 {
5641 switch (c)
5642 {
5643 //case IDX_HELP: usage = 1; break;
5644 //case IDX_VERSION: version = 1; break;
5645 //case IDX_RESTORE: restore = 1; break;
5646 case IDX_QUIET: quiet = 1; break;
5647 //case IDX_SHOW: show = 1; break;
5648 case IDX_SHOW: break;
5649 //case IDX_LEFT: left = 1; break;
5650 case IDX_LEFT: break;
5651 case IDX_USERNAME: username = 1; break;
5652 case IDX_REMOVE: remove = 1; break;
5653 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5654 remove_timer_chgd = 1; break;
5655 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5656 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5657 case IDX_DEBUG_FILE: debug_file = optarg; break;
5658 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5659 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5660 case IDX_FORCE: force = 1; break;
5661 case IDX_SKIP: skip = atoll (optarg); break;
5662 case IDX_LIMIT: limit = atoll (optarg); break;
5663 case IDX_KEYSPACE: keyspace = 1; break;
5664 case IDX_BENCHMARK: benchmark = 1; break;
5665 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5666 case IDX_RESTORE: break;
5667 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5668 case IDX_STATUS: status = 1; break;
5669 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5670 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5671 case IDX_LOOPBACK: loopback = 1; break;
5672 case IDX_WEAK_HASH_THRESHOLD:
5673 weak_hash_threshold = atoi (optarg); break;
5674 //case IDX_SESSION: session = optarg; break;
5675 case IDX_SESSION: break;
5676 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5677 hash_mode_chgd = 1; break;
5678 case IDX_RUNTIME: runtime = atoi (optarg);
5679 runtime_chgd = 1; break;
5680 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5681 attack_mode_chgd = 1; break;
5682 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5683 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5684 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5685 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5686 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5687 rp_gen_seed_chgd = 1; break;
5688 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5689 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5690 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5691 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5692 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5693 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5694 case IDX_OUTFILE: outfile = optarg; break;
5695 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5696 outfile_format_chgd = 1; break;
5697 case IDX_OUTFILE_AUTOHEX_DISABLE:
5698 outfile_autohex = 0; break;
5699 case IDX_OUTFILE_CHECK_TIMER:
5700 outfile_check_timer = atoi (optarg); break;
5701 case IDX_HEX_CHARSET: hex_charset = 1; break;
5702 case IDX_HEX_SALT: hex_salt = 1; break;
5703 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5704 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5705 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5706 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5707 case IDX_OPENCL_DEVICE_TYPES:
5708 opencl_device_types = optarg; break;
5709 case IDX_OPENCL_VECTOR_WIDTH:
5710 opencl_vector_width = atoi (optarg); break;
5711 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5712 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5713 kernel_accel_chgd = 1; break;
5714 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5715 kernel_loops_chgd = 1; break;
5716 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5717 #ifdef HAVE_HWMON
5718 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5719 #ifdef HAVE_ADL
5720 gpu_temp_abort_chgd = 1;
5721 #endif
5722 break;
5723 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5724 #ifdef HAVE_ADL
5725 gpu_temp_retain_chgd = 1;
5726 #endif
5727 break;
5728 #ifdef HAVE_ADL
5729 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5730 #endif
5731 #endif // HAVE_HWMON
5732 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5733 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5734 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5735 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5736 case IDX_SEPARATOR: separator = optarg[0]; break;
5737 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5738 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5739 case IDX_INCREMENT: increment = 1; break;
5740 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5741 increment_min_chgd = 1; break;
5742 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5743 increment_max_chgd = 1; break;
5744 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5745 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5746 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5747 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5748
5749 default:
5750 log_error ("ERROR: Invalid argument specified");
5751 return (-1);
5752 }
5753 }
5754
5755 if (optopt != 0)
5756 {
5757 log_error ("ERROR: Invalid argument specified");
5758
5759 return (-1);
5760 }
5761
5762 /**
5763 * Inform user things getting started,
5764 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5765 * - we do not need to check algorithm_pos
5766 */
5767
5768 if (quiet == 0)
5769 {
5770 if (benchmark == 1)
5771 {
5772 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5773
5774 log_info ("");
5775 }
5776 else if (restore == 1)
5777 {
5778 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5779
5780 log_info ("");
5781 }
5782 else
5783 {
5784 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5785
5786 log_info ("");
5787 }
5788 }
5789
5790 /**
5791 * sanity check
5792 */
5793
5794 if (attack_mode > 7)
5795 {
5796 log_error ("ERROR: Invalid attack-mode specified");
5797
5798 return (-1);
5799 }
5800
5801 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5802 {
5803 log_error ("ERROR: Invalid runtime specified");
5804
5805 return (-1);
5806 }
5807
5808 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5809 {
5810 log_error ("ERROR: Invalid hash-type specified");
5811
5812 return (-1);
5813 }
5814
5815 // renamed hash modes
5816
5817 if (hash_mode_chgd)
5818 {
5819 int n = -1;
5820
5821 switch (hash_mode)
5822 {
5823 case 123: n = 124;
5824 break;
5825 }
5826
5827 if (n >= 0)
5828 {
5829 log_error ("Old -m specified, use -m %d instead", n);
5830
5831 return (-1);
5832 }
5833 }
5834
5835 if (username == 1)
5836 {
5837 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5838 {
5839 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5840
5841 return (-1);
5842 }
5843 }
5844
5845 if (outfile_format > 16)
5846 {
5847 log_error ("ERROR: Invalid outfile-format specified");
5848
5849 return (-1);
5850 }
5851
5852 if (left == 1)
5853 {
5854 if (outfile_format_chgd == 1)
5855 {
5856 if (outfile_format > 1)
5857 {
5858 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5859
5860 return (-1);
5861 }
5862 }
5863 else
5864 {
5865 outfile_format = OUTFILE_FMT_HASH;
5866 }
5867 }
5868
5869 if (show == 1)
5870 {
5871 if (outfile_format_chgd == 1)
5872 {
5873 if ((outfile_format > 7) && (outfile_format < 16))
5874 {
5875 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5876
5877 return (-1);
5878 }
5879 }
5880 }
5881
5882 if (increment_min < INCREMENT_MIN)
5883 {
5884 log_error ("ERROR: Invalid increment-min specified");
5885
5886 return (-1);
5887 }
5888
5889 if (increment_max > INCREMENT_MAX)
5890 {
5891 log_error ("ERROR: Invalid increment-max specified");
5892
5893 return (-1);
5894 }
5895
5896 if (increment_min > increment_max)
5897 {
5898 log_error ("ERROR: Invalid increment-min specified");
5899
5900 return (-1);
5901 }
5902
5903 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5904 {
5905 log_error ("ERROR: increment is not allowed in attack-mode 0");
5906
5907 return (-1);
5908 }
5909
5910 if ((increment == 0) && (increment_min_chgd == 1))
5911 {
5912 log_error ("ERROR: increment-min is only supported together with increment switch");
5913
5914 return (-1);
5915 }
5916
5917 if ((increment == 0) && (increment_max_chgd == 1))
5918 {
5919 log_error ("ERROR: increment-max is only supported together with increment switch");
5920
5921 return (-1);
5922 }
5923
5924 if (rp_files_cnt && rp_gen)
5925 {
5926 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5927
5928 return (-1);
5929 }
5930
5931 if (rp_files_cnt || rp_gen)
5932 {
5933 if (attack_mode != ATTACK_MODE_STRAIGHT)
5934 {
5935 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5936
5937 return (-1);
5938 }
5939 }
5940
5941 if (rp_gen_func_min > rp_gen_func_max)
5942 {
5943 log_error ("ERROR: Invalid rp-gen-func-min specified");
5944
5945 return (-1);
5946 }
5947
5948 if (kernel_accel_chgd == 1)
5949 {
5950 if (workload_profile != WORKLOAD_PROFILE)
5951 {
5952 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5953
5954 return (-1);
5955 }
5956
5957 if (kernel_accel < 1)
5958 {
5959 log_error ("ERROR: Invalid kernel-accel specified");
5960
5961 return (-1);
5962 }
5963
5964 if (kernel_accel > 1024)
5965 {
5966 log_error ("ERROR: Invalid kernel-accel specified");
5967
5968 return (-1);
5969 }
5970 }
5971
5972 if (kernel_loops_chgd == 1)
5973 {
5974 if (workload_profile != WORKLOAD_PROFILE)
5975 {
5976 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5977
5978 return (-1);
5979 }
5980
5981 if (kernel_loops < 1)
5982 {
5983 log_error ("ERROR: Invalid kernel-loops specified");
5984
5985 return (-1);
5986 }
5987
5988 if (kernel_loops > 1024)
5989 {
5990 log_error ("ERROR: Invalid kernel-loops specified");
5991
5992 return (-1);
5993 }
5994 }
5995
5996 if (benchmark == 1)
5997 {
5998 if (workload_profile != WORKLOAD_PROFILE)
5999 {
6000 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
6001
6002 return (-1);
6003 }
6004 }
6005
6006 if ((workload_profile < 1) || (workload_profile > 3))
6007 {
6008 log_error ("ERROR: workload-profile %i not available", workload_profile);
6009
6010 return (-1);
6011 }
6012
6013 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
6014 {
6015 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6016
6017 return (-1);
6018 }
6019
6020 if (show == 1 || left == 1)
6021 {
6022 attack_mode = ATTACK_MODE_NONE;
6023
6024 if (remove == 1)
6025 {
6026 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6027
6028 return (-1);
6029 }
6030
6031 if (potfile_disable == 1)
6032 {
6033 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6034
6035 return (-1);
6036 }
6037 }
6038
6039 uint attack_kern = ATTACK_KERN_NONE;
6040
6041 switch (attack_mode)
6042 {
6043 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6044 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6045 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6046 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6047 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6048 }
6049
6050 if (benchmark == 0)
6051 {
6052 if (keyspace == 1)
6053 {
6054 int num_additional_params = 1;
6055
6056 if (attack_kern == ATTACK_KERN_COMBI)
6057 {
6058 num_additional_params = 2;
6059 }
6060
6061 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6062
6063 if (keyspace_wordlist_specified == 0) optind--;
6064 }
6065
6066 if (attack_kern == ATTACK_KERN_NONE)
6067 {
6068 if ((optind + 1) != myargc)
6069 {
6070 usage_mini_print (myargv[0]);
6071
6072 return (-1);
6073 }
6074 }
6075 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6076 {
6077 if ((optind + 1) > myargc)
6078 {
6079 usage_mini_print (myargv[0]);
6080
6081 return (-1);
6082 }
6083 }
6084 else if (attack_kern == ATTACK_KERN_COMBI)
6085 {
6086 if ((optind + 3) != myargc)
6087 {
6088 usage_mini_print (myargv[0]);
6089
6090 return (-1);
6091 }
6092 }
6093 else if (attack_kern == ATTACK_KERN_BF)
6094 {
6095 if ((optind + 1) > myargc)
6096 {
6097 usage_mini_print (myargv[0]);
6098
6099 return (-1);
6100 }
6101 }
6102 else
6103 {
6104 usage_mini_print (myargv[0]);
6105
6106 return (-1);
6107 }
6108 }
6109 else
6110 {
6111 if (myargv[optind] != 0)
6112 {
6113 log_error ("ERROR: Invalid argument for benchmark mode specified");
6114
6115 return (-1);
6116 }
6117
6118 if (attack_mode_chgd == 1)
6119 {
6120 if (attack_mode != ATTACK_MODE_BF)
6121 {
6122 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6123
6124 return (-1);
6125 }
6126 }
6127
6128 if (benchmark_mode == 0)
6129 {
6130 // nothing to do
6131 }
6132 else if (benchmark_mode == 1)
6133 {
6134 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6135 {
6136 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6137
6138 return (-1);
6139 }
6140 }
6141 else
6142 {
6143 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6144
6145 return (-1);
6146 }
6147 }
6148
6149 if (skip != 0 && limit != 0)
6150 {
6151 limit += skip;
6152 }
6153
6154 if (keyspace == 1)
6155 {
6156 if (show == 1)
6157 {
6158 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6159
6160 return (-1);
6161 }
6162 else if (left == 1)
6163 {
6164 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6165
6166 return (-1);
6167 }
6168
6169 potfile_disable = 1;
6170
6171 restore_disable = 1;
6172
6173 restore = 0;
6174
6175 weak_hash_threshold = 0;
6176
6177 quiet = 1;
6178 }
6179
6180 if (remove_timer_chgd == 1)
6181 {
6182 if (remove == 0)
6183 {
6184 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6185
6186 return (-1);
6187 }
6188
6189 if (remove_timer < 1)
6190 {
6191 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6192
6193 return (-1);
6194 }
6195 }
6196
6197 if (loopback == 1)
6198 {
6199 if (attack_mode == ATTACK_MODE_BF)
6200 {
6201 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6202
6203 return (-1);
6204 }
6205 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6206 {
6207 if ((rp_files_cnt == 0) && (rp_gen == 0))
6208 {
6209 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6210
6211 return (-1);
6212 }
6213 }
6214 }
6215
6216 if (debug_mode > 0)
6217 {
6218 if (attack_mode != ATTACK_MODE_STRAIGHT)
6219 {
6220 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6221
6222 return (-1);
6223 }
6224
6225 if ((rp_files_cnt == 0) && (rp_gen == 0))
6226 {
6227 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6228
6229 return (-1);
6230 }
6231 }
6232
6233 if (debug_mode > 4)
6234 {
6235 log_error ("ERROR: Invalid debug-mode specified");
6236
6237 return (-1);
6238 }
6239
6240 if (debug_file != NULL)
6241 {
6242 if (debug_mode < 1)
6243 {
6244 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6245
6246 return (-1);
6247 }
6248 }
6249
6250 if (induction_dir != NULL)
6251 {
6252 if (attack_mode == ATTACK_MODE_BF)
6253 {
6254 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6255
6256 return (-1);
6257 }
6258 }
6259
6260 if (attack_mode != ATTACK_MODE_STRAIGHT)
6261 {
6262 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6263 {
6264 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6265
6266 return (-1);
6267 }
6268
6269 weak_hash_threshold = 0;
6270 }
6271
6272 /**
6273 * induction directory
6274 */
6275
6276 char *induction_directory = NULL;
6277
6278 if (attack_mode != ATTACK_MODE_BF)
6279 {
6280 if (induction_dir == NULL)
6281 {
6282 induction_directory = (char *) mymalloc (session_size);
6283
6284 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6285
6286 // create induction folder if it does not already exist
6287
6288 if (keyspace == 0)
6289 {
6290 if (rmdir (induction_directory) == -1)
6291 {
6292 if (errno == ENOENT)
6293 {
6294 // good, we can ignore
6295 }
6296 else if (errno == ENOTEMPTY)
6297 {
6298 char *induction_directory_mv = (char *) mymalloc (session_size);
6299
6300 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6301
6302 if (rename (induction_directory, induction_directory_mv) != 0)
6303 {
6304 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6305
6306 return (-1);
6307 }
6308 }
6309 else
6310 {
6311 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6312
6313 return (-1);
6314 }
6315 }
6316
6317 if (mkdir (induction_directory, 0700) == -1)
6318 {
6319 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6320
6321 return (-1);
6322 }
6323 }
6324 }
6325 else
6326 {
6327 induction_directory = induction_dir;
6328 }
6329 }
6330
6331 data.induction_directory = induction_directory;
6332
6333 /**
6334 * loopback
6335 */
6336
6337 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6338
6339 char *loopback_file = (char *) mymalloc (loopback_size);
6340
6341 /**
6342 * tuning db
6343 */
6344
6345 char tuning_db_file[256] = { 0 };
6346
6347 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6348
6349 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6350
6351 /**
6352 * outfile-check directory
6353 */
6354
6355 char *outfile_check_directory = NULL;
6356
6357 if (outfile_check_dir == NULL)
6358 {
6359 outfile_check_directory = (char *) mymalloc (session_size);
6360
6361 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6362 }
6363 else
6364 {
6365 outfile_check_directory = outfile_check_dir;
6366 }
6367
6368 data.outfile_check_directory = outfile_check_directory;
6369
6370 if (keyspace == 0)
6371 {
6372 struct stat outfile_check_stat;
6373
6374 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6375 {
6376 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6377
6378 if (is_dir == 0)
6379 {
6380 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6381
6382 return (-1);
6383 }
6384 }
6385 else if (outfile_check_dir == NULL)
6386 {
6387 if (mkdir (outfile_check_directory, 0700) == -1)
6388 {
6389 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6390
6391 return (-1);
6392 }
6393 }
6394 }
6395
6396 /**
6397 * special other stuff
6398 */
6399
6400 if (hash_mode == 9710)
6401 {
6402 outfile_format = 5;
6403 outfile_format_chgd = 1;
6404 }
6405
6406 if (hash_mode == 9810)
6407 {
6408 outfile_format = 5;
6409 outfile_format_chgd = 1;
6410 }
6411
6412 if (hash_mode == 10410)
6413 {
6414 outfile_format = 5;
6415 outfile_format_chgd = 1;
6416 }
6417
6418 /**
6419 * store stuff
6420 */
6421
6422 data.hash_mode = hash_mode;
6423 data.restore = restore;
6424 data.restore_timer = restore_timer;
6425 data.restore_disable = restore_disable;
6426 data.status = status;
6427 data.status_timer = status_timer;
6428 data.status_automat = status_automat;
6429 data.loopback = loopback;
6430 data.runtime = runtime;
6431 data.remove = remove;
6432 data.remove_timer = remove_timer;
6433 data.debug_mode = debug_mode;
6434 data.debug_file = debug_file;
6435 data.username = username;
6436 data.quiet = quiet;
6437 data.outfile = outfile;
6438 data.outfile_format = outfile_format;
6439 data.outfile_autohex = outfile_autohex;
6440 data.hex_charset = hex_charset;
6441 data.hex_salt = hex_salt;
6442 data.hex_wordlist = hex_wordlist;
6443 data.separator = separator;
6444 data.rp_files = rp_files;
6445 data.rp_files_cnt = rp_files_cnt;
6446 data.rp_gen = rp_gen;
6447 data.rp_gen_seed = rp_gen_seed;
6448 data.force = force;
6449 data.benchmark = benchmark;
6450 data.skip = skip;
6451 data.limit = limit;
6452 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6453 data.powertune_enable = powertune_enable;
6454 #endif
6455 data.logfile_disable = logfile_disable;
6456 data.truecrypt_keyfiles = truecrypt_keyfiles;
6457 data.scrypt_tmto = scrypt_tmto;
6458
6459 /**
6460 * cpu affinity
6461 */
6462
6463 if (cpu_affinity)
6464 {
6465 set_cpu_affinity (cpu_affinity);
6466 }
6467
6468 if (rp_gen_seed_chgd == 0)
6469 {
6470 srand (proc_start);
6471 }
6472 else
6473 {
6474 srand (rp_gen_seed);
6475 }
6476
6477 /**
6478 * logfile init
6479 */
6480
6481 if (logfile_disable == 0)
6482 {
6483 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6484
6485 char *logfile = (char *) mymalloc (logfile_size);
6486
6487 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6488
6489 data.logfile = logfile;
6490
6491 char *topid = logfile_generate_topid ();
6492
6493 data.topid = topid;
6494 }
6495
6496 // logfile_append() checks for logfile_disable internally to make it easier from here
6497
6498 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6499 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6500 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6501 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6502 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6503 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6504 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6505 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6506 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6507 #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));
6508
6509 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6510 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6511 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6512 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6513 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6514 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6515 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6516 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6517
6518 logfile_top_msg ("START");
6519
6520 logfile_top_uint (attack_mode);
6521 logfile_top_uint (attack_kern);
6522 logfile_top_uint (benchmark);
6523 logfile_top_uint (benchmark_mode);
6524 logfile_top_uint (bitmap_min);
6525 logfile_top_uint (bitmap_max);
6526 logfile_top_uint (debug_mode);
6527 logfile_top_uint (force);
6528 logfile_top_uint (kernel_accel);
6529 logfile_top_uint (kernel_loops);
6530 logfile_top_uint (gpu_temp_disable);
6531 #ifdef HAVE_HWMON
6532 logfile_top_uint (gpu_temp_abort);
6533 logfile_top_uint (gpu_temp_retain);
6534 #endif
6535 logfile_top_uint (hash_mode);
6536 logfile_top_uint (hex_charset);
6537 logfile_top_uint (hex_salt);
6538 logfile_top_uint (hex_wordlist);
6539 logfile_top_uint (increment);
6540 logfile_top_uint (increment_max);
6541 logfile_top_uint (increment_min);
6542 logfile_top_uint (keyspace);
6543 logfile_top_uint (left);
6544 logfile_top_uint (logfile_disable);
6545 logfile_top_uint (loopback);
6546 logfile_top_uint (markov_classic);
6547 logfile_top_uint (markov_disable);
6548 logfile_top_uint (markov_threshold);
6549 logfile_top_uint (outfile_autohex);
6550 logfile_top_uint (outfile_check_timer);
6551 logfile_top_uint (outfile_format);
6552 logfile_top_uint (potfile_disable);
6553 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6554 logfile_top_uint (powertune_enable);
6555 #endif
6556 logfile_top_uint (scrypt_tmto);
6557 logfile_top_uint (quiet);
6558 logfile_top_uint (remove);
6559 logfile_top_uint (remove_timer);
6560 logfile_top_uint (restore);
6561 logfile_top_uint (restore_disable);
6562 logfile_top_uint (restore_timer);
6563 logfile_top_uint (rp_gen);
6564 logfile_top_uint (rp_gen_func_max);
6565 logfile_top_uint (rp_gen_func_min);
6566 logfile_top_uint (rp_gen_seed);
6567 logfile_top_uint (runtime);
6568 logfile_top_uint (segment_size);
6569 logfile_top_uint (show);
6570 logfile_top_uint (status);
6571 logfile_top_uint (status_automat);
6572 logfile_top_uint (status_timer);
6573 logfile_top_uint (usage);
6574 logfile_top_uint (username);
6575 logfile_top_uint (version);
6576 logfile_top_uint (weak_hash_threshold);
6577 logfile_top_uint (workload_profile);
6578 logfile_top_uint64 (limit);
6579 logfile_top_uint64 (skip);
6580 logfile_top_char (separator);
6581 logfile_top_string (cpu_affinity);
6582 logfile_top_string (custom_charset_1);
6583 logfile_top_string (custom_charset_2);
6584 logfile_top_string (custom_charset_3);
6585 logfile_top_string (custom_charset_4);
6586 logfile_top_string (debug_file);
6587 logfile_top_string (opencl_devices);
6588 logfile_top_string (opencl_platforms);
6589 logfile_top_string (opencl_device_types);
6590 logfile_top_uint (opencl_vector_width);
6591 logfile_top_string (induction_dir);
6592 logfile_top_string (markov_hcstat);
6593 logfile_top_string (outfile);
6594 logfile_top_string (outfile_check_dir);
6595 logfile_top_string (rule_buf_l);
6596 logfile_top_string (rule_buf_r);
6597 logfile_top_string (session);
6598 logfile_top_string (truecrypt_keyfiles);
6599
6600 /**
6601 * Init OpenCL library loader
6602 */
6603
6604 if (keyspace == 0)
6605 {
6606 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6607
6608 ocl_init (ocl);
6609
6610 data.ocl = ocl;
6611 }
6612
6613 /**
6614 * OpenCL platform selection
6615 */
6616
6617 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6618
6619 /**
6620 * OpenCL device selection
6621 */
6622
6623 u32 devices_filter = setup_devices_filter (opencl_devices);
6624
6625 /**
6626 * OpenCL device type selection
6627 */
6628
6629 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6630
6631 /**
6632 * benchmark
6633 */
6634
6635 if (benchmark == 1)
6636 {
6637 /**
6638 * disable useless stuff for benchmark
6639 */
6640
6641 restore_timer = 0;
6642 status_timer = 0;
6643 restore_disable = 1;
6644 potfile_disable = 1;
6645 weak_hash_threshold = 0;
6646
6647 data.restore_timer = restore_timer;
6648 data.status_timer = status_timer;
6649 data.restore_disable = restore_disable;
6650
6651 if (benchmark_mode == 1)
6652 {
6653 markov_disable = 1;
6654
6655 workload_profile = 3;
6656 }
6657
6658 /**
6659 * force attack mode to be bruteforce
6660 */
6661
6662 attack_mode = ATTACK_MODE_BF;
6663 attack_kern = ATTACK_KERN_BF;
6664
6665 if (runtime_chgd == 0)
6666 {
6667 runtime = 8;
6668
6669 if (benchmark_mode == 1) runtime = 17;
6670
6671 data.runtime = runtime;
6672 }
6673 }
6674
6675 /**
6676 * config
6677 */
6678
6679 uint hash_type = 0;
6680 uint salt_type = 0;
6681 uint attack_exec = 0;
6682 uint opts_type = 0;
6683 uint kern_type = 0;
6684 uint dgst_size = 0;
6685 uint esalt_size = 0;
6686 uint opti_type = 0;
6687 uint dgst_pos0 = -1;
6688 uint dgst_pos1 = -1;
6689 uint dgst_pos2 = -1;
6690 uint dgst_pos3 = -1;
6691
6692 int (*parse_func) (char *, uint, hash_t *);
6693 int (*sort_by_digest) (const void *, const void *);
6694
6695 uint algorithm_pos = 0;
6696 uint algorithm_max = 1;
6697
6698 uint *algorithms = default_benchmark_algorithms;
6699
6700 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6701
6702 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6703 {
6704 /*
6705 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6706 * the following algos are skipped entirely
6707 */
6708
6709 if (algorithm_pos > 0)
6710 {
6711 local_free (rd);
6712
6713 rd = init_restore (argc, argv);
6714
6715 data.rd = rd;
6716 }
6717
6718 /**
6719 * update hash_mode in case of multihash benchmark
6720 */
6721
6722 if (benchmark == 1)
6723 {
6724 if (hash_mode_chgd == 0)
6725 {
6726 hash_mode = algorithms[algorithm_pos];
6727
6728 data.hash_mode = hash_mode;
6729 }
6730
6731 quiet = 1;
6732
6733 data.quiet = quiet;
6734 }
6735
6736 switch (hash_mode)
6737 {
6738 case 0: hash_type = HASH_TYPE_MD5;
6739 salt_type = SALT_TYPE_NONE;
6740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6741 opts_type = OPTS_TYPE_PT_GENERATE_LE
6742 | OPTS_TYPE_PT_ADD80
6743 | OPTS_TYPE_PT_ADDBITS14;
6744 kern_type = KERN_TYPE_MD5;
6745 dgst_size = DGST_SIZE_4_4;
6746 parse_func = md5_parse_hash;
6747 sort_by_digest = sort_by_digest_4_4;
6748 opti_type = OPTI_TYPE_ZERO_BYTE
6749 | OPTI_TYPE_PRECOMPUTE_INIT
6750 | OPTI_TYPE_PRECOMPUTE_MERKLE
6751 | OPTI_TYPE_MEET_IN_MIDDLE
6752 | OPTI_TYPE_EARLY_SKIP
6753 | OPTI_TYPE_NOT_ITERATED
6754 | OPTI_TYPE_NOT_SALTED
6755 | OPTI_TYPE_RAW_HASH;
6756 dgst_pos0 = 0;
6757 dgst_pos1 = 3;
6758 dgst_pos2 = 2;
6759 dgst_pos3 = 1;
6760 break;
6761
6762 case 10: hash_type = HASH_TYPE_MD5;
6763 salt_type = SALT_TYPE_INTERN;
6764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6765 opts_type = OPTS_TYPE_PT_GENERATE_LE
6766 | OPTS_TYPE_ST_ADD80
6767 | OPTS_TYPE_ST_ADDBITS14;
6768 kern_type = KERN_TYPE_MD5_PWSLT;
6769 dgst_size = DGST_SIZE_4_4;
6770 parse_func = md5s_parse_hash;
6771 sort_by_digest = sort_by_digest_4_4;
6772 opti_type = OPTI_TYPE_ZERO_BYTE
6773 | OPTI_TYPE_PRECOMPUTE_INIT
6774 | OPTI_TYPE_PRECOMPUTE_MERKLE
6775 | OPTI_TYPE_MEET_IN_MIDDLE
6776 | OPTI_TYPE_EARLY_SKIP
6777 | OPTI_TYPE_NOT_ITERATED
6778 | OPTI_TYPE_APPENDED_SALT
6779 | OPTI_TYPE_RAW_HASH;
6780 dgst_pos0 = 0;
6781 dgst_pos1 = 3;
6782 dgst_pos2 = 2;
6783 dgst_pos3 = 1;
6784 break;
6785
6786 case 11: hash_type = HASH_TYPE_MD5;
6787 salt_type = SALT_TYPE_INTERN;
6788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6789 opts_type = OPTS_TYPE_PT_GENERATE_LE
6790 | OPTS_TYPE_ST_ADD80
6791 | OPTS_TYPE_ST_ADDBITS14;
6792 kern_type = KERN_TYPE_MD5_PWSLT;
6793 dgst_size = DGST_SIZE_4_4;
6794 parse_func = joomla_parse_hash;
6795 sort_by_digest = sort_by_digest_4_4;
6796 opti_type = OPTI_TYPE_ZERO_BYTE
6797 | OPTI_TYPE_PRECOMPUTE_INIT
6798 | OPTI_TYPE_PRECOMPUTE_MERKLE
6799 | OPTI_TYPE_MEET_IN_MIDDLE
6800 | OPTI_TYPE_EARLY_SKIP
6801 | OPTI_TYPE_NOT_ITERATED
6802 | OPTI_TYPE_APPENDED_SALT
6803 | OPTI_TYPE_RAW_HASH;
6804 dgst_pos0 = 0;
6805 dgst_pos1 = 3;
6806 dgst_pos2 = 2;
6807 dgst_pos3 = 1;
6808 break;
6809
6810 case 12: hash_type = HASH_TYPE_MD5;
6811 salt_type = SALT_TYPE_INTERN;
6812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6813 opts_type = OPTS_TYPE_PT_GENERATE_LE
6814 | OPTS_TYPE_ST_ADD80
6815 | OPTS_TYPE_ST_ADDBITS14;
6816 kern_type = KERN_TYPE_MD5_PWSLT;
6817 dgst_size = DGST_SIZE_4_4;
6818 parse_func = postgresql_parse_hash;
6819 sort_by_digest = sort_by_digest_4_4;
6820 opti_type = OPTI_TYPE_ZERO_BYTE
6821 | OPTI_TYPE_PRECOMPUTE_INIT
6822 | OPTI_TYPE_PRECOMPUTE_MERKLE
6823 | OPTI_TYPE_MEET_IN_MIDDLE
6824 | OPTI_TYPE_EARLY_SKIP
6825 | OPTI_TYPE_NOT_ITERATED
6826 | OPTI_TYPE_APPENDED_SALT
6827 | OPTI_TYPE_RAW_HASH;
6828 dgst_pos0 = 0;
6829 dgst_pos1 = 3;
6830 dgst_pos2 = 2;
6831 dgst_pos3 = 1;
6832 break;
6833
6834 case 20: hash_type = HASH_TYPE_MD5;
6835 salt_type = SALT_TYPE_INTERN;
6836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6837 opts_type = OPTS_TYPE_PT_GENERATE_LE
6838 | OPTS_TYPE_PT_ADD80
6839 | OPTS_TYPE_PT_ADDBITS14;
6840 kern_type = KERN_TYPE_MD5_SLTPW;
6841 dgst_size = DGST_SIZE_4_4;
6842 parse_func = md5s_parse_hash;
6843 sort_by_digest = sort_by_digest_4_4;
6844 opti_type = OPTI_TYPE_ZERO_BYTE
6845 | OPTI_TYPE_PRECOMPUTE_INIT
6846 | OPTI_TYPE_PRECOMPUTE_MERKLE
6847 | OPTI_TYPE_EARLY_SKIP
6848 | OPTI_TYPE_NOT_ITERATED
6849 | OPTI_TYPE_PREPENDED_SALT
6850 | OPTI_TYPE_RAW_HASH;
6851 dgst_pos0 = 0;
6852 dgst_pos1 = 3;
6853 dgst_pos2 = 2;
6854 dgst_pos3 = 1;
6855 break;
6856
6857 case 21: hash_type = HASH_TYPE_MD5;
6858 salt_type = SALT_TYPE_INTERN;
6859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6860 opts_type = OPTS_TYPE_PT_GENERATE_LE
6861 | OPTS_TYPE_PT_ADD80
6862 | OPTS_TYPE_PT_ADDBITS14;
6863 kern_type = KERN_TYPE_MD5_SLTPW;
6864 dgst_size = DGST_SIZE_4_4;
6865 parse_func = osc_parse_hash;
6866 sort_by_digest = sort_by_digest_4_4;
6867 opti_type = OPTI_TYPE_ZERO_BYTE
6868 | OPTI_TYPE_PRECOMPUTE_INIT
6869 | OPTI_TYPE_PRECOMPUTE_MERKLE
6870 | OPTI_TYPE_EARLY_SKIP
6871 | OPTI_TYPE_NOT_ITERATED
6872 | OPTI_TYPE_PREPENDED_SALT
6873 | OPTI_TYPE_RAW_HASH;
6874 dgst_pos0 = 0;
6875 dgst_pos1 = 3;
6876 dgst_pos2 = 2;
6877 dgst_pos3 = 1;
6878 break;
6879
6880 case 22: hash_type = HASH_TYPE_MD5;
6881 salt_type = SALT_TYPE_EMBEDDED;
6882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6883 opts_type = OPTS_TYPE_PT_GENERATE_LE
6884 | OPTS_TYPE_PT_ADD80
6885 | OPTS_TYPE_PT_ADDBITS14;
6886 kern_type = KERN_TYPE_MD5_SLTPW;
6887 dgst_size = DGST_SIZE_4_4;
6888 parse_func = netscreen_parse_hash;
6889 sort_by_digest = sort_by_digest_4_4;
6890 opti_type = OPTI_TYPE_ZERO_BYTE
6891 | OPTI_TYPE_PRECOMPUTE_INIT
6892 | OPTI_TYPE_PRECOMPUTE_MERKLE
6893 | OPTI_TYPE_EARLY_SKIP
6894 | OPTI_TYPE_NOT_ITERATED
6895 | OPTI_TYPE_PREPENDED_SALT
6896 | OPTI_TYPE_RAW_HASH;
6897 dgst_pos0 = 0;
6898 dgst_pos1 = 3;
6899 dgst_pos2 = 2;
6900 dgst_pos3 = 1;
6901 break;
6902
6903 case 23: hash_type = HASH_TYPE_MD5;
6904 salt_type = SALT_TYPE_EMBEDDED;
6905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6906 opts_type = OPTS_TYPE_PT_GENERATE_LE
6907 | OPTS_TYPE_PT_ADD80
6908 | OPTS_TYPE_PT_ADDBITS14;
6909 kern_type = KERN_TYPE_MD5_SLTPW;
6910 dgst_size = DGST_SIZE_4_4;
6911 parse_func = skype_parse_hash;
6912 sort_by_digest = sort_by_digest_4_4;
6913 opti_type = OPTI_TYPE_ZERO_BYTE
6914 | OPTI_TYPE_PRECOMPUTE_INIT
6915 | OPTI_TYPE_PRECOMPUTE_MERKLE
6916 | OPTI_TYPE_EARLY_SKIP
6917 | OPTI_TYPE_NOT_ITERATED
6918 | OPTI_TYPE_PREPENDED_SALT
6919 | OPTI_TYPE_RAW_HASH;
6920 dgst_pos0 = 0;
6921 dgst_pos1 = 3;
6922 dgst_pos2 = 2;
6923 dgst_pos3 = 1;
6924 break;
6925
6926 case 30: hash_type = HASH_TYPE_MD5;
6927 salt_type = SALT_TYPE_INTERN;
6928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6929 opts_type = OPTS_TYPE_PT_GENERATE_LE
6930 | OPTS_TYPE_PT_UNICODE
6931 | OPTS_TYPE_ST_ADD80
6932 | OPTS_TYPE_ST_ADDBITS14;
6933 kern_type = KERN_TYPE_MD5_PWUSLT;
6934 dgst_size = DGST_SIZE_4_4;
6935 parse_func = md5s_parse_hash;
6936 sort_by_digest = sort_by_digest_4_4;
6937 opti_type = OPTI_TYPE_ZERO_BYTE
6938 | OPTI_TYPE_PRECOMPUTE_INIT
6939 | OPTI_TYPE_PRECOMPUTE_MERKLE
6940 | OPTI_TYPE_MEET_IN_MIDDLE
6941 | OPTI_TYPE_EARLY_SKIP
6942 | OPTI_TYPE_NOT_ITERATED
6943 | OPTI_TYPE_APPENDED_SALT
6944 | OPTI_TYPE_RAW_HASH;
6945 dgst_pos0 = 0;
6946 dgst_pos1 = 3;
6947 dgst_pos2 = 2;
6948 dgst_pos3 = 1;
6949 break;
6950
6951 case 40: hash_type = HASH_TYPE_MD5;
6952 salt_type = SALT_TYPE_INTERN;
6953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6954 opts_type = OPTS_TYPE_PT_GENERATE_LE
6955 | OPTS_TYPE_PT_ADD80
6956 | OPTS_TYPE_PT_ADDBITS14
6957 | OPTS_TYPE_PT_UNICODE;
6958 kern_type = KERN_TYPE_MD5_SLTPWU;
6959 dgst_size = DGST_SIZE_4_4;
6960 parse_func = md5s_parse_hash;
6961 sort_by_digest = sort_by_digest_4_4;
6962 opti_type = OPTI_TYPE_ZERO_BYTE
6963 | OPTI_TYPE_PRECOMPUTE_INIT
6964 | OPTI_TYPE_PRECOMPUTE_MERKLE
6965 | OPTI_TYPE_EARLY_SKIP
6966 | OPTI_TYPE_NOT_ITERATED
6967 | OPTI_TYPE_PREPENDED_SALT
6968 | OPTI_TYPE_RAW_HASH;
6969 dgst_pos0 = 0;
6970 dgst_pos1 = 3;
6971 dgst_pos2 = 2;
6972 dgst_pos3 = 1;
6973 break;
6974
6975 case 50: hash_type = HASH_TYPE_MD5;
6976 salt_type = SALT_TYPE_INTERN;
6977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6978 opts_type = OPTS_TYPE_PT_GENERATE_LE
6979 | OPTS_TYPE_ST_ADD80
6980 | OPTS_TYPE_ST_ADDBITS14;
6981 kern_type = KERN_TYPE_HMACMD5_PW;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = hmacmd5_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_NOT_ITERATED;
6987 dgst_pos0 = 0;
6988 dgst_pos1 = 3;
6989 dgst_pos2 = 2;
6990 dgst_pos3 = 1;
6991 break;
6992
6993 case 60: hash_type = HASH_TYPE_MD5;
6994 salt_type = SALT_TYPE_INTERN;
6995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6996 opts_type = OPTS_TYPE_PT_GENERATE_LE
6997 | OPTS_TYPE_PT_ADD80
6998 | OPTS_TYPE_PT_ADDBITS14;
6999 kern_type = KERN_TYPE_HMACMD5_SLT;
7000 dgst_size = DGST_SIZE_4_4;
7001 parse_func = hmacmd5_parse_hash;
7002 sort_by_digest = sort_by_digest_4_4;
7003 opti_type = OPTI_TYPE_ZERO_BYTE
7004 | OPTI_TYPE_NOT_ITERATED;
7005 dgst_pos0 = 0;
7006 dgst_pos1 = 3;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 100: hash_type = HASH_TYPE_SHA1;
7012 salt_type = SALT_TYPE_NONE;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_BE
7015 | OPTS_TYPE_PT_ADD80
7016 | OPTS_TYPE_PT_ADDBITS15;
7017 kern_type = KERN_TYPE_SHA1;
7018 dgst_size = DGST_SIZE_4_5;
7019 parse_func = sha1_parse_hash;
7020 sort_by_digest = sort_by_digest_4_5;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_EARLY_SKIP
7025 | OPTI_TYPE_NOT_ITERATED
7026 | OPTI_TYPE_NOT_SALTED
7027 | OPTI_TYPE_RAW_HASH;
7028 dgst_pos0 = 3;
7029 dgst_pos1 = 4;
7030 dgst_pos2 = 2;
7031 dgst_pos3 = 1;
7032 break;
7033
7034 case 101: hash_type = HASH_TYPE_SHA1;
7035 salt_type = SALT_TYPE_NONE;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_BE
7038 | OPTS_TYPE_PT_ADD80
7039 | OPTS_TYPE_PT_ADDBITS15;
7040 kern_type = KERN_TYPE_SHA1;
7041 dgst_size = DGST_SIZE_4_5;
7042 parse_func = sha1b64_parse_hash;
7043 sort_by_digest = sort_by_digest_4_5;
7044 opti_type = OPTI_TYPE_ZERO_BYTE
7045 | OPTI_TYPE_PRECOMPUTE_INIT
7046 | OPTI_TYPE_PRECOMPUTE_MERKLE
7047 | OPTI_TYPE_EARLY_SKIP
7048 | OPTI_TYPE_NOT_ITERATED
7049 | OPTI_TYPE_NOT_SALTED
7050 | OPTI_TYPE_RAW_HASH;
7051 dgst_pos0 = 3;
7052 dgst_pos1 = 4;
7053 dgst_pos2 = 2;
7054 dgst_pos3 = 1;
7055 break;
7056
7057 case 110: hash_type = HASH_TYPE_SHA1;
7058 salt_type = SALT_TYPE_INTERN;
7059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7060 opts_type = OPTS_TYPE_PT_GENERATE_BE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS15;
7063 kern_type = KERN_TYPE_SHA1_PWSLT;
7064 dgst_size = DGST_SIZE_4_5;
7065 parse_func = sha1s_parse_hash;
7066 sort_by_digest = sort_by_digest_4_5;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_EARLY_SKIP
7071 | OPTI_TYPE_NOT_ITERATED
7072 | OPTI_TYPE_APPENDED_SALT
7073 | OPTI_TYPE_RAW_HASH;
7074 dgst_pos0 = 3;
7075 dgst_pos1 = 4;
7076 dgst_pos2 = 2;
7077 dgst_pos3 = 1;
7078 break;
7079
7080 case 111: hash_type = HASH_TYPE_SHA1;
7081 salt_type = SALT_TYPE_EMBEDDED;
7082 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7083 opts_type = OPTS_TYPE_PT_GENERATE_BE
7084 | OPTS_TYPE_ST_ADD80
7085 | OPTS_TYPE_ST_ADDBITS15;
7086 kern_type = KERN_TYPE_SHA1_PWSLT;
7087 dgst_size = DGST_SIZE_4_5;
7088 parse_func = sha1b64s_parse_hash;
7089 sort_by_digest = sort_by_digest_4_5;
7090 opti_type = OPTI_TYPE_ZERO_BYTE
7091 | OPTI_TYPE_PRECOMPUTE_INIT
7092 | OPTI_TYPE_PRECOMPUTE_MERKLE
7093 | OPTI_TYPE_EARLY_SKIP
7094 | OPTI_TYPE_NOT_ITERATED
7095 | OPTI_TYPE_APPENDED_SALT
7096 | OPTI_TYPE_RAW_HASH;
7097 dgst_pos0 = 3;
7098 dgst_pos1 = 4;
7099 dgst_pos2 = 2;
7100 dgst_pos3 = 1;
7101 break;
7102
7103 case 112: hash_type = HASH_TYPE_SHA1;
7104 salt_type = SALT_TYPE_INTERN;
7105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7106 opts_type = OPTS_TYPE_PT_GENERATE_BE
7107 | OPTS_TYPE_ST_ADD80
7108 | OPTS_TYPE_ST_ADDBITS15
7109 | OPTS_TYPE_ST_HEX;
7110 kern_type = KERN_TYPE_SHA1_PWSLT;
7111 dgst_size = DGST_SIZE_4_5;
7112 parse_func = oracles_parse_hash;
7113 sort_by_digest = sort_by_digest_4_5;
7114 opti_type = OPTI_TYPE_ZERO_BYTE
7115 | OPTI_TYPE_PRECOMPUTE_INIT
7116 | OPTI_TYPE_PRECOMPUTE_MERKLE
7117 | OPTI_TYPE_EARLY_SKIP
7118 | OPTI_TYPE_NOT_ITERATED
7119 | OPTI_TYPE_APPENDED_SALT
7120 | OPTI_TYPE_RAW_HASH;
7121 dgst_pos0 = 3;
7122 dgst_pos1 = 4;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 120: hash_type = HASH_TYPE_SHA1;
7128 salt_type = SALT_TYPE_INTERN;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_BE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS15;
7133 kern_type = KERN_TYPE_SHA1_SLTPW;
7134 dgst_size = DGST_SIZE_4_5;
7135 parse_func = sha1s_parse_hash;
7136 sort_by_digest = sort_by_digest_4_5;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_PRECOMPUTE_INIT
7139 | OPTI_TYPE_PRECOMPUTE_MERKLE
7140 | OPTI_TYPE_EARLY_SKIP
7141 | OPTI_TYPE_NOT_ITERATED
7142 | OPTI_TYPE_PREPENDED_SALT
7143 | OPTI_TYPE_RAW_HASH;
7144 dgst_pos0 = 3;
7145 dgst_pos1 = 4;
7146 dgst_pos2 = 2;
7147 dgst_pos3 = 1;
7148 break;
7149
7150 case 121: hash_type = HASH_TYPE_SHA1;
7151 salt_type = SALT_TYPE_INTERN;
7152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7153 opts_type = OPTS_TYPE_PT_GENERATE_BE
7154 | OPTS_TYPE_PT_ADD80
7155 | OPTS_TYPE_PT_ADDBITS15
7156 | OPTS_TYPE_ST_LOWER;
7157 kern_type = KERN_TYPE_SHA1_SLTPW;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = smf_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_PREPENDED_SALT
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 122: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_EMBEDDED;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_PT_ADD80
7179 | OPTS_TYPE_PT_ADDBITS15
7180 | OPTS_TYPE_ST_HEX;
7181 kern_type = KERN_TYPE_SHA1_SLTPW;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = osx1_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 124: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_EMBEDDED;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS15;
7204 kern_type = KERN_TYPE_SHA1_SLTPW;
7205 dgst_size = DGST_SIZE_4_5;
7206 parse_func = djangosha1_parse_hash;
7207 sort_by_digest = sort_by_digest_4_5;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_PREPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 3;
7216 dgst_pos1 = 4;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 130: hash_type = HASH_TYPE_SHA1;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_BE
7225 | OPTS_TYPE_PT_UNICODE
7226 | OPTS_TYPE_ST_ADD80
7227 | OPTS_TYPE_ST_ADDBITS15;
7228 kern_type = KERN_TYPE_SHA1_PWUSLT;
7229 dgst_size = DGST_SIZE_4_5;
7230 parse_func = sha1s_parse_hash;
7231 sort_by_digest = sort_by_digest_4_5;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_APPENDED_SALT
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 3;
7240 dgst_pos1 = 4;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 1;
7243 break;
7244
7245 case 131: hash_type = HASH_TYPE_SHA1;
7246 salt_type = SALT_TYPE_EMBEDDED;
7247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7248 opts_type = OPTS_TYPE_PT_GENERATE_BE
7249 | OPTS_TYPE_PT_UNICODE
7250 | OPTS_TYPE_PT_UPPER
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS15
7253 | OPTS_TYPE_ST_HEX;
7254 kern_type = KERN_TYPE_SHA1_PWUSLT;
7255 dgst_size = DGST_SIZE_4_5;
7256 parse_func = mssql2000_parse_hash;
7257 sort_by_digest = sort_by_digest_4_5;
7258 opti_type = OPTI_TYPE_ZERO_BYTE
7259 | OPTI_TYPE_PRECOMPUTE_INIT
7260 | OPTI_TYPE_PRECOMPUTE_MERKLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_APPENDED_SALT
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 3;
7266 dgst_pos1 = 4;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 132: hash_type = HASH_TYPE_SHA1;
7272 salt_type = SALT_TYPE_EMBEDDED;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_BE
7275 | OPTS_TYPE_PT_UNICODE
7276 | OPTS_TYPE_ST_ADD80
7277 | OPTS_TYPE_ST_ADDBITS15
7278 | OPTS_TYPE_ST_HEX;
7279 kern_type = KERN_TYPE_SHA1_PWUSLT;
7280 dgst_size = DGST_SIZE_4_5;
7281 parse_func = mssql2005_parse_hash;
7282 sort_by_digest = sort_by_digest_4_5;
7283 opti_type = OPTI_TYPE_ZERO_BYTE
7284 | OPTI_TYPE_PRECOMPUTE_INIT
7285 | OPTI_TYPE_PRECOMPUTE_MERKLE
7286 | OPTI_TYPE_EARLY_SKIP
7287 | OPTI_TYPE_NOT_ITERATED
7288 | OPTI_TYPE_APPENDED_SALT
7289 | OPTI_TYPE_RAW_HASH;
7290 dgst_pos0 = 3;
7291 dgst_pos1 = 4;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 133: hash_type = HASH_TYPE_SHA1;
7297 salt_type = SALT_TYPE_EMBEDDED;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_BE
7300 | OPTS_TYPE_PT_UNICODE
7301 | OPTS_TYPE_ST_ADD80
7302 | OPTS_TYPE_ST_ADDBITS15;
7303 kern_type = KERN_TYPE_SHA1_PWUSLT;
7304 dgst_size = DGST_SIZE_4_5;
7305 parse_func = peoplesoft_parse_hash;
7306 sort_by_digest = sort_by_digest_4_5;
7307 opti_type = OPTI_TYPE_ZERO_BYTE
7308 | OPTI_TYPE_PRECOMPUTE_INIT
7309 | OPTI_TYPE_PRECOMPUTE_MERKLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_APPENDED_SALT
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 3;
7315 dgst_pos1 = 4;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 140: hash_type = HASH_TYPE_SHA1;
7321 salt_type = SALT_TYPE_INTERN;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_BE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS15
7326 | OPTS_TYPE_PT_UNICODE;
7327 kern_type = KERN_TYPE_SHA1_SLTPWU;
7328 dgst_size = DGST_SIZE_4_5;
7329 parse_func = sha1s_parse_hash;
7330 sort_by_digest = sort_by_digest_4_5;
7331 opti_type = OPTI_TYPE_ZERO_BYTE
7332 | OPTI_TYPE_PRECOMPUTE_INIT
7333 | OPTI_TYPE_PRECOMPUTE_MERKLE
7334 | OPTI_TYPE_EARLY_SKIP
7335 | OPTI_TYPE_NOT_ITERATED
7336 | OPTI_TYPE_PREPENDED_SALT
7337 | OPTI_TYPE_RAW_HASH;
7338 dgst_pos0 = 3;
7339 dgst_pos1 = 4;
7340 dgst_pos2 = 2;
7341 dgst_pos3 = 1;
7342 break;
7343
7344 case 141: hash_type = HASH_TYPE_SHA1;
7345 salt_type = SALT_TYPE_EMBEDDED;
7346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7347 opts_type = OPTS_TYPE_PT_GENERATE_BE
7348 | OPTS_TYPE_PT_ADD80
7349 | OPTS_TYPE_PT_ADDBITS15
7350 | OPTS_TYPE_PT_UNICODE
7351 | OPTS_TYPE_ST_BASE64;
7352 kern_type = KERN_TYPE_SHA1_SLTPWU;
7353 dgst_size = DGST_SIZE_4_5;
7354 parse_func = episerver_parse_hash;
7355 sort_by_digest = sort_by_digest_4_5;
7356 opti_type = OPTI_TYPE_ZERO_BYTE
7357 | OPTI_TYPE_PRECOMPUTE_INIT
7358 | OPTI_TYPE_PRECOMPUTE_MERKLE
7359 | OPTI_TYPE_EARLY_SKIP
7360 | OPTI_TYPE_NOT_ITERATED
7361 | OPTI_TYPE_PREPENDED_SALT
7362 | OPTI_TYPE_RAW_HASH;
7363 dgst_pos0 = 3;
7364 dgst_pos1 = 4;
7365 dgst_pos2 = 2;
7366 dgst_pos3 = 1;
7367 break;
7368
7369 case 150: hash_type = HASH_TYPE_SHA1;
7370 salt_type = SALT_TYPE_INTERN;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = OPTS_TYPE_PT_GENERATE_BE
7373 | OPTS_TYPE_ST_ADD80
7374 | OPTS_TYPE_ST_ADDBITS15;
7375 kern_type = KERN_TYPE_HMACSHA1_PW;
7376 dgst_size = DGST_SIZE_4_5;
7377 parse_func = hmacsha1_parse_hash;
7378 sort_by_digest = sort_by_digest_4_5;
7379 opti_type = OPTI_TYPE_ZERO_BYTE
7380 | OPTI_TYPE_NOT_ITERATED;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 4;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 160: hash_type = HASH_TYPE_SHA1;
7388 salt_type = SALT_TYPE_INTERN;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_PT_ADD80
7392 | OPTS_TYPE_PT_ADDBITS15;
7393 kern_type = KERN_TYPE_HMACSHA1_SLT;
7394 dgst_size = DGST_SIZE_4_5;
7395 parse_func = hmacsha1_parse_hash;
7396 sort_by_digest = sort_by_digest_4_5;
7397 opti_type = OPTI_TYPE_ZERO_BYTE
7398 | OPTI_TYPE_NOT_ITERATED;
7399 dgst_pos0 = 3;
7400 dgst_pos1 = 4;
7401 dgst_pos2 = 2;
7402 dgst_pos3 = 1;
7403 break;
7404
7405 case 190: hash_type = HASH_TYPE_SHA1;
7406 salt_type = SALT_TYPE_NONE;
7407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7408 opts_type = OPTS_TYPE_PT_GENERATE_BE
7409 | OPTS_TYPE_PT_ADD80
7410 | OPTS_TYPE_PT_ADDBITS15;
7411 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7412 dgst_size = DGST_SIZE_4_5;
7413 parse_func = sha1linkedin_parse_hash;
7414 sort_by_digest = sort_by_digest_4_5;
7415 opti_type = OPTI_TYPE_ZERO_BYTE
7416 | OPTI_TYPE_PRECOMPUTE_INIT
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_NOT_SALTED;
7420 dgst_pos0 = 0;
7421 dgst_pos1 = 4;
7422 dgst_pos2 = 3;
7423 dgst_pos3 = 2;
7424 break;
7425
7426 case 200: hash_type = HASH_TYPE_MYSQL;
7427 salt_type = SALT_TYPE_NONE;
7428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7429 opts_type = 0;
7430 kern_type = KERN_TYPE_MYSQL;
7431 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7432 parse_func = mysql323_parse_hash;
7433 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7434 opti_type = OPTI_TYPE_ZERO_BYTE;
7435 dgst_pos0 = 0;
7436 dgst_pos1 = 1;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 3;
7439 break;
7440
7441 case 300: hash_type = HASH_TYPE_SHA1;
7442 salt_type = SALT_TYPE_NONE;
7443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7444 opts_type = OPTS_TYPE_PT_GENERATE_BE
7445 | OPTS_TYPE_PT_ADD80
7446 | OPTS_TYPE_PT_ADDBITS15;
7447 kern_type = KERN_TYPE_MYSQL41;
7448 dgst_size = DGST_SIZE_4_5;
7449 parse_func = sha1_parse_hash;
7450 sort_by_digest = sort_by_digest_4_5;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_NOT_SALTED;
7457 dgst_pos0 = 3;
7458 dgst_pos1 = 4;
7459 dgst_pos2 = 2;
7460 dgst_pos3 = 1;
7461 break;
7462
7463 case 400: hash_type = HASH_TYPE_MD5;
7464 salt_type = SALT_TYPE_EMBEDDED;
7465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7467 kern_type = KERN_TYPE_PHPASS;
7468 dgst_size = DGST_SIZE_4_4;
7469 parse_func = phpass_parse_hash;
7470 sort_by_digest = sort_by_digest_4_4;
7471 opti_type = OPTI_TYPE_ZERO_BYTE;
7472 dgst_pos0 = 0;
7473 dgst_pos1 = 1;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 3;
7476 break;
7477
7478 case 500: hash_type = HASH_TYPE_MD5;
7479 salt_type = SALT_TYPE_EMBEDDED;
7480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7482 kern_type = KERN_TYPE_MD5CRYPT;
7483 dgst_size = DGST_SIZE_4_4;
7484 parse_func = md5crypt_parse_hash;
7485 sort_by_digest = sort_by_digest_4_4;
7486 opti_type = OPTI_TYPE_ZERO_BYTE;
7487 dgst_pos0 = 0;
7488 dgst_pos1 = 1;
7489 dgst_pos2 = 2;
7490 dgst_pos3 = 3;
7491 break;
7492
7493 case 501: hash_type = HASH_TYPE_MD5;
7494 salt_type = SALT_TYPE_EMBEDDED;
7495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_LE
7497 | OPTS_TYPE_HASH_COPY;
7498 kern_type = KERN_TYPE_MD5CRYPT;
7499 dgst_size = DGST_SIZE_4_4;
7500 parse_func = juniper_parse_hash;
7501 sort_by_digest = sort_by_digest_4_4;
7502 opti_type = OPTI_TYPE_ZERO_BYTE;
7503 dgst_pos0 = 0;
7504 dgst_pos1 = 1;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 3;
7507 break;
7508
7509 case 900: hash_type = HASH_TYPE_MD4;
7510 salt_type = SALT_TYPE_NONE;
7511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7512 opts_type = OPTS_TYPE_PT_GENERATE_LE
7513 | OPTS_TYPE_PT_ADD80
7514 | OPTS_TYPE_PT_ADDBITS14;
7515 kern_type = KERN_TYPE_MD4;
7516 dgst_size = DGST_SIZE_4_4;
7517 parse_func = md4_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_MEET_IN_MIDDLE
7523 | OPTI_TYPE_EARLY_SKIP
7524 | OPTI_TYPE_NOT_ITERATED
7525 | OPTI_TYPE_NOT_SALTED
7526 | OPTI_TYPE_RAW_HASH;
7527 dgst_pos0 = 0;
7528 dgst_pos1 = 3;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 1;
7531 break;
7532
7533 case 1000: hash_type = HASH_TYPE_MD4;
7534 salt_type = SALT_TYPE_NONE;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_LE
7537 | OPTS_TYPE_PT_ADD80
7538 | OPTS_TYPE_PT_ADDBITS14
7539 | OPTS_TYPE_PT_UNICODE;
7540 kern_type = KERN_TYPE_MD4_PWU;
7541 dgst_size = DGST_SIZE_4_4;
7542 parse_func = md4_parse_hash;
7543 sort_by_digest = sort_by_digest_4_4;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_MEET_IN_MIDDLE
7548 | OPTI_TYPE_EARLY_SKIP
7549 | OPTI_TYPE_NOT_ITERATED
7550 | OPTI_TYPE_NOT_SALTED
7551 | OPTI_TYPE_RAW_HASH;
7552 dgst_pos0 = 0;
7553 dgst_pos1 = 3;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 1;
7556 break;
7557
7558 case 1100: hash_type = HASH_TYPE_MD4;
7559 salt_type = SALT_TYPE_INTERN;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_LE
7562 | OPTS_TYPE_PT_ADD80
7563 | OPTS_TYPE_PT_ADDBITS14
7564 | OPTS_TYPE_PT_UNICODE
7565 | OPTS_TYPE_ST_ADD80
7566 | OPTS_TYPE_ST_UNICODE
7567 | OPTS_TYPE_ST_LOWER;
7568 kern_type = KERN_TYPE_MD44_PWUSLT;
7569 dgst_size = DGST_SIZE_4_4;
7570 parse_func = dcc_parse_hash;
7571 sort_by_digest = sort_by_digest_4_4;
7572 opti_type = OPTI_TYPE_ZERO_BYTE
7573 | OPTI_TYPE_PRECOMPUTE_INIT
7574 | OPTI_TYPE_PRECOMPUTE_MERKLE
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED;
7577 dgst_pos0 = 0;
7578 dgst_pos1 = 3;
7579 dgst_pos2 = 2;
7580 dgst_pos3 = 1;
7581 break;
7582
7583 case 1400: hash_type = HASH_TYPE_SHA256;
7584 salt_type = SALT_TYPE_NONE;
7585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7586 opts_type = OPTS_TYPE_PT_GENERATE_BE
7587 | OPTS_TYPE_PT_ADD80
7588 | OPTS_TYPE_PT_ADDBITS15;
7589 kern_type = KERN_TYPE_SHA256;
7590 dgst_size = DGST_SIZE_4_8;
7591 parse_func = sha256_parse_hash;
7592 sort_by_digest = sort_by_digest_4_8;
7593 opti_type = OPTI_TYPE_ZERO_BYTE
7594 | OPTI_TYPE_PRECOMPUTE_INIT
7595 | OPTI_TYPE_PRECOMPUTE_MERKLE
7596 | OPTI_TYPE_EARLY_SKIP
7597 | OPTI_TYPE_NOT_ITERATED
7598 | OPTI_TYPE_NOT_SALTED
7599 | OPTI_TYPE_RAW_HASH;
7600 dgst_pos0 = 3;
7601 dgst_pos1 = 7;
7602 dgst_pos2 = 2;
7603 dgst_pos3 = 6;
7604 break;
7605
7606 case 1410: hash_type = HASH_TYPE_SHA256;
7607 salt_type = SALT_TYPE_INTERN;
7608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7609 opts_type = OPTS_TYPE_PT_GENERATE_BE
7610 | OPTS_TYPE_ST_ADD80
7611 | OPTS_TYPE_ST_ADDBITS15;
7612 kern_type = KERN_TYPE_SHA256_PWSLT;
7613 dgst_size = DGST_SIZE_4_8;
7614 parse_func = sha256s_parse_hash;
7615 sort_by_digest = sort_by_digest_4_8;
7616 opti_type = OPTI_TYPE_ZERO_BYTE
7617 | OPTI_TYPE_PRECOMPUTE_INIT
7618 | OPTI_TYPE_PRECOMPUTE_MERKLE
7619 | OPTI_TYPE_EARLY_SKIP
7620 | OPTI_TYPE_NOT_ITERATED
7621 | OPTI_TYPE_APPENDED_SALT
7622 | OPTI_TYPE_RAW_HASH;
7623 dgst_pos0 = 3;
7624 dgst_pos1 = 7;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 6;
7627 break;
7628
7629 case 1420: hash_type = HASH_TYPE_SHA256;
7630 salt_type = SALT_TYPE_INTERN;
7631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_BE
7633 | OPTS_TYPE_PT_ADD80
7634 | OPTS_TYPE_PT_ADDBITS15;
7635 kern_type = KERN_TYPE_SHA256_SLTPW;
7636 dgst_size = DGST_SIZE_4_8;
7637 parse_func = sha256s_parse_hash;
7638 sort_by_digest = sort_by_digest_4_8;
7639 opti_type = OPTI_TYPE_ZERO_BYTE
7640 | OPTI_TYPE_PRECOMPUTE_INIT
7641 | OPTI_TYPE_PRECOMPUTE_MERKLE
7642 | OPTI_TYPE_EARLY_SKIP
7643 | OPTI_TYPE_NOT_ITERATED
7644 | OPTI_TYPE_PREPENDED_SALT
7645 | OPTI_TYPE_RAW_HASH;
7646 dgst_pos0 = 3;
7647 dgst_pos1 = 7;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 6;
7650 break;
7651
7652 case 1421: hash_type = HASH_TYPE_SHA256;
7653 salt_type = SALT_TYPE_EMBEDDED;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_BE
7656 | OPTS_TYPE_PT_ADD80
7657 | OPTS_TYPE_PT_ADDBITS15;
7658 kern_type = KERN_TYPE_SHA256_SLTPW;
7659 dgst_size = DGST_SIZE_4_8;
7660 parse_func = hmailserver_parse_hash;
7661 sort_by_digest = sort_by_digest_4_8;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_EARLY_SKIP
7666 | OPTI_TYPE_NOT_ITERATED
7667 | OPTI_TYPE_PREPENDED_SALT
7668 | OPTI_TYPE_RAW_HASH;
7669 dgst_pos0 = 3;
7670 dgst_pos1 = 7;
7671 dgst_pos2 = 2;
7672 dgst_pos3 = 6;
7673 break;
7674
7675 case 1430: hash_type = HASH_TYPE_SHA256;
7676 salt_type = SALT_TYPE_INTERN;
7677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7678 opts_type = OPTS_TYPE_PT_GENERATE_BE
7679 | OPTS_TYPE_PT_UNICODE
7680 | OPTS_TYPE_ST_ADD80
7681 | OPTS_TYPE_ST_ADDBITS15;
7682 kern_type = KERN_TYPE_SHA256_PWUSLT;
7683 dgst_size = DGST_SIZE_4_8;
7684 parse_func = sha256s_parse_hash;
7685 sort_by_digest = sort_by_digest_4_8;
7686 opti_type = OPTI_TYPE_ZERO_BYTE
7687 | OPTI_TYPE_PRECOMPUTE_INIT
7688 | OPTI_TYPE_PRECOMPUTE_MERKLE
7689 | OPTI_TYPE_EARLY_SKIP
7690 | OPTI_TYPE_NOT_ITERATED
7691 | OPTI_TYPE_APPENDED_SALT
7692 | OPTI_TYPE_RAW_HASH;
7693 dgst_pos0 = 3;
7694 dgst_pos1 = 7;
7695 dgst_pos2 = 2;
7696 dgst_pos3 = 6;
7697 break;
7698
7699 case 1440: hash_type = HASH_TYPE_SHA256;
7700 salt_type = SALT_TYPE_INTERN;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = OPTS_TYPE_PT_GENERATE_BE
7703 | OPTS_TYPE_PT_ADD80
7704 | OPTS_TYPE_PT_ADDBITS15
7705 | OPTS_TYPE_PT_UNICODE;
7706 kern_type = KERN_TYPE_SHA256_SLTPWU;
7707 dgst_size = DGST_SIZE_4_8;
7708 parse_func = sha256s_parse_hash;
7709 sort_by_digest = sort_by_digest_4_8;
7710 opti_type = OPTI_TYPE_ZERO_BYTE
7711 | OPTI_TYPE_PRECOMPUTE_INIT
7712 | OPTI_TYPE_PRECOMPUTE_MERKLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_PREPENDED_SALT
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 3;
7718 dgst_pos1 = 7;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 6;
7721 break;
7722
7723 case 1441: hash_type = HASH_TYPE_SHA256;
7724 salt_type = SALT_TYPE_EMBEDDED;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_BE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS15
7729 | OPTS_TYPE_PT_UNICODE
7730 | OPTS_TYPE_ST_BASE64;
7731 kern_type = KERN_TYPE_SHA256_SLTPWU;
7732 dgst_size = DGST_SIZE_4_8;
7733 parse_func = episerver4_parse_hash;
7734 sort_by_digest = sort_by_digest_4_8;
7735 opti_type = OPTI_TYPE_ZERO_BYTE
7736 | OPTI_TYPE_PRECOMPUTE_INIT
7737 | OPTI_TYPE_PRECOMPUTE_MERKLE
7738 | OPTI_TYPE_EARLY_SKIP
7739 | OPTI_TYPE_NOT_ITERATED
7740 | OPTI_TYPE_PREPENDED_SALT
7741 | OPTI_TYPE_RAW_HASH;
7742 dgst_pos0 = 3;
7743 dgst_pos1 = 7;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 6;
7746 break;
7747
7748 case 1450: hash_type = HASH_TYPE_SHA256;
7749 salt_type = SALT_TYPE_INTERN;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_BE
7752 | OPTS_TYPE_ST_ADD80;
7753 kern_type = KERN_TYPE_HMACSHA256_PW;
7754 dgst_size = DGST_SIZE_4_8;
7755 parse_func = hmacsha256_parse_hash;
7756 sort_by_digest = sort_by_digest_4_8;
7757 opti_type = OPTI_TYPE_ZERO_BYTE
7758 | OPTI_TYPE_NOT_ITERATED;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1460: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15;
7771 kern_type = KERN_TYPE_HMACSHA256_SLT;
7772 dgst_size = DGST_SIZE_4_8;
7773 parse_func = hmacsha256_parse_hash;
7774 sort_by_digest = sort_by_digest_4_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_NOT_ITERATED;
7777 dgst_pos0 = 3;
7778 dgst_pos1 = 7;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 6;
7781 break;
7782
7783 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7784 salt_type = SALT_TYPE_EMBEDDED;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_LE
7787 | OPTS_TYPE_PT_BITSLICE;
7788 kern_type = KERN_TYPE_DESCRYPT;
7789 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7790 parse_func = descrypt_parse_hash;
7791 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7794 dgst_pos0 = 0;
7795 dgst_pos1 = 1;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 3;
7798 break;
7799
7800 case 1600: hash_type = HASH_TYPE_MD5;
7801 salt_type = SALT_TYPE_EMBEDDED;
7802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7804 kern_type = KERN_TYPE_APR1CRYPT;
7805 dgst_size = DGST_SIZE_4_4;
7806 parse_func = md5apr1_parse_hash;
7807 sort_by_digest = sort_by_digest_4_4;
7808 opti_type = OPTI_TYPE_ZERO_BYTE;
7809 dgst_pos0 = 0;
7810 dgst_pos1 = 1;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 3;
7813 break;
7814
7815 case 1700: hash_type = HASH_TYPE_SHA512;
7816 salt_type = SALT_TYPE_NONE;
7817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7818 opts_type = OPTS_TYPE_PT_GENERATE_BE
7819 | OPTS_TYPE_PT_ADD80
7820 | OPTS_TYPE_PT_ADDBITS15;
7821 kern_type = KERN_TYPE_SHA512;
7822 dgst_size = DGST_SIZE_8_8;
7823 parse_func = sha512_parse_hash;
7824 sort_by_digest = sort_by_digest_8_8;
7825 opti_type = OPTI_TYPE_ZERO_BYTE
7826 | OPTI_TYPE_PRECOMPUTE_INIT
7827 | OPTI_TYPE_PRECOMPUTE_MERKLE
7828 | OPTI_TYPE_EARLY_SKIP
7829 | OPTI_TYPE_NOT_ITERATED
7830 | OPTI_TYPE_NOT_SALTED
7831 | OPTI_TYPE_USES_BITS_64
7832 | OPTI_TYPE_RAW_HASH;
7833 dgst_pos0 = 14;
7834 dgst_pos1 = 15;
7835 dgst_pos2 = 6;
7836 dgst_pos3 = 7;
7837 break;
7838
7839 case 1710: hash_type = HASH_TYPE_SHA512;
7840 salt_type = SALT_TYPE_INTERN;
7841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7842 opts_type = OPTS_TYPE_PT_GENERATE_BE
7843 | OPTS_TYPE_ST_ADD80
7844 | OPTS_TYPE_ST_ADDBITS15;
7845 kern_type = KERN_TYPE_SHA512_PWSLT;
7846 dgst_size = DGST_SIZE_8_8;
7847 parse_func = sha512s_parse_hash;
7848 sort_by_digest = sort_by_digest_8_8;
7849 opti_type = OPTI_TYPE_ZERO_BYTE
7850 | OPTI_TYPE_PRECOMPUTE_INIT
7851 | OPTI_TYPE_PRECOMPUTE_MERKLE
7852 | OPTI_TYPE_EARLY_SKIP
7853 | OPTI_TYPE_NOT_ITERATED
7854 | OPTI_TYPE_APPENDED_SALT
7855 | OPTI_TYPE_USES_BITS_64
7856 | OPTI_TYPE_RAW_HASH;
7857 dgst_pos0 = 14;
7858 dgst_pos1 = 15;
7859 dgst_pos2 = 6;
7860 dgst_pos3 = 7;
7861 break;
7862
7863 case 1711: hash_type = HASH_TYPE_SHA512;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_BE
7867 | OPTS_TYPE_ST_ADD80
7868 | OPTS_TYPE_ST_ADDBITS15;
7869 kern_type = KERN_TYPE_SHA512_PWSLT;
7870 dgst_size = DGST_SIZE_8_8;
7871 parse_func = sha512b64s_parse_hash;
7872 sort_by_digest = sort_by_digest_8_8;
7873 opti_type = OPTI_TYPE_ZERO_BYTE
7874 | OPTI_TYPE_PRECOMPUTE_INIT
7875 | OPTI_TYPE_PRECOMPUTE_MERKLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_APPENDED_SALT
7879 | OPTI_TYPE_USES_BITS_64
7880 | OPTI_TYPE_RAW_HASH;
7881 dgst_pos0 = 14;
7882 dgst_pos1 = 15;
7883 dgst_pos2 = 6;
7884 dgst_pos3 = 7;
7885 break;
7886
7887 case 1720: hash_type = HASH_TYPE_SHA512;
7888 salt_type = SALT_TYPE_INTERN;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_BE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS15;
7893 kern_type = KERN_TYPE_SHA512_SLTPW;
7894 dgst_size = DGST_SIZE_8_8;
7895 parse_func = sha512s_parse_hash;
7896 sort_by_digest = sort_by_digest_8_8;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_PREPENDED_SALT
7903 | OPTI_TYPE_USES_BITS_64
7904 | OPTI_TYPE_RAW_HASH;
7905 dgst_pos0 = 14;
7906 dgst_pos1 = 15;
7907 dgst_pos2 = 6;
7908 dgst_pos3 = 7;
7909 break;
7910
7911 case 1722: hash_type = HASH_TYPE_SHA512;
7912 salt_type = SALT_TYPE_EMBEDDED;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_BE
7915 | OPTS_TYPE_PT_ADD80
7916 | OPTS_TYPE_PT_ADDBITS15
7917 | OPTS_TYPE_ST_HEX;
7918 kern_type = KERN_TYPE_SHA512_SLTPW;
7919 dgst_size = DGST_SIZE_8_8;
7920 parse_func = osx512_parse_hash;
7921 sort_by_digest = sort_by_digest_8_8;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_PRECOMPUTE_INIT
7924 | OPTI_TYPE_PRECOMPUTE_MERKLE
7925 | OPTI_TYPE_EARLY_SKIP
7926 | OPTI_TYPE_NOT_ITERATED
7927 | OPTI_TYPE_PREPENDED_SALT
7928 | OPTI_TYPE_USES_BITS_64
7929 | OPTI_TYPE_RAW_HASH;
7930 dgst_pos0 = 14;
7931 dgst_pos1 = 15;
7932 dgst_pos2 = 6;
7933 dgst_pos3 = 7;
7934 break;
7935
7936 case 1730: hash_type = HASH_TYPE_SHA512;
7937 salt_type = SALT_TYPE_INTERN;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_UNICODE
7941 | OPTS_TYPE_ST_ADD80
7942 | OPTS_TYPE_ST_ADDBITS15;
7943 kern_type = KERN_TYPE_SHA512_PWSLTU;
7944 dgst_size = DGST_SIZE_8_8;
7945 parse_func = sha512s_parse_hash;
7946 sort_by_digest = sort_by_digest_8_8;
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_PRECOMPUTE_INIT
7949 | OPTI_TYPE_PRECOMPUTE_MERKLE
7950 | OPTI_TYPE_EARLY_SKIP
7951 | OPTI_TYPE_NOT_ITERATED
7952 | OPTI_TYPE_APPENDED_SALT
7953 | OPTI_TYPE_USES_BITS_64
7954 | OPTI_TYPE_RAW_HASH;
7955 dgst_pos0 = 14;
7956 dgst_pos1 = 15;
7957 dgst_pos2 = 6;
7958 dgst_pos3 = 7;
7959 break;
7960
7961 case 1731: hash_type = HASH_TYPE_SHA512;
7962 salt_type = SALT_TYPE_EMBEDDED;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_PT_UNICODE
7966 | OPTS_TYPE_ST_ADD80
7967 | OPTS_TYPE_ST_ADDBITS15
7968 | OPTS_TYPE_ST_HEX;
7969 kern_type = KERN_TYPE_SHA512_PWSLTU;
7970 dgst_size = DGST_SIZE_8_8;
7971 parse_func = mssql2012_parse_hash;
7972 sort_by_digest = sort_by_digest_8_8;
7973 opti_type = OPTI_TYPE_ZERO_BYTE
7974 | OPTI_TYPE_PRECOMPUTE_INIT
7975 | OPTI_TYPE_PRECOMPUTE_MERKLE
7976 | OPTI_TYPE_EARLY_SKIP
7977 | OPTI_TYPE_NOT_ITERATED
7978 | OPTI_TYPE_APPENDED_SALT
7979 | OPTI_TYPE_USES_BITS_64
7980 | OPTI_TYPE_RAW_HASH;
7981 dgst_pos0 = 14;
7982 dgst_pos1 = 15;
7983 dgst_pos2 = 6;
7984 dgst_pos3 = 7;
7985 break;
7986
7987 case 1740: hash_type = HASH_TYPE_SHA512;
7988 salt_type = SALT_TYPE_INTERN;
7989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7990 opts_type = OPTS_TYPE_PT_GENERATE_BE
7991 | OPTS_TYPE_PT_ADD80
7992 | OPTS_TYPE_PT_ADDBITS15
7993 | OPTS_TYPE_PT_UNICODE;
7994 kern_type = KERN_TYPE_SHA512_SLTPWU;
7995 dgst_size = DGST_SIZE_8_8;
7996 parse_func = sha512s_parse_hash;
7997 sort_by_digest = sort_by_digest_8_8;
7998 opti_type = OPTI_TYPE_ZERO_BYTE
7999 | OPTI_TYPE_PRECOMPUTE_INIT
8000 | OPTI_TYPE_PRECOMPUTE_MERKLE
8001 | OPTI_TYPE_EARLY_SKIP
8002 | OPTI_TYPE_NOT_ITERATED
8003 | OPTI_TYPE_PREPENDED_SALT
8004 | OPTI_TYPE_USES_BITS_64
8005 | OPTI_TYPE_RAW_HASH;
8006 dgst_pos0 = 14;
8007 dgst_pos1 = 15;
8008 dgst_pos2 = 6;
8009 dgst_pos3 = 7;
8010 break;
8011
8012 case 1750: hash_type = HASH_TYPE_SHA512;
8013 salt_type = SALT_TYPE_INTERN;
8014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8015 opts_type = OPTS_TYPE_PT_GENERATE_BE
8016 | OPTS_TYPE_ST_ADD80;
8017 kern_type = KERN_TYPE_HMACSHA512_PW;
8018 dgst_size = DGST_SIZE_8_8;
8019 parse_func = hmacsha512_parse_hash;
8020 sort_by_digest = sort_by_digest_8_8;
8021 opti_type = OPTI_TYPE_ZERO_BYTE
8022 | OPTI_TYPE_USES_BITS_64
8023 | OPTI_TYPE_NOT_ITERATED;
8024 dgst_pos0 = 14;
8025 dgst_pos1 = 15;
8026 dgst_pos2 = 6;
8027 dgst_pos3 = 7;
8028 break;
8029
8030 case 1760: hash_type = HASH_TYPE_SHA512;
8031 salt_type = SALT_TYPE_INTERN;
8032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8033 opts_type = OPTS_TYPE_PT_GENERATE_BE
8034 | OPTS_TYPE_PT_ADD80
8035 | OPTS_TYPE_PT_ADDBITS15;
8036 kern_type = KERN_TYPE_HMACSHA512_SLT;
8037 dgst_size = DGST_SIZE_8_8;
8038 parse_func = hmacsha512_parse_hash;
8039 sort_by_digest = sort_by_digest_8_8;
8040 opti_type = OPTI_TYPE_ZERO_BYTE
8041 | OPTI_TYPE_USES_BITS_64
8042 | OPTI_TYPE_NOT_ITERATED;
8043 dgst_pos0 = 14;
8044 dgst_pos1 = 15;
8045 dgst_pos2 = 6;
8046 dgst_pos3 = 7;
8047 break;
8048
8049 case 1800: hash_type = HASH_TYPE_SHA512;
8050 salt_type = SALT_TYPE_EMBEDDED;
8051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8052 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8053 kern_type = KERN_TYPE_SHA512CRYPT;
8054 dgst_size = DGST_SIZE_8_8;
8055 parse_func = sha512crypt_parse_hash;
8056 sort_by_digest = sort_by_digest_8_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_USES_BITS_64;
8059 dgst_pos0 = 0;
8060 dgst_pos1 = 1;
8061 dgst_pos2 = 2;
8062 dgst_pos3 = 3;
8063 break;
8064
8065 case 2100: hash_type = HASH_TYPE_DCC2;
8066 salt_type = SALT_TYPE_EMBEDDED;
8067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8068 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8069 | OPTS_TYPE_ST_LOWER
8070 | OPTS_TYPE_ST_UNICODE;
8071 kern_type = KERN_TYPE_DCC2;
8072 dgst_size = DGST_SIZE_4_4;
8073 parse_func = dcc2_parse_hash;
8074 sort_by_digest = sort_by_digest_4_4;
8075 opti_type = OPTI_TYPE_ZERO_BYTE;
8076 dgst_pos0 = 0;
8077 dgst_pos1 = 1;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 3;
8080 break;
8081
8082 case 2400: hash_type = HASH_TYPE_MD5;
8083 salt_type = SALT_TYPE_NONE;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8086 kern_type = KERN_TYPE_MD5PIX;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = md5pix_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_NOT_SALTED;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 3;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102 case 2410: hash_type = HASH_TYPE_MD5;
8103 salt_type = SALT_TYPE_INTERN;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8106 kern_type = KERN_TYPE_MD5ASA;
8107 dgst_size = DGST_SIZE_4_4;
8108 parse_func = md5asa_parse_hash;
8109 sort_by_digest = sort_by_digest_4_4;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP
8114 | OPTI_TYPE_NOT_ITERATED;
8115 dgst_pos0 = 0;
8116 dgst_pos1 = 3;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 1;
8119 break;
8120
8121 case 2500: hash_type = HASH_TYPE_WPA;
8122 salt_type = SALT_TYPE_EMBEDDED;
8123 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8125 kern_type = KERN_TYPE_WPA;
8126 dgst_size = DGST_SIZE_4_4;
8127 parse_func = wpa_parse_hash;
8128 sort_by_digest = sort_by_digest_4_4;
8129 opti_type = OPTI_TYPE_ZERO_BYTE;
8130 dgst_pos0 = 0;
8131 dgst_pos1 = 1;
8132 dgst_pos2 = 2;
8133 dgst_pos3 = 3;
8134 break;
8135
8136 case 2600: hash_type = HASH_TYPE_MD5;
8137 salt_type = SALT_TYPE_VIRTUAL;
8138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8139 opts_type = OPTS_TYPE_PT_GENERATE_LE
8140 | OPTS_TYPE_PT_ADD80
8141 | OPTS_TYPE_PT_ADDBITS14
8142 | OPTS_TYPE_ST_ADD80;
8143 kern_type = KERN_TYPE_MD55_PWSLT1;
8144 dgst_size = DGST_SIZE_4_4;
8145 parse_func = md5md5_parse_hash;
8146 sort_by_digest = sort_by_digest_4_4;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_PRECOMPUTE_INIT
8149 | OPTI_TYPE_PRECOMPUTE_MERKLE
8150 | OPTI_TYPE_EARLY_SKIP;
8151 dgst_pos0 = 0;
8152 dgst_pos1 = 3;
8153 dgst_pos2 = 2;
8154 dgst_pos3 = 1;
8155 break;
8156
8157 case 2611: hash_type = HASH_TYPE_MD5;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_LE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS14
8163 | OPTS_TYPE_ST_ADD80;
8164 kern_type = KERN_TYPE_MD55_PWSLT1;
8165 dgst_size = DGST_SIZE_4_4;
8166 parse_func = vb3_parse_hash;
8167 sort_by_digest = sort_by_digest_4_4;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_PRECOMPUTE_INIT
8170 | OPTI_TYPE_PRECOMPUTE_MERKLE
8171 | OPTI_TYPE_EARLY_SKIP;
8172 dgst_pos0 = 0;
8173 dgst_pos1 = 3;
8174 dgst_pos2 = 2;
8175 dgst_pos3 = 1;
8176 break;
8177
8178 case 2612: hash_type = HASH_TYPE_MD5;
8179 salt_type = SALT_TYPE_EMBEDDED;
8180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8181 opts_type = OPTS_TYPE_PT_GENERATE_LE
8182 | OPTS_TYPE_PT_ADD80
8183 | OPTS_TYPE_PT_ADDBITS14
8184 | OPTS_TYPE_ST_ADD80
8185 | OPTS_TYPE_ST_HEX;
8186 kern_type = KERN_TYPE_MD55_PWSLT1;
8187 dgst_size = DGST_SIZE_4_4;
8188 parse_func = phps_parse_hash;
8189 sort_by_digest = sort_by_digest_4_4;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP;
8194 dgst_pos0 = 0;
8195 dgst_pos1 = 3;
8196 dgst_pos2 = 2;
8197 dgst_pos3 = 1;
8198 break;
8199
8200 case 2711: hash_type = HASH_TYPE_MD5;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_LE
8204 | OPTS_TYPE_PT_ADD80
8205 | OPTS_TYPE_PT_ADDBITS14
8206 | OPTS_TYPE_ST_ADD80;
8207 kern_type = KERN_TYPE_MD55_PWSLT2;
8208 dgst_size = DGST_SIZE_4_4;
8209 parse_func = vb30_parse_hash;
8210 sort_by_digest = sort_by_digest_4_4;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_PRECOMPUTE_INIT
8213 | OPTI_TYPE_EARLY_SKIP;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 3;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 1;
8218 break;
8219
8220 case 2811: hash_type = HASH_TYPE_MD5;
8221 salt_type = SALT_TYPE_INTERN;
8222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE
8224 | OPTS_TYPE_PT_ADD80
8225 | OPTS_TYPE_PT_ADDBITS14;
8226 kern_type = KERN_TYPE_MD55_SLTPW;
8227 dgst_size = DGST_SIZE_4_4;
8228 parse_func = ipb2_parse_hash;
8229 sort_by_digest = sort_by_digest_4_4;
8230 opti_type = OPTI_TYPE_ZERO_BYTE
8231 | OPTI_TYPE_PRECOMPUTE_INIT
8232 | OPTI_TYPE_EARLY_SKIP;
8233 dgst_pos0 = 0;
8234 dgst_pos1 = 3;
8235 dgst_pos2 = 2;
8236 dgst_pos3 = 1;
8237 break;
8238
8239 case 3000: hash_type = HASH_TYPE_LM;
8240 salt_type = SALT_TYPE_NONE;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_LE
8243 | OPTS_TYPE_PT_UPPER
8244 | OPTS_TYPE_PT_BITSLICE;
8245 kern_type = KERN_TYPE_LM;
8246 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8247 parse_func = lm_parse_hash;
8248 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8249 opti_type = OPTI_TYPE_ZERO_BYTE
8250 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8251 dgst_pos0 = 0;
8252 dgst_pos1 = 1;
8253 dgst_pos2 = 2;
8254 dgst_pos3 = 3;
8255 break;
8256
8257 case 3100: hash_type = HASH_TYPE_ORACLEH;
8258 salt_type = SALT_TYPE_INTERN;
8259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8260 opts_type = OPTS_TYPE_PT_GENERATE_LE
8261 | OPTS_TYPE_PT_UPPER
8262 | OPTS_TYPE_ST_UPPER;
8263 kern_type = KERN_TYPE_ORACLEH;
8264 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8265 parse_func = oracleh_parse_hash;
8266 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8267 opti_type = OPTI_TYPE_ZERO_BYTE;
8268 dgst_pos0 = 0;
8269 dgst_pos1 = 1;
8270 dgst_pos2 = 2;
8271 dgst_pos3 = 3;
8272 break;
8273
8274 case 3200: hash_type = HASH_TYPE_BCRYPT;
8275 salt_type = SALT_TYPE_EMBEDDED;
8276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_LE
8278 | OPTS_TYPE_ST_GENERATE_LE;
8279 kern_type = KERN_TYPE_BCRYPT;
8280 dgst_size = DGST_SIZE_4_6;
8281 parse_func = bcrypt_parse_hash;
8282 sort_by_digest = sort_by_digest_4_6;
8283 opti_type = OPTI_TYPE_ZERO_BYTE;
8284 dgst_pos0 = 0;
8285 dgst_pos1 = 1;
8286 dgst_pos2 = 2;
8287 dgst_pos3 = 3;
8288 break;
8289
8290 case 3710: hash_type = HASH_TYPE_MD5;
8291 salt_type = SALT_TYPE_INTERN;
8292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8293 opts_type = OPTS_TYPE_PT_GENERATE_LE
8294 | OPTS_TYPE_PT_ADD80
8295 | OPTS_TYPE_PT_ADDBITS14;
8296 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = md5s_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_PRECOMPUTE_INIT
8302 | OPTI_TYPE_PRECOMPUTE_MERKLE
8303 | OPTI_TYPE_EARLY_SKIP;
8304 dgst_pos0 = 0;
8305 dgst_pos1 = 3;
8306 dgst_pos2 = 2;
8307 dgst_pos3 = 1;
8308 break;
8309
8310 case 3711: hash_type = HASH_TYPE_MD5;
8311 salt_type = SALT_TYPE_EMBEDDED;
8312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8313 opts_type = OPTS_TYPE_PT_GENERATE_LE
8314 | OPTS_TYPE_PT_ADD80
8315 | OPTS_TYPE_PT_ADDBITS14;
8316 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8317 dgst_size = DGST_SIZE_4_4;
8318 parse_func = mediawiki_b_parse_hash;
8319 sort_by_digest = sort_by_digest_4_4;
8320 opti_type = OPTI_TYPE_ZERO_BYTE
8321 | OPTI_TYPE_PRECOMPUTE_INIT
8322 | OPTI_TYPE_PRECOMPUTE_MERKLE
8323 | OPTI_TYPE_EARLY_SKIP;
8324 dgst_pos0 = 0;
8325 dgst_pos1 = 3;
8326 dgst_pos2 = 2;
8327 dgst_pos3 = 1;
8328 break;
8329
8330 case 3800: hash_type = HASH_TYPE_MD5;
8331 salt_type = SALT_TYPE_INTERN;
8332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8333 opts_type = OPTS_TYPE_PT_GENERATE_LE
8334 | OPTS_TYPE_ST_ADDBITS14;
8335 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8336 dgst_size = DGST_SIZE_4_4;
8337 parse_func = md5s_parse_hash;
8338 sort_by_digest = sort_by_digest_4_4;
8339 opti_type = OPTI_TYPE_ZERO_BYTE
8340 | OPTI_TYPE_PRECOMPUTE_INIT
8341 | OPTI_TYPE_PRECOMPUTE_MERKLE
8342 | OPTI_TYPE_EARLY_SKIP
8343 | OPTI_TYPE_NOT_ITERATED
8344 | OPTI_TYPE_RAW_HASH;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 4300: hash_type = HASH_TYPE_MD5;
8352 salt_type = SALT_TYPE_VIRTUAL;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_LE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS14
8357 | OPTS_TYPE_ST_ADD80;
8358 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = md5md5_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 3;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 1;
8370 break;
8371
8372
8373 case 4400: hash_type = HASH_TYPE_MD5;
8374 salt_type = SALT_TYPE_NONE;
8375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8376 opts_type = OPTS_TYPE_PT_GENERATE_BE
8377 | OPTS_TYPE_PT_ADD80
8378 | OPTS_TYPE_PT_ADDBITS15;
8379 kern_type = KERN_TYPE_MD5_SHA1;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = md5_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_EARLY_SKIP
8387 | OPTI_TYPE_NOT_ITERATED
8388 | OPTI_TYPE_NOT_SALTED
8389 | OPTI_TYPE_RAW_HASH;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 4500: hash_type = HASH_TYPE_SHA1;
8397 salt_type = SALT_TYPE_NONE;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_BE
8400 | OPTS_TYPE_PT_ADD80
8401 | OPTS_TYPE_PT_ADDBITS15;
8402 kern_type = KERN_TYPE_SHA11;
8403 dgst_size = DGST_SIZE_4_5;
8404 parse_func = sha1_parse_hash;
8405 sort_by_digest = sort_by_digest_4_5;
8406 opti_type = OPTI_TYPE_ZERO_BYTE
8407 | OPTI_TYPE_PRECOMPUTE_INIT
8408 | OPTI_TYPE_PRECOMPUTE_MERKLE
8409 | OPTI_TYPE_EARLY_SKIP
8410 | OPTI_TYPE_NOT_SALTED;
8411 dgst_pos0 = 3;
8412 dgst_pos1 = 4;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 1;
8415 break;
8416
8417 case 4700: hash_type = HASH_TYPE_SHA1;
8418 salt_type = SALT_TYPE_NONE;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_LE
8421 | OPTS_TYPE_PT_ADD80
8422 | OPTS_TYPE_PT_ADDBITS14;
8423 kern_type = KERN_TYPE_SHA1_MD5;
8424 dgst_size = DGST_SIZE_4_5;
8425 parse_func = sha1_parse_hash;
8426 sort_by_digest = sort_by_digest_4_5;
8427 opti_type = OPTI_TYPE_ZERO_BYTE
8428 | OPTI_TYPE_PRECOMPUTE_INIT
8429 | OPTI_TYPE_PRECOMPUTE_MERKLE
8430 | OPTI_TYPE_EARLY_SKIP
8431 | OPTI_TYPE_NOT_ITERATED
8432 | OPTI_TYPE_NOT_SALTED
8433 | OPTI_TYPE_RAW_HASH;
8434 dgst_pos0 = 3;
8435 dgst_pos1 = 4;
8436 dgst_pos2 = 2;
8437 dgst_pos3 = 1;
8438 break;
8439
8440 case 4800: hash_type = HASH_TYPE_MD5;
8441 salt_type = SALT_TYPE_EMBEDDED;
8442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8443 opts_type = OPTS_TYPE_PT_GENERATE_LE
8444 | OPTS_TYPE_PT_ADDBITS14;
8445 kern_type = KERN_TYPE_MD5_CHAP;
8446 dgst_size = DGST_SIZE_4_4;
8447 parse_func = chap_parse_hash;
8448 sort_by_digest = sort_by_digest_4_4;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_MEET_IN_MIDDLE
8453 | OPTI_TYPE_EARLY_SKIP
8454 | OPTI_TYPE_NOT_ITERATED
8455 | OPTI_TYPE_RAW_HASH;
8456 dgst_pos0 = 0;
8457 dgst_pos1 = 3;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 1;
8460 break;
8461
8462 case 4900: hash_type = HASH_TYPE_SHA1;
8463 salt_type = SALT_TYPE_INTERN;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8466 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8467 dgst_size = DGST_SIZE_4_5;
8468 parse_func = sha1s_parse_hash;
8469 sort_by_digest = sort_by_digest_4_5;
8470 opti_type = OPTI_TYPE_ZERO_BYTE
8471 | OPTI_TYPE_PRECOMPUTE_INIT
8472 | OPTI_TYPE_PRECOMPUTE_MERKLE
8473 | OPTI_TYPE_EARLY_SKIP;
8474 dgst_pos0 = 3;
8475 dgst_pos1 = 4;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 1;
8478 break;
8479
8480 case 5000: hash_type = HASH_TYPE_KECCAK;
8481 salt_type = SALT_TYPE_EMBEDDED;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_LE
8484 | OPTS_TYPE_PT_ADD01;
8485 kern_type = KERN_TYPE_KECCAK;
8486 dgst_size = DGST_SIZE_8_25;
8487 parse_func = keccak_parse_hash;
8488 sort_by_digest = sort_by_digest_8_25;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_USES_BITS_64
8491 | OPTI_TYPE_RAW_HASH;
8492 dgst_pos0 = 2;
8493 dgst_pos1 = 3;
8494 dgst_pos2 = 4;
8495 dgst_pos3 = 5;
8496 break;
8497
8498 case 5100: hash_type = HASH_TYPE_MD5H;
8499 salt_type = SALT_TYPE_NONE;
8500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8501 opts_type = OPTS_TYPE_PT_GENERATE_LE
8502 | OPTS_TYPE_PT_ADD80
8503 | OPTS_TYPE_PT_ADDBITS14;
8504 kern_type = KERN_TYPE_MD5H;
8505 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8506 parse_func = md5half_parse_hash;
8507 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8508 opti_type = OPTI_TYPE_ZERO_BYTE
8509 | OPTI_TYPE_RAW_HASH;
8510 dgst_pos0 = 0;
8511 dgst_pos1 = 1;
8512 dgst_pos2 = 2;
8513 dgst_pos3 = 3;
8514 break;
8515
8516 case 5200: hash_type = HASH_TYPE_SHA256;
8517 salt_type = SALT_TYPE_EMBEDDED;
8518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8520 kern_type = KERN_TYPE_PSAFE3;
8521 dgst_size = DGST_SIZE_4_8;
8522 parse_func = psafe3_parse_hash;
8523 sort_by_digest = sort_by_digest_4_8;
8524 opti_type = OPTI_TYPE_ZERO_BYTE;
8525 dgst_pos0 = 0;
8526 dgst_pos1 = 1;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 3;
8529 break;
8530
8531 case 5300: hash_type = HASH_TYPE_MD5;
8532 salt_type = SALT_TYPE_EMBEDDED;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE
8535 | OPTS_TYPE_ST_ADD80;
8536 kern_type = KERN_TYPE_IKEPSK_MD5;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = ikepsk_md5_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 5400: hash_type = HASH_TYPE_SHA1;
8548 salt_type = SALT_TYPE_EMBEDDED;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_BE
8551 | OPTS_TYPE_ST_ADD80;
8552 kern_type = KERN_TYPE_IKEPSK_SHA1;
8553 dgst_size = DGST_SIZE_4_5;
8554 parse_func = ikepsk_sha1_parse_hash;
8555 sort_by_digest = sort_by_digest_4_5;
8556 opti_type = OPTI_TYPE_ZERO_BYTE;
8557 dgst_pos0 = 3;
8558 dgst_pos1 = 4;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 5500: hash_type = HASH_TYPE_NETNTLM;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE
8567 | OPTS_TYPE_PT_ADD80
8568 | OPTS_TYPE_PT_ADDBITS14
8569 | OPTS_TYPE_PT_UNICODE
8570 | OPTS_TYPE_ST_HEX;
8571 kern_type = KERN_TYPE_NETNTLMv1;
8572 dgst_size = DGST_SIZE_4_4;
8573 parse_func = netntlmv1_parse_hash;
8574 sort_by_digest = sort_by_digest_4_4;
8575 opti_type = OPTI_TYPE_ZERO_BYTE
8576 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8577 dgst_pos0 = 0;
8578 dgst_pos1 = 1;
8579 dgst_pos2 = 2;
8580 dgst_pos3 = 3;
8581 break;
8582
8583 case 5600: hash_type = HASH_TYPE_MD5;
8584 salt_type = SALT_TYPE_EMBEDDED;
8585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8586 opts_type = OPTS_TYPE_PT_GENERATE_LE
8587 | OPTS_TYPE_PT_ADD80
8588 | OPTS_TYPE_PT_ADDBITS14
8589 | OPTS_TYPE_PT_UNICODE;
8590 kern_type = KERN_TYPE_NETNTLMv2;
8591 dgst_size = DGST_SIZE_4_4;
8592 parse_func = netntlmv2_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4;
8594 opti_type = OPTI_TYPE_ZERO_BYTE;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 3;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 1;
8599 break;
8600
8601 case 5700: hash_type = HASH_TYPE_SHA256;
8602 salt_type = SALT_TYPE_NONE;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_BE
8605 | OPTS_TYPE_PT_ADD80
8606 | OPTS_TYPE_PT_ADDBITS15;
8607 kern_type = KERN_TYPE_SHA256;
8608 dgst_size = DGST_SIZE_4_8;
8609 parse_func = cisco4_parse_hash;
8610 sort_by_digest = sort_by_digest_4_8;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_NOT_SALTED
8617 | OPTI_TYPE_RAW_HASH;
8618 dgst_pos0 = 3;
8619 dgst_pos1 = 7;
8620 dgst_pos2 = 2;
8621 dgst_pos3 = 6;
8622 break;
8623
8624 case 5800: hash_type = HASH_TYPE_SHA1;
8625 salt_type = SALT_TYPE_INTERN;
8626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8628 | OPTS_TYPE_ST_ADD80;
8629 kern_type = KERN_TYPE_ANDROIDPIN;
8630 dgst_size = DGST_SIZE_4_5;
8631 parse_func = androidpin_parse_hash;
8632 sort_by_digest = sort_by_digest_4_5;
8633 opti_type = OPTI_TYPE_ZERO_BYTE;
8634 dgst_pos0 = 0;
8635 dgst_pos1 = 1;
8636 dgst_pos2 = 2;
8637 dgst_pos3 = 3;
8638 break;
8639
8640 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8641 salt_type = SALT_TYPE_NONE;
8642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8643 opts_type = OPTS_TYPE_PT_GENERATE_LE
8644 | OPTS_TYPE_PT_ADD80;
8645 kern_type = KERN_TYPE_RIPEMD160;
8646 dgst_size = DGST_SIZE_4_5;
8647 parse_func = ripemd160_parse_hash;
8648 sort_by_digest = sort_by_digest_4_5;
8649 opti_type = OPTI_TYPE_ZERO_BYTE;
8650 dgst_pos0 = 0;
8651 dgst_pos1 = 1;
8652 dgst_pos2 = 2;
8653 dgst_pos3 = 3;
8654 break;
8655
8656 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8657 salt_type = SALT_TYPE_NONE;
8658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8659 opts_type = OPTS_TYPE_PT_GENERATE_BE
8660 | OPTS_TYPE_PT_ADD80;
8661 kern_type = KERN_TYPE_WHIRLPOOL;
8662 dgst_size = DGST_SIZE_4_16;
8663 parse_func = whirlpool_parse_hash;
8664 sort_by_digest = sort_by_digest_4_16;
8665 opti_type = OPTI_TYPE_ZERO_BYTE;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 1;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 3;
8670 break;
8671
8672 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8673 salt_type = SALT_TYPE_EMBEDDED;
8674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8676 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8677 dgst_size = DGST_SIZE_4_5;
8678 parse_func = truecrypt_parse_hash_2k;
8679 sort_by_digest = sort_by_digest_4_5;
8680 opti_type = OPTI_TYPE_ZERO_BYTE;
8681 dgst_pos0 = 0;
8682 dgst_pos1 = 1;
8683 dgst_pos2 = 2;
8684 dgst_pos3 = 3;
8685 break;
8686
8687 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8688 salt_type = SALT_TYPE_EMBEDDED;
8689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8691 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8692 dgst_size = DGST_SIZE_4_5;
8693 parse_func = truecrypt_parse_hash_2k;
8694 sort_by_digest = sort_by_digest_4_5;
8695 opti_type = OPTI_TYPE_ZERO_BYTE;
8696 dgst_pos0 = 0;
8697 dgst_pos1 = 1;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 3;
8700 break;
8701
8702 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8703 salt_type = SALT_TYPE_EMBEDDED;
8704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8706 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8707 dgst_size = DGST_SIZE_4_5;
8708 parse_func = truecrypt_parse_hash_2k;
8709 sort_by_digest = sort_by_digest_4_5;
8710 opti_type = OPTI_TYPE_ZERO_BYTE;
8711 dgst_pos0 = 0;
8712 dgst_pos1 = 1;
8713 dgst_pos2 = 2;
8714 dgst_pos3 = 3;
8715 break;
8716
8717 case 6221: hash_type = HASH_TYPE_SHA512;
8718 salt_type = SALT_TYPE_EMBEDDED;
8719 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8720 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8721 kern_type = KERN_TYPE_TCSHA512_XTS512;
8722 dgst_size = DGST_SIZE_8_8;
8723 parse_func = truecrypt_parse_hash_1k;
8724 sort_by_digest = sort_by_digest_8_8;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_USES_BITS_64;
8727 dgst_pos0 = 0;
8728 dgst_pos1 = 1;
8729 dgst_pos2 = 2;
8730 dgst_pos3 = 3;
8731 break;
8732
8733 case 6222: hash_type = HASH_TYPE_SHA512;
8734 salt_type = SALT_TYPE_EMBEDDED;
8735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8736 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8737 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8738 dgst_size = DGST_SIZE_8_8;
8739 parse_func = truecrypt_parse_hash_1k;
8740 sort_by_digest = sort_by_digest_8_8;
8741 opti_type = OPTI_TYPE_ZERO_BYTE
8742 | OPTI_TYPE_USES_BITS_64;
8743 dgst_pos0 = 0;
8744 dgst_pos1 = 1;
8745 dgst_pos2 = 2;
8746 dgst_pos3 = 3;
8747 break;
8748
8749 case 6223: hash_type = HASH_TYPE_SHA512;
8750 salt_type = SALT_TYPE_EMBEDDED;
8751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8753 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8754 dgst_size = DGST_SIZE_8_8;
8755 parse_func = truecrypt_parse_hash_1k;
8756 sort_by_digest = sort_by_digest_8_8;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_USES_BITS_64;
8759 dgst_pos0 = 0;
8760 dgst_pos1 = 1;
8761 dgst_pos2 = 2;
8762 dgst_pos3 = 3;
8763 break;
8764
8765 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8766 salt_type = SALT_TYPE_EMBEDDED;
8767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8769 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8770 dgst_size = DGST_SIZE_4_8;
8771 parse_func = truecrypt_parse_hash_1k;
8772 sort_by_digest = sort_by_digest_4_8;
8773 opti_type = OPTI_TYPE_ZERO_BYTE;
8774 dgst_pos0 = 0;
8775 dgst_pos1 = 1;
8776 dgst_pos2 = 2;
8777 dgst_pos3 = 3;
8778 break;
8779
8780 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8784 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8785 dgst_size = DGST_SIZE_4_8;
8786 parse_func = truecrypt_parse_hash_1k;
8787 sort_by_digest = sort_by_digest_4_8;
8788 opti_type = OPTI_TYPE_ZERO_BYTE;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8799 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8800 dgst_size = DGST_SIZE_4_8;
8801 parse_func = truecrypt_parse_hash_1k;
8802 sort_by_digest = sort_by_digest_4_8;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8814 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8815 dgst_size = DGST_SIZE_4_5;
8816 parse_func = truecrypt_parse_hash_1k;
8817 sort_by_digest = sort_by_digest_4_5;
8818 opti_type = OPTI_TYPE_ZERO_BYTE;
8819 dgst_pos0 = 0;
8820 dgst_pos1 = 1;
8821 dgst_pos2 = 2;
8822 dgst_pos3 = 3;
8823 break;
8824
8825 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8826 salt_type = SALT_TYPE_EMBEDDED;
8827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8829 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8830 dgst_size = DGST_SIZE_4_5;
8831 parse_func = truecrypt_parse_hash_1k;
8832 sort_by_digest = sort_by_digest_4_5;
8833 opti_type = OPTI_TYPE_ZERO_BYTE;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8844 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8845 dgst_size = DGST_SIZE_4_5;
8846 parse_func = truecrypt_parse_hash_1k;
8847 sort_by_digest = sort_by_digest_4_5;
8848 opti_type = OPTI_TYPE_ZERO_BYTE;
8849 dgst_pos0 = 0;
8850 dgst_pos1 = 1;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 3;
8853 break;
8854
8855 case 6300: hash_type = HASH_TYPE_MD5;
8856 salt_type = SALT_TYPE_EMBEDDED;
8857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8859 kern_type = KERN_TYPE_MD5AIX;
8860 dgst_size = DGST_SIZE_4_4;
8861 parse_func = md5aix_parse_hash;
8862 sort_by_digest = sort_by_digest_4_4;
8863 opti_type = OPTI_TYPE_ZERO_BYTE;
8864 dgst_pos0 = 0;
8865 dgst_pos1 = 1;
8866 dgst_pos2 = 2;
8867 dgst_pos3 = 3;
8868 break;
8869
8870 case 6400: hash_type = HASH_TYPE_SHA256;
8871 salt_type = SALT_TYPE_EMBEDDED;
8872 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8873 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8874 kern_type = KERN_TYPE_SHA256AIX;
8875 dgst_size = DGST_SIZE_4_8;
8876 parse_func = sha256aix_parse_hash;
8877 sort_by_digest = sort_by_digest_4_8;
8878 opti_type = OPTI_TYPE_ZERO_BYTE;
8879 dgst_pos0 = 0;
8880 dgst_pos1 = 1;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 3;
8883 break;
8884
8885 case 6500: hash_type = HASH_TYPE_SHA512;
8886 salt_type = SALT_TYPE_EMBEDDED;
8887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8889 kern_type = KERN_TYPE_SHA512AIX;
8890 dgst_size = DGST_SIZE_8_8;
8891 parse_func = sha512aix_parse_hash;
8892 sort_by_digest = sort_by_digest_8_8;
8893 opti_type = OPTI_TYPE_ZERO_BYTE
8894 | OPTI_TYPE_USES_BITS_64;
8895 dgst_pos0 = 0;
8896 dgst_pos1 = 1;
8897 dgst_pos2 = 2;
8898 dgst_pos3 = 3;
8899 break;
8900
8901 case 6600: hash_type = HASH_TYPE_AES;
8902 salt_type = SALT_TYPE_EMBEDDED;
8903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8904 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8905 kern_type = KERN_TYPE_AGILEKEY;
8906 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8907 parse_func = agilekey_parse_hash;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6700: hash_type = HASH_TYPE_SHA1;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8920 kern_type = KERN_TYPE_SHA1AIX;
8921 dgst_size = DGST_SIZE_4_5;
8922 parse_func = sha1aix_parse_hash;
8923 sort_by_digest = sort_by_digest_4_5;
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 1;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 3;
8929 break;
8930
8931 case 6800: hash_type = HASH_TYPE_AES;
8932 salt_type = SALT_TYPE_EMBEDDED;
8933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8935 kern_type = KERN_TYPE_LASTPASS;
8936 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8937 parse_func = lastpass_parse_hash;
8938 sort_by_digest = sort_by_digest_4_8;
8939 opti_type = OPTI_TYPE_ZERO_BYTE;
8940 dgst_pos0 = 0;
8941 dgst_pos1 = 1;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 3;
8944 break;
8945
8946 case 6900: hash_type = HASH_TYPE_GOST;
8947 salt_type = SALT_TYPE_NONE;
8948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8950 kern_type = KERN_TYPE_GOST;
8951 dgst_size = DGST_SIZE_4_8;
8952 parse_func = gost_parse_hash;
8953 sort_by_digest = sort_by_digest_4_8;
8954 opti_type = OPTI_TYPE_ZERO_BYTE;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 1;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 3;
8959 break;
8960
8961 case 7100: hash_type = HASH_TYPE_SHA512;
8962 salt_type = SALT_TYPE_EMBEDDED;
8963 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8965 kern_type = KERN_TYPE_PBKDF2_SHA512;
8966 dgst_size = DGST_SIZE_8_16;
8967 parse_func = sha512osx_parse_hash;
8968 sort_by_digest = sort_by_digest_8_16;
8969 opti_type = OPTI_TYPE_ZERO_BYTE
8970 | OPTI_TYPE_USES_BITS_64;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 7200: hash_type = HASH_TYPE_SHA512;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8981 kern_type = KERN_TYPE_PBKDF2_SHA512;
8982 dgst_size = DGST_SIZE_8_16;
8983 parse_func = sha512grub_parse_hash;
8984 sort_by_digest = sort_by_digest_8_16;
8985 opti_type = OPTI_TYPE_ZERO_BYTE
8986 | OPTI_TYPE_USES_BITS_64;
8987 dgst_pos0 = 0;
8988 dgst_pos1 = 1;
8989 dgst_pos2 = 2;
8990 dgst_pos3 = 3;
8991 break;
8992
8993 case 7300: hash_type = HASH_TYPE_SHA1;
8994 salt_type = SALT_TYPE_EMBEDDED;
8995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8996 opts_type = OPTS_TYPE_PT_GENERATE_BE
8997 | OPTS_TYPE_ST_ADD80
8998 | OPTS_TYPE_ST_ADDBITS15;
8999 kern_type = KERN_TYPE_RAKP;
9000 dgst_size = DGST_SIZE_4_5;
9001 parse_func = rakp_parse_hash;
9002 sort_by_digest = sort_by_digest_4_5;
9003 opti_type = OPTI_TYPE_ZERO_BYTE
9004 | OPTI_TYPE_NOT_ITERATED;
9005 dgst_pos0 = 3;
9006 dgst_pos1 = 4;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 1;
9009 break;
9010
9011 case 7400: hash_type = HASH_TYPE_SHA256;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_SHA256CRYPT;
9016 dgst_size = DGST_SIZE_4_8;
9017 parse_func = sha256crypt_parse_hash;
9018 sort_by_digest = sort_by_digest_4_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 7500: hash_type = HASH_TYPE_KRB5PA;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_KRB5PA;
9031 dgst_size = DGST_SIZE_4_4;
9032 parse_func = krb5pa_parse_hash;
9033 sort_by_digest = sort_by_digest_4_4;
9034 opti_type = OPTI_TYPE_ZERO_BYTE
9035 | OPTI_TYPE_NOT_ITERATED;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 7600: hash_type = HASH_TYPE_SHA1;
9043 salt_type = SALT_TYPE_INTERN;
9044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_BE
9046 | OPTS_TYPE_PT_ADD80
9047 | OPTS_TYPE_PT_ADDBITS15;
9048 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9049 dgst_size = DGST_SIZE_4_5;
9050 parse_func = redmine_parse_hash;
9051 sort_by_digest = sort_by_digest_4_5;
9052 opti_type = OPTI_TYPE_ZERO_BYTE
9053 | OPTI_TYPE_PRECOMPUTE_INIT
9054 | OPTI_TYPE_EARLY_SKIP
9055 | OPTI_TYPE_NOT_ITERATED
9056 | OPTI_TYPE_PREPENDED_SALT;
9057 dgst_pos0 = 3;
9058 dgst_pos1 = 4;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 1;
9061 break;
9062
9063 case 7700: hash_type = HASH_TYPE_SAPB;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE
9067 | OPTS_TYPE_PT_UPPER
9068 | OPTS_TYPE_ST_UPPER;
9069 kern_type = KERN_TYPE_SAPB;
9070 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9071 parse_func = sapb_parse_hash;
9072 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9073 opti_type = OPTI_TYPE_ZERO_BYTE
9074 | OPTI_TYPE_PRECOMPUTE_INIT
9075 | OPTI_TYPE_NOT_ITERATED;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 7800: hash_type = HASH_TYPE_SAPG;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_BE
9086 | OPTS_TYPE_ST_ADD80
9087 | OPTS_TYPE_ST_UPPER;
9088 kern_type = KERN_TYPE_SAPG;
9089 dgst_size = DGST_SIZE_4_5;
9090 parse_func = sapg_parse_hash;
9091 sort_by_digest = sort_by_digest_4_5;
9092 opti_type = OPTI_TYPE_ZERO_BYTE
9093 | OPTI_TYPE_PRECOMPUTE_INIT
9094 | OPTI_TYPE_NOT_ITERATED;
9095 dgst_pos0 = 3;
9096 dgst_pos1 = 4;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 1;
9099 break;
9100
9101 case 7900: hash_type = HASH_TYPE_SHA512;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9105 kern_type = KERN_TYPE_DRUPAL7;
9106 dgst_size = DGST_SIZE_8_8;
9107 parse_func = drupal7_parse_hash;
9108 sort_by_digest = sort_by_digest_8_8;
9109 opti_type = OPTI_TYPE_ZERO_BYTE
9110 | OPTI_TYPE_USES_BITS_64;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 8000: hash_type = HASH_TYPE_SHA256;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_BE
9121 | OPTS_TYPE_PT_UNICODE
9122 | OPTS_TYPE_ST_ADD80
9123 | OPTS_TYPE_ST_HEX;
9124 kern_type = KERN_TYPE_SYBASEASE;
9125 dgst_size = DGST_SIZE_4_8;
9126 parse_func = sybasease_parse_hash;
9127 sort_by_digest = sort_by_digest_4_8;
9128 opti_type = OPTI_TYPE_ZERO_BYTE
9129 | OPTI_TYPE_PRECOMPUTE_INIT
9130 | OPTI_TYPE_EARLY_SKIP
9131 | OPTI_TYPE_NOT_ITERATED
9132 | OPTI_TYPE_RAW_HASH;
9133 dgst_pos0 = 3;
9134 dgst_pos1 = 7;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 6;
9137 break;
9138
9139 case 8100: hash_type = HASH_TYPE_SHA1;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9143 kern_type = KERN_TYPE_NETSCALER;
9144 dgst_size = DGST_SIZE_4_5;
9145 parse_func = netscaler_parse_hash;
9146 sort_by_digest = sort_by_digest_4_5;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_PRECOMPUTE_INIT
9149 | OPTI_TYPE_PRECOMPUTE_MERKLE
9150 | OPTI_TYPE_EARLY_SKIP
9151 | OPTI_TYPE_NOT_ITERATED
9152 | OPTI_TYPE_PREPENDED_SALT
9153 | OPTI_TYPE_RAW_HASH;
9154 dgst_pos0 = 3;
9155 dgst_pos1 = 4;
9156 dgst_pos2 = 2;
9157 dgst_pos3 = 1;
9158 break;
9159
9160 case 8200: hash_type = HASH_TYPE_SHA256;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9164 kern_type = KERN_TYPE_CLOUDKEY;
9165 dgst_size = DGST_SIZE_4_8;
9166 parse_func = cloudkey_parse_hash;
9167 sort_by_digest = sort_by_digest_4_8;
9168 opti_type = OPTI_TYPE_ZERO_BYTE;
9169 dgst_pos0 = 0;
9170 dgst_pos1 = 1;
9171 dgst_pos2 = 2;
9172 dgst_pos3 = 3;
9173 break;
9174
9175 case 8300: hash_type = HASH_TYPE_SHA1;
9176 salt_type = SALT_TYPE_EMBEDDED;
9177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9178 opts_type = OPTS_TYPE_PT_GENERATE_LE
9179 | OPTS_TYPE_ST_HEX
9180 | OPTS_TYPE_ST_ADD80;
9181 kern_type = KERN_TYPE_NSEC3;
9182 dgst_size = DGST_SIZE_4_5;
9183 parse_func = nsec3_parse_hash;
9184 sort_by_digest = sort_by_digest_4_5;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 3;
9187 dgst_pos1 = 4;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 1;
9190 break;
9191
9192 case 8400: hash_type = HASH_TYPE_SHA1;
9193 salt_type = SALT_TYPE_INTERN;
9194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_BE
9196 | OPTS_TYPE_PT_ADD80
9197 | OPTS_TYPE_PT_ADDBITS15;
9198 kern_type = KERN_TYPE_WBB3;
9199 dgst_size = DGST_SIZE_4_5;
9200 parse_func = wbb3_parse_hash;
9201 sort_by_digest = sort_by_digest_4_5;
9202 opti_type = OPTI_TYPE_ZERO_BYTE
9203 | OPTI_TYPE_PRECOMPUTE_INIT
9204 | OPTI_TYPE_NOT_ITERATED;
9205 dgst_pos0 = 3;
9206 dgst_pos1 = 4;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 1;
9209 break;
9210
9211 case 8500: hash_type = HASH_TYPE_DESRACF;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_LE
9215 | OPTS_TYPE_ST_UPPER;
9216 kern_type = KERN_TYPE_RACF;
9217 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9218 parse_func = racf_parse_hash;
9219 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 8600: hash_type = HASH_TYPE_LOTUS5;
9229 salt_type = SALT_TYPE_NONE;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9232 kern_type = KERN_TYPE_LOTUS5;
9233 dgst_size = DGST_SIZE_4_4;
9234 parse_func = lotus5_parse_hash;
9235 sort_by_digest = sort_by_digest_4_4;
9236 opti_type = OPTI_TYPE_EARLY_SKIP
9237 | OPTI_TYPE_NOT_ITERATED
9238 | OPTI_TYPE_NOT_SALTED
9239 | OPTI_TYPE_RAW_HASH;
9240 dgst_pos0 = 0;
9241 dgst_pos1 = 1;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 3;
9244 break;
9245
9246 case 8700: hash_type = HASH_TYPE_LOTUS6;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9250 kern_type = KERN_TYPE_LOTUS6;
9251 dgst_size = DGST_SIZE_4_4;
9252 parse_func = lotus6_parse_hash;
9253 sort_by_digest = sort_by_digest_4_4;
9254 opti_type = OPTI_TYPE_EARLY_SKIP
9255 | OPTI_TYPE_NOT_ITERATED
9256 | OPTI_TYPE_RAW_HASH;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9267 kern_type = KERN_TYPE_ANDROIDFDE;
9268 dgst_size = DGST_SIZE_4_4;
9269 parse_func = androidfde_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 8900: hash_type = HASH_TYPE_SCRYPT;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_SCRYPT;
9283 dgst_size = DGST_SIZE_4_8;
9284 parse_func = scrypt_parse_hash;
9285 sort_by_digest = sort_by_digest_4_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 9000: hash_type = HASH_TYPE_SHA1;
9294 salt_type = SALT_TYPE_EMBEDDED;
9295 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE
9297 | OPTS_TYPE_ST_GENERATE_LE;
9298 kern_type = KERN_TYPE_PSAFE2;
9299 dgst_size = DGST_SIZE_4_5;
9300 parse_func = psafe2_parse_hash;
9301 sort_by_digest = sort_by_digest_4_5;
9302 opti_type = OPTI_TYPE_ZERO_BYTE;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 9100: hash_type = HASH_TYPE_LOTUS8;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9313 kern_type = KERN_TYPE_LOTUS8;
9314 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9315 parse_func = lotus8_parse_hash;
9316 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9317 opti_type = OPTI_TYPE_ZERO_BYTE;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 1;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 3;
9322 break;
9323
9324 case 9200: hash_type = HASH_TYPE_SHA256;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9328 kern_type = KERN_TYPE_PBKDF2_SHA256;
9329 dgst_size = DGST_SIZE_4_32;
9330 parse_func = cisco8_parse_hash;
9331 sort_by_digest = sort_by_digest_4_32;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 9300: hash_type = HASH_TYPE_SCRYPT;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_SCRYPT;
9344 dgst_size = DGST_SIZE_4_8;
9345 parse_func = cisco9_parse_hash;
9346 sort_by_digest = sort_by_digest_4_8;
9347 opti_type = OPTI_TYPE_ZERO_BYTE;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9358 kern_type = KERN_TYPE_OFFICE2007;
9359 dgst_size = DGST_SIZE_4_4;
9360 parse_func = office2007_parse_hash;
9361 sort_by_digest = sort_by_digest_4_4;
9362 opti_type = OPTI_TYPE_ZERO_BYTE;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9373 kern_type = KERN_TYPE_OFFICE2010;
9374 dgst_size = DGST_SIZE_4_4;
9375 parse_func = office2010_parse_hash;
9376 sort_by_digest = sort_by_digest_4_4;
9377 opti_type = OPTI_TYPE_ZERO_BYTE;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9385 salt_type = SALT_TYPE_EMBEDDED;
9386 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9388 kern_type = KERN_TYPE_OFFICE2013;
9389 dgst_size = DGST_SIZE_4_4;
9390 parse_func = office2013_parse_hash;
9391 sort_by_digest = sort_by_digest_4_4;
9392 opti_type = OPTI_TYPE_ZERO_BYTE;
9393 dgst_pos0 = 0;
9394 dgst_pos1 = 1;
9395 dgst_pos2 = 2;
9396 dgst_pos3 = 3;
9397 break;
9398
9399 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9400 salt_type = SALT_TYPE_EMBEDDED;
9401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9402 opts_type = OPTS_TYPE_PT_GENERATE_LE
9403 | OPTS_TYPE_PT_ADD80
9404 | OPTS_TYPE_PT_UNICODE;
9405 kern_type = KERN_TYPE_OLDOFFICE01;
9406 dgst_size = DGST_SIZE_4_4;
9407 parse_func = oldoffice01_parse_hash;
9408 sort_by_digest = sort_by_digest_4_4;
9409 opti_type = OPTI_TYPE_ZERO_BYTE
9410 | OPTI_TYPE_PRECOMPUTE_INIT
9411 | OPTI_TYPE_NOT_ITERATED;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE
9422 | OPTS_TYPE_PT_ADD80;
9423 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9424 dgst_size = DGST_SIZE_4_4;
9425 parse_func = oldoffice01cm1_parse_hash;
9426 sort_by_digest = sort_by_digest_4_4;
9427 opti_type = OPTI_TYPE_ZERO_BYTE
9428 | OPTI_TYPE_PRECOMPUTE_INIT
9429 | OPTI_TYPE_NOT_ITERATED;
9430 dgst_pos0 = 0;
9431 dgst_pos1 = 1;
9432 dgst_pos2 = 2;
9433 dgst_pos3 = 3;
9434 break;
9435
9436 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9437 salt_type = SALT_TYPE_EMBEDDED;
9438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9439 opts_type = OPTS_TYPE_PT_GENERATE_LE
9440 | OPTS_TYPE_PT_ADD80
9441 | OPTS_TYPE_PT_UNICODE
9442 | OPTS_TYPE_PT_NEVERCRACK;
9443 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9444 dgst_size = DGST_SIZE_4_4;
9445 parse_func = oldoffice01cm2_parse_hash;
9446 sort_by_digest = sort_by_digest_4_4;
9447 opti_type = OPTI_TYPE_ZERO_BYTE
9448 | OPTI_TYPE_PRECOMPUTE_INIT
9449 | OPTI_TYPE_NOT_ITERATED;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_BE
9460 | OPTS_TYPE_PT_ADD80
9461 | OPTS_TYPE_PT_UNICODE;
9462 kern_type = KERN_TYPE_OLDOFFICE34;
9463 dgst_size = DGST_SIZE_4_4;
9464 parse_func = oldoffice34_parse_hash;
9465 sort_by_digest = sort_by_digest_4_4;
9466 opti_type = OPTI_TYPE_ZERO_BYTE
9467 | OPTI_TYPE_PRECOMPUTE_INIT
9468 | OPTI_TYPE_NOT_ITERATED;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = oldoffice34cm1_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_PRECOMPUTE_INIT
9485 | OPTI_TYPE_NOT_ITERATED;
9486 dgst_pos0 = 0;
9487 dgst_pos1 = 1;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 3;
9490 break;
9491
9492 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_BE
9496 | OPTS_TYPE_PT_ADD80
9497 | OPTS_TYPE_PT_UNICODE
9498 | OPTS_TYPE_PT_NEVERCRACK;
9499 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = oldoffice34cm2_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE
9504 | OPTI_TYPE_PRECOMPUTE_INIT
9505 | OPTI_TYPE_NOT_ITERATED;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 9900: hash_type = HASH_TYPE_MD5;
9513 salt_type = SALT_TYPE_NONE;
9514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_RADMIN2;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = radmin2_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_ZERO_BYTE
9521 | OPTI_TYPE_PRECOMPUTE_INIT
9522 | OPTI_TYPE_EARLY_SKIP
9523 | OPTI_TYPE_NOT_ITERATED
9524 | OPTI_TYPE_NOT_SALTED;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 3;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 1;
9529 break;
9530
9531 case 10000: hash_type = HASH_TYPE_SHA256;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9535 kern_type = KERN_TYPE_PBKDF2_SHA256;
9536 dgst_size = DGST_SIZE_4_32;
9537 parse_func = djangopbkdf2_parse_hash;
9538 sort_by_digest = sort_by_digest_4_32;
9539 opti_type = OPTI_TYPE_ZERO_BYTE;
9540 dgst_pos0 = 0;
9541 dgst_pos1 = 1;
9542 dgst_pos2 = 2;
9543 dgst_pos3 = 3;
9544 break;
9545
9546 case 10100: hash_type = HASH_TYPE_SIPHASH;
9547 salt_type = SALT_TYPE_EMBEDDED;
9548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9550 kern_type = KERN_TYPE_SIPHASH;
9551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9552 parse_func = siphash_parse_hash;
9553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9554 opti_type = OPTI_TYPE_ZERO_BYTE
9555 | OPTI_TYPE_NOT_ITERATED
9556 | OPTI_TYPE_RAW_HASH;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 10200: hash_type = HASH_TYPE_MD5;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_ST_ADD80
9568 | OPTS_TYPE_ST_ADDBITS14;
9569 kern_type = KERN_TYPE_HMACMD5_PW;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = crammd5_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_NOT_ITERATED;
9575 dgst_pos0 = 0;
9576 dgst_pos1 = 3;
9577 dgst_pos2 = 2;
9578 dgst_pos3 = 1;
9579 break;
9580
9581 case 10300: hash_type = HASH_TYPE_SHA1;
9582 salt_type = SALT_TYPE_EMBEDDED;
9583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9584 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9585 kern_type = KERN_TYPE_SAPH_SHA1;
9586 dgst_size = DGST_SIZE_4_5;
9587 parse_func = saph_sha1_parse_hash;
9588 sort_by_digest = sort_by_digest_4_5;
9589 opti_type = OPTI_TYPE_ZERO_BYTE;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 10400: hash_type = HASH_TYPE_PDFU16;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9600 kern_type = KERN_TYPE_PDF11;
9601 dgst_size = DGST_SIZE_4_4;
9602 parse_func = pdf11_parse_hash;
9603 sort_by_digest = sort_by_digest_4_4;
9604 opti_type = OPTI_TYPE_ZERO_BYTE
9605 | OPTI_TYPE_NOT_ITERATED;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 10410: hash_type = HASH_TYPE_PDFU16;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_PDF11CM1;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = pdf11cm1_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE
9621 | OPTI_TYPE_NOT_ITERATED;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 10420: hash_type = HASH_TYPE_PDFU16;
9629 salt_type = SALT_TYPE_EMBEDDED;
9630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9632 kern_type = KERN_TYPE_PDF11CM2;
9633 dgst_size = DGST_SIZE_4_4;
9634 parse_func = pdf11cm2_parse_hash;
9635 sort_by_digest = sort_by_digest_4_4;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 10500: hash_type = HASH_TYPE_PDFU16;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_PDF14;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = pdf14_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 10600: hash_type = HASH_TYPE_SHA256;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_BE
9664 | OPTS_TYPE_ST_ADD80
9665 | OPTS_TYPE_ST_ADDBITS15
9666 | OPTS_TYPE_HASH_COPY;
9667 kern_type = KERN_TYPE_SHA256_PWSLT;
9668 dgst_size = DGST_SIZE_4_8;
9669 parse_func = pdf17l3_parse_hash;
9670 sort_by_digest = sort_by_digest_4_8;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_PRECOMPUTE_INIT
9673 | OPTI_TYPE_PRECOMPUTE_MERKLE
9674 | OPTI_TYPE_EARLY_SKIP
9675 | OPTI_TYPE_NOT_ITERATED
9676 | OPTI_TYPE_APPENDED_SALT
9677 | OPTI_TYPE_RAW_HASH;
9678 dgst_pos0 = 3;
9679 dgst_pos1 = 7;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 6;
9682 break;
9683
9684 case 10700: hash_type = HASH_TYPE_PDFU32;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE
9688 | OPTS_TYPE_HASH_COPY;
9689 kern_type = KERN_TYPE_PDF17L8;
9690 dgst_size = DGST_SIZE_4_8;
9691 parse_func = pdf17l8_parse_hash;
9692 sort_by_digest = sort_by_digest_4_8;
9693 opti_type = OPTI_TYPE_ZERO_BYTE
9694 | OPTI_TYPE_NOT_ITERATED;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 10800: hash_type = HASH_TYPE_SHA384;
9702 salt_type = SALT_TYPE_NONE;
9703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_BE
9705 | OPTS_TYPE_PT_ADD80
9706 | OPTS_TYPE_PT_ADDBITS15;
9707 kern_type = KERN_TYPE_SHA384;
9708 dgst_size = DGST_SIZE_8_8;
9709 parse_func = sha384_parse_hash;
9710 sort_by_digest = sort_by_digest_8_8;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_PRECOMPUTE_INIT
9713 | OPTI_TYPE_PRECOMPUTE_MERKLE
9714 | OPTI_TYPE_EARLY_SKIP
9715 | OPTI_TYPE_NOT_ITERATED
9716 | OPTI_TYPE_NOT_SALTED
9717 | OPTI_TYPE_USES_BITS_64
9718 | OPTI_TYPE_RAW_HASH;
9719 dgst_pos0 = 6;
9720 dgst_pos1 = 7;
9721 dgst_pos2 = 4;
9722 dgst_pos3 = 5;
9723 break;
9724
9725 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9726 salt_type = SALT_TYPE_EMBEDDED;
9727 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9728 opts_type = OPTS_TYPE_PT_GENERATE_LE
9729 | OPTS_TYPE_ST_BASE64
9730 | OPTS_TYPE_HASH_COPY;
9731 kern_type = KERN_TYPE_PBKDF2_SHA256;
9732 dgst_size = DGST_SIZE_4_32;
9733 parse_func = pbkdf2_sha256_parse_hash;
9734 sort_by_digest = sort_by_digest_4_32;
9735 opti_type = OPTI_TYPE_ZERO_BYTE;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 11000: hash_type = HASH_TYPE_MD5;
9743 salt_type = SALT_TYPE_INTERN;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE
9746 | OPTS_TYPE_PT_ADD80;
9747 kern_type = KERN_TYPE_PRESTASHOP;
9748 dgst_size = DGST_SIZE_4_4;
9749 parse_func = prestashop_parse_hash;
9750 sort_by_digest = sort_by_digest_4_4;
9751 opti_type = OPTI_TYPE_ZERO_BYTE
9752 | OPTI_TYPE_PRECOMPUTE_INIT
9753 | OPTI_TYPE_NOT_ITERATED
9754 | OPTI_TYPE_PREPENDED_SALT;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 3;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 1;
9759 break;
9760
9761 case 11100: hash_type = HASH_TYPE_MD5;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE
9765 | OPTS_TYPE_ST_ADD80;
9766 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = postgresql_auth_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_PRECOMPUTE_INIT
9772 | OPTI_TYPE_PRECOMPUTE_MERKLE
9773 | OPTI_TYPE_EARLY_SKIP;
9774 dgst_pos0 = 0;
9775 dgst_pos1 = 3;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 1;
9778 break;
9779
9780 case 11200: hash_type = HASH_TYPE_SHA1;
9781 salt_type = SALT_TYPE_EMBEDDED;
9782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_BE
9784 | OPTS_TYPE_PT_ADD80
9785 | OPTS_TYPE_ST_HEX;
9786 kern_type = KERN_TYPE_MYSQL_AUTH;
9787 dgst_size = DGST_SIZE_4_5;
9788 parse_func = mysql_auth_parse_hash;
9789 sort_by_digest = sort_by_digest_4_5;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_EARLY_SKIP;
9792 dgst_pos0 = 3;
9793 dgst_pos1 = 4;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 1;
9796 break;
9797
9798 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE
9802 | OPTS_TYPE_ST_HEX
9803 | OPTS_TYPE_ST_ADD80;
9804 kern_type = KERN_TYPE_BITCOIN_WALLET;
9805 dgst_size = DGST_SIZE_4_4;
9806 parse_func = bitcoin_wallet_parse_hash;
9807 sort_by_digest = sort_by_digest_4_4;
9808 opti_type = OPTI_TYPE_ZERO_BYTE;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 11400: hash_type = HASH_TYPE_MD5;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE
9819 | OPTS_TYPE_PT_ADD80
9820 | OPTS_TYPE_HASH_COPY;
9821 kern_type = KERN_TYPE_SIP_AUTH;
9822 dgst_size = DGST_SIZE_4_4;
9823 parse_func = sip_auth_parse_hash;
9824 sort_by_digest = sort_by_digest_4_4;
9825 opti_type = OPTI_TYPE_ZERO_BYTE;
9826 dgst_pos0 = 0;
9827 dgst_pos1 = 3;
9828 dgst_pos2 = 2;
9829 dgst_pos3 = 1;
9830 break;
9831
9832 case 11500: hash_type = HASH_TYPE_CRC32;
9833 salt_type = SALT_TYPE_INTERN;
9834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9835 opts_type = OPTS_TYPE_PT_GENERATE_LE
9836 | OPTS_TYPE_ST_GENERATE_LE
9837 | OPTS_TYPE_ST_HEX;
9838 kern_type = KERN_TYPE_CRC32;
9839 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9840 parse_func = crc32_parse_hash;
9841 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9842 opti_type = OPTI_TYPE_ZERO_BYTE;
9843 dgst_pos0 = 0;
9844 dgst_pos1 = 1;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 3;
9847 break;
9848
9849 case 11600: hash_type = HASH_TYPE_AES;
9850 salt_type = SALT_TYPE_EMBEDDED;
9851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE
9853 | OPTS_TYPE_PT_NEVERCRACK;
9854 kern_type = KERN_TYPE_SEVEN_ZIP;
9855 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9856 parse_func = seven_zip_parse_hash;
9857 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9858 opti_type = OPTI_TYPE_ZERO_BYTE;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9866 salt_type = SALT_TYPE_NONE;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_PT_ADD01;
9870 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9871 dgst_size = DGST_SIZE_4_8;
9872 parse_func = gost2012sbog_256_parse_hash;
9873 sort_by_digest = sort_by_digest_4_8;
9874 opti_type = OPTI_TYPE_ZERO_BYTE;
9875 dgst_pos0 = 0;
9876 dgst_pos1 = 1;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 3;
9879 break;
9880
9881 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9882 salt_type = SALT_TYPE_NONE;
9883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE
9885 | OPTS_TYPE_PT_ADD01;
9886 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9887 dgst_size = DGST_SIZE_4_16;
9888 parse_func = gost2012sbog_512_parse_hash;
9889 sort_by_digest = sort_by_digest_4_16;
9890 opti_type = OPTI_TYPE_ZERO_BYTE;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE
9901 | OPTS_TYPE_ST_BASE64
9902 | OPTS_TYPE_HASH_COPY;
9903 kern_type = KERN_TYPE_PBKDF2_MD5;
9904 dgst_size = DGST_SIZE_4_32;
9905 parse_func = pbkdf2_md5_parse_hash;
9906 sort_by_digest = sort_by_digest_4_32;
9907 opti_type = OPTI_TYPE_ZERO_BYTE;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_ST_BASE64
9919 | OPTS_TYPE_HASH_COPY;
9920 kern_type = KERN_TYPE_PBKDF2_SHA1;
9921 dgst_size = DGST_SIZE_4_32;
9922 parse_func = pbkdf2_sha1_parse_hash;
9923 sort_by_digest = sort_by_digest_4_32;
9924 opti_type = OPTI_TYPE_ZERO_BYTE;
9925 dgst_pos0 = 0;
9926 dgst_pos1 = 1;
9927 dgst_pos2 = 2;
9928 dgst_pos3 = 3;
9929 break;
9930
9931 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9932 salt_type = SALT_TYPE_EMBEDDED;
9933 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9934 opts_type = OPTS_TYPE_PT_GENERATE_LE
9935 | OPTS_TYPE_ST_BASE64
9936 | OPTS_TYPE_HASH_COPY;
9937 kern_type = KERN_TYPE_PBKDF2_SHA512;
9938 dgst_size = DGST_SIZE_8_16;
9939 parse_func = pbkdf2_sha512_parse_hash;
9940 sort_by_digest = sort_by_digest_8_16;
9941 opti_type = OPTI_TYPE_ZERO_BYTE
9942 | OPTI_TYPE_USES_BITS_64;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9953 kern_type = KERN_TYPE_ECRYPTFS;
9954 dgst_size = DGST_SIZE_8_8;
9955 parse_func = ecryptfs_parse_hash;
9956 sort_by_digest = sort_by_digest_8_8;
9957 opti_type = OPTI_TYPE_ZERO_BYTE
9958 | OPTI_TYPE_USES_BITS_64;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 12300: hash_type = HASH_TYPE_ORACLET;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9969 kern_type = KERN_TYPE_ORACLET;
9970 dgst_size = DGST_SIZE_8_16;
9971 parse_func = oraclet_parse_hash;
9972 sort_by_digest = sort_by_digest_8_16;
9973 opti_type = OPTI_TYPE_ZERO_BYTE
9974 | OPTI_TYPE_USES_BITS_64;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9985 kern_type = KERN_TYPE_BSDICRYPT;
9986 dgst_size = DGST_SIZE_4_4;
9987 parse_func = bsdicrypt_parse_hash;
9988 sort_by_digest = sort_by_digest_4_4;
9989 opti_type = OPTI_TYPE_ZERO_BYTE
9990 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 12500: hash_type = HASH_TYPE_RAR3HP;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_RAR3;
10002 dgst_size = DGST_SIZE_4_4;
10003 parse_func = rar3hp_parse_hash;
10004 sort_by_digest = sort_by_digest_4_4;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 12600: hash_type = HASH_TYPE_SHA256;
10013 salt_type = SALT_TYPE_INTERN;
10014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_BE
10016 | OPTS_TYPE_PT_ADD80;
10017 kern_type = KERN_TYPE_CF10;
10018 dgst_size = DGST_SIZE_4_8;
10019 parse_func = cf10_parse_hash;
10020 sort_by_digest = sort_by_digest_4_8;
10021 opti_type = OPTI_TYPE_ZERO_BYTE
10022 | OPTI_TYPE_PRECOMPUTE_INIT
10023 | OPTI_TYPE_EARLY_SKIP
10024 | OPTI_TYPE_NOT_ITERATED;
10025 dgst_pos0 = 3;
10026 dgst_pos1 = 7;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 6;
10029 break;
10030
10031 case 12700: hash_type = HASH_TYPE_AES;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_HASH_COPY;
10036 kern_type = KERN_TYPE_MYWALLET;
10037 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10038 parse_func = mywallet_parse_hash;
10039 sort_by_digest = sort_by_digest_4_5;
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10051 kern_type = KERN_TYPE_MS_DRSR;
10052 dgst_size = DGST_SIZE_4_8;
10053 parse_func = ms_drsr_parse_hash;
10054 sort_by_digest = sort_by_digest_4_8;
10055 opti_type = OPTI_TYPE_ZERO_BYTE;
10056 dgst_pos0 = 0;
10057 dgst_pos1 = 1;
10058 dgst_pos2 = 2;
10059 dgst_pos3 = 3;
10060 break;
10061
10062 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10063 salt_type = SALT_TYPE_EMBEDDED;
10064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10066 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10067 dgst_size = DGST_SIZE_4_8;
10068 parse_func = androidfde_samsung_parse_hash;
10069 sort_by_digest = sort_by_digest_4_8;
10070 opti_type = OPTI_TYPE_ZERO_BYTE;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10081 kern_type = KERN_TYPE_RAR5;
10082 dgst_size = DGST_SIZE_4_4;
10083 parse_func = rar5_parse_hash;
10084 sort_by_digest = sort_by_digest_4_4;
10085 opti_type = OPTI_TYPE_ZERO_BYTE;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 default: usage_mini_print (PROGNAME); return (-1);
10093 }
10094
10095 /**
10096 * transpose
10097 */
10098
10099 data.parse_func = parse_func;
10100
10101 /**
10102 * misc stuff
10103 */
10104
10105 if (hex_salt)
10106 {
10107 if (salt_type == SALT_TYPE_INTERN)
10108 {
10109 opts_type |= OPTS_TYPE_ST_HEX;
10110 }
10111 else
10112 {
10113 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10114
10115 return (-1);
10116 }
10117 }
10118
10119 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10120 | (salt_type == SALT_TYPE_EXTERN)
10121 | (salt_type == SALT_TYPE_EMBEDDED)
10122 | (salt_type == SALT_TYPE_VIRTUAL));
10123
10124 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10125
10126 data.hash_type = hash_type;
10127 data.attack_mode = attack_mode;
10128 data.attack_kern = attack_kern;
10129 data.attack_exec = attack_exec;
10130 data.kern_type = kern_type;
10131 data.opts_type = opts_type;
10132 data.dgst_size = dgst_size;
10133 data.salt_type = salt_type;
10134 data.isSalted = isSalted;
10135 data.sort_by_digest = sort_by_digest;
10136 data.dgst_pos0 = dgst_pos0;
10137 data.dgst_pos1 = dgst_pos1;
10138 data.dgst_pos2 = dgst_pos2;
10139 data.dgst_pos3 = dgst_pos3;
10140
10141 esalt_size = 0;
10142
10143 switch (hash_mode)
10144 {
10145 case 2500: esalt_size = sizeof (wpa_t); break;
10146 case 5300: esalt_size = sizeof (ikepsk_t); break;
10147 case 5400: esalt_size = sizeof (ikepsk_t); break;
10148 case 5500: esalt_size = sizeof (netntlm_t); break;
10149 case 5600: esalt_size = sizeof (netntlm_t); break;
10150 case 6211:
10151 case 6212:
10152 case 6213:
10153 case 6221:
10154 case 6222:
10155 case 6223:
10156 case 6231:
10157 case 6232:
10158 case 6233:
10159 case 6241:
10160 case 6242:
10161 case 6243: esalt_size = sizeof (tc_t); break;
10162 case 6600: esalt_size = sizeof (agilekey_t); break;
10163 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10164 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10165 case 7300: esalt_size = sizeof (rakp_t); break;
10166 case 7500: esalt_size = sizeof (krb5pa_t); break;
10167 case 8200: esalt_size = sizeof (cloudkey_t); break;
10168 case 8800: esalt_size = sizeof (androidfde_t); break;
10169 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10170 case 9400: esalt_size = sizeof (office2007_t); break;
10171 case 9500: esalt_size = sizeof (office2010_t); break;
10172 case 9600: esalt_size = sizeof (office2013_t); break;
10173 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10174 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10175 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10176 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10177 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10178 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10179 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10180 case 10200: esalt_size = sizeof (cram_md5_t); break;
10181 case 10400: esalt_size = sizeof (pdf_t); break;
10182 case 10410: esalt_size = sizeof (pdf_t); break;
10183 case 10420: esalt_size = sizeof (pdf_t); break;
10184 case 10500: esalt_size = sizeof (pdf_t); break;
10185 case 10600: esalt_size = sizeof (pdf_t); break;
10186 case 10700: esalt_size = sizeof (pdf_t); break;
10187 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10188 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10189 case 11400: esalt_size = sizeof (sip_t); break;
10190 case 11600: esalt_size = sizeof (seven_zip_t); break;
10191 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10192 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10193 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10194 case 13000: esalt_size = sizeof (rar5_t); break;
10195 }
10196
10197 data.esalt_size = esalt_size;
10198
10199 /**
10200 * choose dictionary parser
10201 */
10202
10203 if (hash_type == HASH_TYPE_LM)
10204 {
10205 get_next_word_func = get_next_word_lm;
10206 }
10207 else if (opts_type & OPTS_TYPE_PT_UPPER)
10208 {
10209 get_next_word_func = get_next_word_uc;
10210 }
10211 else
10212 {
10213 get_next_word_func = get_next_word_std;
10214 }
10215
10216 /**
10217 * dictstat
10218 */
10219
10220 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10221
10222 #ifdef _POSIX
10223 size_t dictstat_nmemb = 0;
10224 #endif
10225
10226 #ifdef _WIN
10227 uint dictstat_nmemb = 0;
10228 #endif
10229
10230 char dictstat[256] = { 0 };
10231
10232 FILE *dictstat_fp = NULL;
10233
10234 if (keyspace == 0)
10235 {
10236 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10237
10238 dictstat_fp = fopen (dictstat, "rb");
10239
10240 if (dictstat_fp)
10241 {
10242 #ifdef _POSIX
10243 struct stat tmpstat;
10244
10245 fstat (fileno (dictstat_fp), &tmpstat);
10246 #endif
10247
10248 #ifdef _WIN
10249 struct stat64 tmpstat;
10250
10251 _fstat64 (fileno (dictstat_fp), &tmpstat);
10252 #endif
10253
10254 if (tmpstat.st_mtime < COMPTIME)
10255 {
10256 /* with v0.15 the format changed so we have to ensure user is using a good version
10257 since there is no version-header in the dictstat file */
10258
10259 fclose (dictstat_fp);
10260
10261 unlink (dictstat);
10262 }
10263 else
10264 {
10265 while (!feof (dictstat_fp))
10266 {
10267 dictstat_t d;
10268
10269 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10270
10271 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10272
10273 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10274 {
10275 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10276
10277 return -1;
10278 }
10279 }
10280
10281 fclose (dictstat_fp);
10282 }
10283 }
10284 }
10285
10286 /**
10287 * potfile
10288 */
10289
10290 char potfile[256] = { 0 };
10291
10292 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10293
10294 data.pot_fp = NULL;
10295
10296 FILE *out_fp = NULL;
10297 FILE *pot_fp = NULL;
10298
10299 if (show == 1 || left == 1)
10300 {
10301 pot_fp = fopen (potfile, "rb");
10302
10303 if (pot_fp == NULL)
10304 {
10305 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10306
10307 return (-1);
10308 }
10309
10310 if (outfile != NULL)
10311 {
10312 if ((out_fp = fopen (outfile, "ab")) == NULL)
10313 {
10314 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10315
10316 fclose (pot_fp);
10317
10318 return (-1);
10319 }
10320 }
10321 else
10322 {
10323 out_fp = stdout;
10324 }
10325 }
10326 else
10327 {
10328 if (potfile_disable == 0)
10329 {
10330 pot_fp = fopen (potfile, "ab");
10331
10332 if (pot_fp == NULL)
10333 {
10334 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10335
10336 return (-1);
10337 }
10338
10339 data.pot_fp = pot_fp;
10340 }
10341 }
10342
10343 pot_t *pot = NULL;
10344
10345 uint pot_cnt = 0;
10346 uint pot_avail = 0;
10347
10348 if (show == 1 || left == 1)
10349 {
10350 SUPPRESS_OUTPUT = 1;
10351
10352 pot_avail = count_lines (pot_fp);
10353
10354 rewind (pot_fp);
10355
10356 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10357
10358 uint pot_hashes_avail = 0;
10359
10360 uint line_num = 0;
10361
10362 while (!feof (pot_fp))
10363 {
10364 line_num++;
10365
10366 char line_buf[BUFSIZ] = { 0 };
10367
10368 int line_len = fgetl (pot_fp, line_buf);
10369
10370 if (line_len == 0) continue;
10371
10372 char *plain_buf = line_buf + line_len;
10373
10374 pot_t *pot_ptr = &pot[pot_cnt];
10375
10376 hash_t *hashes_buf = &pot_ptr->hash;
10377
10378 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10379 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10380
10381 if (pot_cnt == pot_hashes_avail)
10382 {
10383 uint pos = 0;
10384
10385 for (pos = 0; pos < INCR_POT; pos++)
10386 {
10387 if ((pot_cnt + pos) >= pot_avail) break;
10388
10389 pot_t *tmp_pot = &pot[pot_cnt + pos];
10390
10391 hash_t *tmp_hash = &tmp_pot->hash;
10392
10393 tmp_hash->digest = mymalloc (dgst_size);
10394
10395 if (isSalted)
10396 {
10397 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10398 }
10399
10400 if (esalt_size)
10401 {
10402 tmp_hash->esalt = mymalloc (esalt_size);
10403 }
10404
10405 pot_hashes_avail++;
10406 }
10407 }
10408
10409 int plain_len = 0;
10410
10411 int parser_status;
10412
10413 int iter = MAX_CUT_TRIES;
10414
10415 do
10416 {
10417 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10418 {
10419 if (line_buf[i] == ':')
10420 {
10421 line_len--;
10422
10423 break;
10424 }
10425 }
10426
10427 if (data.hash_mode != 2500)
10428 {
10429 parser_status = parse_func (line_buf, line_len, hashes_buf);
10430 }
10431 else
10432 {
10433 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10434
10435 if (line_len > max_salt_size)
10436 {
10437 parser_status = PARSER_GLOBAL_LENGTH;
10438 }
10439 else
10440 {
10441 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10442
10443 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10444
10445 hashes_buf->salt->salt_len = line_len;
10446
10447 parser_status = PARSER_OK;
10448 }
10449 }
10450
10451 // if NOT parsed without error, we add the ":" to the plain
10452
10453 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10454 {
10455 plain_len++;
10456 plain_buf--;
10457 }
10458
10459 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10460
10461 if (parser_status < PARSER_GLOBAL_ZERO)
10462 {
10463 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10464
10465 continue;
10466 }
10467
10468 if (plain_len >= 255) continue;
10469
10470 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10471
10472 pot_ptr->plain_len = plain_len;
10473
10474 pot_cnt++;
10475 }
10476
10477 fclose (pot_fp);
10478
10479 SUPPRESS_OUTPUT = 0;
10480
10481 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10482 }
10483
10484 /**
10485 * word len
10486 */
10487
10488 uint pw_min = PW_MIN;
10489 uint pw_max = PW_MAX;
10490
10491 switch (hash_mode)
10492 {
10493 case 400: if (pw_max > 40) pw_max = 40;
10494 break;
10495 case 500: if (pw_max > 16) pw_max = 16;
10496 break;
10497 case 1500: if (pw_max > 8) pw_max = 8;
10498 break;
10499 case 1600: if (pw_max > 16) pw_max = 16;
10500 break;
10501 case 1800: if (pw_max > 16) pw_max = 16;
10502 break;
10503 case 2100: if (pw_max > 16) pw_max = 16;
10504 break;
10505 case 2500: if (pw_min < 8) pw_min = 8;
10506 break;
10507 case 3000: if (pw_max > 7) pw_max = 7;
10508 break;
10509 case 5200: if (pw_max > 24) pw_max = 24;
10510 break;
10511 case 5800: if (pw_max > 16) pw_max = 16;
10512 break;
10513 case 6300: if (pw_max > 16) pw_max = 16;
10514 break;
10515 case 7400: if (pw_max > 16) pw_max = 16;
10516 break;
10517 case 7900: if (pw_max > 48) pw_max = 48;
10518 break;
10519 case 8500: if (pw_max > 8) pw_max = 8;
10520 break;
10521 case 8600: if (pw_max > 16) pw_max = 16;
10522 break;
10523 case 9710: pw_min = 5;
10524 pw_max = 5;
10525 break;
10526 case 9810: pw_min = 5;
10527 pw_max = 5;
10528 break;
10529 case 10410: pw_min = 5;
10530 pw_max = 5;
10531 break;
10532 case 10300: if (pw_max < 3) pw_min = 3;
10533 if (pw_max > 40) pw_max = 40;
10534 break;
10535 case 10500: if (pw_max < 3) pw_min = 3;
10536 if (pw_max > 40) pw_max = 40;
10537 break;
10538 case 10700: if (pw_max > 16) pw_max = 16;
10539 break;
10540 case 11300: if (pw_max > 40) pw_max = 40;
10541 break;
10542 case 12500: if (pw_max > 20) pw_max = 20;
10543 break;
10544 case 12800: if (pw_max > 24) pw_max = 24;
10545 break;
10546 }
10547
10548 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10549 {
10550 switch (attack_kern)
10551 {
10552 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10553 break;
10554 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10555 break;
10556 }
10557 }
10558
10559 /**
10560 * charsets : keep them together for more easy maintainnce
10561 */
10562
10563 cs_t mp_sys[6] = { { { 0 }, 0 } };
10564 cs_t mp_usr[4] = { { { 0 }, 0 } };
10565
10566 mp_setup_sys (mp_sys);
10567
10568 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10569 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10570 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10571 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10572
10573 /**
10574 * load hashes, part I: find input mode, count hashes
10575 */
10576
10577 uint hashlist_mode = 0;
10578 uint hashlist_format = HLFMT_HASHCAT;
10579
10580 uint hashes_avail = 0;
10581
10582 if (benchmark == 0)
10583 {
10584 struct stat f;
10585
10586 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10587
10588 if ((hash_mode == 2500) ||
10589 (hash_mode == 5200) ||
10590 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10591 (hash_mode == 9000))
10592 {
10593 hashlist_mode = HL_MODE_ARG;
10594
10595 char *hashfile = myargv[optind];
10596
10597 data.hashfile = hashfile;
10598
10599 logfile_top_var_string ("target", hashfile);
10600 }
10601
10602 if (hashlist_mode == HL_MODE_ARG)
10603 {
10604 if (hash_mode == 2500)
10605 {
10606 struct stat st;
10607
10608 if (stat (data.hashfile, &st) == -1)
10609 {
10610 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10611
10612 return (-1);
10613 }
10614
10615 hashes_avail = st.st_size / sizeof (hccap_t);
10616 }
10617 else
10618 {
10619 hashes_avail = 1;
10620 }
10621 }
10622 else if (hashlist_mode == HL_MODE_FILE)
10623 {
10624 char *hashfile = myargv[optind];
10625
10626 data.hashfile = hashfile;
10627
10628 logfile_top_var_string ("target", hashfile);
10629
10630 FILE *fp = NULL;
10631
10632 if ((fp = fopen (hashfile, "rb")) == NULL)
10633 {
10634 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10635
10636 return (-1);
10637 }
10638
10639 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10640
10641 hashes_avail = count_lines (fp);
10642
10643 rewind (fp);
10644
10645 if (hashes_avail == 0)
10646 {
10647 log_error ("ERROR: hashfile is empty or corrupt");
10648
10649 fclose (fp);
10650
10651 return (-1);
10652 }
10653
10654 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10655
10656 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10657 {
10658 log_error ("ERROR: remove not supported in native hashfile-format mode");
10659
10660 fclose (fp);
10661
10662 return (-1);
10663 }
10664
10665 fclose (fp);
10666 }
10667 }
10668 else
10669 {
10670 hashlist_mode = HL_MODE_ARG;
10671
10672 hashes_avail = 1;
10673 }
10674
10675 if (hash_mode == 3000) hashes_avail *= 2;
10676
10677 data.hashlist_mode = hashlist_mode;
10678 data.hashlist_format = hashlist_format;
10679
10680 logfile_top_uint (hashlist_mode);
10681 logfile_top_uint (hashlist_format);
10682
10683 /**
10684 * load hashes, part II: allocate required memory, set pointers
10685 */
10686
10687 hash_t *hashes_buf = NULL;
10688 void *digests_buf = NULL;
10689 salt_t *salts_buf = NULL;
10690 void *esalts_buf = NULL;
10691
10692 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10693
10694 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10695
10696 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10697 {
10698 u32 hash_pos;
10699
10700 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10701 {
10702 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10703
10704 hashes_buf[hash_pos].hash_info = hash_info;
10705
10706 if (username && (remove || show || left))
10707 {
10708 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10709 }
10710
10711 if (benchmark)
10712 {
10713 hash_info->orighash = (char *) mymalloc (256);
10714 }
10715 }
10716 }
10717
10718 if (isSalted)
10719 {
10720 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10721
10722 if (esalt_size)
10723 {
10724 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10725 }
10726 }
10727 else
10728 {
10729 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10730 }
10731
10732 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10733 {
10734 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10735
10736 if (isSalted)
10737 {
10738 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10739
10740 if (esalt_size)
10741 {
10742 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10743 }
10744 }
10745 else
10746 {
10747 hashes_buf[hash_pos].salt = &salts_buf[0];
10748 }
10749 }
10750
10751 /**
10752 * load hashes, part III: parse hashes or generate them if benchmark
10753 */
10754
10755 uint hashes_cnt = 0;
10756
10757 if (benchmark == 0)
10758 {
10759 if (keyspace == 1)
10760 {
10761 // useless to read hash file for keyspace, cheat a little bit w/ optind
10762 }
10763 else if (hashes_avail == 0)
10764 {
10765 }
10766 else if (hashlist_mode == HL_MODE_ARG)
10767 {
10768 char *input_buf = myargv[optind];
10769
10770 uint input_len = strlen (input_buf);
10771
10772 logfile_top_var_string ("target", input_buf);
10773
10774 char *hash_buf = NULL;
10775 int hash_len = 0;
10776
10777 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10778
10779 if (hash_len)
10780 {
10781 if (opts_type & OPTS_TYPE_HASH_COPY)
10782 {
10783 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10784
10785 hash_info_tmp->orighash = mystrdup (hash_buf);
10786 }
10787
10788 if (isSalted)
10789 {
10790 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10791 }
10792
10793 int parser_status = PARSER_OK;
10794
10795 if (hash_mode == 2500)
10796 {
10797 if (hash_len == 0)
10798 {
10799 log_error ("ERROR: hccap file not specified");
10800
10801 return (-1);
10802 }
10803
10804 hashlist_mode = HL_MODE_FILE;
10805
10806 data.hashlist_mode = hashlist_mode;
10807
10808 FILE *fp = fopen (hash_buf, "rb");
10809
10810 if (fp == NULL)
10811 {
10812 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10813
10814 return (-1);
10815 }
10816
10817 if (hashes_avail < 1)
10818 {
10819 log_error ("ERROR: hccap file is empty or corrupt");
10820
10821 fclose (fp);
10822
10823 return (-1);
10824 }
10825
10826 uint hccap_size = sizeof (hccap_t);
10827
10828 char *in = (char *) mymalloc (hccap_size);
10829
10830 while (!feof (fp))
10831 {
10832 int n = fread (in, hccap_size, 1, fp);
10833
10834 if (n != 1)
10835 {
10836 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10837
10838 break;
10839 }
10840
10841 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10842
10843 if (parser_status != PARSER_OK)
10844 {
10845 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10846
10847 continue;
10848 }
10849
10850 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10851
10852 if ((show == 1) || (left == 1))
10853 {
10854 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10855
10856 char *salt_ptr = (char *) tmp_salt->salt_buf;
10857
10858 int cur_pos = tmp_salt->salt_len;
10859 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10860
10861 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10862
10863 u8 *pke_ptr = (u8 *) wpa->pke;
10864
10865 // do the appending task
10866
10867 snprintf (salt_ptr + cur_pos,
10868 rem_len,
10869 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10870 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10871 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10872
10873
10874 // memset () the remaining part of the salt
10875
10876 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10877 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10878
10879 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10880
10881 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10882 }
10883
10884 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);
10885 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);
10886
10887 hashes_cnt++;
10888 }
10889
10890 fclose (fp);
10891
10892 myfree (in);
10893 }
10894 else if (hash_mode == 3000)
10895 {
10896 if (hash_len == 32)
10897 {
10898 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10899
10900 hash_t *lm_hash_left = NULL;
10901
10902 if (parser_status == PARSER_OK)
10903 {
10904 lm_hash_left = &hashes_buf[hashes_cnt];
10905
10906 hashes_cnt++;
10907 }
10908 else
10909 {
10910 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10911 }
10912
10913 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10914
10915 hash_t *lm_hash_right = NULL;
10916
10917 if (parser_status == PARSER_OK)
10918 {
10919 lm_hash_right = &hashes_buf[hashes_cnt];
10920
10921 hashes_cnt++;
10922 }
10923 else
10924 {
10925 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10926 }
10927
10928 // show / left
10929
10930 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10931 {
10932 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);
10933 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);
10934 }
10935 }
10936 else
10937 {
10938 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10939
10940 if (parser_status == PARSER_OK)
10941 {
10942 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10943 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10944 }
10945
10946 if (parser_status == PARSER_OK)
10947 {
10948 hashes_cnt++;
10949 }
10950 else
10951 {
10952 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10953 }
10954 }
10955 }
10956 else
10957 {
10958 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10959
10960 if (parser_status == PARSER_OK)
10961 {
10962 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10963 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10964 }
10965
10966 if (parser_status == PARSER_OK)
10967 {
10968 hashes_cnt++;
10969 }
10970 else
10971 {
10972 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10973 }
10974 }
10975 }
10976 }
10977 else if (hashlist_mode == HL_MODE_FILE)
10978 {
10979 char *hashfile = data.hashfile;
10980
10981 FILE *fp;
10982
10983 if ((fp = fopen (hashfile, "rb")) == NULL)
10984 {
10985 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10986
10987 return (-1);
10988 }
10989
10990 uint line_num = 0;
10991
10992 while (!feof (fp))
10993 {
10994 line_num++;
10995
10996 char line_buf[BUFSIZ] = { 0 };
10997
10998 int line_len = fgetl (fp, line_buf);
10999
11000 if (line_len == 0) continue;
11001
11002 char *hash_buf = NULL;
11003 int hash_len = 0;
11004
11005 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11006
11007 if (username)
11008 {
11009 char *user_buf = NULL;
11010 int user_len = 0;
11011
11012 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11013
11014 if (remove || show)
11015 {
11016 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11017
11018 *user = (user_t *) mymalloc (sizeof (user_t));
11019
11020 user_t *user_ptr = *user;
11021
11022 if (user_buf != NULL)
11023 {
11024 user_ptr->user_name = mystrdup (user_buf);
11025 }
11026 else
11027 {
11028 user_ptr->user_name = mystrdup ("");
11029 }
11030
11031 user_ptr->user_len = user_len;
11032 }
11033 }
11034
11035 if (opts_type & OPTS_TYPE_HASH_COPY)
11036 {
11037 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11038
11039 hash_info_tmp->orighash = mystrdup (hash_buf);
11040 }
11041
11042 if (isSalted)
11043 {
11044 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11045 }
11046
11047 if (hash_mode == 3000)
11048 {
11049 if (hash_len == 32)
11050 {
11051 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11052
11053 if (parser_status < PARSER_GLOBAL_ZERO)
11054 {
11055 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11056
11057 continue;
11058 }
11059
11060 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11061
11062 hashes_cnt++;
11063
11064 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11065
11066 if (parser_status < PARSER_GLOBAL_ZERO)
11067 {
11068 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11069
11070 continue;
11071 }
11072
11073 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11074
11075 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);
11076
11077 hashes_cnt++;
11078
11079 // show / left
11080
11081 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);
11082 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);
11083 }
11084 else
11085 {
11086 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11087
11088 if (parser_status < PARSER_GLOBAL_ZERO)
11089 {
11090 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11091
11092 continue;
11093 }
11094
11095 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);
11096
11097 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11098 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11099
11100 hashes_cnt++;
11101 }
11102 }
11103 else
11104 {
11105 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11106
11107 if (parser_status < PARSER_GLOBAL_ZERO)
11108 {
11109 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11110
11111 continue;
11112 }
11113
11114 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);
11115
11116 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11117 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11118
11119 hashes_cnt++;
11120 }
11121 }
11122
11123 fclose (fp);
11124
11125 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11126
11127 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11128 }
11129 }
11130 else
11131 {
11132 if (isSalted)
11133 {
11134 hashes_buf[0].salt->salt_len = 8;
11135
11136 // special salt handling
11137
11138 switch (hash_mode)
11139 {
11140 case 1500: hashes_buf[0].salt->salt_len = 2;
11141 break;
11142 case 1731: hashes_buf[0].salt->salt_len = 4;
11143 break;
11144 case 2410: hashes_buf[0].salt->salt_len = 4;
11145 break;
11146 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11147 break;
11148 case 3100: hashes_buf[0].salt->salt_len = 1;
11149 break;
11150 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11151 break;
11152 case 5800: hashes_buf[0].salt->salt_len = 16;
11153 break;
11154 case 6800: hashes_buf[0].salt->salt_len = 32;
11155 break;
11156 case 8400: hashes_buf[0].salt->salt_len = 40;
11157 break;
11158 case 8800: hashes_buf[0].salt->salt_len = 16;
11159 break;
11160 case 8900: hashes_buf[0].salt->salt_len = 16;
11161 hashes_buf[0].salt->scrypt_N = 1024;
11162 hashes_buf[0].salt->scrypt_r = 1;
11163 hashes_buf[0].salt->scrypt_p = 1;
11164 break;
11165 case 9100: hashes_buf[0].salt->salt_len = 16;
11166 break;
11167 case 9300: hashes_buf[0].salt->salt_len = 14;
11168 hashes_buf[0].salt->scrypt_N = 16384;
11169 hashes_buf[0].salt->scrypt_r = 1;
11170 hashes_buf[0].salt->scrypt_p = 1;
11171 break;
11172 case 9400: hashes_buf[0].salt->salt_len = 16;
11173 break;
11174 case 9500: hashes_buf[0].salt->salt_len = 16;
11175 break;
11176 case 9600: hashes_buf[0].salt->salt_len = 16;
11177 break;
11178 case 9700: hashes_buf[0].salt->salt_len = 16;
11179 break;
11180 case 9710: hashes_buf[0].salt->salt_len = 16;
11181 break;
11182 case 9720: hashes_buf[0].salt->salt_len = 16;
11183 break;
11184 case 9800: hashes_buf[0].salt->salt_len = 16;
11185 break;
11186 case 9810: hashes_buf[0].salt->salt_len = 16;
11187 break;
11188 case 9820: hashes_buf[0].salt->salt_len = 16;
11189 break;
11190 case 10300: hashes_buf[0].salt->salt_len = 12;
11191 break;
11192 case 11500: hashes_buf[0].salt->salt_len = 4;
11193 break;
11194 case 11600: hashes_buf[0].salt->salt_len = 4;
11195 break;
11196 case 12400: hashes_buf[0].salt->salt_len = 4;
11197 break;
11198 case 12500: hashes_buf[0].salt->salt_len = 8;
11199 break;
11200 case 12600: hashes_buf[0].salt->salt_len = 64;
11201 break;
11202 }
11203
11204 // special esalt handling
11205
11206 switch (hash_mode)
11207 {
11208 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11209 break;
11210 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11211 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11212 break;
11213 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11214 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11215 break;
11216 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11217 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11218 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11219 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11220 break;
11221 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11222 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11223 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11224 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11225 break;
11226 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11227 break;
11228 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11229 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11230 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11231 break;
11232 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11233 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11234 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11235 break;
11236 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11237 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11238 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11239 break;
11240 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11241 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11242 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11243 break;
11244 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11245 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11246 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11247 break;
11248 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11249 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11250 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11251 break;
11252 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11253 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11254 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11255 break;
11256 }
11257 }
11258
11259 // set hashfile
11260
11261 switch (hash_mode)
11262 {
11263 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11264 break;
11265 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11266 break;
11267 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11268 break;
11269 case 6211:
11270 case 6212:
11271 case 6213:
11272 case 6221:
11273 case 6222:
11274 case 6223:
11275 case 6231:
11276 case 6232:
11277 case 6233:
11278 case 6241:
11279 case 6242:
11280 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11281 break;
11282 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11283 break;
11284 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11285 break;
11286 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11287 break;
11288 }
11289
11290 // set default iterations
11291
11292 switch (hash_mode)
11293 {
11294 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11295 break;
11296 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11297 break;
11298 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11299 break;
11300 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11301 break;
11302 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11303 break;
11304 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11305 break;
11306 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11307 break;
11308 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11309 break;
11310 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11311 break;
11312 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11313 break;
11314 case 6211:
11315 case 6212:
11316 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11317 break;
11318 case 6221:
11319 case 6222:
11320 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11321 break;
11322 case 6231:
11323 case 6232:
11324 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11325 break;
11326 case 6241:
11327 case 6242:
11328 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11329 break;
11330 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11331 break;
11332 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11333 break;
11334 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11335 break;
11336 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11337 break;
11338 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11339 break;
11340 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11341 break;
11342 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11343 break;
11344 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11345 break;
11346 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11347 break;
11348 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11349 break;
11350 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11351 break;
11352 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11353 break;
11354 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11355 break;
11356 case 8900: hashes_buf[0].salt->salt_iter = 1;
11357 break;
11358 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11359 break;
11360 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11361 break;
11362 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11363 break;
11364 case 9300: hashes_buf[0].salt->salt_iter = 1;
11365 break;
11366 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11367 break;
11368 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11369 break;
11370 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11371 break;
11372 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11373 break;
11374 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11375 break;
11376 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11377 break;
11378 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11379 break;
11380 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11381 break;
11382 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11383 break;
11384 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11385 break;
11386 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11387 break;
11388 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11389 break;
11390 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11391 break;
11392 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11393 break;
11394 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11395 break;
11396 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11397 break;
11398 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11399 break;
11400 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11401 break;
11402 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11403 break;
11404 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11405 break;
11406 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11407 break;
11408 }
11409
11410 hashes_cnt = 1;
11411 }
11412
11413 if (show == 1 || left == 1)
11414 {
11415 for (uint i = 0; i < pot_cnt; i++)
11416 {
11417 pot_t *pot_ptr = &pot[i];
11418
11419 hash_t *hashes_buf = &pot_ptr->hash;
11420
11421 local_free (hashes_buf->digest);
11422
11423 if (isSalted)
11424 {
11425 local_free (hashes_buf->salt);
11426 }
11427 }
11428
11429 local_free (pot);
11430
11431 if (data.quiet == 0) log_info_nn ("");
11432
11433 return (0);
11434 }
11435
11436 if (keyspace == 0)
11437 {
11438 if (hashes_cnt == 0)
11439 {
11440 log_error ("ERROR: No hashes loaded");
11441
11442 return (-1);
11443 }
11444 }
11445
11446 /**
11447 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11448 */
11449
11450 if (data.outfile != NULL)
11451 {
11452 if (data.hashfile != NULL)
11453 {
11454 #ifdef _POSIX
11455 struct stat tmpstat_outfile;
11456 struct stat tmpstat_hashfile;
11457 #endif
11458
11459 #ifdef _WIN
11460 struct stat64 tmpstat_outfile;
11461 struct stat64 tmpstat_hashfile;
11462 #endif
11463
11464 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11465
11466 if (tmp_outfile_fp)
11467 {
11468 #ifdef _POSIX
11469 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11470 #endif
11471
11472 #ifdef _WIN
11473 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11474 #endif
11475
11476 fclose (tmp_outfile_fp);
11477 }
11478
11479 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11480
11481 if (tmp_hashfile_fp)
11482 {
11483 #ifdef _POSIX
11484 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11485 #endif
11486
11487 #ifdef _WIN
11488 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11489 #endif
11490
11491 fclose (tmp_hashfile_fp);
11492 }
11493
11494 if (tmp_outfile_fp && tmp_outfile_fp)
11495 {
11496 tmpstat_outfile.st_mode = 0;
11497 tmpstat_outfile.st_nlink = 0;
11498 tmpstat_outfile.st_uid = 0;
11499 tmpstat_outfile.st_gid = 0;
11500 tmpstat_outfile.st_rdev = 0;
11501 tmpstat_outfile.st_atime = 0;
11502
11503 tmpstat_hashfile.st_mode = 0;
11504 tmpstat_hashfile.st_nlink = 0;
11505 tmpstat_hashfile.st_uid = 0;
11506 tmpstat_hashfile.st_gid = 0;
11507 tmpstat_hashfile.st_rdev = 0;
11508 tmpstat_hashfile.st_atime = 0;
11509
11510 #ifdef _POSIX
11511 tmpstat_outfile.st_blksize = 0;
11512 tmpstat_outfile.st_blocks = 0;
11513
11514 tmpstat_hashfile.st_blksize = 0;
11515 tmpstat_hashfile.st_blocks = 0;
11516 #endif
11517
11518 #ifdef _POSIX
11519 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11520 {
11521 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11522
11523 return (-1);
11524 }
11525 #endif
11526
11527 #ifdef _WIN
11528 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11529 {
11530 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11531
11532 return (-1);
11533 }
11534 #endif
11535 }
11536 }
11537 }
11538
11539 /**
11540 * Remove duplicates
11541 */
11542
11543 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11544
11545 if (isSalted)
11546 {
11547 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11548 }
11549 else
11550 {
11551 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11552 }
11553
11554 uint hashes_cnt_orig = hashes_cnt;
11555
11556 hashes_cnt = 1;
11557
11558 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11559 {
11560 if (isSalted)
11561 {
11562 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11563 {
11564 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11565 }
11566 }
11567 else
11568 {
11569 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11570 }
11571
11572 if (hashes_pos > hashes_cnt)
11573 {
11574 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11575 }
11576
11577 hashes_cnt++;
11578 }
11579
11580 /**
11581 * Potfile removes
11582 */
11583
11584 uint potfile_remove_cracks = 0;
11585
11586 if (potfile_disable == 0)
11587 {
11588 hash_t hash_buf;
11589
11590 hash_buf.digest = mymalloc (dgst_size);
11591 hash_buf.salt = NULL;
11592 hash_buf.esalt = NULL;
11593 hash_buf.hash_info = NULL;
11594 hash_buf.cracked = 0;
11595
11596 if (isSalted)
11597 {
11598 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11599 }
11600
11601 if (esalt_size)
11602 {
11603 hash_buf.esalt = mymalloc (esalt_size);
11604 }
11605
11606 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11607
11608 // no solution for these special hash types (for instane because they use hashfile in output etc)
11609 if ((hash_mode != 5200) &&
11610 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11611 (hash_mode != 9000))
11612 {
11613 FILE *fp = fopen (potfile, "rb");
11614
11615 if (fp != NULL)
11616 {
11617 while (!feof (fp))
11618 {
11619 char line_buf[BUFSIZ] = { 0 };
11620
11621 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11622
11623 if (ptr == NULL) break;
11624
11625 int line_len = strlen (line_buf);
11626
11627 if (line_len == 0) continue;
11628
11629 int iter = MAX_CUT_TRIES;
11630
11631 for (int i = line_len - 1; i && iter; i--, line_len--)
11632 {
11633 if (line_buf[i] != ':') continue;
11634
11635 if (isSalted)
11636 {
11637 memset (hash_buf.salt, 0, sizeof (salt_t));
11638 }
11639
11640 hash_t *found = NULL;
11641
11642 if (hash_mode == 6800)
11643 {
11644 if (i < 64) // 64 = 16 * uint in salt_buf[]
11645 {
11646 // manipulate salt_buf
11647 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11648
11649 hash_buf.salt->salt_len = i;
11650
11651 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11652 }
11653 }
11654 else if (hash_mode == 2500)
11655 {
11656 if (i < 64) // 64 = 16 * uint in salt_buf[]
11657 {
11658 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11659 // manipulate salt_buf
11660
11661 // to be safe work with a copy (because of line_len loop, i etc)
11662
11663 char line_buf_cpy[BUFSIZ] = { 0 };
11664
11665 memcpy (line_buf_cpy, line_buf, i);
11666
11667 char *mac2_pos = strrchr (line_buf_cpy, ':');
11668
11669 if (mac2_pos == NULL) continue;
11670
11671 mac2_pos[0] = 0;
11672 mac2_pos++;
11673
11674 if (strlen (mac2_pos) != 12) continue;
11675
11676 char *mac1_pos = strrchr (line_buf_cpy, ':');
11677
11678 if (mac1_pos == NULL) continue;
11679
11680 mac1_pos[0] = 0;
11681 mac1_pos++;
11682
11683 if (strlen (mac1_pos) != 12) continue;
11684
11685 uint essid_length = mac1_pos - line_buf_cpy - 1;
11686
11687 // here we need the ESSID
11688 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11689
11690 hash_buf.salt->salt_len = essid_length;
11691
11692 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11693
11694 if (found)
11695 {
11696 wpa_t *wpa = (wpa_t *) found->esalt;
11697
11698 uint pke[25] = { 0 };
11699
11700 char *pke_ptr = (char *) pke;
11701
11702 for (uint i = 0; i < 25; i++)
11703 {
11704 pke[i] = byte_swap_32 (wpa->pke[i]);
11705 }
11706
11707 u8 mac1[6] = { 0 };
11708 u8 mac2[6] = { 0 };
11709
11710 memcpy (mac1, pke_ptr + 23, 6);
11711 memcpy (mac2, pke_ptr + 29, 6);
11712
11713 // compare hex string(s) vs binary MAC address(es)
11714
11715 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11716 {
11717 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11718 {
11719 found = NULL;
11720 break;
11721 }
11722 }
11723
11724 // early skip ;)
11725 if (!found) continue;
11726
11727 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11728 {
11729 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11730 {
11731 found = NULL;
11732 break;
11733 }
11734 }
11735 }
11736 }
11737 }
11738 else
11739 {
11740 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11741
11742 if (parser_status == PARSER_OK)
11743 {
11744 if (isSalted)
11745 {
11746 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11747 }
11748 else
11749 {
11750 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11751 }
11752 }
11753 }
11754
11755 if (found == NULL) continue;
11756
11757 if (!found->cracked) potfile_remove_cracks++;
11758
11759 found->cracked = 1;
11760
11761 if (found) break;
11762
11763 iter--;
11764 }
11765 }
11766
11767 fclose (fp);
11768 }
11769 }
11770
11771 if (esalt_size)
11772 {
11773 local_free (hash_buf.esalt);
11774 }
11775
11776 if (isSalted)
11777 {
11778 local_free (hash_buf.salt);
11779 }
11780
11781 local_free (hash_buf.digest);
11782 }
11783
11784 /**
11785 * Now generate all the buffers required for later
11786 */
11787
11788 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11789
11790 salt_t *salts_buf_new = NULL;
11791 void *esalts_buf_new = NULL;
11792
11793 if (isSalted)
11794 {
11795 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11796
11797 if (esalt_size)
11798 {
11799 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11800 }
11801 }
11802 else
11803 {
11804 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11805 }
11806
11807 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11808
11809 uint digests_cnt = hashes_cnt;
11810 uint digests_done = 0;
11811
11812 uint size_digests = digests_cnt * dgst_size;
11813 uint size_shown = digests_cnt * sizeof (uint);
11814
11815 uint *digests_shown = (uint *) mymalloc (size_shown);
11816 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11817
11818 uint salts_cnt = 0;
11819 uint salts_done = 0;
11820
11821 hashinfo_t **hash_info = NULL;
11822
11823 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11824 {
11825 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11826
11827 if (username && (remove || show))
11828 {
11829 uint user_pos;
11830
11831 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11832 {
11833 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11834
11835 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11836 }
11837 }
11838 }
11839
11840 uint *salts_shown = (uint *) mymalloc (size_shown);
11841
11842 salt_t *salt_buf;
11843
11844 {
11845 // copied from inner loop
11846
11847 salt_buf = &salts_buf_new[salts_cnt];
11848
11849 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11850
11851 if (esalt_size)
11852 {
11853 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11854 }
11855
11856 salt_buf->digests_cnt = 0;
11857 salt_buf->digests_done = 0;
11858 salt_buf->digests_offset = 0;
11859
11860 salts_cnt++;
11861 }
11862
11863 if (hashes_buf[0].cracked == 1)
11864 {
11865 digests_shown[0] = 1;
11866
11867 digests_done++;
11868
11869 salt_buf->digests_done++;
11870 }
11871
11872 salt_buf->digests_cnt++;
11873
11874 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11875
11876 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11877 {
11878 hash_info[0] = hashes_buf[0].hash_info;
11879 }
11880
11881 // copy from inner loop
11882
11883 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11884 {
11885 if (isSalted)
11886 {
11887 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11888 {
11889 salt_buf = &salts_buf_new[salts_cnt];
11890
11891 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11892
11893 if (esalt_size)
11894 {
11895 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11896 }
11897
11898 salt_buf->digests_cnt = 0;
11899 salt_buf->digests_done = 0;
11900 salt_buf->digests_offset = hashes_pos;
11901
11902 salts_cnt++;
11903 }
11904 }
11905
11906 if (hashes_buf[hashes_pos].cracked == 1)
11907 {
11908 digests_shown[hashes_pos] = 1;
11909
11910 digests_done++;
11911
11912 salt_buf->digests_done++;
11913 }
11914
11915 salt_buf->digests_cnt++;
11916
11917 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11918
11919 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11920 {
11921 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11922 }
11923 }
11924
11925 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11926 {
11927 salt_t *salt_buf = &salts_buf_new[salt_pos];
11928
11929 if (salt_buf->digests_done == salt_buf->digests_cnt)
11930 {
11931 salts_shown[salt_pos] = 1;
11932
11933 salts_done++;
11934 }
11935
11936 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11937 }
11938
11939 local_free (digests_buf);
11940 local_free (salts_buf);
11941 local_free (esalts_buf);
11942
11943 digests_buf = digests_buf_new;
11944 salts_buf = salts_buf_new;
11945 esalts_buf = esalts_buf_new;
11946
11947 local_free (hashes_buf);
11948
11949 /**
11950 * special modification not set from parser
11951 */
11952
11953 switch (hash_mode)
11954 {
11955 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11956 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11957 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11958 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11959 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11960 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11961 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11962 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11963 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11964 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11965 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11966 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11967 }
11968
11969 if (truecrypt_keyfiles)
11970 {
11971 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11972
11973 char *keyfiles = strdup (truecrypt_keyfiles);
11974
11975 char *keyfile = strtok (keyfiles, ",");
11976
11977 do
11978 {
11979 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
11980
11981 } while ((keyfile = strtok (NULL, ",")) != NULL);
11982
11983 free (keyfiles);
11984 }
11985
11986 data.digests_cnt = digests_cnt;
11987 data.digests_done = digests_done;
11988 data.digests_buf = digests_buf;
11989 data.digests_shown = digests_shown;
11990 data.digests_shown_tmp = digests_shown_tmp;
11991
11992 data.salts_cnt = salts_cnt;
11993 data.salts_done = salts_done;
11994 data.salts_buf = salts_buf;
11995 data.salts_shown = salts_shown;
11996
11997 data.esalts_buf = esalts_buf;
11998 data.hash_info = hash_info;
11999
12000 /**
12001 * Automatic Optimizers
12002 */
12003
12004 if (salts_cnt == 1)
12005 opti_type |= OPTI_TYPE_SINGLE_SALT;
12006
12007 if (digests_cnt == 1)
12008 opti_type |= OPTI_TYPE_SINGLE_HASH;
12009
12010 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12011 opti_type |= OPTI_TYPE_NOT_ITERATED;
12012
12013 if (attack_mode == ATTACK_MODE_BF)
12014 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12015
12016 data.opti_type = opti_type;
12017
12018 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12019 {
12020 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12021 {
12022 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12023 {
12024 if (opts_type & OPTS_TYPE_ST_ADD80)
12025 {
12026 opts_type &= ~OPTS_TYPE_ST_ADD80;
12027 opts_type |= OPTS_TYPE_PT_ADD80;
12028 }
12029
12030 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12031 {
12032 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12033 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12034 }
12035
12036 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12037 {
12038 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12039 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12040 }
12041 }
12042 }
12043 }
12044
12045 /**
12046 * Some algorithm, like descrypt, can benefit from JIT compilation
12047 */
12048
12049 int force_jit_compilation = -1;
12050
12051 if (hash_mode == 8900)
12052 {
12053 force_jit_compilation = 8900;
12054 }
12055 else if (hash_mode == 9300)
12056 {
12057 force_jit_compilation = 8900;
12058 }
12059 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12060 {
12061 force_jit_compilation = 1500;
12062 }
12063
12064 /**
12065 * generate bitmap tables
12066 */
12067
12068 const uint bitmap_shift1 = 5;
12069 const uint bitmap_shift2 = 13;
12070
12071 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12072
12073 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12074 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12075 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12076 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12077 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12078 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12079 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12080 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12081
12082 uint bitmap_bits;
12083 uint bitmap_nums;
12084 uint bitmap_mask;
12085 uint bitmap_size;
12086
12087 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12088 {
12089 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12090
12091 bitmap_nums = 1 << bitmap_bits;
12092
12093 bitmap_mask = bitmap_nums - 1;
12094
12095 bitmap_size = bitmap_nums * sizeof (uint);
12096
12097 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12098
12099 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;
12100 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;
12101
12102 break;
12103 }
12104
12105 bitmap_nums = 1 << bitmap_bits;
12106
12107 bitmap_mask = bitmap_nums - 1;
12108
12109 bitmap_size = bitmap_nums * sizeof (uint);
12110
12111 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);
12112 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);
12113
12114 /**
12115 * prepare quick rule
12116 */
12117
12118 data.rule_buf_l = rule_buf_l;
12119 data.rule_buf_r = rule_buf_r;
12120
12121 int rule_len_l = (int) strlen (rule_buf_l);
12122 int rule_len_r = (int) strlen (rule_buf_r);
12123
12124 data.rule_len_l = rule_len_l;
12125 data.rule_len_r = rule_len_r;
12126
12127 /**
12128 * load rules
12129 */
12130
12131 uint *all_kernel_rules_cnt = NULL;
12132
12133 kernel_rule_t **all_kernel_rules_buf = NULL;
12134
12135 if (rp_files_cnt)
12136 {
12137 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12138
12139 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12140 }
12141
12142 char rule_buf[BUFSIZ] = { 0 };
12143
12144 int rule_len = 0;
12145
12146 for (uint i = 0; i < rp_files_cnt; i++)
12147 {
12148 uint kernel_rules_avail = 0;
12149
12150 uint kernel_rules_cnt = 0;
12151
12152 kernel_rule_t *kernel_rules_buf = NULL;
12153
12154 char *rp_file = rp_files[i];
12155
12156 char in[BLOCK_SIZE] = { 0 };
12157 char out[BLOCK_SIZE] = { 0 };
12158
12159 FILE *fp = NULL;
12160
12161 uint rule_line = 0;
12162
12163 if ((fp = fopen (rp_file, "rb")) == NULL)
12164 {
12165 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12166
12167 return (-1);
12168 }
12169
12170 while (!feof (fp))
12171 {
12172 memset (rule_buf, 0, BUFSIZ);
12173
12174 rule_len = fgetl (fp, rule_buf);
12175
12176 rule_line++;
12177
12178 if (rule_len == 0) continue;
12179
12180 if (rule_buf[0] == '#') continue;
12181
12182 if (kernel_rules_avail == kernel_rules_cnt)
12183 {
12184 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12185
12186 kernel_rules_avail += INCR_RULES;
12187 }
12188
12189 memset (in, 0, BLOCK_SIZE);
12190 memset (out, 0, BLOCK_SIZE);
12191
12192 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12193
12194 if (result == -1)
12195 {
12196 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12197
12198 continue;
12199 }
12200
12201 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12202 {
12203 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12204
12205 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12206
12207 continue;
12208 }
12209
12210 /* its so slow
12211 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12212 {
12213 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12214
12215 continue;
12216 }
12217 */
12218
12219 kernel_rules_cnt++;
12220 }
12221
12222 fclose (fp);
12223
12224 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12225
12226 all_kernel_rules_buf[i] = kernel_rules_buf;
12227 }
12228
12229 /**
12230 * merge rules or automatic rule generator
12231 */
12232
12233 uint kernel_rules_cnt = 0;
12234
12235 kernel_rule_t *kernel_rules_buf = NULL;
12236
12237 if (attack_mode == ATTACK_MODE_STRAIGHT)
12238 {
12239 if (rp_files_cnt)
12240 {
12241 kernel_rules_cnt = 1;
12242
12243 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12244
12245 repeats[0] = kernel_rules_cnt;
12246
12247 for (uint i = 0; i < rp_files_cnt; i++)
12248 {
12249 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12250
12251 repeats[i + 1] = kernel_rules_cnt;
12252 }
12253
12254 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12255
12256 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12257
12258 for (uint i = 0; i < kernel_rules_cnt; i++)
12259 {
12260 uint out_pos = 0;
12261
12262 kernel_rule_t *out = &kernel_rules_buf[i];
12263
12264 for (uint j = 0; j < rp_files_cnt; j++)
12265 {
12266 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12267 uint in_pos;
12268
12269 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12270
12271 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12272 {
12273 if (out_pos == RULES_MAX - 1)
12274 {
12275 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12276
12277 break;
12278 }
12279
12280 out->cmds[out_pos] = in->cmds[in_pos];
12281 }
12282 }
12283 }
12284
12285 local_free (repeats);
12286 }
12287 else if (rp_gen)
12288 {
12289 uint kernel_rules_avail = 0;
12290
12291 while (kernel_rules_cnt < rp_gen)
12292 {
12293 if (kernel_rules_avail == kernel_rules_cnt)
12294 {
12295 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12296
12297 kernel_rules_avail += INCR_RULES;
12298 }
12299
12300 memset (rule_buf, 0, BLOCK_SIZE);
12301
12302 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12303
12304 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12305
12306 kernel_rules_cnt++;
12307 }
12308 }
12309 }
12310
12311 /**
12312 * generate NOP rules
12313 */
12314
12315 if (kernel_rules_cnt == 0)
12316 {
12317 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12318
12319 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12320
12321 kernel_rules_cnt++;
12322 }
12323
12324 data.kernel_rules_cnt = kernel_rules_cnt;
12325 data.kernel_rules_buf = kernel_rules_buf;
12326
12327 /**
12328 * OpenCL platforms: detect
12329 */
12330
12331 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12332 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12333
12334 cl_uint platforms_cnt = 0;
12335 cl_uint platform_devices_cnt = 0;
12336
12337 if (keyspace == 0)
12338 {
12339 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12340
12341 if (platforms_cnt == 0)
12342 {
12343 log_error ("ERROR: No OpenCL compatible platform found");
12344
12345 return (-1);
12346 }
12347 }
12348
12349 /**
12350 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12351 */
12352
12353 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12354 {
12355 cl_platform_id platform = platforms[platform_id];
12356
12357 char platform_vendor[INFOSZ] = { 0 };
12358
12359 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12360
12361 #ifdef HAVE_HWMON
12362 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12363 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12364 {
12365 // make sure that we do not directly control the fan for NVidia
12366
12367 gpu_temp_retain = 0;
12368
12369 data.gpu_temp_retain = gpu_temp_retain;
12370 }
12371 #endif // HAVE_NVML || HAVE_NVAPI
12372 #endif
12373 }
12374
12375 /**
12376 * OpenCL devices: simply push all devices from all platforms into the same device array
12377 */
12378
12379 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12380
12381 data.devices_param = devices_param;
12382
12383 uint devices_cnt = 0;
12384
12385 uint devices_active = 0;
12386
12387 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12388 {
12389 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12390
12391 cl_platform_id platform = platforms[platform_id];
12392
12393 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12394
12395 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12396 {
12397 size_t param_value_size = 0;
12398
12399 const uint device_id = devices_cnt;
12400
12401 hc_device_param_t *device_param = &data.devices_param[device_id];
12402
12403 device_param->device = platform_devices[platform_devices_id];
12404
12405 device_param->device_id = device_id;
12406
12407 device_param->platform_devices_id = platform_devices_id;
12408
12409 // device_type
12410
12411 cl_device_type device_type;
12412
12413 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12414
12415 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12416
12417 device_param->device_type = device_type;
12418
12419 // vendor_id
12420
12421 cl_uint vendor_id = 0;
12422
12423 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12424
12425 device_param->vendor_id = vendor_id;
12426
12427 // device_name
12428
12429 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12430
12431 char *device_name = (char *) mymalloc (param_value_size);
12432
12433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12434
12435 device_param->device_name = device_name;
12436
12437 // tuning db
12438
12439 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode, workload_profile);
12440
12441 // device_version
12442
12443 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12444
12445 char *device_version = (char *) mymalloc (param_value_size);
12446
12447 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12448
12449 device_param->device_version = device_version;
12450
12451 // device_opencl_version
12452
12453 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12454
12455 char *device_opencl_version = (char *) mymalloc (param_value_size);
12456
12457 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12458
12459 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12460
12461 myfree (device_opencl_version);
12462
12463 if (strstr (device_version, "pocl"))
12464 {
12465 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12466 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12467
12468 cl_uint vendor_id = VENDOR_ID_GENERIC;
12469
12470 device_param->vendor_id = vendor_id;
12471 }
12472
12473 // vector_width
12474
12475 cl_uint vector_width;
12476
12477 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12478 {
12479 if (tuningdb_entry->vector_width == -1)
12480 {
12481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12482
12483 if (opti_type & OPTI_TYPE_USES_BITS_64)
12484 {
12485 if (vector_width > 1) vector_width /= 2;
12486 }
12487 }
12488 else
12489 {
12490 vector_width = (cl_uint) tuningdb_entry->vector_width;
12491 }
12492 }
12493 else
12494 {
12495 vector_width = opencl_vector_width;
12496 }
12497
12498 if (vector_width > 8) vector_width = 8;
12499
12500 device_param->vector_width = vector_width;
12501
12502 // max_compute_units
12503
12504 cl_uint device_processors;
12505
12506 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12507
12508 device_param->device_processors = device_processors;
12509
12510 // max_mem_alloc_size
12511
12512 cl_ulong device_maxmem_alloc;
12513
12514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12515
12516 device_param->device_maxmem_alloc = device_maxmem_alloc;
12517
12518 // max_mem_alloc_size
12519
12520 cl_ulong device_global_mem;
12521
12522 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12523
12524 device_param->device_global_mem = device_global_mem;
12525
12526 // max_clock_frequency
12527
12528 cl_uint device_maxclock_frequency;
12529
12530 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12531
12532 device_param->device_maxclock_frequency = device_maxclock_frequency;
12533
12534 // skipped
12535
12536 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12537 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12538
12539 device_param->skipped = (skipped1 || skipped2);
12540
12541 // driver_version
12542 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12543
12544 char *driver_version = (char *) mymalloc (param_value_size);
12545
12546 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12547
12548 device_param->driver_version = driver_version;
12549
12550 // device_name_chksum
12551
12552 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12553
12554 #if __x86_64__
12555 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);
12556 #else
12557 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);
12558 #endif
12559
12560 uint device_name_digest[4] = { 0 };
12561
12562 md5_64 ((uint *) device_name_chksum, device_name_digest);
12563
12564 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12565
12566 device_param->device_name_chksum = device_name_chksum;
12567
12568 // device_processor_cores
12569
12570 if (device_type & CL_DEVICE_TYPE_CPU)
12571 {
12572 cl_uint device_processor_cores = 1;
12573
12574 device_param->device_processor_cores = device_processor_cores;
12575 }
12576
12577 if (device_type & CL_DEVICE_TYPE_GPU)
12578 {
12579 if (vendor_id == VENDOR_ID_AMD)
12580 {
12581 cl_uint device_processor_cores = 0;
12582
12583 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12584
12585 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12586
12587 device_param->device_processor_cores = device_processor_cores;
12588 }
12589 else if (vendor_id == VENDOR_ID_NV)
12590 {
12591 cl_uint kernel_exec_timeout = 0;
12592
12593 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12594
12595 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12596
12597 device_param->kernel_exec_timeout = kernel_exec_timeout;
12598
12599 cl_uint device_processor_cores = 0;
12600
12601 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12602
12603 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12604
12605 device_param->device_processor_cores = device_processor_cores;
12606
12607 cl_uint sm_minor = 0;
12608 cl_uint sm_major = 0;
12609
12610 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12611 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12612
12613 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12614 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12615
12616 device_param->sm_minor = sm_minor;
12617 device_param->sm_major = sm_major;
12618 }
12619 else
12620 {
12621 cl_uint device_processor_cores = 1;
12622
12623 device_param->device_processor_cores = device_processor_cores;
12624 }
12625 }
12626
12627 // display results
12628
12629 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12630 {
12631 if (device_param->skipped == 0)
12632 {
12633 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12634 device_id + 1,
12635 device_name,
12636 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12637 (unsigned int) (device_global_mem / 1024 / 1024),
12638 (unsigned int) (device_maxclock_frequency),
12639 (unsigned int) device_processors);
12640 }
12641 else
12642 {
12643 log_info ("Device #%u: %s, skipped",
12644 device_id + 1,
12645 device_name);
12646 }
12647 }
12648
12649 // common driver check
12650
12651 if (device_param->skipped == 0)
12652 {
12653 if (strstr (device_version, "pocl"))
12654 {
12655 if (force == 0)
12656 {
12657 log_info ("");
12658 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12659 log_info ("You are STRONGLY encouraged not to use it");
12660 log_info ("You can use --force to override this but do not post error reports if you do so");
12661 log_info ("");
12662
12663 return (-1);
12664 }
12665 }
12666
12667 if (device_type & CL_DEVICE_TYPE_GPU)
12668 {
12669 if (vendor_id == VENDOR_ID_NV)
12670 {
12671 if (device_param->kernel_exec_timeout != 0)
12672 {
12673 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);
12674 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12675 }
12676 }
12677 else if (vendor_id == VENDOR_ID_AMD)
12678 {
12679 int catalyst_check = (force == 1) ? 0 : 1;
12680
12681 int catalyst_warn = 0;
12682
12683 int catalyst_broken = 0;
12684
12685 if (catalyst_check == 1)
12686 {
12687 catalyst_warn = 1;
12688
12689 // v14.9 and higher
12690 if (atoi (device_param->driver_version) >= 1573)
12691 {
12692 catalyst_warn = 0;
12693 }
12694
12695 catalyst_check = 0;
12696 }
12697
12698 if (catalyst_broken == 1)
12699 {
12700 log_info ("");
12701 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12702 log_info ("It will pass over cracked hashes and does not report them as cracked");
12703 log_info ("You are STRONGLY encouraged not to use it");
12704 log_info ("You can use --force to override this but do not post error reports if you do so");
12705 log_info ("");
12706
12707 return (-1);
12708 }
12709
12710 if (catalyst_warn == 1)
12711 {
12712 log_info ("");
12713 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12714 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12715 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12716 #ifdef _WIN
12717 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12718 #endif
12719 log_info ("You can use --force to override this but do not post error reports if you do so");
12720 log_info ("");
12721
12722 return (-1);
12723 }
12724 }
12725 }
12726
12727 /**
12728 * kernel accel and loops auto adjustment
12729 */
12730
12731 uint _kernel_accel = kernel_accel;
12732 uint _kernel_loops = kernel_loops;
12733
12734 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode, workload_profile);
12735
12736 if (kernel_accel_chgd == 0)
12737 {
12738 _kernel_accel = tuningdb_entry->kernel_accel;
12739 }
12740
12741 if (kernel_loops_chgd == 0)
12742 {
12743 _kernel_loops = tuningdb_entry->kernel_loops;
12744 }
12745
12746 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
12747 {
12748 _kernel_loops = 1024;
12749 }
12750
12751 if (hash_mode == 12500)
12752 {
12753 _kernel_loops = ROUNDS_RAR3 / 16;
12754 }
12755
12756 device_param->kernel_accel = _kernel_accel;
12757 device_param->kernel_loops = _kernel_loops;
12758
12759 devices_active++;
12760 }
12761
12762 // next please
12763
12764 devices_cnt++;
12765 }
12766 }
12767
12768 if (keyspace == 0 && devices_active == 0)
12769 {
12770 log_error ("ERROR: No devices found/left");
12771
12772 return (-1);
12773 }
12774
12775 data.devices_cnt = devices_cnt;
12776
12777 data.devices_active = devices_active;
12778
12779 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12780 {
12781 log_info ("");
12782 }
12783
12784 /**
12785 * HM devices: init
12786 */
12787
12788 #ifdef HAVE_HWMON
12789 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12790 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12791 #endif
12792
12793 #ifdef HAVE_ADL
12794 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12795 #endif
12796
12797 if (gpu_temp_disable == 0)
12798 {
12799 #if defined(WIN) && defined(HAVE_NVAPI)
12800 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12801
12802 if (nvapi_init (nvapi) == 0)
12803 data.hm_nv = nvapi;
12804
12805 if (data.hm_nv)
12806 {
12807 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12808 {
12809 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12810
12811 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12812
12813 int tmp_out = 0;
12814
12815 for (int i = 0; i < tmp_in; i++)
12816 {
12817 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12818 }
12819
12820 for (int i = 0; i < tmp_out; i++)
12821 {
12822 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12823
12824 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12825
12826 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12827 }
12828 }
12829 }
12830 #endif // WIN && HAVE_NVAPI
12831
12832 #if defined(LINUX) && defined(HAVE_NVML)
12833 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12834
12835 if (nvml_init (nvml) == 0)
12836 data.hm_nv = nvml;
12837
12838 if (data.hm_nv)
12839 {
12840 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12841 {
12842 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12843
12844 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12845
12846 int tmp_out = 0;
12847
12848 for (int i = 0; i < tmp_in; i++)
12849 {
12850 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12851 }
12852
12853 for (int i = 0; i < tmp_out; i++)
12854 {
12855 unsigned int speed;
12856
12857 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;
12858 }
12859 }
12860 }
12861 #endif // LINUX && HAVE_NVML
12862
12863 data.hm_amd = NULL;
12864
12865 #ifdef HAVE_ADL
12866 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
12867
12868 if (adl_init (adl) == 0)
12869 data.hm_amd = adl;
12870
12871 if (data.hm_amd)
12872 {
12873 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12874 {
12875 // total number of adapters
12876
12877 int hm_adapters_num;
12878
12879 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
12880
12881 // adapter info
12882
12883 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
12884
12885 if (lpAdapterInfo == NULL) return (-1);
12886
12887 // get a list (of ids of) valid/usable adapters
12888
12889 int num_adl_adapters = 0;
12890
12891 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12892
12893 if (num_adl_adapters > 0)
12894 {
12895 hc_thread_mutex_lock (mux_adl);
12896
12897 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12898
12899 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12900
12901 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12902 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12903
12904 hc_thread_mutex_unlock (mux_adl);
12905 }
12906
12907 myfree (valid_adl_device_list);
12908 myfree (lpAdapterInfo);
12909 }
12910 }
12911 #endif // HAVE_ADL
12912
12913 if (data.hm_amd == NULL && data.hm_nv == NULL)
12914 {
12915 gpu_temp_disable = 1;
12916 }
12917 }
12918
12919 /**
12920 * OpenCL devices: allocate buffer for device specific information
12921 */
12922
12923 #ifdef HAVE_HWMON
12924 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
12925
12926 #ifdef HAVE_ADL
12927 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
12928
12929 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
12930 #endif // ADL
12931 #endif
12932
12933 /**
12934 * enable custom signal handler(s)
12935 */
12936
12937 if (benchmark == 0)
12938 {
12939 hc_signal (sigHandler_default);
12940 }
12941 else
12942 {
12943 hc_signal (sigHandler_benchmark);
12944 }
12945
12946 /**
12947 * User-defined GPU temp handling
12948 */
12949
12950 #ifdef HAVE_HWMON
12951 if (gpu_temp_disable == 1)
12952 {
12953 gpu_temp_abort = 0;
12954 gpu_temp_retain = 0;
12955 }
12956
12957 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12958 {
12959 if (gpu_temp_abort < gpu_temp_retain)
12960 {
12961 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12962
12963 return (-1);
12964 }
12965 }
12966
12967 data.gpu_temp_disable = gpu_temp_disable;
12968 data.gpu_temp_abort = gpu_temp_abort;
12969 data.gpu_temp_retain = gpu_temp_retain;
12970 #endif
12971
12972 /**
12973 * inform the user
12974 */
12975
12976 if (data.quiet == 0)
12977 {
12978 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12979
12980 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);
12981
12982 if (attack_mode == ATTACK_MODE_STRAIGHT)
12983 {
12984 log_info ("Rules: %u", kernel_rules_cnt);
12985 }
12986
12987 if (opti_type)
12988 {
12989 log_info ("Applicable Optimizers:");
12990
12991 for (uint i = 0; i < 32; i++)
12992 {
12993 const uint opti_bit = 1u << i;
12994
12995 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12996 }
12997 }
12998
12999 /**
13000 * Watchdog and Temperature balance
13001 */
13002
13003 #ifdef HAVE_HWMON
13004 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13005 {
13006 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13007 }
13008
13009 if (gpu_temp_abort == 0)
13010 {
13011 log_info ("Watchdog: Temperature abort trigger disabled");
13012 }
13013 else
13014 {
13015 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13016 }
13017
13018 if (gpu_temp_retain == 0)
13019 {
13020 log_info ("Watchdog: Temperature retain trigger disabled");
13021 }
13022 else
13023 {
13024 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13025 }
13026 #endif
13027 }
13028
13029 if (data.quiet == 0) log_info ("");
13030
13031 /**
13032 * HM devices: copy
13033 */
13034
13035 if (gpu_temp_disable == 0)
13036 {
13037 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13038 {
13039 hc_device_param_t *device_param = &data.devices_param[device_id];
13040
13041 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13042
13043 if (device_param->skipped) continue;
13044
13045 const uint platform_devices_id = device_param->platform_devices_id;
13046
13047 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13048 if (device_param->vendor_id == VENDOR_ID_NV)
13049 {
13050 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13051 }
13052 #endif
13053
13054 #ifdef HAVE_ADL
13055 if (device_param->vendor_id == VENDOR_ID_AMD)
13056 {
13057 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13058 }
13059 #endif
13060 }
13061 }
13062
13063 /*
13064 * Temporary fix:
13065 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13066 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13067 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13068 * Driver / ADL bug?
13069 */
13070
13071 #ifdef HAVE_ADL
13072 if (powertune_enable == 1)
13073 {
13074 hc_thread_mutex_lock (mux_adl);
13075
13076 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13077 {
13078 hc_device_param_t *device_param = &data.devices_param[device_id];
13079
13080 if (device_param->skipped) continue;
13081
13082 if (data.hm_device[device_id].od_version == 6)
13083 {
13084 // set powertune value only
13085
13086 int powertune_supported = 0;
13087
13088 int ADL_rc = 0;
13089
13090 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13091 {
13092 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13093
13094 return (-1);
13095 }
13096
13097 if (powertune_supported != 0)
13098 {
13099 // powertune set
13100 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13101
13102 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13103 {
13104 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13105
13106 return (-1);
13107 }
13108
13109 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13110 {
13111 log_error ("ERROR: Failed to set new ADL PowerControl values");
13112
13113 return (-1);
13114 }
13115 }
13116 }
13117 }
13118
13119 hc_thread_mutex_unlock (mux_adl);
13120 }
13121 #endif // HAVE_ADK
13122 #endif // HAVE_HWMON
13123
13124 #ifdef OSX
13125 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13126 {
13127 if (force == 0)
13128 {
13129 log_info ("");
13130 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13131 log_info ("You can use --force to override this but do not post error reports if you do so");
13132 log_info ("");
13133
13134 continue;
13135 }
13136 }
13137 #endif
13138
13139 #ifdef DEBUG
13140 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13141 #endif
13142
13143 uint kernel_blocks_all = 0;
13144
13145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13146 {
13147 /**
13148 * host buffer
13149 */
13150
13151 hc_device_param_t *device_param = &data.devices_param[device_id];
13152
13153 if (device_param->skipped) continue;
13154
13155 /**
13156 * device properties
13157 */
13158
13159 char *device_name_chksum = device_param->device_name_chksum;
13160
13161 uint device_processors = device_param->device_processors;
13162
13163 uint device_processor_cores = device_param->device_processor_cores;
13164
13165 uint kernel_accel = device_param->kernel_accel;
13166
13167 /**
13168 * create context for each device
13169 */
13170
13171 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13172
13173 /**
13174 * create command-queue
13175 */
13176
13177 // not supported with NV
13178 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13179
13180 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13181
13182 /**
13183 * create input buffers on device
13184 */
13185
13186 uint kernel_threads = KERNEL_THREADS;
13187
13188 // bcrypt
13189 if (hash_mode == 3200) kernel_threads = 8;
13190 if (hash_mode == 9000) kernel_threads = 8;
13191
13192 uint kernel_power = 1;
13193 uint kernel_blocks = 1;
13194
13195 uint size_pws = 4;
13196 uint size_tmps = 4;
13197 uint size_hooks = 4;
13198
13199 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13200
13201 while (kernel_accel)
13202 {
13203 kernel_power = device_processors * kernel_threads * kernel_accel;
13204 kernel_blocks = kernel_power;
13205
13206 // size_pws
13207
13208 size_pws = kernel_blocks * sizeof (pw_t);
13209
13210 // size_tmps
13211
13212 switch (hash_mode)
13213 {
13214 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13215 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13216 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13217 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13218 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13219 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13220 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13221 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13222 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13223 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13224 case 6211:
13225 case 6212:
13226 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13227 case 6221:
13228 case 6222:
13229 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13230 case 6231:
13231 case 6232:
13232 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13233 case 6241:
13234 case 6242:
13235 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13236 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13237 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13238 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13239 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13240 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13241 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13242 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13243 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13244 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13245 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13246 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13247 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13248 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13249 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13250 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13251 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13252 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13253 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13254 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13255 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13256 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13257 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13258 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13259 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13260 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13261 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13262 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13263 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13264 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13265 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13266 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13267 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13268 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13269 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13270 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13271 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13272 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13273 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13274 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13275 };
13276
13277 // size_hooks
13278
13279 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13280 {
13281 // none yet
13282 }
13283
13284 // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
13285 // if not, decrease amplifier and try again
13286
13287 if (size_pws > device_param->device_maxmem_alloc)
13288 {
13289 kernel_accel--;
13290
13291 continue;
13292 }
13293
13294 if (size_tmps > device_param->device_maxmem_alloc)
13295 {
13296 kernel_accel--;
13297
13298 continue;
13299 }
13300
13301 if (size_hooks > device_param->device_maxmem_alloc)
13302 {
13303 kernel_accel--;
13304
13305 continue;
13306 }
13307
13308 if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
13309 {
13310 kernel_accel--;
13311
13312 continue;
13313 }
13314
13315 break;
13316 }
13317
13318 if (kernel_accel == 0)
13319 {
13320 log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13321
13322 return -1;
13323 }
13324
13325 device_param->kernel_threads = kernel_threads;
13326 device_param->kernel_power_user = kernel_power;
13327 device_param->kernel_blocks_user = kernel_blocks;
13328
13329 kernel_blocks_all += kernel_blocks;
13330
13331 device_param->size_pws = size_pws;
13332 device_param->size_tmps = size_tmps;
13333 device_param->size_hooks = size_hooks;
13334
13335 // we can optimize some stuff here...
13336
13337 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13338 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13339
13340 device_param->size_root_css = size_root_css;
13341 device_param->size_markov_css = size_markov_css;
13342
13343 uint size_results = KERNEL_THREADS * sizeof (uint);
13344
13345 device_param->size_results = size_results;
13346
13347 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13348 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13349
13350 uint size_plains = digests_cnt * sizeof (plain_t);
13351 uint size_salts = salts_cnt * sizeof (salt_t);
13352 uint size_esalts = salts_cnt * esalt_size;
13353
13354 device_param->size_plains = size_plains;
13355 device_param->size_digests = size_digests;
13356 device_param->size_shown = size_shown;
13357 device_param->size_salts = size_salts;
13358
13359 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13360 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13361 uint size_tm = 32 * sizeof (bs_word_t);
13362
13363 // scrypt stuff
13364
13365 u64 size_scryptV = 1;
13366
13367 if ((hash_mode == 8900) || (hash_mode == 9300))
13368 {
13369 uint tmto_start = 0;
13370 uint tmto_stop = 10;
13371
13372 if (scrypt_tmto)
13373 {
13374 tmto_start = scrypt_tmto;
13375 }
13376 else
13377 {
13378 // in case the user did not specify the tmto manually
13379 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13380 // but set the lower end only in case the user has a device with too less memory
13381
13382 if (hash_mode == 8900)
13383 {
13384 if (device_param->vendor_id == VENDOR_ID_AMD)
13385 {
13386 tmto_start = 1;
13387 }
13388 else if (device_param->vendor_id == VENDOR_ID_NV)
13389 {
13390 tmto_start = 3;
13391 }
13392 }
13393 else if (hash_mode == 9300)
13394 {
13395 if (device_param->vendor_id == VENDOR_ID_AMD)
13396 {
13397 tmto_start = 3;
13398 }
13399 else if (device_param->vendor_id == VENDOR_ID_NV)
13400 {
13401 tmto_start = 5;
13402 }
13403 }
13404 }
13405
13406 if (quiet == 0) log_info ("");
13407
13408 uint shader_per_mp = 1;
13409
13410 if (device_param->vendor_id == VENDOR_ID_AMD)
13411 {
13412 shader_per_mp = 8;
13413 }
13414 else if (device_param->vendor_id == VENDOR_ID_NV)
13415 {
13416 shader_per_mp = 32;
13417 }
13418
13419 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13420 {
13421 // TODO: in theory the following calculation needs to be done per salt, not global
13422 // we assume all hashes have the same scrypt settings
13423
13424 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13425
13426 size_scryptV /= 1 << tmto;
13427
13428 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13429
13430 if (size_scryptV > device_param->device_maxmem_alloc)
13431 {
13432 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13433
13434 continue;
13435 }
13436
13437 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13438 {
13439 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13440 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13441 }
13442
13443 break;
13444 }
13445
13446 if (data.salts_buf[0].scrypt_phy == 0)
13447 {
13448 log_error ("ERROR: can't allocate enough device memory");
13449
13450 return -1;
13451 }
13452
13453 if (quiet == 0) log_info ("");
13454 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13455 }
13456
13457 /**
13458 * default building options
13459 */
13460
13461 char build_opts[1024] = { 0 };
13462
13463 // we don't have sm_* on vendors not NV but it doesn't matter
13464
13465 snprintf (build_opts, sizeof (build_opts) - 1, "-I%s/ -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type);
13466
13467 /**
13468 * main kernel
13469 */
13470
13471 {
13472 /**
13473 * kernel source filename
13474 */
13475
13476 char source_file[256] = { 0 };
13477
13478 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13479
13480 struct stat sst;
13481
13482 if (stat (source_file, &sst) == -1)
13483 {
13484 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13485
13486 return -1;
13487 }
13488
13489 /**
13490 * kernel cached filename
13491 */
13492
13493 char cached_file[256] = { 0 };
13494
13495 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13496
13497 int cached = 1;
13498
13499 struct stat cst;
13500
13501 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13502 {
13503 cached = 0;
13504 }
13505
13506 /**
13507 * kernel compile or load
13508 */
13509
13510 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13511
13512 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13513
13514 if (force_jit_compilation == -1)
13515 {
13516 if (cached == 0)
13517 {
13518 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13519
13520 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13521
13522 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13523
13524 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13525
13526 if (rc != 0)
13527 {
13528 device_param->skipped = true;
13529 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13530 continue;
13531 }
13532
13533 size_t binary_size;
13534
13535 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13536
13537 u8 *binary = (u8 *) mymalloc (binary_size);
13538
13539 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13540
13541 writeProgramBin (cached_file, binary, binary_size);
13542
13543 local_free (binary);
13544 }
13545 else
13546 {
13547 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13548
13549 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13550
13551 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13552
13553 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13554 }
13555 }
13556 else
13557 {
13558 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13559
13560 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13561
13562 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13563
13564 char build_opts_update[1024] = { 0 };
13565
13566 if (force_jit_compilation == 1500)
13567 {
13568 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13569 }
13570 else if (force_jit_compilation == 8900)
13571 {
13572 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);
13573 }
13574
13575 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13576
13577 if (rc != 0)
13578 {
13579 device_param->skipped = true;
13580 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13581 }
13582 }
13583
13584 local_free (kernel_lengths);
13585 local_free (kernel_sources[0]);
13586 local_free (kernel_sources);
13587 }
13588
13589 /**
13590 * word generator kernel
13591 */
13592
13593 if (attack_mode != ATTACK_MODE_STRAIGHT)
13594 {
13595 /**
13596 * kernel mp source filename
13597 */
13598
13599 char source_file[256] = { 0 };
13600
13601 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13602
13603 struct stat sst;
13604
13605 if (stat (source_file, &sst) == -1)
13606 {
13607 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13608
13609 return -1;
13610 }
13611
13612 /**
13613 * kernel mp cached filename
13614 */
13615
13616 char cached_file[256] = { 0 };
13617
13618 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13619
13620 int cached = 1;
13621
13622 struct stat cst;
13623
13624 if (stat (cached_file, &cst) == -1)
13625 {
13626 cached = 0;
13627 }
13628
13629 /**
13630 * kernel compile or load
13631 */
13632
13633 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13634
13635 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13636
13637 if (cached == 0)
13638 {
13639 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13640
13641 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13642
13643 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13644
13645 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13646
13647 if (rc != 0)
13648 {
13649 device_param->skipped = true;
13650 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13651 continue;
13652 }
13653
13654 size_t binary_size;
13655
13656 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13657
13658 u8 *binary = (u8 *) mymalloc (binary_size);
13659
13660 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13661
13662 writeProgramBin (cached_file, binary, binary_size);
13663
13664 local_free (binary);
13665 }
13666 else
13667 {
13668 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13669
13670 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13671
13672 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13673
13674 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13675 }
13676
13677 local_free (kernel_lengths);
13678 local_free (kernel_sources[0]);
13679 local_free (kernel_sources);
13680 }
13681
13682 /**
13683 * amplifier kernel
13684 */
13685
13686 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13687 {
13688
13689 }
13690 else
13691 {
13692 /**
13693 * kernel amp source filename
13694 */
13695
13696 char source_file[256] = { 0 };
13697
13698 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13699
13700 struct stat sst;
13701
13702 if (stat (source_file, &sst) == -1)
13703 {
13704 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13705
13706 return -1;
13707 }
13708
13709 /**
13710 * kernel amp cached filename
13711 */
13712
13713 char cached_file[256] = { 0 };
13714
13715 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13716
13717 int cached = 1;
13718
13719 struct stat cst;
13720
13721 if (stat (cached_file, &cst) == -1)
13722 {
13723 cached = 0;
13724 }
13725
13726 /**
13727 * kernel compile or load
13728 */
13729
13730 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13731
13732 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13733
13734 if (cached == 0)
13735 {
13736 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13737
13738 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13739
13740 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13741
13742 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13743
13744 if (rc != 0)
13745 {
13746 device_param->skipped = true;
13747 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13748 continue;
13749 }
13750
13751 size_t binary_size;
13752
13753 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13754
13755 u8 *binary = (u8 *) mymalloc (binary_size);
13756
13757 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13758
13759 writeProgramBin (cached_file, binary, binary_size);
13760
13761 local_free (binary);
13762 }
13763 else
13764 {
13765 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13766
13767 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13768
13769 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13770
13771 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
13772 }
13773
13774 local_free (kernel_lengths);
13775 local_free (kernel_sources[0]);
13776 local_free (kernel_sources);
13777 }
13778
13779 // some algorithm collide too fast, make that impossible
13780
13781 if (benchmark == 1)
13782 {
13783 ((uint *) digests_buf)[0] = -1;
13784 ((uint *) digests_buf)[1] = -1;
13785 ((uint *) digests_buf)[2] = -1;
13786 ((uint *) digests_buf)[3] = -1;
13787 }
13788
13789 /**
13790 * global buffers
13791 */
13792
13793 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13794 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13795 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13796 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13797 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13798 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13799 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13800 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13801 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13802 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13803 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13804 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13805 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13806 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13807 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13808 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13809 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13810 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13811
13812 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);
13813 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);
13814 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);
13815 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);
13816 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);
13817 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);
13818 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);
13819 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);
13820 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13821 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13822 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13823
13824 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13825 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13826 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13827 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13828 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13829 run_kernel_bzero (device_param, device_param->d_result, size_results);
13830
13831 /**
13832 * special buffers
13833 */
13834
13835 if (attack_kern == ATTACK_KERN_STRAIGHT)
13836 {
13837 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13838 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13839
13840 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13841
13842 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13843 }
13844 else if (attack_kern == ATTACK_KERN_COMBI)
13845 {
13846 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13847 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13848 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13849 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13850
13851 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13852 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13853 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13854 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13855 }
13856 else if (attack_kern == ATTACK_KERN_BF)
13857 {
13858 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13859 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13860 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13861 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13862 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13863
13864 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13865 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13866 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13867 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13868 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13869 }
13870
13871 if (size_esalts)
13872 {
13873 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13874
13875 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13876 }
13877
13878 /**
13879 * main host data
13880 */
13881
13882 uint *result = (uint *) mymalloc (size_results);
13883
13884 device_param->result = result;
13885
13886 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13887
13888 device_param->pws_buf = pws_buf;
13889
13890 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13891
13892 for (int i = 0; i < 64; i++)
13893 {
13894 pw_caches[i].pw_buf.pw_len = i;
13895 pw_caches[i].cnt = 0;
13896 }
13897
13898 device_param->pw_caches = pw_caches;
13899
13900 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13901
13902 device_param->combs_buf = combs_buf;
13903
13904 void *hooks_buf = mymalloc (size_hooks);
13905
13906 device_param->hooks_buf = hooks_buf;
13907
13908 device_param->pw_transpose = pw_transpose_to_hi1;
13909 device_param->pw_add = pw_add_to_hc1;
13910
13911 /**
13912 * kernel args
13913 */
13914
13915 device_param->kernel_params_buf32[21] = bitmap_mask;
13916 device_param->kernel_params_buf32[22] = bitmap_shift1;
13917 device_param->kernel_params_buf32[23] = bitmap_shift2;
13918 device_param->kernel_params_buf32[24] = 0; // salt_pos
13919 device_param->kernel_params_buf32[25] = 0; // loop_pos
13920 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13921 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13922 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13923 device_param->kernel_params_buf32[29] = 0; // digests_offset
13924 device_param->kernel_params_buf32[30] = 0; // combs_mode
13925 device_param->kernel_params_buf32[31] = 0; // gid_max
13926
13927 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13928 ? &device_param->d_pws_buf
13929 : &device_param->d_pws_amp_buf;
13930 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13931 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13932 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13933 device_param->kernel_params[ 4] = &device_param->d_tmps;
13934 device_param->kernel_params[ 5] = &device_param->d_hooks;
13935 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13936 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13937 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13938 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13939 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13940 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13941 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13942 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13943 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13944 device_param->kernel_params[15] = &device_param->d_digests_buf;
13945 device_param->kernel_params[16] = &device_param->d_digests_shown;
13946 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13947 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13948 device_param->kernel_params[19] = &device_param->d_result;
13949 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13950 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13951 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13952 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13953 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13954 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13955 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13956 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13957 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13958 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13959 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13960 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13961
13962 device_param->kernel_params_mp_buf64[3] = 0;
13963 device_param->kernel_params_mp_buf32[4] = 0;
13964 device_param->kernel_params_mp_buf32[5] = 0;
13965 device_param->kernel_params_mp_buf32[6] = 0;
13966 device_param->kernel_params_mp_buf32[7] = 0;
13967 device_param->kernel_params_mp_buf32[8] = 0;
13968
13969 device_param->kernel_params_mp[0] = NULL;
13970 device_param->kernel_params_mp[1] = NULL;
13971 device_param->kernel_params_mp[2] = NULL;
13972 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13973 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13974 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13975 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13976 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13977 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13978
13979 device_param->kernel_params_mp_l_buf64[3] = 0;
13980 device_param->kernel_params_mp_l_buf32[4] = 0;
13981 device_param->kernel_params_mp_l_buf32[5] = 0;
13982 device_param->kernel_params_mp_l_buf32[6] = 0;
13983 device_param->kernel_params_mp_l_buf32[7] = 0;
13984 device_param->kernel_params_mp_l_buf32[8] = 0;
13985 device_param->kernel_params_mp_l_buf32[9] = 0;
13986
13987 device_param->kernel_params_mp_l[0] = NULL;
13988 device_param->kernel_params_mp_l[1] = NULL;
13989 device_param->kernel_params_mp_l[2] = NULL;
13990 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13991 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13992 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13993 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13994 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13995 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13996 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13997
13998 device_param->kernel_params_mp_r_buf64[3] = 0;
13999 device_param->kernel_params_mp_r_buf32[4] = 0;
14000 device_param->kernel_params_mp_r_buf32[5] = 0;
14001 device_param->kernel_params_mp_r_buf32[6] = 0;
14002 device_param->kernel_params_mp_r_buf32[7] = 0;
14003 device_param->kernel_params_mp_r_buf32[8] = 0;
14004
14005 device_param->kernel_params_mp_r[0] = NULL;
14006 device_param->kernel_params_mp_r[1] = NULL;
14007 device_param->kernel_params_mp_r[2] = NULL;
14008 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14009 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14010 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14011 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14012 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14013 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14014
14015 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14016 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14017
14018 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14019 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14020 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14021 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14022 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14023 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14024 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14025
14026 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14027
14028 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14029 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14030
14031 /**
14032 * kernel name
14033 */
14034
14035 char kernel_name[64] = { 0 };
14036
14037 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14038 {
14039 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14040 {
14041 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14042
14043 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14044
14045 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14046
14047 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14048
14049 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14050
14051 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14052 }
14053 else
14054 {
14055 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14056
14057 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14058
14059 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14060
14061 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14062
14063 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14064
14065 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14066 }
14067
14068 if (data.attack_mode == ATTACK_MODE_BF)
14069 {
14070 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14071 {
14072 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14073
14074 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14075
14076 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14077
14078 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14079 }
14080 }
14081 }
14082 else
14083 {
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14085
14086 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14087
14088 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14089
14090 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14091
14092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14093
14094 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14095
14096 if (opts_type & OPTS_TYPE_HOOK12)
14097 {
14098 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14099
14100 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14101 }
14102
14103 if (opts_type & OPTS_TYPE_HOOK23)
14104 {
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14106
14107 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14108 }
14109 }
14110
14111 for (uint i = 0; i <= 20; i++)
14112 {
14113 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14114 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14115 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14116
14117 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14118 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14119 }
14120
14121 for (uint i = 21; i <= 31; i++)
14122 {
14123 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14124 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14125 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14126
14127 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14128 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14129 }
14130
14131 if (attack_mode == ATTACK_MODE_BF)
14132 {
14133 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14134 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14135
14136 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14137 {
14138 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14139
14140 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14141 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14142 }
14143 }
14144 else if (attack_mode == ATTACK_MODE_HYBRID1)
14145 {
14146 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14147 }
14148 else if (attack_mode == ATTACK_MODE_HYBRID2)
14149 {
14150 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14151 }
14152
14153 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14154 {
14155 // nothing to do
14156 }
14157 else
14158 {
14159 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14160 }
14161
14162 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14163 {
14164 // nothing to do
14165 }
14166 else
14167 {
14168 for (uint i = 0; i < 5; i++)
14169 {
14170 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14171 }
14172
14173 for (uint i = 5; i < 7; i++)
14174 {
14175 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14176 }
14177 }
14178
14179 /**
14180 * Store initial fanspeed if gpu_temp_retain is enabled
14181 */
14182
14183 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14184 int gpu_temp_retain_set = 0;
14185
14186 if (gpu_temp_disable == 0)
14187 {
14188 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14189 {
14190 hc_thread_mutex_lock (mux_adl);
14191
14192 if (data.hm_device[device_id].fan_supported == 1)
14193 {
14194 if (gpu_temp_retain_chgd == 0)
14195 {
14196 uint cur_temp = 0;
14197 uint default_temp = 0;
14198
14199 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);
14200
14201 if (ADL_rc == ADL_OK)
14202 {
14203 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14204
14205 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14206
14207 // special case with multi gpu setups: always use minimum retain
14208
14209 if (gpu_temp_retain_set == 0)
14210 {
14211 gpu_temp_retain = gpu_temp_retain_target;
14212 gpu_temp_retain_set = 1;
14213 }
14214 else
14215 {
14216 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14217 }
14218
14219 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14220 }
14221 }
14222
14223 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14224
14225 temp_retain_fanspeed_value[device_id] = fan_speed;
14226
14227 if (fan_speed == -1)
14228 {
14229 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14230
14231 temp_retain_fanspeed_value[device_id] = 0;
14232 }
14233 }
14234
14235 hc_thread_mutex_unlock (mux_adl);
14236 }
14237 }
14238
14239 /**
14240 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14241 */
14242
14243 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14244 {
14245 hc_thread_mutex_lock (mux_adl);
14246
14247 if (data.hm_device[device_id].od_version == 6)
14248 {
14249 int ADL_rc;
14250
14251 // check powertune capabilities first, if not available then skip device
14252
14253 int powertune_supported = 0;
14254
14255 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14256 {
14257 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14258
14259 return (-1);
14260 }
14261
14262 if (powertune_supported != 0)
14263 {
14264 // powercontrol settings
14265
14266 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14267
14268 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14269 {
14270 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14271 }
14272
14273 if (ADL_rc != ADL_OK)
14274 {
14275 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14276
14277 return (-1);
14278 }
14279
14280 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14281 {
14282 log_error ("ERROR: Failed to set new ADL PowerControl values");
14283
14284 return (-1);
14285 }
14286
14287 // clocks
14288
14289 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14290
14291 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14292
14293 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)
14294 {
14295 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14296
14297 return (-1);
14298 }
14299
14300 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14301
14302 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14303
14304 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14305 {
14306 log_error ("ERROR: Failed to get ADL device capabilities");
14307
14308 return (-1);
14309 }
14310
14311 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14312 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14313
14314 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14315 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14316
14317 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14318 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14319
14320 // warning if profile has too low max values
14321
14322 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14323 {
14324 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14325 }
14326
14327 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14328 {
14329 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14330 }
14331
14332 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14333
14334 performance_state->iNumberOfPerformanceLevels = 2;
14335
14336 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14337 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14338 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14339 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14340
14341 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)
14342 {
14343 log_info ("ERROR: Failed to set ADL performance state");
14344
14345 return (-1);
14346 }
14347
14348 local_free (performance_state);
14349 }
14350 }
14351
14352 hc_thread_mutex_unlock (mux_adl);
14353 }
14354 #endif // HAVE_HWMON && HAVE_ADL
14355 }
14356
14357 data.kernel_blocks_all = kernel_blocks_all;
14358
14359 if (data.quiet == 0) log_info ("");
14360
14361 /**
14362 * Inform user which algorithm is checked and at which workload setting
14363 */
14364
14365 if (benchmark == 1)
14366 {
14367 quiet = 0;
14368
14369 data.quiet = quiet;
14370
14371 char *hash_type = strhashtype (data.hash_mode); // not a bug
14372
14373 log_info ("Hashtype: %s", hash_type);
14374 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14375 log_info ("");
14376 }
14377
14378 /**
14379 * keep track of the progress
14380 */
14381
14382 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14383 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14384 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14385
14386 /**
14387 * open filehandles
14388 */
14389
14390 #if _WIN
14391 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14392 {
14393 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14394
14395 return (-1);
14396 }
14397
14398 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14399 {
14400 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14401
14402 return (-1);
14403 }
14404
14405 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14406 {
14407 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14408
14409 return (-1);
14410 }
14411 #endif
14412
14413 /**
14414 * dictionary pad
14415 */
14416
14417 segment_size *= (1024 * 1024);
14418
14419 data.segment_size = segment_size;
14420
14421 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14422
14423 wl_data->buf = (char *) mymalloc (segment_size);
14424 wl_data->avail = segment_size;
14425 wl_data->incr = segment_size;
14426 wl_data->cnt = 0;
14427 wl_data->pos = 0;
14428
14429 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14430
14431 data.wordlist_mode = wordlist_mode;
14432
14433 cs_t *css_buf = NULL;
14434 uint css_cnt = 0;
14435 uint dictcnt = 0;
14436 uint maskcnt = 1;
14437 char **masks = NULL;
14438 char **dictfiles = NULL;
14439
14440 uint mask_from_file = 0;
14441
14442 if (attack_mode == ATTACK_MODE_STRAIGHT)
14443 {
14444 if (wordlist_mode == WL_MODE_FILE)
14445 {
14446 int wls_left = myargc - (optind + 1);
14447
14448 for (int i = 0; i < wls_left; i++)
14449 {
14450 char *l0_filename = myargv[optind + 1 + i];
14451
14452 struct stat l0_stat;
14453
14454 if (stat (l0_filename, &l0_stat) == -1)
14455 {
14456 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14457
14458 return (-1);
14459 }
14460
14461 uint is_dir = S_ISDIR (l0_stat.st_mode);
14462
14463 if (is_dir == 0)
14464 {
14465 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14466
14467 dictcnt++;
14468
14469 dictfiles[dictcnt - 1] = l0_filename;
14470 }
14471 else
14472 {
14473 // do not allow --keyspace w/ a directory
14474
14475 if (keyspace == 1)
14476 {
14477 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14478
14479 return (-1);
14480 }
14481
14482 char **dictionary_files = NULL;
14483
14484 dictionary_files = scan_directory (l0_filename);
14485
14486 if (dictionary_files != NULL)
14487 {
14488 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14489
14490 for (int d = 0; dictionary_files[d] != NULL; d++)
14491 {
14492 char *l1_filename = dictionary_files[d];
14493
14494 struct stat l1_stat;
14495
14496 if (stat (l1_filename, &l1_stat) == -1)
14497 {
14498 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14499
14500 return (-1);
14501 }
14502
14503 if (S_ISREG (l1_stat.st_mode))
14504 {
14505 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14506
14507 dictcnt++;
14508
14509 dictfiles[dictcnt - 1] = strdup (l1_filename);
14510 }
14511 }
14512 }
14513
14514 local_free (dictionary_files);
14515 }
14516 }
14517
14518 if (dictcnt < 1)
14519 {
14520 log_error ("ERROR: No usable dictionary file found.");
14521
14522 return (-1);
14523 }
14524 }
14525 else if (wordlist_mode == WL_MODE_STDIN)
14526 {
14527 dictcnt = 1;
14528 }
14529 }
14530 else if (attack_mode == ATTACK_MODE_COMBI)
14531 {
14532 // display
14533
14534 char *dictfile1 = myargv[optind + 1 + 0];
14535 char *dictfile2 = myargv[optind + 1 + 1];
14536
14537 // find the bigger dictionary and use as base
14538
14539 FILE *fp1 = NULL;
14540 FILE *fp2 = NULL;
14541
14542 struct stat tmp_stat;
14543
14544 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14545 {
14546 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14547
14548 return (-1);
14549 }
14550
14551 if (stat (dictfile1, &tmp_stat) == -1)
14552 {
14553 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14554
14555 fclose (fp1);
14556
14557 return (-1);
14558 }
14559
14560 if (S_ISDIR (tmp_stat.st_mode))
14561 {
14562 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14563
14564 fclose (fp1);
14565
14566 return (-1);
14567 }
14568
14569 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14570 {
14571 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14572
14573 fclose (fp1);
14574
14575 return (-1);
14576 }
14577
14578 if (stat (dictfile2, &tmp_stat) == -1)
14579 {
14580 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14581
14582 fclose (fp1);
14583 fclose (fp2);
14584
14585 return (-1);
14586 }
14587
14588 if (S_ISDIR (tmp_stat.st_mode))
14589 {
14590 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14591
14592 fclose (fp1);
14593 fclose (fp2);
14594
14595 return (-1);
14596 }
14597
14598 data.combs_cnt = 1;
14599
14600 data.quiet = 1;
14601
14602 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14603
14604 data.quiet = quiet;
14605
14606 if (words1_cnt == 0)
14607 {
14608 log_error ("ERROR: %s: empty file", dictfile1);
14609
14610 fclose (fp1);
14611 fclose (fp2);
14612
14613 return (-1);
14614 }
14615
14616 data.combs_cnt = 1;
14617
14618 data.quiet = 1;
14619
14620 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14621
14622 data.quiet = quiet;
14623
14624 if (words2_cnt == 0)
14625 {
14626 log_error ("ERROR: %s: empty file", dictfile2);
14627
14628 fclose (fp1);
14629 fclose (fp2);
14630
14631 return (-1);
14632 }
14633
14634 fclose (fp1);
14635 fclose (fp2);
14636
14637 data.dictfile = dictfile1;
14638 data.dictfile2 = dictfile2;
14639
14640 if (words1_cnt >= words2_cnt)
14641 {
14642 data.combs_cnt = words2_cnt;
14643 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14644
14645 dictfiles = &data.dictfile;
14646
14647 dictcnt = 1;
14648 }
14649 else
14650 {
14651 data.combs_cnt = words1_cnt;
14652 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14653
14654 dictfiles = &data.dictfile2;
14655
14656 dictcnt = 1;
14657
14658 // we also have to switch wordlist related rules!
14659
14660 char *tmpc = data.rule_buf_l;
14661
14662 data.rule_buf_l = data.rule_buf_r;
14663 data.rule_buf_r = tmpc;
14664
14665 int tmpi = data.rule_len_l;
14666
14667 data.rule_len_l = data.rule_len_r;
14668 data.rule_len_r = tmpi;
14669 }
14670 }
14671 else if (attack_mode == ATTACK_MODE_BF)
14672 {
14673 char *mask = NULL;
14674
14675 maskcnt = 0;
14676
14677 if (benchmark == 0)
14678 {
14679 mask = myargv[optind + 1];
14680
14681 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14682
14683 if ((optind + 2) <= myargc)
14684 {
14685 struct stat file_stat;
14686
14687 if (stat (mask, &file_stat) == -1)
14688 {
14689 maskcnt = 1;
14690
14691 masks[maskcnt - 1] = mystrdup (mask);
14692 }
14693 else
14694 {
14695 int wls_left = myargc - (optind + 1);
14696
14697 uint masks_avail = INCR_MASKS;
14698
14699 for (int i = 0; i < wls_left; i++)
14700 {
14701 if (i != 0)
14702 {
14703 mask = myargv[optind + 1 + i];
14704
14705 if (stat (mask, &file_stat) == -1)
14706 {
14707 log_error ("ERROR: %s: %s", mask, strerror (errno));
14708
14709 return (-1);
14710 }
14711 }
14712
14713 uint is_file = S_ISREG (file_stat.st_mode);
14714
14715 if (is_file == 1)
14716 {
14717 FILE *mask_fp;
14718
14719 if ((mask_fp = fopen (mask, "r")) == NULL)
14720 {
14721 log_error ("ERROR: %s: %s", mask, strerror (errno));
14722
14723 return (-1);
14724 }
14725
14726 char line_buf[BUFSIZ] = { 0 };
14727
14728 while (!feof (mask_fp))
14729 {
14730 memset (line_buf, 0, BUFSIZ);
14731
14732 int line_len = fgetl (mask_fp, line_buf);
14733
14734 if (line_len == 0) continue;
14735
14736 if (line_buf[0] == '#') continue;
14737
14738 if (masks_avail == maskcnt)
14739 {
14740 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14741
14742 masks_avail += INCR_MASKS;
14743 }
14744
14745 masks[maskcnt] = mystrdup (line_buf);
14746
14747 maskcnt++;
14748 }
14749
14750 fclose (mask_fp);
14751 }
14752 else
14753 {
14754 log_error ("ERROR: %s: unsupported file-type", mask);
14755
14756 return (-1);
14757 }
14758 }
14759
14760 mask_from_file = 1;
14761 }
14762 }
14763 else
14764 {
14765 custom_charset_1 = (char *) "?l?d?u";
14766 custom_charset_2 = (char *) "?l?d";
14767 custom_charset_3 = (char *) "?l?d*!$@_";
14768
14769 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14770 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14771 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14772
14773 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14774
14775 wordlist_mode = WL_MODE_MASK;
14776
14777 data.wordlist_mode = wordlist_mode;
14778
14779 increment = 1;
14780
14781 maskcnt = 1;
14782 }
14783 }
14784 else
14785 {
14786 /**
14787 * generate full masks and charsets
14788 */
14789
14790 masks = (char **) mymalloc (sizeof (char *));
14791
14792 switch (hash_mode)
14793 {
14794 case 1731: pw_min = 5;
14795 pw_max = 5;
14796 mask = mystrdup ("?b?b?b?b?b");
14797 break;
14798 case 12500: pw_min = 5;
14799 pw_max = 5;
14800 mask = mystrdup ("?b?b?b?b?b");
14801 break;
14802 default: pw_min = 7;
14803 pw_max = 7;
14804 mask = mystrdup ("?b?b?b?b?b?b?b");
14805 break;
14806 }
14807
14808 maskcnt = 1;
14809
14810 masks[maskcnt - 1] = mystrdup (mask);
14811
14812 wordlist_mode = WL_MODE_MASK;
14813
14814 data.wordlist_mode = wordlist_mode;
14815
14816 increment = 1;
14817 }
14818
14819 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14820
14821 if (increment)
14822 {
14823 if (increment_min > pw_min) pw_min = increment_min;
14824
14825 if (increment_max < pw_max) pw_max = increment_max;
14826 }
14827 }
14828 else if (attack_mode == ATTACK_MODE_HYBRID1)
14829 {
14830 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14831
14832 // display
14833
14834 char *mask = myargv[myargc - 1];
14835
14836 maskcnt = 0;
14837
14838 masks = (char **) mymalloc (1 * sizeof (char *));
14839
14840 // mod
14841
14842 struct stat file_stat;
14843
14844 if (stat (mask, &file_stat) == -1)
14845 {
14846 maskcnt = 1;
14847
14848 masks[maskcnt - 1] = mystrdup (mask);
14849 }
14850 else
14851 {
14852 uint is_file = S_ISREG (file_stat.st_mode);
14853
14854 if (is_file == 1)
14855 {
14856 FILE *mask_fp;
14857
14858 if ((mask_fp = fopen (mask, "r")) == NULL)
14859 {
14860 log_error ("ERROR: %s: %s", mask, strerror (errno));
14861
14862 return (-1);
14863 }
14864
14865 char line_buf[BUFSIZ] = { 0 };
14866
14867 uint masks_avail = 1;
14868
14869 while (!feof (mask_fp))
14870 {
14871 memset (line_buf, 0, BUFSIZ);
14872
14873 int line_len = fgetl (mask_fp, line_buf);
14874
14875 if (line_len == 0) continue;
14876
14877 if (line_buf[0] == '#') continue;
14878
14879 if (masks_avail == maskcnt)
14880 {
14881 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14882
14883 masks_avail += INCR_MASKS;
14884 }
14885
14886 masks[maskcnt] = mystrdup (line_buf);
14887
14888 maskcnt++;
14889 }
14890
14891 fclose (mask_fp);
14892
14893 mask_from_file = 1;
14894 }
14895 else
14896 {
14897 maskcnt = 1;
14898
14899 masks[maskcnt - 1] = mystrdup (mask);
14900 }
14901 }
14902
14903 // base
14904
14905 int wls_left = myargc - (optind + 2);
14906
14907 for (int i = 0; i < wls_left; i++)
14908 {
14909 char *filename = myargv[optind + 1 + i];
14910
14911 struct stat file_stat;
14912
14913 if (stat (filename, &file_stat) == -1)
14914 {
14915 log_error ("ERROR: %s: %s", filename, strerror (errno));
14916
14917 return (-1);
14918 }
14919
14920 uint is_dir = S_ISDIR (file_stat.st_mode);
14921
14922 if (is_dir == 0)
14923 {
14924 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14925
14926 dictcnt++;
14927
14928 dictfiles[dictcnt - 1] = filename;
14929 }
14930 else
14931 {
14932 // do not allow --keyspace w/ a directory
14933
14934 if (keyspace == 1)
14935 {
14936 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14937
14938 return (-1);
14939 }
14940
14941 char **dictionary_files = NULL;
14942
14943 dictionary_files = scan_directory (filename);
14944
14945 if (dictionary_files != NULL)
14946 {
14947 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14948
14949 for (int d = 0; dictionary_files[d] != NULL; d++)
14950 {
14951 char *l1_filename = dictionary_files[d];
14952
14953 struct stat l1_stat;
14954
14955 if (stat (l1_filename, &l1_stat) == -1)
14956 {
14957 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14958
14959 return (-1);
14960 }
14961
14962 if (S_ISREG (l1_stat.st_mode))
14963 {
14964 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14965
14966 dictcnt++;
14967
14968 dictfiles[dictcnt - 1] = strdup (l1_filename);
14969 }
14970 }
14971 }
14972
14973 local_free (dictionary_files);
14974 }
14975 }
14976
14977 if (dictcnt < 1)
14978 {
14979 log_error ("ERROR: No usable dictionary file found.");
14980
14981 return (-1);
14982 }
14983
14984 if (increment)
14985 {
14986 maskcnt = 0;
14987
14988 uint mask_min = increment_min; // we can't reject smaller masks here
14989 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14990
14991 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14992 {
14993 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14994
14995 if (cur_mask == NULL) break;
14996
14997 masks[maskcnt] = cur_mask;
14998
14999 maskcnt++;
15000
15001 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15002 }
15003 }
15004 }
15005 else if (attack_mode == ATTACK_MODE_HYBRID2)
15006 {
15007 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15008
15009 // display
15010
15011 char *mask = myargv[optind + 1 + 0];
15012
15013 maskcnt = 0;
15014
15015 masks = (char **) mymalloc (1 * sizeof (char *));
15016
15017 // mod
15018
15019 struct stat file_stat;
15020
15021 if (stat (mask, &file_stat) == -1)
15022 {
15023 maskcnt = 1;
15024
15025 masks[maskcnt - 1] = mystrdup (mask);
15026 }
15027 else
15028 {
15029 uint is_file = S_ISREG (file_stat.st_mode);
15030
15031 if (is_file == 1)
15032 {
15033 FILE *mask_fp;
15034
15035 if ((mask_fp = fopen (mask, "r")) == NULL)
15036 {
15037 log_error ("ERROR: %s: %s", mask, strerror (errno));
15038
15039 return (-1);
15040 }
15041
15042 char line_buf[BUFSIZ] = { 0 };
15043
15044 uint masks_avail = 1;
15045
15046 while (!feof (mask_fp))
15047 {
15048 memset (line_buf, 0, BUFSIZ);
15049
15050 int line_len = fgetl (mask_fp, line_buf);
15051
15052 if (line_len == 0) continue;
15053
15054 if (line_buf[0] == '#') continue;
15055
15056 if (masks_avail == maskcnt)
15057 {
15058 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15059
15060 masks_avail += INCR_MASKS;
15061 }
15062
15063 masks[maskcnt] = mystrdup (line_buf);
15064
15065 maskcnt++;
15066 }
15067
15068 fclose (mask_fp);
15069
15070 mask_from_file = 1;
15071 }
15072 else
15073 {
15074 maskcnt = 1;
15075
15076 masks[maskcnt - 1] = mystrdup (mask);
15077 }
15078 }
15079
15080 // base
15081
15082 int wls_left = myargc - (optind + 2);
15083
15084 for (int i = 0; i < wls_left; i++)
15085 {
15086 char *filename = myargv[optind + 2 + i];
15087
15088 struct stat file_stat;
15089
15090 if (stat (filename, &file_stat) == -1)
15091 {
15092 log_error ("ERROR: %s: %s", filename, strerror (errno));
15093
15094 return (-1);
15095 }
15096
15097 uint is_dir = S_ISDIR (file_stat.st_mode);
15098
15099 if (is_dir == 0)
15100 {
15101 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15102
15103 dictcnt++;
15104
15105 dictfiles[dictcnt - 1] = filename;
15106 }
15107 else
15108 {
15109 // do not allow --keyspace w/ a directory
15110
15111 if (keyspace == 1)
15112 {
15113 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15114
15115 return (-1);
15116 }
15117
15118 char **dictionary_files = NULL;
15119
15120 dictionary_files = scan_directory (filename);
15121
15122 if (dictionary_files != NULL)
15123 {
15124 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15125
15126 for (int d = 0; dictionary_files[d] != NULL; d++)
15127 {
15128 char *l1_filename = dictionary_files[d];
15129
15130 struct stat l1_stat;
15131
15132 if (stat (l1_filename, &l1_stat) == -1)
15133 {
15134 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15135
15136 return (-1);
15137 }
15138
15139 if (S_ISREG (l1_stat.st_mode))
15140 {
15141 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15142
15143 dictcnt++;
15144
15145 dictfiles[dictcnt - 1] = strdup (l1_filename);
15146 }
15147 }
15148 }
15149
15150 local_free (dictionary_files);
15151 }
15152 }
15153
15154 if (dictcnt < 1)
15155 {
15156 log_error ("ERROR: No usable dictionary file found.");
15157
15158 return (-1);
15159 }
15160
15161 if (increment)
15162 {
15163 maskcnt = 0;
15164
15165 uint mask_min = increment_min; // we can't reject smaller masks here
15166 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15167
15168 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15169 {
15170 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15171
15172 if (cur_mask == NULL) break;
15173
15174 masks[maskcnt] = cur_mask;
15175
15176 maskcnt++;
15177
15178 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15179 }
15180 }
15181 }
15182
15183 data.pw_min = pw_min;
15184 data.pw_max = pw_max;
15185
15186 /**
15187 * weak hash check
15188 */
15189
15190 if (weak_hash_threshold >= salts_cnt)
15191 {
15192 hc_device_param_t *device_param = NULL;
15193
15194 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15195 {
15196 device_param = &data.devices_param[device_id];
15197
15198 if (device_param->skipped) continue;
15199
15200 break;
15201 }
15202
15203 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15204
15205 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15206 {
15207 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15208 }
15209 }
15210
15211 // Display hack, guarantee that there is at least one \r before real start
15212
15213 if (data.quiet == 0) log_info_nn ("");
15214
15215 /**
15216 * status and monitor threads
15217 */
15218
15219 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15220
15221 hc_thread_t i_thread = 0;
15222
15223 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15224 {
15225 hc_thread_create (i_thread, thread_keypress, &benchmark);
15226 }
15227
15228 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15229
15230 uint ni_threads_cnt = 0;
15231
15232 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15233
15234 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15235
15236 ni_threads_cnt++;
15237
15238 /**
15239 * Outfile remove
15240 */
15241
15242 if (keyspace == 0)
15243 {
15244 if (outfile_check_timer != 0)
15245 {
15246 if (data.outfile_check_directory != NULL)
15247 {
15248 if ((hash_mode != 5200) &&
15249 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15250 (hash_mode != 9000))
15251 {
15252 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15253
15254 ni_threads_cnt++;
15255 }
15256 else
15257 {
15258 outfile_check_timer = 0;
15259 }
15260 }
15261 else
15262 {
15263 outfile_check_timer = 0;
15264 }
15265 }
15266 }
15267
15268 /**
15269 * Inform the user if we got some hashes remove because of the pot file remove feature
15270 */
15271
15272 if (data.quiet == 0)
15273 {
15274 if (potfile_remove_cracks > 0)
15275 {
15276 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15277 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15278 }
15279 }
15280
15281 data.outfile_check_timer = outfile_check_timer;
15282
15283 /**
15284 * main loop
15285 */
15286
15287 char **induction_dictionaries = NULL;
15288
15289 int induction_dictionaries_cnt = 0;
15290
15291 hcstat_table_t *root_table_buf = NULL;
15292 hcstat_table_t *markov_table_buf = NULL;
15293
15294 uint initial_restore_done = 0;
15295
15296 data.maskcnt = maskcnt;
15297
15298 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15299 {
15300 if (data.devices_status == STATUS_CRACKED) break;
15301
15302 data.devices_status = STATUS_INIT;
15303
15304 if (maskpos > rd->maskpos)
15305 {
15306 rd->dictpos = 0;
15307 }
15308
15309 rd->maskpos = maskpos;
15310 data.maskpos = maskpos;
15311
15312 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15313 {
15314 char *mask = masks[maskpos];
15315
15316 if (mask_from_file == 1)
15317 {
15318 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15319
15320 char *str_ptr;
15321 uint str_pos;
15322
15323 uint mask_offset = 0;
15324
15325 uint separator_cnt;
15326
15327 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15328 {
15329 str_ptr = strstr (mask + mask_offset, ",");
15330
15331 if (str_ptr == NULL) break;
15332
15333 str_pos = str_ptr - mask;
15334
15335 // escaped separator, i.e. "\,"
15336
15337 if (str_pos > 0)
15338 {
15339 if (mask[str_pos - 1] == '\\')
15340 {
15341 separator_cnt --;
15342
15343 mask_offset = str_pos + 1;
15344
15345 continue;
15346 }
15347 }
15348
15349 // reset the offset
15350
15351 mask_offset = 0;
15352
15353 mask[str_pos] = '\0';
15354
15355 switch (separator_cnt)
15356 {
15357 case 0:
15358 mp_reset_usr (mp_usr, 0);
15359
15360 custom_charset_1 = mask;
15361 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15362 break;
15363
15364 case 1:
15365 mp_reset_usr (mp_usr, 1);
15366
15367 custom_charset_2 = mask;
15368 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15369 break;
15370
15371 case 2:
15372 mp_reset_usr (mp_usr, 2);
15373
15374 custom_charset_3 = mask;
15375 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15376 break;
15377
15378 case 3:
15379 mp_reset_usr (mp_usr, 3);
15380
15381 custom_charset_4 = mask;
15382 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15383 break;
15384 }
15385
15386 mask = mask + str_pos + 1;
15387 }
15388 }
15389
15390 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15391 {
15392 if (maskpos > 0)
15393 {
15394 local_free (css_buf);
15395 local_free (data.root_css_buf);
15396 local_free (data.markov_css_buf);
15397
15398 local_free (masks[maskpos - 1]);
15399 }
15400
15401 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15402
15403 data.mask = mask;
15404 data.css_cnt = css_cnt;
15405 data.css_buf = css_buf;
15406
15407 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15408
15409 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15410
15411 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15412 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15413
15414 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15415
15416 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15417
15418 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15419 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15420
15421 data.root_css_buf = root_css_buf;
15422 data.markov_css_buf = markov_css_buf;
15423
15424 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15425
15426 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15427
15428 local_free (root_table_buf);
15429 local_free (markov_table_buf);
15430
15431 // args
15432
15433 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15434 {
15435 hc_device_param_t *device_param = &data.devices_param[device_id];
15436
15437 if (device_param->skipped) continue;
15438
15439 device_param->kernel_params_mp[0] = &device_param->d_combs;
15440 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15441 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15442
15443 device_param->kernel_params_mp_buf64[3] = 0;
15444 device_param->kernel_params_mp_buf32[4] = css_cnt;
15445 device_param->kernel_params_mp_buf32[5] = 0;
15446 device_param->kernel_params_mp_buf32[6] = 0;
15447 device_param->kernel_params_mp_buf32[7] = 0;
15448
15449 if (attack_mode == ATTACK_MODE_HYBRID1)
15450 {
15451 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15452 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15453 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15454 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15455 }
15456 else if (attack_mode == ATTACK_MODE_HYBRID2)
15457 {
15458 device_param->kernel_params_mp_buf32[5] = 0;
15459 device_param->kernel_params_mp_buf32[6] = 0;
15460 device_param->kernel_params_mp_buf32[7] = 0;
15461 }
15462
15463 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]);
15464 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]);
15465 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]);
15466
15467 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);
15468 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);
15469 }
15470 }
15471 else if (attack_mode == ATTACK_MODE_BF)
15472 {
15473 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15474
15475 if (increment)
15476 {
15477 for (uint i = 0; i < dictcnt; i++)
15478 {
15479 local_free (dictfiles[i]);
15480 }
15481
15482 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15483 {
15484 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15485
15486 if (l1_filename == NULL) break;
15487
15488 dictcnt++;
15489
15490 dictfiles[dictcnt - 1] = l1_filename;
15491 }
15492 }
15493 else
15494 {
15495 dictcnt++;
15496
15497 dictfiles[dictcnt - 1] = mask;
15498 }
15499
15500 if (dictcnt == 0)
15501 {
15502 log_error ("ERROR: Mask is too small");
15503
15504 return (-1);
15505 }
15506 }
15507 }
15508
15509 free (induction_dictionaries);
15510
15511 // induction_dictionaries_cnt = 0; // implied
15512
15513 if (attack_mode != ATTACK_MODE_BF)
15514 {
15515 if (keyspace == 0)
15516 {
15517 induction_dictionaries = scan_directory (induction_directory);
15518
15519 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15520 }
15521 }
15522
15523 if (induction_dictionaries_cnt)
15524 {
15525 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15526 }
15527
15528 /**
15529 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15530 */
15531 if (keyspace == 1)
15532 {
15533 if ((maskcnt > 1) || (dictcnt > 1))
15534 {
15535 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15536
15537 return (-1);
15538 }
15539 }
15540
15541 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15542 {
15543 char *subid = logfile_generate_subid ();
15544
15545 data.subid = subid;
15546
15547 logfile_sub_msg ("START");
15548
15549 data.devices_status = STATUS_INIT;
15550
15551 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15552 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15553 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15554
15555 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15556
15557 data.cpt_pos = 0;
15558
15559 data.cpt_start = time (NULL);
15560
15561 data.cpt_total = 0;
15562
15563 if (data.restore == 0)
15564 {
15565 rd->words_cur = skip;
15566
15567 skip = 0;
15568
15569 data.skip = 0;
15570 }
15571
15572 data.ms_paused = 0;
15573
15574 data.words_cur = rd->words_cur;
15575
15576 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15577 {
15578 hc_device_param_t *device_param = &data.devices_param[device_id];
15579
15580 if (device_param->skipped) continue;
15581
15582 device_param->speed_pos = 0;
15583
15584 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15585 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15586 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15587
15588 device_param->kernel_power = device_param->kernel_power_user;
15589 device_param->kernel_blocks = device_param->kernel_blocks_user;
15590
15591 device_param->outerloop_pos = 0;
15592 device_param->outerloop_left = 0;
15593 device_param->innerloop_pos = 0;
15594 device_param->innerloop_left = 0;
15595
15596 // some more resets:
15597
15598 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15599
15600 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15601
15602 device_param->pw_cnt = 0;
15603 device_param->pws_cnt = 0;
15604
15605 device_param->words_off = 0;
15606 device_param->words_done = 0;
15607 }
15608
15609 data.kernel_blocks_div = 0;
15610
15611 // figure out some workload
15612
15613 if (attack_mode == ATTACK_MODE_STRAIGHT)
15614 {
15615 if (data.wordlist_mode == WL_MODE_FILE)
15616 {
15617 char *dictfile = NULL;
15618
15619 if (induction_dictionaries_cnt)
15620 {
15621 dictfile = induction_dictionaries[0];
15622 }
15623 else
15624 {
15625 dictfile = dictfiles[dictpos];
15626 }
15627
15628 data.dictfile = dictfile;
15629
15630 logfile_sub_string (dictfile);
15631
15632 for (uint i = 0; i < rp_files_cnt; i++)
15633 {
15634 logfile_sub_var_string ("rulefile", rp_files[i]);
15635 }
15636
15637 FILE *fd2 = fopen (dictfile, "rb");
15638
15639 if (fd2 == NULL)
15640 {
15641 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15642
15643 return (-1);
15644 }
15645
15646 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15647
15648 fclose (fd2);
15649
15650 if (data.words_cnt == 0)
15651 {
15652 if (data.devices_status == STATUS_CRACKED) break;
15653 if (data.devices_status == STATUS_ABORTED) break;
15654
15655 dictpos++;
15656
15657 continue;
15658 }
15659 }
15660 }
15661 else if (attack_mode == ATTACK_MODE_COMBI)
15662 {
15663 char *dictfile = data.dictfile;
15664 char *dictfile2 = data.dictfile2;
15665
15666 logfile_sub_string (dictfile);
15667 logfile_sub_string (dictfile2);
15668
15669 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15670 {
15671 FILE *fd2 = fopen (dictfile, "rb");
15672
15673 if (fd2 == NULL)
15674 {
15675 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15676
15677 return (-1);
15678 }
15679
15680 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15681
15682 fclose (fd2);
15683 }
15684 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15685 {
15686 FILE *fd2 = fopen (dictfile2, "rb");
15687
15688 if (fd2 == NULL)
15689 {
15690 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15691
15692 return (-1);
15693 }
15694
15695 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15696
15697 fclose (fd2);
15698 }
15699
15700 if (data.words_cnt == 0)
15701 {
15702 if (data.devices_status == STATUS_CRACKED) break;
15703 if (data.devices_status == STATUS_ABORTED) break;
15704
15705 dictpos++;
15706
15707 continue;
15708 }
15709 }
15710 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15711 {
15712 char *dictfile = NULL;
15713
15714 if (induction_dictionaries_cnt)
15715 {
15716 dictfile = induction_dictionaries[0];
15717 }
15718 else
15719 {
15720 dictfile = dictfiles[dictpos];
15721 }
15722
15723 data.dictfile = dictfile;
15724
15725 char *mask = data.mask;
15726
15727 logfile_sub_string (dictfile);
15728 logfile_sub_string (mask);
15729
15730 FILE *fd2 = fopen (dictfile, "rb");
15731
15732 if (fd2 == NULL)
15733 {
15734 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15735
15736 return (-1);
15737 }
15738
15739 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15740
15741 fclose (fd2);
15742
15743 if (data.words_cnt == 0)
15744 {
15745 if (data.devices_status == STATUS_CRACKED) break;
15746 if (data.devices_status == STATUS_ABORTED) break;
15747
15748 dictpos++;
15749
15750 continue;
15751 }
15752 }
15753 else if (attack_mode == ATTACK_MODE_BF)
15754 {
15755 local_free (css_buf);
15756 local_free (data.root_css_buf);
15757 local_free (data.markov_css_buf);
15758
15759 char *mask = dictfiles[dictpos];
15760
15761 logfile_sub_string (mask);
15762
15763 // base
15764
15765 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15766
15767 if (opts_type & OPTS_TYPE_PT_UNICODE)
15768 {
15769 uint css_cnt_unicode = css_cnt * 2;
15770
15771 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15772
15773 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15774 {
15775 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15776
15777 css_buf_unicode[j + 1].cs_buf[0] = 0;
15778 css_buf_unicode[j + 1].cs_len = 1;
15779 }
15780
15781 free (css_buf);
15782
15783 css_buf = css_buf_unicode;
15784 css_cnt = css_cnt_unicode;
15785 }
15786
15787 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15788
15789 uint mask_min = pw_min;
15790 uint mask_max = pw_max;
15791
15792 if (opts_type & OPTS_TYPE_PT_UNICODE)
15793 {
15794 mask_min *= 2;
15795 mask_max *= 2;
15796 }
15797
15798 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15799 {
15800 if (css_cnt < mask_min)
15801 {
15802 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15803 }
15804
15805 if (css_cnt > mask_max)
15806 {
15807 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15808 }
15809
15810 // skip to next mask
15811
15812 dictpos++;
15813
15814 rd->dictpos = dictpos;
15815
15816 logfile_sub_msg ("STOP");
15817
15818 continue;
15819 }
15820
15821 uint save_css_cnt = css_cnt;
15822
15823 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15824 {
15825 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15826 {
15827 uint salt_len = (uint) data.salts_buf[0].salt_len;
15828 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15829
15830 uint css_cnt_salt = css_cnt + salt_len;
15831
15832 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15833
15834 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15835
15836 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15837 {
15838 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15839 css_buf_salt[j].cs_len = 1;
15840 }
15841
15842 free (css_buf);
15843
15844 css_buf = css_buf_salt;
15845 css_cnt = css_cnt_salt;
15846 }
15847 }
15848
15849 data.mask = mask;
15850 data.css_cnt = css_cnt;
15851 data.css_buf = css_buf;
15852
15853 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15854
15855 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15856
15857 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15858
15859 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15860 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15861
15862 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15863
15864 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15865
15866 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15867 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15868
15869 data.root_css_buf = root_css_buf;
15870 data.markov_css_buf = markov_css_buf;
15871
15872 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15873
15874 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15875
15876 local_free (root_table_buf);
15877 local_free (markov_table_buf);
15878
15879 // copy + args
15880
15881 uint css_cnt_l = css_cnt;
15882 uint css_cnt_r;
15883
15884 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15885 {
15886 if (save_css_cnt < 6)
15887 {
15888 css_cnt_r = 1;
15889 }
15890 else if (save_css_cnt == 6)
15891 {
15892 css_cnt_r = 2;
15893 }
15894 else
15895 {
15896 if (opts_type & OPTS_TYPE_PT_UNICODE)
15897 {
15898 if (save_css_cnt == 8 || save_css_cnt == 10)
15899 {
15900 css_cnt_r = 2;
15901 }
15902 else
15903 {
15904 css_cnt_r = 4;
15905 }
15906 }
15907 else
15908 {
15909 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15910 {
15911 css_cnt_r = 3;
15912 }
15913 else
15914 {
15915 css_cnt_r = 4;
15916 }
15917 }
15918 }
15919 }
15920 else
15921 {
15922 css_cnt_r = 1;
15923
15924 /* unfinished code?
15925 int sum = css_buf[css_cnt_r - 1].cs_len;
15926
15927 for (uint i = 1; i < 4 && i < css_cnt; i++)
15928 {
15929 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15930
15931 css_cnt_r++;
15932
15933 sum *= css_buf[css_cnt_r - 1].cs_len;
15934 }
15935 */
15936 }
15937
15938 css_cnt_l -= css_cnt_r;
15939
15940 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15941
15942 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15943 {
15944 hc_device_param_t *device_param = &data.devices_param[device_id];
15945
15946 if (device_param->skipped) continue;
15947
15948 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15949 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15950 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15951
15952 device_param->kernel_params_mp_l_buf64[3] = 0;
15953 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15954 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15955 device_param->kernel_params_mp_l_buf32[6] = 0;
15956 device_param->kernel_params_mp_l_buf32[7] = 0;
15957 device_param->kernel_params_mp_l_buf32[8] = 0;
15958
15959 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15960 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15961 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15962 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15963
15964 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15965 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15966 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15967
15968 device_param->kernel_params_mp_r_buf64[3] = 0;
15969 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15970 device_param->kernel_params_mp_r_buf32[5] = 0;
15971 device_param->kernel_params_mp_r_buf32[6] = 0;
15972 device_param->kernel_params_mp_r_buf32[7] = 0;
15973
15974 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]);
15975 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]);
15976 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]);
15977
15978 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]);
15979 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]);
15980 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]);
15981
15982 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);
15983 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);
15984 }
15985 }
15986
15987 u64 words_base = data.words_cnt;
15988
15989 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15990 {
15991 if (data.kernel_rules_cnt)
15992 {
15993 words_base /= data.kernel_rules_cnt;
15994 }
15995 }
15996 else if (data.attack_kern == ATTACK_KERN_COMBI)
15997 {
15998 if (data.combs_cnt)
15999 {
16000 words_base /= data.combs_cnt;
16001 }
16002 }
16003 else if (data.attack_kern == ATTACK_KERN_BF)
16004 {
16005 if (data.bfs_cnt)
16006 {
16007 words_base /= data.bfs_cnt;
16008 }
16009 }
16010
16011 data.words_base = words_base;
16012
16013 if (keyspace == 1)
16014 {
16015 log_info ("%llu", (unsigned long long int) words_base);
16016
16017 return (0);
16018 }
16019
16020 if (data.words_cur > data.words_base)
16021 {
16022 log_error ("ERROR: restore value greater keyspace");
16023
16024 return (-1);
16025 }
16026
16027 if (data.words_cur)
16028 {
16029 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16030 {
16031 for (uint i = 0; i < data.salts_cnt; i++)
16032 {
16033 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16034 }
16035 }
16036 else if (data.attack_kern == ATTACK_KERN_COMBI)
16037 {
16038 for (uint i = 0; i < data.salts_cnt; i++)
16039 {
16040 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16041 }
16042 }
16043 else if (data.attack_kern == ATTACK_KERN_BF)
16044 {
16045 for (uint i = 0; i < data.salts_cnt; i++)
16046 {
16047 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16048 }
16049 }
16050 }
16051
16052 /*
16053 * Inform user about possible slow speeds
16054 */
16055
16056 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16057 {
16058 if (data.words_base < kernel_blocks_all)
16059 {
16060 if (quiet == 0)
16061 {
16062 log_info ("");
16063 log_info ("ATTENTION!");
16064 log_info (" The wordlist or mask you are using is too small.");
16065 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16066 log_info (" The cracking speed will drop.");
16067 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16068 log_info ("");
16069 }
16070 }
16071 }
16072
16073 /*
16074 * Update loopback file
16075 */
16076
16077 if (loopback == 1)
16078 {
16079 time_t now;
16080
16081 time (&now);
16082
16083 uint random_num = get_random_num (0, 9999);
16084
16085 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16086
16087 data.loopback_file = loopback_file;
16088 }
16089
16090 /*
16091 * Update dictionary statistic
16092 */
16093
16094 if (keyspace == 0)
16095 {
16096 dictstat_fp = fopen (dictstat, "wb");
16097
16098 if (dictstat_fp)
16099 {
16100 lock_file (dictstat_fp);
16101
16102 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16103
16104 fclose (dictstat_fp);
16105 }
16106 }
16107
16108 data.devices_status = STATUS_RUNNING;
16109
16110 if (initial_restore_done == 0)
16111 {
16112 if (data.restore_disable == 0) cycle_restore ();
16113
16114 initial_restore_done = 1;
16115 }
16116
16117 hc_timer_set (&data.timer_running);
16118
16119 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16120 {
16121 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16122 {
16123 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16124 if (quiet == 0) fflush (stdout);
16125 }
16126 }
16127 else if (wordlist_mode == WL_MODE_STDIN)
16128 {
16129 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16130 if (data.quiet == 0) log_info ("");
16131 }
16132
16133 time_t runtime_start;
16134
16135 time (&runtime_start);
16136
16137 data.runtime_start = runtime_start;
16138
16139 /**
16140 * create cracker threads
16141 */
16142
16143 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16144
16145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16146 {
16147 hc_device_param_t *device_param = &devices_param[device_id];
16148
16149 if (wordlist_mode == WL_MODE_STDIN)
16150 {
16151 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16152 }
16153 else
16154 {
16155 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16156 }
16157 }
16158
16159 // wait for crack threads to exit
16160
16161 hc_thread_wait (data.devices_cnt, c_threads);
16162
16163 local_free (c_threads);
16164
16165 data.restore = 0;
16166
16167 // finalize task
16168
16169 logfile_sub_var_uint ("status-after-work", data.devices_status);
16170
16171 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16172
16173 if (data.devices_status == STATUS_CRACKED) break;
16174 if (data.devices_status == STATUS_ABORTED) break;
16175
16176 if (data.devices_status == STATUS_BYPASS)
16177 {
16178 data.devices_status = STATUS_RUNNING;
16179 }
16180
16181 if (induction_dictionaries_cnt)
16182 {
16183 unlink (induction_dictionaries[0]);
16184 }
16185
16186 free (induction_dictionaries);
16187
16188 if (attack_mode != ATTACK_MODE_BF)
16189 {
16190 induction_dictionaries = scan_directory (induction_directory);
16191
16192 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16193 }
16194
16195 if (benchmark == 0)
16196 {
16197 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16198 {
16199 if (quiet == 0) clear_prompt ();
16200
16201 if (quiet == 0) log_info ("");
16202
16203 if (status == 1)
16204 {
16205 status_display ();
16206 }
16207 else
16208 {
16209 if (quiet == 0) status_display ();
16210 }
16211
16212 if (quiet == 0) log_info ("");
16213 }
16214 }
16215
16216 if (attack_mode == ATTACK_MODE_BF)
16217 {
16218 dictpos++;
16219
16220 rd->dictpos = dictpos;
16221 }
16222 else
16223 {
16224 if (induction_dictionaries_cnt)
16225 {
16226 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16227 }
16228 else
16229 {
16230 dictpos++;
16231
16232 rd->dictpos = dictpos;
16233 }
16234 }
16235
16236 time_t runtime_stop;
16237
16238 time (&runtime_stop);
16239
16240 data.runtime_stop = runtime_stop;
16241
16242 logfile_sub_uint (runtime_start);
16243 logfile_sub_uint (runtime_stop);
16244
16245 logfile_sub_msg ("STOP");
16246
16247 global_free (subid);
16248 }
16249
16250 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16251
16252 if (data.devices_status == STATUS_CRACKED) break;
16253 if (data.devices_status == STATUS_ABORTED) break;
16254 if (data.devices_status == STATUS_QUIT) break;
16255
16256 if (data.devices_status == STATUS_BYPASS)
16257 {
16258 data.devices_status = STATUS_RUNNING;
16259 }
16260 }
16261
16262 // 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
16263
16264 if (attack_mode == ATTACK_MODE_STRAIGHT)
16265 {
16266 if (data.wordlist_mode == WL_MODE_FILE)
16267 {
16268 if (data.dictfile == NULL)
16269 {
16270 if (dictfiles != NULL)
16271 {
16272 data.dictfile = dictfiles[0];
16273
16274 hc_timer_set (&data.timer_running);
16275 }
16276 }
16277 }
16278 }
16279 // NOTE: combi is okay because it is already set beforehand
16280 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16281 {
16282 if (data.dictfile == NULL)
16283 {
16284 if (dictfiles != NULL)
16285 {
16286 hc_timer_set (&data.timer_running);
16287
16288 data.dictfile = dictfiles[0];
16289 }
16290 }
16291 }
16292 else if (attack_mode == ATTACK_MODE_BF)
16293 {
16294 if (data.mask == NULL)
16295 {
16296 hc_timer_set (&data.timer_running);
16297
16298 data.mask = masks[0];
16299 }
16300 }
16301
16302 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16303 {
16304 data.devices_status = STATUS_EXHAUSTED;
16305 }
16306
16307 // if cracked / aborted remove last induction dictionary
16308
16309 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16310 {
16311 struct stat induct_stat;
16312
16313 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16314 {
16315 unlink (induction_dictionaries[file_pos]);
16316 }
16317 }
16318
16319 // wait for non-interactive threads
16320
16321 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16322 {
16323 hc_thread_wait (1, &ni_threads[thread_idx]);
16324 }
16325
16326 local_free (ni_threads);
16327
16328 // wait for interactive threads
16329
16330 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16331 {
16332 hc_thread_wait (1, &i_thread);
16333 }
16334
16335 // we dont need restore file anymore
16336 if (data.restore_disable == 0)
16337 {
16338 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16339 {
16340 unlink (eff_restore_file);
16341 unlink (new_restore_file);
16342 }
16343 else
16344 {
16345 cycle_restore ();
16346 }
16347 }
16348
16349 // finally save left hashes
16350
16351 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16352 {
16353 save_hash ();
16354 }
16355
16356 /**
16357 * Clean up
16358 */
16359
16360 if (benchmark == 1)
16361 {
16362 status_benchmark ();
16363
16364 log_info ("");
16365 }
16366 else
16367 {
16368 if (quiet == 0) clear_prompt ();
16369
16370 if (quiet == 0) log_info ("");
16371
16372 if (status == 1)
16373 {
16374 status_display ();
16375 }
16376 else
16377 {
16378 if (quiet == 0) status_display ();
16379 }
16380
16381 if (quiet == 0) log_info ("");
16382 }
16383
16384 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16385 {
16386 hc_device_param_t *device_param = &data.devices_param[device_id];
16387
16388 if (device_param->skipped) continue;
16389
16390 local_free (device_param->result);
16391
16392 local_free (device_param->pw_caches);
16393
16394 local_free (device_param->combs_buf);
16395
16396 local_free (device_param->hooks_buf);
16397
16398 local_free (device_param->device_name);
16399
16400 local_free (device_param->device_name_chksum);
16401
16402 local_free (device_param->device_version);
16403
16404 local_free (device_param->driver_version);
16405
16406 if (device_param->pws_buf) myfree (device_param->pws_buf);
16407 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16408 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16409 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16410 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16411 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16412 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16413 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16414 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16415 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16416 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16417 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16418 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16419 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16420 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16421 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16422 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16423 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16424 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16425 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16426 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16427 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16428 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16429 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16430 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16431 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16432 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16433 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16434 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16435
16436 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16437 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16438 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16439 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16440 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16441 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16442 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16443 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16444 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16445 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16446 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16447
16448 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16449 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16450 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16451
16452 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16453 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16454 }
16455
16456 // reset default fan speed
16457
16458 #ifdef HAVE_HWMON
16459 if (gpu_temp_disable == 0)
16460 {
16461 #ifdef HAVE_ADL
16462 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16463 {
16464 hc_thread_mutex_lock (mux_adl);
16465
16466 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16467 {
16468 hc_device_param_t *device_param = &data.devices_param[device_id];
16469
16470 if (device_param->skipped) continue;
16471
16472 if (data.hm_device[device_id].fan_supported == 1)
16473 {
16474 int fanspeed = temp_retain_fanspeed_value[device_id];
16475
16476 if (fanspeed == -1) continue;
16477
16478 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16479
16480 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16481 }
16482 }
16483
16484 hc_thread_mutex_unlock (mux_adl);
16485 }
16486 #endif // HAVE_ADL
16487 }
16488
16489 #ifdef HAVE_ADL
16490 // reset power tuning
16491
16492 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16493 {
16494 hc_thread_mutex_lock (mux_adl);
16495
16496 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16497 {
16498 hc_device_param_t *device_param = &data.devices_param[device_id];
16499
16500 if (device_param->skipped) continue;
16501
16502 if (data.hm_device[device_id].od_version == 6)
16503 {
16504 // check powertune capabilities first, if not available then skip device
16505
16506 int powertune_supported = 0;
16507
16508 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16509 {
16510 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16511
16512 return (-1);
16513 }
16514
16515 if (powertune_supported != 0)
16516 {
16517 // powercontrol settings
16518
16519 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)
16520 {
16521 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16522
16523 return (-1);
16524 }
16525
16526 // clocks
16527
16528 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16529
16530 performance_state->iNumberOfPerformanceLevels = 2;
16531
16532 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16533 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16534 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16535 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16536
16537 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)
16538 {
16539 log_info ("ERROR: Failed to restore ADL performance state");
16540
16541 return (-1);
16542 }
16543
16544 local_free (performance_state);
16545 }
16546 }
16547 }
16548
16549 hc_thread_mutex_unlock (mux_adl);
16550 }
16551 #endif // HAVE_ADL
16552
16553 if (gpu_temp_disable == 0)
16554 {
16555 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16556 if (data.hm_nv)
16557 {
16558 #if defined(LINUX) && defined(HAVE_NVML)
16559
16560 hm_NVML_nvmlShutdown (data.hm_nv);
16561
16562 nvml_close (data.hm_nv);
16563
16564 #elif defined(WIN) && (HAVE_NVAPI)
16565
16566 hm_NvAPI_Unload (data.hm_nv);
16567
16568 nvapi_close (data.hm_nv);
16569
16570 #endif
16571
16572 data.hm_nv = NULL;
16573 }
16574 #endif
16575
16576 #ifdef HAVE_ADL
16577 if (data.hm_amd)
16578 {
16579 hm_ADL_Main_Control_Destroy (data.hm_amd);
16580
16581 adl_close (data.hm_amd);
16582 data.hm_amd = NULL;
16583 }
16584 #endif
16585 }
16586 #endif // HAVE_HWMON
16587
16588 // free memory
16589
16590 local_free (masks);
16591
16592 local_free (dictstat_base);
16593
16594 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16595 {
16596 pot_t *pot_ptr = &pot[pot_pos];
16597
16598 hash_t *hash = &pot_ptr->hash;
16599
16600 local_free (hash->digest);
16601
16602 if (isSalted)
16603 {
16604 local_free (hash->salt);
16605 }
16606 }
16607
16608 local_free (pot);
16609
16610 local_free (all_kernel_rules_cnt);
16611 local_free (all_kernel_rules_buf);
16612
16613 local_free (wl_data->buf);
16614 local_free (wl_data);
16615
16616 local_free (bitmap_s1_a);
16617 local_free (bitmap_s1_b);
16618 local_free (bitmap_s1_c);
16619 local_free (bitmap_s1_d);
16620 local_free (bitmap_s2_a);
16621 local_free (bitmap_s2_b);
16622 local_free (bitmap_s2_c);
16623 local_free (bitmap_s2_d);
16624
16625 #ifdef HAVE_HWMON
16626 local_free (temp_retain_fanspeed_value);
16627 #ifdef HAVE_ADL
16628 local_free (od_clock_mem_status);
16629 local_free (od_power_control_status);
16630 #endif // ADL
16631 #endif
16632
16633 global_free (devices_param);
16634
16635 global_free (kernel_rules_buf);
16636
16637 global_free (root_css_buf);
16638 global_free (markov_css_buf);
16639
16640 global_free (digests_buf);
16641 global_free (digests_shown);
16642 global_free (digests_shown_tmp);
16643
16644 global_free (salts_buf);
16645 global_free (salts_shown);
16646
16647 global_free (esalts_buf);
16648
16649 global_free (words_progress_done);
16650 global_free (words_progress_rejected);
16651 global_free (words_progress_restored);
16652
16653 if (pot_fp) fclose (pot_fp);
16654
16655 if (data.devices_status == STATUS_QUIT) break;
16656 }
16657
16658 // destroy others mutex
16659
16660 hc_thread_mutex_delete (mux_dispatcher);
16661 hc_thread_mutex_delete (mux_counter);
16662 hc_thread_mutex_delete (mux_display);
16663 hc_thread_mutex_delete (mux_adl);
16664
16665 // free memory
16666
16667 local_free (eff_restore_file);
16668 local_free (new_restore_file);
16669
16670 local_free (rd);
16671
16672 // tuning db
16673
16674 tuning_db_destroy (tuning_db);
16675
16676 // loopback
16677
16678 local_free (loopback_file);
16679
16680 if (loopback == 1) unlink (loopback_file);
16681
16682 // induction directory
16683
16684 if (induction_dir == NULL)
16685 {
16686 if (attack_mode != ATTACK_MODE_BF)
16687 {
16688 if (rmdir (induction_directory) == -1)
16689 {
16690 if (errno == ENOENT)
16691 {
16692 // good, we can ignore
16693 }
16694 else if (errno == ENOTEMPTY)
16695 {
16696 // good, we can ignore
16697 }
16698 else
16699 {
16700 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16701
16702 return (-1);
16703 }
16704 }
16705
16706 local_free (induction_directory);
16707 }
16708 }
16709
16710 // outfile-check directory
16711
16712 if (outfile_check_dir == NULL)
16713 {
16714 if (rmdir (outfile_check_directory) == -1)
16715 {
16716 if (errno == ENOENT)
16717 {
16718 // good, we can ignore
16719 }
16720 else if (errno == ENOTEMPTY)
16721 {
16722 // good, we can ignore
16723 }
16724 else
16725 {
16726 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16727
16728 return (-1);
16729 }
16730 }
16731
16732 local_free (outfile_check_directory);
16733 }
16734
16735 time_t proc_stop;
16736
16737 time (&proc_stop);
16738
16739 logfile_top_uint (proc_start);
16740 logfile_top_uint (proc_stop);
16741
16742 logfile_top_msg ("STOP");
16743
16744 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16745 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16746
16747 if (data.ocl) ocl_close (data.ocl);
16748
16749 if (data.devices_status == STATUS_ABORTED) return 2;
16750 if (data.devices_status == STATUS_QUIT) return 2;
16751 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16752 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16753 if (data.devices_status == STATUS_CRACKED) return 0;
16754
16755 return -1;
16756 }
Hashcat additions to support pwdhash