projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Added new concept of a tuning database; tryout phase
[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 = ((double)(time_end - time_start) * (double)(device_param->device_timer_resolution)) / 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 // device_timer_resolution
12535
12536 cl_ulong device_timer_resolution;
12537
12538 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof (device_timer_resolution), &device_timer_resolution, NULL);
12539
12540 device_param->device_timer_resolution = device_timer_resolution;
12541
12542 // skipped
12543
12544 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12545 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12546
12547 device_param->skipped = (skipped1 || skipped2);
12548
12549 // driver_version
12550 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12551
12552 char *driver_version = (char *) mymalloc (param_value_size);
12553
12554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12555
12556 device_param->driver_version = driver_version;
12557
12558 // device_name_chksum
12559
12560 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12561
12562 #if __x86_64__
12563 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);
12564 #else
12565 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);
12566 #endif
12567
12568 uint device_name_digest[4] = { 0 };
12569
12570 md5_64 ((uint *) device_name_chksum, device_name_digest);
12571
12572 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12573
12574 device_param->device_name_chksum = device_name_chksum;
12575
12576 // device_processor_cores
12577
12578 if (device_type & CL_DEVICE_TYPE_CPU)
12579 {
12580 cl_uint device_processor_cores = 1;
12581
12582 device_param->device_processor_cores = device_processor_cores;
12583 }
12584
12585 if (device_type & CL_DEVICE_TYPE_GPU)
12586 {
12587 if (vendor_id == VENDOR_ID_AMD)
12588 {
12589 cl_uint device_processor_cores = 0;
12590
12591 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12592
12593 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12594
12595 device_param->device_processor_cores = device_processor_cores;
12596 }
12597 else if (vendor_id == VENDOR_ID_NV)
12598 {
12599 cl_uint kernel_exec_timeout = 0;
12600
12601 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12602
12603 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12604
12605 device_param->kernel_exec_timeout = kernel_exec_timeout;
12606
12607 cl_uint device_processor_cores = 0;
12608
12609 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12610
12611 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12612
12613 device_param->device_processor_cores = device_processor_cores;
12614
12615 cl_uint sm_minor = 0;
12616 cl_uint sm_major = 0;
12617
12618 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12619 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12620
12621 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12622 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12623
12624 device_param->sm_minor = sm_minor;
12625 device_param->sm_major = sm_major;
12626 }
12627 else
12628 {
12629 cl_uint device_processor_cores = 1;
12630
12631 device_param->device_processor_cores = device_processor_cores;
12632 }
12633 }
12634
12635 // display results
12636
12637 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12638 {
12639 if (device_param->skipped == 0)
12640 {
12641 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12642 device_id + 1,
12643 device_name,
12644 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12645 (unsigned int) (device_global_mem / 1024 / 1024),
12646 (unsigned int) (device_maxclock_frequency),
12647 (unsigned int) device_processors);
12648 }
12649 else
12650 {
12651 log_info ("Device #%u: %s, skipped",
12652 device_id + 1,
12653 device_name);
12654 }
12655 }
12656
12657 // common driver check
12658
12659 if (device_param->skipped == 0)
12660 {
12661 if (strstr (device_version, "pocl"))
12662 {
12663 if (force == 0)
12664 {
12665 log_info ("");
12666 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12667 log_info ("You are STRONGLY encouraged not to use it");
12668 log_info ("You can use --force to override this but do not post error reports if you do so");
12669 log_info ("");
12670
12671 return (-1);
12672 }
12673 }
12674
12675 if (device_type & CL_DEVICE_TYPE_GPU)
12676 {
12677 if (vendor_id == VENDOR_ID_NV)
12678 {
12679 if (device_param->kernel_exec_timeout != 0)
12680 {
12681 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);
12682 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12683 }
12684 }
12685 else if (vendor_id == VENDOR_ID_AMD)
12686 {
12687 int catalyst_check = (force == 1) ? 0 : 1;
12688
12689 int catalyst_warn = 0;
12690
12691 int catalyst_broken = 0;
12692
12693 if (catalyst_check == 1)
12694 {
12695 catalyst_warn = 1;
12696
12697 // v14.9 and higher
12698 if (atoi (device_param->driver_version) >= 1573)
12699 {
12700 catalyst_warn = 0;
12701 }
12702
12703 catalyst_check = 0;
12704 }
12705
12706 if (catalyst_broken == 1)
12707 {
12708 log_info ("");
12709 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12710 log_info ("It will pass over cracked hashes and does not report them as cracked");
12711 log_info ("You are STRONGLY encouraged not to use it");
12712 log_info ("You can use --force to override this but do not post error reports if you do so");
12713 log_info ("");
12714
12715 return (-1);
12716 }
12717
12718 if (catalyst_warn == 1)
12719 {
12720 log_info ("");
12721 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12722 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12723 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12724 #ifdef _WIN
12725 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12726 #endif
12727 log_info ("You can use --force to override this but do not post error reports if you do so");
12728 log_info ("");
12729
12730 return (-1);
12731 }
12732 }
12733 }
12734
12735 /**
12736 * kernel accel and loops auto adjustment
12737 */
12738
12739 uint _kernel_accel = kernel_accel;
12740 uint _kernel_loops = kernel_loops;
12741
12742 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param->device_name, attack_mode, hash_mode, workload_profile);
12743
12744 if (kernel_accel_chgd == 0)
12745 {
12746 _kernel_accel = tuningdb_entry->kernel_accel;
12747 }
12748
12749 if (kernel_loops_chgd == 0)
12750 {
12751 _kernel_loops = tuningdb_entry->kernel_loops;
12752 }
12753
12754 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
12755 {
12756 _kernel_loops = 1024;
12757 }
12758
12759 if (hash_mode == 12500)
12760 {
12761 _kernel_loops = ROUNDS_RAR3 / 16;
12762 }
12763
12764 device_param->kernel_accel = _kernel_accel;
12765 device_param->kernel_loops = _kernel_loops;
12766
12767 devices_active++;
12768 }
12769
12770 // next please
12771
12772 devices_cnt++;
12773 }
12774 }
12775
12776 if (keyspace == 0 && devices_active == 0)
12777 {
12778 log_error ("ERROR: No devices found/left");
12779
12780 return (-1);
12781 }
12782
12783 data.devices_cnt = devices_cnt;
12784
12785 data.devices_active = devices_active;
12786
12787 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12788 {
12789 log_info ("");
12790 }
12791
12792 /**
12793 * HM devices: init
12794 */
12795
12796 #ifdef HAVE_HWMON
12797 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12798 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12799 #endif
12800
12801 #ifdef HAVE_ADL
12802 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12803 #endif
12804
12805 if (gpu_temp_disable == 0)
12806 {
12807 #if defined(WIN) && defined(HAVE_NVAPI)
12808 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
12809
12810 if (nvapi_init (nvapi) == 0)
12811 data.hm_nv = nvapi;
12812
12813 if (data.hm_nv)
12814 {
12815 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
12816 {
12817 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12818
12819 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12820
12821 int tmp_out = 0;
12822
12823 for (int i = 0; i < tmp_in; i++)
12824 {
12825 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12826 }
12827
12828 for (int i = 0; i < tmp_out; i++)
12829 {
12830 NV_GPU_COOLER_SETTINGS pCoolerSettings;
12831
12832 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
12833
12834 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;
12835 }
12836 }
12837 }
12838 #endif // WIN && HAVE_NVAPI
12839
12840 #if defined(LINUX) && defined(HAVE_NVML)
12841 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
12842
12843 if (nvml_init (nvml) == 0)
12844 data.hm_nv = nvml;
12845
12846 if (data.hm_nv)
12847 {
12848 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
12849 {
12850 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
12851
12852 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12853
12854 int tmp_out = 0;
12855
12856 for (int i = 0; i < tmp_in; i++)
12857 {
12858 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12859 }
12860
12861 for (int i = 0; i < tmp_out; i++)
12862 {
12863 unsigned int speed;
12864
12865 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;
12866 }
12867 }
12868 }
12869 #endif // LINUX && HAVE_NVML
12870
12871 data.hm_amd = NULL;
12872
12873 #ifdef HAVE_ADL
12874 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
12875
12876 if (adl_init (adl) == 0)
12877 data.hm_amd = adl;
12878
12879 if (data.hm_amd)
12880 {
12881 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12882 {
12883 // total number of adapters
12884
12885 int hm_adapters_num;
12886
12887 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
12888
12889 // adapter info
12890
12891 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
12892
12893 if (lpAdapterInfo == NULL) return (-1);
12894
12895 // get a list (of ids of) valid/usable adapters
12896
12897 int num_adl_adapters = 0;
12898
12899 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12900
12901 if (num_adl_adapters > 0)
12902 {
12903 hc_thread_mutex_lock (mux_adl);
12904
12905 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12906
12907 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12908
12909 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12910 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12911
12912 hc_thread_mutex_unlock (mux_adl);
12913 }
12914
12915 myfree (valid_adl_device_list);
12916 myfree (lpAdapterInfo);
12917 }
12918 }
12919 #endif // HAVE_ADL
12920
12921 if (data.hm_amd == NULL && data.hm_nv == NULL)
12922 {
12923 gpu_temp_disable = 1;
12924 }
12925 }
12926
12927 /**
12928 * OpenCL devices: allocate buffer for device specific information
12929 */
12930
12931 #ifdef HAVE_HWMON
12932 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
12933
12934 #ifdef HAVE_ADL
12935 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
12936
12937 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
12938 #endif // ADL
12939 #endif
12940
12941 /**
12942 * enable custom signal handler(s)
12943 */
12944
12945 if (benchmark == 0)
12946 {
12947 hc_signal (sigHandler_default);
12948 }
12949 else
12950 {
12951 hc_signal (sigHandler_benchmark);
12952 }
12953
12954 /**
12955 * User-defined GPU temp handling
12956 */
12957
12958 #ifdef HAVE_HWMON
12959 if (gpu_temp_disable == 1)
12960 {
12961 gpu_temp_abort = 0;
12962 gpu_temp_retain = 0;
12963 }
12964
12965 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12966 {
12967 if (gpu_temp_abort < gpu_temp_retain)
12968 {
12969 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12970
12971 return (-1);
12972 }
12973 }
12974
12975 data.gpu_temp_disable = gpu_temp_disable;
12976 data.gpu_temp_abort = gpu_temp_abort;
12977 data.gpu_temp_retain = gpu_temp_retain;
12978 #endif
12979
12980 /**
12981 * inform the user
12982 */
12983
12984 if (data.quiet == 0)
12985 {
12986 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12987
12988 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);
12989
12990 if (attack_mode == ATTACK_MODE_STRAIGHT)
12991 {
12992 log_info ("Rules: %u", kernel_rules_cnt);
12993 }
12994
12995 if (opti_type)
12996 {
12997 log_info ("Applicable Optimizers:");
12998
12999 for (uint i = 0; i < 32; i++)
13000 {
13001 const uint opti_bit = 1u << i;
13002
13003 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13004 }
13005 }
13006
13007 /**
13008 * Watchdog and Temperature balance
13009 */
13010
13011 #ifdef HAVE_HWMON
13012 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13013 {
13014 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13015 }
13016
13017 if (gpu_temp_abort == 0)
13018 {
13019 log_info ("Watchdog: Temperature abort trigger disabled");
13020 }
13021 else
13022 {
13023 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13024 }
13025
13026 if (gpu_temp_retain == 0)
13027 {
13028 log_info ("Watchdog: Temperature retain trigger disabled");
13029 }
13030 else
13031 {
13032 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13033 }
13034 #endif
13035 }
13036
13037 if (data.quiet == 0) log_info ("");
13038
13039 /**
13040 * HM devices: copy
13041 */
13042
13043 if (gpu_temp_disable == 0)
13044 {
13045 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13046 {
13047 hc_device_param_t *device_param = &data.devices_param[device_id];
13048
13049 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13050
13051 if (device_param->skipped) continue;
13052
13053 const uint platform_devices_id = device_param->platform_devices_id;
13054
13055 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13056 if (device_param->vendor_id == VENDOR_ID_NV)
13057 {
13058 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13059 }
13060 #endif
13061
13062 #ifdef HAVE_ADL
13063 if (device_param->vendor_id == VENDOR_ID_AMD)
13064 {
13065 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13066 }
13067 #endif
13068 }
13069 }
13070
13071 /*
13072 * Temporary fix:
13073 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13074 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13075 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13076 * Driver / ADL bug?
13077 */
13078
13079 #ifdef HAVE_ADL
13080 if (powertune_enable == 1)
13081 {
13082 hc_thread_mutex_lock (mux_adl);
13083
13084 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13085 {
13086 hc_device_param_t *device_param = &data.devices_param[device_id];
13087
13088 if (device_param->skipped) continue;
13089
13090 if (data.hm_device[device_id].od_version == 6)
13091 {
13092 // set powertune value only
13093
13094 int powertune_supported = 0;
13095
13096 int ADL_rc = 0;
13097
13098 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13099 {
13100 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13101
13102 return (-1);
13103 }
13104
13105 if (powertune_supported != 0)
13106 {
13107 // powertune set
13108 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13109
13110 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13111 {
13112 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13113
13114 return (-1);
13115 }
13116
13117 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13118 {
13119 log_error ("ERROR: Failed to set new ADL PowerControl values");
13120
13121 return (-1);
13122 }
13123 }
13124 }
13125 }
13126
13127 hc_thread_mutex_unlock (mux_adl);
13128 }
13129 #endif // HAVE_ADK
13130 #endif // HAVE_HWMON
13131
13132 #ifdef OSX
13133 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13134 {
13135 if (force == 0)
13136 {
13137 log_info ("");
13138 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13139 log_info ("You can use --force to override this but do not post error reports if you do so");
13140 log_info ("");
13141
13142 continue;
13143 }
13144 }
13145 #endif
13146
13147 #ifdef DEBUG
13148 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13149 #endif
13150
13151 uint kernel_blocks_all = 0;
13152
13153 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13154 {
13155 /**
13156 * host buffer
13157 */
13158
13159 hc_device_param_t *device_param = &data.devices_param[device_id];
13160
13161 if (device_param->skipped) continue;
13162
13163 /**
13164 * device properties
13165 */
13166
13167 char *device_name_chksum = device_param->device_name_chksum;
13168
13169 uint device_processors = device_param->device_processors;
13170
13171 uint device_processor_cores = device_param->device_processor_cores;
13172
13173 uint kernel_accel = device_param->kernel_accel;
13174
13175 /**
13176 * create context for each device
13177 */
13178
13179 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13180
13181 /**
13182 * create command-queue
13183 */
13184
13185 // not supported with NV
13186 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13187
13188 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
13189
13190 /**
13191 * create input buffers on device
13192 */
13193
13194 uint kernel_threads = KERNEL_THREADS;
13195
13196 // bcrypt
13197 if (hash_mode == 3200) kernel_threads = 8;
13198 if (hash_mode == 9000) kernel_threads = 8;
13199
13200 uint kernel_power = 1;
13201 uint kernel_blocks = 1;
13202
13203 uint size_pws = 4;
13204 uint size_tmps = 4;
13205 uint size_hooks = 4;
13206
13207 // find out if we would request too much memory on memory blocks which are based on kernel_accel
13208
13209 while (kernel_accel)
13210 {
13211 kernel_power = device_processors * kernel_threads * kernel_accel;
13212 kernel_blocks = kernel_power;
13213
13214 // size_pws
13215
13216 size_pws = kernel_blocks * sizeof (pw_t);
13217
13218 // size_tmps
13219
13220 switch (hash_mode)
13221 {
13222 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13223 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13224 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13225 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13226 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13227 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13228 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13229 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13230 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13231 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13232 case 6211:
13233 case 6212:
13234 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13235 case 6221:
13236 case 6222:
13237 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13238 case 6231:
13239 case 6232:
13240 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13241 case 6241:
13242 case 6242:
13243 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13244 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13245 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13246 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13247 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13248 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13249 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13250 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13251 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13252 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13253 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13254 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13255 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13256 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13257 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13258 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13259 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13260 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13261 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13262 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13263 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13264 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13265 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13266 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13267 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13268 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13269 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13270 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13271 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13272 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13273 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13274 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13275 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13276 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13277 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13278 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13279 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13280 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13281 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13282 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13283 };
13284
13285 // size_hooks
13286
13287 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13288 {
13289 // none yet
13290 }
13291
13292 // now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
13293 // if not, decrease amplifier and try again
13294
13295 if (size_pws > device_param->device_maxmem_alloc)
13296 {
13297 kernel_accel--;
13298
13299 continue;
13300 }
13301
13302 if (size_tmps > device_param->device_maxmem_alloc)
13303 {
13304 kernel_accel--;
13305
13306 continue;
13307 }
13308
13309 if (size_hooks > device_param->device_maxmem_alloc)
13310 {
13311 kernel_accel--;
13312
13313 continue;
13314 }
13315
13316 if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
13317 {
13318 kernel_accel--;
13319
13320 continue;
13321 }
13322
13323 break;
13324 }
13325
13326 if (kernel_accel == 0)
13327 {
13328 log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
13329
13330 return -1;
13331 }
13332
13333 device_param->kernel_threads = kernel_threads;
13334 device_param->kernel_power_user = kernel_power;
13335 device_param->kernel_blocks_user = kernel_blocks;
13336
13337 kernel_blocks_all += kernel_blocks;
13338
13339 device_param->size_pws = size_pws;
13340 device_param->size_tmps = size_tmps;
13341 device_param->size_hooks = size_hooks;
13342
13343 // we can optimize some stuff here...
13344
13345 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13346 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13347
13348 device_param->size_root_css = size_root_css;
13349 device_param->size_markov_css = size_markov_css;
13350
13351 uint size_results = KERNEL_THREADS * sizeof (uint);
13352
13353 device_param->size_results = size_results;
13354
13355 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13356 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13357
13358 uint size_plains = digests_cnt * sizeof (plain_t);
13359 uint size_salts = salts_cnt * sizeof (salt_t);
13360 uint size_esalts = salts_cnt * esalt_size;
13361
13362 device_param->size_plains = size_plains;
13363 device_param->size_digests = size_digests;
13364 device_param->size_shown = size_shown;
13365 device_param->size_salts = size_salts;
13366
13367 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13368 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13369 uint size_tm = 32 * sizeof (bs_word_t);
13370
13371 // scrypt stuff
13372
13373 u64 size_scryptV = 1;
13374
13375 if ((hash_mode == 8900) || (hash_mode == 9300))
13376 {
13377 uint tmto_start = 0;
13378 uint tmto_stop = 10;
13379
13380 if (scrypt_tmto)
13381 {
13382 tmto_start = scrypt_tmto;
13383 }
13384 else
13385 {
13386 // in case the user did not specify the tmto manually
13387 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13388 // but set the lower end only in case the user has a device with too less memory
13389
13390 if (hash_mode == 8900)
13391 {
13392 if (device_param->vendor_id == VENDOR_ID_AMD)
13393 {
13394 tmto_start = 1;
13395 }
13396 else if (device_param->vendor_id == VENDOR_ID_NV)
13397 {
13398 tmto_start = 3;
13399 }
13400 }
13401 else if (hash_mode == 9300)
13402 {
13403 if (device_param->vendor_id == VENDOR_ID_AMD)
13404 {
13405 tmto_start = 3;
13406 }
13407 else if (device_param->vendor_id == VENDOR_ID_NV)
13408 {
13409 tmto_start = 5;
13410 }
13411 }
13412 }
13413
13414 if (quiet == 0) log_info ("");
13415
13416 uint shader_per_mp = 1;
13417
13418 if (device_param->vendor_id == VENDOR_ID_AMD)
13419 {
13420 shader_per_mp = 8;
13421 }
13422 else if (device_param->vendor_id == VENDOR_ID_NV)
13423 {
13424 shader_per_mp = 32;
13425 }
13426
13427 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13428 {
13429 // TODO: in theory the following calculation needs to be done per salt, not global
13430 // we assume all hashes have the same scrypt settings
13431
13432 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13433
13434 size_scryptV /= 1 << tmto;
13435
13436 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13437
13438 if (size_scryptV > device_param->device_maxmem_alloc)
13439 {
13440 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13441
13442 continue;
13443 }
13444
13445 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13446 {
13447 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13448 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13449 }
13450
13451 break;
13452 }
13453
13454 if (data.salts_buf[0].scrypt_phy == 0)
13455 {
13456 log_error ("ERROR: can't allocate enough device memory");
13457
13458 return -1;
13459 }
13460
13461 if (quiet == 0) log_info ("");
13462 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13463 }
13464
13465 /**
13466 * default building options
13467 */
13468
13469 char build_opts[1024] = { 0 };
13470
13471 // we don't have sm_* on vendors not NV but it doesn't matter
13472
13473 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);
13474
13475 /**
13476 * main kernel
13477 */
13478
13479 {
13480 /**
13481 * kernel source filename
13482 */
13483
13484 char source_file[256] = { 0 };
13485
13486 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13487
13488 struct stat sst;
13489
13490 if (stat (source_file, &sst) == -1)
13491 {
13492 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13493
13494 return -1;
13495 }
13496
13497 /**
13498 * kernel cached filename
13499 */
13500
13501 char cached_file[256] = { 0 };
13502
13503 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13504
13505 int cached = 1;
13506
13507 struct stat cst;
13508
13509 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13510 {
13511 cached = 0;
13512 }
13513
13514 /**
13515 * kernel compile or load
13516 */
13517
13518 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13519
13520 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13521
13522 if (force_jit_compilation == -1)
13523 {
13524 if (cached == 0)
13525 {
13526 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13527
13528 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13529
13530 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13531
13532 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13533
13534 if (rc != 0)
13535 {
13536 device_param->skipped = true;
13537 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13538 continue;
13539 }
13540
13541 size_t binary_size;
13542
13543 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13544
13545 u8 *binary = (u8 *) mymalloc (binary_size);
13546
13547 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13548
13549 writeProgramBin (cached_file, binary, binary_size);
13550
13551 local_free (binary);
13552 }
13553 else
13554 {
13555 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13556
13557 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13558
13559 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13560
13561 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13562 }
13563 }
13564 else
13565 {
13566 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13567
13568 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13569
13570 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13571
13572 char build_opts_update[1024] = { 0 };
13573
13574 if (force_jit_compilation == 1500)
13575 {
13576 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13577 }
13578 else if (force_jit_compilation == 8900)
13579 {
13580 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);
13581 }
13582
13583 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13584
13585 if (rc != 0)
13586 {
13587 device_param->skipped = true;
13588 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13589 }
13590 }
13591
13592 local_free (kernel_lengths);
13593 local_free (kernel_sources[0]);
13594 local_free (kernel_sources);
13595 }
13596
13597 /**
13598 * word generator kernel
13599 */
13600
13601 if (attack_mode != ATTACK_MODE_STRAIGHT)
13602 {
13603 /**
13604 * kernel mp source filename
13605 */
13606
13607 char source_file[256] = { 0 };
13608
13609 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13610
13611 struct stat sst;
13612
13613 if (stat (source_file, &sst) == -1)
13614 {
13615 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13616
13617 return -1;
13618 }
13619
13620 /**
13621 * kernel mp cached filename
13622 */
13623
13624 char cached_file[256] = { 0 };
13625
13626 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13627
13628 int cached = 1;
13629
13630 struct stat cst;
13631
13632 if (stat (cached_file, &cst) == -1)
13633 {
13634 cached = 0;
13635 }
13636
13637 /**
13638 * kernel compile or load
13639 */
13640
13641 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13642
13643 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13644
13645 if (cached == 0)
13646 {
13647 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13648
13649 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13650
13651 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13652
13653 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13654
13655 if (rc != 0)
13656 {
13657 device_param->skipped = true;
13658 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13659 continue;
13660 }
13661
13662 size_t binary_size;
13663
13664 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13665
13666 u8 *binary = (u8 *) mymalloc (binary_size);
13667
13668 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13669
13670 writeProgramBin (cached_file, binary, binary_size);
13671
13672 local_free (binary);
13673 }
13674 else
13675 {
13676 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13677
13678 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13679
13680 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13681
13682 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13683 }
13684
13685 local_free (kernel_lengths);
13686 local_free (kernel_sources[0]);
13687 local_free (kernel_sources);
13688 }
13689
13690 /**
13691 * amplifier kernel
13692 */
13693
13694 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13695 {
13696
13697 }
13698 else
13699 {
13700 /**
13701 * kernel amp source filename
13702 */
13703
13704 char source_file[256] = { 0 };
13705
13706 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13707
13708 struct stat sst;
13709
13710 if (stat (source_file, &sst) == -1)
13711 {
13712 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13713
13714 return -1;
13715 }
13716
13717 /**
13718 * kernel amp cached filename
13719 */
13720
13721 char cached_file[256] = { 0 };
13722
13723 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13724
13725 int cached = 1;
13726
13727 struct stat cst;
13728
13729 if (stat (cached_file, &cst) == -1)
13730 {
13731 cached = 0;
13732 }
13733
13734 /**
13735 * kernel compile or load
13736 */
13737
13738 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13739
13740 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13741
13742 if (cached == 0)
13743 {
13744 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13745
13746 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13747
13748 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13749
13750 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13751
13752 if (rc != 0)
13753 {
13754 device_param->skipped = true;
13755 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13756 continue;
13757 }
13758
13759 size_t binary_size;
13760
13761 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13762
13763 u8 *binary = (u8 *) mymalloc (binary_size);
13764
13765 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13766
13767 writeProgramBin (cached_file, binary, binary_size);
13768
13769 local_free (binary);
13770 }
13771 else
13772 {
13773 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13774
13775 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13776
13777 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13778
13779 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
13780 }
13781
13782 local_free (kernel_lengths);
13783 local_free (kernel_sources[0]);
13784 local_free (kernel_sources);
13785 }
13786
13787 // some algorithm collide too fast, make that impossible
13788
13789 if (benchmark == 1)
13790 {
13791 ((uint *) digests_buf)[0] = -1;
13792 ((uint *) digests_buf)[1] = -1;
13793 ((uint *) digests_buf)[2] = -1;
13794 ((uint *) digests_buf)[3] = -1;
13795 }
13796
13797 /**
13798 * global buffers
13799 */
13800
13801 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13802 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13803 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13804 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13805 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13806 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13807 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13808 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13809 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13810 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13811 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13812 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13813 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13814 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13815 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13816 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13817 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13818 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13819
13820 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);
13821 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);
13822 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);
13823 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);
13824 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);
13825 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);
13826 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);
13827 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);
13828 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13829 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13830 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13831
13832 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13833 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13834 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13835 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13836 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13837 run_kernel_bzero (device_param, device_param->d_result, size_results);
13838
13839 /**
13840 * special buffers
13841 */
13842
13843 if (attack_kern == ATTACK_KERN_STRAIGHT)
13844 {
13845 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13846 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13847
13848 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13849
13850 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13851 }
13852 else if (attack_kern == ATTACK_KERN_COMBI)
13853 {
13854 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13855 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13856 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13857 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13858
13859 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13860 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13861 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13862 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13863 }
13864 else if (attack_kern == ATTACK_KERN_BF)
13865 {
13866 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13867 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13868 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13869 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13870 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13871
13872 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13873 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13874 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13875 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13876 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13877 }
13878
13879 if (size_esalts)
13880 {
13881 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13882
13883 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13884 }
13885
13886 /**
13887 * main host data
13888 */
13889
13890 uint *result = (uint *) mymalloc (size_results);
13891
13892 device_param->result = result;
13893
13894 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13895
13896 device_param->pws_buf = pws_buf;
13897
13898 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13899
13900 for (int i = 0; i < 64; i++)
13901 {
13902 pw_caches[i].pw_buf.pw_len = i;
13903 pw_caches[i].cnt = 0;
13904 }
13905
13906 device_param->pw_caches = pw_caches;
13907
13908 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13909
13910 device_param->combs_buf = combs_buf;
13911
13912 void *hooks_buf = mymalloc (size_hooks);
13913
13914 device_param->hooks_buf = hooks_buf;
13915
13916 device_param->pw_transpose = pw_transpose_to_hi1;
13917 device_param->pw_add = pw_add_to_hc1;
13918
13919 /**
13920 * kernel args
13921 */
13922
13923 device_param->kernel_params_buf32[21] = bitmap_mask;
13924 device_param->kernel_params_buf32[22] = bitmap_shift1;
13925 device_param->kernel_params_buf32[23] = bitmap_shift2;
13926 device_param->kernel_params_buf32[24] = 0; // salt_pos
13927 device_param->kernel_params_buf32[25] = 0; // loop_pos
13928 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13929 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13930 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13931 device_param->kernel_params_buf32[29] = 0; // digests_offset
13932 device_param->kernel_params_buf32[30] = 0; // combs_mode
13933 device_param->kernel_params_buf32[31] = 0; // gid_max
13934
13935 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13936 ? &device_param->d_pws_buf
13937 : &device_param->d_pws_amp_buf;
13938 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13939 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13940 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13941 device_param->kernel_params[ 4] = &device_param->d_tmps;
13942 device_param->kernel_params[ 5] = &device_param->d_hooks;
13943 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13944 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13945 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13946 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13947 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13948 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13949 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13950 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13951 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13952 device_param->kernel_params[15] = &device_param->d_digests_buf;
13953 device_param->kernel_params[16] = &device_param->d_digests_shown;
13954 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13955 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13956 device_param->kernel_params[19] = &device_param->d_result;
13957 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13958 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13959 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13960 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13961 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13962 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13963 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13964 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13965 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13966 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13967 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13968 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13969
13970 device_param->kernel_params_mp_buf64[3] = 0;
13971 device_param->kernel_params_mp_buf32[4] = 0;
13972 device_param->kernel_params_mp_buf32[5] = 0;
13973 device_param->kernel_params_mp_buf32[6] = 0;
13974 device_param->kernel_params_mp_buf32[7] = 0;
13975 device_param->kernel_params_mp_buf32[8] = 0;
13976
13977 device_param->kernel_params_mp[0] = NULL;
13978 device_param->kernel_params_mp[1] = NULL;
13979 device_param->kernel_params_mp[2] = NULL;
13980 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13981 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13982 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13983 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13984 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13985 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13986
13987 device_param->kernel_params_mp_l_buf64[3] = 0;
13988 device_param->kernel_params_mp_l_buf32[4] = 0;
13989 device_param->kernel_params_mp_l_buf32[5] = 0;
13990 device_param->kernel_params_mp_l_buf32[6] = 0;
13991 device_param->kernel_params_mp_l_buf32[7] = 0;
13992 device_param->kernel_params_mp_l_buf32[8] = 0;
13993 device_param->kernel_params_mp_l_buf32[9] = 0;
13994
13995 device_param->kernel_params_mp_l[0] = NULL;
13996 device_param->kernel_params_mp_l[1] = NULL;
13997 device_param->kernel_params_mp_l[2] = NULL;
13998 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13999 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14000 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14001 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14002 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14003 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14004 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14005
14006 device_param->kernel_params_mp_r_buf64[3] = 0;
14007 device_param->kernel_params_mp_r_buf32[4] = 0;
14008 device_param->kernel_params_mp_r_buf32[5] = 0;
14009 device_param->kernel_params_mp_r_buf32[6] = 0;
14010 device_param->kernel_params_mp_r_buf32[7] = 0;
14011 device_param->kernel_params_mp_r_buf32[8] = 0;
14012
14013 device_param->kernel_params_mp_r[0] = NULL;
14014 device_param->kernel_params_mp_r[1] = NULL;
14015 device_param->kernel_params_mp_r[2] = NULL;
14016 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14017 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14018 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14019 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14020 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14021 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14022
14023 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14024 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14025
14026 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14027 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14028 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14029 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14030 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14031 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14032 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14033
14034 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14035
14036 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14037 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14038
14039 /**
14040 * kernel name
14041 */
14042
14043 char kernel_name[64] = { 0 };
14044
14045 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14046 {
14047 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14048 {
14049 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14050
14051 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14052
14053 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14054
14055 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14056
14057 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14058
14059 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14060 }
14061 else
14062 {
14063 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14064
14065 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14066
14067 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14068
14069 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14070
14071 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14072
14073 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14074 }
14075
14076 if (data.attack_mode == ATTACK_MODE_BF)
14077 {
14078 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14079 {
14080 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14081
14082 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14083
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14085
14086 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14087 }
14088 }
14089 }
14090 else
14091 {
14092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14093
14094 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14095
14096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14097
14098 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14099
14100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14101
14102 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14103
14104 if (opts_type & OPTS_TYPE_HOOK12)
14105 {
14106 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14107
14108 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14109 }
14110
14111 if (opts_type & OPTS_TYPE_HOOK23)
14112 {
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14114
14115 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14116 }
14117 }
14118
14119 for (uint i = 0; i <= 20; i++)
14120 {
14121 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14122 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14123 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14124
14125 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14126 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14127 }
14128
14129 for (uint i = 21; i <= 31; i++)
14130 {
14131 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14132 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14133 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14134
14135 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14136 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14137 }
14138
14139 if (attack_mode == ATTACK_MODE_BF)
14140 {
14141 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14142 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14143
14144 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14145 {
14146 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14147
14148 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14149 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14150 }
14151 }
14152 else if (attack_mode == ATTACK_MODE_HYBRID1)
14153 {
14154 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14155 }
14156 else if (attack_mode == ATTACK_MODE_HYBRID2)
14157 {
14158 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14159 }
14160
14161 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14162 {
14163 // nothing to do
14164 }
14165 else
14166 {
14167 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14168 }
14169
14170 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14171 {
14172 // nothing to do
14173 }
14174 else
14175 {
14176 for (uint i = 0; i < 5; i++)
14177 {
14178 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14179 }
14180
14181 for (uint i = 5; i < 7; i++)
14182 {
14183 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14184 }
14185 }
14186
14187 /**
14188 * Store initial fanspeed if gpu_temp_retain is enabled
14189 */
14190
14191 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14192 int gpu_temp_retain_set = 0;
14193
14194 if (gpu_temp_disable == 0)
14195 {
14196 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14197 {
14198 hc_thread_mutex_lock (mux_adl);
14199
14200 if (data.hm_device[device_id].fan_supported == 1)
14201 {
14202 if (gpu_temp_retain_chgd == 0)
14203 {
14204 uint cur_temp = 0;
14205 uint default_temp = 0;
14206
14207 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);
14208
14209 if (ADL_rc == ADL_OK)
14210 {
14211 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14212
14213 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14214
14215 // special case with multi gpu setups: always use minimum retain
14216
14217 if (gpu_temp_retain_set == 0)
14218 {
14219 gpu_temp_retain = gpu_temp_retain_target;
14220 gpu_temp_retain_set = 1;
14221 }
14222 else
14223 {
14224 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14225 }
14226
14227 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14228 }
14229 }
14230
14231 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14232
14233 temp_retain_fanspeed_value[device_id] = fan_speed;
14234
14235 if (fan_speed == -1)
14236 {
14237 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14238
14239 temp_retain_fanspeed_value[device_id] = 0;
14240 }
14241 }
14242
14243 hc_thread_mutex_unlock (mux_adl);
14244 }
14245 }
14246
14247 /**
14248 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14249 */
14250
14251 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14252 {
14253 hc_thread_mutex_lock (mux_adl);
14254
14255 if (data.hm_device[device_id].od_version == 6)
14256 {
14257 int ADL_rc;
14258
14259 // check powertune capabilities first, if not available then skip device
14260
14261 int powertune_supported = 0;
14262
14263 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14264 {
14265 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14266
14267 return (-1);
14268 }
14269
14270 if (powertune_supported != 0)
14271 {
14272 // powercontrol settings
14273
14274 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14275
14276 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14277 {
14278 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14279 }
14280
14281 if (ADL_rc != ADL_OK)
14282 {
14283 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14284
14285 return (-1);
14286 }
14287
14288 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14289 {
14290 log_error ("ERROR: Failed to set new ADL PowerControl values");
14291
14292 return (-1);
14293 }
14294
14295 // clocks
14296
14297 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14298
14299 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14300
14301 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)
14302 {
14303 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14304
14305 return (-1);
14306 }
14307
14308 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14309
14310 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14311
14312 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14313 {
14314 log_error ("ERROR: Failed to get ADL device capabilities");
14315
14316 return (-1);
14317 }
14318
14319 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14320 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14321
14322 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14323 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14324
14325 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14326 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14327
14328 // warning if profile has too low max values
14329
14330 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14331 {
14332 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14333 }
14334
14335 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14336 {
14337 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14338 }
14339
14340 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14341
14342 performance_state->iNumberOfPerformanceLevels = 2;
14343
14344 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14345 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14346 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14347 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14348
14349 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)
14350 {
14351 log_info ("ERROR: Failed to set ADL performance state");
14352
14353 return (-1);
14354 }
14355
14356 local_free (performance_state);
14357 }
14358 }
14359
14360 hc_thread_mutex_unlock (mux_adl);
14361 }
14362 #endif // HAVE_HWMON && HAVE_ADL
14363 }
14364
14365 data.kernel_blocks_all = kernel_blocks_all;
14366
14367 if (data.quiet == 0) log_info ("");
14368
14369 /**
14370 * Inform user which algorithm is checked and at which workload setting
14371 */
14372
14373 if (benchmark == 1)
14374 {
14375 quiet = 0;
14376
14377 data.quiet = quiet;
14378
14379 char *hash_type = strhashtype (data.hash_mode); // not a bug
14380
14381 log_info ("Hashtype: %s", hash_type);
14382 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14383 log_info ("");
14384 }
14385
14386 /**
14387 * keep track of the progress
14388 */
14389
14390 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14391 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14392 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14393
14394 /**
14395 * open filehandles
14396 */
14397
14398 #if _WIN
14399 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14400 {
14401 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14402
14403 return (-1);
14404 }
14405
14406 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14407 {
14408 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14409
14410 return (-1);
14411 }
14412
14413 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14414 {
14415 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14416
14417 return (-1);
14418 }
14419 #endif
14420
14421 /**
14422 * dictionary pad
14423 */
14424
14425 segment_size *= (1024 * 1024);
14426
14427 data.segment_size = segment_size;
14428
14429 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14430
14431 wl_data->buf = (char *) mymalloc (segment_size);
14432 wl_data->avail = segment_size;
14433 wl_data->incr = segment_size;
14434 wl_data->cnt = 0;
14435 wl_data->pos = 0;
14436
14437 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14438
14439 data.wordlist_mode = wordlist_mode;
14440
14441 cs_t *css_buf = NULL;
14442 uint css_cnt = 0;
14443 uint dictcnt = 0;
14444 uint maskcnt = 1;
14445 char **masks = NULL;
14446 char **dictfiles = NULL;
14447
14448 uint mask_from_file = 0;
14449
14450 if (attack_mode == ATTACK_MODE_STRAIGHT)
14451 {
14452 if (wordlist_mode == WL_MODE_FILE)
14453 {
14454 int wls_left = myargc - (optind + 1);
14455
14456 for (int i = 0; i < wls_left; i++)
14457 {
14458 char *l0_filename = myargv[optind + 1 + i];
14459
14460 struct stat l0_stat;
14461
14462 if (stat (l0_filename, &l0_stat) == -1)
14463 {
14464 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14465
14466 return (-1);
14467 }
14468
14469 uint is_dir = S_ISDIR (l0_stat.st_mode);
14470
14471 if (is_dir == 0)
14472 {
14473 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14474
14475 dictcnt++;
14476
14477 dictfiles[dictcnt - 1] = l0_filename;
14478 }
14479 else
14480 {
14481 // do not allow --keyspace w/ a directory
14482
14483 if (keyspace == 1)
14484 {
14485 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14486
14487 return (-1);
14488 }
14489
14490 char **dictionary_files = NULL;
14491
14492 dictionary_files = scan_directory (l0_filename);
14493
14494 if (dictionary_files != NULL)
14495 {
14496 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14497
14498 for (int d = 0; dictionary_files[d] != NULL; d++)
14499 {
14500 char *l1_filename = dictionary_files[d];
14501
14502 struct stat l1_stat;
14503
14504 if (stat (l1_filename, &l1_stat) == -1)
14505 {
14506 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14507
14508 return (-1);
14509 }
14510
14511 if (S_ISREG (l1_stat.st_mode))
14512 {
14513 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14514
14515 dictcnt++;
14516
14517 dictfiles[dictcnt - 1] = strdup (l1_filename);
14518 }
14519 }
14520 }
14521
14522 local_free (dictionary_files);
14523 }
14524 }
14525
14526 if (dictcnt < 1)
14527 {
14528 log_error ("ERROR: No usable dictionary file found.");
14529
14530 return (-1);
14531 }
14532 }
14533 else if (wordlist_mode == WL_MODE_STDIN)
14534 {
14535 dictcnt = 1;
14536 }
14537 }
14538 else if (attack_mode == ATTACK_MODE_COMBI)
14539 {
14540 // display
14541
14542 char *dictfile1 = myargv[optind + 1 + 0];
14543 char *dictfile2 = myargv[optind + 1 + 1];
14544
14545 // find the bigger dictionary and use as base
14546
14547 FILE *fp1 = NULL;
14548 FILE *fp2 = NULL;
14549
14550 struct stat tmp_stat;
14551
14552 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14553 {
14554 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14555
14556 return (-1);
14557 }
14558
14559 if (stat (dictfile1, &tmp_stat) == -1)
14560 {
14561 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14562
14563 fclose (fp1);
14564
14565 return (-1);
14566 }
14567
14568 if (S_ISDIR (tmp_stat.st_mode))
14569 {
14570 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14571
14572 fclose (fp1);
14573
14574 return (-1);
14575 }
14576
14577 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14578 {
14579 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14580
14581 fclose (fp1);
14582
14583 return (-1);
14584 }
14585
14586 if (stat (dictfile2, &tmp_stat) == -1)
14587 {
14588 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14589
14590 fclose (fp1);
14591 fclose (fp2);
14592
14593 return (-1);
14594 }
14595
14596 if (S_ISDIR (tmp_stat.st_mode))
14597 {
14598 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14599
14600 fclose (fp1);
14601 fclose (fp2);
14602
14603 return (-1);
14604 }
14605
14606 data.combs_cnt = 1;
14607
14608 data.quiet = 1;
14609
14610 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14611
14612 data.quiet = quiet;
14613
14614 if (words1_cnt == 0)
14615 {
14616 log_error ("ERROR: %s: empty file", dictfile1);
14617
14618 fclose (fp1);
14619 fclose (fp2);
14620
14621 return (-1);
14622 }
14623
14624 data.combs_cnt = 1;
14625
14626 data.quiet = 1;
14627
14628 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14629
14630 data.quiet = quiet;
14631
14632 if (words2_cnt == 0)
14633 {
14634 log_error ("ERROR: %s: empty file", dictfile2);
14635
14636 fclose (fp1);
14637 fclose (fp2);
14638
14639 return (-1);
14640 }
14641
14642 fclose (fp1);
14643 fclose (fp2);
14644
14645 data.dictfile = dictfile1;
14646 data.dictfile2 = dictfile2;
14647
14648 if (words1_cnt >= words2_cnt)
14649 {
14650 data.combs_cnt = words2_cnt;
14651 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14652
14653 dictfiles = &data.dictfile;
14654
14655 dictcnt = 1;
14656 }
14657 else
14658 {
14659 data.combs_cnt = words1_cnt;
14660 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14661
14662 dictfiles = &data.dictfile2;
14663
14664 dictcnt = 1;
14665
14666 // we also have to switch wordlist related rules!
14667
14668 char *tmpc = data.rule_buf_l;
14669
14670 data.rule_buf_l = data.rule_buf_r;
14671 data.rule_buf_r = tmpc;
14672
14673 int tmpi = data.rule_len_l;
14674
14675 data.rule_len_l = data.rule_len_r;
14676 data.rule_len_r = tmpi;
14677 }
14678 }
14679 else if (attack_mode == ATTACK_MODE_BF)
14680 {
14681 char *mask = NULL;
14682
14683 maskcnt = 0;
14684
14685 if (benchmark == 0)
14686 {
14687 mask = myargv[optind + 1];
14688
14689 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14690
14691 if ((optind + 2) <= myargc)
14692 {
14693 struct stat file_stat;
14694
14695 if (stat (mask, &file_stat) == -1)
14696 {
14697 maskcnt = 1;
14698
14699 masks[maskcnt - 1] = mystrdup (mask);
14700 }
14701 else
14702 {
14703 int wls_left = myargc - (optind + 1);
14704
14705 uint masks_avail = INCR_MASKS;
14706
14707 for (int i = 0; i < wls_left; i++)
14708 {
14709 if (i != 0)
14710 {
14711 mask = myargv[optind + 1 + i];
14712
14713 if (stat (mask, &file_stat) == -1)
14714 {
14715 log_error ("ERROR: %s: %s", mask, strerror (errno));
14716
14717 return (-1);
14718 }
14719 }
14720
14721 uint is_file = S_ISREG (file_stat.st_mode);
14722
14723 if (is_file == 1)
14724 {
14725 FILE *mask_fp;
14726
14727 if ((mask_fp = fopen (mask, "r")) == NULL)
14728 {
14729 log_error ("ERROR: %s: %s", mask, strerror (errno));
14730
14731 return (-1);
14732 }
14733
14734 char line_buf[BUFSIZ] = { 0 };
14735
14736 while (!feof (mask_fp))
14737 {
14738 memset (line_buf, 0, BUFSIZ);
14739
14740 int line_len = fgetl (mask_fp, line_buf);
14741
14742 if (line_len == 0) continue;
14743
14744 if (line_buf[0] == '#') continue;
14745
14746 if (masks_avail == maskcnt)
14747 {
14748 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14749
14750 masks_avail += INCR_MASKS;
14751 }
14752
14753 masks[maskcnt] = mystrdup (line_buf);
14754
14755 maskcnt++;
14756 }
14757
14758 fclose (mask_fp);
14759 }
14760 else
14761 {
14762 log_error ("ERROR: %s: unsupported file-type", mask);
14763
14764 return (-1);
14765 }
14766 }
14767
14768 mask_from_file = 1;
14769 }
14770 }
14771 else
14772 {
14773 custom_charset_1 = (char *) "?l?d?u";
14774 custom_charset_2 = (char *) "?l?d";
14775 custom_charset_3 = (char *) "?l?d*!$@_";
14776
14777 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14778 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14779 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14780
14781 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14782
14783 wordlist_mode = WL_MODE_MASK;
14784
14785 data.wordlist_mode = wordlist_mode;
14786
14787 increment = 1;
14788
14789 maskcnt = 1;
14790 }
14791 }
14792 else
14793 {
14794 /**
14795 * generate full masks and charsets
14796 */
14797
14798 masks = (char **) mymalloc (sizeof (char *));
14799
14800 switch (hash_mode)
14801 {
14802 case 1731: pw_min = 5;
14803 pw_max = 5;
14804 mask = mystrdup ("?b?b?b?b?b");
14805 break;
14806 case 12500: pw_min = 5;
14807 pw_max = 5;
14808 mask = mystrdup ("?b?b?b?b?b");
14809 break;
14810 default: pw_min = 7;
14811 pw_max = 7;
14812 mask = mystrdup ("?b?b?b?b?b?b?b");
14813 break;
14814 }
14815
14816 maskcnt = 1;
14817
14818 masks[maskcnt - 1] = mystrdup (mask);
14819
14820 wordlist_mode = WL_MODE_MASK;
14821
14822 data.wordlist_mode = wordlist_mode;
14823
14824 increment = 1;
14825 }
14826
14827 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14828
14829 if (increment)
14830 {
14831 if (increment_min > pw_min) pw_min = increment_min;
14832
14833 if (increment_max < pw_max) pw_max = increment_max;
14834 }
14835 }
14836 else if (attack_mode == ATTACK_MODE_HYBRID1)
14837 {
14838 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14839
14840 // display
14841
14842 char *mask = myargv[myargc - 1];
14843
14844 maskcnt = 0;
14845
14846 masks = (char **) mymalloc (1 * sizeof (char *));
14847
14848 // mod
14849
14850 struct stat file_stat;
14851
14852 if (stat (mask, &file_stat) == -1)
14853 {
14854 maskcnt = 1;
14855
14856 masks[maskcnt - 1] = mystrdup (mask);
14857 }
14858 else
14859 {
14860 uint is_file = S_ISREG (file_stat.st_mode);
14861
14862 if (is_file == 1)
14863 {
14864 FILE *mask_fp;
14865
14866 if ((mask_fp = fopen (mask, "r")) == NULL)
14867 {
14868 log_error ("ERROR: %s: %s", mask, strerror (errno));
14869
14870 return (-1);
14871 }
14872
14873 char line_buf[BUFSIZ] = { 0 };
14874
14875 uint masks_avail = 1;
14876
14877 while (!feof (mask_fp))
14878 {
14879 memset (line_buf, 0, BUFSIZ);
14880
14881 int line_len = fgetl (mask_fp, line_buf);
14882
14883 if (line_len == 0) continue;
14884
14885 if (line_buf[0] == '#') continue;
14886
14887 if (masks_avail == maskcnt)
14888 {
14889 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14890
14891 masks_avail += INCR_MASKS;
14892 }
14893
14894 masks[maskcnt] = mystrdup (line_buf);
14895
14896 maskcnt++;
14897 }
14898
14899 fclose (mask_fp);
14900
14901 mask_from_file = 1;
14902 }
14903 else
14904 {
14905 maskcnt = 1;
14906
14907 masks[maskcnt - 1] = mystrdup (mask);
14908 }
14909 }
14910
14911 // base
14912
14913 int wls_left = myargc - (optind + 2);
14914
14915 for (int i = 0; i < wls_left; i++)
14916 {
14917 char *filename = myargv[optind + 1 + i];
14918
14919 struct stat file_stat;
14920
14921 if (stat (filename, &file_stat) == -1)
14922 {
14923 log_error ("ERROR: %s: %s", filename, strerror (errno));
14924
14925 return (-1);
14926 }
14927
14928 uint is_dir = S_ISDIR (file_stat.st_mode);
14929
14930 if (is_dir == 0)
14931 {
14932 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14933
14934 dictcnt++;
14935
14936 dictfiles[dictcnt - 1] = filename;
14937 }
14938 else
14939 {
14940 // do not allow --keyspace w/ a directory
14941
14942 if (keyspace == 1)
14943 {
14944 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14945
14946 return (-1);
14947 }
14948
14949 char **dictionary_files = NULL;
14950
14951 dictionary_files = scan_directory (filename);
14952
14953 if (dictionary_files != NULL)
14954 {
14955 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14956
14957 for (int d = 0; dictionary_files[d] != NULL; d++)
14958 {
14959 char *l1_filename = dictionary_files[d];
14960
14961 struct stat l1_stat;
14962
14963 if (stat (l1_filename, &l1_stat) == -1)
14964 {
14965 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14966
14967 return (-1);
14968 }
14969
14970 if (S_ISREG (l1_stat.st_mode))
14971 {
14972 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14973
14974 dictcnt++;
14975
14976 dictfiles[dictcnt - 1] = strdup (l1_filename);
14977 }
14978 }
14979 }
14980
14981 local_free (dictionary_files);
14982 }
14983 }
14984
14985 if (dictcnt < 1)
14986 {
14987 log_error ("ERROR: No usable dictionary file found.");
14988
14989 return (-1);
14990 }
14991
14992 if (increment)
14993 {
14994 maskcnt = 0;
14995
14996 uint mask_min = increment_min; // we can't reject smaller masks here
14997 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14998
14999 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15000 {
15001 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15002
15003 if (cur_mask == NULL) break;
15004
15005 masks[maskcnt] = cur_mask;
15006
15007 maskcnt++;
15008
15009 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15010 }
15011 }
15012 }
15013 else if (attack_mode == ATTACK_MODE_HYBRID2)
15014 {
15015 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15016
15017 // display
15018
15019 char *mask = myargv[optind + 1 + 0];
15020
15021 maskcnt = 0;
15022
15023 masks = (char **) mymalloc (1 * sizeof (char *));
15024
15025 // mod
15026
15027 struct stat file_stat;
15028
15029 if (stat (mask, &file_stat) == -1)
15030 {
15031 maskcnt = 1;
15032
15033 masks[maskcnt - 1] = mystrdup (mask);
15034 }
15035 else
15036 {
15037 uint is_file = S_ISREG (file_stat.st_mode);
15038
15039 if (is_file == 1)
15040 {
15041 FILE *mask_fp;
15042
15043 if ((mask_fp = fopen (mask, "r")) == NULL)
15044 {
15045 log_error ("ERROR: %s: %s", mask, strerror (errno));
15046
15047 return (-1);
15048 }
15049
15050 char line_buf[BUFSIZ] = { 0 };
15051
15052 uint masks_avail = 1;
15053
15054 while (!feof (mask_fp))
15055 {
15056 memset (line_buf, 0, BUFSIZ);
15057
15058 int line_len = fgetl (mask_fp, line_buf);
15059
15060 if (line_len == 0) continue;
15061
15062 if (line_buf[0] == '#') continue;
15063
15064 if (masks_avail == maskcnt)
15065 {
15066 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15067
15068 masks_avail += INCR_MASKS;
15069 }
15070
15071 masks[maskcnt] = mystrdup (line_buf);
15072
15073 maskcnt++;
15074 }
15075
15076 fclose (mask_fp);
15077
15078 mask_from_file = 1;
15079 }
15080 else
15081 {
15082 maskcnt = 1;
15083
15084 masks[maskcnt - 1] = mystrdup (mask);
15085 }
15086 }
15087
15088 // base
15089
15090 int wls_left = myargc - (optind + 2);
15091
15092 for (int i = 0; i < wls_left; i++)
15093 {
15094 char *filename = myargv[optind + 2 + i];
15095
15096 struct stat file_stat;
15097
15098 if (stat (filename, &file_stat) == -1)
15099 {
15100 log_error ("ERROR: %s: %s", filename, strerror (errno));
15101
15102 return (-1);
15103 }
15104
15105 uint is_dir = S_ISDIR (file_stat.st_mode);
15106
15107 if (is_dir == 0)
15108 {
15109 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15110
15111 dictcnt++;
15112
15113 dictfiles[dictcnt - 1] = filename;
15114 }
15115 else
15116 {
15117 // do not allow --keyspace w/ a directory
15118
15119 if (keyspace == 1)
15120 {
15121 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15122
15123 return (-1);
15124 }
15125
15126 char **dictionary_files = NULL;
15127
15128 dictionary_files = scan_directory (filename);
15129
15130 if (dictionary_files != NULL)
15131 {
15132 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15133
15134 for (int d = 0; dictionary_files[d] != NULL; d++)
15135 {
15136 char *l1_filename = dictionary_files[d];
15137
15138 struct stat l1_stat;
15139
15140 if (stat (l1_filename, &l1_stat) == -1)
15141 {
15142 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15143
15144 return (-1);
15145 }
15146
15147 if (S_ISREG (l1_stat.st_mode))
15148 {
15149 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15150
15151 dictcnt++;
15152
15153 dictfiles[dictcnt - 1] = strdup (l1_filename);
15154 }
15155 }
15156 }
15157
15158 local_free (dictionary_files);
15159 }
15160 }
15161
15162 if (dictcnt < 1)
15163 {
15164 log_error ("ERROR: No usable dictionary file found.");
15165
15166 return (-1);
15167 }
15168
15169 if (increment)
15170 {
15171 maskcnt = 0;
15172
15173 uint mask_min = increment_min; // we can't reject smaller masks here
15174 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15175
15176 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15177 {
15178 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15179
15180 if (cur_mask == NULL) break;
15181
15182 masks[maskcnt] = cur_mask;
15183
15184 maskcnt++;
15185
15186 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15187 }
15188 }
15189 }
15190
15191 data.pw_min = pw_min;
15192 data.pw_max = pw_max;
15193
15194 /**
15195 * weak hash check
15196 */
15197
15198 if (weak_hash_threshold >= salts_cnt)
15199 {
15200 hc_device_param_t *device_param = NULL;
15201
15202 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15203 {
15204 device_param = &data.devices_param[device_id];
15205
15206 if (device_param->skipped) continue;
15207
15208 break;
15209 }
15210
15211 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15212
15213 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15214 {
15215 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15216 }
15217 }
15218
15219 // Display hack, guarantee that there is at least one \r before real start
15220
15221 if (data.quiet == 0) log_info_nn ("");
15222
15223 /**
15224 * status and monitor threads
15225 */
15226
15227 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15228
15229 hc_thread_t i_thread = 0;
15230
15231 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15232 {
15233 hc_thread_create (i_thread, thread_keypress, &benchmark);
15234 }
15235
15236 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15237
15238 uint ni_threads_cnt = 0;
15239
15240 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15241
15242 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15243
15244 ni_threads_cnt++;
15245
15246 /**
15247 * Outfile remove
15248 */
15249
15250 if (keyspace == 0)
15251 {
15252 if (outfile_check_timer != 0)
15253 {
15254 if (data.outfile_check_directory != NULL)
15255 {
15256 if ((hash_mode != 5200) &&
15257 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15258 (hash_mode != 9000))
15259 {
15260 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15261
15262 ni_threads_cnt++;
15263 }
15264 else
15265 {
15266 outfile_check_timer = 0;
15267 }
15268 }
15269 else
15270 {
15271 outfile_check_timer = 0;
15272 }
15273 }
15274 }
15275
15276 /**
15277 * Inform the user if we got some hashes remove because of the pot file remove feature
15278 */
15279
15280 if (data.quiet == 0)
15281 {
15282 if (potfile_remove_cracks > 0)
15283 {
15284 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15285 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15286 }
15287 }
15288
15289 data.outfile_check_timer = outfile_check_timer;
15290
15291 /**
15292 * main loop
15293 */
15294
15295 char **induction_dictionaries = NULL;
15296
15297 int induction_dictionaries_cnt = 0;
15298
15299 hcstat_table_t *root_table_buf = NULL;
15300 hcstat_table_t *markov_table_buf = NULL;
15301
15302 uint initial_restore_done = 0;
15303
15304 data.maskcnt = maskcnt;
15305
15306 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15307 {
15308 if (data.devices_status == STATUS_CRACKED) break;
15309
15310 data.devices_status = STATUS_INIT;
15311
15312 if (maskpos > rd->maskpos)
15313 {
15314 rd->dictpos = 0;
15315 }
15316
15317 rd->maskpos = maskpos;
15318 data.maskpos = maskpos;
15319
15320 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15321 {
15322 char *mask = masks[maskpos];
15323
15324 if (mask_from_file == 1)
15325 {
15326 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15327
15328 char *str_ptr;
15329 uint str_pos;
15330
15331 uint mask_offset = 0;
15332
15333 uint separator_cnt;
15334
15335 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15336 {
15337 str_ptr = strstr (mask + mask_offset, ",");
15338
15339 if (str_ptr == NULL) break;
15340
15341 str_pos = str_ptr - mask;
15342
15343 // escaped separator, i.e. "\,"
15344
15345 if (str_pos > 0)
15346 {
15347 if (mask[str_pos - 1] == '\\')
15348 {
15349 separator_cnt --;
15350
15351 mask_offset = str_pos + 1;
15352
15353 continue;
15354 }
15355 }
15356
15357 // reset the offset
15358
15359 mask_offset = 0;
15360
15361 mask[str_pos] = '\0';
15362
15363 switch (separator_cnt)
15364 {
15365 case 0:
15366 mp_reset_usr (mp_usr, 0);
15367
15368 custom_charset_1 = mask;
15369 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15370 break;
15371
15372 case 1:
15373 mp_reset_usr (mp_usr, 1);
15374
15375 custom_charset_2 = mask;
15376 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15377 break;
15378
15379 case 2:
15380 mp_reset_usr (mp_usr, 2);
15381
15382 custom_charset_3 = mask;
15383 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15384 break;
15385
15386 case 3:
15387 mp_reset_usr (mp_usr, 3);
15388
15389 custom_charset_4 = mask;
15390 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15391 break;
15392 }
15393
15394 mask = mask + str_pos + 1;
15395 }
15396 }
15397
15398 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15399 {
15400 if (maskpos > 0)
15401 {
15402 local_free (css_buf);
15403 local_free (data.root_css_buf);
15404 local_free (data.markov_css_buf);
15405
15406 local_free (masks[maskpos - 1]);
15407 }
15408
15409 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15410
15411 data.mask = mask;
15412 data.css_cnt = css_cnt;
15413 data.css_buf = css_buf;
15414
15415 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15416
15417 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15418
15419 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15420 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15421
15422 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15423
15424 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15425
15426 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15427 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15428
15429 data.root_css_buf = root_css_buf;
15430 data.markov_css_buf = markov_css_buf;
15431
15432 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15433
15434 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15435
15436 local_free (root_table_buf);
15437 local_free (markov_table_buf);
15438
15439 // args
15440
15441 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15442 {
15443 hc_device_param_t *device_param = &data.devices_param[device_id];
15444
15445 if (device_param->skipped) continue;
15446
15447 device_param->kernel_params_mp[0] = &device_param->d_combs;
15448 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15449 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15450
15451 device_param->kernel_params_mp_buf64[3] = 0;
15452 device_param->kernel_params_mp_buf32[4] = css_cnt;
15453 device_param->kernel_params_mp_buf32[5] = 0;
15454 device_param->kernel_params_mp_buf32[6] = 0;
15455 device_param->kernel_params_mp_buf32[7] = 0;
15456
15457 if (attack_mode == ATTACK_MODE_HYBRID1)
15458 {
15459 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15460 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15461 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15462 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15463 }
15464 else if (attack_mode == ATTACK_MODE_HYBRID2)
15465 {
15466 device_param->kernel_params_mp_buf32[5] = 0;
15467 device_param->kernel_params_mp_buf32[6] = 0;
15468 device_param->kernel_params_mp_buf32[7] = 0;
15469 }
15470
15471 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]);
15472 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]);
15473 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]);
15474
15475 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);
15476 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);
15477 }
15478 }
15479 else if (attack_mode == ATTACK_MODE_BF)
15480 {
15481 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15482
15483 if (increment)
15484 {
15485 for (uint i = 0; i < dictcnt; i++)
15486 {
15487 local_free (dictfiles[i]);
15488 }
15489
15490 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15491 {
15492 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15493
15494 if (l1_filename == NULL) break;
15495
15496 dictcnt++;
15497
15498 dictfiles[dictcnt - 1] = l1_filename;
15499 }
15500 }
15501 else
15502 {
15503 dictcnt++;
15504
15505 dictfiles[dictcnt - 1] = mask;
15506 }
15507
15508 if (dictcnt == 0)
15509 {
15510 log_error ("ERROR: Mask is too small");
15511
15512 return (-1);
15513 }
15514 }
15515 }
15516
15517 free (induction_dictionaries);
15518
15519 // induction_dictionaries_cnt = 0; // implied
15520
15521 if (attack_mode != ATTACK_MODE_BF)
15522 {
15523 if (keyspace == 0)
15524 {
15525 induction_dictionaries = scan_directory (induction_directory);
15526
15527 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15528 }
15529 }
15530
15531 if (induction_dictionaries_cnt)
15532 {
15533 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15534 }
15535
15536 /**
15537 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15538 */
15539 if (keyspace == 1)
15540 {
15541 if ((maskcnt > 1) || (dictcnt > 1))
15542 {
15543 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15544
15545 return (-1);
15546 }
15547 }
15548
15549 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15550 {
15551 char *subid = logfile_generate_subid ();
15552
15553 data.subid = subid;
15554
15555 logfile_sub_msg ("START");
15556
15557 data.devices_status = STATUS_INIT;
15558
15559 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15560 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15561 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15562
15563 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15564
15565 data.cpt_pos = 0;
15566
15567 data.cpt_start = time (NULL);
15568
15569 data.cpt_total = 0;
15570
15571 if (data.restore == 0)
15572 {
15573 rd->words_cur = skip;
15574
15575 skip = 0;
15576
15577 data.skip = 0;
15578 }
15579
15580 data.ms_paused = 0;
15581
15582 data.words_cur = rd->words_cur;
15583
15584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15585 {
15586 hc_device_param_t *device_param = &data.devices_param[device_id];
15587
15588 if (device_param->skipped) continue;
15589
15590 device_param->speed_pos = 0;
15591
15592 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15593 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15594 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15595
15596 device_param->kernel_power = device_param->kernel_power_user;
15597 device_param->kernel_blocks = device_param->kernel_blocks_user;
15598
15599 device_param->outerloop_pos = 0;
15600 device_param->outerloop_left = 0;
15601 device_param->innerloop_pos = 0;
15602 device_param->innerloop_left = 0;
15603
15604 // some more resets:
15605
15606 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15607
15608 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15609
15610 device_param->pw_cnt = 0;
15611 device_param->pws_cnt = 0;
15612
15613 device_param->words_off = 0;
15614 device_param->words_done = 0;
15615 }
15616
15617 data.kernel_blocks_div = 0;
15618
15619 // figure out some workload
15620
15621 if (attack_mode == ATTACK_MODE_STRAIGHT)
15622 {
15623 if (data.wordlist_mode == WL_MODE_FILE)
15624 {
15625 char *dictfile = NULL;
15626
15627 if (induction_dictionaries_cnt)
15628 {
15629 dictfile = induction_dictionaries[0];
15630 }
15631 else
15632 {
15633 dictfile = dictfiles[dictpos];
15634 }
15635
15636 data.dictfile = dictfile;
15637
15638 logfile_sub_string (dictfile);
15639
15640 for (uint i = 0; i < rp_files_cnt; i++)
15641 {
15642 logfile_sub_var_string ("rulefile", rp_files[i]);
15643 }
15644
15645 FILE *fd2 = fopen (dictfile, "rb");
15646
15647 if (fd2 == NULL)
15648 {
15649 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15650
15651 return (-1);
15652 }
15653
15654 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15655
15656 fclose (fd2);
15657
15658 if (data.words_cnt == 0)
15659 {
15660 if (data.devices_status == STATUS_CRACKED) break;
15661 if (data.devices_status == STATUS_ABORTED) break;
15662
15663 dictpos++;
15664
15665 continue;
15666 }
15667 }
15668 }
15669 else if (attack_mode == ATTACK_MODE_COMBI)
15670 {
15671 char *dictfile = data.dictfile;
15672 char *dictfile2 = data.dictfile2;
15673
15674 logfile_sub_string (dictfile);
15675 logfile_sub_string (dictfile2);
15676
15677 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15678 {
15679 FILE *fd2 = fopen (dictfile, "rb");
15680
15681 if (fd2 == NULL)
15682 {
15683 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15684
15685 return (-1);
15686 }
15687
15688 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15689
15690 fclose (fd2);
15691 }
15692 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15693 {
15694 FILE *fd2 = fopen (dictfile2, "rb");
15695
15696 if (fd2 == NULL)
15697 {
15698 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15699
15700 return (-1);
15701 }
15702
15703 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15704
15705 fclose (fd2);
15706 }
15707
15708 if (data.words_cnt == 0)
15709 {
15710 if (data.devices_status == STATUS_CRACKED) break;
15711 if (data.devices_status == STATUS_ABORTED) break;
15712
15713 dictpos++;
15714
15715 continue;
15716 }
15717 }
15718 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15719 {
15720 char *dictfile = NULL;
15721
15722 if (induction_dictionaries_cnt)
15723 {
15724 dictfile = induction_dictionaries[0];
15725 }
15726 else
15727 {
15728 dictfile = dictfiles[dictpos];
15729 }
15730
15731 data.dictfile = dictfile;
15732
15733 char *mask = data.mask;
15734
15735 logfile_sub_string (dictfile);
15736 logfile_sub_string (mask);
15737
15738 FILE *fd2 = fopen (dictfile, "rb");
15739
15740 if (fd2 == NULL)
15741 {
15742 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15743
15744 return (-1);
15745 }
15746
15747 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15748
15749 fclose (fd2);
15750
15751 if (data.words_cnt == 0)
15752 {
15753 if (data.devices_status == STATUS_CRACKED) break;
15754 if (data.devices_status == STATUS_ABORTED) break;
15755
15756 dictpos++;
15757
15758 continue;
15759 }
15760 }
15761 else if (attack_mode == ATTACK_MODE_BF)
15762 {
15763 local_free (css_buf);
15764 local_free (data.root_css_buf);
15765 local_free (data.markov_css_buf);
15766
15767 char *mask = dictfiles[dictpos];
15768
15769 logfile_sub_string (mask);
15770
15771 // base
15772
15773 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15774
15775 if (opts_type & OPTS_TYPE_PT_UNICODE)
15776 {
15777 uint css_cnt_unicode = css_cnt * 2;
15778
15779 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15780
15781 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15782 {
15783 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15784
15785 css_buf_unicode[j + 1].cs_buf[0] = 0;
15786 css_buf_unicode[j + 1].cs_len = 1;
15787 }
15788
15789 free (css_buf);
15790
15791 css_buf = css_buf_unicode;
15792 css_cnt = css_cnt_unicode;
15793 }
15794
15795 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15796
15797 uint mask_min = pw_min;
15798 uint mask_max = pw_max;
15799
15800 if (opts_type & OPTS_TYPE_PT_UNICODE)
15801 {
15802 mask_min *= 2;
15803 mask_max *= 2;
15804 }
15805
15806 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15807 {
15808 if (css_cnt < mask_min)
15809 {
15810 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15811 }
15812
15813 if (css_cnt > mask_max)
15814 {
15815 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15816 }
15817
15818 // skip to next mask
15819
15820 dictpos++;
15821
15822 rd->dictpos = dictpos;
15823
15824 logfile_sub_msg ("STOP");
15825
15826 continue;
15827 }
15828
15829 uint save_css_cnt = css_cnt;
15830
15831 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15832 {
15833 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15834 {
15835 uint salt_len = (uint) data.salts_buf[0].salt_len;
15836 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15837
15838 uint css_cnt_salt = css_cnt + salt_len;
15839
15840 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15841
15842 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15843
15844 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15845 {
15846 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15847 css_buf_salt[j].cs_len = 1;
15848 }
15849
15850 free (css_buf);
15851
15852 css_buf = css_buf_salt;
15853 css_cnt = css_cnt_salt;
15854 }
15855 }
15856
15857 data.mask = mask;
15858 data.css_cnt = css_cnt;
15859 data.css_buf = css_buf;
15860
15861 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15862
15863 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15864
15865 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15866
15867 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15868 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15869
15870 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15871
15872 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15873
15874 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15875 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15876
15877 data.root_css_buf = root_css_buf;
15878 data.markov_css_buf = markov_css_buf;
15879
15880 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15881
15882 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15883
15884 local_free (root_table_buf);
15885 local_free (markov_table_buf);
15886
15887 // copy + args
15888
15889 uint css_cnt_l = css_cnt;
15890 uint css_cnt_r;
15891
15892 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15893 {
15894 if (save_css_cnt < 6)
15895 {
15896 css_cnt_r = 1;
15897 }
15898 else if (save_css_cnt == 6)
15899 {
15900 css_cnt_r = 2;
15901 }
15902 else
15903 {
15904 if (opts_type & OPTS_TYPE_PT_UNICODE)
15905 {
15906 if (save_css_cnt == 8 || save_css_cnt == 10)
15907 {
15908 css_cnt_r = 2;
15909 }
15910 else
15911 {
15912 css_cnt_r = 4;
15913 }
15914 }
15915 else
15916 {
15917 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15918 {
15919 css_cnt_r = 3;
15920 }
15921 else
15922 {
15923 css_cnt_r = 4;
15924 }
15925 }
15926 }
15927 }
15928 else
15929 {
15930 css_cnt_r = 1;
15931
15932 /* unfinished code?
15933 int sum = css_buf[css_cnt_r - 1].cs_len;
15934
15935 for (uint i = 1; i < 4 && i < css_cnt; i++)
15936 {
15937 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15938
15939 css_cnt_r++;
15940
15941 sum *= css_buf[css_cnt_r - 1].cs_len;
15942 }
15943 */
15944 }
15945
15946 css_cnt_l -= css_cnt_r;
15947
15948 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15949
15950 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15951 {
15952 hc_device_param_t *device_param = &data.devices_param[device_id];
15953
15954 if (device_param->skipped) continue;
15955
15956 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15957 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15958 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15959
15960 device_param->kernel_params_mp_l_buf64[3] = 0;
15961 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15962 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15963 device_param->kernel_params_mp_l_buf32[6] = 0;
15964 device_param->kernel_params_mp_l_buf32[7] = 0;
15965 device_param->kernel_params_mp_l_buf32[8] = 0;
15966
15967 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15968 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15969 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15970 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15971
15972 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15973 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15974 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15975
15976 device_param->kernel_params_mp_r_buf64[3] = 0;
15977 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15978 device_param->kernel_params_mp_r_buf32[5] = 0;
15979 device_param->kernel_params_mp_r_buf32[6] = 0;
15980 device_param->kernel_params_mp_r_buf32[7] = 0;
15981
15982 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]);
15983 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]);
15984 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]);
15985
15986 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]);
15987 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]);
15988 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]);
15989
15990 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);
15991 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);
15992 }
15993 }
15994
15995 u64 words_base = data.words_cnt;
15996
15997 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15998 {
15999 if (data.kernel_rules_cnt)
16000 {
16001 words_base /= data.kernel_rules_cnt;
16002 }
16003 }
16004 else if (data.attack_kern == ATTACK_KERN_COMBI)
16005 {
16006 if (data.combs_cnt)
16007 {
16008 words_base /= data.combs_cnt;
16009 }
16010 }
16011 else if (data.attack_kern == ATTACK_KERN_BF)
16012 {
16013 if (data.bfs_cnt)
16014 {
16015 words_base /= data.bfs_cnt;
16016 }
16017 }
16018
16019 data.words_base = words_base;
16020
16021 if (keyspace == 1)
16022 {
16023 log_info ("%llu", (unsigned long long int) words_base);
16024
16025 return (0);
16026 }
16027
16028 if (data.words_cur > data.words_base)
16029 {
16030 log_error ("ERROR: restore value greater keyspace");
16031
16032 return (-1);
16033 }
16034
16035 if (data.words_cur)
16036 {
16037 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16038 {
16039 for (uint i = 0; i < data.salts_cnt; i++)
16040 {
16041 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16042 }
16043 }
16044 else if (data.attack_kern == ATTACK_KERN_COMBI)
16045 {
16046 for (uint i = 0; i < data.salts_cnt; i++)
16047 {
16048 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16049 }
16050 }
16051 else if (data.attack_kern == ATTACK_KERN_BF)
16052 {
16053 for (uint i = 0; i < data.salts_cnt; i++)
16054 {
16055 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16056 }
16057 }
16058 }
16059
16060 /*
16061 * Inform user about possible slow speeds
16062 */
16063
16064 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16065 {
16066 if (data.words_base < kernel_blocks_all)
16067 {
16068 if (quiet == 0)
16069 {
16070 log_info ("");
16071 log_info ("ATTENTION!");
16072 log_info (" The wordlist or mask you are using is too small.");
16073 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16074 log_info (" The cracking speed will drop.");
16075 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16076 log_info ("");
16077 }
16078 }
16079 }
16080
16081 /*
16082 * Update loopback file
16083 */
16084
16085 if (loopback == 1)
16086 {
16087 time_t now;
16088
16089 time (&now);
16090
16091 uint random_num = get_random_num (0, 9999);
16092
16093 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16094
16095 data.loopback_file = loopback_file;
16096 }
16097
16098 /*
16099 * Update dictionary statistic
16100 */
16101
16102 if (keyspace == 0)
16103 {
16104 dictstat_fp = fopen (dictstat, "wb");
16105
16106 if (dictstat_fp)
16107 {
16108 lock_file (dictstat_fp);
16109
16110 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16111
16112 fclose (dictstat_fp);
16113 }
16114 }
16115
16116 data.devices_status = STATUS_RUNNING;
16117
16118 if (initial_restore_done == 0)
16119 {
16120 if (data.restore_disable == 0) cycle_restore ();
16121
16122 initial_restore_done = 1;
16123 }
16124
16125 hc_timer_set (&data.timer_running);
16126
16127 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16128 {
16129 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16130 {
16131 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16132 if (quiet == 0) fflush (stdout);
16133 }
16134 }
16135 else if (wordlist_mode == WL_MODE_STDIN)
16136 {
16137 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16138 if (data.quiet == 0) log_info ("");
16139 }
16140
16141 time_t runtime_start;
16142
16143 time (&runtime_start);
16144
16145 data.runtime_start = runtime_start;
16146
16147 /**
16148 * create cracker threads
16149 */
16150
16151 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16152
16153 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16154 {
16155 hc_device_param_t *device_param = &devices_param[device_id];
16156
16157 if (wordlist_mode == WL_MODE_STDIN)
16158 {
16159 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16160 }
16161 else
16162 {
16163 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16164 }
16165 }
16166
16167 // wait for crack threads to exit
16168
16169 hc_thread_wait (data.devices_cnt, c_threads);
16170
16171 local_free (c_threads);
16172
16173 data.restore = 0;
16174
16175 // finalize task
16176
16177 logfile_sub_var_uint ("status-after-work", data.devices_status);
16178
16179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16180
16181 if (data.devices_status == STATUS_CRACKED) break;
16182 if (data.devices_status == STATUS_ABORTED) break;
16183
16184 if (data.devices_status == STATUS_BYPASS)
16185 {
16186 data.devices_status = STATUS_RUNNING;
16187 }
16188
16189 if (induction_dictionaries_cnt)
16190 {
16191 unlink (induction_dictionaries[0]);
16192 }
16193
16194 free (induction_dictionaries);
16195
16196 if (attack_mode != ATTACK_MODE_BF)
16197 {
16198 induction_dictionaries = scan_directory (induction_directory);
16199
16200 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16201 }
16202
16203 if (benchmark == 0)
16204 {
16205 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16206 {
16207 if (quiet == 0) clear_prompt ();
16208
16209 if (quiet == 0) log_info ("");
16210
16211 if (status == 1)
16212 {
16213 status_display ();
16214 }
16215 else
16216 {
16217 if (quiet == 0) status_display ();
16218 }
16219
16220 if (quiet == 0) log_info ("");
16221 }
16222 }
16223
16224 if (attack_mode == ATTACK_MODE_BF)
16225 {
16226 dictpos++;
16227
16228 rd->dictpos = dictpos;
16229 }
16230 else
16231 {
16232 if (induction_dictionaries_cnt)
16233 {
16234 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16235 }
16236 else
16237 {
16238 dictpos++;
16239
16240 rd->dictpos = dictpos;
16241 }
16242 }
16243
16244 time_t runtime_stop;
16245
16246 time (&runtime_stop);
16247
16248 data.runtime_stop = runtime_stop;
16249
16250 logfile_sub_uint (runtime_start);
16251 logfile_sub_uint (runtime_stop);
16252
16253 logfile_sub_msg ("STOP");
16254
16255 global_free (subid);
16256 }
16257
16258 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16259
16260 if (data.devices_status == STATUS_CRACKED) break;
16261 if (data.devices_status == STATUS_ABORTED) break;
16262 if (data.devices_status == STATUS_QUIT) break;
16263
16264 if (data.devices_status == STATUS_BYPASS)
16265 {
16266 data.devices_status = STATUS_RUNNING;
16267 }
16268 }
16269
16270 // 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
16271
16272 if (attack_mode == ATTACK_MODE_STRAIGHT)
16273 {
16274 if (data.wordlist_mode == WL_MODE_FILE)
16275 {
16276 if (data.dictfile == NULL)
16277 {
16278 if (dictfiles != NULL)
16279 {
16280 data.dictfile = dictfiles[0];
16281
16282 hc_timer_set (&data.timer_running);
16283 }
16284 }
16285 }
16286 }
16287 // NOTE: combi is okay because it is already set beforehand
16288 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16289 {
16290 if (data.dictfile == NULL)
16291 {
16292 if (dictfiles != NULL)
16293 {
16294 hc_timer_set (&data.timer_running);
16295
16296 data.dictfile = dictfiles[0];
16297 }
16298 }
16299 }
16300 else if (attack_mode == ATTACK_MODE_BF)
16301 {
16302 if (data.mask == NULL)
16303 {
16304 hc_timer_set (&data.timer_running);
16305
16306 data.mask = masks[0];
16307 }
16308 }
16309
16310 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16311 {
16312 data.devices_status = STATUS_EXHAUSTED;
16313 }
16314
16315 // if cracked / aborted remove last induction dictionary
16316
16317 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16318 {
16319 struct stat induct_stat;
16320
16321 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16322 {
16323 unlink (induction_dictionaries[file_pos]);
16324 }
16325 }
16326
16327 // wait for non-interactive threads
16328
16329 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16330 {
16331 hc_thread_wait (1, &ni_threads[thread_idx]);
16332 }
16333
16334 local_free (ni_threads);
16335
16336 // wait for interactive threads
16337
16338 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16339 {
16340 hc_thread_wait (1, &i_thread);
16341 }
16342
16343 // we dont need restore file anymore
16344 if (data.restore_disable == 0)
16345 {
16346 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16347 {
16348 unlink (eff_restore_file);
16349 unlink (new_restore_file);
16350 }
16351 else
16352 {
16353 cycle_restore ();
16354 }
16355 }
16356
16357 // finally save left hashes
16358
16359 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16360 {
16361 save_hash ();
16362 }
16363
16364 /**
16365 * Clean up
16366 */
16367
16368 if (benchmark == 1)
16369 {
16370 status_benchmark ();
16371
16372 log_info ("");
16373 }
16374 else
16375 {
16376 if (quiet == 0) clear_prompt ();
16377
16378 if (quiet == 0) log_info ("");
16379
16380 if (status == 1)
16381 {
16382 status_display ();
16383 }
16384 else
16385 {
16386 if (quiet == 0) status_display ();
16387 }
16388
16389 if (quiet == 0) log_info ("");
16390 }
16391
16392 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16393 {
16394 hc_device_param_t *device_param = &data.devices_param[device_id];
16395
16396 if (device_param->skipped) continue;
16397
16398 local_free (device_param->result);
16399
16400 local_free (device_param->pw_caches);
16401
16402 local_free (device_param->combs_buf);
16403
16404 local_free (device_param->hooks_buf);
16405
16406 local_free (device_param->device_name);
16407
16408 local_free (device_param->device_name_chksum);
16409
16410 local_free (device_param->device_version);
16411
16412 local_free (device_param->driver_version);
16413
16414 if (device_param->pws_buf) myfree (device_param->pws_buf);
16415 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16416 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16417 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16418 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16419 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16420 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16421 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16422 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16423 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16424 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16425 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16426 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16427 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16428 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16429 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16430 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16431 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16432 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16433 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16434 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16435 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16436 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16437 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16438 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16439 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16440 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16441 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16442 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16443
16444 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16445 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16446 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16447 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16448 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16449 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16450 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16451 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16452 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16453 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16454 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16455
16456 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16457 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16458 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16459
16460 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16461 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16462 }
16463
16464 // reset default fan speed
16465
16466 #ifdef HAVE_HWMON
16467 if (gpu_temp_disable == 0)
16468 {
16469 #ifdef HAVE_ADL
16470 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16471 {
16472 hc_thread_mutex_lock (mux_adl);
16473
16474 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16475 {
16476 hc_device_param_t *device_param = &data.devices_param[device_id];
16477
16478 if (device_param->skipped) continue;
16479
16480 if (data.hm_device[device_id].fan_supported == 1)
16481 {
16482 int fanspeed = temp_retain_fanspeed_value[device_id];
16483
16484 if (fanspeed == -1) continue;
16485
16486 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16487
16488 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16489 }
16490 }
16491
16492 hc_thread_mutex_unlock (mux_adl);
16493 }
16494 #endif // HAVE_ADL
16495 }
16496
16497 #ifdef HAVE_ADL
16498 // reset power tuning
16499
16500 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16501 {
16502 hc_thread_mutex_lock (mux_adl);
16503
16504 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16505 {
16506 hc_device_param_t *device_param = &data.devices_param[device_id];
16507
16508 if (device_param->skipped) continue;
16509
16510 if (data.hm_device[device_id].od_version == 6)
16511 {
16512 // check powertune capabilities first, if not available then skip device
16513
16514 int powertune_supported = 0;
16515
16516 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16517 {
16518 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16519
16520 return (-1);
16521 }
16522
16523 if (powertune_supported != 0)
16524 {
16525 // powercontrol settings
16526
16527 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)
16528 {
16529 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16530
16531 return (-1);
16532 }
16533
16534 // clocks
16535
16536 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16537
16538 performance_state->iNumberOfPerformanceLevels = 2;
16539
16540 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16541 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16542 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16543 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16544
16545 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)
16546 {
16547 log_info ("ERROR: Failed to restore ADL performance state");
16548
16549 return (-1);
16550 }
16551
16552 local_free (performance_state);
16553 }
16554 }
16555 }
16556
16557 hc_thread_mutex_unlock (mux_adl);
16558 }
16559 #endif // HAVE_ADL
16560
16561 if (gpu_temp_disable == 0)
16562 {
16563 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16564 if (data.hm_nv)
16565 {
16566 #if defined(LINUX) && defined(HAVE_NVML)
16567
16568 hm_NVML_nvmlShutdown (data.hm_nv);
16569
16570 nvml_close (data.hm_nv);
16571
16572 #elif defined(WIN) && (HAVE_NVAPI)
16573
16574 hm_NvAPI_Unload (data.hm_nv);
16575
16576 nvapi_close (data.hm_nv);
16577
16578 #endif
16579
16580 data.hm_nv = NULL;
16581 }
16582 #endif
16583
16584 #ifdef HAVE_ADL
16585 if (data.hm_amd)
16586 {
16587 hm_ADL_Main_Control_Destroy (data.hm_amd);
16588
16589 adl_close (data.hm_amd);
16590 data.hm_amd = NULL;
16591 }
16592 #endif
16593 }
16594 #endif // HAVE_HWMON
16595
16596 // free memory
16597
16598 local_free (masks);
16599
16600 local_free (dictstat_base);
16601
16602 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16603 {
16604 pot_t *pot_ptr = &pot[pot_pos];
16605
16606 hash_t *hash = &pot_ptr->hash;
16607
16608 local_free (hash->digest);
16609
16610 if (isSalted)
16611 {
16612 local_free (hash->salt);
16613 }
16614 }
16615
16616 local_free (pot);
16617
16618 local_free (all_kernel_rules_cnt);
16619 local_free (all_kernel_rules_buf);
16620
16621 local_free (wl_data->buf);
16622 local_free (wl_data);
16623
16624 local_free (bitmap_s1_a);
16625 local_free (bitmap_s1_b);
16626 local_free (bitmap_s1_c);
16627 local_free (bitmap_s1_d);
16628 local_free (bitmap_s2_a);
16629 local_free (bitmap_s2_b);
16630 local_free (bitmap_s2_c);
16631 local_free (bitmap_s2_d);
16632
16633 #ifdef HAVE_HWMON
16634 local_free (temp_retain_fanspeed_value);
16635 #ifdef HAVE_ADL
16636 local_free (od_clock_mem_status);
16637 local_free (od_power_control_status);
16638 #endif // ADL
16639 #endif
16640
16641 global_free (devices_param);
16642
16643 global_free (kernel_rules_buf);
16644
16645 global_free (root_css_buf);
16646 global_free (markov_css_buf);
16647
16648 global_free (digests_buf);
16649 global_free (digests_shown);
16650 global_free (digests_shown_tmp);
16651
16652 global_free (salts_buf);
16653 global_free (salts_shown);
16654
16655 global_free (esalts_buf);
16656
16657 global_free (words_progress_done);
16658 global_free (words_progress_rejected);
16659 global_free (words_progress_restored);
16660
16661 if (pot_fp) fclose (pot_fp);
16662
16663 if (data.devices_status == STATUS_QUIT) break;
16664 }
16665
16666 // destroy others mutex
16667
16668 hc_thread_mutex_delete (mux_dispatcher);
16669 hc_thread_mutex_delete (mux_counter);
16670 hc_thread_mutex_delete (mux_display);
16671 hc_thread_mutex_delete (mux_adl);
16672
16673 // free memory
16674
16675 local_free (eff_restore_file);
16676 local_free (new_restore_file);
16677
16678 local_free (rd);
16679
16680 // tuning db
16681
16682 tuning_db_destroy (tuning_db);
16683
16684 // loopback
16685
16686 local_free (loopback_file);
16687
16688 if (loopback == 1) unlink (loopback_file);
16689
16690 // induction directory
16691
16692 if (induction_dir == NULL)
16693 {
16694 if (attack_mode != ATTACK_MODE_BF)
16695 {
16696 if (rmdir (induction_directory) == -1)
16697 {
16698 if (errno == ENOENT)
16699 {
16700 // good, we can ignore
16701 }
16702 else if (errno == ENOTEMPTY)
16703 {
16704 // good, we can ignore
16705 }
16706 else
16707 {
16708 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16709
16710 return (-1);
16711 }
16712 }
16713
16714 local_free (induction_directory);
16715 }
16716 }
16717
16718 // outfile-check directory
16719
16720 if (outfile_check_dir == NULL)
16721 {
16722 if (rmdir (outfile_check_directory) == -1)
16723 {
16724 if (errno == ENOENT)
16725 {
16726 // good, we can ignore
16727 }
16728 else if (errno == ENOTEMPTY)
16729 {
16730 // good, we can ignore
16731 }
16732 else
16733 {
16734 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16735
16736 return (-1);
16737 }
16738 }
16739
16740 local_free (outfile_check_directory);
16741 }
16742
16743 time_t proc_stop;
16744
16745 time (&proc_stop);
16746
16747 logfile_top_uint (proc_start);
16748 logfile_top_uint (proc_stop);
16749
16750 logfile_top_msg ("STOP");
16751
16752 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16753 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16754
16755 if (data.ocl) ocl_close (data.ocl);
16756
16757 if (data.devices_status == STATUS_ABORTED) return 2;
16758 if (data.devices_status == STATUS_QUIT) return 2;
16759 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16760 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16761 if (data.devices_status == STATUS_CRACKED) return 0;
16762
16763 return -1;
16764 }
Hashcat additions to support pwdhash