projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
skip device if buildProgram() fail
[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 * words_cur
782 */
783
784 u64 words_cur = get_lowest_words_done ();
785
786 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
787
788 /**
789 * counter
790 */
791
792 uint salts_left = data.salts_cnt - data.salts_done;
793
794 if (salts_left == 0) salts_left = 1;
795
796 u64 progress_total = data.words_cnt * salts_left;
797
798 u64 all_done = 0;
799 u64 all_rejected = 0;
800 u64 all_restored = 0;
801
802 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
803 {
804 if (salts_left > 1)
805 {
806 // otherwise the final cracked status shows 0/XXX progress
807
808 if (data.salts_shown[salt_pos] == 1) continue;
809 }
810
811 all_done += data.words_progress_done[salt_pos];
812 all_rejected += data.words_progress_rejected[salt_pos];
813 all_restored += data.words_progress_restored[salt_pos];
814 }
815
816 u64 progress_cur = all_restored + all_done + all_rejected;
817 u64 progress_end = progress_total;
818
819 u64 progress_skip = 0;
820
821 if (data.skip)
822 {
823 progress_skip = MIN (data.skip, data.words_base) * salts_left;
824
825 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
826 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
827 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
828 }
829
830 if (data.limit)
831 {
832 progress_end = MIN (data.limit, data.words_base) * salts_left;
833
834 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
835 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
836 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
837 }
838
839 u64 progress_cur_relative_skip = progress_cur - progress_skip;
840 u64 progress_end_relative_skip = progress_end - progress_skip;
841
842 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
843
844 /**
845 * cracks
846 */
847
848 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
849 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
850
851 /**
852 * temperature
853 */
854
855 #ifdef HAVE_HWMON
856 if (data.gpu_temp_disable == 0)
857 {
858 fprintf (out, "TEMP\t");
859
860 hc_thread_mutex_lock (mux_adl);
861
862 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
863 {
864 hc_device_param_t *device_param = &data.devices_param[device_id];
865
866 if (device_param->skipped) continue;
867
868 int temp = hm_get_temperature_with_device_id (device_id);
869
870 fprintf (out, "%d\t", temp);
871 }
872
873 hc_thread_mutex_unlock (mux_adl);
874 }
875 #endif // HAVE_HWMON
876
877 #ifdef _WIN
878 fputc ('\r', out);
879 fputc ('\n', out);
880 #endif
881
882 #ifdef _POSIX
883 fputc ('\n', out);
884 #endif
885
886 fflush (out);
887 }
888
889 void status_display ()
890 {
891 if (data.devices_status == STATUS_INIT) return;
892 if (data.devices_status == STATUS_STARTING) return;
893 if (data.devices_status == STATUS_BYPASS) return;
894
895 if (data.status_automat == 1)
896 {
897 status_display_automat ();
898
899 return;
900 }
901
902 char tmp_buf[1000] = { 0 };
903
904 uint tmp_len = 0;
905
906 log_info ("Session.Name...: %s", data.session);
907
908 char *status_type = strstatus (data.devices_status);
909
910 uint hash_mode = data.hash_mode;
911
912 char *hash_type = strhashtype (hash_mode); // not a bug
913
914 log_info ("Status.........: %s", status_type);
915
916 /**
917 * show rules
918 */
919
920 if (data.rp_files_cnt)
921 {
922 uint i;
923
924 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
925 {
926 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
927 }
928
929 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
930
931 log_info ("Rules.Type.....: %s", tmp_buf);
932
933 tmp_len = 0;
934 }
935
936 if (data.rp_gen)
937 {
938 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
939
940 if (data.rp_gen_seed)
941 {
942 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
943 }
944 }
945
946 /**
947 * show input
948 */
949
950 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
951 {
952 if (data.wordlist_mode == WL_MODE_FILE)
953 {
954 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
955 }
956 else if (data.wordlist_mode == WL_MODE_STDIN)
957 {
958 log_info ("Input.Mode.....: Pipe");
959 }
960 }
961 else if (data.attack_mode == ATTACK_MODE_COMBI)
962 {
963 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
964 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
965 }
966 else if (data.attack_mode == ATTACK_MODE_BF)
967 {
968 char *mask = data.mask;
969
970 if (mask != NULL)
971 {
972 uint mask_len = data.css_cnt;
973
974 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
975
976 if (mask_len > 0)
977 {
978 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
979 {
980 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
981 {
982 mask_len -= data.salts_buf[0].salt_len;
983 }
984 }
985
986 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
987
988 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
989 }
990
991 if (data.maskcnt > 1)
992 {
993 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
994
995 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
996 }
997
998 log_info ("Input.Mode.....: %s", tmp_buf);
999 }
1000
1001 tmp_len = 0;
1002 }
1003 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1004 {
1005 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1006 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1007 }
1008 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1009 {
1010 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1011 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1012 }
1013
1014 if (data.digests_cnt == 1)
1015 {
1016 if (data.hash_mode == 2500)
1017 {
1018 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1019
1020 uint pke[25] = { 0 };
1021
1022 char *pke_ptr = (char *) pke;
1023
1024 for (uint i = 0; i < 25; i++)
1025 {
1026 pke[i] = byte_swap_32 (wpa->pke[i]);
1027 }
1028
1029 char mac1[6] = { 0 };
1030 char mac2[6] = { 0 };
1031
1032 memcpy (mac1, pke_ptr + 23, 6);
1033 memcpy (mac2, pke_ptr + 29, 6);
1034
1035 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1036 (char *) data.salts_buf[0].salt_buf,
1037 mac1[0] & 0xff,
1038 mac1[1] & 0xff,
1039 mac1[2] & 0xff,
1040 mac1[3] & 0xff,
1041 mac1[4] & 0xff,
1042 mac1[5] & 0xff,
1043 mac2[0] & 0xff,
1044 mac2[1] & 0xff,
1045 mac2[2] & 0xff,
1046 mac2[3] & 0xff,
1047 mac2[4] & 0xff,
1048 mac2[5] & 0xff);
1049 }
1050 else if (data.hash_mode == 5200)
1051 {
1052 log_info ("Hash.Target....: File (%s)", data.hashfile);
1053 }
1054 else if (data.hash_mode == 9000)
1055 {
1056 log_info ("Hash.Target....: File (%s)", data.hashfile);
1057 }
1058 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1059 {
1060 log_info ("Hash.Target....: File (%s)", data.hashfile);
1061 }
1062 else
1063 {
1064 char out_buf[4096] = { 0 };
1065
1066 ascii_digest (out_buf, 0, 0);
1067
1068 // limit length
1069 if (strlen (out_buf) > 40)
1070 {
1071 out_buf[41] = '.';
1072 out_buf[42] = '.';
1073 out_buf[43] = '.';
1074 out_buf[44] = 0;
1075 }
1076
1077 log_info ("Hash.Target....: %s", out_buf);
1078 }
1079 }
1080 else
1081 {
1082 if (data.hash_mode == 3000)
1083 {
1084 char out_buf1[4096] = { 0 };
1085 char out_buf2[4096] = { 0 };
1086
1087 ascii_digest (out_buf1, 0, 0);
1088 ascii_digest (out_buf2, 0, 1);
1089
1090 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1091 }
1092 else
1093 {
1094 log_info ("Hash.Target....: File (%s)", data.hashfile);
1095 }
1096 }
1097
1098 log_info ("Hash.Type......: %s", hash_type);
1099
1100 /**
1101 * speed new
1102 */
1103
1104 u64 speed_cnt[DEVICES_MAX] = { 0 };
1105 float speed_ms[DEVICES_MAX] = { 0 };
1106
1107 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1108 {
1109 hc_device_param_t *device_param = &data.devices_param[device_id];
1110
1111 if (device_param->skipped) continue;
1112
1113 // we need to clear values (set to 0) because in case the device does
1114 // not get new candidates it idles around but speed display would
1115 // show it as working.
1116 // if we instantly set it to 0 after reading it happens that the
1117 // speed can be shown as zero if the users refreshes too fast.
1118 // therefore, we add a timestamp when a stat was recorded and if its
1119 // too old we will not use it
1120
1121 speed_cnt[device_id] = 0;
1122 speed_ms[device_id] = 0;
1123
1124 for (int i = 0; i < SPEED_CACHE; i++)
1125 {
1126 float rec_ms;
1127
1128 hc_timer_get (device_param->speed_rec[i], rec_ms);
1129
1130 if (rec_ms > SPEED_MAXAGE) continue;
1131
1132 speed_cnt[device_id] += device_param->speed_cnt[i];
1133 speed_ms[device_id] += device_param->speed_ms[i];
1134 }
1135
1136 speed_cnt[device_id] /= SPEED_CACHE;
1137 speed_ms[device_id] /= SPEED_CACHE;
1138 }
1139
1140 float hashes_all_ms = 0;
1141
1142 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1143
1144 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1145 {
1146 hc_device_param_t *device_param = &data.devices_param[device_id];
1147
1148 if (device_param->skipped) continue;
1149
1150 hashes_dev_ms[device_id] = 0;
1151
1152 if (speed_ms[device_id])
1153 {
1154 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1155
1156 hashes_all_ms += hashes_dev_ms[device_id];
1157 }
1158 }
1159
1160 /**
1161 * timers
1162 */
1163
1164 float ms_running = 0;
1165
1166 hc_timer_get (data.timer_running, ms_running);
1167
1168 float ms_paused = data.ms_paused;
1169
1170 if (data.devices_status == STATUS_PAUSED)
1171 {
1172 float ms_paused_tmp = 0;
1173
1174 hc_timer_get (data.timer_paused, ms_paused_tmp);
1175
1176 ms_paused += ms_paused_tmp;
1177 }
1178
1179 #ifdef WIN
1180
1181 __time64_t sec_run = ms_running / 1000;
1182
1183 #else
1184
1185 time_t sec_run = ms_running / 1000;
1186
1187 #endif
1188
1189 if (sec_run)
1190 {
1191 char display_run[32] = { 0 };
1192
1193 struct tm tm_run;
1194
1195 struct tm *tmp = NULL;
1196
1197 #ifdef WIN
1198
1199 tmp = _gmtime64 (&sec_run);
1200
1201 #else
1202
1203 tmp = gmtime (&sec_run);
1204
1205 #endif
1206
1207 if (tmp != NULL)
1208 {
1209 memset (&tm_run, 0, sizeof (tm_run));
1210
1211 memcpy (&tm_run, tmp, sizeof (tm_run));
1212
1213 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1214
1215 char *start = ctime (&data.proc_start);
1216
1217 size_t start_len = strlen (start);
1218
1219 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1220 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1221
1222 log_info ("Time.Started...: %s (%s)", start, display_run);
1223 }
1224 }
1225 else
1226 {
1227 log_info ("Time.Started...: 0 secs");
1228 }
1229
1230 /**
1231 * counters
1232 */
1233
1234 uint salts_left = data.salts_cnt - data.salts_done;
1235
1236 if (salts_left == 0) salts_left = 1;
1237
1238 u64 progress_total = data.words_cnt * salts_left;
1239
1240 u64 all_done = 0;
1241 u64 all_rejected = 0;
1242 u64 all_restored = 0;
1243
1244 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1245 {
1246 if (salts_left > 1)
1247 {
1248 // otherwise the final cracked status shows 0/XXX progress
1249
1250 if (data.salts_shown[salt_pos] == 1) continue;
1251 }
1252
1253 all_done += data.words_progress_done[salt_pos];
1254 all_rejected += data.words_progress_rejected[salt_pos];
1255 all_restored += data.words_progress_restored[salt_pos];
1256 }
1257
1258 u64 progress_cur = all_restored + all_done + all_rejected;
1259 u64 progress_end = progress_total;
1260
1261 u64 progress_skip = 0;
1262
1263 if (data.skip)
1264 {
1265 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1266
1267 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1268 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1269 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1270 }
1271
1272 if (data.limit)
1273 {
1274 progress_end = MIN (data.limit, data.words_base) * salts_left;
1275
1276 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1277 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1278 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1279 }
1280
1281 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1282 u64 progress_end_relative_skip = progress_end - progress_skip;
1283
1284 float speed_ms_real = ms_running - ms_paused;
1285 u64 speed_plains_real = all_done;
1286
1287 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1288 {
1289 if (data.devices_status != STATUS_CRACKED)
1290 {
1291 u64 words_per_ms = 0;
1292
1293 if (speed_plains_real && speed_ms_real)
1294 {
1295 words_per_ms = speed_plains_real / speed_ms_real;
1296 }
1297
1298 #ifdef WIN
1299 __time64_t sec_etc = 0;
1300 #else
1301 time_t sec_etc = 0;
1302 #endif
1303
1304 if (words_per_ms)
1305 {
1306 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1307
1308 u64 ms_left = progress_left_relative_skip / words_per_ms;
1309
1310 sec_etc = ms_left / 1000;
1311 }
1312
1313 if (sec_etc == 0)
1314 {
1315 log_info ("Time.Estimated.: 0 secs");
1316 }
1317 else if ((u64) sec_etc > ETC_MAX)
1318 {
1319 log_info ("Time.Estimated.: > 10 Years");
1320 }
1321 else
1322 {
1323 char display_etc[32] = { 0 };
1324
1325 struct tm tm_etc;
1326
1327 struct tm *tmp = NULL;
1328
1329 #ifdef WIN
1330
1331 tmp = _gmtime64 (&sec_etc);
1332
1333 #else
1334
1335 tmp = gmtime (&sec_etc);
1336
1337 #endif
1338
1339 if (tmp != NULL)
1340 {
1341 memset (&tm_etc, 0, sizeof (tm_etc));
1342
1343 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1344
1345 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1346
1347 time_t now;
1348
1349 time (&now);
1350
1351 now += sec_etc;
1352
1353 char *etc = ctime (&now);
1354
1355 size_t etc_len = strlen (etc);
1356
1357 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1358 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1359
1360 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1361 }
1362 }
1363 }
1364 }
1365
1366 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1367 {
1368 hc_device_param_t *device_param = &data.devices_param[device_id];
1369
1370 if (device_param->skipped) continue;
1371
1372 char display_dev_cur[16] = { 0 };
1373
1374 strncpy (display_dev_cur, "0.00", 4);
1375
1376 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1377
1378 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1379 }
1380
1381 char display_all_cur[16] = { 0 };
1382
1383 strncpy (display_all_cur, "0.00", 4);
1384
1385 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1386
1387 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1388
1389 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1390 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1391
1392 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);
1393
1394 // crack-per-time
1395
1396 if (data.digests_cnt > 100)
1397 {
1398 time_t now = time (NULL);
1399
1400 int cpt_cur_min = 0;
1401 int cpt_cur_hour = 0;
1402 int cpt_cur_day = 0;
1403
1404 for (int i = 0; i < CPT_BUF; i++)
1405 {
1406 const uint cracked = data.cpt_buf[i].cracked;
1407 const time_t timestamp = data.cpt_buf[i].timestamp;
1408
1409 if ((timestamp + 60) > now)
1410 {
1411 cpt_cur_min += cracked;
1412 }
1413
1414 if ((timestamp + 3600) > now)
1415 {
1416 cpt_cur_hour += cracked;
1417 }
1418
1419 if ((timestamp + 86400) > now)
1420 {
1421 cpt_cur_day += cracked;
1422 }
1423 }
1424
1425 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1426 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1427 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1428
1429 if ((data.cpt_start + 86400) < now)
1430 {
1431 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1432 cpt_cur_min,
1433 cpt_cur_hour,
1434 cpt_cur_day,
1435 cpt_avg_min,
1436 cpt_avg_hour,
1437 cpt_avg_day);
1438 }
1439 else if ((data.cpt_start + 3600) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_avg_min,
1445 cpt_avg_hour,
1446 cpt_avg_day);
1447 }
1448 else if ((data.cpt_start + 60) < now)
1449 {
1450 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1451 cpt_cur_min,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else
1457 {
1458 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_avg_min,
1460 cpt_avg_hour,
1461 cpt_avg_day);
1462 }
1463 }
1464
1465 // Restore point
1466
1467 u64 restore_point = get_lowest_words_done ();
1468
1469 u64 restore_total = data.words_base;
1470
1471 float percent_restore = 0;
1472
1473 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1474
1475 if (progress_end_relative_skip)
1476 {
1477 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1478 {
1479 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1480 float percent_rejected = 0.0;
1481
1482 if (progress_cur)
1483 {
1484 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1485 }
1486
1487 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);
1488 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1489
1490 if (data.restore_disable == 0)
1491 {
1492 if (percent_finished != 1)
1493 {
1494 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1495 }
1496 }
1497 }
1498 }
1499 else
1500 {
1501 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1502 {
1503 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1504 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1505
1506 if (data.restore_disable == 0)
1507 {
1508 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1509 }
1510 }
1511 else
1512 {
1513 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1514 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1515
1516 // --restore not allowed if stdin is used -- really? why?
1517
1518 //if (data.restore_disable == 0)
1519 //{
1520 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1521 //}
1522 }
1523 }
1524
1525 #ifdef HAVE_HWMON
1526 if (data.gpu_temp_disable == 0)
1527 {
1528 hc_thread_mutex_lock (mux_adl);
1529
1530 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1531 {
1532 hc_device_param_t *device_param = &data.devices_param[device_id];
1533
1534 if (device_param->skipped) continue;
1535
1536 #define HM_STR_BUF_SIZE 255
1537
1538 if (data.hm_device[device_id].fan_supported == 1)
1539 {
1540 char utilization[HM_STR_BUF_SIZE] = { 0 };
1541 char temperature[HM_STR_BUF_SIZE] = { 0 };
1542 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1543
1544 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1545 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1546
1547 if (device_param->vendor_id == VENDOR_ID_AMD)
1548 {
1549 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1550 }
1551 else if (device_param->vendor_id == VENDOR_ID_NV)
1552 {
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 }
1555
1556 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1557 }
1558 else
1559 {
1560 char utilization[HM_STR_BUF_SIZE] = { 0 };
1561 char temperature[HM_STR_BUF_SIZE] = { 0 };
1562
1563 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1564 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1565
1566 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1567 }
1568 }
1569
1570 hc_thread_mutex_unlock (mux_adl);
1571 }
1572 #endif // HAVE_HWMON
1573 }
1574
1575 static void status_benchmark ()
1576 {
1577 if (data.devices_status == STATUS_INIT) return;
1578 if (data.devices_status == STATUS_STARTING) return;
1579
1580 if (data.words_cnt == 0) return;
1581
1582 u64 speed_cnt[DEVICES_MAX] = { 0 };
1583 float speed_ms[DEVICES_MAX] = { 0 };
1584
1585 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1586 {
1587 hc_device_param_t *device_param = &data.devices_param[device_id];
1588
1589 if (device_param->skipped) continue;
1590
1591 speed_cnt[device_id] = 0;
1592 speed_ms[device_id] = 0;
1593
1594 for (int i = 0; i < SPEED_CACHE; i++)
1595 {
1596 speed_cnt[device_id] += device_param->speed_cnt[i];
1597 speed_ms[device_id] += device_param->speed_ms[i];
1598 }
1599
1600 speed_cnt[device_id] /= SPEED_CACHE;
1601 speed_ms[device_id] /= SPEED_CACHE;
1602 }
1603
1604 float hashes_all_ms = 0;
1605
1606 float hashes_dev_ms[DEVICES_MAX] = { 0 };
1607
1608 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1609 {
1610 hc_device_param_t *device_param = &data.devices_param[device_id];
1611
1612 if (device_param->skipped) continue;
1613
1614 hashes_dev_ms[device_id] = 0;
1615
1616 if (speed_ms[device_id])
1617 {
1618 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1619
1620 hashes_all_ms += hashes_dev_ms[device_id];
1621 }
1622 }
1623
1624 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1625 {
1626 hc_device_param_t *device_param = &data.devices_param[device_id];
1627
1628 if (device_param->skipped) continue;
1629
1630 char display_dev_cur[16] = { 0 };
1631
1632 strncpy (display_dev_cur, "0.00", 4);
1633
1634 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1635
1636 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1637 }
1638
1639 char display_all_cur[16] = { 0 };
1640
1641 strncpy (display_all_cur, "0.00", 4);
1642
1643 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1644
1645 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1646 }
1647
1648 /**
1649 * oclHashcat -only- functions
1650 */
1651
1652 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1653 {
1654 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1655 {
1656 if (attack_kern == ATTACK_KERN_STRAIGHT)
1657 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1658 else if (attack_kern == ATTACK_KERN_COMBI)
1659 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1660 else if (attack_kern == ATTACK_KERN_BF)
1661 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1662 }
1663 else
1664 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1665 }
1666
1667 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)
1668 {
1669 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1670 {
1671 if (attack_kern == ATTACK_KERN_STRAIGHT)
1672 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1673 else if (attack_kern == ATTACK_KERN_COMBI)
1674 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1675 else if (attack_kern == ATTACK_KERN_BF)
1676 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1677 }
1678 else
1679 {
1680 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1681 }
1682 }
1683
1684 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1685 {
1686 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1687 {
1688 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1689 }
1690 else
1691 {
1692 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1693 }
1694 }
1695
1696 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)
1697 {
1698 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1699 {
1700 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1701 }
1702 else
1703 {
1704 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1705 }
1706 }
1707
1708 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1709 {
1710 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1711 }
1712
1713 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1714 {
1715 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1716 }
1717
1718 static uint convert_from_hex (char *line_buf, const uint line_len)
1719 {
1720 if (line_len & 1) return (line_len); // not in hex
1721
1722 if (data.hex_wordlist == 1)
1723 {
1724 uint i;
1725 uint j;
1726
1727 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1728 {
1729 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1730 }
1731
1732 memset (line_buf + i, 0, line_len - i);
1733
1734 return (i);
1735 }
1736 else if (line_len >= 6) // $HEX[] = 6
1737 {
1738 if (line_buf[0] != '$') return (line_len);
1739 if (line_buf[1] != 'H') return (line_len);
1740 if (line_buf[2] != 'E') return (line_len);
1741 if (line_buf[3] != 'X') return (line_len);
1742 if (line_buf[4] != '[') return (line_len);
1743 if (line_buf[line_len - 1] != ']') return (line_len);
1744
1745 uint i;
1746 uint j;
1747
1748 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1749 {
1750 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1751 }
1752
1753 memset (line_buf + i, 0, line_len - i);
1754
1755 return (i);
1756 }
1757
1758 return (line_len);
1759 }
1760
1761 static uint count_lines (FILE *fd)
1762 {
1763 uint cnt = 0;
1764
1765 char *buf = (char *) mymalloc (BUFSIZ + 1);
1766
1767 size_t nread_tmp = 0;
1768
1769 char *ptr = buf;
1770
1771 while (!feof (fd))
1772 {
1773 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1774 nread_tmp = nread;
1775
1776 if (nread < 1) continue;
1777
1778 ptr = buf;
1779
1780 do
1781 {
1782 if (*ptr++ == '\n') cnt++;
1783
1784 } while (nread--);
1785 }
1786
1787 // special case (if last line did not contain a newline char ... at the very end of the file)
1788
1789 if (nread_tmp > 3)
1790 {
1791 ptr -= 2;
1792
1793 if (*ptr != '\n')
1794 {
1795 ptr--;
1796
1797 if (*ptr != '\n') // needed ? different on windows systems?
1798 {
1799 cnt++;
1800 }
1801 }
1802 }
1803
1804 myfree (buf);
1805
1806 return cnt;
1807 }
1808
1809 static void clear_prompt ()
1810 {
1811 fputc ('\r', stdout);
1812
1813 for (size_t i = 0; i < strlen (PROMPT); i++)
1814 {
1815 fputc (' ', stdout);
1816 }
1817
1818 fputc ('\r', stdout);
1819
1820 fflush (stdout);
1821 }
1822
1823 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1824 {
1825 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);
1826 }
1827
1828 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1829 {
1830 char *outfile = data.outfile;
1831 uint quiet = data.quiet;
1832 FILE *pot_fp = data.pot_fp;
1833 uint loopback = data.loopback;
1834 uint debug_mode = data.debug_mode;
1835 char *debug_file = data.debug_file;
1836
1837 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1838 int debug_rule_len = 0; // -1 error
1839 uint debug_plain_len = 0;
1840
1841 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1842
1843 // hash
1844
1845 char out_buf[4096] = { 0 };
1846
1847 ascii_digest (out_buf, salt_pos, digest_pos);
1848
1849 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1850
1851 // plain
1852
1853 plain_t plain;
1854
1855 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);
1856
1857 uint gidvid = plain.gidvid;
1858 uint il_pos = plain.il_pos;
1859
1860 u64 crackpos = device_param->words_off;
1861
1862 uint plain_buf[16] = { 0 };
1863
1864 u8 *plain_ptr = (u8 *) plain_buf;
1865 unsigned int plain_len = 0;
1866
1867 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1868 {
1869 u64 gidd = gidvid;
1870 u64 gidm = 0;
1871
1872 pw_t pw;
1873
1874 gidd_to_pw_t (device_param, gidd, &pw);
1875
1876 for (int i = 0, j = gidm; i < 16; i++, j++)
1877 {
1878 plain_buf[i] = pw.h.hi1[0][j];
1879 }
1880
1881 plain_len = pw.pw_len;
1882
1883 const uint off = device_param->innerloop_pos + il_pos;
1884
1885 if (debug_mode > 0)
1886 {
1887 debug_rule_len = 0;
1888
1889 // save rule
1890 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1891 {
1892 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1893
1894 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1895 }
1896
1897 // save plain
1898 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1899 {
1900 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1901
1902 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1903
1904 debug_plain_len = plain_len;
1905 }
1906 }
1907
1908 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1909
1910 crackpos += gidvid;
1911 crackpos *= data.kernel_rules_cnt;
1912 crackpos += device_param->innerloop_pos + il_pos;
1913
1914 if (plain_len > data.pw_max) plain_len = data.pw_max;
1915 }
1916 else if (data.attack_mode == ATTACK_MODE_COMBI)
1917 {
1918 u64 gidd = gidvid;
1919 u64 gidm = 0;
1920
1921 pw_t pw;
1922
1923 gidd_to_pw_t (device_param, gidd, &pw);
1924
1925 for (int i = 0, j = gidm; i < 16; i++, j++)
1926 {
1927 plain_buf[i] = pw.h.hi1[0][j];
1928 }
1929
1930 plain_len = pw.pw_len;
1931
1932 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1933 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1934
1935 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1936 {
1937 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1938 }
1939 else
1940 {
1941 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1942
1943 memcpy (plain_ptr, comb_buf, comb_len);
1944 }
1945
1946 plain_len += comb_len;
1947
1948 crackpos += gidvid;
1949 crackpos *= data.combs_cnt;
1950 crackpos += device_param->innerloop_pos + il_pos;
1951
1952 if (data.pw_max != PW_DICTMAX1)
1953 {
1954 if (plain_len > data.pw_max) plain_len = data.pw_max;
1955 }
1956 }
1957 else if (data.attack_mode == ATTACK_MODE_BF)
1958 {
1959 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1960 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1961
1962 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1963 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1964
1965 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1966 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1967
1968 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1969 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1970
1971 plain_len = data.css_cnt;
1972
1973 crackpos += gidvid;
1974 crackpos *= data.bfs_cnt;
1975 crackpos += device_param->innerloop_pos + il_pos;
1976 }
1977 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1978 {
1979 u64 gidd = gidvid;
1980 u64 gidm = 0;
1981
1982 pw_t pw;
1983
1984 gidd_to_pw_t (device_param, gidd, &pw);
1985
1986 for (int i = 0, j = gidm; i < 16; i++, j++)
1987 {
1988 plain_buf[i] = pw.h.hi1[0][j];
1989 }
1990
1991 plain_len = pw.pw_len;
1992
1993 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1994
1995 uint start = 0;
1996 uint stop = device_param->kernel_params_mp_buf32[4];
1997
1998 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1999
2000 plain_len += start + stop;
2001
2002 crackpos += gidvid;
2003 crackpos *= data.combs_cnt;
2004 crackpos += device_param->innerloop_pos + il_pos;
2005
2006 if (data.pw_max != PW_DICTMAX1)
2007 {
2008 if (plain_len > data.pw_max) plain_len = data.pw_max;
2009 }
2010 }
2011 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2012 {
2013 u64 gidd = gidvid;
2014 u64 gidm = 0;
2015
2016 pw_t pw;
2017
2018 gidd_to_pw_t (device_param, gidd, &pw);
2019
2020 for (int i = 0, j = gidm; i < 16; i++, j++)
2021 {
2022 plain_buf[i] = pw.h.hi1[0][j];
2023 }
2024
2025 plain_len = pw.pw_len;
2026
2027 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2028
2029 uint start = 0;
2030 uint stop = device_param->kernel_params_mp_buf32[4];
2031
2032 memmove (plain_ptr + stop, plain_ptr, plain_len);
2033
2034 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2035
2036 plain_len += start + stop;
2037
2038 crackpos += gidvid;
2039 crackpos *= data.combs_cnt;
2040 crackpos += device_param->innerloop_pos + il_pos;
2041
2042 if (data.pw_max != PW_DICTMAX1)
2043 {
2044 if (plain_len > data.pw_max) plain_len = data.pw_max;
2045 }
2046 }
2047
2048 if (data.attack_mode == ATTACK_MODE_BF)
2049 {
2050 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2051 {
2052 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2053 {
2054 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2055 {
2056 plain_len = plain_len - data.salts_buf[0].salt_len;
2057 }
2058 }
2059
2060 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2061 {
2062 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2063 {
2064 plain_ptr[j] = plain_ptr[i];
2065 }
2066
2067 plain_len = plain_len / 2;
2068 }
2069 }
2070 }
2071
2072 // if enabled, update also the potfile
2073
2074 if (pot_fp)
2075 {
2076 lock_file (pot_fp);
2077
2078 fprintf (pot_fp, "%s:", out_buf);
2079
2080 format_plain (pot_fp, plain_ptr, plain_len, 1);
2081
2082 fputc ('\n', pot_fp);
2083
2084 fflush (pot_fp);
2085
2086 unlock_file (pot_fp);
2087 }
2088
2089 // outfile
2090
2091 FILE *out_fp = NULL;
2092
2093 if (outfile != NULL)
2094 {
2095 if ((out_fp = fopen (outfile, "ab")) == NULL)
2096 {
2097 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2098
2099 out_fp = stdout;
2100 }
2101 lock_file (out_fp);
2102 }
2103 else
2104 {
2105 out_fp = stdout;
2106
2107 if (quiet == 0) clear_prompt ();
2108 }
2109
2110 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2111
2112 if (outfile != NULL)
2113 {
2114 if (out_fp != stdout)
2115 {
2116 fclose (out_fp);
2117 }
2118 }
2119 else
2120 {
2121 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2122 {
2123 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2124 {
2125 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2126 if (quiet == 0) fflush (stdout);
2127 }
2128 }
2129 }
2130
2131 // loopback
2132
2133 if (loopback)
2134 {
2135 char *loopback_file = data.loopback_file;
2136
2137 FILE *fb_fp = NULL;
2138
2139 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2140 {
2141 lock_file (fb_fp);
2142
2143 format_plain (fb_fp, plain_ptr, plain_len, 1);
2144
2145 fputc ('\n', fb_fp);
2146
2147 fclose (fb_fp);
2148 }
2149 }
2150
2151 // (rule) debug mode
2152
2153 // the next check implies that:
2154 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2155 // - debug_mode > 0
2156
2157 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2158 {
2159 if (debug_rule_len < 0) debug_rule_len = 0;
2160
2161 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2162
2163 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2164
2165 if ((quiet == 0) && (debug_file == NULL))
2166 {
2167 fprintf (stdout, "%s", PROMPT);
2168 fflush (stdout);
2169 }
2170 }
2171 }
2172
2173 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2174 {
2175 salt_t *salt_buf = &data.salts_buf[salt_pos];
2176
2177 int found = 0;
2178
2179 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);
2180
2181 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2182
2183 if (found == 1)
2184 {
2185 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2186
2187 log_info_nn ("");
2188
2189 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);
2190
2191 uint cpt_cracked = 0;
2192
2193 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2194 {
2195 uint idx = salt_buf->digests_offset + digest_pos;
2196
2197 if (data.digests_shown_tmp[idx] == 0) continue;
2198
2199 if (data.digests_shown[idx] == 1) continue;
2200
2201 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2202 {
2203 data.digests_shown[idx] = 1;
2204
2205 data.digests_done++;
2206
2207 cpt_cracked++;
2208
2209 salt_buf->digests_done++;
2210
2211 if (salt_buf->digests_done == salt_buf->digests_cnt)
2212 {
2213 data.salts_shown[salt_pos] = 1;
2214
2215 data.salts_done++;
2216 }
2217 }
2218
2219 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2220
2221 check_hash (device_param, salt_pos, digest_pos);
2222 }
2223
2224 if (cpt_cracked > 0)
2225 {
2226 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2227 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2228
2229 data.cpt_pos++;
2230
2231 data.cpt_total += cpt_cracked;
2232
2233 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2234 }
2235
2236 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2237 {
2238 // we need to reset cracked state on the device
2239 // otherwise host thinks again and again the hash was cracked
2240 // and returns invalid password each time
2241
2242 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2243
2244 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);
2245 }
2246
2247 memset (device_param->result, 0, device_param->size_results);
2248
2249 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);
2250 }
2251 }
2252
2253 static void save_hash ()
2254 {
2255 char *hashfile = data.hashfile;
2256
2257 char new_hashfile[256] = { 0 };
2258 char old_hashfile[256] = { 0 };
2259
2260 snprintf (new_hashfile, 255, "%s.new", hashfile);
2261 snprintf (old_hashfile, 255, "%s.old", hashfile);
2262
2263 unlink (new_hashfile);
2264
2265 char separator = data.separator;
2266
2267 FILE *fp = fopen (new_hashfile, "wb");
2268
2269 if (fp == NULL)
2270 {
2271 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2272
2273 exit (-1);
2274 }
2275
2276 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2277 {
2278 if (data.salts_shown[salt_pos] == 1) continue;
2279
2280 salt_t *salt_buf = &data.salts_buf[salt_pos];
2281
2282 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2283 {
2284 uint idx = salt_buf->digests_offset + digest_pos;
2285
2286 if (data.digests_shown[idx] == 1) continue;
2287
2288 if (data.hash_mode != 2500)
2289 {
2290 char out_buf[4096] = { 0 };
2291
2292 if (data.username == 1)
2293 {
2294 user_t *user = data.hash_info[idx]->user;
2295
2296 uint i;
2297
2298 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2299
2300 fputc (separator, fp);
2301 }
2302
2303 ascii_digest (out_buf, salt_pos, digest_pos);
2304
2305 fputs (out_buf, fp);
2306
2307 log_out (fp, "");
2308 }
2309 else
2310 {
2311 hccap_t hccap;
2312
2313 to_hccap_t (&hccap, salt_pos, digest_pos);
2314
2315 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2316 }
2317 }
2318 }
2319
2320 fflush (fp);
2321
2322 fclose (fp);
2323
2324 unlink (old_hashfile);
2325
2326 if (rename (hashfile, old_hashfile) != 0)
2327 {
2328 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2329
2330 exit (-1);
2331 }
2332
2333 unlink (hashfile);
2334
2335 if (rename (new_hashfile, hashfile) != 0)
2336 {
2337 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2338
2339 exit (-1);
2340 }
2341
2342 unlink (old_hashfile);
2343 }
2344
2345 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2346 {
2347 // function called only in case kernel_blocks_all > words_left)
2348
2349 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2350
2351 kernel_blocks_div += kernel_blocks_div / 100;
2352
2353 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2354
2355 while (kernel_blocks_new < total_left)
2356 {
2357 kernel_blocks_div += kernel_blocks_div / 100;
2358
2359 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2360 }
2361
2362 if (data.quiet == 0)
2363 {
2364 clear_prompt ();
2365
2366 log_info ("");
2367
2368 log_info ("INFO: approaching final keyspace, workload adjusted");
2369
2370 log_info ("");
2371
2372 fprintf (stdout, "%s", PROMPT);
2373
2374 fflush (stdout);
2375 }
2376
2377 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2378
2379 return kernel_blocks_div;
2380 }
2381
2382 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2383 {
2384 uint num_elements = num;
2385
2386 device_param->kernel_params_buf32[30] = data.combs_mode;
2387 device_param->kernel_params_buf32[31] = num;
2388
2389 uint kernel_threads = device_param->kernel_threads;
2390
2391 while (num_elements % kernel_threads) num_elements++;
2392
2393 cl_kernel kernel = NULL;
2394
2395 switch (kern_run)
2396 {
2397 case KERN_RUN_1: kernel = device_param->kernel1; break;
2398 case KERN_RUN_12: kernel = device_param->kernel12; break;
2399 case KERN_RUN_2: kernel = device_param->kernel2; break;
2400 case KERN_RUN_23: kernel = device_param->kernel23; break;
2401 case KERN_RUN_3: kernel = device_param->kernel3; break;
2402 }
2403
2404 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2405 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2406 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2407 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2408 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2409 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2410 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2411 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2412 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2413 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2414 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2415
2416 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2417 {
2418 const size_t global_work_size[3] = { num_elements, 32, 1 };
2419 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2420
2421 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL, true);
2422 }
2423 else
2424 {
2425 const size_t global_work_size[3] = { num_elements, 1, 1 };
2426 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2427
2428 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);
2429
2430 if (rc != CL_SUCCESS)
2431 {
2432 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2433
2434 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2435 }
2436 }
2437
2438 hc_clFlush (data.ocl, device_param->command_queue);
2439
2440 hc_clFinish (data.ocl, device_param->command_queue);
2441 }
2442
2443 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2444 {
2445 uint num_elements = num;
2446
2447 switch (kern_run)
2448 {
2449 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2450 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2451 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2452 }
2453
2454 // causes problems with special threads like in bcrypt
2455 // const uint kernel_threads = device_param->kernel_threads;
2456
2457 const uint kernel_threads = KERNEL_THREADS;
2458
2459 while (num_elements % kernel_threads) num_elements++;
2460
2461 cl_kernel kernel = NULL;
2462
2463 switch (kern_run)
2464 {
2465 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2466 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2467 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2468 }
2469
2470 switch (kern_run)
2471 {
2472 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2473 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2474 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2475 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2476 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2477 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2478 break;
2479 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2480 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2481 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2482 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2483 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2484 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2485 break;
2486 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2487 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2488 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2489 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2490 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2491 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2492 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2493 break;
2494 }
2495
2496 const size_t global_work_size[3] = { num_elements, 1, 1 };
2497 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2498
2499 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);
2500
2501 if (rc != CL_SUCCESS)
2502 {
2503 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2504
2505 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2506 }
2507
2508 hc_clFlush (data.ocl, device_param->command_queue);
2509
2510 hc_clFinish (data.ocl, device_param->command_queue);
2511 }
2512
2513 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2514 {
2515 uint num_elements = num;
2516
2517 uint kernel_threads = device_param->kernel_threads;
2518
2519 while (num_elements % kernel_threads) num_elements++;
2520
2521 cl_kernel kernel = device_param->kernel_tb;
2522
2523 const size_t global_work_size[3] = { num_elements, 1, 1 };
2524 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2525
2526 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);
2527
2528 if (rc != CL_SUCCESS)
2529 {
2530 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2531
2532 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2533 }
2534
2535 hc_clFlush (data.ocl, device_param->command_queue);
2536
2537 hc_clFinish (data.ocl, device_param->command_queue);
2538 }
2539
2540 static void run_kernel_tm (hc_device_param_t *device_param)
2541 {
2542 const uint num_elements = 1024; // fixed
2543
2544 const uint kernel_threads = 32;
2545
2546 cl_kernel kernel = device_param->kernel_tm;
2547
2548 const size_t global_work_size[3] = { num_elements, 1, 1 };
2549 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2550
2551 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);
2552
2553 if (rc != CL_SUCCESS)
2554 {
2555 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2556
2557 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2558 }
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2566 {
2567 uint num_elements = num;
2568
2569 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2570 device_param->kernel_params_amp_buf32[6] = num_elements;
2571
2572 // causes problems with special threads like in bcrypt
2573 // const uint kernel_threads = device_param->kernel_threads;
2574
2575 const uint kernel_threads = KERNEL_THREADS;
2576
2577 while (num_elements % kernel_threads) num_elements++;
2578
2579 cl_kernel kernel = device_param->kernel_amp;
2580
2581 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2582 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2583
2584 const size_t global_work_size[3] = { num_elements, 1, 1 };
2585 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2586
2587 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);
2588
2589 if (rc != CL_SUCCESS)
2590 {
2591 const size_t local_work_size_fallback[3] = { 1, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size_fallback, 0, NULL, NULL, true);
2594 }
2595
2596 hc_clFlush (data.ocl, device_param->command_queue);
2597
2598 hc_clFinish (data.ocl, device_param->command_queue);
2599 }
2600
2601 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2602 {
2603 int rc = -1;
2604
2605 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2606 {
2607 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2608
2609 const cl_uchar zero = 0;
2610
2611 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2612 }
2613
2614 if (rc != 0)
2615 {
2616 // NOTE: clEnqueueFillBuffer () always fails with -59
2617 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults, also on apple
2618 // How's that possible, OpenCL 1.2 support is advertised??
2619 // We need to workaround...
2620
2621 #define FILLSZ 0x100000
2622
2623 char *tmp = (char *) mymalloc (FILLSZ);
2624
2625 for (uint i = 0; i < size; i += FILLSZ)
2626 {
2627 const int left = size - i;
2628
2629 const int fillsz = MIN (FILLSZ, left);
2630
2631 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2632 }
2633
2634 myfree (tmp);
2635 }
2636 }
2637
2638 static int run_rule_engine (const int rule_len, const char *rule_buf)
2639 {
2640 if (rule_len == 0)
2641 {
2642 return 0;
2643 }
2644 else if (rule_len == 1)
2645 {
2646 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2647 }
2648
2649 return 1;
2650 }
2651
2652 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2653 {
2654 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2655 {
2656 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);
2657 }
2658 else if (data.attack_kern == ATTACK_KERN_COMBI)
2659 {
2660 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);
2661 }
2662 else if (data.attack_kern == ATTACK_KERN_BF)
2663 {
2664 const u64 off = device_param->words_off;
2665
2666 device_param->kernel_params_mp_l_buf64[3] = off;
2667
2668 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2669 }
2670 }
2671
2672 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2673 {
2674 const uint kernel_loops = device_param->kernel_loops;
2675
2676 //only useful in debug
2677 //if (data.quiet == 0)
2678 // log_info ("Workload.Dev#%u : loops %u, accel %u", device_param->device_id + 1, device_param->kernel_loops, device_param->kernel_accel);
2679
2680 // init speed timer
2681
2682 uint speed_pos = device_param->speed_pos;
2683
2684 #ifdef _POSIX
2685 if (device_param->timer_speed.tv_sec == 0)
2686 {
2687 hc_timer_set (&device_param->timer_speed);
2688 }
2689 #endif
2690
2691 #ifdef _WIN
2692 if (device_param->timer_speed.QuadPart == 0)
2693 {
2694 hc_timer_set (&device_param->timer_speed);
2695 }
2696 #endif
2697
2698 // find higest password length, this is for optimization stuff
2699
2700 uint highest_pw_len = 0;
2701
2702 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2703 {
2704 }
2705 else if (data.attack_kern == ATTACK_KERN_COMBI)
2706 {
2707 }
2708 else if (data.attack_kern == ATTACK_KERN_BF)
2709 {
2710 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2711 + device_param->kernel_params_mp_l_buf32[5];
2712 }
2713
2714 // bitslice optimization stuff
2715
2716 if (data.attack_mode == ATTACK_MODE_BF)
2717 {
2718 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2719 {
2720 run_kernel_tb (device_param, pws_cnt);
2721 }
2722 }
2723
2724 // iteration type
2725
2726 uint innerloop_step = 0;
2727 uint innerloop_cnt = 0;
2728
2729 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2730 else innerloop_step = 1;
2731
2732 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2733 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2734 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2735
2736 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2737
2738 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2739 {
2740 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2741
2742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2743
2744 if (data.devices_status == STATUS_CRACKED) break;
2745 if (data.devices_status == STATUS_ABORTED) break;
2746 if (data.devices_status == STATUS_QUIT) break;
2747 if (data.devices_status == STATUS_BYPASS) break;
2748
2749 if (data.salts_shown[salt_pos] == 1) continue;
2750
2751 salt_t *salt_buf = &data.salts_buf[salt_pos];
2752
2753 device_param->kernel_params_buf32[24] = salt_pos;
2754 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2755 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2756
2757 FILE *combs_fp = device_param->combs_fp;
2758
2759 if (data.attack_mode == ATTACK_MODE_COMBI)
2760 {
2761 rewind (combs_fp);
2762 }
2763
2764 // innerloops
2765
2766 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2767 {
2768 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2769
2770 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2771
2772 if (data.devices_status == STATUS_CRACKED) break;
2773 if (data.devices_status == STATUS_ABORTED) break;
2774 if (data.devices_status == STATUS_QUIT) break;
2775 if (data.devices_status == STATUS_BYPASS) break;
2776
2777 uint innerloop_left = innerloop_cnt - innerloop_pos;
2778
2779 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2780
2781 device_param->innerloop_pos = innerloop_pos;
2782 device_param->innerloop_left = innerloop_left;
2783
2784 device_param->kernel_params_buf32[27] = innerloop_left;
2785
2786 if (innerloop_left == 0) continue;
2787
2788 // initialize amplifiers
2789
2790 if (data.attack_mode == ATTACK_MODE_COMBI)
2791 {
2792 char line_buf[BUFSIZ] = { 0 };
2793
2794 uint i = 0;
2795
2796 while (i < innerloop_left)
2797 {
2798 if (feof (combs_fp)) break;
2799
2800 int line_len = fgetl (combs_fp, line_buf);
2801
2802 if (line_len >= PW_MAX1) continue;
2803
2804 line_len = convert_from_hex (line_buf, line_len);
2805
2806 char *line_buf_new = line_buf;
2807
2808 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2809 {
2810 char rule_buf_out[BLOCK_SIZE] = { 0 };
2811
2812 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2813
2814 if (rule_len_out < 0)
2815 {
2816 data.words_progress_rejected[salt_pos] += pw_cnt;
2817
2818 continue;
2819 }
2820
2821 line_len = rule_len_out;
2822
2823 line_buf_new = rule_buf_out;
2824 }
2825
2826 line_len = MIN (line_len, PW_DICTMAX);
2827
2828 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2829
2830 memcpy (ptr, line_buf_new, line_len);
2831
2832 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2833
2834 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2835 {
2836 uppercase (ptr, line_len);
2837 }
2838
2839 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2840 {
2841 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2842 {
2843 ptr[line_len] = 0x80;
2844 }
2845
2846 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2847 {
2848 ptr[line_len] = 0x01;
2849 }
2850 }
2851
2852 device_param->combs_buf[i].pw_len = line_len;
2853
2854 i++;
2855 }
2856
2857 for (uint j = i; j < innerloop_left; j++)
2858 {
2859 device_param->combs_buf[j].i[0] = 0;
2860 device_param->combs_buf[j].i[1] = 0;
2861 device_param->combs_buf[j].i[2] = 0;
2862 device_param->combs_buf[j].i[3] = 0;
2863 device_param->combs_buf[j].i[4] = 0;
2864 device_param->combs_buf[j].i[5] = 0;
2865 device_param->combs_buf[j].i[6] = 0;
2866 device_param->combs_buf[j].i[7] = 0;
2867
2868 device_param->combs_buf[j].pw_len = 0;
2869 }
2870
2871 innerloop_left = i;
2872 }
2873 else if (data.attack_mode == ATTACK_MODE_BF)
2874 {
2875 u64 off = innerloop_pos;
2876
2877 device_param->kernel_params_mp_r_buf64[3] = off;
2878
2879 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2880 }
2881 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2882 {
2883 u64 off = innerloop_pos;
2884
2885 device_param->kernel_params_mp_buf64[3] = off;
2886
2887 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2888 }
2889 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2890 {
2891 u64 off = innerloop_pos;
2892
2893 device_param->kernel_params_mp_buf64[3] = off;
2894
2895 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2896 }
2897
2898 // copy amplifiers
2899
2900 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2901 {
2902 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);
2903 }
2904 else if (data.attack_mode == ATTACK_MODE_COMBI)
2905 {
2906 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);
2907 }
2908 else if (data.attack_mode == ATTACK_MODE_BF)
2909 {
2910 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);
2911 }
2912 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2913 {
2914 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);
2915 }
2916 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2917 {
2918 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);
2919 }
2920
2921 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2922 {
2923 if (data.attack_mode == ATTACK_MODE_BF)
2924 {
2925 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2926 {
2927 const uint size_tm = 32 * sizeof (bs_word_t);
2928
2929 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2930
2931 run_kernel_tm (device_param);
2932
2933 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);
2934 }
2935 }
2936
2937 if (highest_pw_len < 16)
2938 {
2939 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2940 }
2941 else if (highest_pw_len < 32)
2942 {
2943 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2944 }
2945 else
2946 {
2947 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2948 }
2949 }
2950 else
2951 {
2952 run_kernel_amp (device_param, pws_cnt);
2953
2954 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2955
2956 if (data.opts_type & OPTS_TYPE_HOOK12)
2957 {
2958 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2959 }
2960
2961 uint iter = salt_buf->salt_iter;
2962
2963 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2964 {
2965 uint loop_left = iter - loop_pos;
2966
2967 loop_left = MIN (loop_left, kernel_loops);
2968
2969 device_param->kernel_params_buf32[25] = loop_pos;
2970 device_param->kernel_params_buf32[26] = loop_left;
2971
2972 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2973
2974 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2975
2976 if (data.devices_status == STATUS_CRACKED) break;
2977 if (data.devices_status == STATUS_ABORTED) break;
2978 if (data.devices_status == STATUS_QUIT) break;
2979 }
2980
2981 if (data.opts_type & OPTS_TYPE_HOOK23)
2982 {
2983 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2984
2985 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);
2986
2987 // do something with data
2988
2989 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);
2990 }
2991
2992 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2993 }
2994
2995 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2996
2997 if (data.devices_status == STATUS_CRACKED) break;
2998 if (data.devices_status == STATUS_ABORTED) break;
2999 if (data.devices_status == STATUS_QUIT) break;
3000
3001 /**
3002 * result
3003 */
3004
3005 hc_thread_mutex_lock (mux_display);
3006
3007 check_cracked (device_param, salt_pos);
3008
3009 hc_thread_mutex_unlock (mux_display);
3010
3011 /**
3012 * progress
3013 */
3014
3015 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
3016
3017 hc_thread_mutex_lock (mux_counter);
3018
3019 data.words_progress_done[salt_pos] += perf_sum_all;
3020
3021 hc_thread_mutex_unlock (mux_counter);
3022
3023 /**
3024 * speed
3025 */
3026
3027 float speed_ms;
3028
3029 hc_timer_get (device_param->timer_speed, speed_ms);
3030
3031 hc_timer_set (&device_param->timer_speed);
3032
3033 hc_thread_mutex_lock (mux_display);
3034
3035 device_param->speed_cnt[speed_pos] = perf_sum_all;
3036
3037 device_param->speed_ms[speed_pos] = speed_ms;
3038
3039 device_param->speed_rec[speed_pos] = device_param->timer_speed;
3040
3041 hc_thread_mutex_unlock (mux_display);
3042
3043 speed_pos++;
3044
3045 if (speed_pos == SPEED_CACHE)
3046 {
3047 speed_pos = 0;
3048 }
3049 }
3050 }
3051
3052 device_param->speed_pos = speed_pos;
3053 }
3054
3055 static void load_segment (wl_data_t *wl_data, FILE *fd)
3056 {
3057 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3058
3059 wl_data->pos = 0;
3060
3061 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3062
3063 wl_data->buf[wl_data->cnt] = 0;
3064
3065 if (wl_data->cnt == 0) return;
3066
3067 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3068
3069 while (!feof (fd))
3070 {
3071 if (wl_data->cnt == wl_data->avail)
3072 {
3073 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3074
3075 wl_data->avail += wl_data->incr;
3076 }
3077
3078 const int c = fgetc (fd);
3079
3080 if (c == EOF) break;
3081
3082 wl_data->buf[wl_data->cnt] = (char) c;
3083
3084 wl_data->cnt++;
3085
3086 if (c == '\n') break;
3087 }
3088
3089 // ensure stream ends with a newline
3090
3091 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3092 {
3093 wl_data->cnt++;
3094
3095 wl_data->buf[wl_data->cnt - 1] = '\n';
3096 }
3097
3098 return;
3099 }
3100
3101 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3102 {
3103 char *ptr = buf;
3104
3105 for (u32 i = 0; i < sz; i++, ptr++)
3106 {
3107 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3108
3109 if (i == 7)
3110 {
3111 *off = i;
3112 *len = i;
3113
3114 return;
3115 }
3116
3117 if (*ptr != '\n') continue;
3118
3119 *off = i + 1;
3120
3121 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3122
3123 *len = i;
3124
3125 return;
3126 }
3127
3128 *off = sz;
3129 *len = sz;
3130 }
3131
3132 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3133 {
3134 char *ptr = buf;
3135
3136 for (u32 i = 0; i < sz; i++, ptr++)
3137 {
3138 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3139
3140 if (*ptr != '\n') continue;
3141
3142 *off = i + 1;
3143
3144 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3145
3146 *len = i;
3147
3148 return;
3149 }
3150
3151 *off = sz;
3152 *len = sz;
3153 }
3154
3155 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3156 {
3157 char *ptr = buf;
3158
3159 for (u32 i = 0; i < sz; i++, ptr++)
3160 {
3161 if (*ptr != '\n') continue;
3162
3163 *off = i + 1;
3164
3165 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3166
3167 *len = i;
3168
3169 return;
3170 }
3171
3172 *off = sz;
3173 *len = sz;
3174 }
3175
3176 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3177 {
3178 while (wl_data->pos < wl_data->cnt)
3179 {
3180 uint off;
3181 uint len;
3182
3183 char *ptr = wl_data->buf + wl_data->pos;
3184
3185 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3186
3187 wl_data->pos += off;
3188
3189 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3190 {
3191 char rule_buf_out[BLOCK_SIZE] = { 0 };
3192
3193 int rule_len_out = -1;
3194
3195 if (len < BLOCK_SIZE)
3196 {
3197 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3198 }
3199
3200 if (rule_len_out < 0)
3201 {
3202 continue;
3203 }
3204
3205 if (rule_len_out > PW_MAX)
3206 {
3207 continue;
3208 }
3209 }
3210 else
3211 {
3212 if (len > PW_MAX)
3213 {
3214 continue;
3215 }
3216 }
3217
3218 *out_buf = ptr;
3219 *out_len = len;
3220
3221 return;
3222 }
3223
3224 if (feof (fd))
3225 {
3226 fprintf (stderr, "bug!!\n");
3227
3228 return;
3229 }
3230
3231 load_segment (wl_data, fd);
3232
3233 get_next_word (wl_data, fd, out_buf, out_len);
3234 }
3235
3236 #ifdef _POSIX
3237 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3238 #endif
3239
3240 #ifdef _WIN
3241 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3242 #endif
3243 {
3244 hc_signal (NULL);
3245
3246 dictstat_t d;
3247
3248 d.cnt = 0;
3249
3250 #ifdef _POSIX
3251 fstat (fileno (fd), &d.stat);
3252 #endif
3253
3254 #ifdef _WIN
3255 _fstat64 (fileno (fd), &d.stat);
3256 #endif
3257
3258 d.stat.st_mode = 0;
3259 d.stat.st_nlink = 0;
3260 d.stat.st_uid = 0;
3261 d.stat.st_gid = 0;
3262 d.stat.st_rdev = 0;
3263 d.stat.st_atime = 0;
3264
3265 #ifdef _POSIX
3266 d.stat.st_blksize = 0;
3267 d.stat.st_blocks = 0;
3268 #endif
3269
3270 if (d.stat.st_size == 0) return 0;
3271
3272 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3273
3274 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3275 {
3276 if (d_cache)
3277 {
3278 u64 cnt = d_cache->cnt;
3279
3280 u64 keyspace = cnt;
3281
3282 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3283 {
3284 keyspace *= data.kernel_rules_cnt;
3285 }
3286 else if (data.attack_kern == ATTACK_KERN_COMBI)
3287 {
3288 keyspace *= data.combs_cnt;
3289 }
3290
3291 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);
3292 if (data.quiet == 0) log_info ("");
3293
3294 hc_signal (sigHandler_default);
3295
3296 return (keyspace);
3297 }
3298 }
3299
3300 time_t now = 0;
3301 time_t prev = 0;
3302
3303 u64 comp = 0;
3304 u64 cnt = 0;
3305 u64 cnt2 = 0;
3306
3307 while (!feof (fd))
3308 {
3309 load_segment (wl_data, fd);
3310
3311 comp += wl_data->cnt;
3312
3313 u32 i = 0;
3314
3315 while (i < wl_data->cnt)
3316 {
3317 u32 len;
3318 u32 off;
3319
3320 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3321
3322 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3323 {
3324 char rule_buf_out[BLOCK_SIZE] = { 0 };
3325
3326 int rule_len_out = -1;
3327
3328 if (len < BLOCK_SIZE)
3329 {
3330 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3331 }
3332
3333 if (rule_len_out < 0)
3334 {
3335 len = PW_MAX1;
3336 }
3337 else
3338 {
3339 len = rule_len_out;
3340 }
3341 }
3342
3343 if (len < PW_MAX1)
3344 {
3345 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3346 {
3347 cnt += data.kernel_rules_cnt;
3348 }
3349 else if (data.attack_kern == ATTACK_KERN_COMBI)
3350 {
3351 cnt += data.combs_cnt;
3352 }
3353
3354 d.cnt++;
3355 }
3356
3357 i += off;
3358
3359 cnt2++;
3360 }
3361
3362 time (&now);
3363
3364 if ((now - prev) == 0) continue;
3365
3366 float percent = (float) comp / (float) d.stat.st_size;
3367
3368 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);
3369
3370 time (&prev);
3371 }
3372
3373 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);
3374 if (data.quiet == 0) log_info ("");
3375
3376 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3377
3378 hc_signal (sigHandler_default);
3379
3380 return (cnt);
3381 }
3382
3383 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3384 {
3385 memcpy (p2->h.hi1, p1->h.hi1, 64 * sizeof (uint));
3386 }
3387
3388 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3389 {
3390 if (data.devices_status == STATUS_BYPASS) return 0;
3391
3392 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3393
3394 uint cache_cnt = pw_cache->cnt;
3395
3396 u8 *pw_hc1 = pw_cache->pw_buf.h.hc1[cache_cnt];
3397
3398 memcpy (pw_hc1, pw_buf, pw_len);
3399
3400 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3401
3402 uint pws_cnt = device_param->pws_cnt;
3403
3404 cache_cnt++;
3405
3406 pw_t *pw = device_param->pws_buf + pws_cnt;
3407
3408 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3409
3410 pw->pw_len = pw_len;
3411
3412 pws_cnt++;
3413
3414 device_param->pws_cnt = pws_cnt;
3415 device_param->pw_cnt = pws_cnt * 1;
3416
3417 cache_cnt = 0;
3418
3419 pw_cache->cnt = cache_cnt;
3420
3421 return pws_cnt;
3422 }
3423
3424 static void *thread_monitor (void *p)
3425 {
3426 uint runtime_check = 0;
3427 uint remove_check = 0;
3428 uint status_check = 0;
3429 uint restore_check = 0;
3430
3431 uint restore_left = data.restore_timer;
3432 uint remove_left = data.remove_timer;
3433 uint status_left = data.status_timer;
3434
3435 #ifdef HAVE_HWMON
3436 uint hwmon_check = 0;
3437
3438 // these variables are mainly used for fan control (AMD only)
3439
3440 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3441
3442 // temperature controller "loopback" values
3443
3444 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3445 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3446
3447 #ifdef HAVE_ADL
3448 int temp_threshold = 1; // degrees celcius
3449
3450 int fan_speed_min = 15; // in percentage
3451 int fan_speed_max = 100;
3452 #endif // HAVE_ADL
3453
3454 time_t last_temp_check_time;
3455 #endif // HAVE_HWMON
3456
3457 uint sleep_time = 1;
3458
3459 if (data.runtime)
3460 {
3461 runtime_check = 1;
3462 }
3463
3464 if (data.restore_timer)
3465 {
3466 restore_check = 1;
3467 }
3468
3469 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3470 {
3471 remove_check = 1;
3472 }
3473
3474 if (data.status == 1)
3475 {
3476 status_check = 1;
3477 }
3478
3479 #ifdef HAVE_HWMON
3480 if (data.gpu_temp_disable == 0)
3481 {
3482 time (&last_temp_check_time);
3483
3484 hwmon_check = 1;
3485 }
3486 #endif
3487
3488 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3489 {
3490 #ifdef HAVE_HWMON
3491 if (hwmon_check == 0)
3492 #endif
3493 return (p);
3494 }
3495
3496 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3497 {
3498 hc_sleep (sleep_time);
3499
3500 if (data.devices_status != STATUS_RUNNING) continue;
3501
3502 #ifdef HAVE_HWMON
3503 if (hwmon_check == 1)
3504 {
3505 hc_thread_mutex_lock (mux_adl);
3506
3507 time_t temp_check_time;
3508
3509 time (&temp_check_time);
3510
3511 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3512
3513 if (Ta == 0) Ta = 1;
3514
3515 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3516 {
3517 hc_device_param_t *device_param = &data.devices_param[device_id];
3518
3519 if (device_param->skipped) continue;
3520
3521 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3522
3523 const int temperature = hm_get_temperature_with_device_id (device_id);
3524
3525 if (temperature > (int) data.gpu_temp_abort)
3526 {
3527 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3528
3529 if (data.devices_status != STATUS_QUIT) myabort ();
3530
3531 break;
3532 }
3533
3534 #ifdef HAVE_ADL
3535 const int gpu_temp_retain = data.gpu_temp_retain;
3536
3537 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3538 {
3539 if (data.hm_device[device_id].fan_supported == 1)
3540 {
3541 int temp_cur = temperature;
3542
3543 int temp_diff_new = gpu_temp_retain - temp_cur;
3544
3545 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3546
3547 // calculate Ta value (time difference in seconds between the last check and this check)
3548
3549 last_temp_check_time = temp_check_time;
3550
3551 float Kp = 1.8;
3552 float Ki = 0.005;
3553 float Kd = 6;
3554
3555 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3556
3557 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);
3558
3559 if (abs (fan_diff_required) >= temp_threshold)
3560 {
3561 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3562
3563 int fan_speed_level = fan_speed_cur;
3564
3565 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3566
3567 int fan_speed_new = fan_speed_level - fan_diff_required;
3568
3569 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3570 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3571
3572 if (fan_speed_new != fan_speed_cur)
3573 {
3574 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3575 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3576
3577 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3578 {
3579 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3580
3581 fan_speed_chgd[device_id] = 1;
3582 }
3583
3584 temp_diff_old[device_id] = temp_diff_new;
3585 }
3586 }
3587 }
3588 }
3589 #endif // HAVE_ADL
3590 }
3591
3592 hc_thread_mutex_unlock (mux_adl);
3593 }
3594 #endif // HAVE_HWMON
3595
3596 if (restore_check == 1)
3597 {
3598 restore_left--;
3599
3600 if (restore_left == 0)
3601 {
3602 if (data.restore_disable == 0) cycle_restore ();
3603
3604 restore_left = data.restore_timer;
3605 }
3606 }
3607
3608 if ((runtime_check == 1) && (data.runtime_start > 0))
3609 {
3610 time_t runtime_cur;
3611
3612 time (&runtime_cur);
3613
3614 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3615
3616 if (runtime_left <= 0)
3617 {
3618 if (data.benchmark == 0)
3619 {
3620 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3621 }
3622
3623 if (data.devices_status != STATUS_QUIT) myabort ();
3624 }
3625 }
3626
3627 if (remove_check == 1)
3628 {
3629 remove_left--;
3630
3631 if (remove_left == 0)
3632 {
3633 if (data.digests_saved != data.digests_done)
3634 {
3635 data.digests_saved = data.digests_done;
3636
3637 save_hash ();
3638 }
3639
3640 remove_left = data.remove_timer;
3641 }
3642 }
3643
3644 if (status_check == 1)
3645 {
3646 status_left--;
3647
3648 if (status_left == 0)
3649 {
3650 hc_thread_mutex_lock (mux_display);
3651
3652 if (data.quiet == 0) clear_prompt ();
3653
3654 if (data.quiet == 0) log_info ("");
3655
3656 status_display ();
3657
3658 if (data.quiet == 0) log_info ("");
3659
3660 hc_thread_mutex_unlock (mux_display);
3661
3662 status_left = data.status_timer;
3663 }
3664 }
3665 }
3666
3667 #ifdef HAVE_HWMON
3668 myfree (fan_speed_chgd);
3669
3670 myfree (temp_diff_old);
3671 myfree (temp_diff_sum);
3672 #endif
3673
3674 p = NULL;
3675
3676 return (p);
3677 }
3678
3679 static void *thread_outfile_remove (void *p)
3680 {
3681 // some hash-dependent constants
3682 char *outfile_dir = data.outfile_check_directory;
3683 uint dgst_size = data.dgst_size;
3684 uint isSalted = data.isSalted;
3685 uint esalt_size = data.esalt_size;
3686 uint hash_mode = data.hash_mode;
3687
3688 uint outfile_check_timer = data.outfile_check_timer;
3689
3690 char separator = data.separator;
3691
3692 // some hash-dependent functions
3693 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3694 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3695
3696 // buffers
3697 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3698
3699 hash_buf.digest = mymalloc (dgst_size);
3700
3701 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3702
3703 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3704
3705 uint digest_buf[64] = { 0 };
3706
3707 outfile_data_t *out_info = NULL;
3708
3709 char **out_files = NULL;
3710
3711 time_t folder_mtime = 0;
3712
3713 int out_cnt = 0;
3714
3715 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3716
3717 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3718 {
3719 hc_sleep (1);
3720
3721 if (data.devices_status != STATUS_RUNNING) continue;
3722
3723 check_left--;
3724
3725 if (check_left == 0)
3726 {
3727 struct stat outfile_check_stat;
3728
3729 if (stat (outfile_dir, &outfile_check_stat) == 0)
3730 {
3731 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3732
3733 if (is_dir == 1)
3734 {
3735 if (outfile_check_stat.st_mtime > folder_mtime)
3736 {
3737 char **out_files_new = scan_directory (outfile_dir);
3738
3739 int out_cnt_new = count_dictionaries (out_files_new);
3740
3741 outfile_data_t *out_info_new = NULL;
3742
3743 if (out_cnt_new > 0)
3744 {
3745 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3746
3747 for (int i = 0; i < out_cnt_new; i++)
3748 {
3749 out_info_new[i].file_name = out_files_new[i];
3750
3751 // check if there are files that we have seen/checked before (and not changed)
3752
3753 for (int j = 0; j < out_cnt; j++)
3754 {
3755 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3756 {
3757 struct stat outfile_stat;
3758
3759 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3760 {
3761 if (outfile_stat.st_ctime == out_info[j].ctime)
3762 {
3763 out_info_new[i].ctime = out_info[j].ctime;
3764 out_info_new[i].seek = out_info[j].seek;
3765 }
3766 }
3767 }
3768 }
3769 }
3770 }
3771
3772 local_free (out_info);
3773 local_free (out_files);
3774
3775 out_files = out_files_new;
3776 out_cnt = out_cnt_new;
3777 out_info = out_info_new;
3778
3779 folder_mtime = outfile_check_stat.st_mtime;
3780 }
3781
3782 for (int j = 0; j < out_cnt; j++)
3783 {
3784 FILE *fp = fopen (out_info[j].file_name, "rb");
3785
3786 if (fp != NULL)
3787 {
3788 //hc_thread_mutex_lock (mux_display);
3789
3790 #ifdef _POSIX
3791 struct stat outfile_stat;
3792
3793 fstat (fileno (fp), &outfile_stat);
3794 #endif
3795
3796 #ifdef _WIN
3797 struct stat64 outfile_stat;
3798
3799 _fstat64 (fileno (fp), &outfile_stat);
3800 #endif
3801
3802 if (outfile_stat.st_ctime > out_info[j].ctime)
3803 {
3804 out_info[j].ctime = outfile_stat.st_ctime;
3805 out_info[j].seek = 0;
3806 }
3807
3808 fseek (fp, out_info[j].seek, SEEK_SET);
3809
3810 while (!feof (fp))
3811 {
3812 char line_buf[BUFSIZ] = { 0 };
3813
3814 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3815
3816 if (ptr == NULL) break;
3817
3818 int line_len = strlen (line_buf);
3819
3820 if (line_len <= 0) continue;
3821
3822 int iter = MAX_CUT_TRIES;
3823
3824 for (uint i = line_len - 1; i && iter; i--, line_len--)
3825 {
3826 if (line_buf[i] != separator) continue;
3827
3828 int parser_status = PARSER_OK;
3829
3830 if ((hash_mode != 2500) && (hash_mode != 6800))
3831 {
3832 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3833 }
3834
3835 uint found = 0;
3836
3837 if (parser_status == PARSER_OK)
3838 {
3839 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3840 {
3841 if (data.salts_shown[salt_pos] == 1) continue;
3842
3843 salt_t *salt_buf = &data.salts_buf[salt_pos];
3844
3845 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3846 {
3847 uint idx = salt_buf->digests_offset + digest_pos;
3848
3849 if (data.digests_shown[idx] == 1) continue;
3850
3851 uint cracked = 0;
3852
3853 if (hash_mode == 6800)
3854 {
3855 if (i == salt_buf->salt_len)
3856 {
3857 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3858 }
3859 }
3860 else if (hash_mode == 2500)
3861 {
3862 // BSSID : MAC1 : MAC2 (:plain)
3863 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3864 {
3865 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3866
3867 if (!cracked) continue;
3868
3869 // now compare MAC1 and MAC2 too, since we have this additional info
3870 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3871 char *mac2_pos = mac1_pos + 12 + 1;
3872
3873 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3874 wpa_t *wpa = &wpas[salt_pos];
3875
3876 uint pke[25] = { 0 };
3877
3878 char *pke_ptr = (char *) pke;
3879
3880 for (uint i = 0; i < 25; i++)
3881 {
3882 pke[i] = byte_swap_32 (wpa->pke[i]);
3883 }
3884
3885 u8 mac1[6] = { 0 };
3886 u8 mac2[6] = { 0 };
3887
3888 memcpy (mac1, pke_ptr + 23, 6);
3889 memcpy (mac2, pke_ptr + 29, 6);
3890
3891 // compare hex string(s) vs binary MAC address(es)
3892
3893 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3894 {
3895 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3896 {
3897 cracked = 0;
3898 break;
3899 }
3900 }
3901
3902 // early skip ;)
3903 if (!cracked) continue;
3904
3905 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3906 {
3907 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3908 {
3909 cracked = 0;
3910 break;
3911 }
3912 }
3913 }
3914 }
3915 else
3916 {
3917 char *digests_buf_ptr = (char *) data.digests_buf;
3918
3919 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3920
3921 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3922 }
3923
3924 if (cracked == 1)
3925 {
3926 found = 1;
3927
3928 data.digests_shown[idx] = 1;
3929
3930 data.digests_done++;
3931
3932 salt_buf->digests_done++;
3933
3934 if (salt_buf->digests_done == salt_buf->digests_cnt)
3935 {
3936 data.salts_shown[salt_pos] = 1;
3937
3938 data.salts_done++;
3939
3940 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3941 }
3942 }
3943 }
3944
3945 if (data.devices_status == STATUS_CRACKED) break;
3946 }
3947 }
3948
3949 if (found) break;
3950
3951 if (data.devices_status == STATUS_CRACKED) break;
3952
3953 iter--;
3954 }
3955
3956 if (data.devices_status == STATUS_CRACKED) break;
3957 }
3958
3959 out_info[j].seek = ftell (fp);
3960
3961 //hc_thread_mutex_unlock (mux_display);
3962
3963 fclose (fp);
3964 }
3965 }
3966 }
3967 }
3968
3969 check_left = outfile_check_timer;
3970 }
3971 }
3972
3973 if (esalt_size) local_free (hash_buf.esalt);
3974
3975 if (isSalted) local_free (hash_buf.salt);
3976
3977 local_free (hash_buf.digest);
3978
3979 local_free (out_info);
3980
3981 local_free (out_files);
3982
3983 p = NULL;
3984
3985 return (p);
3986 }
3987
3988 static uint get_work (hc_device_param_t *device_param, const u64 max)
3989 {
3990 hc_thread_mutex_lock (mux_dispatcher);
3991
3992 const u64 words_cur = data.words_cur;
3993 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3994
3995 device_param->words_off = words_cur;
3996
3997 const u64 words_left = words_base - words_cur;
3998
3999 if (data.kernel_blocks_all > words_left)
4000 {
4001 if (data.kernel_blocks_div == 0)
4002 {
4003 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
4004 }
4005 }
4006
4007 if (data.kernel_blocks_div)
4008 {
4009 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
4010 {
4011 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
4012 const u32 kernel_power_new = kernel_blocks_new;
4013
4014 if (kernel_blocks_new < device_param->kernel_blocks)
4015 {
4016 device_param->kernel_blocks = kernel_blocks_new;
4017 device_param->kernel_power = kernel_power_new;
4018 }
4019 }
4020 }
4021
4022 const uint kernel_blocks = device_param->kernel_blocks;
4023
4024 uint work = MIN (words_left, kernel_blocks);
4025
4026 work = MIN (work, max);
4027
4028 data.words_cur += work;
4029
4030 hc_thread_mutex_unlock (mux_dispatcher);
4031
4032 return work;
4033 }
4034
4035 static void *thread_calc_stdin (void *p)
4036 {
4037 hc_device_param_t *device_param = (hc_device_param_t *) p;
4038
4039 if (device_param->skipped) return NULL;
4040
4041 const uint attack_kern = data.attack_kern;
4042
4043 const uint kernel_blocks = device_param->kernel_blocks;
4044
4045 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4046 {
4047 hc_thread_mutex_lock (mux_dispatcher);
4048
4049 if (feof (stdin) != 0)
4050 {
4051 hc_thread_mutex_unlock (mux_dispatcher);
4052
4053 break;
4054 }
4055
4056 uint words_cur = 0;
4057
4058 while (words_cur < kernel_blocks)
4059 {
4060 char buf[BUFSIZ] = { 0 };
4061
4062 char *line_buf = fgets (buf, sizeof (buf), stdin);
4063
4064 if (line_buf == NULL) break;
4065
4066 uint line_len = in_superchop (line_buf);
4067
4068 line_len = convert_from_hex (line_buf, line_len);
4069
4070 // post-process rule engine
4071
4072 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4073 {
4074 char rule_buf_out[BLOCK_SIZE] = { 0 };
4075
4076 int rule_len_out = -1;
4077
4078 if (line_len < BLOCK_SIZE)
4079 {
4080 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4081 }
4082
4083 if (rule_len_out < 0) continue;
4084
4085 line_buf = rule_buf_out;
4086 line_len = rule_len_out;
4087 }
4088
4089 if (line_len > PW_MAX)
4090 {
4091 continue;
4092 }
4093
4094 if (attack_kern == ATTACK_KERN_STRAIGHT)
4095 {
4096 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4097 {
4098 hc_thread_mutex_lock (mux_counter);
4099
4100 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4101 {
4102 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4103 }
4104
4105 hc_thread_mutex_unlock (mux_counter);
4106
4107 continue;
4108 }
4109 }
4110 else if (attack_kern == ATTACK_KERN_COMBI)
4111 {
4112 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4113 // since we still need to combine the plains
4114
4115 if (line_len > data.pw_max)
4116 {
4117 hc_thread_mutex_lock (mux_counter);
4118
4119 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4120 {
4121 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4122 }
4123
4124 hc_thread_mutex_unlock (mux_counter);
4125
4126 continue;
4127 }
4128 }
4129
4130 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4131
4132 words_cur++;
4133
4134 if (data.devices_status == STATUS_CRACKED) break;
4135 if (data.devices_status == STATUS_ABORTED) break;
4136 if (data.devices_status == STATUS_QUIT) break;
4137 if (data.devices_status == STATUS_BYPASS) break;
4138 }
4139
4140 hc_thread_mutex_unlock (mux_dispatcher);
4141
4142 if (data.devices_status == STATUS_CRACKED) break;
4143 if (data.devices_status == STATUS_ABORTED) break;
4144 if (data.devices_status == STATUS_QUIT) break;
4145 if (data.devices_status == STATUS_BYPASS) break;
4146
4147 // we need 2 flushing because we have two independant caches and it can occur
4148 // that one buffer is already at threshold plus for that length also exists
4149 // more data in the 2nd buffer so it would overflow
4150
4151 // flush session 1
4152
4153 {
4154 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4155 {
4156 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4157
4158 const uint pw_cache_cnt = pw_cache->cnt;
4159
4160 if (pw_cache_cnt == 0) continue;
4161
4162 pw_cache->cnt = 0;
4163
4164 uint pws_cnt = device_param->pws_cnt;
4165
4166 pw_t *pw = device_param->pws_buf + pws_cnt;
4167
4168 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4169
4170 pw->pw_len = pw_len;
4171
4172 uint pw_cnt = device_param->pw_cnt;
4173
4174 pw_cnt += pw_cache_cnt;
4175
4176 device_param->pw_cnt = pw_cnt;
4177
4178 pws_cnt++;
4179
4180 device_param->pws_cnt = pws_cnt;
4181
4182 if (pws_cnt == device_param->kernel_power_user) break;
4183 }
4184
4185 const uint pw_cnt = device_param->pw_cnt;
4186 const uint pws_cnt = device_param->pws_cnt;
4187
4188 if (pws_cnt)
4189 {
4190 run_copy (device_param, pws_cnt);
4191
4192 run_cracker (device_param, pw_cnt, pws_cnt);
4193
4194 device_param->pw_cnt = 0;
4195 device_param->pws_cnt = 0;
4196 }
4197 }
4198
4199 // flush session 2
4200
4201 {
4202 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4203 {
4204 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4205
4206 const uint pw_cache_cnt = pw_cache->cnt;
4207
4208 if (pw_cache_cnt == 0) continue;
4209
4210 pw_cache->cnt = 0;
4211
4212 uint pws_cnt = device_param->pws_cnt;
4213
4214 pw_t *pw = device_param->pws_buf + pws_cnt;
4215
4216 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4217
4218 pw->pw_len = pw_len;
4219
4220 uint pw_cnt = device_param->pw_cnt;
4221
4222 pw_cnt += pw_cache_cnt;
4223
4224 device_param->pw_cnt = pw_cnt;
4225
4226 pws_cnt++;
4227
4228 device_param->pws_cnt = pws_cnt;
4229 }
4230
4231 const uint pw_cnt = device_param->pw_cnt;
4232 const uint pws_cnt = device_param->pws_cnt;
4233
4234 if (pws_cnt)
4235 {
4236 run_copy (device_param, pws_cnt);
4237
4238 run_cracker (device_param, pw_cnt, pws_cnt);
4239
4240 device_param->pw_cnt = 0;
4241 device_param->pws_cnt = 0;
4242 }
4243 }
4244 }
4245
4246 return NULL;
4247 }
4248
4249 static void *thread_calc (void *p)
4250 {
4251 hc_device_param_t *device_param = (hc_device_param_t *) p;
4252
4253 if (device_param->skipped) return NULL;
4254
4255 const uint attack_mode = data.attack_mode;
4256 const uint attack_kern = data.attack_kern;
4257
4258 if (attack_mode == ATTACK_MODE_BF)
4259 {
4260 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4261 {
4262 const uint work = get_work (device_param, -1);
4263
4264 if (work == 0) break;
4265
4266 const u64 words_off = device_param->words_off;
4267 const u64 words_fin = words_off + work;
4268
4269 const uint pw_cnt = work;
4270 const uint pws_cnt = work;
4271
4272 device_param->pw_cnt = pw_cnt;
4273 device_param->pws_cnt = pws_cnt;
4274
4275 if (pws_cnt)
4276 {
4277 run_copy (device_param, pws_cnt);
4278
4279 run_cracker (device_param, pw_cnt, pws_cnt);
4280
4281 device_param->pw_cnt = 0;
4282 device_param->pws_cnt = 0;
4283 }
4284
4285 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4286
4287 if (data.devices_status == STATUS_CRACKED) break;
4288 if (data.devices_status == STATUS_ABORTED) break;
4289 if (data.devices_status == STATUS_QUIT) break;
4290 if (data.devices_status == STATUS_BYPASS) break;
4291
4292 device_param->words_done = words_fin;
4293 }
4294 }
4295 else
4296 {
4297 const uint segment_size = data.segment_size;
4298
4299 char *dictfile = data.dictfile;
4300
4301 if (attack_mode == ATTACK_MODE_COMBI)
4302 {
4303 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4304 {
4305 dictfile = data.dictfile2;
4306 }
4307 }
4308
4309 FILE *fd = fopen (dictfile, "rb");
4310
4311 if (fd == NULL)
4312 {
4313 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4314
4315 return NULL;
4316 }
4317
4318 if (attack_mode == ATTACK_MODE_COMBI)
4319 {
4320 const uint combs_mode = data.combs_mode;
4321
4322 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4323 {
4324 const char *dictfilec = data.dictfile2;
4325
4326 FILE *combs_fp = fopen (dictfilec, "rb");
4327
4328 if (combs_fp == NULL)
4329 {
4330 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4331
4332 fclose (fd);
4333
4334 return NULL;
4335 }
4336
4337 device_param->combs_fp = combs_fp;
4338 }
4339 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4340 {
4341 const char *dictfilec = data.dictfile;
4342
4343 FILE *combs_fp = fopen (dictfilec, "rb");
4344
4345 if (combs_fp == NULL)
4346 {
4347 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4348
4349 fclose (fd);
4350
4351 return NULL;
4352 }
4353
4354 device_param->combs_fp = combs_fp;
4355 }
4356 }
4357
4358 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4359
4360 wl_data->buf = (char *) mymalloc (segment_size);
4361 wl_data->avail = segment_size;
4362 wl_data->incr = segment_size;
4363 wl_data->cnt = 0;
4364 wl_data->pos = 0;
4365
4366 u64 words_cur = 0;
4367
4368 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4369 {
4370 u64 words_off = 0;
4371 u64 words_fin = 0;
4372
4373 u64 max = -1;
4374
4375 while (max)
4376 {
4377 const uint work = get_work (device_param, max);
4378
4379 if (work == 0) break;
4380
4381 words_off = device_param->words_off;
4382 words_fin = words_off + work;
4383
4384 char *line_buf;
4385 uint line_len;
4386
4387 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4388
4389 max = 0;
4390
4391 for ( ; words_cur < words_fin; words_cur++)
4392 {
4393 get_next_word (wl_data, fd, &line_buf, &line_len);
4394
4395 line_len = convert_from_hex (line_buf, line_len);
4396
4397 // post-process rule engine
4398
4399 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4400 {
4401 char rule_buf_out[BLOCK_SIZE] = { 0 };
4402
4403 int rule_len_out = -1;
4404
4405 if (line_len < BLOCK_SIZE)
4406 {
4407 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4408 }
4409
4410 if (rule_len_out < 0) continue;
4411
4412 line_buf = rule_buf_out;
4413 line_len = rule_len_out;
4414 }
4415
4416 if (attack_kern == ATTACK_KERN_STRAIGHT)
4417 {
4418 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4419 {
4420 max++;
4421
4422 hc_thread_mutex_lock (mux_counter);
4423
4424 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4425 {
4426 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4427 }
4428
4429 hc_thread_mutex_unlock (mux_counter);
4430
4431 continue;
4432 }
4433 }
4434 else if (attack_kern == ATTACK_KERN_COMBI)
4435 {
4436 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4437 // since we still need to combine the plains
4438
4439 if (line_len > data.pw_max)
4440 {
4441 max++;
4442
4443 hc_thread_mutex_lock (mux_counter);
4444
4445 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4446 {
4447 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4448 }
4449
4450 hc_thread_mutex_unlock (mux_counter);
4451
4452 continue;
4453 }
4454 }
4455
4456 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4457
4458 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4459
4460 if (data.devices_status == STATUS_CRACKED) break;
4461 if (data.devices_status == STATUS_ABORTED) break;
4462 if (data.devices_status == STATUS_QUIT) break;
4463 if (data.devices_status == STATUS_BYPASS) break;
4464 }
4465
4466 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4467
4468 if (data.devices_status == STATUS_CRACKED) break;
4469 if (data.devices_status == STATUS_ABORTED) break;
4470 if (data.devices_status == STATUS_QUIT) break;
4471 if (data.devices_status == STATUS_BYPASS) break;
4472 }
4473
4474 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4475
4476 if (data.devices_status == STATUS_CRACKED) break;
4477 if (data.devices_status == STATUS_ABORTED) break;
4478 if (data.devices_status == STATUS_QUIT) break;
4479 if (data.devices_status == STATUS_BYPASS) break;
4480
4481 // we need 2 flushing because we have two independant caches and it can occur
4482 // that one buffer is already at threshold plus for that length also exists
4483 // more data in the 2nd buffer so it would overflow
4484
4485 //
4486 // flush session 1
4487 //
4488
4489 {
4490 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4491 {
4492 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4493
4494 const uint pw_cache_cnt = pw_cache->cnt;
4495
4496 if (pw_cache_cnt == 0) continue;
4497
4498 pw_cache->cnt = 0;
4499
4500 uint pws_cnt = device_param->pws_cnt;
4501
4502 pw_t *pw = device_param->pws_buf + pws_cnt;
4503
4504 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4505
4506 pw->pw_len = pw_len;
4507
4508 uint pw_cnt = device_param->pw_cnt;
4509
4510 pw_cnt += pw_cache_cnt;
4511
4512 device_param->pw_cnt = pw_cnt;
4513
4514 pws_cnt++;
4515
4516 device_param->pws_cnt = pws_cnt;
4517
4518 if (pws_cnt == device_param->kernel_power_user) break;
4519 }
4520
4521 const uint pw_cnt = device_param->pw_cnt;
4522 const uint pws_cnt = device_param->pws_cnt;
4523
4524 if (pws_cnt)
4525 {
4526 run_copy (device_param, pws_cnt);
4527
4528 run_cracker (device_param, pw_cnt, pws_cnt);
4529
4530 device_param->pw_cnt = 0;
4531 device_param->pws_cnt = 0;
4532 }
4533
4534 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4535
4536 if (data.devices_status == STATUS_CRACKED) break;
4537 if (data.devices_status == STATUS_ABORTED) break;
4538 if (data.devices_status == STATUS_QUIT) break;
4539 if (data.devices_status == STATUS_BYPASS) break;
4540 }
4541
4542 //
4543 // flush session 2
4544 //
4545
4546 {
4547 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4548 {
4549 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4550
4551 const uint pw_cache_cnt = pw_cache->cnt;
4552
4553 if (pw_cache_cnt == 0) continue;
4554
4555 pw_cache->cnt = 0;
4556
4557 uint pws_cnt = device_param->pws_cnt;
4558
4559 pw_t *pw = device_param->pws_buf + pws_cnt;
4560
4561 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4562
4563 pw->pw_len = pw_len;
4564
4565 uint pw_cnt = device_param->pw_cnt;
4566
4567 pw_cnt += pw_cache_cnt;
4568
4569 device_param->pw_cnt = pw_cnt;
4570
4571 pws_cnt++;
4572
4573 device_param->pws_cnt = pws_cnt;
4574 }
4575
4576 const uint pw_cnt = device_param->pw_cnt;
4577 const uint pws_cnt = device_param->pws_cnt;
4578
4579 if (pws_cnt)
4580 {
4581 run_copy (device_param, pws_cnt);
4582
4583 run_cracker (device_param, pw_cnt, pws_cnt);
4584
4585 device_param->pw_cnt = 0;
4586 device_param->pws_cnt = 0;
4587 }
4588
4589 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4590
4591 if (data.devices_status == STATUS_CRACKED) break;
4592 if (data.devices_status == STATUS_ABORTED) break;
4593 if (data.devices_status == STATUS_QUIT) break;
4594 if (data.devices_status == STATUS_BYPASS) break;
4595 }
4596
4597 if (words_fin == 0) break;
4598
4599 device_param->words_done = words_fin;
4600 }
4601
4602 if (attack_mode == ATTACK_MODE_COMBI)
4603 {
4604 fclose (device_param->combs_fp);
4605 }
4606
4607 free (wl_data->buf);
4608 free (wl_data);
4609
4610 fclose (fd);
4611 }
4612
4613 return NULL;
4614 }
4615
4616 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4617 {
4618 if (!device_param)
4619 {
4620 log_error ("ERROR: %s : Invalid argument", __func__);
4621
4622 exit (-1);
4623 }
4624
4625 salt_t *salt_buf = &data.salts_buf[salt_pos];
4626
4627 device_param->kernel_params_buf32[24] = salt_pos;
4628 device_param->kernel_params_buf32[27] = 1;
4629 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4630 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4631 device_param->kernel_params_buf32[30] = 0;
4632 device_param->kernel_params_buf32[31] = 1;
4633
4634 char *dictfile_old = data.dictfile;
4635
4636 const char *weak_hash_check = "weak-hash-check";
4637
4638 data.dictfile = (char *) weak_hash_check;
4639
4640 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4641
4642 data.kernel_rules_buf[0].cmds[0] = 0;
4643
4644 /**
4645 * run the kernel
4646 */
4647
4648 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4649 {
4650 run_kernel (KERN_RUN_1, device_param, 1);
4651 }
4652 else
4653 {
4654 run_kernel (KERN_RUN_1, device_param, 1);
4655
4656 const uint iter = salt_buf->salt_iter;
4657
4658 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4659 {
4660 uint loop_left = iter - loop_pos;
4661
4662 loop_left = MIN (loop_left, kernel_loops);
4663
4664 device_param->kernel_params_buf32[25] = loop_pos;
4665 device_param->kernel_params_buf32[26] = loop_left;
4666
4667 run_kernel (KERN_RUN_2, device_param, 1);
4668 }
4669
4670 run_kernel (KERN_RUN_3, device_param, 1);
4671 }
4672
4673 /**
4674 * result
4675 */
4676
4677 check_cracked (device_param, salt_pos);
4678
4679 /**
4680 * cleanup
4681 */
4682
4683 device_param->kernel_params_buf32[24] = 0;
4684 device_param->kernel_params_buf32[25] = 0;
4685 device_param->kernel_params_buf32[26] = 0;
4686 device_param->kernel_params_buf32[27] = 0;
4687 device_param->kernel_params_buf32[28] = 0;
4688 device_param->kernel_params_buf32[29] = 0;
4689 device_param->kernel_params_buf32[30] = 0;
4690 device_param->kernel_params_buf32[31] = 0;
4691
4692 data.dictfile = dictfile_old;
4693
4694 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4695 }
4696
4697 // hlfmt hashcat
4698
4699 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4700 {
4701 if (data.username == 0)
4702 {
4703 *hashbuf_pos = line_buf;
4704 *hashbuf_len = line_len;
4705 }
4706 else
4707 {
4708 char *pos = line_buf;
4709 int len = line_len;
4710
4711 for (int i = 0; i < line_len; i++, pos++, len--)
4712 {
4713 if (line_buf[i] == data.separator)
4714 {
4715 pos++;
4716
4717 len--;
4718
4719 break;
4720 }
4721 }
4722
4723 *hashbuf_pos = pos;
4724 *hashbuf_len = len;
4725 }
4726 }
4727
4728 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4729 {
4730 char *pos = NULL;
4731 int len = 0;
4732
4733 int sep_cnt = 0;
4734
4735 for (int i = 0; i < line_len; i++)
4736 {
4737 if (line_buf[i] == data.separator)
4738 {
4739 sep_cnt++;
4740
4741 continue;
4742 }
4743
4744 if (sep_cnt == 0)
4745 {
4746 if (pos == NULL) pos = line_buf + i;
4747
4748 len++;
4749 }
4750 }
4751
4752 *userbuf_pos = pos;
4753 *userbuf_len = len;
4754 }
4755
4756 // hlfmt pwdump
4757
4758 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4759 {
4760 int sep_cnt = 0;
4761
4762 int sep2_len = 0;
4763 int sep3_len = 0;
4764
4765 for (int i = 0; i < line_len; i++)
4766 {
4767 if (line_buf[i] == ':')
4768 {
4769 sep_cnt++;
4770
4771 continue;
4772 }
4773
4774 if (sep_cnt == 2) sep2_len++;
4775 if (sep_cnt == 3) sep3_len++;
4776 }
4777
4778 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4779
4780 return 0;
4781 }
4782
4783 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4784 {
4785 char *pos = NULL;
4786 int len = 0;
4787
4788 int sep_cnt = 0;
4789
4790 for (int i = 0; i < line_len; i++)
4791 {
4792 if (line_buf[i] == ':')
4793 {
4794 sep_cnt++;
4795
4796 continue;
4797 }
4798
4799 if (data.hash_mode == 1000)
4800 {
4801 if (sep_cnt == 3)
4802 {
4803 if (pos == NULL) pos = line_buf + i;
4804
4805 len++;
4806 }
4807 }
4808 else if (data.hash_mode == 3000)
4809 {
4810 if (sep_cnt == 2)
4811 {
4812 if (pos == NULL) pos = line_buf + i;
4813
4814 len++;
4815 }
4816 }
4817 }
4818
4819 *hashbuf_pos = pos;
4820 *hashbuf_len = len;
4821 }
4822
4823 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4824 {
4825 char *pos = NULL;
4826 int len = 0;
4827
4828 int sep_cnt = 0;
4829
4830 for (int i = 0; i < line_len; i++)
4831 {
4832 if (line_buf[i] == ':')
4833 {
4834 sep_cnt++;
4835
4836 continue;
4837 }
4838
4839 if (sep_cnt == 0)
4840 {
4841 if (pos == NULL) pos = line_buf + i;
4842
4843 len++;
4844 }
4845 }
4846
4847 *userbuf_pos = pos;
4848 *userbuf_len = len;
4849 }
4850
4851 // hlfmt passwd
4852
4853 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4854 {
4855 int sep_cnt = 0;
4856
4857 char sep5_first = 0;
4858 char sep6_first = 0;
4859
4860 for (int i = 0; i < line_len; i++)
4861 {
4862 if (line_buf[i] == ':')
4863 {
4864 sep_cnt++;
4865
4866 continue;
4867 }
4868
4869 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4870 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4871 }
4872
4873 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4874
4875 return 0;
4876 }
4877
4878 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4879 {
4880 char *pos = NULL;
4881 int len = 0;
4882
4883 int sep_cnt = 0;
4884
4885 for (int i = 0; i < line_len; i++)
4886 {
4887 if (line_buf[i] == ':')
4888 {
4889 sep_cnt++;
4890
4891 continue;
4892 }
4893
4894 if (sep_cnt == 1)
4895 {
4896 if (pos == NULL) pos = line_buf + i;
4897
4898 len++;
4899 }
4900 }
4901
4902 *hashbuf_pos = pos;
4903 *hashbuf_len = len;
4904 }
4905
4906 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4907 {
4908 char *pos = NULL;
4909 int len = 0;
4910
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':')
4916 {
4917 sep_cnt++;
4918
4919 continue;
4920 }
4921
4922 if (sep_cnt == 0)
4923 {
4924 if (pos == NULL) pos = line_buf + i;
4925
4926 len++;
4927 }
4928 }
4929
4930 *userbuf_pos = pos;
4931 *userbuf_len = len;
4932 }
4933
4934 // hlfmt shadow
4935
4936 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4937 {
4938 int sep_cnt = 0;
4939
4940 for (int i = 0; i < line_len; i++)
4941 {
4942 if (line_buf[i] == ':') sep_cnt++;
4943 }
4944
4945 if (sep_cnt == 8) return 1;
4946
4947 return 0;
4948 }
4949
4950 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4951 {
4952 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4953 }
4954
4955 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4956 {
4957 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4958 }
4959
4960 // hlfmt main
4961
4962 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4963 {
4964 switch (hashfile_format)
4965 {
4966 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4967 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4968 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4969 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4970 }
4971 }
4972
4973 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4974 {
4975 switch (hashfile_format)
4976 {
4977 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4978 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4979 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4980 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4981 }
4982 }
4983
4984 static uint hlfmt_detect (FILE *fp, uint max_check)
4985 {
4986 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4987
4988 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4989 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4990
4991 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4992
4993 uint num_check = 0;
4994
4995 while (!feof (fp))
4996 {
4997 char line_buf[BUFSIZ] = { 0 };
4998
4999 int line_len = fgetl (fp, line_buf);
5000
5001 if (line_len == 0) continue;
5002
5003 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5004 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5005 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5006
5007 if (num_check == max_check) break;
5008
5009 num_check++;
5010 }
5011
5012 uint hashlist_format = HLFMT_HASHCAT;
5013
5014 for (int i = 1; i < HLFMTS_CNT; i++)
5015 {
5016 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5017
5018 hashlist_format = i;
5019 }
5020
5021 free (formats_cnt);
5022
5023 return hashlist_format;
5024 }
5025
5026 /**
5027 * some further helper function
5028 */
5029
5030 // wrapper around mymalloc for ADL
5031
5032 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5033 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5034 {
5035 return mymalloc (iSize);
5036 }
5037 #endif
5038
5039 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)
5040 {
5041 u64 collisions = 0;
5042
5043 const uint dgst_pos0 = data.dgst_pos0;
5044 const uint dgst_pos1 = data.dgst_pos1;
5045 const uint dgst_pos2 = data.dgst_pos2;
5046 const uint dgst_pos3 = data.dgst_pos3;
5047
5048 memset (bitmap_a, 0, bitmap_size);
5049 memset (bitmap_b, 0, bitmap_size);
5050 memset (bitmap_c, 0, bitmap_size);
5051 memset (bitmap_d, 0, bitmap_size);
5052
5053 for (uint i = 0; i < digests_cnt; i++)
5054 {
5055 uint *digest_ptr = (uint *) digests_buf_ptr;
5056
5057 digests_buf_ptr += dgst_size;
5058
5059 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5060 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5061 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5062 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5063
5064 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5065 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5066 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5067 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5068
5069 if (bitmap_a[idx0] & val0) collisions++;
5070 if (bitmap_b[idx1] & val1) collisions++;
5071 if (bitmap_c[idx2] & val2) collisions++;
5072 if (bitmap_d[idx3] & val3) collisions++;
5073
5074 bitmap_a[idx0] |= val0;
5075 bitmap_b[idx1] |= val1;
5076 bitmap_c[idx2] |= val2;
5077 bitmap_d[idx3] |= val3;
5078
5079 if (collisions >= collisions_max) return 0x7fffffff;
5080 }
5081
5082 return collisions;
5083 }
5084
5085 /**
5086 * main
5087 */
5088
5089 int main (int argc, char **argv)
5090 {
5091 /**
5092 * To help users a bit
5093 */
5094
5095 char *compute = getenv ("COMPUTE");
5096
5097 if (compute)
5098 {
5099 static char display[100];
5100
5101 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5102
5103 putenv (display);
5104 }
5105 else
5106 {
5107 if (getenv ("DISPLAY") == NULL)
5108 putenv ((char *) "DISPLAY=:0");
5109 }
5110
5111 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5112 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5113
5114 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5115 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5116
5117 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5118 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5119
5120 /**
5121 * Real init
5122 */
5123
5124 memset (&data, 0, sizeof (hc_global_data_t));
5125
5126 time_t proc_start;
5127
5128 time (&proc_start);
5129
5130 data.proc_start = proc_start;
5131
5132 int myargc = argc;
5133 char **myargv = argv;
5134
5135 hc_thread_mutex_init (mux_dispatcher);
5136 hc_thread_mutex_init (mux_counter);
5137 hc_thread_mutex_init (mux_display);
5138 hc_thread_mutex_init (mux_adl);
5139
5140 /**
5141 * commandline parameters
5142 */
5143
5144 uint usage = USAGE;
5145 uint version = VERSION;
5146 uint quiet = QUIET;
5147 uint benchmark = BENCHMARK;
5148 uint benchmark_mode = BENCHMARK_MODE;
5149 uint show = SHOW;
5150 uint left = LEFT;
5151 uint username = USERNAME;
5152 uint remove = REMOVE;
5153 uint remove_timer = REMOVE_TIMER;
5154 u64 skip = SKIP;
5155 u64 limit = LIMIT;
5156 uint keyspace = KEYSPACE;
5157 uint potfile_disable = POTFILE_DISABLE;
5158 uint debug_mode = DEBUG_MODE;
5159 char *debug_file = NULL;
5160 char *induction_dir = NULL;
5161 char *outfile_check_dir = NULL;
5162 uint force = FORCE;
5163 uint runtime = RUNTIME;
5164 uint hash_mode = HASH_MODE;
5165 uint attack_mode = ATTACK_MODE;
5166 uint markov_disable = MARKOV_DISABLE;
5167 uint markov_classic = MARKOV_CLASSIC;
5168 uint markov_threshold = MARKOV_THRESHOLD;
5169 char *markov_hcstat = NULL;
5170 char *outfile = NULL;
5171 uint outfile_format = OUTFILE_FORMAT;
5172 uint outfile_autohex = OUTFILE_AUTOHEX;
5173 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5174 uint restore = RESTORE;
5175 uint restore_timer = RESTORE_TIMER;
5176 uint restore_disable = RESTORE_DISABLE;
5177 uint status = STATUS;
5178 uint status_timer = STATUS_TIMER;
5179 uint status_automat = STATUS_AUTOMAT;
5180 uint loopback = LOOPBACK;
5181 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5182 char *session = NULL;
5183 uint hex_charset = HEX_CHARSET;
5184 uint hex_salt = HEX_SALT;
5185 uint hex_wordlist = HEX_WORDLIST;
5186 uint rp_gen = RP_GEN;
5187 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5188 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5189 uint rp_gen_seed = RP_GEN_SEED;
5190 char *rule_buf_l = (char *) RULE_BUF_L;
5191 char *rule_buf_r = (char *) RULE_BUF_R;
5192 uint increment = INCREMENT;
5193 uint increment_min = INCREMENT_MIN;
5194 uint increment_max = INCREMENT_MAX;
5195 char *cpu_affinity = NULL;
5196 OCL_PTR *ocl = NULL;
5197 char *opencl_devices = NULL;
5198 char *opencl_platforms = NULL;
5199 char *opencl_device_types = NULL;
5200 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5201 char *truecrypt_keyfiles = NULL;
5202 uint workload_profile = WORKLOAD_PROFILE;
5203 uint kernel_accel = KERNEL_ACCEL;
5204 uint kernel_loops = KERNEL_LOOPS;
5205 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5206 #ifdef HAVE_HWMON
5207 uint gpu_temp_abort = GPU_TEMP_ABORT;
5208 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5209 #ifdef HAVE_ADL
5210 uint powertune_enable = POWERTUNE_ENABLE;
5211 #endif
5212 #endif
5213 uint logfile_disable = LOGFILE_DISABLE;
5214 uint segment_size = SEGMENT_SIZE;
5215 uint scrypt_tmto = SCRYPT_TMTO;
5216 char separator = SEPARATOR;
5217 uint bitmap_min = BITMAP_MIN;
5218 uint bitmap_max = BITMAP_MAX;
5219 char *custom_charset_1 = NULL;
5220 char *custom_charset_2 = NULL;
5221 char *custom_charset_3 = NULL;
5222 char *custom_charset_4 = NULL;
5223
5224 #define IDX_HELP 'h'
5225 #define IDX_VERSION 'V'
5226 #define IDX_VERSION_LOWER 'v'
5227 #define IDX_QUIET 0xff02
5228 #define IDX_SHOW 0xff03
5229 #define IDX_LEFT 0xff04
5230 #define IDX_REMOVE 0xff05
5231 #define IDX_REMOVE_TIMER 0xff37
5232 #define IDX_SKIP 's'
5233 #define IDX_LIMIT 'l'
5234 #define IDX_KEYSPACE 0xff35
5235 #define IDX_POTFILE_DISABLE 0xff06
5236 #define IDX_DEBUG_MODE 0xff43
5237 #define IDX_DEBUG_FILE 0xff44
5238 #define IDX_INDUCTION_DIR 0xff46
5239 #define IDX_OUTFILE_CHECK_DIR 0xff47
5240 #define IDX_USERNAME 0xff07
5241 #define IDX_FORCE 0xff08
5242 #define IDX_RUNTIME 0xff09
5243 #define IDX_BENCHMARK 'b'
5244 #define IDX_BENCHMARK_MODE 0xff32
5245 #define IDX_HASH_MODE 'm'
5246 #define IDX_ATTACK_MODE 'a'
5247 #define IDX_RP_FILE 'r'
5248 #define IDX_RP_GEN 'g'
5249 #define IDX_RP_GEN_FUNC_MIN 0xff10
5250 #define IDX_RP_GEN_FUNC_MAX 0xff11
5251 #define IDX_RP_GEN_SEED 0xff34
5252 #define IDX_RULE_BUF_L 'j'
5253 #define IDX_RULE_BUF_R 'k'
5254 #define IDX_INCREMENT 'i'
5255 #define IDX_INCREMENT_MIN 0xff12
5256 #define IDX_INCREMENT_MAX 0xff13
5257 #define IDX_OUTFILE 'o'
5258 #define IDX_OUTFILE_FORMAT 0xff14
5259 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5260 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5261 #define IDX_RESTORE 0xff15
5262 #define IDX_RESTORE_DISABLE 0xff27
5263 #define IDX_STATUS 0xff17
5264 #define IDX_STATUS_TIMER 0xff18
5265 #define IDX_STATUS_AUTOMAT 0xff50
5266 #define IDX_LOOPBACK 0xff38
5267 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5268 #define IDX_SESSION 0xff19
5269 #define IDX_HEX_CHARSET 0xff20
5270 #define IDX_HEX_SALT 0xff21
5271 #define IDX_HEX_WORDLIST 0xff40
5272 #define IDX_MARKOV_DISABLE 0xff22
5273 #define IDX_MARKOV_CLASSIC 0xff23
5274 #define IDX_MARKOV_THRESHOLD 't'
5275 #define IDX_MARKOV_HCSTAT 0xff24
5276 #define IDX_CPU_AFFINITY 0xff25
5277 #define IDX_OPENCL_DEVICES 'd'
5278 #define IDX_OPENCL_PLATFORMS 0xff72
5279 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5280 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5281 #define IDX_WORKLOAD_PROFILE 'w'
5282 #define IDX_KERNEL_ACCEL 'n'
5283 #define IDX_KERNEL_LOOPS 'u'
5284 #define IDX_GPU_TEMP_DISABLE 0xff29
5285 #define IDX_GPU_TEMP_ABORT 0xff30
5286 #define IDX_GPU_TEMP_RETAIN 0xff31
5287 #define IDX_POWERTUNE_ENABLE 0xff41
5288 #define IDX_LOGFILE_DISABLE 0xff51
5289 #define IDX_TRUECRYPT_KEYFILES 0xff52
5290 #define IDX_SCRYPT_TMTO 0xff61
5291 #define IDX_SEGMENT_SIZE 'c'
5292 #define IDX_SEPARATOR 'p'
5293 #define IDX_BITMAP_MIN 0xff70
5294 #define IDX_BITMAP_MAX 0xff71
5295 #define IDX_CUSTOM_CHARSET_1 '1'
5296 #define IDX_CUSTOM_CHARSET_2 '2'
5297 #define IDX_CUSTOM_CHARSET_3 '3'
5298 #define IDX_CUSTOM_CHARSET_4 '4'
5299
5300 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5301
5302 struct option long_options[] =
5303 {
5304 {"help", no_argument, 0, IDX_HELP},
5305 {"version", no_argument, 0, IDX_VERSION},
5306 {"quiet", no_argument, 0, IDX_QUIET},
5307 {"show", no_argument, 0, IDX_SHOW},
5308 {"left", no_argument, 0, IDX_LEFT},
5309 {"username", no_argument, 0, IDX_USERNAME},
5310 {"remove", no_argument, 0, IDX_REMOVE},
5311 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5312 {"skip", required_argument, 0, IDX_SKIP},
5313 {"limit", required_argument, 0, IDX_LIMIT},
5314 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5315 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5316 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5317 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5318 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5319 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5320 {"force", no_argument, 0, IDX_FORCE},
5321 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5322 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5323 {"restore", no_argument, 0, IDX_RESTORE},
5324 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5325 {"status", no_argument, 0, IDX_STATUS},
5326 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5327 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5328 {"loopback", no_argument, 0, IDX_LOOPBACK},
5329 {"weak-hash-threshold",
5330 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5331 {"session", required_argument, 0, IDX_SESSION},
5332 {"runtime", required_argument, 0, IDX_RUNTIME},
5333 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5334 {"generate-rules-func-min",
5335 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5336 {"generate-rules-func-max",
5337 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5338 {"generate-rules-seed",
5339 required_argument, 0, IDX_RP_GEN_SEED},
5340 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5341 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5342 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5343 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5344 {"rules-file", required_argument, 0, IDX_RP_FILE},
5345 {"outfile", required_argument, 0, IDX_OUTFILE},
5346 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5347 {"outfile-autohex-disable",
5348 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5349 {"outfile-check-timer",
5350 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5351 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5352 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5353 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5354 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5355 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5356 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5357 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5358 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5359 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5360 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5361 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5362 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5363 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5364 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5365 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5366 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5367 #ifdef HAVE_HWMON
5368 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5369 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5370 #ifdef HAVE_ADL
5371 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5372 #endif
5373 #endif // HAVE_HWMON
5374 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5375 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5376 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5377 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5378 // deprecated
5379 {"seperator", required_argument, 0, IDX_SEPARATOR},
5380 {"separator", required_argument, 0, IDX_SEPARATOR},
5381 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5382 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5383 {"increment", no_argument, 0, IDX_INCREMENT},
5384 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5385 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5386 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5387 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5388 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5389 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5390
5391 {0, 0, 0, 0}
5392 };
5393
5394 uint rp_files_cnt = 0;
5395
5396 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5397
5398 int option_index = 0;
5399 int c = -1;
5400
5401 optind = 1;
5402 optopt = 0;
5403
5404 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5405 {
5406 switch (c)
5407 {
5408 case IDX_HELP: usage = 1; break;
5409 case IDX_VERSION:
5410 case IDX_VERSION_LOWER: version = 1; break;
5411 case IDX_RESTORE: restore = 1; break;
5412 case IDX_SESSION: session = optarg; break;
5413 case IDX_SHOW: show = 1; break;
5414 case IDX_LEFT: left = 1; break;
5415 case '?': return (-1);
5416 }
5417 }
5418
5419 if (optopt != 0)
5420 {
5421 log_error ("ERROR: Invalid argument specified");
5422
5423 return (-1);
5424 }
5425
5426 /**
5427 * exit functions
5428 */
5429
5430 if (version)
5431 {
5432 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5433
5434 return (0);
5435 }
5436
5437 if (usage)
5438 {
5439 usage_big_print (PROGNAME);
5440
5441 return (0);
5442 }
5443
5444 /**
5445 * session needs to be set, always!
5446 */
5447
5448 if (session == NULL) session = (char *) PROGNAME;
5449
5450 /**
5451 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5452 */
5453
5454 char *exec_path = get_exec_path ();
5455
5456 #ifdef LINUX
5457
5458 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5459 char *resolved_exec_path = realpath (exec_path, NULL);
5460
5461 char *install_dir = get_install_dir (resolved_exec_path);
5462 char *profile_dir = NULL;
5463 char *session_dir = NULL;
5464 char *shared_dir = NULL;
5465
5466 if (strcmp (install_dir, resolved_install_folder) == 0)
5467 {
5468 struct passwd *pw = getpwuid (getuid ());
5469
5470 const char *homedir = pw->pw_dir;
5471
5472 profile_dir = get_profile_dir (homedir);
5473 session_dir = get_session_dir (profile_dir);
5474 shared_dir = strdup (SHARED_FOLDER);
5475
5476 mkdir (profile_dir, 0700);
5477 mkdir (session_dir, 0700);
5478 }
5479 else
5480 {
5481 profile_dir = install_dir;
5482 session_dir = install_dir;
5483 shared_dir = install_dir;
5484 }
5485
5486 myfree (resolved_install_folder);
5487 myfree (resolved_exec_path);
5488
5489 #else
5490
5491 char *install_dir = get_install_dir (exec_path);
5492 char *profile_dir = install_dir;
5493 char *session_dir = install_dir;
5494 char *shared_dir = install_dir;
5495
5496 #endif
5497
5498 data.install_dir = install_dir;
5499 data.profile_dir = profile_dir;
5500 data.session_dir = session_dir;
5501 data.shared_dir = shared_dir;
5502
5503 myfree (exec_path);
5504
5505 /**
5506 * kernel cache, we need to make sure folder exist
5507 */
5508
5509 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5510
5511 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5512
5513 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5514
5515 mkdir (kernels_folder, 0700);
5516
5517 myfree (kernels_folder);
5518
5519 /**
5520 * session
5521 */
5522
5523 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5524
5525 data.session = session;
5526
5527 char *eff_restore_file = (char *) mymalloc (session_size);
5528 char *new_restore_file = (char *) mymalloc (session_size);
5529
5530 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5531 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5532
5533 data.eff_restore_file = eff_restore_file;
5534 data.new_restore_file = new_restore_file;
5535
5536 if (((show == 1) || (left == 1)) && (restore == 1))
5537 {
5538 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5539 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5540
5541 return (-1);
5542 }
5543
5544 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5545 if ((show == 1) || (left == 1))
5546 {
5547 restore_disable = 1;
5548
5549 restore = 0;
5550 }
5551
5552 data.restore_disable = restore_disable;
5553
5554 restore_data_t *rd = init_restore (argc, argv);
5555
5556 data.rd = rd;
5557
5558 /**
5559 * restore file
5560 */
5561
5562 if (restore == 1)
5563 {
5564 read_restore (eff_restore_file, rd);
5565
5566 if (rd->version_bin < RESTORE_MIN)
5567 {
5568 log_error ("ERROR: Incompatible restore-file version");
5569
5570 return (-1);
5571 }
5572
5573 myargc = rd->argc;
5574 myargv = rd->argv;
5575
5576 #ifdef _POSIX
5577 rd->pid = getpid ();
5578 #elif _WIN
5579 rd->pid = GetCurrentProcessId ();
5580 #endif
5581 }
5582
5583 uint hash_mode_chgd = 0;
5584 uint runtime_chgd = 0;
5585 uint kernel_loops_chgd = 0;
5586 uint kernel_accel_chgd = 0;
5587 uint attack_mode_chgd = 0;
5588 uint outfile_format_chgd = 0;
5589 uint rp_gen_seed_chgd = 0;
5590 uint remove_timer_chgd = 0;
5591 uint increment_min_chgd = 0;
5592 uint increment_max_chgd = 0;
5593 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5594 uint gpu_temp_retain_chgd = 0;
5595 uint gpu_temp_abort_chgd = 0;
5596 #endif
5597
5598 optind = 1;
5599 optopt = 0;
5600 option_index = 0;
5601
5602 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5603 {
5604 switch (c)
5605 {
5606 //case IDX_HELP: usage = 1; break;
5607 //case IDX_VERSION: version = 1; break;
5608 //case IDX_RESTORE: restore = 1; break;
5609 case IDX_QUIET: quiet = 1; break;
5610 //case IDX_SHOW: show = 1; break;
5611 case IDX_SHOW: break;
5612 //case IDX_LEFT: left = 1; break;
5613 case IDX_LEFT: break;
5614 case IDX_USERNAME: username = 1; break;
5615 case IDX_REMOVE: remove = 1; break;
5616 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5617 remove_timer_chgd = 1; break;
5618 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5619 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5620 case IDX_DEBUG_FILE: debug_file = optarg; break;
5621 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5622 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5623 case IDX_FORCE: force = 1; break;
5624 case IDX_SKIP: skip = atoll (optarg); break;
5625 case IDX_LIMIT: limit = atoll (optarg); break;
5626 case IDX_KEYSPACE: keyspace = 1; break;
5627 case IDX_BENCHMARK: benchmark = 1; break;
5628 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5629 case IDX_RESTORE: break;
5630 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5631 case IDX_STATUS: status = 1; break;
5632 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5633 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5634 case IDX_LOOPBACK: loopback = 1; break;
5635 case IDX_WEAK_HASH_THRESHOLD:
5636 weak_hash_threshold = atoi (optarg); break;
5637 //case IDX_SESSION: session = optarg; break;
5638 case IDX_SESSION: break;
5639 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5640 hash_mode_chgd = 1; break;
5641 case IDX_RUNTIME: runtime = atoi (optarg);
5642 runtime_chgd = 1; break;
5643 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5644 attack_mode_chgd = 1; break;
5645 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5646 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5647 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5648 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5649 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5650 rp_gen_seed_chgd = 1; break;
5651 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5652 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5653 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5654 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5655 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5656 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5657 case IDX_OUTFILE: outfile = optarg; break;
5658 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5659 outfile_format_chgd = 1; break;
5660 case IDX_OUTFILE_AUTOHEX_DISABLE:
5661 outfile_autohex = 0; break;
5662 case IDX_OUTFILE_CHECK_TIMER:
5663 outfile_check_timer = atoi (optarg); break;
5664 case IDX_HEX_CHARSET: hex_charset = 1; break;
5665 case IDX_HEX_SALT: hex_salt = 1; break;
5666 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5667 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5668 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5669 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5670 case IDX_OPENCL_DEVICE_TYPES:
5671 opencl_device_types = optarg; break;
5672 case IDX_OPENCL_VECTOR_WIDTH:
5673 opencl_vector_width = atoi (optarg); break;
5674 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5675 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5676 kernel_accel_chgd = 1; break;
5677 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5678 kernel_loops_chgd = 1; break;
5679 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5680 #ifdef HAVE_HWMON
5681 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5682 #ifdef HAVE_ADL
5683 gpu_temp_abort_chgd = 1;
5684 #endif
5685 break;
5686 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5687 #ifdef HAVE_ADL
5688 gpu_temp_retain_chgd = 1;
5689 #endif
5690 break;
5691 #ifdef HAVE_ADL
5692 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5693 #endif
5694 #endif // HAVE_HWMON
5695 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5696 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5697 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5698 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5699 case IDX_SEPARATOR: separator = optarg[0]; break;
5700 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5701 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5702 case IDX_INCREMENT: increment = 1; break;
5703 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5704 increment_min_chgd = 1; break;
5705 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5706 increment_max_chgd = 1; break;
5707 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5708 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5709 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5710 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5711
5712 default:
5713 log_error ("ERROR: Invalid argument specified");
5714 return (-1);
5715 }
5716 }
5717
5718 if (optopt != 0)
5719 {
5720 log_error ("ERROR: Invalid argument specified");
5721
5722 return (-1);
5723 }
5724
5725 /**
5726 * Inform user things getting started,
5727 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5728 * - we do not need to check algorithm_pos
5729 */
5730
5731 if (quiet == 0)
5732 {
5733 if (benchmark == 1)
5734 {
5735 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5736
5737 log_info ("");
5738 }
5739 else if (restore == 1)
5740 {
5741 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5742
5743 log_info ("");
5744 }
5745 else
5746 {
5747 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5748
5749 log_info ("");
5750 }
5751 }
5752
5753 /**
5754 * sanity check
5755 */
5756
5757 if (attack_mode > 7)
5758 {
5759 log_error ("ERROR: Invalid attack-mode specified");
5760
5761 return (-1);
5762 }
5763
5764 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5765 {
5766 log_error ("ERROR: Invalid runtime specified");
5767
5768 return (-1);
5769 }
5770
5771 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5772 {
5773 log_error ("ERROR: Invalid hash-type specified");
5774
5775 return (-1);
5776 }
5777
5778 // renamed hash modes
5779
5780 if (hash_mode_chgd)
5781 {
5782 int n = -1;
5783
5784 switch (hash_mode)
5785 {
5786 case 123: n = 124;
5787 break;
5788 }
5789
5790 if (n >= 0)
5791 {
5792 log_error ("Old -m specified, use -m %d instead", n);
5793
5794 return (-1);
5795 }
5796 }
5797
5798 if (username == 1)
5799 {
5800 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5801 {
5802 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5803
5804 return (-1);
5805 }
5806 }
5807
5808 if (outfile_format > 16)
5809 {
5810 log_error ("ERROR: Invalid outfile-format specified");
5811
5812 return (-1);
5813 }
5814
5815 if (left == 1)
5816 {
5817 if (outfile_format_chgd == 1)
5818 {
5819 if (outfile_format > 1)
5820 {
5821 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5822
5823 return (-1);
5824 }
5825 }
5826 else
5827 {
5828 outfile_format = OUTFILE_FMT_HASH;
5829 }
5830 }
5831
5832 if (show == 1)
5833 {
5834 if (outfile_format_chgd == 1)
5835 {
5836 if ((outfile_format > 7) && (outfile_format < 16))
5837 {
5838 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5839
5840 return (-1);
5841 }
5842 }
5843 }
5844
5845 if (increment_min < INCREMENT_MIN)
5846 {
5847 log_error ("ERROR: Invalid increment-min specified");
5848
5849 return (-1);
5850 }
5851
5852 if (increment_max > INCREMENT_MAX)
5853 {
5854 log_error ("ERROR: Invalid increment-max specified");
5855
5856 return (-1);
5857 }
5858
5859 if (increment_min > increment_max)
5860 {
5861 log_error ("ERROR: Invalid increment-min specified");
5862
5863 return (-1);
5864 }
5865
5866 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5867 {
5868 log_error ("ERROR: increment is not allowed in attack-mode 0");
5869
5870 return (-1);
5871 }
5872
5873 if ((increment == 0) && (increment_min_chgd == 1))
5874 {
5875 log_error ("ERROR: increment-min is only supported together with increment switch");
5876
5877 return (-1);
5878 }
5879
5880 if ((increment == 0) && (increment_max_chgd == 1))
5881 {
5882 log_error ("ERROR: increment-max is only supported together with increment switch");
5883
5884 return (-1);
5885 }
5886
5887 if (rp_files_cnt && rp_gen)
5888 {
5889 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5890
5891 return (-1);
5892 }
5893
5894 if (rp_files_cnt || rp_gen)
5895 {
5896 if (attack_mode != ATTACK_MODE_STRAIGHT)
5897 {
5898 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5899
5900 return (-1);
5901 }
5902 }
5903
5904 if (rp_gen_func_min > rp_gen_func_max)
5905 {
5906 log_error ("ERROR: Invalid rp-gen-func-min specified");
5907
5908 return (-1);
5909 }
5910
5911 if (kernel_accel_chgd == 1)
5912 {
5913 if (workload_profile != WORKLOAD_PROFILE)
5914 {
5915 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5916
5917 return (-1);
5918 }
5919
5920 if (kernel_accel < 1)
5921 {
5922 log_error ("ERROR: Invalid kernel-accel specified");
5923
5924 return (-1);
5925 }
5926
5927 if (kernel_accel > 800)
5928 {
5929 log_error ("ERROR: Invalid kernel-accel specified");
5930
5931 return (-1);
5932 }
5933 }
5934
5935 if (kernel_loops_chgd == 1)
5936 {
5937 if (workload_profile != WORKLOAD_PROFILE)
5938 {
5939 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5940
5941 return (-1);
5942 }
5943
5944 if (kernel_loops < 1)
5945 {
5946 log_error ("ERROR: Invalid kernel-loops specified");
5947
5948 return (-1);
5949 }
5950
5951 if (kernel_loops > 1024)
5952 {
5953 log_error ("ERROR: Invalid kernel-loops specified");
5954
5955 return (-1);
5956 }
5957 }
5958
5959 if (benchmark == 1)
5960 {
5961 if (workload_profile != WORKLOAD_PROFILE)
5962 {
5963 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5964
5965 return (-1);
5966 }
5967 }
5968
5969 if ((workload_profile < 1) || (workload_profile > 3))
5970 {
5971 log_error ("ERROR: workload-profile %i not available", workload_profile);
5972
5973 return (-1);
5974 }
5975
5976 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5977 {
5978 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5979
5980 return (-1);
5981 }
5982
5983 if (show == 1 || left == 1)
5984 {
5985 attack_mode = ATTACK_MODE_NONE;
5986
5987 if (remove == 1)
5988 {
5989 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5990
5991 return (-1);
5992 }
5993
5994 if (potfile_disable == 1)
5995 {
5996 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5997
5998 return (-1);
5999 }
6000 }
6001
6002 uint attack_kern = ATTACK_KERN_NONE;
6003
6004 switch (attack_mode)
6005 {
6006 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6007 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6008 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6009 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6010 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6011 }
6012
6013 if (benchmark == 0)
6014 {
6015 if (keyspace == 1)
6016 {
6017 int num_additional_params = 1;
6018
6019 if (attack_kern == ATTACK_KERN_COMBI)
6020 {
6021 num_additional_params = 2;
6022 }
6023
6024 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6025
6026 if (keyspace_wordlist_specified == 0) optind--;
6027 }
6028
6029 if (attack_kern == ATTACK_KERN_NONE)
6030 {
6031 if ((optind + 1) != myargc)
6032 {
6033 usage_mini_print (myargv[0]);
6034
6035 return (-1);
6036 }
6037 }
6038 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6039 {
6040 if ((optind + 1) > myargc)
6041 {
6042 usage_mini_print (myargv[0]);
6043
6044 return (-1);
6045 }
6046 }
6047 else if (attack_kern == ATTACK_KERN_COMBI)
6048 {
6049 if ((optind + 3) != myargc)
6050 {
6051 usage_mini_print (myargv[0]);
6052
6053 return (-1);
6054 }
6055 }
6056 else if (attack_kern == ATTACK_KERN_BF)
6057 {
6058 if ((optind + 1) > myargc)
6059 {
6060 usage_mini_print (myargv[0]);
6061
6062 return (-1);
6063 }
6064 }
6065 else
6066 {
6067 usage_mini_print (myargv[0]);
6068
6069 return (-1);
6070 }
6071 }
6072 else
6073 {
6074 if (myargv[optind] != 0)
6075 {
6076 log_error ("ERROR: Invalid argument for benchmark mode specified");
6077
6078 return (-1);
6079 }
6080
6081 if (attack_mode_chgd == 1)
6082 {
6083 if (attack_mode != ATTACK_MODE_BF)
6084 {
6085 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6086
6087 return (-1);
6088 }
6089 }
6090
6091 if (benchmark_mode == 0)
6092 {
6093 // nothing to do
6094 }
6095 else if (benchmark_mode == 1)
6096 {
6097 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6098 {
6099 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6100
6101 return (-1);
6102 }
6103 }
6104 else
6105 {
6106 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6107
6108 return (-1);
6109 }
6110 }
6111
6112 if (skip != 0 && limit != 0)
6113 {
6114 limit += skip;
6115 }
6116
6117 if (keyspace == 1)
6118 {
6119 if (show == 1)
6120 {
6121 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6122
6123 return (-1);
6124 }
6125 else if (left == 1)
6126 {
6127 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6128
6129 return (-1);
6130 }
6131
6132 potfile_disable = 1;
6133
6134 restore_disable = 1;
6135
6136 restore = 0;
6137
6138 weak_hash_threshold = 0;
6139
6140 quiet = 1;
6141 }
6142
6143 if (remove_timer_chgd == 1)
6144 {
6145 if (remove == 0)
6146 {
6147 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6148
6149 return (-1);
6150 }
6151
6152 if (remove_timer < 1)
6153 {
6154 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6155
6156 return (-1);
6157 }
6158 }
6159
6160 if (loopback == 1)
6161 {
6162 if (attack_mode == ATTACK_MODE_BF)
6163 {
6164 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6165
6166 return (-1);
6167 }
6168 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6169 {
6170 if ((rp_files_cnt == 0) && (rp_gen == 0))
6171 {
6172 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6173
6174 return (-1);
6175 }
6176 }
6177 }
6178
6179 if (debug_mode > 0)
6180 {
6181 if (attack_mode != ATTACK_MODE_STRAIGHT)
6182 {
6183 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6184
6185 return (-1);
6186 }
6187
6188 if ((rp_files_cnt == 0) && (rp_gen == 0))
6189 {
6190 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6191
6192 return (-1);
6193 }
6194 }
6195
6196 if (debug_mode > 4)
6197 {
6198 log_error ("ERROR: Invalid debug-mode specified");
6199
6200 return (-1);
6201 }
6202
6203 if (debug_file != NULL)
6204 {
6205 if (debug_mode < 1)
6206 {
6207 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6208
6209 return (-1);
6210 }
6211 }
6212
6213 if (induction_dir != NULL)
6214 {
6215 if (attack_mode == ATTACK_MODE_BF)
6216 {
6217 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6218
6219 return (-1);
6220 }
6221 }
6222
6223 if (attack_mode != ATTACK_MODE_STRAIGHT)
6224 {
6225 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6226 {
6227 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6228
6229 return (-1);
6230 }
6231
6232 weak_hash_threshold = 0;
6233 }
6234
6235 /**
6236 * induction directory
6237 */
6238
6239 char *induction_directory = NULL;
6240
6241 if (attack_mode != ATTACK_MODE_BF)
6242 {
6243 if (induction_dir == NULL)
6244 {
6245 induction_directory = (char *) mymalloc (session_size);
6246
6247 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6248
6249 // create induction folder if it does not already exist
6250
6251 if (keyspace == 0)
6252 {
6253 if (rmdir (induction_directory) == -1)
6254 {
6255 if (errno == ENOENT)
6256 {
6257 // good, we can ignore
6258 }
6259 else if (errno == ENOTEMPTY)
6260 {
6261 char *induction_directory_mv = (char *) mymalloc (session_size);
6262
6263 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6264
6265 if (rename (induction_directory, induction_directory_mv) != 0)
6266 {
6267 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6268
6269 return (-1);
6270 }
6271 }
6272 else
6273 {
6274 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6275
6276 return (-1);
6277 }
6278 }
6279
6280 if (mkdir (induction_directory, 0700) == -1)
6281 {
6282 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6283
6284 return (-1);
6285 }
6286 }
6287 }
6288 else
6289 {
6290 induction_directory = induction_dir;
6291 }
6292 }
6293
6294 data.induction_directory = induction_directory;
6295
6296 /**
6297 * loopback
6298 */
6299
6300 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6301
6302 char *loopback_file = (char *) mymalloc (loopback_size);
6303
6304 /**
6305 * outfile-check directory
6306 */
6307
6308 char *outfile_check_directory = NULL;
6309
6310 if (outfile_check_dir == NULL)
6311 {
6312 outfile_check_directory = (char *) mymalloc (session_size);
6313
6314 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6315 }
6316 else
6317 {
6318 outfile_check_directory = outfile_check_dir;
6319 }
6320
6321 data.outfile_check_directory = outfile_check_directory;
6322
6323 if (keyspace == 0)
6324 {
6325 struct stat outfile_check_stat;
6326
6327 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6328 {
6329 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6330
6331 if (is_dir == 0)
6332 {
6333 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6334
6335 return (-1);
6336 }
6337 }
6338 else if (outfile_check_dir == NULL)
6339 {
6340 if (mkdir (outfile_check_directory, 0700) == -1)
6341 {
6342 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6343
6344 return (-1);
6345 }
6346 }
6347 }
6348
6349 /**
6350 * special other stuff
6351 */
6352
6353 if (hash_mode == 9710)
6354 {
6355 outfile_format = 5;
6356 outfile_format_chgd = 1;
6357 }
6358
6359 if (hash_mode == 9810)
6360 {
6361 outfile_format = 5;
6362 outfile_format_chgd = 1;
6363 }
6364
6365 if (hash_mode == 10410)
6366 {
6367 outfile_format = 5;
6368 outfile_format_chgd = 1;
6369 }
6370
6371 /**
6372 * store stuff
6373 */
6374
6375 data.hash_mode = hash_mode;
6376 data.restore = restore;
6377 data.restore_timer = restore_timer;
6378 data.restore_disable = restore_disable;
6379 data.status = status;
6380 data.status_timer = status_timer;
6381 data.status_automat = status_automat;
6382 data.loopback = loopback;
6383 data.runtime = runtime;
6384 data.remove = remove;
6385 data.remove_timer = remove_timer;
6386 data.debug_mode = debug_mode;
6387 data.debug_file = debug_file;
6388 data.username = username;
6389 data.quiet = quiet;
6390 data.outfile = outfile;
6391 data.outfile_format = outfile_format;
6392 data.outfile_autohex = outfile_autohex;
6393 data.hex_charset = hex_charset;
6394 data.hex_salt = hex_salt;
6395 data.hex_wordlist = hex_wordlist;
6396 data.separator = separator;
6397 data.rp_files = rp_files;
6398 data.rp_files_cnt = rp_files_cnt;
6399 data.rp_gen = rp_gen;
6400 data.rp_gen_seed = rp_gen_seed;
6401 data.force = force;
6402 data.benchmark = benchmark;
6403 data.skip = skip;
6404 data.limit = limit;
6405 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6406 data.powertune_enable = powertune_enable;
6407 #endif
6408 data.logfile_disable = logfile_disable;
6409 data.truecrypt_keyfiles = truecrypt_keyfiles;
6410 data.scrypt_tmto = scrypt_tmto;
6411
6412 /**
6413 * cpu affinity
6414 */
6415
6416 if (cpu_affinity)
6417 {
6418 set_cpu_affinity (cpu_affinity);
6419 }
6420
6421 if (rp_gen_seed_chgd == 0)
6422 {
6423 srand (proc_start);
6424 }
6425 else
6426 {
6427 srand (rp_gen_seed);
6428 }
6429
6430 /**
6431 * logfile init
6432 */
6433
6434 if (logfile_disable == 0)
6435 {
6436 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6437
6438 char *logfile = (char *) mymalloc (logfile_size);
6439
6440 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6441
6442 data.logfile = logfile;
6443
6444 char *topid = logfile_generate_topid ();
6445
6446 data.topid = topid;
6447 }
6448
6449 // logfile_append() checks for logfile_disable internally to make it easier from here
6450
6451 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6452 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6453 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6454 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6455 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6456 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6457 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6458 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6459 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6460 #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));
6461
6462 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6463 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6464 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6465 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6466 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6467 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6468 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6469 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6470
6471 logfile_top_msg ("START");
6472
6473 logfile_top_uint (attack_mode);
6474 logfile_top_uint (attack_kern);
6475 logfile_top_uint (benchmark);
6476 logfile_top_uint (benchmark_mode);
6477 logfile_top_uint (bitmap_min);
6478 logfile_top_uint (bitmap_max);
6479 logfile_top_uint (debug_mode);
6480 logfile_top_uint (force);
6481 logfile_top_uint (kernel_accel);
6482 logfile_top_uint (kernel_loops);
6483 logfile_top_uint (gpu_temp_disable);
6484 #ifdef HAVE_HWMON
6485 logfile_top_uint (gpu_temp_abort);
6486 logfile_top_uint (gpu_temp_retain);
6487 #endif
6488 logfile_top_uint (hash_mode);
6489 logfile_top_uint (hex_charset);
6490 logfile_top_uint (hex_salt);
6491 logfile_top_uint (hex_wordlist);
6492 logfile_top_uint (increment);
6493 logfile_top_uint (increment_max);
6494 logfile_top_uint (increment_min);
6495 logfile_top_uint (keyspace);
6496 logfile_top_uint (left);
6497 logfile_top_uint (logfile_disable);
6498 logfile_top_uint (loopback);
6499 logfile_top_uint (markov_classic);
6500 logfile_top_uint (markov_disable);
6501 logfile_top_uint (markov_threshold);
6502 logfile_top_uint (outfile_autohex);
6503 logfile_top_uint (outfile_check_timer);
6504 logfile_top_uint (outfile_format);
6505 logfile_top_uint (potfile_disable);
6506 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6507 logfile_top_uint (powertune_enable);
6508 #endif
6509 logfile_top_uint (scrypt_tmto);
6510 logfile_top_uint (quiet);
6511 logfile_top_uint (remove);
6512 logfile_top_uint (remove_timer);
6513 logfile_top_uint (restore);
6514 logfile_top_uint (restore_disable);
6515 logfile_top_uint (restore_timer);
6516 logfile_top_uint (rp_gen);
6517 logfile_top_uint (rp_gen_func_max);
6518 logfile_top_uint (rp_gen_func_min);
6519 logfile_top_uint (rp_gen_seed);
6520 logfile_top_uint (runtime);
6521 logfile_top_uint (segment_size);
6522 logfile_top_uint (show);
6523 logfile_top_uint (status);
6524 logfile_top_uint (status_automat);
6525 logfile_top_uint (status_timer);
6526 logfile_top_uint (usage);
6527 logfile_top_uint (username);
6528 logfile_top_uint (version);
6529 logfile_top_uint (weak_hash_threshold);
6530 logfile_top_uint (workload_profile);
6531 logfile_top_uint64 (limit);
6532 logfile_top_uint64 (skip);
6533 logfile_top_char (separator);
6534 logfile_top_string (cpu_affinity);
6535 logfile_top_string (custom_charset_1);
6536 logfile_top_string (custom_charset_2);
6537 logfile_top_string (custom_charset_3);
6538 logfile_top_string (custom_charset_4);
6539 logfile_top_string (debug_file);
6540 logfile_top_string (opencl_devices);
6541 logfile_top_string (opencl_platforms);
6542 logfile_top_string (opencl_device_types);
6543 logfile_top_uint (opencl_vector_width);
6544 logfile_top_string (induction_dir);
6545 logfile_top_string (markov_hcstat);
6546 logfile_top_string (outfile);
6547 logfile_top_string (outfile_check_dir);
6548 logfile_top_string (rule_buf_l);
6549 logfile_top_string (rule_buf_r);
6550 logfile_top_string (session);
6551 logfile_top_string (truecrypt_keyfiles);
6552
6553 /**
6554 * Init OpenCL library loader
6555 */
6556
6557 if (keyspace == 0)
6558 {
6559 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6560
6561 ocl_init (ocl);
6562
6563 data.ocl = ocl;
6564 }
6565
6566 /**
6567 * OpenCL platform selection
6568 */
6569
6570 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6571
6572 /**
6573 * OpenCL device selection
6574 */
6575
6576 u32 devices_filter = setup_devices_filter (opencl_devices);
6577
6578 /**
6579 * OpenCL device type selection
6580 */
6581
6582 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6583
6584 /**
6585 * benchmark
6586 */
6587
6588 if (benchmark == 1)
6589 {
6590 /**
6591 * disable useless stuff for benchmark
6592 */
6593
6594 restore_timer = 0;
6595 status_timer = 0;
6596 restore_disable = 1;
6597 potfile_disable = 1;
6598 weak_hash_threshold = 0;
6599
6600 data.restore_timer = restore_timer;
6601 data.status_timer = status_timer;
6602 data.restore_disable = restore_disable;
6603
6604 if (benchmark_mode == 1)
6605 {
6606 markov_disable = 1;
6607 }
6608
6609 /**
6610 * force attack mode to be bruteforce
6611 */
6612
6613 attack_mode = ATTACK_MODE_BF;
6614 attack_kern = ATTACK_KERN_BF;
6615
6616 if (runtime_chgd == 0)
6617 {
6618 runtime = 8;
6619
6620 if (benchmark_mode == 1) runtime = 17;
6621
6622 data.runtime = runtime;
6623 }
6624 }
6625
6626 /**
6627 * config
6628 */
6629
6630 uint hash_type = 0;
6631 uint salt_type = 0;
6632 uint attack_exec = 0;
6633 uint opts_type = 0;
6634 uint kern_type = 0;
6635 uint dgst_size = 0;
6636 uint esalt_size = 0;
6637 uint opti_type = 0;
6638 uint dgst_pos0 = -1;
6639 uint dgst_pos1 = -1;
6640 uint dgst_pos2 = -1;
6641 uint dgst_pos3 = -1;
6642
6643 int (*parse_func) (char *, uint, hash_t *);
6644 int (*sort_by_digest) (const void *, const void *);
6645
6646 uint algorithm_pos = 0;
6647 uint algorithm_max = 1;
6648
6649 uint *algorithms = default_benchmark_algorithms;
6650
6651 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6652
6653 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6654 {
6655 /*
6656 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6657 * the following algos are skipped entirely
6658 */
6659
6660 if (algorithm_pos > 0)
6661 {
6662 local_free (rd);
6663
6664 rd = init_restore (argc, argv);
6665
6666 data.rd = rd;
6667 }
6668
6669 /**
6670 * update hash_mode in case of multihash benchmark
6671 */
6672
6673 if (benchmark == 1)
6674 {
6675 if (hash_mode_chgd == 0)
6676 {
6677 hash_mode = algorithms[algorithm_pos];
6678
6679 data.hash_mode = hash_mode;
6680 }
6681
6682 quiet = 1;
6683
6684 data.quiet = quiet;
6685 }
6686
6687 switch (hash_mode)
6688 {
6689 case 0: hash_type = HASH_TYPE_MD5;
6690 salt_type = SALT_TYPE_NONE;
6691 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6692 opts_type = OPTS_TYPE_PT_GENERATE_LE
6693 | OPTS_TYPE_PT_ADD80
6694 | OPTS_TYPE_PT_ADDBITS14;
6695 kern_type = KERN_TYPE_MD5;
6696 dgst_size = DGST_SIZE_4_4;
6697 parse_func = md5_parse_hash;
6698 sort_by_digest = sort_by_digest_4_4;
6699 opti_type = OPTI_TYPE_ZERO_BYTE
6700 | OPTI_TYPE_PRECOMPUTE_INIT
6701 | OPTI_TYPE_PRECOMPUTE_MERKLE
6702 | OPTI_TYPE_MEET_IN_MIDDLE
6703 | OPTI_TYPE_EARLY_SKIP
6704 | OPTI_TYPE_NOT_ITERATED
6705 | OPTI_TYPE_NOT_SALTED
6706 | OPTI_TYPE_RAW_HASH;
6707 dgst_pos0 = 0;
6708 dgst_pos1 = 3;
6709 dgst_pos2 = 2;
6710 dgst_pos3 = 1;
6711 break;
6712
6713 case 10: hash_type = HASH_TYPE_MD5;
6714 salt_type = SALT_TYPE_INTERN;
6715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6716 opts_type = OPTS_TYPE_PT_GENERATE_LE
6717 | OPTS_TYPE_ST_ADD80
6718 | OPTS_TYPE_ST_ADDBITS14;
6719 kern_type = KERN_TYPE_MD5_PWSLT;
6720 dgst_size = DGST_SIZE_4_4;
6721 parse_func = md5s_parse_hash;
6722 sort_by_digest = sort_by_digest_4_4;
6723 opti_type = OPTI_TYPE_ZERO_BYTE
6724 | OPTI_TYPE_PRECOMPUTE_INIT
6725 | OPTI_TYPE_PRECOMPUTE_MERKLE
6726 | OPTI_TYPE_MEET_IN_MIDDLE
6727 | OPTI_TYPE_EARLY_SKIP
6728 | OPTI_TYPE_NOT_ITERATED
6729 | OPTI_TYPE_APPENDED_SALT
6730 | OPTI_TYPE_RAW_HASH;
6731 dgst_pos0 = 0;
6732 dgst_pos1 = 3;
6733 dgst_pos2 = 2;
6734 dgst_pos3 = 1;
6735 break;
6736
6737 case 11: hash_type = HASH_TYPE_MD5;
6738 salt_type = SALT_TYPE_INTERN;
6739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6740 opts_type = OPTS_TYPE_PT_GENERATE_LE
6741 | OPTS_TYPE_ST_ADD80
6742 | OPTS_TYPE_ST_ADDBITS14;
6743 kern_type = KERN_TYPE_MD5_PWSLT;
6744 dgst_size = DGST_SIZE_4_4;
6745 parse_func = joomla_parse_hash;
6746 sort_by_digest = sort_by_digest_4_4;
6747 opti_type = OPTI_TYPE_ZERO_BYTE
6748 | OPTI_TYPE_PRECOMPUTE_INIT
6749 | OPTI_TYPE_PRECOMPUTE_MERKLE
6750 | OPTI_TYPE_MEET_IN_MIDDLE
6751 | OPTI_TYPE_EARLY_SKIP
6752 | OPTI_TYPE_NOT_ITERATED
6753 | OPTI_TYPE_APPENDED_SALT
6754 | OPTI_TYPE_RAW_HASH;
6755 dgst_pos0 = 0;
6756 dgst_pos1 = 3;
6757 dgst_pos2 = 2;
6758 dgst_pos3 = 1;
6759 break;
6760
6761 case 12: hash_type = HASH_TYPE_MD5;
6762 salt_type = SALT_TYPE_INTERN;
6763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6764 opts_type = OPTS_TYPE_PT_GENERATE_LE
6765 | OPTS_TYPE_ST_ADD80
6766 | OPTS_TYPE_ST_ADDBITS14;
6767 kern_type = KERN_TYPE_MD5_PWSLT;
6768 dgst_size = DGST_SIZE_4_4;
6769 parse_func = postgresql_parse_hash;
6770 sort_by_digest = sort_by_digest_4_4;
6771 opti_type = OPTI_TYPE_ZERO_BYTE
6772 | OPTI_TYPE_PRECOMPUTE_INIT
6773 | OPTI_TYPE_PRECOMPUTE_MERKLE
6774 | OPTI_TYPE_MEET_IN_MIDDLE
6775 | OPTI_TYPE_EARLY_SKIP
6776 | OPTI_TYPE_NOT_ITERATED
6777 | OPTI_TYPE_APPENDED_SALT
6778 | OPTI_TYPE_RAW_HASH;
6779 dgst_pos0 = 0;
6780 dgst_pos1 = 3;
6781 dgst_pos2 = 2;
6782 dgst_pos3 = 1;
6783 break;
6784
6785 case 20: hash_type = HASH_TYPE_MD5;
6786 salt_type = SALT_TYPE_INTERN;
6787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6788 opts_type = OPTS_TYPE_PT_GENERATE_LE
6789 | OPTS_TYPE_PT_ADD80
6790 | OPTS_TYPE_PT_ADDBITS14;
6791 kern_type = KERN_TYPE_MD5_SLTPW;
6792 dgst_size = DGST_SIZE_4_4;
6793 parse_func = md5s_parse_hash;
6794 sort_by_digest = sort_by_digest_4_4;
6795 opti_type = OPTI_TYPE_ZERO_BYTE
6796 | OPTI_TYPE_PRECOMPUTE_INIT
6797 | OPTI_TYPE_PRECOMPUTE_MERKLE
6798 | OPTI_TYPE_EARLY_SKIP
6799 | OPTI_TYPE_NOT_ITERATED
6800 | OPTI_TYPE_PREPENDED_SALT
6801 | OPTI_TYPE_RAW_HASH;
6802 dgst_pos0 = 0;
6803 dgst_pos1 = 3;
6804 dgst_pos2 = 2;
6805 dgst_pos3 = 1;
6806 break;
6807
6808 case 21: hash_type = HASH_TYPE_MD5;
6809 salt_type = SALT_TYPE_INTERN;
6810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6811 opts_type = OPTS_TYPE_PT_GENERATE_LE
6812 | OPTS_TYPE_PT_ADD80
6813 | OPTS_TYPE_PT_ADDBITS14;
6814 kern_type = KERN_TYPE_MD5_SLTPW;
6815 dgst_size = DGST_SIZE_4_4;
6816 parse_func = osc_parse_hash;
6817 sort_by_digest = sort_by_digest_4_4;
6818 opti_type = OPTI_TYPE_ZERO_BYTE
6819 | OPTI_TYPE_PRECOMPUTE_INIT
6820 | OPTI_TYPE_PRECOMPUTE_MERKLE
6821 | OPTI_TYPE_EARLY_SKIP
6822 | OPTI_TYPE_NOT_ITERATED
6823 | OPTI_TYPE_PREPENDED_SALT
6824 | OPTI_TYPE_RAW_HASH;
6825 dgst_pos0 = 0;
6826 dgst_pos1 = 3;
6827 dgst_pos2 = 2;
6828 dgst_pos3 = 1;
6829 break;
6830
6831 case 22: hash_type = HASH_TYPE_MD5;
6832 salt_type = SALT_TYPE_EMBEDDED;
6833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6834 opts_type = OPTS_TYPE_PT_GENERATE_LE
6835 | OPTS_TYPE_PT_ADD80
6836 | OPTS_TYPE_PT_ADDBITS14;
6837 kern_type = KERN_TYPE_MD5_SLTPW;
6838 dgst_size = DGST_SIZE_4_4;
6839 parse_func = netscreen_parse_hash;
6840 sort_by_digest = sort_by_digest_4_4;
6841 opti_type = OPTI_TYPE_ZERO_BYTE
6842 | OPTI_TYPE_PRECOMPUTE_INIT
6843 | OPTI_TYPE_PRECOMPUTE_MERKLE
6844 | OPTI_TYPE_EARLY_SKIP
6845 | OPTI_TYPE_NOT_ITERATED
6846 | OPTI_TYPE_PREPENDED_SALT
6847 | OPTI_TYPE_RAW_HASH;
6848 dgst_pos0 = 0;
6849 dgst_pos1 = 3;
6850 dgst_pos2 = 2;
6851 dgst_pos3 = 1;
6852 break;
6853
6854 case 23: hash_type = HASH_TYPE_MD5;
6855 salt_type = SALT_TYPE_EMBEDDED;
6856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6857 opts_type = OPTS_TYPE_PT_GENERATE_LE
6858 | OPTS_TYPE_PT_ADD80
6859 | OPTS_TYPE_PT_ADDBITS14;
6860 kern_type = KERN_TYPE_MD5_SLTPW;
6861 dgst_size = DGST_SIZE_4_4;
6862 parse_func = skype_parse_hash;
6863 sort_by_digest = sort_by_digest_4_4;
6864 opti_type = OPTI_TYPE_ZERO_BYTE
6865 | OPTI_TYPE_PRECOMPUTE_INIT
6866 | OPTI_TYPE_PRECOMPUTE_MERKLE
6867 | OPTI_TYPE_EARLY_SKIP
6868 | OPTI_TYPE_NOT_ITERATED
6869 | OPTI_TYPE_PREPENDED_SALT
6870 | OPTI_TYPE_RAW_HASH;
6871 dgst_pos0 = 0;
6872 dgst_pos1 = 3;
6873 dgst_pos2 = 2;
6874 dgst_pos3 = 1;
6875 break;
6876
6877 case 30: hash_type = HASH_TYPE_MD5;
6878 salt_type = SALT_TYPE_INTERN;
6879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6880 opts_type = OPTS_TYPE_PT_GENERATE_LE
6881 | OPTS_TYPE_PT_UNICODE
6882 | OPTS_TYPE_ST_ADD80
6883 | OPTS_TYPE_ST_ADDBITS14;
6884 kern_type = KERN_TYPE_MD5_PWUSLT;
6885 dgst_size = DGST_SIZE_4_4;
6886 parse_func = md5s_parse_hash;
6887 sort_by_digest = sort_by_digest_4_4;
6888 opti_type = OPTI_TYPE_ZERO_BYTE
6889 | OPTI_TYPE_PRECOMPUTE_INIT
6890 | OPTI_TYPE_PRECOMPUTE_MERKLE
6891 | OPTI_TYPE_MEET_IN_MIDDLE
6892 | OPTI_TYPE_EARLY_SKIP
6893 | OPTI_TYPE_NOT_ITERATED
6894 | OPTI_TYPE_APPENDED_SALT
6895 | OPTI_TYPE_RAW_HASH;
6896 dgst_pos0 = 0;
6897 dgst_pos1 = 3;
6898 dgst_pos2 = 2;
6899 dgst_pos3 = 1;
6900 break;
6901
6902 case 40: hash_type = HASH_TYPE_MD5;
6903 salt_type = SALT_TYPE_INTERN;
6904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6905 opts_type = OPTS_TYPE_PT_GENERATE_LE
6906 | OPTS_TYPE_PT_ADD80
6907 | OPTS_TYPE_PT_ADDBITS14
6908 | OPTS_TYPE_PT_UNICODE;
6909 kern_type = KERN_TYPE_MD5_SLTPWU;
6910 dgst_size = DGST_SIZE_4_4;
6911 parse_func = md5s_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 50: 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_ST_ADD80
6931 | OPTS_TYPE_ST_ADDBITS14;
6932 kern_type = KERN_TYPE_HMACMD5_PW;
6933 dgst_size = DGST_SIZE_4_4;
6934 parse_func = hmacmd5_parse_hash;
6935 sort_by_digest = sort_by_digest_4_4;
6936 opti_type = OPTI_TYPE_ZERO_BYTE
6937 | OPTI_TYPE_NOT_ITERATED;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 60: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_PT_ADD80
6949 | OPTS_TYPE_PT_ADDBITS14;
6950 kern_type = KERN_TYPE_HMACMD5_SLT;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = hmacmd5_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_NOT_ITERATED;
6956 dgst_pos0 = 0;
6957 dgst_pos1 = 3;
6958 dgst_pos2 = 2;
6959 dgst_pos3 = 1;
6960 break;
6961
6962 case 100: hash_type = HASH_TYPE_SHA1;
6963 salt_type = SALT_TYPE_NONE;
6964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6965 opts_type = OPTS_TYPE_PT_GENERATE_BE
6966 | OPTS_TYPE_PT_ADD80
6967 | OPTS_TYPE_PT_ADDBITS15;
6968 kern_type = KERN_TYPE_SHA1;
6969 dgst_size = DGST_SIZE_4_5;
6970 parse_func = sha1_parse_hash;
6971 sort_by_digest = sort_by_digest_4_5;
6972 opti_type = OPTI_TYPE_ZERO_BYTE
6973 | OPTI_TYPE_PRECOMPUTE_INIT
6974 | OPTI_TYPE_PRECOMPUTE_MERKLE
6975 | OPTI_TYPE_EARLY_SKIP
6976 | OPTI_TYPE_NOT_ITERATED
6977 | OPTI_TYPE_NOT_SALTED
6978 | OPTI_TYPE_RAW_HASH;
6979 dgst_pos0 = 3;
6980 dgst_pos1 = 4;
6981 dgst_pos2 = 2;
6982 dgst_pos3 = 1;
6983 break;
6984
6985 case 101: hash_type = HASH_TYPE_SHA1;
6986 salt_type = SALT_TYPE_NONE;
6987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6988 opts_type = OPTS_TYPE_PT_GENERATE_BE
6989 | OPTS_TYPE_PT_ADD80
6990 | OPTS_TYPE_PT_ADDBITS15;
6991 kern_type = KERN_TYPE_SHA1;
6992 dgst_size = DGST_SIZE_4_5;
6993 parse_func = sha1b64_parse_hash;
6994 sort_by_digest = sort_by_digest_4_5;
6995 opti_type = OPTI_TYPE_ZERO_BYTE
6996 | OPTI_TYPE_PRECOMPUTE_INIT
6997 | OPTI_TYPE_PRECOMPUTE_MERKLE
6998 | OPTI_TYPE_EARLY_SKIP
6999 | OPTI_TYPE_NOT_ITERATED
7000 | OPTI_TYPE_NOT_SALTED
7001 | OPTI_TYPE_RAW_HASH;
7002 dgst_pos0 = 3;
7003 dgst_pos1 = 4;
7004 dgst_pos2 = 2;
7005 dgst_pos3 = 1;
7006 break;
7007
7008 case 110: hash_type = HASH_TYPE_SHA1;
7009 salt_type = SALT_TYPE_INTERN;
7010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7011 opts_type = OPTS_TYPE_PT_GENERATE_BE
7012 | OPTS_TYPE_ST_ADD80
7013 | OPTS_TYPE_ST_ADDBITS15;
7014 kern_type = KERN_TYPE_SHA1_PWSLT;
7015 dgst_size = DGST_SIZE_4_5;
7016 parse_func = sha1s_parse_hash;
7017 sort_by_digest = sort_by_digest_4_5;
7018 opti_type = OPTI_TYPE_ZERO_BYTE
7019 | OPTI_TYPE_PRECOMPUTE_INIT
7020 | OPTI_TYPE_PRECOMPUTE_MERKLE
7021 | OPTI_TYPE_EARLY_SKIP
7022 | OPTI_TYPE_NOT_ITERATED
7023 | OPTI_TYPE_APPENDED_SALT
7024 | OPTI_TYPE_RAW_HASH;
7025 dgst_pos0 = 3;
7026 dgst_pos1 = 4;
7027 dgst_pos2 = 2;
7028 dgst_pos3 = 1;
7029 break;
7030
7031 case 111: hash_type = HASH_TYPE_SHA1;
7032 salt_type = SALT_TYPE_EMBEDDED;
7033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7034 opts_type = OPTS_TYPE_PT_GENERATE_BE
7035 | OPTS_TYPE_ST_ADD80
7036 | OPTS_TYPE_ST_ADDBITS15;
7037 kern_type = KERN_TYPE_SHA1_PWSLT;
7038 dgst_size = DGST_SIZE_4_5;
7039 parse_func = sha1b64s_parse_hash;
7040 sort_by_digest = sort_by_digest_4_5;
7041 opti_type = OPTI_TYPE_ZERO_BYTE
7042 | OPTI_TYPE_PRECOMPUTE_INIT
7043 | OPTI_TYPE_PRECOMPUTE_MERKLE
7044 | OPTI_TYPE_EARLY_SKIP
7045 | OPTI_TYPE_NOT_ITERATED
7046 | OPTI_TYPE_APPENDED_SALT
7047 | OPTI_TYPE_RAW_HASH;
7048 dgst_pos0 = 3;
7049 dgst_pos1 = 4;
7050 dgst_pos2 = 2;
7051 dgst_pos3 = 1;
7052 break;
7053
7054 case 112: hash_type = HASH_TYPE_SHA1;
7055 salt_type = SALT_TYPE_INTERN;
7056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7057 opts_type = OPTS_TYPE_PT_GENERATE_BE
7058 | OPTS_TYPE_ST_ADD80
7059 | OPTS_TYPE_ST_ADDBITS15
7060 | OPTS_TYPE_ST_HEX;
7061 kern_type = KERN_TYPE_SHA1_PWSLT;
7062 dgst_size = DGST_SIZE_4_5;
7063 parse_func = oracles_parse_hash;
7064 sort_by_digest = sort_by_digest_4_5;
7065 opti_type = OPTI_TYPE_ZERO_BYTE
7066 | OPTI_TYPE_PRECOMPUTE_INIT
7067 | OPTI_TYPE_PRECOMPUTE_MERKLE
7068 | OPTI_TYPE_EARLY_SKIP
7069 | OPTI_TYPE_NOT_ITERATED
7070 | OPTI_TYPE_APPENDED_SALT
7071 | OPTI_TYPE_RAW_HASH;
7072 dgst_pos0 = 3;
7073 dgst_pos1 = 4;
7074 dgst_pos2 = 2;
7075 dgst_pos3 = 1;
7076 break;
7077
7078 case 120: hash_type = HASH_TYPE_SHA1;
7079 salt_type = SALT_TYPE_INTERN;
7080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7081 opts_type = OPTS_TYPE_PT_GENERATE_BE
7082 | OPTS_TYPE_PT_ADD80
7083 | OPTS_TYPE_PT_ADDBITS15;
7084 kern_type = KERN_TYPE_SHA1_SLTPW;
7085 dgst_size = DGST_SIZE_4_5;
7086 parse_func = sha1s_parse_hash;
7087 sort_by_digest = sort_by_digest_4_5;
7088 opti_type = OPTI_TYPE_ZERO_BYTE
7089 | OPTI_TYPE_PRECOMPUTE_INIT
7090 | OPTI_TYPE_PRECOMPUTE_MERKLE
7091 | OPTI_TYPE_EARLY_SKIP
7092 | OPTI_TYPE_NOT_ITERATED
7093 | OPTI_TYPE_PREPENDED_SALT
7094 | OPTI_TYPE_RAW_HASH;
7095 dgst_pos0 = 3;
7096 dgst_pos1 = 4;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 121: hash_type = HASH_TYPE_SHA1;
7102 salt_type = SALT_TYPE_INTERN;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_BE
7105 | OPTS_TYPE_PT_ADD80
7106 | OPTS_TYPE_PT_ADDBITS15
7107 | OPTS_TYPE_ST_LOWER;
7108 kern_type = KERN_TYPE_SHA1_SLTPW;
7109 dgst_size = DGST_SIZE_4_5;
7110 parse_func = smf_parse_hash;
7111 sort_by_digest = sort_by_digest_4_5;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_PRECOMPUTE_INIT
7114 | OPTI_TYPE_PRECOMPUTE_MERKLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_PREPENDED_SALT
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 3;
7120 dgst_pos1 = 4;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 122: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_EMBEDDED;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_ADD80
7130 | OPTS_TYPE_PT_ADDBITS15
7131 | OPTS_TYPE_ST_HEX;
7132 kern_type = KERN_TYPE_SHA1_SLTPW;
7133 dgst_size = DGST_SIZE_4_5;
7134 parse_func = osx1_parse_hash;
7135 sort_by_digest = sort_by_digest_4_5;
7136 opti_type = OPTI_TYPE_ZERO_BYTE
7137 | OPTI_TYPE_PRECOMPUTE_INIT
7138 | OPTI_TYPE_PRECOMPUTE_MERKLE
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_PREPENDED_SALT
7142 | OPTI_TYPE_RAW_HASH;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 124: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_EMBEDDED;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_SHA1_SLTPW;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = djangosha1_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_PREPENDED_SALT
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 3;
7167 dgst_pos1 = 4;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 130: hash_type = HASH_TYPE_SHA1;
7173 salt_type = SALT_TYPE_INTERN;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_BE
7176 | OPTS_TYPE_PT_UNICODE
7177 | OPTS_TYPE_ST_ADD80
7178 | OPTS_TYPE_ST_ADDBITS15;
7179 kern_type = KERN_TYPE_SHA1_PWUSLT;
7180 dgst_size = DGST_SIZE_4_5;
7181 parse_func = sha1s_parse_hash;
7182 sort_by_digest = sort_by_digest_4_5;
7183 opti_type = OPTI_TYPE_ZERO_BYTE
7184 | OPTI_TYPE_PRECOMPUTE_INIT
7185 | OPTI_TYPE_PRECOMPUTE_MERKLE
7186 | OPTI_TYPE_EARLY_SKIP
7187 | OPTI_TYPE_NOT_ITERATED
7188 | OPTI_TYPE_APPENDED_SALT
7189 | OPTI_TYPE_RAW_HASH;
7190 dgst_pos0 = 3;
7191 dgst_pos1 = 4;
7192 dgst_pos2 = 2;
7193 dgst_pos3 = 1;
7194 break;
7195
7196 case 131: hash_type = HASH_TYPE_SHA1;
7197 salt_type = SALT_TYPE_EMBEDDED;
7198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7199 opts_type = OPTS_TYPE_PT_GENERATE_BE
7200 | OPTS_TYPE_PT_UNICODE
7201 | OPTS_TYPE_PT_UPPER
7202 | OPTS_TYPE_ST_ADD80
7203 | OPTS_TYPE_ST_ADDBITS15
7204 | OPTS_TYPE_ST_HEX;
7205 kern_type = KERN_TYPE_SHA1_PWUSLT;
7206 dgst_size = DGST_SIZE_4_5;
7207 parse_func = mssql2000_parse_hash;
7208 sort_by_digest = sort_by_digest_4_5;
7209 opti_type = OPTI_TYPE_ZERO_BYTE
7210 | OPTI_TYPE_PRECOMPUTE_INIT
7211 | OPTI_TYPE_PRECOMPUTE_MERKLE
7212 | OPTI_TYPE_EARLY_SKIP
7213 | OPTI_TYPE_NOT_ITERATED
7214 | OPTI_TYPE_APPENDED_SALT
7215 | OPTI_TYPE_RAW_HASH;
7216 dgst_pos0 = 3;
7217 dgst_pos1 = 4;
7218 dgst_pos2 = 2;
7219 dgst_pos3 = 1;
7220 break;
7221
7222 case 132: hash_type = HASH_TYPE_SHA1;
7223 salt_type = SALT_TYPE_EMBEDDED;
7224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7225 opts_type = OPTS_TYPE_PT_GENERATE_BE
7226 | OPTS_TYPE_PT_UNICODE
7227 | OPTS_TYPE_ST_ADD80
7228 | OPTS_TYPE_ST_ADDBITS15
7229 | OPTS_TYPE_ST_HEX;
7230 kern_type = KERN_TYPE_SHA1_PWUSLT;
7231 dgst_size = DGST_SIZE_4_5;
7232 parse_func = mssql2005_parse_hash;
7233 sort_by_digest = sort_by_digest_4_5;
7234 opti_type = OPTI_TYPE_ZERO_BYTE
7235 | OPTI_TYPE_PRECOMPUTE_INIT
7236 | OPTI_TYPE_PRECOMPUTE_MERKLE
7237 | OPTI_TYPE_EARLY_SKIP
7238 | OPTI_TYPE_NOT_ITERATED
7239 | OPTI_TYPE_APPENDED_SALT
7240 | OPTI_TYPE_RAW_HASH;
7241 dgst_pos0 = 3;
7242 dgst_pos1 = 4;
7243 dgst_pos2 = 2;
7244 dgst_pos3 = 1;
7245 break;
7246
7247 case 133: hash_type = HASH_TYPE_SHA1;
7248 salt_type = SALT_TYPE_EMBEDDED;
7249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7250 opts_type = OPTS_TYPE_PT_GENERATE_BE
7251 | OPTS_TYPE_PT_UNICODE
7252 | OPTS_TYPE_ST_ADD80
7253 | OPTS_TYPE_ST_ADDBITS15;
7254 kern_type = KERN_TYPE_SHA1_PWUSLT;
7255 dgst_size = DGST_SIZE_4_5;
7256 parse_func = peoplesoft_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 140: hash_type = HASH_TYPE_SHA1;
7272 salt_type = SALT_TYPE_INTERN;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_BE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS15
7277 | OPTS_TYPE_PT_UNICODE;
7278 kern_type = KERN_TYPE_SHA1_SLTPWU;
7279 dgst_size = DGST_SIZE_4_5;
7280 parse_func = sha1s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_5;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 3;
7290 dgst_pos1 = 4;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 141: hash_type = HASH_TYPE_SHA1;
7296 salt_type = SALT_TYPE_EMBEDDED;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_BE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS15
7301 | OPTS_TYPE_PT_UNICODE
7302 | OPTS_TYPE_ST_BASE64;
7303 kern_type = KERN_TYPE_SHA1_SLTPWU;
7304 dgst_size = DGST_SIZE_4_5;
7305 parse_func = episerver_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_PREPENDED_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 150: 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_ST_ADD80
7325 | OPTS_TYPE_ST_ADDBITS15;
7326 kern_type = KERN_TYPE_HMACSHA1_PW;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = hmacsha1_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_NOT_ITERATED;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 4;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 160: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_INTERN;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15;
7344 kern_type = KERN_TYPE_HMACSHA1_SLT;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = hmacsha1_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_NOT_ITERATED;
7350 dgst_pos0 = 3;
7351 dgst_pos1 = 4;
7352 dgst_pos2 = 2;
7353 dgst_pos3 = 1;
7354 break;
7355
7356 case 190: hash_type = HASH_TYPE_SHA1;
7357 salt_type = SALT_TYPE_NONE;
7358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7359 opts_type = OPTS_TYPE_PT_GENERATE_BE
7360 | OPTS_TYPE_PT_ADD80
7361 | OPTS_TYPE_PT_ADDBITS15;
7362 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = sha1linkedin_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_EARLY_SKIP
7369 | OPTI_TYPE_NOT_ITERATED
7370 | OPTI_TYPE_NOT_SALTED;
7371 dgst_pos0 = 0;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 3;
7374 dgst_pos3 = 2;
7375 break;
7376
7377 case 200: hash_type = HASH_TYPE_MYSQL;
7378 salt_type = SALT_TYPE_NONE;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = 0;
7381 kern_type = KERN_TYPE_MYSQL;
7382 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7383 parse_func = mysql323_parse_hash;
7384 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7385 opti_type = OPTI_TYPE_ZERO_BYTE;
7386 dgst_pos0 = 0;
7387 dgst_pos1 = 1;
7388 dgst_pos2 = 2;
7389 dgst_pos3 = 3;
7390 break;
7391
7392 case 300: hash_type = HASH_TYPE_SHA1;
7393 salt_type = SALT_TYPE_NONE;
7394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7395 opts_type = OPTS_TYPE_PT_GENERATE_BE
7396 | OPTS_TYPE_PT_ADD80
7397 | OPTS_TYPE_PT_ADDBITS15;
7398 kern_type = KERN_TYPE_MYSQL41;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = sha1_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_NOT_SALTED;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 4;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 1;
7412 break;
7413
7414 case 400: hash_type = HASH_TYPE_MD5;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7418 kern_type = KERN_TYPE_PHPASS;
7419 dgst_size = DGST_SIZE_4_4;
7420 parse_func = phpass_parse_hash;
7421 sort_by_digest = sort_by_digest_4_4;
7422 opti_type = OPTI_TYPE_ZERO_BYTE;
7423 dgst_pos0 = 0;
7424 dgst_pos1 = 1;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 3;
7427 break;
7428
7429 case 500: hash_type = HASH_TYPE_MD5;
7430 salt_type = SALT_TYPE_EMBEDDED;
7431 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7433 kern_type = KERN_TYPE_MD5CRYPT;
7434 dgst_size = DGST_SIZE_4_4;
7435 parse_func = md5crypt_parse_hash;
7436 sort_by_digest = sort_by_digest_4_4;
7437 opti_type = OPTI_TYPE_ZERO_BYTE;
7438 dgst_pos0 = 0;
7439 dgst_pos1 = 1;
7440 dgst_pos2 = 2;
7441 dgst_pos3 = 3;
7442 break;
7443
7444 case 501: hash_type = HASH_TYPE_MD5;
7445 salt_type = SALT_TYPE_EMBEDDED;
7446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7447 opts_type = OPTS_TYPE_PT_GENERATE_LE
7448 | OPTS_TYPE_HASH_COPY;
7449 kern_type = KERN_TYPE_MD5CRYPT;
7450 dgst_size = DGST_SIZE_4_4;
7451 parse_func = juniper_parse_hash;
7452 sort_by_digest = sort_by_digest_4_4;
7453 opti_type = OPTI_TYPE_ZERO_BYTE;
7454 dgst_pos0 = 0;
7455 dgst_pos1 = 1;
7456 dgst_pos2 = 2;
7457 dgst_pos3 = 3;
7458 break;
7459
7460 case 900: hash_type = HASH_TYPE_MD4;
7461 salt_type = SALT_TYPE_NONE;
7462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7463 opts_type = OPTS_TYPE_PT_GENERATE_LE
7464 | OPTS_TYPE_PT_ADD80
7465 | OPTS_TYPE_PT_ADDBITS14;
7466 kern_type = KERN_TYPE_MD4;
7467 dgst_size = DGST_SIZE_4_4;
7468 parse_func = md4_parse_hash;
7469 sort_by_digest = sort_by_digest_4_4;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_PRECOMPUTE_INIT
7472 | OPTI_TYPE_PRECOMPUTE_MERKLE
7473 | OPTI_TYPE_MEET_IN_MIDDLE
7474 | OPTI_TYPE_EARLY_SKIP
7475 | OPTI_TYPE_NOT_ITERATED
7476 | OPTI_TYPE_NOT_SALTED
7477 | OPTI_TYPE_RAW_HASH;
7478 dgst_pos0 = 0;
7479 dgst_pos1 = 3;
7480 dgst_pos2 = 2;
7481 dgst_pos3 = 1;
7482 break;
7483
7484 case 1000: hash_type = HASH_TYPE_MD4;
7485 salt_type = SALT_TYPE_NONE;
7486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7487 opts_type = OPTS_TYPE_PT_GENERATE_LE
7488 | OPTS_TYPE_PT_ADD80
7489 | OPTS_TYPE_PT_ADDBITS14
7490 | OPTS_TYPE_PT_UNICODE;
7491 kern_type = KERN_TYPE_MD4_PWU;
7492 dgst_size = DGST_SIZE_4_4;
7493 parse_func = md4_parse_hash;
7494 sort_by_digest = sort_by_digest_4_4;
7495 opti_type = OPTI_TYPE_ZERO_BYTE
7496 | OPTI_TYPE_PRECOMPUTE_INIT
7497 | OPTI_TYPE_PRECOMPUTE_MERKLE
7498 | OPTI_TYPE_MEET_IN_MIDDLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_NOT_SALTED
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 0;
7504 dgst_pos1 = 3;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 1;
7507 break;
7508
7509 case 1100: hash_type = HASH_TYPE_MD4;
7510 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_PT_UNICODE
7516 | OPTS_TYPE_ST_ADD80
7517 | OPTS_TYPE_ST_UNICODE
7518 | OPTS_TYPE_ST_LOWER;
7519 kern_type = KERN_TYPE_MD44_PWUSLT;
7520 dgst_size = DGST_SIZE_4_4;
7521 parse_func = dcc_parse_hash;
7522 sort_by_digest = sort_by_digest_4_4;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED;
7528 dgst_pos0 = 0;
7529 dgst_pos1 = 3;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 1400: hash_type = HASH_TYPE_SHA256;
7535 salt_type = SALT_TYPE_NONE;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_BE
7538 | OPTS_TYPE_PT_ADD80
7539 | OPTS_TYPE_PT_ADDBITS15;
7540 kern_type = KERN_TYPE_SHA256;
7541 dgst_size = DGST_SIZE_4_8;
7542 parse_func = sha256_parse_hash;
7543 sort_by_digest = sort_by_digest_4_8;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_EARLY_SKIP
7548 | OPTI_TYPE_NOT_ITERATED
7549 | OPTI_TYPE_NOT_SALTED
7550 | OPTI_TYPE_RAW_HASH;
7551 dgst_pos0 = 3;
7552 dgst_pos1 = 7;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 6;
7555 break;
7556
7557 case 1410: hash_type = HASH_TYPE_SHA256;
7558 salt_type = SALT_TYPE_INTERN;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_BE
7561 | OPTS_TYPE_ST_ADD80
7562 | OPTS_TYPE_ST_ADDBITS15;
7563 kern_type = KERN_TYPE_SHA256_PWSLT;
7564 dgst_size = DGST_SIZE_4_8;
7565 parse_func = sha256s_parse_hash;
7566 sort_by_digest = sort_by_digest_4_8;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_EARLY_SKIP
7571 | OPTI_TYPE_NOT_ITERATED
7572 | OPTI_TYPE_APPENDED_SALT
7573 | OPTI_TYPE_RAW_HASH;
7574 dgst_pos0 = 3;
7575 dgst_pos1 = 7;
7576 dgst_pos2 = 2;
7577 dgst_pos3 = 6;
7578 break;
7579
7580 case 1420: hash_type = HASH_TYPE_SHA256;
7581 salt_type = SALT_TYPE_INTERN;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = OPTS_TYPE_PT_GENERATE_BE
7584 | OPTS_TYPE_PT_ADD80
7585 | OPTS_TYPE_PT_ADDBITS15;
7586 kern_type = KERN_TYPE_SHA256_SLTPW;
7587 dgst_size = DGST_SIZE_4_8;
7588 parse_func = sha256s_parse_hash;
7589 sort_by_digest = sort_by_digest_4_8;
7590 opti_type = OPTI_TYPE_ZERO_BYTE
7591 | OPTI_TYPE_PRECOMPUTE_INIT
7592 | OPTI_TYPE_PRECOMPUTE_MERKLE
7593 | OPTI_TYPE_EARLY_SKIP
7594 | OPTI_TYPE_NOT_ITERATED
7595 | OPTI_TYPE_PREPENDED_SALT
7596 | OPTI_TYPE_RAW_HASH;
7597 dgst_pos0 = 3;
7598 dgst_pos1 = 7;
7599 dgst_pos2 = 2;
7600 dgst_pos3 = 6;
7601 break;
7602
7603 case 1421: hash_type = HASH_TYPE_SHA256;
7604 salt_type = SALT_TYPE_EMBEDDED;
7605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7606 opts_type = OPTS_TYPE_PT_GENERATE_BE
7607 | OPTS_TYPE_PT_ADD80
7608 | OPTS_TYPE_PT_ADDBITS15;
7609 kern_type = KERN_TYPE_SHA256_SLTPW;
7610 dgst_size = DGST_SIZE_4_8;
7611 parse_func = hmailserver_parse_hash;
7612 sort_by_digest = sort_by_digest_4_8;
7613 opti_type = OPTI_TYPE_ZERO_BYTE
7614 | OPTI_TYPE_PRECOMPUTE_INIT
7615 | OPTI_TYPE_PRECOMPUTE_MERKLE
7616 | OPTI_TYPE_EARLY_SKIP
7617 | OPTI_TYPE_NOT_ITERATED
7618 | OPTI_TYPE_PREPENDED_SALT
7619 | OPTI_TYPE_RAW_HASH;
7620 dgst_pos0 = 3;
7621 dgst_pos1 = 7;
7622 dgst_pos2 = 2;
7623 dgst_pos3 = 6;
7624 break;
7625
7626 case 1430: hash_type = HASH_TYPE_SHA256;
7627 salt_type = SALT_TYPE_INTERN;
7628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7629 opts_type = OPTS_TYPE_PT_GENERATE_BE
7630 | OPTS_TYPE_PT_UNICODE
7631 | OPTS_TYPE_ST_ADD80
7632 | OPTS_TYPE_ST_ADDBITS15;
7633 kern_type = KERN_TYPE_SHA256_PWUSLT;
7634 dgst_size = DGST_SIZE_4_8;
7635 parse_func = sha256s_parse_hash;
7636 sort_by_digest = sort_by_digest_4_8;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_PRECOMPUTE_INIT
7639 | OPTI_TYPE_PRECOMPUTE_MERKLE
7640 | OPTI_TYPE_EARLY_SKIP
7641 | OPTI_TYPE_NOT_ITERATED
7642 | OPTI_TYPE_APPENDED_SALT
7643 | OPTI_TYPE_RAW_HASH;
7644 dgst_pos0 = 3;
7645 dgst_pos1 = 7;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 6;
7648 break;
7649
7650 case 1440: hash_type = HASH_TYPE_SHA256;
7651 salt_type = SALT_TYPE_INTERN;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_BE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS15
7656 | OPTS_TYPE_PT_UNICODE;
7657 kern_type = KERN_TYPE_SHA256_SLTPWU;
7658 dgst_size = DGST_SIZE_4_8;
7659 parse_func = sha256s_parse_hash;
7660 sort_by_digest = sort_by_digest_4_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_PREPENDED_SALT
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 3;
7669 dgst_pos1 = 7;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 6;
7672 break;
7673
7674 case 1441: hash_type = HASH_TYPE_SHA256;
7675 salt_type = SALT_TYPE_EMBEDDED;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS15
7680 | OPTS_TYPE_PT_UNICODE
7681 | OPTS_TYPE_ST_BASE64;
7682 kern_type = KERN_TYPE_SHA256_SLTPWU;
7683 dgst_size = DGST_SIZE_4_8;
7684 parse_func = episerver4_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_PREPENDED_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 1450: 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_ST_ADD80;
7704 kern_type = KERN_TYPE_HMACSHA256_PW;
7705 dgst_size = DGST_SIZE_4_8;
7706 parse_func = hmacsha256_parse_hash;
7707 sort_by_digest = sort_by_digest_4_8;
7708 opti_type = OPTI_TYPE_ZERO_BYTE
7709 | OPTI_TYPE_NOT_ITERATED;
7710 dgst_pos0 = 3;
7711 dgst_pos1 = 7;
7712 dgst_pos2 = 2;
7713 dgst_pos3 = 6;
7714 break;
7715
7716 case 1460: hash_type = HASH_TYPE_SHA256;
7717 salt_type = SALT_TYPE_INTERN;
7718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7719 opts_type = OPTS_TYPE_PT_GENERATE_BE
7720 | OPTS_TYPE_PT_ADD80
7721 | OPTS_TYPE_PT_ADDBITS15;
7722 kern_type = KERN_TYPE_HMACSHA256_SLT;
7723 dgst_size = DGST_SIZE_4_8;
7724 parse_func = hmacsha256_parse_hash;
7725 sort_by_digest = sort_by_digest_4_8;
7726 opti_type = OPTI_TYPE_ZERO_BYTE
7727 | OPTI_TYPE_NOT_ITERATED;
7728 dgst_pos0 = 3;
7729 dgst_pos1 = 7;
7730 dgst_pos2 = 2;
7731 dgst_pos3 = 6;
7732 break;
7733
7734 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7735 salt_type = SALT_TYPE_EMBEDDED;
7736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7737 opts_type = OPTS_TYPE_PT_GENERATE_LE
7738 | OPTS_TYPE_PT_BITSLICE;
7739 kern_type = KERN_TYPE_DESCRYPT;
7740 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7741 parse_func = descrypt_parse_hash;
7742 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7743 opti_type = OPTI_TYPE_ZERO_BYTE
7744 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7745 dgst_pos0 = 0;
7746 dgst_pos1 = 1;
7747 dgst_pos2 = 2;
7748 dgst_pos3 = 3;
7749 break;
7750
7751 case 1600: hash_type = HASH_TYPE_MD5;
7752 salt_type = SALT_TYPE_EMBEDDED;
7753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7755 kern_type = KERN_TYPE_APR1CRYPT;
7756 dgst_size = DGST_SIZE_4_4;
7757 parse_func = md5apr1_parse_hash;
7758 sort_by_digest = sort_by_digest_4_4;
7759 opti_type = OPTI_TYPE_ZERO_BYTE;
7760 dgst_pos0 = 0;
7761 dgst_pos1 = 1;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 3;
7764 break;
7765
7766 case 1700: hash_type = HASH_TYPE_SHA512;
7767 salt_type = SALT_TYPE_NONE;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_ADD80
7771 | OPTS_TYPE_PT_ADDBITS15;
7772 kern_type = KERN_TYPE_SHA512;
7773 dgst_size = DGST_SIZE_8_8;
7774 parse_func = sha512_parse_hash;
7775 sort_by_digest = sort_by_digest_8_8;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_NOT_SALTED
7782 | OPTI_TYPE_USES_BITS_64
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 14;
7785 dgst_pos1 = 15;
7786 dgst_pos2 = 6;
7787 dgst_pos3 = 7;
7788 break;
7789
7790 case 1710: hash_type = HASH_TYPE_SHA512;
7791 salt_type = SALT_TYPE_INTERN;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_ST_ADD80
7795 | OPTS_TYPE_ST_ADDBITS15;
7796 kern_type = KERN_TYPE_SHA512_PWSLT;
7797 dgst_size = DGST_SIZE_8_8;
7798 parse_func = sha512s_parse_hash;
7799 sort_by_digest = sort_by_digest_8_8;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_APPENDED_SALT
7806 | OPTI_TYPE_USES_BITS_64
7807 | OPTI_TYPE_RAW_HASH;
7808 dgst_pos0 = 14;
7809 dgst_pos1 = 15;
7810 dgst_pos2 = 6;
7811 dgst_pos3 = 7;
7812 break;
7813
7814 case 1711: hash_type = HASH_TYPE_SHA512;
7815 salt_type = SALT_TYPE_EMBEDDED;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_BE
7818 | OPTS_TYPE_ST_ADD80
7819 | OPTS_TYPE_ST_ADDBITS15;
7820 kern_type = KERN_TYPE_SHA512_PWSLT;
7821 dgst_size = DGST_SIZE_8_8;
7822 parse_func = sha512b64s_parse_hash;
7823 sort_by_digest = sort_by_digest_8_8;
7824 opti_type = OPTI_TYPE_ZERO_BYTE
7825 | OPTI_TYPE_PRECOMPUTE_INIT
7826 | OPTI_TYPE_PRECOMPUTE_MERKLE
7827 | OPTI_TYPE_EARLY_SKIP
7828 | OPTI_TYPE_NOT_ITERATED
7829 | OPTI_TYPE_APPENDED_SALT
7830 | OPTI_TYPE_USES_BITS_64
7831 | OPTI_TYPE_RAW_HASH;
7832 dgst_pos0 = 14;
7833 dgst_pos1 = 15;
7834 dgst_pos2 = 6;
7835 dgst_pos3 = 7;
7836 break;
7837
7838 case 1720: hash_type = HASH_TYPE_SHA512;
7839 salt_type = SALT_TYPE_INTERN;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_BE
7842 | OPTS_TYPE_PT_ADD80
7843 | OPTS_TYPE_PT_ADDBITS15;
7844 kern_type = KERN_TYPE_SHA512_SLTPW;
7845 dgst_size = DGST_SIZE_8_8;
7846 parse_func = sha512s_parse_hash;
7847 sort_by_digest = sort_by_digest_8_8;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_EARLY_SKIP
7852 | OPTI_TYPE_NOT_ITERATED
7853 | OPTI_TYPE_PREPENDED_SALT
7854 | OPTI_TYPE_USES_BITS_64
7855 | OPTI_TYPE_RAW_HASH;
7856 dgst_pos0 = 14;
7857 dgst_pos1 = 15;
7858 dgst_pos2 = 6;
7859 dgst_pos3 = 7;
7860 break;
7861
7862 case 1722: hash_type = HASH_TYPE_SHA512;
7863 salt_type = SALT_TYPE_EMBEDDED;
7864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865 opts_type = OPTS_TYPE_PT_GENERATE_BE
7866 | OPTS_TYPE_PT_ADD80
7867 | OPTS_TYPE_PT_ADDBITS15
7868 | OPTS_TYPE_ST_HEX;
7869 kern_type = KERN_TYPE_SHA512_SLTPW;
7870 dgst_size = DGST_SIZE_8_8;
7871 parse_func = osx512_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_PREPENDED_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 1730: 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_UNICODE
7892 | OPTS_TYPE_ST_ADD80
7893 | OPTS_TYPE_ST_ADDBITS15;
7894 kern_type = KERN_TYPE_SHA512_PWSLTU;
7895 dgst_size = DGST_SIZE_8_8;
7896 parse_func = sha512s_parse_hash;
7897 sort_by_digest = sort_by_digest_8_8;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP
7902 | OPTI_TYPE_NOT_ITERATED
7903 | OPTI_TYPE_APPENDED_SALT
7904 | OPTI_TYPE_USES_BITS_64
7905 | OPTI_TYPE_RAW_HASH;
7906 dgst_pos0 = 14;
7907 dgst_pos1 = 15;
7908 dgst_pos2 = 6;
7909 dgst_pos3 = 7;
7910 break;
7911
7912 case 1731: hash_type = HASH_TYPE_SHA512;
7913 salt_type = SALT_TYPE_EMBEDDED;
7914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_BE
7916 | OPTS_TYPE_PT_UNICODE
7917 | OPTS_TYPE_ST_ADD80
7918 | OPTS_TYPE_ST_ADDBITS15
7919 | OPTS_TYPE_ST_HEX;
7920 kern_type = KERN_TYPE_SHA512_PWSLTU;
7921 dgst_size = DGST_SIZE_8_8;
7922 parse_func = mssql2012_parse_hash;
7923 sort_by_digest = sort_by_digest_8_8;
7924 opti_type = OPTI_TYPE_ZERO_BYTE
7925 | OPTI_TYPE_PRECOMPUTE_INIT
7926 | OPTI_TYPE_PRECOMPUTE_MERKLE
7927 | OPTI_TYPE_EARLY_SKIP
7928 | OPTI_TYPE_NOT_ITERATED
7929 | OPTI_TYPE_APPENDED_SALT
7930 | OPTI_TYPE_USES_BITS_64
7931 | OPTI_TYPE_RAW_HASH;
7932 dgst_pos0 = 14;
7933 dgst_pos1 = 15;
7934 dgst_pos2 = 6;
7935 dgst_pos3 = 7;
7936 break;
7937
7938 case 1740: hash_type = HASH_TYPE_SHA512;
7939 salt_type = SALT_TYPE_INTERN;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_BE
7942 | OPTS_TYPE_PT_ADD80
7943 | OPTS_TYPE_PT_ADDBITS15
7944 | OPTS_TYPE_PT_UNICODE;
7945 kern_type = KERN_TYPE_SHA512_SLTPWU;
7946 dgst_size = DGST_SIZE_8_8;
7947 parse_func = sha512s_parse_hash;
7948 sort_by_digest = sort_by_digest_8_8;
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_INIT
7951 | OPTI_TYPE_PRECOMPUTE_MERKLE
7952 | OPTI_TYPE_EARLY_SKIP
7953 | OPTI_TYPE_NOT_ITERATED
7954 | OPTI_TYPE_PREPENDED_SALT
7955 | OPTI_TYPE_USES_BITS_64
7956 | OPTI_TYPE_RAW_HASH;
7957 dgst_pos0 = 14;
7958 dgst_pos1 = 15;
7959 dgst_pos2 = 6;
7960 dgst_pos3 = 7;
7961 break;
7962
7963 case 1750: hash_type = HASH_TYPE_SHA512;
7964 salt_type = SALT_TYPE_INTERN;
7965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7966 opts_type = OPTS_TYPE_PT_GENERATE_BE
7967 | OPTS_TYPE_ST_ADD80;
7968 kern_type = KERN_TYPE_HMACSHA512_PW;
7969 dgst_size = DGST_SIZE_8_8;
7970 parse_func = hmacsha512_parse_hash;
7971 sort_by_digest = sort_by_digest_8_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_USES_BITS_64
7974 | OPTI_TYPE_NOT_ITERATED;
7975 dgst_pos0 = 14;
7976 dgst_pos1 = 15;
7977 dgst_pos2 = 6;
7978 dgst_pos3 = 7;
7979 break;
7980
7981 case 1760: hash_type = HASH_TYPE_SHA512;
7982 salt_type = SALT_TYPE_INTERN;
7983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7984 opts_type = OPTS_TYPE_PT_GENERATE_BE
7985 | OPTS_TYPE_PT_ADD80
7986 | OPTS_TYPE_PT_ADDBITS15;
7987 kern_type = KERN_TYPE_HMACSHA512_SLT;
7988 dgst_size = DGST_SIZE_8_8;
7989 parse_func = hmacsha512_parse_hash;
7990 sort_by_digest = sort_by_digest_8_8;
7991 opti_type = OPTI_TYPE_ZERO_BYTE
7992 | OPTI_TYPE_USES_BITS_64
7993 | OPTI_TYPE_NOT_ITERATED;
7994 dgst_pos0 = 14;
7995 dgst_pos1 = 15;
7996 dgst_pos2 = 6;
7997 dgst_pos3 = 7;
7998 break;
7999
8000 case 1800: hash_type = HASH_TYPE_SHA512;
8001 salt_type = SALT_TYPE_EMBEDDED;
8002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8004 kern_type = KERN_TYPE_SHA512CRYPT;
8005 dgst_size = DGST_SIZE_8_8;
8006 parse_func = sha512crypt_parse_hash;
8007 sort_by_digest = sort_by_digest_8_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_USES_BITS_64;
8010 dgst_pos0 = 0;
8011 dgst_pos1 = 1;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 3;
8014 break;
8015
8016 case 2100: hash_type = HASH_TYPE_DCC2;
8017 salt_type = SALT_TYPE_EMBEDDED;
8018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_ST_LOWER
8021 | OPTS_TYPE_ST_UNICODE;
8022 kern_type = KERN_TYPE_DCC2;
8023 dgst_size = DGST_SIZE_4_4;
8024 parse_func = dcc2_parse_hash;
8025 sort_by_digest = sort_by_digest_4_4;
8026 opti_type = OPTI_TYPE_ZERO_BYTE;
8027 dgst_pos0 = 0;
8028 dgst_pos1 = 1;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 3;
8031 break;
8032
8033 case 2400: hash_type = HASH_TYPE_MD5;
8034 salt_type = SALT_TYPE_NONE;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8037 kern_type = KERN_TYPE_MD5PIX;
8038 dgst_size = DGST_SIZE_4_4;
8039 parse_func = md5pix_parse_hash;
8040 sort_by_digest = sort_by_digest_4_4;
8041 opti_type = OPTI_TYPE_ZERO_BYTE
8042 | OPTI_TYPE_PRECOMPUTE_INIT
8043 | OPTI_TYPE_PRECOMPUTE_MERKLE
8044 | OPTI_TYPE_EARLY_SKIP
8045 | OPTI_TYPE_NOT_ITERATED
8046 | OPTI_TYPE_NOT_SALTED;
8047 dgst_pos0 = 0;
8048 dgst_pos1 = 3;
8049 dgst_pos2 = 2;
8050 dgst_pos3 = 1;
8051 break;
8052
8053 case 2410: hash_type = HASH_TYPE_MD5;
8054 salt_type = SALT_TYPE_INTERN;
8055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8056 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8057 kern_type = KERN_TYPE_MD5ASA;
8058 dgst_size = DGST_SIZE_4_4;
8059 parse_func = md5asa_parse_hash;
8060 sort_by_digest = sort_by_digest_4_4;
8061 opti_type = OPTI_TYPE_ZERO_BYTE
8062 | OPTI_TYPE_PRECOMPUTE_INIT
8063 | OPTI_TYPE_PRECOMPUTE_MERKLE
8064 | OPTI_TYPE_EARLY_SKIP
8065 | OPTI_TYPE_NOT_ITERATED;
8066 dgst_pos0 = 0;
8067 dgst_pos1 = 3;
8068 dgst_pos2 = 2;
8069 dgst_pos3 = 1;
8070 break;
8071
8072 case 2500: hash_type = HASH_TYPE_WPA;
8073 salt_type = SALT_TYPE_EMBEDDED;
8074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8076 kern_type = KERN_TYPE_WPA;
8077 dgst_size = DGST_SIZE_4_4;
8078 parse_func = wpa_parse_hash;
8079 sort_by_digest = sort_by_digest_4_4;
8080 opti_type = OPTI_TYPE_ZERO_BYTE;
8081 dgst_pos0 = 0;
8082 dgst_pos1 = 1;
8083 dgst_pos2 = 2;
8084 dgst_pos3 = 3;
8085 break;
8086
8087 case 2600: hash_type = HASH_TYPE_MD5;
8088 salt_type = SALT_TYPE_VIRTUAL;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_LE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS14
8093 | OPTS_TYPE_ST_ADD80;
8094 kern_type = KERN_TYPE_MD55_PWSLT1;
8095 dgst_size = DGST_SIZE_4_4;
8096 parse_func = md5md5_parse_hash;
8097 sort_by_digest = sort_by_digest_4_4;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_PRECOMPUTE_MERKLE
8101 | OPTI_TYPE_EARLY_SKIP;
8102 dgst_pos0 = 0;
8103 dgst_pos1 = 3;
8104 dgst_pos2 = 2;
8105 dgst_pos3 = 1;
8106 break;
8107
8108 case 2611: hash_type = HASH_TYPE_MD5;
8109 salt_type = SALT_TYPE_INTERN;
8110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8111 opts_type = OPTS_TYPE_PT_GENERATE_LE
8112 | OPTS_TYPE_PT_ADD80
8113 | OPTS_TYPE_PT_ADDBITS14
8114 | OPTS_TYPE_ST_ADD80;
8115 kern_type = KERN_TYPE_MD55_PWSLT1;
8116 dgst_size = DGST_SIZE_4_4;
8117 parse_func = vb3_parse_hash;
8118 sort_by_digest = sort_by_digest_4_4;
8119 opti_type = OPTI_TYPE_ZERO_BYTE
8120 | OPTI_TYPE_PRECOMPUTE_INIT
8121 | OPTI_TYPE_PRECOMPUTE_MERKLE
8122 | OPTI_TYPE_EARLY_SKIP;
8123 dgst_pos0 = 0;
8124 dgst_pos1 = 3;
8125 dgst_pos2 = 2;
8126 dgst_pos3 = 1;
8127 break;
8128
8129 case 2612: hash_type = HASH_TYPE_MD5;
8130 salt_type = SALT_TYPE_EMBEDDED;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_LE
8133 | OPTS_TYPE_PT_ADD80
8134 | OPTS_TYPE_PT_ADDBITS14
8135 | OPTS_TYPE_ST_ADD80
8136 | OPTS_TYPE_ST_HEX;
8137 kern_type = KERN_TYPE_MD55_PWSLT1;
8138 dgst_size = DGST_SIZE_4_4;
8139 parse_func = phps_parse_hash;
8140 sort_by_digest = sort_by_digest_4_4;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_INIT
8143 | OPTI_TYPE_PRECOMPUTE_MERKLE
8144 | OPTI_TYPE_EARLY_SKIP;
8145 dgst_pos0 = 0;
8146 dgst_pos1 = 3;
8147 dgst_pos2 = 2;
8148 dgst_pos3 = 1;
8149 break;
8150
8151 case 2711: hash_type = HASH_TYPE_MD5;
8152 salt_type = SALT_TYPE_INTERN;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_LE
8155 | OPTS_TYPE_PT_ADD80
8156 | OPTS_TYPE_PT_ADDBITS14
8157 | OPTS_TYPE_ST_ADD80;
8158 kern_type = KERN_TYPE_MD55_PWSLT2;
8159 dgst_size = DGST_SIZE_4_4;
8160 parse_func = vb30_parse_hash;
8161 sort_by_digest = sort_by_digest_4_4;
8162 opti_type = OPTI_TYPE_ZERO_BYTE
8163 | OPTI_TYPE_PRECOMPUTE_INIT
8164 | OPTI_TYPE_EARLY_SKIP;
8165 dgst_pos0 = 0;
8166 dgst_pos1 = 3;
8167 dgst_pos2 = 2;
8168 dgst_pos3 = 1;
8169 break;
8170
8171 case 2811: hash_type = HASH_TYPE_MD5;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_LE
8175 | OPTS_TYPE_PT_ADD80
8176 | OPTS_TYPE_PT_ADDBITS14;
8177 kern_type = KERN_TYPE_MD55_SLTPW;
8178 dgst_size = DGST_SIZE_4_4;
8179 parse_func = ipb2_parse_hash;
8180 sort_by_digest = sort_by_digest_4_4;
8181 opti_type = OPTI_TYPE_ZERO_BYTE
8182 | OPTI_TYPE_PRECOMPUTE_INIT
8183 | OPTI_TYPE_EARLY_SKIP;
8184 dgst_pos0 = 0;
8185 dgst_pos1 = 3;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 1;
8188 break;
8189
8190 case 3000: hash_type = HASH_TYPE_LM;
8191 salt_type = SALT_TYPE_NONE;
8192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8193 opts_type = OPTS_TYPE_PT_GENERATE_LE
8194 | OPTS_TYPE_PT_UPPER
8195 | OPTS_TYPE_PT_BITSLICE;
8196 kern_type = KERN_TYPE_LM;
8197 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8198 parse_func = lm_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 3100: hash_type = HASH_TYPE_ORACLEH;
8209 salt_type = SALT_TYPE_INTERN;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE
8212 | OPTS_TYPE_PT_UPPER
8213 | OPTS_TYPE_ST_UPPER;
8214 kern_type = KERN_TYPE_ORACLEH;
8215 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8216 parse_func = oracleh_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8218 opti_type = OPTI_TYPE_ZERO_BYTE;
8219 dgst_pos0 = 0;
8220 dgst_pos1 = 1;
8221 dgst_pos2 = 2;
8222 dgst_pos3 = 3;
8223 break;
8224
8225 case 3200: hash_type = HASH_TYPE_BCRYPT;
8226 salt_type = SALT_TYPE_EMBEDDED;
8227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_LE
8229 | OPTS_TYPE_ST_GENERATE_LE;
8230 kern_type = KERN_TYPE_BCRYPT;
8231 dgst_size = DGST_SIZE_4_6;
8232 parse_func = bcrypt_parse_hash;
8233 sort_by_digest = sort_by_digest_4_6;
8234 opti_type = OPTI_TYPE_ZERO_BYTE;
8235 dgst_pos0 = 0;
8236 dgst_pos1 = 1;
8237 dgst_pos2 = 2;
8238 dgst_pos3 = 3;
8239 break;
8240
8241 case 3710: hash_type = HASH_TYPE_MD5;
8242 salt_type = SALT_TYPE_INTERN;
8243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8244 opts_type = OPTS_TYPE_PT_GENERATE_LE
8245 | OPTS_TYPE_PT_ADD80
8246 | OPTS_TYPE_PT_ADDBITS14;
8247 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = md5s_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_EARLY_SKIP;
8255 dgst_pos0 = 0;
8256 dgst_pos1 = 3;
8257 dgst_pos2 = 2;
8258 dgst_pos3 = 1;
8259 break;
8260
8261 case 3711: hash_type = HASH_TYPE_MD5;
8262 salt_type = SALT_TYPE_EMBEDDED;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_LE
8265 | OPTS_TYPE_PT_ADD80
8266 | OPTS_TYPE_PT_ADDBITS14;
8267 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8268 dgst_size = DGST_SIZE_4_4;
8269 parse_func = mediawiki_b_parse_hash;
8270 sort_by_digest = sort_by_digest_4_4;
8271 opti_type = OPTI_TYPE_ZERO_BYTE
8272 | OPTI_TYPE_PRECOMPUTE_INIT
8273 | OPTI_TYPE_PRECOMPUTE_MERKLE
8274 | OPTI_TYPE_EARLY_SKIP;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 3;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 1;
8279 break;
8280
8281 case 3800: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_INTERN;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_ST_ADDBITS14;
8286 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = md5s_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE
8291 | OPTI_TYPE_PRECOMPUTE_INIT
8292 | OPTI_TYPE_PRECOMPUTE_MERKLE
8293 | OPTI_TYPE_EARLY_SKIP
8294 | OPTI_TYPE_NOT_ITERATED
8295 | OPTI_TYPE_RAW_HASH;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 3;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 1;
8300 break;
8301
8302 case 4300: hash_type = HASH_TYPE_MD5;
8303 salt_type = SALT_TYPE_VIRTUAL;
8304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE
8306 | OPTS_TYPE_PT_ADD80
8307 | OPTS_TYPE_PT_ADDBITS14
8308 | OPTS_TYPE_ST_ADD80;
8309 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8310 dgst_size = DGST_SIZE_4_4;
8311 parse_func = md5md5_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323
8324 case 4400: hash_type = HASH_TYPE_MD5;
8325 salt_type = SALT_TYPE_NONE;
8326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8327 opts_type = OPTS_TYPE_PT_GENERATE_BE
8328 | OPTS_TYPE_PT_ADD80
8329 | OPTS_TYPE_PT_ADDBITS15;
8330 kern_type = KERN_TYPE_MD5_SHA1;
8331 dgst_size = DGST_SIZE_4_4;
8332 parse_func = md5_parse_hash;
8333 sort_by_digest = sort_by_digest_4_4;
8334 opti_type = OPTI_TYPE_ZERO_BYTE
8335 | OPTI_TYPE_PRECOMPUTE_INIT
8336 | OPTI_TYPE_PRECOMPUTE_MERKLE
8337 | OPTI_TYPE_EARLY_SKIP
8338 | OPTI_TYPE_NOT_ITERATED
8339 | OPTI_TYPE_NOT_SALTED
8340 | OPTI_TYPE_RAW_HASH;
8341 dgst_pos0 = 0;
8342 dgst_pos1 = 3;
8343 dgst_pos2 = 2;
8344 dgst_pos3 = 1;
8345 break;
8346
8347 case 4500: hash_type = HASH_TYPE_SHA1;
8348 salt_type = SALT_TYPE_NONE;
8349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8350 opts_type = OPTS_TYPE_PT_GENERATE_BE
8351 | OPTS_TYPE_PT_ADD80
8352 | OPTS_TYPE_PT_ADDBITS15;
8353 kern_type = KERN_TYPE_SHA11;
8354 dgst_size = DGST_SIZE_4_5;
8355 parse_func = sha1_parse_hash;
8356 sort_by_digest = sort_by_digest_4_5;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_PRECOMPUTE_INIT
8359 | OPTI_TYPE_PRECOMPUTE_MERKLE
8360 | OPTI_TYPE_EARLY_SKIP
8361 | OPTI_TYPE_NOT_SALTED;
8362 dgst_pos0 = 3;
8363 dgst_pos1 = 4;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 1;
8366 break;
8367
8368 case 4700: hash_type = HASH_TYPE_SHA1;
8369 salt_type = SALT_TYPE_NONE;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_ADD80
8373 | OPTS_TYPE_PT_ADDBITS14;
8374 kern_type = KERN_TYPE_SHA1_MD5;
8375 dgst_size = DGST_SIZE_4_5;
8376 parse_func = sha1_parse_hash;
8377 sort_by_digest = sort_by_digest_4_5;
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_PRECOMPUTE_INIT
8380 | OPTI_TYPE_PRECOMPUTE_MERKLE
8381 | OPTI_TYPE_EARLY_SKIP
8382 | OPTI_TYPE_NOT_ITERATED
8383 | OPTI_TYPE_NOT_SALTED
8384 | OPTI_TYPE_RAW_HASH;
8385 dgst_pos0 = 3;
8386 dgst_pos1 = 4;
8387 dgst_pos2 = 2;
8388 dgst_pos3 = 1;
8389 break;
8390
8391 case 4800: hash_type = HASH_TYPE_MD5;
8392 salt_type = SALT_TYPE_EMBEDDED;
8393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8394 opts_type = OPTS_TYPE_PT_GENERATE_LE
8395 | OPTS_TYPE_PT_ADDBITS14;
8396 kern_type = KERN_TYPE_MD5_CHAP;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = chap_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_INIT
8402 | OPTI_TYPE_PRECOMPUTE_MERKLE
8403 | OPTI_TYPE_MEET_IN_MIDDLE
8404 | OPTI_TYPE_EARLY_SKIP
8405 | OPTI_TYPE_NOT_ITERATED
8406 | OPTI_TYPE_RAW_HASH;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 3;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 1;
8411 break;
8412
8413 case 4900: hash_type = HASH_TYPE_SHA1;
8414 salt_type = SALT_TYPE_INTERN;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8417 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8418 dgst_size = DGST_SIZE_4_5;
8419 parse_func = sha1s_parse_hash;
8420 sort_by_digest = sort_by_digest_4_5;
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_INIT
8423 | OPTI_TYPE_PRECOMPUTE_MERKLE
8424 | OPTI_TYPE_EARLY_SKIP;
8425 dgst_pos0 = 3;
8426 dgst_pos1 = 4;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 1;
8429 break;
8430
8431 case 5000: hash_type = HASH_TYPE_KECCAK;
8432 salt_type = SALT_TYPE_EMBEDDED;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_PT_ADD01;
8436 kern_type = KERN_TYPE_KECCAK;
8437 dgst_size = DGST_SIZE_8_25;
8438 parse_func = keccak_parse_hash;
8439 sort_by_digest = sort_by_digest_8_25;
8440 opti_type = OPTI_TYPE_ZERO_BYTE
8441 | OPTI_TYPE_USES_BITS_64
8442 | OPTI_TYPE_RAW_HASH;
8443 dgst_pos0 = 2;
8444 dgst_pos1 = 3;
8445 dgst_pos2 = 4;
8446 dgst_pos3 = 5;
8447 break;
8448
8449 case 5100: hash_type = HASH_TYPE_MD5H;
8450 salt_type = SALT_TYPE_NONE;
8451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE
8453 | OPTS_TYPE_PT_ADD80
8454 | OPTS_TYPE_PT_ADDBITS14;
8455 kern_type = KERN_TYPE_MD5H;
8456 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8457 parse_func = md5half_parse_hash;
8458 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8459 opti_type = OPTI_TYPE_ZERO_BYTE
8460 | OPTI_TYPE_RAW_HASH;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 1;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 3;
8465 break;
8466
8467 case 5200: hash_type = HASH_TYPE_SHA256;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_PSAFE3;
8472 dgst_size = DGST_SIZE_4_8;
8473 parse_func = psafe3_parse_hash;
8474 sort_by_digest = sort_by_digest_4_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 1;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 3;
8480 break;
8481
8482 case 5300: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_ST_ADD80;
8487 kern_type = KERN_TYPE_IKEPSK_MD5;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = ikepsk_md5_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE;
8492 dgst_pos0 = 0;
8493 dgst_pos1 = 3;
8494 dgst_pos2 = 2;
8495 dgst_pos3 = 1;
8496 break;
8497
8498 case 5400: hash_type = HASH_TYPE_SHA1;
8499 salt_type = SALT_TYPE_EMBEDDED;
8500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8501 opts_type = OPTS_TYPE_PT_GENERATE_BE
8502 | OPTS_TYPE_ST_ADD80;
8503 kern_type = KERN_TYPE_IKEPSK_SHA1;
8504 dgst_size = DGST_SIZE_4_5;
8505 parse_func = ikepsk_sha1_parse_hash;
8506 sort_by_digest = sort_by_digest_4_5;
8507 opti_type = OPTI_TYPE_ZERO_BYTE;
8508 dgst_pos0 = 3;
8509 dgst_pos1 = 4;
8510 dgst_pos2 = 2;
8511 dgst_pos3 = 1;
8512 break;
8513
8514 case 5500: hash_type = HASH_TYPE_NETNTLM;
8515 salt_type = SALT_TYPE_EMBEDDED;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_LE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS14
8520 | OPTS_TYPE_PT_UNICODE
8521 | OPTS_TYPE_ST_HEX;
8522 kern_type = KERN_TYPE_NETNTLMv1;
8523 dgst_size = DGST_SIZE_4_4;
8524 parse_func = netntlmv1_parse_hash;
8525 sort_by_digest = sort_by_digest_4_4;
8526 opti_type = OPTI_TYPE_ZERO_BYTE
8527 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8528 dgst_pos0 = 0;
8529 dgst_pos1 = 1;
8530 dgst_pos2 = 2;
8531 dgst_pos3 = 3;
8532 break;
8533
8534 case 5600: hash_type = HASH_TYPE_MD5;
8535 salt_type = SALT_TYPE_EMBEDDED;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE
8538 | OPTS_TYPE_PT_ADD80
8539 | OPTS_TYPE_PT_ADDBITS14
8540 | OPTS_TYPE_PT_UNICODE;
8541 kern_type = KERN_TYPE_NETNTLMv2;
8542 dgst_size = DGST_SIZE_4_4;
8543 parse_func = netntlmv2_parse_hash;
8544 sort_by_digest = sort_by_digest_4_4;
8545 opti_type = OPTI_TYPE_ZERO_BYTE;
8546 dgst_pos0 = 0;
8547 dgst_pos1 = 3;
8548 dgst_pos2 = 2;
8549 dgst_pos3 = 1;
8550 break;
8551
8552 case 5700: hash_type = HASH_TYPE_SHA256;
8553 salt_type = SALT_TYPE_NONE;
8554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8555 opts_type = OPTS_TYPE_PT_GENERATE_BE
8556 | OPTS_TYPE_PT_ADD80
8557 | OPTS_TYPE_PT_ADDBITS15;
8558 kern_type = KERN_TYPE_SHA256;
8559 dgst_size = DGST_SIZE_4_8;
8560 parse_func = cisco4_parse_hash;
8561 sort_by_digest = sort_by_digest_4_8;
8562 opti_type = OPTI_TYPE_ZERO_BYTE
8563 | OPTI_TYPE_PRECOMPUTE_INIT
8564 | OPTI_TYPE_PRECOMPUTE_MERKLE
8565 | OPTI_TYPE_EARLY_SKIP
8566 | OPTI_TYPE_NOT_ITERATED
8567 | OPTI_TYPE_NOT_SALTED
8568 | OPTI_TYPE_RAW_HASH;
8569 dgst_pos0 = 3;
8570 dgst_pos1 = 7;
8571 dgst_pos2 = 2;
8572 dgst_pos3 = 6;
8573 break;
8574
8575 case 5800: hash_type = HASH_TYPE_SHA1;
8576 salt_type = SALT_TYPE_INTERN;
8577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8578 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8579 | OPTS_TYPE_ST_ADD80;
8580 kern_type = KERN_TYPE_ANDROIDPIN;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = androidpin_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 1;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 3;
8589 break;
8590
8591 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8592 salt_type = SALT_TYPE_NONE;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE
8595 | OPTS_TYPE_PT_ADD80;
8596 kern_type = KERN_TYPE_RIPEMD160;
8597 dgst_size = DGST_SIZE_4_5;
8598 parse_func = ripemd160_parse_hash;
8599 sort_by_digest = sort_by_digest_4_5;
8600 opti_type = OPTI_TYPE_ZERO_BYTE;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 1;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 3;
8605 break;
8606
8607 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8608 salt_type = SALT_TYPE_NONE;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_BE
8611 | OPTS_TYPE_PT_ADD80;
8612 kern_type = KERN_TYPE_WHIRLPOOL;
8613 dgst_size = DGST_SIZE_4_16;
8614 parse_func = whirlpool_parse_hash;
8615 sort_by_digest = sort_by_digest_4_16;
8616 opti_type = OPTI_TYPE_ZERO_BYTE;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 1;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 3;
8621 break;
8622
8623 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = truecrypt_parse_hash_2k;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 1;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 3;
8636 break;
8637
8638 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8642 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8643 dgst_size = DGST_SIZE_4_5;
8644 parse_func = truecrypt_parse_hash_2k;
8645 sort_by_digest = sort_by_digest_4_5;
8646 opti_type = OPTI_TYPE_ZERO_BYTE;
8647 dgst_pos0 = 0;
8648 dgst_pos1 = 1;
8649 dgst_pos2 = 2;
8650 dgst_pos3 = 3;
8651 break;
8652
8653 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8657 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8658 dgst_size = DGST_SIZE_4_5;
8659 parse_func = truecrypt_parse_hash_2k;
8660 sort_by_digest = sort_by_digest_4_5;
8661 opti_type = OPTI_TYPE_ZERO_BYTE;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 6221: hash_type = HASH_TYPE_SHA512;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8672 kern_type = KERN_TYPE_TCSHA512_XTS512;
8673 dgst_size = DGST_SIZE_8_8;
8674 parse_func = truecrypt_parse_hash_1k;
8675 sort_by_digest = sort_by_digest_8_8;
8676 opti_type = OPTI_TYPE_ZERO_BYTE
8677 | OPTI_TYPE_USES_BITS_64;
8678 dgst_pos0 = 0;
8679 dgst_pos1 = 1;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 3;
8682 break;
8683
8684 case 6222: hash_type = HASH_TYPE_SHA512;
8685 salt_type = SALT_TYPE_EMBEDDED;
8686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8687 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8688 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8689 dgst_size = DGST_SIZE_8_8;
8690 parse_func = truecrypt_parse_hash_1k;
8691 sort_by_digest = sort_by_digest_8_8;
8692 opti_type = OPTI_TYPE_ZERO_BYTE
8693 | OPTI_TYPE_USES_BITS_64;
8694 dgst_pos0 = 0;
8695 dgst_pos1 = 1;
8696 dgst_pos2 = 2;
8697 dgst_pos3 = 3;
8698 break;
8699
8700 case 6223: hash_type = HASH_TYPE_SHA512;
8701 salt_type = SALT_TYPE_EMBEDDED;
8702 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8704 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8705 dgst_size = DGST_SIZE_8_8;
8706 parse_func = truecrypt_parse_hash_1k;
8707 sort_by_digest = sort_by_digest_8_8;
8708 opti_type = OPTI_TYPE_ZERO_BYTE
8709 | OPTI_TYPE_USES_BITS_64;
8710 dgst_pos0 = 0;
8711 dgst_pos1 = 1;
8712 dgst_pos2 = 2;
8713 dgst_pos3 = 3;
8714 break;
8715
8716 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8717 salt_type = SALT_TYPE_EMBEDDED;
8718 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8720 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8721 dgst_size = DGST_SIZE_4_8;
8722 parse_func = truecrypt_parse_hash_1k;
8723 sort_by_digest = sort_by_digest_4_8;
8724 opti_type = OPTI_TYPE_ZERO_BYTE;
8725 dgst_pos0 = 0;
8726 dgst_pos1 = 1;
8727 dgst_pos2 = 2;
8728 dgst_pos3 = 3;
8729 break;
8730
8731 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8732 salt_type = SALT_TYPE_EMBEDDED;
8733 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8734 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8735 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8736 dgst_size = DGST_SIZE_4_8;
8737 parse_func = truecrypt_parse_hash_1k;
8738 sort_by_digest = sort_by_digest_4_8;
8739 opti_type = OPTI_TYPE_ZERO_BYTE;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 1;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 3;
8744 break;
8745
8746 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8747 salt_type = SALT_TYPE_EMBEDDED;
8748 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8749 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8750 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8751 dgst_size = DGST_SIZE_4_8;
8752 parse_func = truecrypt_parse_hash_1k;
8753 sort_by_digest = sort_by_digest_4_8;
8754 opti_type = OPTI_TYPE_ZERO_BYTE;
8755 dgst_pos0 = 0;
8756 dgst_pos1 = 1;
8757 dgst_pos2 = 2;
8758 dgst_pos3 = 3;
8759 break;
8760
8761 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8762 salt_type = SALT_TYPE_EMBEDDED;
8763 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8764 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8765 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8766 dgst_size = DGST_SIZE_4_5;
8767 parse_func = truecrypt_parse_hash_1k;
8768 sort_by_digest = sort_by_digest_4_5;
8769 opti_type = OPTI_TYPE_ZERO_BYTE;
8770 dgst_pos0 = 0;
8771 dgst_pos1 = 1;
8772 dgst_pos2 = 2;
8773 dgst_pos3 = 3;
8774 break;
8775
8776 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8777 salt_type = SALT_TYPE_EMBEDDED;
8778 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8779 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8780 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8781 dgst_size = DGST_SIZE_4_5;
8782 parse_func = truecrypt_parse_hash_1k;
8783 sort_by_digest = sort_by_digest_4_5;
8784 opti_type = OPTI_TYPE_ZERO_BYTE;
8785 dgst_pos0 = 0;
8786 dgst_pos1 = 1;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 3;
8789 break;
8790
8791 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8792 salt_type = SALT_TYPE_EMBEDDED;
8793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8795 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8796 dgst_size = DGST_SIZE_4_5;
8797 parse_func = truecrypt_parse_hash_1k;
8798 sort_by_digest = sort_by_digest_4_5;
8799 opti_type = OPTI_TYPE_ZERO_BYTE;
8800 dgst_pos0 = 0;
8801 dgst_pos1 = 1;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 3;
8804 break;
8805
8806 case 6300: hash_type = HASH_TYPE_MD5;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8810 kern_type = KERN_TYPE_MD5AIX;
8811 dgst_size = DGST_SIZE_4_4;
8812 parse_func = md5aix_parse_hash;
8813 sort_by_digest = sort_by_digest_4_4;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 6400: hash_type = HASH_TYPE_SHA256;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8825 kern_type = KERN_TYPE_SHA256AIX;
8826 dgst_size = DGST_SIZE_4_8;
8827 parse_func = sha256aix_parse_hash;
8828 sort_by_digest = sort_by_digest_4_8;
8829 opti_type = OPTI_TYPE_ZERO_BYTE;
8830 dgst_pos0 = 0;
8831 dgst_pos1 = 1;
8832 dgst_pos2 = 2;
8833 dgst_pos3 = 3;
8834 break;
8835
8836 case 6500: hash_type = HASH_TYPE_SHA512;
8837 salt_type = SALT_TYPE_EMBEDDED;
8838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8839 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8840 kern_type = KERN_TYPE_SHA512AIX;
8841 dgst_size = DGST_SIZE_8_8;
8842 parse_func = sha512aix_parse_hash;
8843 sort_by_digest = sort_by_digest_8_8;
8844 opti_type = OPTI_TYPE_ZERO_BYTE
8845 | OPTI_TYPE_USES_BITS_64;
8846 dgst_pos0 = 0;
8847 dgst_pos1 = 1;
8848 dgst_pos2 = 2;
8849 dgst_pos3 = 3;
8850 break;
8851
8852 case 6600: hash_type = HASH_TYPE_AES;
8853 salt_type = SALT_TYPE_EMBEDDED;
8854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8856 kern_type = KERN_TYPE_AGILEKEY;
8857 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8858 parse_func = agilekey_parse_hash;
8859 sort_by_digest = sort_by_digest_4_5;
8860 opti_type = OPTI_TYPE_ZERO_BYTE;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 6700: hash_type = HASH_TYPE_SHA1;
8868 salt_type = SALT_TYPE_EMBEDDED;
8869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8871 kern_type = KERN_TYPE_SHA1AIX;
8872 dgst_size = DGST_SIZE_4_5;
8873 parse_func = sha1aix_parse_hash;
8874 sort_by_digest = sort_by_digest_4_5;
8875 opti_type = OPTI_TYPE_ZERO_BYTE;
8876 dgst_pos0 = 0;
8877 dgst_pos1 = 1;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 3;
8880 break;
8881
8882 case 6800: hash_type = HASH_TYPE_AES;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8886 kern_type = KERN_TYPE_LASTPASS;
8887 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8888 parse_func = lastpass_parse_hash;
8889 sort_by_digest = sort_by_digest_4_8;
8890 opti_type = OPTI_TYPE_ZERO_BYTE;
8891 dgst_pos0 = 0;
8892 dgst_pos1 = 1;
8893 dgst_pos2 = 2;
8894 dgst_pos3 = 3;
8895 break;
8896
8897 case 6900: hash_type = HASH_TYPE_GOST;
8898 salt_type = SALT_TYPE_NONE;
8899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8901 kern_type = KERN_TYPE_GOST;
8902 dgst_size = DGST_SIZE_4_8;
8903 parse_func = gost_parse_hash;
8904 sort_by_digest = sort_by_digest_4_8;
8905 opti_type = OPTI_TYPE_ZERO_BYTE;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 7100: hash_type = HASH_TYPE_SHA512;
8913 salt_type = SALT_TYPE_EMBEDDED;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8916 kern_type = KERN_TYPE_PBKDF2_SHA512;
8917 dgst_size = DGST_SIZE_8_16;
8918 parse_func = sha512osx_parse_hash;
8919 sort_by_digest = sort_by_digest_8_16;
8920 opti_type = OPTI_TYPE_ZERO_BYTE
8921 | OPTI_TYPE_USES_BITS_64;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 1;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 3;
8926 break;
8927
8928 case 7200: hash_type = HASH_TYPE_SHA512;
8929 salt_type = SALT_TYPE_EMBEDDED;
8930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8932 kern_type = KERN_TYPE_PBKDF2_SHA512;
8933 dgst_size = DGST_SIZE_8_16;
8934 parse_func = sha512grub_parse_hash;
8935 sort_by_digest = sort_by_digest_8_16;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_USES_BITS_64;
8938 dgst_pos0 = 0;
8939 dgst_pos1 = 1;
8940 dgst_pos2 = 2;
8941 dgst_pos3 = 3;
8942 break;
8943
8944 case 7300: hash_type = HASH_TYPE_SHA1;
8945 salt_type = SALT_TYPE_EMBEDDED;
8946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8947 opts_type = OPTS_TYPE_PT_GENERATE_BE
8948 | OPTS_TYPE_ST_ADD80
8949 | OPTS_TYPE_ST_ADDBITS15;
8950 kern_type = KERN_TYPE_RAKP;
8951 dgst_size = DGST_SIZE_4_5;
8952 parse_func = rakp_parse_hash;
8953 sort_by_digest = sort_by_digest_4_5;
8954 opti_type = OPTI_TYPE_ZERO_BYTE
8955 | OPTI_TYPE_NOT_ITERATED;
8956 dgst_pos0 = 3;
8957 dgst_pos1 = 4;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 1;
8960 break;
8961
8962 case 7400: hash_type = HASH_TYPE_SHA256;
8963 salt_type = SALT_TYPE_EMBEDDED;
8964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8966 kern_type = KERN_TYPE_SHA256CRYPT;
8967 dgst_size = DGST_SIZE_4_8;
8968 parse_func = sha256crypt_parse_hash;
8969 sort_by_digest = sort_by_digest_4_8;
8970 opti_type = OPTI_TYPE_ZERO_BYTE;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 7500: hash_type = HASH_TYPE_KRB5PA;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8981 kern_type = KERN_TYPE_KRB5PA;
8982 dgst_size = DGST_SIZE_4_4;
8983 parse_func = krb5pa_parse_hash;
8984 sort_by_digest = sort_by_digest_4_4;
8985 opti_type = OPTI_TYPE_ZERO_BYTE
8986 | OPTI_TYPE_NOT_ITERATED;
8987 dgst_pos0 = 0;
8988 dgst_pos1 = 1;
8989 dgst_pos2 = 2;
8990 dgst_pos3 = 3;
8991 break;
8992
8993 case 7600: hash_type = HASH_TYPE_SHA1;
8994 salt_type = SALT_TYPE_INTERN;
8995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8996 opts_type = OPTS_TYPE_PT_GENERATE_BE
8997 | OPTS_TYPE_PT_ADD80
8998 | OPTS_TYPE_PT_ADDBITS15;
8999 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9000 dgst_size = DGST_SIZE_4_5;
9001 parse_func = redmine_parse_hash;
9002 sort_by_digest = sort_by_digest_4_5;
9003 opti_type = OPTI_TYPE_ZERO_BYTE
9004 | OPTI_TYPE_PRECOMPUTE_INIT
9005 | OPTI_TYPE_EARLY_SKIP
9006 | OPTI_TYPE_NOT_ITERATED
9007 | OPTI_TYPE_PREPENDED_SALT;
9008 dgst_pos0 = 3;
9009 dgst_pos1 = 4;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 1;
9012 break;
9013
9014 case 7700: hash_type = HASH_TYPE_SAPB;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE
9018 | OPTS_TYPE_PT_UPPER
9019 | OPTS_TYPE_ST_UPPER;
9020 kern_type = KERN_TYPE_SAPB;
9021 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9022 parse_func = sapb_parse_hash;
9023 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9024 opti_type = OPTI_TYPE_ZERO_BYTE
9025 | OPTI_TYPE_PRECOMPUTE_INIT
9026 | OPTI_TYPE_NOT_ITERATED;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 7800: hash_type = HASH_TYPE_SAPG;
9034 salt_type = SALT_TYPE_EMBEDDED;
9035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_BE
9037 | OPTS_TYPE_ST_ADD80
9038 | OPTS_TYPE_ST_UPPER;
9039 kern_type = KERN_TYPE_SAPG;
9040 dgst_size = DGST_SIZE_4_5;
9041 parse_func = sapg_parse_hash;
9042 sort_by_digest = sort_by_digest_4_5;
9043 opti_type = OPTI_TYPE_ZERO_BYTE
9044 | OPTI_TYPE_PRECOMPUTE_INIT
9045 | OPTI_TYPE_NOT_ITERATED;
9046 dgst_pos0 = 3;
9047 dgst_pos1 = 4;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 1;
9050 break;
9051
9052 case 7900: hash_type = HASH_TYPE_SHA512;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9056 kern_type = KERN_TYPE_DRUPAL7;
9057 dgst_size = DGST_SIZE_8_8;
9058 parse_func = drupal7_parse_hash;
9059 sort_by_digest = sort_by_digest_8_8;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_USES_BITS_64;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 8000: hash_type = HASH_TYPE_SHA256;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_BE
9072 | OPTS_TYPE_PT_UNICODE
9073 | OPTS_TYPE_ST_ADD80
9074 | OPTS_TYPE_ST_HEX;
9075 kern_type = KERN_TYPE_SYBASEASE;
9076 dgst_size = DGST_SIZE_4_8;
9077 parse_func = sybasease_parse_hash;
9078 sort_by_digest = sort_by_digest_4_8;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_PRECOMPUTE_INIT
9081 | OPTI_TYPE_EARLY_SKIP
9082 | OPTI_TYPE_NOT_ITERATED
9083 | OPTI_TYPE_RAW_HASH;
9084 dgst_pos0 = 3;
9085 dgst_pos1 = 7;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 6;
9088 break;
9089
9090 case 8100: hash_type = HASH_TYPE_SHA1;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9094 kern_type = KERN_TYPE_NETSCALER;
9095 dgst_size = DGST_SIZE_4_5;
9096 parse_func = netscaler_parse_hash;
9097 sort_by_digest = sort_by_digest_4_5;
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_PRECOMPUTE_INIT
9100 | OPTI_TYPE_PRECOMPUTE_MERKLE
9101 | OPTI_TYPE_EARLY_SKIP
9102 | OPTI_TYPE_NOT_ITERATED
9103 | OPTI_TYPE_PREPENDED_SALT
9104 | OPTI_TYPE_RAW_HASH;
9105 dgst_pos0 = 3;
9106 dgst_pos1 = 4;
9107 dgst_pos2 = 2;
9108 dgst_pos3 = 1;
9109 break;
9110
9111 case 8200: hash_type = HASH_TYPE_SHA256;
9112 salt_type = SALT_TYPE_EMBEDDED;
9113 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9114 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9115 kern_type = KERN_TYPE_CLOUDKEY;
9116 dgst_size = DGST_SIZE_4_8;
9117 parse_func = cloudkey_parse_hash;
9118 sort_by_digest = sort_by_digest_4_8;
9119 opti_type = OPTI_TYPE_ZERO_BYTE;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 8300: hash_type = HASH_TYPE_SHA1;
9127 salt_type = SALT_TYPE_EMBEDDED;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_LE
9130 | OPTS_TYPE_ST_HEX
9131 | OPTS_TYPE_ST_ADD80;
9132 kern_type = KERN_TYPE_NSEC3;
9133 dgst_size = DGST_SIZE_4_5;
9134 parse_func = nsec3_parse_hash;
9135 sort_by_digest = sort_by_digest_4_5;
9136 opti_type = OPTI_TYPE_ZERO_BYTE;
9137 dgst_pos0 = 3;
9138 dgst_pos1 = 4;
9139 dgst_pos2 = 2;
9140 dgst_pos3 = 1;
9141 break;
9142
9143 case 8400: hash_type = HASH_TYPE_SHA1;
9144 salt_type = SALT_TYPE_INTERN;
9145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9146 opts_type = OPTS_TYPE_PT_GENERATE_BE
9147 | OPTS_TYPE_PT_ADD80
9148 | OPTS_TYPE_PT_ADDBITS15;
9149 kern_type = KERN_TYPE_WBB3;
9150 dgst_size = DGST_SIZE_4_5;
9151 parse_func = wbb3_parse_hash;
9152 sort_by_digest = sort_by_digest_4_5;
9153 opti_type = OPTI_TYPE_ZERO_BYTE
9154 | OPTI_TYPE_PRECOMPUTE_INIT
9155 | OPTI_TYPE_NOT_ITERATED;
9156 dgst_pos0 = 3;
9157 dgst_pos1 = 4;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 1;
9160 break;
9161
9162 case 8500: hash_type = HASH_TYPE_DESRACF;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE
9166 | OPTS_TYPE_ST_UPPER;
9167 kern_type = KERN_TYPE_RACF;
9168 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9169 parse_func = racf_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9171 opti_type = OPTI_TYPE_ZERO_BYTE
9172 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 8600: hash_type = HASH_TYPE_LOTUS5;
9180 salt_type = SALT_TYPE_NONE;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9183 kern_type = KERN_TYPE_LOTUS5;
9184 dgst_size = DGST_SIZE_4_4;
9185 parse_func = lotus5_parse_hash;
9186 sort_by_digest = sort_by_digest_4_4;
9187 opti_type = OPTI_TYPE_EARLY_SKIP
9188 | OPTI_TYPE_NOT_ITERATED
9189 | OPTI_TYPE_NOT_SALTED
9190 | OPTI_TYPE_RAW_HASH;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 8700: hash_type = HASH_TYPE_LOTUS6;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_LOTUS6;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = lotus6_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_EARLY_SKIP
9206 | OPTI_TYPE_NOT_ITERATED
9207 | OPTI_TYPE_RAW_HASH;
9208 dgst_pos0 = 0;
9209 dgst_pos1 = 1;
9210 dgst_pos2 = 2;
9211 dgst_pos3 = 3;
9212 break;
9213
9214 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9215 salt_type = SALT_TYPE_EMBEDDED;
9216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9218 kern_type = KERN_TYPE_ANDROIDFDE;
9219 dgst_size = DGST_SIZE_4_4;
9220 parse_func = androidfde_parse_hash;
9221 sort_by_digest = sort_by_digest_4_4;
9222 opti_type = OPTI_TYPE_ZERO_BYTE;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 8900: hash_type = HASH_TYPE_SCRYPT;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9233 kern_type = KERN_TYPE_SCRYPT;
9234 dgst_size = DGST_SIZE_4_8;
9235 parse_func = scrypt_parse_hash;
9236 sort_by_digest = sort_by_digest_4_8;
9237 opti_type = OPTI_TYPE_ZERO_BYTE;
9238 dgst_pos0 = 0;
9239 dgst_pos1 = 1;
9240 dgst_pos2 = 2;
9241 dgst_pos3 = 3;
9242 break;
9243
9244 case 9000: hash_type = HASH_TYPE_SHA1;
9245 salt_type = SALT_TYPE_EMBEDDED;
9246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9247 opts_type = OPTS_TYPE_PT_GENERATE_LE
9248 | OPTS_TYPE_ST_GENERATE_LE;
9249 kern_type = KERN_TYPE_PSAFE2;
9250 dgst_size = DGST_SIZE_4_5;
9251 parse_func = psafe2_parse_hash;
9252 sort_by_digest = sort_by_digest_4_5;
9253 opti_type = OPTI_TYPE_ZERO_BYTE;
9254 dgst_pos0 = 0;
9255 dgst_pos1 = 1;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 3;
9258 break;
9259
9260 case 9100: hash_type = HASH_TYPE_LOTUS8;
9261 salt_type = SALT_TYPE_EMBEDDED;
9262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9263 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9264 kern_type = KERN_TYPE_LOTUS8;
9265 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9266 parse_func = lotus8_parse_hash;
9267 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9268 opti_type = OPTI_TYPE_ZERO_BYTE;
9269 dgst_pos0 = 0;
9270 dgst_pos1 = 1;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 3;
9273 break;
9274
9275 case 9200: hash_type = HASH_TYPE_SHA256;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9279 kern_type = KERN_TYPE_PBKDF2_SHA256;
9280 dgst_size = DGST_SIZE_4_32;
9281 parse_func = cisco8_parse_hash;
9282 sort_by_digest = sort_by_digest_4_32;
9283 opti_type = OPTI_TYPE_ZERO_BYTE;
9284 dgst_pos0 = 0;
9285 dgst_pos1 = 1;
9286 dgst_pos2 = 2;
9287 dgst_pos3 = 3;
9288 break;
9289
9290 case 9300: hash_type = HASH_TYPE_SCRYPT;
9291 salt_type = SALT_TYPE_EMBEDDED;
9292 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9293 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9294 kern_type = KERN_TYPE_SCRYPT;
9295 dgst_size = DGST_SIZE_4_8;
9296 parse_func = cisco9_parse_hash;
9297 sort_by_digest = sort_by_digest_4_8;
9298 opti_type = OPTI_TYPE_ZERO_BYTE;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9309 kern_type = KERN_TYPE_OFFICE2007;
9310 dgst_size = DGST_SIZE_4_4;
9311 parse_func = office2007_parse_hash;
9312 sort_by_digest = sort_by_digest_4_4;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_OFFICE2010;
9325 dgst_size = DGST_SIZE_4_4;
9326 parse_func = office2010_parse_hash;
9327 sort_by_digest = sort_by_digest_4_4;
9328 opti_type = OPTI_TYPE_ZERO_BYTE;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9339 kern_type = KERN_TYPE_OFFICE2013;
9340 dgst_size = DGST_SIZE_4_4;
9341 parse_func = office2013_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE
9354 | OPTS_TYPE_PT_ADD80
9355 | OPTS_TYPE_PT_UNICODE;
9356 kern_type = KERN_TYPE_OLDOFFICE01;
9357 dgst_size = DGST_SIZE_4_4;
9358 parse_func = oldoffice01_parse_hash;
9359 sort_by_digest = sort_by_digest_4_4;
9360 opti_type = OPTI_TYPE_ZERO_BYTE
9361 | OPTI_TYPE_PRECOMPUTE_INIT
9362 | OPTI_TYPE_NOT_ITERATED;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 1;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 3;
9367 break;
9368
9369 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9370 salt_type = SALT_TYPE_EMBEDDED;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_LE
9373 | OPTS_TYPE_PT_ADD80;
9374 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9375 dgst_size = DGST_SIZE_4_4;
9376 parse_func = oldoffice01cm1_parse_hash;
9377 sort_by_digest = sort_by_digest_4_4;
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_PRECOMPUTE_INIT
9380 | OPTI_TYPE_NOT_ITERATED;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_PT_ADD80
9392 | OPTS_TYPE_PT_UNICODE
9393 | OPTS_TYPE_PT_NEVERCRACK;
9394 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = oldoffice01cm2_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_PRECOMPUTE_INIT
9400 | OPTI_TYPE_NOT_ITERATED;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 1;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 3;
9405 break;
9406
9407 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_BE
9411 | OPTS_TYPE_PT_ADD80
9412 | OPTS_TYPE_PT_UNICODE;
9413 kern_type = KERN_TYPE_OLDOFFICE34;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = oldoffice34_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_NOT_ITERATED;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9431 dgst_size = DGST_SIZE_4_4;
9432 parse_func = oldoffice34cm1_parse_hash;
9433 sort_by_digest = sort_by_digest_4_4;
9434 opti_type = OPTI_TYPE_ZERO_BYTE
9435 | OPTI_TYPE_PRECOMPUTE_INIT
9436 | OPTI_TYPE_NOT_ITERATED;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_BE
9447 | OPTS_TYPE_PT_ADD80
9448 | OPTS_TYPE_PT_UNICODE
9449 | OPTS_TYPE_PT_NEVERCRACK;
9450 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9451 dgst_size = DGST_SIZE_4_4;
9452 parse_func = oldoffice34cm2_parse_hash;
9453 sort_by_digest = sort_by_digest_4_4;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_NOT_ITERATED;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 9900: hash_type = HASH_TYPE_MD5;
9464 salt_type = SALT_TYPE_NONE;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_RADMIN2;
9468 dgst_size = DGST_SIZE_4_4;
9469 parse_func = radmin2_parse_hash;
9470 sort_by_digest = sort_by_digest_4_4;
9471 opti_type = OPTI_TYPE_ZERO_BYTE
9472 | OPTI_TYPE_PRECOMPUTE_INIT
9473 | OPTI_TYPE_EARLY_SKIP
9474 | OPTI_TYPE_NOT_ITERATED
9475 | OPTI_TYPE_NOT_SALTED;
9476 dgst_pos0 = 0;
9477 dgst_pos1 = 3;
9478 dgst_pos2 = 2;
9479 dgst_pos3 = 1;
9480 break;
9481
9482 case 10000: hash_type = HASH_TYPE_SHA256;
9483 salt_type = SALT_TYPE_EMBEDDED;
9484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9486 kern_type = KERN_TYPE_PBKDF2_SHA256;
9487 dgst_size = DGST_SIZE_4_32;
9488 parse_func = djangopbkdf2_parse_hash;
9489 sort_by_digest = sort_by_digest_4_32;
9490 opti_type = OPTI_TYPE_ZERO_BYTE;
9491 dgst_pos0 = 0;
9492 dgst_pos1 = 1;
9493 dgst_pos2 = 2;
9494 dgst_pos3 = 3;
9495 break;
9496
9497 case 10100: hash_type = HASH_TYPE_SIPHASH;
9498 salt_type = SALT_TYPE_EMBEDDED;
9499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9500 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9501 kern_type = KERN_TYPE_SIPHASH;
9502 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9503 parse_func = siphash_parse_hash;
9504 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9505 opti_type = OPTI_TYPE_ZERO_BYTE
9506 | OPTI_TYPE_NOT_ITERATED
9507 | OPTI_TYPE_RAW_HASH;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 10200: hash_type = HASH_TYPE_MD5;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE
9518 | OPTS_TYPE_ST_ADD80
9519 | OPTS_TYPE_ST_ADDBITS14;
9520 kern_type = KERN_TYPE_HMACMD5_PW;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = crammd5_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_ZERO_BYTE
9525 | OPTI_TYPE_NOT_ITERATED;
9526 dgst_pos0 = 0;
9527 dgst_pos1 = 3;
9528 dgst_pos2 = 2;
9529 dgst_pos3 = 1;
9530 break;
9531
9532 case 10300: hash_type = HASH_TYPE_SHA1;
9533 salt_type = SALT_TYPE_EMBEDDED;
9534 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9535 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9536 kern_type = KERN_TYPE_SAPH_SHA1;
9537 dgst_size = DGST_SIZE_4_5;
9538 parse_func = saph_sha1_parse_hash;
9539 sort_by_digest = sort_by_digest_4_5;
9540 opti_type = OPTI_TYPE_ZERO_BYTE;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 10400: hash_type = HASH_TYPE_PDFU16;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9551 kern_type = KERN_TYPE_PDF11;
9552 dgst_size = DGST_SIZE_4_4;
9553 parse_func = pdf11_parse_hash;
9554 sort_by_digest = sort_by_digest_4_4;
9555 opti_type = OPTI_TYPE_ZERO_BYTE
9556 | OPTI_TYPE_NOT_ITERATED;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 10410: hash_type = HASH_TYPE_PDFU16;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9567 kern_type = KERN_TYPE_PDF11CM1;
9568 dgst_size = DGST_SIZE_4_4;
9569 parse_func = pdf11cm1_parse_hash;
9570 sort_by_digest = sort_by_digest_4_4;
9571 opti_type = OPTI_TYPE_ZERO_BYTE
9572 | OPTI_TYPE_NOT_ITERATED;
9573 dgst_pos0 = 0;
9574 dgst_pos1 = 1;
9575 dgst_pos2 = 2;
9576 dgst_pos3 = 3;
9577 break;
9578
9579 case 10420: hash_type = HASH_TYPE_PDFU16;
9580 salt_type = SALT_TYPE_EMBEDDED;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9583 kern_type = KERN_TYPE_PDF11CM2;
9584 dgst_size = DGST_SIZE_4_4;
9585 parse_func = pdf11cm2_parse_hash;
9586 sort_by_digest = sort_by_digest_4_4;
9587 opti_type = OPTI_TYPE_ZERO_BYTE
9588 | OPTI_TYPE_NOT_ITERATED;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 10500: hash_type = HASH_TYPE_PDFU16;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9599 kern_type = KERN_TYPE_PDF14;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = pdf14_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_NOT_ITERATED;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 10600: hash_type = HASH_TYPE_SHA256;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_BE
9615 | OPTS_TYPE_ST_ADD80
9616 | OPTS_TYPE_ST_ADDBITS15
9617 | OPTS_TYPE_HASH_COPY;
9618 kern_type = KERN_TYPE_SHA256_PWSLT;
9619 dgst_size = DGST_SIZE_4_8;
9620 parse_func = pdf17l3_parse_hash;
9621 sort_by_digest = sort_by_digest_4_8;
9622 opti_type = OPTI_TYPE_ZERO_BYTE
9623 | OPTI_TYPE_PRECOMPUTE_INIT
9624 | OPTI_TYPE_PRECOMPUTE_MERKLE
9625 | OPTI_TYPE_EARLY_SKIP
9626 | OPTI_TYPE_NOT_ITERATED
9627 | OPTI_TYPE_APPENDED_SALT
9628 | OPTI_TYPE_RAW_HASH;
9629 dgst_pos0 = 3;
9630 dgst_pos1 = 7;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 6;
9633 break;
9634
9635 case 10700: hash_type = HASH_TYPE_PDFU32;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE
9639 | OPTS_TYPE_HASH_COPY;
9640 kern_type = KERN_TYPE_PDF17L8;
9641 dgst_size = DGST_SIZE_4_8;
9642 parse_func = pdf17l8_parse_hash;
9643 sort_by_digest = sort_by_digest_4_8;
9644 opti_type = OPTI_TYPE_ZERO_BYTE
9645 | OPTI_TYPE_NOT_ITERATED;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 10800: hash_type = HASH_TYPE_SHA384;
9653 salt_type = SALT_TYPE_NONE;
9654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_BE
9656 | OPTS_TYPE_PT_ADD80
9657 | OPTS_TYPE_PT_ADDBITS15;
9658 kern_type = KERN_TYPE_SHA384;
9659 dgst_size = DGST_SIZE_8_8;
9660 parse_func = sha384_parse_hash;
9661 sort_by_digest = sort_by_digest_8_8;
9662 opti_type = OPTI_TYPE_ZERO_BYTE
9663 | OPTI_TYPE_PRECOMPUTE_INIT
9664 | OPTI_TYPE_PRECOMPUTE_MERKLE
9665 | OPTI_TYPE_EARLY_SKIP
9666 | OPTI_TYPE_NOT_ITERATED
9667 | OPTI_TYPE_NOT_SALTED
9668 | OPTI_TYPE_USES_BITS_64
9669 | OPTI_TYPE_RAW_HASH;
9670 dgst_pos0 = 6;
9671 dgst_pos1 = 7;
9672 dgst_pos2 = 4;
9673 dgst_pos3 = 5;
9674 break;
9675
9676 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE
9680 | OPTS_TYPE_ST_BASE64
9681 | OPTS_TYPE_HASH_COPY;
9682 kern_type = KERN_TYPE_PBKDF2_SHA256;
9683 dgst_size = DGST_SIZE_4_32;
9684 parse_func = pbkdf2_sha256_parse_hash;
9685 sort_by_digest = sort_by_digest_4_32;
9686 opti_type = OPTI_TYPE_ZERO_BYTE;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 11000: hash_type = HASH_TYPE_MD5;
9694 salt_type = SALT_TYPE_INTERN;
9695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE
9697 | OPTS_TYPE_PT_ADD80;
9698 kern_type = KERN_TYPE_PRESTASHOP;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = prestashop_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE
9703 | OPTI_TYPE_PRECOMPUTE_INIT
9704 | OPTI_TYPE_NOT_ITERATED
9705 | OPTI_TYPE_PREPENDED_SALT;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 3;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 1;
9710 break;
9711
9712 case 11100: hash_type = HASH_TYPE_MD5;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE
9716 | OPTS_TYPE_ST_ADD80;
9717 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9718 dgst_size = DGST_SIZE_4_4;
9719 parse_func = postgresql_auth_parse_hash;
9720 sort_by_digest = sort_by_digest_4_4;
9721 opti_type = OPTI_TYPE_ZERO_BYTE
9722 | OPTI_TYPE_PRECOMPUTE_INIT
9723 | OPTI_TYPE_PRECOMPUTE_MERKLE
9724 | OPTI_TYPE_EARLY_SKIP;
9725 dgst_pos0 = 0;
9726 dgst_pos1 = 3;
9727 dgst_pos2 = 2;
9728 dgst_pos3 = 1;
9729 break;
9730
9731 case 11200: hash_type = HASH_TYPE_SHA1;
9732 salt_type = SALT_TYPE_EMBEDDED;
9733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9734 opts_type = OPTS_TYPE_PT_GENERATE_BE
9735 | OPTS_TYPE_PT_ADD80
9736 | OPTS_TYPE_ST_HEX;
9737 kern_type = KERN_TYPE_MYSQL_AUTH;
9738 dgst_size = DGST_SIZE_4_5;
9739 parse_func = mysql_auth_parse_hash;
9740 sort_by_digest = sort_by_digest_4_5;
9741 opti_type = OPTI_TYPE_ZERO_BYTE
9742 | OPTI_TYPE_EARLY_SKIP;
9743 dgst_pos0 = 3;
9744 dgst_pos1 = 4;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 1;
9747 break;
9748
9749 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_ST_HEX
9754 | OPTS_TYPE_ST_ADD80;
9755 kern_type = KERN_TYPE_BITCOIN_WALLET;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = bitcoin_wallet_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 1;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 3;
9764 break;
9765
9766 case 11400: hash_type = HASH_TYPE_MD5;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_PT_ADD80
9771 | OPTS_TYPE_HASH_COPY;
9772 kern_type = KERN_TYPE_SIP_AUTH;
9773 dgst_size = DGST_SIZE_4_4;
9774 parse_func = sip_auth_parse_hash;
9775 sort_by_digest = sort_by_digest_4_4;
9776 opti_type = OPTI_TYPE_ZERO_BYTE;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 3;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 1;
9781 break;
9782
9783 case 11500: hash_type = HASH_TYPE_CRC32;
9784 salt_type = SALT_TYPE_INTERN;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE
9787 | OPTS_TYPE_ST_GENERATE_LE
9788 | OPTS_TYPE_ST_HEX;
9789 kern_type = KERN_TYPE_CRC32;
9790 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9791 parse_func = crc32_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9793 opti_type = OPTI_TYPE_ZERO_BYTE;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 11600: hash_type = HASH_TYPE_AES;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_LE
9804 | OPTS_TYPE_PT_NEVERCRACK;
9805 kern_type = KERN_TYPE_SEVEN_ZIP;
9806 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9807 parse_func = seven_zip_parse_hash;
9808 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9809 opti_type = OPTI_TYPE_ZERO_BYTE;
9810 dgst_pos0 = 0;
9811 dgst_pos1 = 1;
9812 dgst_pos2 = 2;
9813 dgst_pos3 = 3;
9814 break;
9815
9816 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9817 salt_type = SALT_TYPE_NONE;
9818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9819 opts_type = OPTS_TYPE_PT_GENERATE_LE
9820 | OPTS_TYPE_PT_ADD01;
9821 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9822 dgst_size = DGST_SIZE_4_8;
9823 parse_func = gost2012sbog_256_parse_hash;
9824 sort_by_digest = sort_by_digest_4_8;
9825 opti_type = OPTI_TYPE_ZERO_BYTE;
9826 dgst_pos0 = 0;
9827 dgst_pos1 = 1;
9828 dgst_pos2 = 2;
9829 dgst_pos3 = 3;
9830 break;
9831
9832 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9833 salt_type = SALT_TYPE_NONE;
9834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9835 opts_type = OPTS_TYPE_PT_GENERATE_LE
9836 | OPTS_TYPE_PT_ADD01;
9837 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9838 dgst_size = DGST_SIZE_4_16;
9839 parse_func = gost2012sbog_512_parse_hash;
9840 sort_by_digest = sort_by_digest_4_16;
9841 opti_type = OPTI_TYPE_ZERO_BYTE;
9842 dgst_pos0 = 0;
9843 dgst_pos1 = 1;
9844 dgst_pos2 = 2;
9845 dgst_pos3 = 3;
9846 break;
9847
9848 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9849 salt_type = SALT_TYPE_EMBEDDED;
9850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9851 opts_type = OPTS_TYPE_PT_GENERATE_LE
9852 | OPTS_TYPE_ST_BASE64
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PBKDF2_MD5;
9855 dgst_size = DGST_SIZE_4_32;
9856 parse_func = pbkdf2_md5_parse_hash;
9857 sort_by_digest = sort_by_digest_4_32;
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 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE
9869 | OPTS_TYPE_ST_BASE64
9870 | OPTS_TYPE_HASH_COPY;
9871 kern_type = KERN_TYPE_PBKDF2_SHA1;
9872 dgst_size = DGST_SIZE_4_32;
9873 parse_func = pbkdf2_sha1_parse_hash;
9874 sort_by_digest = sort_by_digest_4_32;
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE
9886 | OPTS_TYPE_ST_BASE64
9887 | OPTS_TYPE_HASH_COPY;
9888 kern_type = KERN_TYPE_PBKDF2_SHA512;
9889 dgst_size = DGST_SIZE_8_16;
9890 parse_func = pbkdf2_sha512_parse_hash;
9891 sort_by_digest = sort_by_digest_8_16;
9892 opti_type = OPTI_TYPE_ZERO_BYTE
9893 | OPTI_TYPE_USES_BITS_64;
9894 dgst_pos0 = 0;
9895 dgst_pos1 = 1;
9896 dgst_pos2 = 2;
9897 dgst_pos3 = 3;
9898 break;
9899
9900 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9901 salt_type = SALT_TYPE_EMBEDDED;
9902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9904 kern_type = KERN_TYPE_ECRYPTFS;
9905 dgst_size = DGST_SIZE_8_8;
9906 parse_func = ecryptfs_parse_hash;
9907 sort_by_digest = sort_by_digest_8_8;
9908 opti_type = OPTI_TYPE_ZERO_BYTE
9909 | OPTI_TYPE_USES_BITS_64;
9910 dgst_pos0 = 0;
9911 dgst_pos1 = 1;
9912 dgst_pos2 = 2;
9913 dgst_pos3 = 3;
9914 break;
9915
9916 case 12300: hash_type = HASH_TYPE_ORACLET;
9917 salt_type = SALT_TYPE_EMBEDDED;
9918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9919 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9920 kern_type = KERN_TYPE_ORACLET;
9921 dgst_size = DGST_SIZE_8_16;
9922 parse_func = oraclet_parse_hash;
9923 sort_by_digest = sort_by_digest_8_16;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_USES_BITS_64;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 1;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 3;
9930 break;
9931
9932 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9936 kern_type = KERN_TYPE_BSDICRYPT;
9937 dgst_size = DGST_SIZE_4_4;
9938 parse_func = bsdicrypt_parse_hash;
9939 sort_by_digest = sort_by_digest_4_4;
9940 opti_type = OPTI_TYPE_ZERO_BYTE
9941 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9942 dgst_pos0 = 0;
9943 dgst_pos1 = 1;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 3;
9946 break;
9947
9948 case 12500: hash_type = HASH_TYPE_RAR3HP;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9952 kern_type = KERN_TYPE_RAR3;
9953 dgst_size = DGST_SIZE_4_4;
9954 parse_func = rar3hp_parse_hash;
9955 sort_by_digest = sort_by_digest_4_4;
9956 opti_type = OPTI_TYPE_ZERO_BYTE;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 12600: hash_type = HASH_TYPE_SHA256;
9964 salt_type = SALT_TYPE_INTERN;
9965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_BE
9967 | OPTS_TYPE_PT_ADD80;
9968 kern_type = KERN_TYPE_CF10;
9969 dgst_size = DGST_SIZE_4_8;
9970 parse_func = cf10_parse_hash;
9971 sort_by_digest = sort_by_digest_4_8;
9972 opti_type = OPTI_TYPE_ZERO_BYTE
9973 | OPTI_TYPE_PRECOMPUTE_INIT
9974 | OPTI_TYPE_EARLY_SKIP
9975 | OPTI_TYPE_NOT_ITERATED;
9976 dgst_pos0 = 3;
9977 dgst_pos1 = 7;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 6;
9980 break;
9981
9982 case 12700: hash_type = HASH_TYPE_AES;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_MYWALLET;
9988 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9989 parse_func = mywallet_parse_hash;
9990 sort_by_digest = sort_by_digest_4_5;
9991 opti_type = OPTI_TYPE_ZERO_BYTE;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_MS_DRSR;
10003 dgst_size = DGST_SIZE_4_8;
10004 parse_func = ms_drsr_parse_hash;
10005 sort_by_digest = sort_by_digest_4_8;
10006 opti_type = OPTI_TYPE_ZERO_BYTE;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10017 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10018 dgst_size = DGST_SIZE_4_8;
10019 parse_func = androidfde_samsung_parse_hash;
10020 sort_by_digest = sort_by_digest_4_8;
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10032 kern_type = KERN_TYPE_RAR5;
10033 dgst_size = DGST_SIZE_4_4;
10034 parse_func = rar5_parse_hash;
10035 sort_by_digest = sort_by_digest_4_4;
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 default: usage_mini_print (PROGNAME); return (-1);
10044 }
10045
10046 /**
10047 * transpose
10048 */
10049
10050 data.parse_func = parse_func;
10051
10052 /**
10053 * misc stuff
10054 */
10055
10056 if (hex_salt)
10057 {
10058 if (salt_type == SALT_TYPE_INTERN)
10059 {
10060 opts_type |= OPTS_TYPE_ST_HEX;
10061 }
10062 else
10063 {
10064 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10065
10066 return (-1);
10067 }
10068 }
10069
10070 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10071 | (salt_type == SALT_TYPE_EXTERN)
10072 | (salt_type == SALT_TYPE_EMBEDDED)
10073 | (salt_type == SALT_TYPE_VIRTUAL));
10074
10075 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10076
10077 data.hash_type = hash_type;
10078 data.attack_mode = attack_mode;
10079 data.attack_kern = attack_kern;
10080 data.attack_exec = attack_exec;
10081 data.kern_type = kern_type;
10082 data.opts_type = opts_type;
10083 data.dgst_size = dgst_size;
10084 data.salt_type = salt_type;
10085 data.isSalted = isSalted;
10086 data.sort_by_digest = sort_by_digest;
10087 data.dgst_pos0 = dgst_pos0;
10088 data.dgst_pos1 = dgst_pos1;
10089 data.dgst_pos2 = dgst_pos2;
10090 data.dgst_pos3 = dgst_pos3;
10091
10092 esalt_size = 0;
10093
10094 switch (hash_mode)
10095 {
10096 case 2500: esalt_size = sizeof (wpa_t); break;
10097 case 5300: esalt_size = sizeof (ikepsk_t); break;
10098 case 5400: esalt_size = sizeof (ikepsk_t); break;
10099 case 5500: esalt_size = sizeof (netntlm_t); break;
10100 case 5600: esalt_size = sizeof (netntlm_t); break;
10101 case 6211:
10102 case 6212:
10103 case 6213:
10104 case 6221:
10105 case 6222:
10106 case 6223:
10107 case 6231:
10108 case 6232:
10109 case 6233:
10110 case 6241:
10111 case 6242:
10112 case 6243: esalt_size = sizeof (tc_t); break;
10113 case 6600: esalt_size = sizeof (agilekey_t); break;
10114 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10115 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10116 case 7300: esalt_size = sizeof (rakp_t); break;
10117 case 7500: esalt_size = sizeof (krb5pa_t); break;
10118 case 8200: esalt_size = sizeof (cloudkey_t); break;
10119 case 8800: esalt_size = sizeof (androidfde_t); break;
10120 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10121 case 9400: esalt_size = sizeof (office2007_t); break;
10122 case 9500: esalt_size = sizeof (office2010_t); break;
10123 case 9600: esalt_size = sizeof (office2013_t); break;
10124 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10125 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10126 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10127 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10128 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10129 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10130 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10131 case 10200: esalt_size = sizeof (cram_md5_t); break;
10132 case 10400: esalt_size = sizeof (pdf_t); break;
10133 case 10410: esalt_size = sizeof (pdf_t); break;
10134 case 10420: esalt_size = sizeof (pdf_t); break;
10135 case 10500: esalt_size = sizeof (pdf_t); break;
10136 case 10600: esalt_size = sizeof (pdf_t); break;
10137 case 10700: esalt_size = sizeof (pdf_t); break;
10138 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10139 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10140 case 11400: esalt_size = sizeof (sip_t); break;
10141 case 11600: esalt_size = sizeof (seven_zip_t); break;
10142 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10143 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10144 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10145 case 13000: esalt_size = sizeof (rar5_t); break;
10146 }
10147
10148 data.esalt_size = esalt_size;
10149
10150 /**
10151 * choose dictionary parser
10152 */
10153
10154 if (hash_type == HASH_TYPE_LM)
10155 {
10156 get_next_word_func = get_next_word_lm;
10157 }
10158 else if (opts_type & OPTS_TYPE_PT_UPPER)
10159 {
10160 get_next_word_func = get_next_word_uc;
10161 }
10162 else
10163 {
10164 get_next_word_func = get_next_word_std;
10165 }
10166
10167 /**
10168 * dictstat
10169 */
10170
10171 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10172
10173 #ifdef _POSIX
10174 size_t dictstat_nmemb = 0;
10175 #endif
10176
10177 #ifdef _WIN
10178 uint dictstat_nmemb = 0;
10179 #endif
10180
10181 char dictstat[256] = { 0 };
10182
10183 FILE *dictstat_fp = NULL;
10184
10185 if (keyspace == 0)
10186 {
10187 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10188
10189 dictstat_fp = fopen (dictstat, "rb");
10190
10191 if (dictstat_fp)
10192 {
10193 #ifdef _POSIX
10194 struct stat tmpstat;
10195
10196 fstat (fileno (dictstat_fp), &tmpstat);
10197 #endif
10198
10199 #ifdef _WIN
10200 struct stat64 tmpstat;
10201
10202 _fstat64 (fileno (dictstat_fp), &tmpstat);
10203 #endif
10204
10205 if (tmpstat.st_mtime < COMPTIME)
10206 {
10207 /* with v0.15 the format changed so we have to ensure user is using a good version
10208 since there is no version-header in the dictstat file */
10209
10210 fclose (dictstat_fp);
10211
10212 unlink (dictstat);
10213 }
10214 else
10215 {
10216 while (!feof (dictstat_fp))
10217 {
10218 dictstat_t d;
10219
10220 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10221
10222 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10223
10224 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10225 {
10226 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10227
10228 return -1;
10229 }
10230 }
10231
10232 fclose (dictstat_fp);
10233 }
10234 }
10235 }
10236
10237 /**
10238 * potfile
10239 */
10240
10241 char potfile[256] = { 0 };
10242
10243 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10244
10245 data.pot_fp = NULL;
10246
10247 FILE *out_fp = NULL;
10248 FILE *pot_fp = NULL;
10249
10250 if (show == 1 || left == 1)
10251 {
10252 pot_fp = fopen (potfile, "rb");
10253
10254 if (pot_fp == NULL)
10255 {
10256 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10257
10258 return (-1);
10259 }
10260
10261 if (outfile != NULL)
10262 {
10263 if ((out_fp = fopen (outfile, "ab")) == NULL)
10264 {
10265 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10266
10267 fclose (pot_fp);
10268
10269 return (-1);
10270 }
10271 }
10272 else
10273 {
10274 out_fp = stdout;
10275 }
10276 }
10277 else
10278 {
10279 if (potfile_disable == 0)
10280 {
10281 pot_fp = fopen (potfile, "ab");
10282
10283 if (pot_fp == NULL)
10284 {
10285 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10286
10287 return (-1);
10288 }
10289
10290 data.pot_fp = pot_fp;
10291 }
10292 }
10293
10294 pot_t *pot = NULL;
10295
10296 uint pot_cnt = 0;
10297 uint pot_avail = 0;
10298
10299 if (show == 1 || left == 1)
10300 {
10301 SUPPRESS_OUTPUT = 1;
10302
10303 pot_avail = count_lines (pot_fp);
10304
10305 rewind (pot_fp);
10306
10307 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10308
10309 uint pot_hashes_avail = 0;
10310
10311 uint line_num = 0;
10312
10313 while (!feof (pot_fp))
10314 {
10315 line_num++;
10316
10317 char line_buf[BUFSIZ] = { 0 };
10318
10319 int line_len = fgetl (pot_fp, line_buf);
10320
10321 if (line_len == 0) continue;
10322
10323 char *plain_buf = line_buf + line_len;
10324
10325 pot_t *pot_ptr = &pot[pot_cnt];
10326
10327 hash_t *hashes_buf = &pot_ptr->hash;
10328
10329 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10330 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10331
10332 if (pot_cnt == pot_hashes_avail)
10333 {
10334 uint pos = 0;
10335
10336 for (pos = 0; pos < INCR_POT; pos++)
10337 {
10338 if ((pot_cnt + pos) >= pot_avail) break;
10339
10340 pot_t *tmp_pot = &pot[pot_cnt + pos];
10341
10342 hash_t *tmp_hash = &tmp_pot->hash;
10343
10344 tmp_hash->digest = mymalloc (dgst_size);
10345
10346 if (isSalted)
10347 {
10348 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10349 }
10350
10351 if (esalt_size)
10352 {
10353 tmp_hash->esalt = mymalloc (esalt_size);
10354 }
10355
10356 pot_hashes_avail++;
10357 }
10358 }
10359
10360 int plain_len = 0;
10361
10362 int parser_status;
10363
10364 int iter = MAX_CUT_TRIES;
10365
10366 do
10367 {
10368 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10369 {
10370 if (line_buf[i] == ':')
10371 {
10372 line_len--;
10373
10374 break;
10375 }
10376 }
10377
10378 if (data.hash_mode != 2500)
10379 {
10380 parser_status = parse_func (line_buf, line_len, hashes_buf);
10381 }
10382 else
10383 {
10384 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10385
10386 if (line_len > max_salt_size)
10387 {
10388 parser_status = PARSER_GLOBAL_LENGTH;
10389 }
10390 else
10391 {
10392 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10393
10394 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10395
10396 hashes_buf->salt->salt_len = line_len;
10397
10398 parser_status = PARSER_OK;
10399 }
10400 }
10401
10402 // if NOT parsed without error, we add the ":" to the plain
10403
10404 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10405 {
10406 plain_len++;
10407 plain_buf--;
10408 }
10409
10410 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10411
10412 if (parser_status < PARSER_GLOBAL_ZERO)
10413 {
10414 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10415
10416 continue;
10417 }
10418
10419 if (plain_len >= 255) continue;
10420
10421 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10422
10423 pot_ptr->plain_len = plain_len;
10424
10425 pot_cnt++;
10426 }
10427
10428 fclose (pot_fp);
10429
10430 SUPPRESS_OUTPUT = 0;
10431
10432 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10433 }
10434
10435 /**
10436 * word len
10437 */
10438
10439 uint pw_min = PW_MIN;
10440 uint pw_max = PW_MAX;
10441
10442 switch (hash_mode)
10443 {
10444 case 400: if (pw_max > 40) pw_max = 40;
10445 break;
10446 case 500: if (pw_max > 16) pw_max = 16;
10447 break;
10448 case 1500: if (pw_max > 8) pw_max = 8;
10449 break;
10450 case 1600: if (pw_max > 16) pw_max = 16;
10451 break;
10452 case 1800: if (pw_max > 16) pw_max = 16;
10453 break;
10454 case 2100: if (pw_max > 16) pw_max = 16;
10455 break;
10456 case 2500: if (pw_min < 8) pw_min = 8;
10457 break;
10458 case 3000: if (pw_max > 7) pw_max = 7;
10459 break;
10460 case 5200: if (pw_max > 24) pw_max = 24;
10461 break;
10462 case 5800: if (pw_max > 16) pw_max = 16;
10463 break;
10464 case 6300: if (pw_max > 16) pw_max = 16;
10465 break;
10466 case 7400: if (pw_max > 16) pw_max = 16;
10467 break;
10468 case 7900: if (pw_max > 48) pw_max = 48;
10469 break;
10470 case 8500: if (pw_max > 8) pw_max = 8;
10471 break;
10472 case 8600: if (pw_max > 16) pw_max = 16;
10473 break;
10474 case 9710: pw_min = 5;
10475 pw_max = 5;
10476 break;
10477 case 9810: pw_min = 5;
10478 pw_max = 5;
10479 break;
10480 case 10410: pw_min = 5;
10481 pw_max = 5;
10482 break;
10483 case 10300: if (pw_max < 3) pw_min = 3;
10484 if (pw_max > 40) pw_max = 40;
10485 break;
10486 case 10500: if (pw_max < 3) pw_min = 3;
10487 if (pw_max > 40) pw_max = 40;
10488 break;
10489 case 10700: if (pw_max > 16) pw_max = 16;
10490 break;
10491 case 11300: if (pw_max > 40) pw_max = 40;
10492 break;
10493 case 12500: if (pw_max > 20) pw_max = 20;
10494 break;
10495 case 12800: if (pw_max > 24) pw_max = 24;
10496 break;
10497 }
10498
10499 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10500 {
10501 switch (attack_kern)
10502 {
10503 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10504 break;
10505 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10506 break;
10507 }
10508 }
10509
10510 /**
10511 * charsets : keep them together for more easy maintainnce
10512 */
10513
10514 cs_t mp_sys[6] = { { { 0 }, 0 } };
10515 cs_t mp_usr[4] = { { { 0 }, 0 } };
10516
10517 mp_setup_sys (mp_sys);
10518
10519 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10520 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10521 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10522 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10523
10524 /**
10525 * load hashes, part I: find input mode, count hashes
10526 */
10527
10528 uint hashlist_mode = 0;
10529 uint hashlist_format = HLFMT_HASHCAT;
10530
10531 uint hashes_avail = 0;
10532
10533 if (benchmark == 0)
10534 {
10535 struct stat f;
10536
10537 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10538
10539 if ((hash_mode == 2500) ||
10540 (hash_mode == 5200) ||
10541 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10542 (hash_mode == 9000))
10543 {
10544 hashlist_mode = HL_MODE_ARG;
10545
10546 char *hashfile = myargv[optind];
10547
10548 data.hashfile = hashfile;
10549
10550 logfile_top_var_string ("target", hashfile);
10551 }
10552
10553 if (hashlist_mode == HL_MODE_ARG)
10554 {
10555 if (hash_mode == 2500)
10556 {
10557 struct stat st;
10558
10559 if (stat (data.hashfile, &st) == -1)
10560 {
10561 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10562
10563 return (-1);
10564 }
10565
10566 hashes_avail = st.st_size / sizeof (hccap_t);
10567 }
10568 else
10569 {
10570 hashes_avail = 1;
10571 }
10572 }
10573 else if (hashlist_mode == HL_MODE_FILE)
10574 {
10575 char *hashfile = myargv[optind];
10576
10577 data.hashfile = hashfile;
10578
10579 logfile_top_var_string ("target", hashfile);
10580
10581 FILE *fp = NULL;
10582
10583 if ((fp = fopen (hashfile, "rb")) == NULL)
10584 {
10585 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10586
10587 return (-1);
10588 }
10589
10590 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10591
10592 hashes_avail = count_lines (fp);
10593
10594 rewind (fp);
10595
10596 if (hashes_avail == 0)
10597 {
10598 log_error ("ERROR: hashfile is empty or corrupt");
10599
10600 fclose (fp);
10601
10602 return (-1);
10603 }
10604
10605 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10606
10607 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10608 {
10609 log_error ("ERROR: remove not supported in native hashfile-format mode");
10610
10611 fclose (fp);
10612
10613 return (-1);
10614 }
10615
10616 fclose (fp);
10617 }
10618 }
10619 else
10620 {
10621 hashlist_mode = HL_MODE_ARG;
10622
10623 hashes_avail = 1;
10624 }
10625
10626 if (hash_mode == 3000) hashes_avail *= 2;
10627
10628 data.hashlist_mode = hashlist_mode;
10629 data.hashlist_format = hashlist_format;
10630
10631 logfile_top_uint (hashlist_mode);
10632 logfile_top_uint (hashlist_format);
10633
10634 /**
10635 * load hashes, part II: allocate required memory, set pointers
10636 */
10637
10638 hash_t *hashes_buf = NULL;
10639 void *digests_buf = NULL;
10640 salt_t *salts_buf = NULL;
10641 void *esalts_buf = NULL;
10642
10643 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10644
10645 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10646
10647 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10648 {
10649 u32 hash_pos;
10650
10651 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10652 {
10653 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10654
10655 hashes_buf[hash_pos].hash_info = hash_info;
10656
10657 if (username && (remove || show || left))
10658 {
10659 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10660 }
10661
10662 if (benchmark)
10663 {
10664 hash_info->orighash = (char *) mymalloc (256);
10665 }
10666 }
10667 }
10668
10669 if (isSalted)
10670 {
10671 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10672
10673 if (esalt_size)
10674 {
10675 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10676 }
10677 }
10678 else
10679 {
10680 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10681 }
10682
10683 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10684 {
10685 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10686
10687 if (isSalted)
10688 {
10689 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10690
10691 if (esalt_size)
10692 {
10693 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10694 }
10695 }
10696 else
10697 {
10698 hashes_buf[hash_pos].salt = &salts_buf[0];
10699 }
10700 }
10701
10702 /**
10703 * load hashes, part III: parse hashes or generate them if benchmark
10704 */
10705
10706 uint hashes_cnt = 0;
10707
10708 if (benchmark == 0)
10709 {
10710 if (keyspace == 1)
10711 {
10712 // useless to read hash file for keyspace, cheat a little bit w/ optind
10713 }
10714 else if (hashes_avail == 0)
10715 {
10716 }
10717 else if (hashlist_mode == HL_MODE_ARG)
10718 {
10719 char *input_buf = myargv[optind];
10720
10721 uint input_len = strlen (input_buf);
10722
10723 logfile_top_var_string ("target", input_buf);
10724
10725 char *hash_buf = NULL;
10726 int hash_len = 0;
10727
10728 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10729
10730 if (hash_len)
10731 {
10732 if (opts_type & OPTS_TYPE_HASH_COPY)
10733 {
10734 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10735
10736 hash_info_tmp->orighash = mystrdup (hash_buf);
10737 }
10738
10739 if (isSalted)
10740 {
10741 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10742 }
10743
10744 int parser_status = PARSER_OK;
10745
10746 if (hash_mode == 2500)
10747 {
10748 if (hash_len == 0)
10749 {
10750 log_error ("ERROR: hccap file not specified");
10751
10752 return (-1);
10753 }
10754
10755 hashlist_mode = HL_MODE_FILE;
10756
10757 data.hashlist_mode = hashlist_mode;
10758
10759 FILE *fp = fopen (hash_buf, "rb");
10760
10761 if (fp == NULL)
10762 {
10763 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10764
10765 return (-1);
10766 }
10767
10768 if (hashes_avail < 1)
10769 {
10770 log_error ("ERROR: hccap file is empty or corrupt");
10771
10772 fclose (fp);
10773
10774 return (-1);
10775 }
10776
10777 uint hccap_size = sizeof (hccap_t);
10778
10779 char *in = (char *) mymalloc (hccap_size);
10780
10781 while (!feof (fp))
10782 {
10783 int n = fread (in, hccap_size, 1, fp);
10784
10785 if (n != 1)
10786 {
10787 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10788
10789 break;
10790 }
10791
10792 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10793
10794 if (parser_status != PARSER_OK)
10795 {
10796 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10797
10798 continue;
10799 }
10800
10801 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10802
10803 if ((show == 1) || (left == 1))
10804 {
10805 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10806
10807 char *salt_ptr = (char *) tmp_salt->salt_buf;
10808
10809 int cur_pos = tmp_salt->salt_len;
10810 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10811
10812 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10813
10814 u8 *pke_ptr = (u8 *) wpa->pke;
10815
10816 // do the appending task
10817
10818 snprintf (salt_ptr + cur_pos,
10819 rem_len,
10820 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10821 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10822 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10823
10824
10825 // memset () the remaining part of the salt
10826
10827 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10828 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10829
10830 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10831
10832 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10833 }
10834
10835 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);
10836 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);
10837
10838 hashes_cnt++;
10839 }
10840
10841 fclose (fp);
10842
10843 myfree (in);
10844 }
10845 else if (hash_mode == 3000)
10846 {
10847 if (hash_len == 32)
10848 {
10849 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10850
10851 hash_t *lm_hash_left = NULL;
10852
10853 if (parser_status == PARSER_OK)
10854 {
10855 lm_hash_left = &hashes_buf[hashes_cnt];
10856
10857 hashes_cnt++;
10858 }
10859 else
10860 {
10861 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10862 }
10863
10864 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10865
10866 hash_t *lm_hash_right = NULL;
10867
10868 if (parser_status == PARSER_OK)
10869 {
10870 lm_hash_right = &hashes_buf[hashes_cnt];
10871
10872 hashes_cnt++;
10873 }
10874 else
10875 {
10876 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10877 }
10878
10879 // show / left
10880
10881 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10882 {
10883 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);
10884 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);
10885 }
10886 }
10887 else
10888 {
10889 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10890
10891 if (parser_status == PARSER_OK)
10892 {
10893 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10894 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10895 }
10896
10897 if (parser_status == PARSER_OK)
10898 {
10899 hashes_cnt++;
10900 }
10901 else
10902 {
10903 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10904 }
10905 }
10906 }
10907 else
10908 {
10909 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10910
10911 if (parser_status == PARSER_OK)
10912 {
10913 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10914 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10915 }
10916
10917 if (parser_status == PARSER_OK)
10918 {
10919 hashes_cnt++;
10920 }
10921 else
10922 {
10923 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10924 }
10925 }
10926 }
10927 }
10928 else if (hashlist_mode == HL_MODE_FILE)
10929 {
10930 char *hashfile = data.hashfile;
10931
10932 FILE *fp;
10933
10934 if ((fp = fopen (hashfile, "rb")) == NULL)
10935 {
10936 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10937
10938 return (-1);
10939 }
10940
10941 uint line_num = 0;
10942
10943 while (!feof (fp))
10944 {
10945 line_num++;
10946
10947 char line_buf[BUFSIZ] = { 0 };
10948
10949 int line_len = fgetl (fp, line_buf);
10950
10951 if (line_len == 0) continue;
10952
10953 char *hash_buf = NULL;
10954 int hash_len = 0;
10955
10956 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10957
10958 if (username)
10959 {
10960 char *user_buf = NULL;
10961 int user_len = 0;
10962
10963 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10964
10965 if (remove || show)
10966 {
10967 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10968
10969 *user = (user_t *) mymalloc (sizeof (user_t));
10970
10971 user_t *user_ptr = *user;
10972
10973 if (user_buf != NULL)
10974 {
10975 user_ptr->user_name = mystrdup (user_buf);
10976 }
10977 else
10978 {
10979 user_ptr->user_name = mystrdup ("");
10980 }
10981
10982 user_ptr->user_len = user_len;
10983 }
10984 }
10985
10986 if (opts_type & OPTS_TYPE_HASH_COPY)
10987 {
10988 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10989
10990 hash_info_tmp->orighash = mystrdup (hash_buf);
10991 }
10992
10993 if (isSalted)
10994 {
10995 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10996 }
10997
10998 if (hash_mode == 3000)
10999 {
11000 if (hash_len == 32)
11001 {
11002 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11003
11004 if (parser_status < PARSER_GLOBAL_ZERO)
11005 {
11006 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11007
11008 continue;
11009 }
11010
11011 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11012
11013 hashes_cnt++;
11014
11015 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11016
11017 if (parser_status < PARSER_GLOBAL_ZERO)
11018 {
11019 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11020
11021 continue;
11022 }
11023
11024 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11025
11026 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);
11027
11028 hashes_cnt++;
11029
11030 // show / left
11031
11032 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);
11033 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);
11034 }
11035 else
11036 {
11037 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11038
11039 if (parser_status < PARSER_GLOBAL_ZERO)
11040 {
11041 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11042
11043 continue;
11044 }
11045
11046 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);
11047
11048 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11049 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11050
11051 hashes_cnt++;
11052 }
11053 }
11054 else
11055 {
11056 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11057
11058 if (parser_status < PARSER_GLOBAL_ZERO)
11059 {
11060 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11061
11062 continue;
11063 }
11064
11065 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);
11066
11067 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11068 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11069
11070 hashes_cnt++;
11071 }
11072 }
11073
11074 fclose (fp);
11075
11076 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11077
11078 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11079 }
11080 }
11081 else
11082 {
11083 if (isSalted)
11084 {
11085 hashes_buf[0].salt->salt_len = 8;
11086
11087 // special salt handling
11088
11089 switch (hash_mode)
11090 {
11091 case 1500: hashes_buf[0].salt->salt_len = 2;
11092 break;
11093 case 1731: hashes_buf[0].salt->salt_len = 4;
11094 break;
11095 case 2410: hashes_buf[0].salt->salt_len = 4;
11096 break;
11097 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11098 break;
11099 case 3100: hashes_buf[0].salt->salt_len = 1;
11100 break;
11101 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11102 break;
11103 case 5800: hashes_buf[0].salt->salt_len = 16;
11104 break;
11105 case 6800: hashes_buf[0].salt->salt_len = 32;
11106 break;
11107 case 8400: hashes_buf[0].salt->salt_len = 40;
11108 break;
11109 case 8800: hashes_buf[0].salt->salt_len = 16;
11110 break;
11111 case 8900: hashes_buf[0].salt->salt_len = 16;
11112 hashes_buf[0].salt->scrypt_N = 1024;
11113 hashes_buf[0].salt->scrypt_r = 1;
11114 hashes_buf[0].salt->scrypt_p = 1;
11115 break;
11116 case 9100: hashes_buf[0].salt->salt_len = 16;
11117 break;
11118 case 9300: hashes_buf[0].salt->salt_len = 14;
11119 hashes_buf[0].salt->scrypt_N = 16384;
11120 hashes_buf[0].salt->scrypt_r = 1;
11121 hashes_buf[0].salt->scrypt_p = 1;
11122 break;
11123 case 9400: hashes_buf[0].salt->salt_len = 16;
11124 break;
11125 case 9500: hashes_buf[0].salt->salt_len = 16;
11126 break;
11127 case 9600: hashes_buf[0].salt->salt_len = 16;
11128 break;
11129 case 9700: hashes_buf[0].salt->salt_len = 16;
11130 break;
11131 case 9710: hashes_buf[0].salt->salt_len = 16;
11132 break;
11133 case 9720: hashes_buf[0].salt->salt_len = 16;
11134 break;
11135 case 9800: hashes_buf[0].salt->salt_len = 16;
11136 break;
11137 case 9810: hashes_buf[0].salt->salt_len = 16;
11138 break;
11139 case 9820: hashes_buf[0].salt->salt_len = 16;
11140 break;
11141 case 10300: hashes_buf[0].salt->salt_len = 12;
11142 break;
11143 case 11500: hashes_buf[0].salt->salt_len = 4;
11144 break;
11145 case 11600: hashes_buf[0].salt->salt_len = 4;
11146 break;
11147 case 12400: hashes_buf[0].salt->salt_len = 4;
11148 break;
11149 case 12500: hashes_buf[0].salt->salt_len = 8;
11150 break;
11151 case 12600: hashes_buf[0].salt->salt_len = 64;
11152 break;
11153 }
11154
11155 // special esalt handling
11156
11157 switch (hash_mode)
11158 {
11159 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11160 break;
11161 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11162 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11163 break;
11164 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11165 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11166 break;
11167 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11168 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11169 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11170 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11171 break;
11172 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11173 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11174 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11175 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11176 break;
11177 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11178 break;
11179 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11180 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11181 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11182 break;
11183 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11184 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11185 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11186 break;
11187 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11188 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11189 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11190 break;
11191 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11192 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11193 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11194 break;
11195 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11196 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11197 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11198 break;
11199 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11200 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11201 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11202 break;
11203 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11204 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11205 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11206 break;
11207 }
11208 }
11209
11210 // set hashfile
11211
11212 switch (hash_mode)
11213 {
11214 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11215 break;
11216 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11217 break;
11218 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11219 break;
11220 case 6211:
11221 case 6212:
11222 case 6213:
11223 case 6221:
11224 case 6222:
11225 case 6223:
11226 case 6231:
11227 case 6232:
11228 case 6233:
11229 case 6241:
11230 case 6242:
11231 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11232 break;
11233 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11234 break;
11235 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11236 break;
11237 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11238 break;
11239 }
11240
11241 // set default iterations
11242
11243 switch (hash_mode)
11244 {
11245 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11246 break;
11247 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11248 break;
11249 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11250 break;
11251 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11252 break;
11253 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11254 break;
11255 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11256 break;
11257 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11258 break;
11259 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11260 break;
11261 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11262 break;
11263 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11264 break;
11265 case 6211:
11266 case 6212:
11267 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11268 break;
11269 case 6221:
11270 case 6222:
11271 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11272 break;
11273 case 6231:
11274 case 6232:
11275 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11276 break;
11277 case 6241:
11278 case 6242:
11279 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11280 break;
11281 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11282 break;
11283 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11284 break;
11285 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11286 break;
11287 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11288 break;
11289 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11290 break;
11291 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11292 break;
11293 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11294 break;
11295 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11296 break;
11297 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11298 break;
11299 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11300 break;
11301 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11302 break;
11303 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11304 break;
11305 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11306 break;
11307 case 8900: hashes_buf[0].salt->salt_iter = 1;
11308 break;
11309 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11310 break;
11311 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11312 break;
11313 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11314 break;
11315 case 9300: hashes_buf[0].salt->salt_iter = 1;
11316 break;
11317 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11318 break;
11319 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11320 break;
11321 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11322 break;
11323 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11324 break;
11325 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11326 break;
11327 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11328 break;
11329 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11330 break;
11331 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11332 break;
11333 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11334 break;
11335 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11336 break;
11337 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11338 break;
11339 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11340 break;
11341 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11342 break;
11343 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11344 break;
11345 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11346 break;
11347 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11348 break;
11349 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11350 break;
11351 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11352 break;
11353 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11354 break;
11355 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11356 break;
11357 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11358 break;
11359 }
11360
11361 hashes_cnt = 1;
11362 }
11363
11364 if (show == 1 || left == 1)
11365 {
11366 for (uint i = 0; i < pot_cnt; i++)
11367 {
11368 pot_t *pot_ptr = &pot[i];
11369
11370 hash_t *hashes_buf = &pot_ptr->hash;
11371
11372 local_free (hashes_buf->digest);
11373
11374 if (isSalted)
11375 {
11376 local_free (hashes_buf->salt);
11377 }
11378 }
11379
11380 local_free (pot);
11381
11382 if (data.quiet == 0) log_info_nn ("");
11383
11384 return (0);
11385 }
11386
11387 if (keyspace == 0)
11388 {
11389 if (hashes_cnt == 0)
11390 {
11391 log_error ("ERROR: No hashes loaded");
11392
11393 return (-1);
11394 }
11395 }
11396
11397 /**
11398 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11399 */
11400
11401 if (data.outfile != NULL)
11402 {
11403 if (data.hashfile != NULL)
11404 {
11405 #ifdef _POSIX
11406 struct stat tmpstat_outfile;
11407 struct stat tmpstat_hashfile;
11408 #endif
11409
11410 #ifdef _WIN
11411 struct stat64 tmpstat_outfile;
11412 struct stat64 tmpstat_hashfile;
11413 #endif
11414
11415 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11416
11417 if (tmp_outfile_fp)
11418 {
11419 #ifdef _POSIX
11420 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11421 #endif
11422
11423 #ifdef _WIN
11424 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11425 #endif
11426
11427 fclose (tmp_outfile_fp);
11428 }
11429
11430 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11431
11432 if (tmp_hashfile_fp)
11433 {
11434 #ifdef _POSIX
11435 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11436 #endif
11437
11438 #ifdef _WIN
11439 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11440 #endif
11441
11442 fclose (tmp_hashfile_fp);
11443 }
11444
11445 if (tmp_outfile_fp && tmp_outfile_fp)
11446 {
11447 tmpstat_outfile.st_mode = 0;
11448 tmpstat_outfile.st_nlink = 0;
11449 tmpstat_outfile.st_uid = 0;
11450 tmpstat_outfile.st_gid = 0;
11451 tmpstat_outfile.st_rdev = 0;
11452 tmpstat_outfile.st_atime = 0;
11453
11454 tmpstat_hashfile.st_mode = 0;
11455 tmpstat_hashfile.st_nlink = 0;
11456 tmpstat_hashfile.st_uid = 0;
11457 tmpstat_hashfile.st_gid = 0;
11458 tmpstat_hashfile.st_rdev = 0;
11459 tmpstat_hashfile.st_atime = 0;
11460
11461 #ifdef _POSIX
11462 tmpstat_outfile.st_blksize = 0;
11463 tmpstat_outfile.st_blocks = 0;
11464
11465 tmpstat_hashfile.st_blksize = 0;
11466 tmpstat_hashfile.st_blocks = 0;
11467 #endif
11468
11469 #ifdef _POSIX
11470 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11471 {
11472 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11473
11474 return (-1);
11475 }
11476 #endif
11477
11478 #ifdef _WIN
11479 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11480 {
11481 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11482
11483 return (-1);
11484 }
11485 #endif
11486 }
11487 }
11488 }
11489
11490 /**
11491 * Remove duplicates
11492 */
11493
11494 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11495
11496 if (isSalted)
11497 {
11498 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11499 }
11500 else
11501 {
11502 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11503 }
11504
11505 uint hashes_cnt_orig = hashes_cnt;
11506
11507 hashes_cnt = 1;
11508
11509 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11510 {
11511 if (isSalted)
11512 {
11513 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11514 {
11515 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11516 }
11517 }
11518 else
11519 {
11520 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11521 }
11522
11523 if (hashes_pos > hashes_cnt)
11524 {
11525 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11526 }
11527
11528 hashes_cnt++;
11529 }
11530
11531 /**
11532 * Potfile removes
11533 */
11534
11535 uint potfile_remove_cracks = 0;
11536
11537 if (potfile_disable == 0)
11538 {
11539 hash_t hash_buf;
11540
11541 hash_buf.digest = mymalloc (dgst_size);
11542 hash_buf.salt = NULL;
11543 hash_buf.esalt = NULL;
11544 hash_buf.hash_info = NULL;
11545 hash_buf.cracked = 0;
11546
11547 if (isSalted)
11548 {
11549 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11550 }
11551
11552 if (esalt_size)
11553 {
11554 hash_buf.esalt = mymalloc (esalt_size);
11555 }
11556
11557 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11558
11559 // no solution for these special hash types (for instane because they use hashfile in output etc)
11560 if ((hash_mode != 5200) &&
11561 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11562 (hash_mode != 9000))
11563 {
11564 FILE *fp = fopen (potfile, "rb");
11565
11566 if (fp != NULL)
11567 {
11568 while (!feof (fp))
11569 {
11570 char line_buf[BUFSIZ] = { 0 };
11571
11572 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11573
11574 if (ptr == NULL) break;
11575
11576 int line_len = strlen (line_buf);
11577
11578 if (line_len == 0) continue;
11579
11580 int iter = MAX_CUT_TRIES;
11581
11582 for (int i = line_len - 1; i && iter; i--, line_len--)
11583 {
11584 if (line_buf[i] != ':') continue;
11585
11586 if (isSalted)
11587 {
11588 memset (hash_buf.salt, 0, sizeof (salt_t));
11589 }
11590
11591 hash_t *found = NULL;
11592
11593 if (hash_mode == 6800)
11594 {
11595 if (i < 64) // 64 = 16 * uint in salt_buf[]
11596 {
11597 // manipulate salt_buf
11598 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11599
11600 hash_buf.salt->salt_len = i;
11601
11602 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11603 }
11604 }
11605 else if (hash_mode == 2500)
11606 {
11607 if (i < 64) // 64 = 16 * uint in salt_buf[]
11608 {
11609 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11610 // manipulate salt_buf
11611
11612 // to be safe work with a copy (because of line_len loop, i etc)
11613
11614 char line_buf_cpy[BUFSIZ] = { 0 };
11615
11616 memcpy (line_buf_cpy, line_buf, i);
11617
11618 char *mac2_pos = strrchr (line_buf_cpy, ':');
11619
11620 if (mac2_pos == NULL) continue;
11621
11622 mac2_pos[0] = 0;
11623 mac2_pos++;
11624
11625 if (strlen (mac2_pos) != 12) continue;
11626
11627 char *mac1_pos = strrchr (line_buf_cpy, ':');
11628
11629 if (mac1_pos == NULL) continue;
11630
11631 mac1_pos[0] = 0;
11632 mac1_pos++;
11633
11634 if (strlen (mac1_pos) != 12) continue;
11635
11636 uint essid_length = mac1_pos - line_buf_cpy - 1;
11637
11638 // here we need the ESSID
11639 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11640
11641 hash_buf.salt->salt_len = essid_length;
11642
11643 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11644
11645 if (found)
11646 {
11647 wpa_t *wpa = (wpa_t *) found->esalt;
11648
11649 uint pke[25] = { 0 };
11650
11651 char *pke_ptr = (char *) pke;
11652
11653 for (uint i = 0; i < 25; i++)
11654 {
11655 pke[i] = byte_swap_32 (wpa->pke[i]);
11656 }
11657
11658 u8 mac1[6] = { 0 };
11659 u8 mac2[6] = { 0 };
11660
11661 memcpy (mac1, pke_ptr + 23, 6);
11662 memcpy (mac2, pke_ptr + 29, 6);
11663
11664 // compare hex string(s) vs binary MAC address(es)
11665
11666 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11667 {
11668 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11669 {
11670 found = NULL;
11671 break;
11672 }
11673 }
11674
11675 // early skip ;)
11676 if (!found) continue;
11677
11678 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11679 {
11680 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11681 {
11682 found = NULL;
11683 break;
11684 }
11685 }
11686 }
11687 }
11688 }
11689 else
11690 {
11691 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11692
11693 if (parser_status == PARSER_OK)
11694 {
11695 if (isSalted)
11696 {
11697 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11698 }
11699 else
11700 {
11701 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11702 }
11703 }
11704 }
11705
11706 if (found == NULL) continue;
11707
11708 if (!found->cracked) potfile_remove_cracks++;
11709
11710 found->cracked = 1;
11711
11712 if (found) break;
11713
11714 iter--;
11715 }
11716 }
11717
11718 fclose (fp);
11719 }
11720 }
11721
11722 if (esalt_size)
11723 {
11724 local_free (hash_buf.esalt);
11725 }
11726
11727 if (isSalted)
11728 {
11729 local_free (hash_buf.salt);
11730 }
11731
11732 local_free (hash_buf.digest);
11733 }
11734
11735 /**
11736 * Now generate all the buffers required for later
11737 */
11738
11739 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11740
11741 salt_t *salts_buf_new = NULL;
11742 void *esalts_buf_new = NULL;
11743
11744 if (isSalted)
11745 {
11746 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11747
11748 if (esalt_size)
11749 {
11750 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11751 }
11752 }
11753 else
11754 {
11755 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11756 }
11757
11758 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11759
11760 uint digests_cnt = hashes_cnt;
11761 uint digests_done = 0;
11762
11763 uint size_digests = digests_cnt * dgst_size;
11764 uint size_shown = digests_cnt * sizeof (uint);
11765
11766 uint *digests_shown = (uint *) mymalloc (size_shown);
11767 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11768
11769 uint salts_cnt = 0;
11770 uint salts_done = 0;
11771
11772 hashinfo_t **hash_info = NULL;
11773
11774 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11775 {
11776 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11777
11778 if (username && (remove || show))
11779 {
11780 uint user_pos;
11781
11782 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11783 {
11784 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11785
11786 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11787 }
11788 }
11789 }
11790
11791 uint *salts_shown = (uint *) mymalloc (size_shown);
11792
11793 salt_t *salt_buf;
11794
11795 {
11796 // copied from inner loop
11797
11798 salt_buf = &salts_buf_new[salts_cnt];
11799
11800 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11801
11802 if (esalt_size)
11803 {
11804 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11805 }
11806
11807 salt_buf->digests_cnt = 0;
11808 salt_buf->digests_done = 0;
11809 salt_buf->digests_offset = 0;
11810
11811 salts_cnt++;
11812 }
11813
11814 if (hashes_buf[0].cracked == 1)
11815 {
11816 digests_shown[0] = 1;
11817
11818 digests_done++;
11819
11820 salt_buf->digests_done++;
11821 }
11822
11823 salt_buf->digests_cnt++;
11824
11825 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11826
11827 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11828 {
11829 hash_info[0] = hashes_buf[0].hash_info;
11830 }
11831
11832 // copy from inner loop
11833
11834 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11835 {
11836 if (isSalted)
11837 {
11838 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11839 {
11840 salt_buf = &salts_buf_new[salts_cnt];
11841
11842 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11843
11844 if (esalt_size)
11845 {
11846 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11847 }
11848
11849 salt_buf->digests_cnt = 0;
11850 salt_buf->digests_done = 0;
11851 salt_buf->digests_offset = hashes_pos;
11852
11853 salts_cnt++;
11854 }
11855 }
11856
11857 if (hashes_buf[hashes_pos].cracked == 1)
11858 {
11859 digests_shown[hashes_pos] = 1;
11860
11861 digests_done++;
11862
11863 salt_buf->digests_done++;
11864 }
11865
11866 salt_buf->digests_cnt++;
11867
11868 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11869
11870 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11871 {
11872 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11873 }
11874 }
11875
11876 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11877 {
11878 salt_t *salt_buf = &salts_buf_new[salt_pos];
11879
11880 if (salt_buf->digests_done == salt_buf->digests_cnt)
11881 {
11882 salts_shown[salt_pos] = 1;
11883
11884 salts_done++;
11885 }
11886
11887 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11888 }
11889
11890 local_free (digests_buf);
11891 local_free (salts_buf);
11892 local_free (esalts_buf);
11893
11894 digests_buf = digests_buf_new;
11895 salts_buf = salts_buf_new;
11896 esalts_buf = esalts_buf_new;
11897
11898 local_free (hashes_buf);
11899
11900 /**
11901 * special modification not set from parser
11902 */
11903
11904 switch (hash_mode)
11905 {
11906 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11907 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11908 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11909 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11910 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11911 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11912 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11913 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11914 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11915 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11916 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11917 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11918 }
11919
11920 if (truecrypt_keyfiles)
11921 {
11922 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11923
11924 char *keyfiles = strdup (truecrypt_keyfiles);
11925
11926 char *keyfile = strtok (keyfiles, ",");
11927
11928 do
11929 {
11930 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
11931
11932 } while ((keyfile = strtok (NULL, ",")) != NULL);
11933
11934 free (keyfiles);
11935 }
11936
11937 data.digests_cnt = digests_cnt;
11938 data.digests_done = digests_done;
11939 data.digests_buf = digests_buf;
11940 data.digests_shown = digests_shown;
11941 data.digests_shown_tmp = digests_shown_tmp;
11942
11943 data.salts_cnt = salts_cnt;
11944 data.salts_done = salts_done;
11945 data.salts_buf = salts_buf;
11946 data.salts_shown = salts_shown;
11947
11948 data.esalts_buf = esalts_buf;
11949 data.hash_info = hash_info;
11950
11951 /**
11952 * Automatic Optimizers
11953 */
11954
11955 if (salts_cnt == 1)
11956 opti_type |= OPTI_TYPE_SINGLE_SALT;
11957
11958 if (digests_cnt == 1)
11959 opti_type |= OPTI_TYPE_SINGLE_HASH;
11960
11961 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11962 opti_type |= OPTI_TYPE_NOT_ITERATED;
11963
11964 if (attack_mode == ATTACK_MODE_BF)
11965 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11966
11967 data.opti_type = opti_type;
11968
11969 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11970 {
11971 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11972 {
11973 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11974 {
11975 if (opts_type & OPTS_TYPE_ST_ADD80)
11976 {
11977 opts_type &= ~OPTS_TYPE_ST_ADD80;
11978 opts_type |= OPTS_TYPE_PT_ADD80;
11979 }
11980
11981 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11982 {
11983 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11984 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11985 }
11986
11987 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11988 {
11989 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11990 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11991 }
11992 }
11993 }
11994 }
11995
11996 /**
11997 * Some algorithm, like descrypt, can benefit from JIT compilation
11998 */
11999
12000 int force_jit_compilation = -1;
12001
12002 if (hash_mode == 8900)
12003 {
12004 force_jit_compilation = 8900;
12005 }
12006 else if (hash_mode == 9300)
12007 {
12008 force_jit_compilation = 8900;
12009 }
12010 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12011 {
12012 force_jit_compilation = 1500;
12013 }
12014
12015 /**
12016 * generate bitmap tables
12017 */
12018
12019 const uint bitmap_shift1 = 5;
12020 const uint bitmap_shift2 = 13;
12021
12022 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12023
12024 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12025 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12026 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12027 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12028 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12029 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12030 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12031 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12032
12033 uint bitmap_bits;
12034 uint bitmap_nums;
12035 uint bitmap_mask;
12036 uint bitmap_size;
12037
12038 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12039 {
12040 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12041
12042 bitmap_nums = 1 << bitmap_bits;
12043
12044 bitmap_mask = bitmap_nums - 1;
12045
12046 bitmap_size = bitmap_nums * sizeof (uint);
12047
12048 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12049
12050 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;
12051 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;
12052
12053 break;
12054 }
12055
12056 bitmap_nums = 1 << bitmap_bits;
12057
12058 bitmap_mask = bitmap_nums - 1;
12059
12060 bitmap_size = bitmap_nums * sizeof (uint);
12061
12062 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);
12063 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);
12064
12065 /**
12066 * prepare quick rule
12067 */
12068
12069 data.rule_buf_l = rule_buf_l;
12070 data.rule_buf_r = rule_buf_r;
12071
12072 int rule_len_l = (int) strlen (rule_buf_l);
12073 int rule_len_r = (int) strlen (rule_buf_r);
12074
12075 data.rule_len_l = rule_len_l;
12076 data.rule_len_r = rule_len_r;
12077
12078 /**
12079 * load rules
12080 */
12081
12082 uint *all_kernel_rules_cnt = NULL;
12083
12084 kernel_rule_t **all_kernel_rules_buf = NULL;
12085
12086 if (rp_files_cnt)
12087 {
12088 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12089
12090 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12091 }
12092
12093 char rule_buf[BUFSIZ] = { 0 };
12094
12095 int rule_len = 0;
12096
12097 for (uint i = 0; i < rp_files_cnt; i++)
12098 {
12099 uint kernel_rules_avail = 0;
12100
12101 uint kernel_rules_cnt = 0;
12102
12103 kernel_rule_t *kernel_rules_buf = NULL;
12104
12105 char *rp_file = rp_files[i];
12106
12107 char in[BLOCK_SIZE] = { 0 };
12108 char out[BLOCK_SIZE] = { 0 };
12109
12110 FILE *fp = NULL;
12111
12112 uint rule_line = 0;
12113
12114 if ((fp = fopen (rp_file, "rb")) == NULL)
12115 {
12116 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12117
12118 return (-1);
12119 }
12120
12121 while (!feof (fp))
12122 {
12123 memset (rule_buf, 0, BUFSIZ);
12124
12125 rule_len = fgetl (fp, rule_buf);
12126
12127 rule_line++;
12128
12129 if (rule_len == 0) continue;
12130
12131 if (rule_buf[0] == '#') continue;
12132
12133 if (kernel_rules_avail == kernel_rules_cnt)
12134 {
12135 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12136
12137 kernel_rules_avail += INCR_RULES;
12138 }
12139
12140 memset (in, 0, BLOCK_SIZE);
12141 memset (out, 0, BLOCK_SIZE);
12142
12143 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12144
12145 if (result == -1)
12146 {
12147 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12148
12149 continue;
12150 }
12151
12152 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12153 {
12154 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12155
12156 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12157
12158 continue;
12159 }
12160
12161 /* its so slow
12162 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12163 {
12164 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12165
12166 continue;
12167 }
12168 */
12169
12170 kernel_rules_cnt++;
12171 }
12172
12173 fclose (fp);
12174
12175 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12176
12177 all_kernel_rules_buf[i] = kernel_rules_buf;
12178 }
12179
12180 /**
12181 * merge rules or automatic rule generator
12182 */
12183
12184 uint kernel_rules_cnt = 0;
12185
12186 kernel_rule_t *kernel_rules_buf = NULL;
12187
12188 if (attack_mode == ATTACK_MODE_STRAIGHT)
12189 {
12190 if (rp_files_cnt)
12191 {
12192 kernel_rules_cnt = 1;
12193
12194 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12195
12196 repeats[0] = kernel_rules_cnt;
12197
12198 for (uint i = 0; i < rp_files_cnt; i++)
12199 {
12200 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12201
12202 repeats[i + 1] = kernel_rules_cnt;
12203 }
12204
12205 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12206
12207 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12208
12209 for (uint i = 0; i < kernel_rules_cnt; i++)
12210 {
12211 uint out_pos = 0;
12212
12213 kernel_rule_t *out = &kernel_rules_buf[i];
12214
12215 for (uint j = 0; j < rp_files_cnt; j++)
12216 {
12217 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12218 uint in_pos;
12219
12220 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12221
12222 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12223 {
12224 if (out_pos == RULES_MAX - 1)
12225 {
12226 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12227
12228 break;
12229 }
12230
12231 out->cmds[out_pos] = in->cmds[in_pos];
12232 }
12233 }
12234 }
12235
12236 local_free (repeats);
12237 }
12238 else if (rp_gen)
12239 {
12240 uint kernel_rules_avail = 0;
12241
12242 while (kernel_rules_cnt < rp_gen)
12243 {
12244 if (kernel_rules_avail == kernel_rules_cnt)
12245 {
12246 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12247
12248 kernel_rules_avail += INCR_RULES;
12249 }
12250
12251 memset (rule_buf, 0, BLOCK_SIZE);
12252
12253 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12254
12255 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12256
12257 kernel_rules_cnt++;
12258 }
12259 }
12260 }
12261
12262 /**
12263 * generate NOP rules
12264 */
12265
12266 if (kernel_rules_cnt == 0)
12267 {
12268 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12269
12270 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12271
12272 kernel_rules_cnt++;
12273 }
12274
12275 data.kernel_rules_cnt = kernel_rules_cnt;
12276 data.kernel_rules_buf = kernel_rules_buf;
12277
12278 /**
12279 * OpenCL platforms: detect
12280 */
12281
12282 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
12283 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
12284
12285 cl_uint platforms_cnt = 0;
12286 cl_uint platform_devices_cnt = 0;
12287
12288 if (keyspace == 0)
12289 {
12290 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12291
12292 if (platforms_cnt == 0)
12293 {
12294 log_error ("ERROR: No OpenCL compatible platform found");
12295
12296 return (-1);
12297 }
12298 }
12299
12300 /**
12301 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12302 */
12303
12304 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12305 {
12306 cl_platform_id platform = platforms[platform_id];
12307
12308 char platform_vendor[INFOSZ] = { 0 };
12309
12310 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12311
12312 #ifdef HAVE_HWMON
12313 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12314 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12315 {
12316 // make sure that we do not directly control the fan for NVidia
12317
12318 gpu_temp_retain = 0;
12319
12320 data.gpu_temp_retain = gpu_temp_retain;
12321 }
12322 #endif // HAVE_NVML || HAVE_NVAPI
12323 #endif
12324 }
12325
12326 /**
12327 * OpenCL devices: simply push all devices from all platforms into the same device array
12328 */
12329
12330 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12331
12332 data.devices_param = devices_param;
12333
12334 uint devices_cnt = 0;
12335
12336 uint devices_active = 0;
12337
12338 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12339 {
12340 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12341
12342 cl_platform_id platform = platforms[platform_id];
12343
12344 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12345
12346 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12347 {
12348 size_t param_value_size = 0;
12349
12350 const uint device_id = devices_cnt;
12351
12352 hc_device_param_t *device_param = &data.devices_param[device_id];
12353
12354 device_param->device = platform_devices[platform_devices_id];
12355
12356 device_param->device_id = device_id;
12357
12358 device_param->platform_devices_id = platform_devices_id;
12359
12360 // device_type
12361
12362 cl_device_type device_type;
12363
12364 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12365
12366 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12367
12368 device_param->device_type = device_type;
12369
12370 // vendor_id
12371
12372 cl_uint vendor_id = 0;
12373
12374 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12375
12376 device_param->vendor_id = vendor_id;
12377
12378 // device_name
12379
12380 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
12381
12382 char *device_name = (char *) mymalloc (param_value_size);
12383
12384 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
12385
12386 device_param->device_name = device_name;
12387
12388 // device_version
12389
12390 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
12391
12392 char *device_version = (char *) mymalloc (param_value_size);
12393
12394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
12395
12396 device_param->device_version = device_version;
12397
12398 // device_opencl_version
12399
12400 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
12401
12402 char *device_opencl_version = (char *) mymalloc (param_value_size);
12403
12404 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
12405
12406 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
12407
12408 myfree (device_opencl_version);
12409
12410 if (strstr (device_version, "pocl"))
12411 {
12412 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12413 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12414
12415 cl_uint vendor_id = VENDOR_ID_GENERIC;
12416
12417 device_param->vendor_id = vendor_id;
12418 }
12419
12420 // max_compute_units
12421
12422 cl_uint vector_width;
12423
12424 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12425 {
12426 #ifndef OSX
12427 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12428 #else
12429 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
12430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12431 else
12432 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12433 #endif
12434
12435 int is_ti = 0;
12436
12437 const int device_name_len = strlen (device_name);
12438
12439 if (device_name[device_name_len - 2] == 't') is_ti++;
12440 if (device_name[device_name_len - 2] == 'T') is_ti++;
12441 if (device_name[device_name_len - 1] == 'i') is_ti++;
12442 if (device_name[device_name_len - 1] == 'I') is_ti++;
12443
12444 if ((vendor_id == VENDOR_ID_NV) && (is_ti == 2))
12445 {
12446 // Yeah that's a super bad hack, but there's no other attribute we could use
12447
12448 if (vector_width < 2) vector_width *= 2;
12449 }
12450
12451 if (opti_type & OPTI_TYPE_USES_BITS_64)
12452 {
12453 if (vector_width > 1) vector_width /= 2;
12454 }
12455 }
12456 else
12457 {
12458 vector_width = opencl_vector_width;
12459 }
12460
12461 if (vector_width > 8) vector_width = 8;
12462
12463 device_param->vector_width = vector_width;
12464
12465 // max_compute_units
12466
12467 cl_uint device_processors;
12468
12469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12470
12471 device_param->device_processors = device_processors;
12472
12473 // max_mem_alloc_size
12474
12475 cl_ulong device_maxmem_alloc;
12476
12477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12478
12479 device_param->device_maxmem_alloc = device_maxmem_alloc;
12480
12481 // max_mem_alloc_size
12482
12483 cl_ulong device_global_mem;
12484
12485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12486
12487 device_param->device_global_mem = device_global_mem;
12488
12489 // max_clock_frequency
12490
12491 cl_uint device_maxclock_frequency;
12492
12493 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12494
12495 device_param->device_maxclock_frequency = device_maxclock_frequency;
12496
12497 // skipped
12498
12499 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12500 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12501
12502 device_param->skipped = (skipped1 || skipped2);
12503
12504 // driver_version
12505 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
12506
12507 char *driver_version = (char *) mymalloc (param_value_size);
12508
12509 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
12510
12511 device_param->driver_version = driver_version;
12512
12513 // device_name_chksum
12514
12515 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12516
12517 #if __x86_64__
12518 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);
12519 #else
12520 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);
12521 #endif
12522
12523 uint device_name_digest[4] = { 0 };
12524
12525 md5_64 ((uint *) device_name_chksum, device_name_digest);
12526
12527 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
12528
12529 device_param->device_name_chksum = device_name_chksum;
12530
12531 // device_processor_cores
12532
12533 if (device_type & CL_DEVICE_TYPE_CPU)
12534 {
12535 cl_uint device_processor_cores = 1;
12536
12537 device_param->device_processor_cores = device_processor_cores;
12538 }
12539
12540 if (device_type & CL_DEVICE_TYPE_GPU)
12541 {
12542 if (vendor_id == VENDOR_ID_AMD)
12543 {
12544 cl_uint device_processor_cores = 0;
12545
12546 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12547
12548 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12549
12550 device_param->device_processor_cores = device_processor_cores;
12551 }
12552 else if (vendor_id == VENDOR_ID_NV)
12553 {
12554 cl_uint kernel_exec_timeout = 0;
12555
12556 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12557
12558 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12559
12560 device_param->kernel_exec_timeout = kernel_exec_timeout;
12561
12562 cl_uint device_processor_cores = 0;
12563
12564 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12565
12566 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12567
12568 device_param->device_processor_cores = device_processor_cores;
12569
12570 cl_uint sm_minor = 0;
12571 cl_uint sm_major = 0;
12572
12573 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12574 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12575
12576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12577 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12578
12579 device_param->sm_minor = sm_minor;
12580 device_param->sm_major = sm_major;
12581 }
12582 else
12583 {
12584 cl_uint device_processor_cores = 1;
12585
12586 device_param->device_processor_cores = device_processor_cores;
12587 }
12588 }
12589
12590 // display results
12591
12592 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12593 {
12594 if (device_param->skipped == 0)
12595 {
12596 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12597 device_id + 1,
12598 device_name,
12599 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12600 (unsigned int) (device_global_mem / 1024 / 1024),
12601 (unsigned int) (device_maxclock_frequency),
12602 (unsigned int) device_processors);
12603 }
12604 else
12605 {
12606 log_info ("Device #%u: %s, skipped",
12607 device_id + 1,
12608 device_name);
12609 }
12610 }
12611
12612 // common driver check
12613
12614 if (device_param->skipped == 0)
12615 {
12616 if (strstr (device_version, "pocl"))
12617 {
12618 if (force == 0)
12619 {
12620 log_info ("");
12621 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12622 log_info ("You are STRONGLY encouraged not to use it");
12623 log_info ("You can use --force to override this but do not post error reports if you do so");
12624 log_info ("");
12625
12626 return (-1);
12627 }
12628 }
12629
12630 if (device_type & CL_DEVICE_TYPE_GPU)
12631 {
12632 if (vendor_id == VENDOR_ID_NV)
12633 {
12634 if (device_param->kernel_exec_timeout != 0)
12635 {
12636 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);
12637 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12638 }
12639 }
12640 else if (vendor_id == VENDOR_ID_AMD)
12641 {
12642 int catalyst_check = (force == 1) ? 0 : 1;
12643
12644 int catalyst_warn = 0;
12645
12646 int catalyst_broken = 0;
12647
12648 if (catalyst_check == 1)
12649 {
12650 catalyst_warn = 1;
12651
12652 // v14.9 and higher
12653 if (atoi (device_param->driver_version) >= 1573)
12654 {
12655 catalyst_warn = 0;
12656 }
12657
12658 catalyst_check = 0;
12659 }
12660
12661 if (catalyst_broken == 1)
12662 {
12663 log_info ("");
12664 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12665 log_info ("It will pass over cracked hashes and does not report them as cracked");
12666 log_info ("You are STRONGLY encouraged not to use it");
12667 log_info ("You can use --force to override this but do not post error reports if you do so");
12668 log_info ("");
12669
12670 return (-1);
12671 }
12672
12673 if (catalyst_warn == 1)
12674 {
12675 log_info ("");
12676 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12677 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12678 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12679 #ifdef _WIN
12680 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12681 #endif
12682 log_info ("You can use --force to override this but do not post error reports if you do so");
12683 log_info ("");
12684
12685 return (-1);
12686 }
12687 }
12688 }
12689
12690 /**
12691 * kernel accel and loops auto adjustment
12692 */
12693
12694 uint _kernel_accel = kernel_accel;
12695 uint _kernel_loops = kernel_loops;
12696
12697 #ifndef OSX
12698 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode);
12699 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode);
12700 #else
12701 if (kernel_accel_chgd == 0) _kernel_accel = set_kernel_accel (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12702 if (kernel_loops_chgd == 0) _kernel_loops = set_kernel_loops (hash_mode, device_param->device_type & CL_DEVICE_TYPE_GPU);
12703 #endif
12704
12705 if (workload_profile == 1)
12706 {
12707 _kernel_loops /= 8;
12708 _kernel_accel /= 4;
12709
12710 if (_kernel_loops == 0) _kernel_loops = 8;
12711 if (_kernel_accel == 0) _kernel_accel = 2;
12712 }
12713 else if (workload_profile == 3)
12714 {
12715 _kernel_loops *= 8;
12716 _kernel_accel *= 4;
12717
12718 if (_kernel_loops > 1024) _kernel_loops = 1024;
12719 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
12720 }
12721
12722 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
12723
12724 if (benchmark == 1 && benchmark_mode == 1)
12725 {
12726 _kernel_loops *= 8;
12727 _kernel_accel *= 4;
12728
12729 #ifdef OSX
12730 bool isCpu = device_param->device_type & CL_DEVICE_TYPE_CPU;
12731
12732 if (!isCpu)
12733 {
12734 if (hash_mode == 7100 || hash_mode == 8200 || hash_mode == 9600 || \
12735 hash_mode == 11300 || hash_mode == 11600 || hash_mode == 12200)
12736 {
12737 _kernel_accel = 1;
12738 }
12739 else if (hash_mode == 7200 || hash_mode == 9300 || hash_mode == 13000)
12740 {
12741 _kernel_accel = 2;
12742 }
12743 else if (hash_mode == 3200)
12744 {
12745 _kernel_loops = ROUNDS_BCRYPT / 2;
12746 }
12747 else if (hash_mode == 6231)
12748 {
12749 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12750 _kernel_accel = 1;
12751 }
12752 else if (hash_mode == 6241)
12753 {
12754 _kernel_loops = ROUNDS_TRUECRYPT_1K / 4;
12755 _kernel_accel = 1;
12756 }
12757 }
12758 else
12759 {
12760 if (hash_mode == 3200)
12761 {
12762 _kernel_loops = ROUNDS_BCRYPT;
12763 }
12764 else if (hash_mode == 6231)
12765 {
12766 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12767 _kernel_accel = 8;
12768 }
12769 else if (hash_mode == 6241)
12770 {
12771 _kernel_loops = ROUNDS_TRUECRYPT_1K;
12772 _kernel_accel = 128;
12773 }
12774 }
12775 #endif
12776
12777 switch (hash_mode)
12778 {
12779 case 400: _kernel_loops = ROUNDS_PHPASS;
12780 _kernel_accel = 32;
12781 break;
12782 case 500: _kernel_loops = ROUNDS_MD5CRYPT;
12783 _kernel_accel = 32;
12784 break;
12785 case 501: _kernel_loops = ROUNDS_MD5CRYPT;
12786 _kernel_accel = 32;
12787 break;
12788 case 1600: _kernel_loops = ROUNDS_MD5CRYPT;
12789 _kernel_accel = 32;
12790 break;
12791 case 1800: _kernel_loops = ROUNDS_SHA512CRYPT;
12792 #ifndef OSX
12793 _kernel_accel = 16;
12794 #else
12795 if (isCpu) _kernel_accel = 16;
12796 #endif
12797 break;
12798 case 2100: _kernel_loops = ROUNDS_DCC2;
12799 _kernel_accel = 16;
12800 break;
12801 case 2500: _kernel_loops = ROUNDS_WPA2;
12802 #ifndef OSX
12803 _kernel_accel = 32;
12804 #else
12805 if (isCpu) _kernel_accel = 32;
12806 #endif
12807 break;
12808 case 3200: _kernel_accel = 8;
12809 #ifndef OSX
12810 _kernel_loops = ROUNDS_BCRYPT;
12811 #endif
12812 break;
12813 case 5200: _kernel_loops = ROUNDS_PSAFE3;
12814 _kernel_accel = 16;
12815 break;
12816 case 5800: _kernel_loops = ROUNDS_ANDROIDPIN;
12817 _kernel_accel = 16;
12818 break;
12819 case 6211: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12820 #ifndef OSX
12821 _kernel_accel = 64;
12822 #else
12823 if (isCpu) _kernel_accel = 64;
12824 #endif
12825 break;
12826 case 6212: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12827 _kernel_accel = 32;
12828 break;
12829 case 6213: _kernel_loops = ROUNDS_TRUECRYPT_2K;
12830 _kernel_accel = 32;
12831 break;
12832 case 6221: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12833 _kernel_accel = 8;
12834 break;
12835 case 6222: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12836 _kernel_accel = 8;
12837 break;
12838 case 6223: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12839 _kernel_accel = 8;
12840 break;
12841 #ifndef OSX
12842 case 6231: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12843 _kernel_accel = 8;
12844 break;
12845 #endif
12846 case 6232: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12847 _kernel_accel = 8;
12848 break;
12849 case 6233: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12850 _kernel_accel = 8;
12851 break;
12852 #ifndef OSX
12853 case 6241: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12854 _kernel_accel = 128;
12855 break;
12856 #endif
12857 case 6242: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12858 _kernel_accel = 64;
12859 break;
12860 case 6243: _kernel_loops = ROUNDS_TRUECRYPT_1K;
12861 _kernel_accel = 64;
12862 break;
12863 case 6300: _kernel_loops = ROUNDS_MD5CRYPT;
12864 _kernel_accel = 32;
12865 break;
12866 case 6700: _kernel_loops = ROUNDS_SHA1AIX;
12867 _kernel_accel = 128;
12868 break;
12869 case 6400: _kernel_loops = ROUNDS_SHA256AIX;
12870 _kernel_accel = 128;
12871 break;
12872 case 6500: _kernel_loops = ROUNDS_SHA512AIX;
12873 _kernel_accel = 32;
12874 break;
12875 case 6600: _kernel_loops = ROUNDS_AGILEKEY;
12876 _kernel_accel = 64;
12877 break;
12878 case 6800: _kernel_loops = ROUNDS_LASTPASS;
12879 #ifndef OSX
12880 _kernel_accel = 64;
12881 #else
12882 if (isCpu) _kernel_accel = 64;
12883 #endif
12884 break;
12885 case 7100: _kernel_loops = ROUNDS_SHA512OSX;
12886 #ifndef OSX
12887 _kernel_accel = 8;
12888 #endif
12889 break;
12890 case 7200: _kernel_loops = ROUNDS_GRUB;
12891 #ifndef OSX
12892 _kernel_accel = 16;
12893 #endif
12894 break;
12895 case 7400: _kernel_loops = ROUNDS_SHA256CRYPT;
12896 _kernel_accel = 8;
12897 break;
12898 case 7900: _kernel_loops = ROUNDS_DRUPAL7;
12899 #ifndef OSX
12900 _kernel_accel = 8;
12901 #else
12902 if (isCpu) _kernel_accel = 8;
12903 #endif
12904 break;
12905 case 8200: _kernel_loops = ROUNDS_CLOUDKEY;
12906 #ifndef OSX
12907 _kernel_accel = 8;
12908 #endif
12909 break;
12910 case 8800: _kernel_loops = ROUNDS_ANDROIDFDE;
12911 _kernel_accel = 32;
12912 break;
12913 case 8900: _kernel_loops = 1;
12914 _kernel_accel = 64;
12915 break;
12916 case 9000: _kernel_loops = ROUNDS_PSAFE2;
12917 _kernel_accel = 16;
12918 break;
12919 case 9100: _kernel_loops = ROUNDS_LOTUS8;
12920 #ifndef OSX
12921 _kernel_accel = 64;
12922 #else
12923 if (isCpu) _kernel_accel = 64;
12924 #endif
12925 break;
12926 case 9200: _kernel_loops = ROUNDS_CISCO8;
12927 #ifndef OSX
12928 _kernel_accel = 8;
12929 #else
12930 if (isCpu) _kernel_accel = 8;
12931 #endif
12932 break;
12933 case 9300: _kernel_loops = 1;
12934 #ifndef OSX
12935 _kernel_accel = 4;
12936 #endif
12937 break;
12938 case 9400: _kernel_loops = ROUNDS_OFFICE2007;
12939 #ifndef OSX
12940 _kernel_accel = 32;
12941 #else
12942 if (isCpu) _kernel_accel = 32;
12943 #endif
12944 break;
12945 case 9500: _kernel_loops = ROUNDS_OFFICE2010;
12946 #ifndef OSX
12947 _kernel_accel = 32;
12948 #else
12949 if (isCpu) _kernel_accel = 32;
12950 #endif
12951 break;
12952 case 9600: _kernel_loops = ROUNDS_OFFICE2013;
12953 #ifndef OSX
12954 _kernel_accel = 8;
12955 #endif
12956 break;
12957 case 10000: _kernel_loops = ROUNDS_DJANGOPBKDF2;
12958 #ifndef OSX
12959 _kernel_accel = 8;
12960 #else
12961 if (isCpu) _kernel_accel = 8;
12962 #endif
12963 break;
12964 case 10300: _kernel_loops = ROUNDS_SAPH_SHA1;
12965 _kernel_accel = 16;
12966 break;
12967 case 10500: _kernel_loops = ROUNDS_PDF14;
12968 _kernel_accel = 256;
12969 break;
12970 case 10700: _kernel_loops = ROUNDS_PDF17L8;
12971 _kernel_accel = 8;
12972 break;
12973 case 10900: _kernel_loops = ROUNDS_PBKDF2_SHA256;
12974 _kernel_accel = 8;
12975 break;
12976 case 11300: _kernel_loops = ROUNDS_BITCOIN_WALLET;
12977 #ifndef OSX
12978 _kernel_accel = 8;
12979 #endif
12980 break;
12981 case 11600: _kernel_loops = ROUNDS_SEVEN_ZIP;
12982 #ifndef OSX
12983 _kernel_accel = 8;
12984 #endif
12985 break;
12986 case 11900: _kernel_loops = ROUNDS_PBKDF2_MD5;
12987 _kernel_accel = 8;
12988 break;
12989 case 12000: _kernel_loops = ROUNDS_PBKDF2_SHA1;
12990 _kernel_accel = 8;
12991 break;
12992 case 12100: _kernel_loops = ROUNDS_PBKDF2_SHA512;
12993 _kernel_accel = 8;
12994 break;
12995 case 12200: _kernel_loops = ROUNDS_ECRYPTFS;
12996 #ifndef OSX
12997 _kernel_accel = 8;
12998 #endif
12999 break;
13000 case 12300: _kernel_loops = ROUNDS_ORACLET;
13001 _kernel_accel = 8;
13002 break;
13003 case 12500: _kernel_loops = ROUNDS_RAR3;
13004 #ifndef OSX
13005 _kernel_accel = 32;
13006 #else
13007 if (isCpu) _kernel_accel = 32;
13008 #endif
13009 break;
13010 case 12700: _kernel_loops = ROUNDS_MYWALLET;
13011 _kernel_accel = 512;
13012 break;
13013 case 12800: _kernel_loops = ROUNDS_MS_DRSR;
13014 _kernel_accel = 512;
13015 break;
13016 case 12900: _kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
13017 _kernel_accel = 8;
13018 break;
13019 case 13000: _kernel_loops = ROUNDS_RAR5;
13020 #ifndef OSX
13021 _kernel_accel = 8;
13022 #endif
13023 break;
13024 }
13025
13026 // some algorithm collide too fast, make that impossible
13027
13028 switch (hash_mode)
13029 {
13030 case 11500: ((uint *) digests_buf)[1] = 1;
13031 break;
13032 }
13033
13034 if (_kernel_loops > 1024) _kernel_loops = 1024;
13035 if (_kernel_accel > 256) _kernel_accel = 256; // causes memory problems otherwise
13036 }
13037
13038 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
13039 {
13040 _kernel_loops = 1024;
13041 }
13042
13043 if (hash_mode == 12500)
13044 {
13045 _kernel_loops = ROUNDS_RAR3 / 16;
13046 }
13047
13048 device_param->kernel_accel = _kernel_accel;
13049 device_param->kernel_loops = _kernel_loops;
13050
13051 devices_active++;
13052 }
13053
13054 // next please
13055
13056 devices_cnt++;
13057 }
13058 }
13059
13060 if (keyspace == 0 && devices_active == 0)
13061 {
13062 log_error ("ERROR: No devices found/left");
13063
13064 return (-1);
13065 }
13066
13067 data.devices_cnt = devices_cnt;
13068
13069 data.devices_active = devices_active;
13070
13071 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13072 {
13073 log_info ("");
13074 }
13075
13076 /**
13077 * HM devices: init
13078 */
13079
13080 #ifdef HAVE_HWMON
13081 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13082 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13083 #endif
13084
13085 #ifdef HAVE_ADL
13086 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13087 #endif
13088
13089 if (gpu_temp_disable == 0)
13090 {
13091 #if defined(WIN) && defined(HAVE_NVAPI)
13092 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13093
13094 if (nvapi_init (nvapi) == 0)
13095 data.hm_nv = nvapi;
13096
13097 if (data.hm_nv)
13098 {
13099 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13100 {
13101 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13102
13103 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13104
13105 int tmp_out = 0;
13106
13107 for (int i = 0; i < tmp_in; i++)
13108 {
13109 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13110 }
13111
13112 for (int i = 0; i < tmp_out; i++)
13113 {
13114 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13115
13116 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13117
13118 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;
13119 }
13120 }
13121 }
13122 #endif // WIN && HAVE_NVAPI
13123
13124 #if defined(LINUX) && defined(HAVE_NVML)
13125 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13126
13127 if (nvml_init (nvml) == 0)
13128 data.hm_nv = nvml;
13129
13130 if (data.hm_nv)
13131 {
13132 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13133 {
13134 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13135
13136 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13137
13138 int tmp_out = 0;
13139
13140 for (int i = 0; i < tmp_in; i++)
13141 {
13142 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13143 }
13144
13145 for (int i = 0; i < tmp_out; i++)
13146 {
13147 unsigned int speed;
13148
13149 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;
13150 }
13151 }
13152 }
13153 #endif // LINUX && HAVE_NVML
13154
13155 data.hm_amd = NULL;
13156
13157 #ifdef HAVE_ADL
13158 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13159
13160 if (adl_init (adl) == 0)
13161 data.hm_amd = adl;
13162
13163 if (data.hm_amd)
13164 {
13165 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13166 {
13167 // total number of adapters
13168
13169 int hm_adapters_num;
13170
13171 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13172
13173 // adapter info
13174
13175 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13176
13177 if (lpAdapterInfo == NULL) return (-1);
13178
13179 // get a list (of ids of) valid/usable adapters
13180
13181 int num_adl_adapters = 0;
13182
13183 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13184
13185 if (num_adl_adapters > 0)
13186 {
13187 hc_thread_mutex_lock (mux_adl);
13188
13189 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13190
13191 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13192
13193 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13194 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13195
13196 hc_thread_mutex_unlock (mux_adl);
13197 }
13198
13199 myfree (valid_adl_device_list);
13200 myfree (lpAdapterInfo);
13201 }
13202 }
13203 #endif // HAVE_ADL
13204
13205 if (data.hm_amd == NULL && data.hm_nv == NULL)
13206 {
13207 gpu_temp_disable = 1;
13208 }
13209 }
13210
13211 /**
13212 * OpenCL devices: allocate buffer for device specific information
13213 */
13214
13215 #ifdef HAVE_HWMON
13216 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13217
13218 #ifdef HAVE_ADL
13219 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13220
13221 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13222 #endif // ADL
13223 #endif
13224
13225 /**
13226 * enable custom signal handler(s)
13227 */
13228
13229 if (benchmark == 0)
13230 {
13231 hc_signal (sigHandler_default);
13232 }
13233 else
13234 {
13235 hc_signal (sigHandler_benchmark);
13236 }
13237
13238 /**
13239 * User-defined GPU temp handling
13240 */
13241
13242 #ifdef HAVE_HWMON
13243 if (gpu_temp_disable == 1)
13244 {
13245 gpu_temp_abort = 0;
13246 gpu_temp_retain = 0;
13247 }
13248
13249 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13250 {
13251 if (gpu_temp_abort < gpu_temp_retain)
13252 {
13253 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13254
13255 return (-1);
13256 }
13257 }
13258
13259 data.gpu_temp_disable = gpu_temp_disable;
13260 data.gpu_temp_abort = gpu_temp_abort;
13261 data.gpu_temp_retain = gpu_temp_retain;
13262 #endif
13263
13264 /**
13265 * inform the user
13266 */
13267
13268 if (data.quiet == 0)
13269 {
13270 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13271
13272 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);
13273
13274 if (attack_mode == ATTACK_MODE_STRAIGHT)
13275 {
13276 log_info ("Rules: %u", kernel_rules_cnt);
13277 }
13278
13279 if (opti_type)
13280 {
13281 log_info ("Applicable Optimizers:");
13282
13283 for (uint i = 0; i < 32; i++)
13284 {
13285 const uint opti_bit = 1u << i;
13286
13287 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13288 }
13289 }
13290
13291 /**
13292 * Watchdog and Temperature balance
13293 */
13294
13295 #ifdef HAVE_HWMON
13296 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13297 {
13298 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13299 }
13300
13301 if (gpu_temp_abort == 0)
13302 {
13303 log_info ("Watchdog: Temperature abort trigger disabled");
13304 }
13305 else
13306 {
13307 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13308 }
13309
13310 if (gpu_temp_retain == 0)
13311 {
13312 log_info ("Watchdog: Temperature retain trigger disabled");
13313 }
13314 else
13315 {
13316 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13317 }
13318 #endif
13319 }
13320
13321 if (data.quiet == 0) log_info ("");
13322
13323 /**
13324 * HM devices: copy
13325 */
13326
13327 if (gpu_temp_disable == 0)
13328 {
13329 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13330 {
13331 hc_device_param_t *device_param = &data.devices_param[device_id];
13332
13333 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13334
13335 if (device_param->skipped) continue;
13336
13337 const uint platform_devices_id = device_param->platform_devices_id;
13338
13339 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13340 if (device_param->vendor_id == VENDOR_ID_NV)
13341 {
13342 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13343 }
13344 #endif
13345
13346 #ifdef HAVE_ADL
13347 if (device_param->vendor_id == VENDOR_ID_AMD)
13348 {
13349 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13350 }
13351 #endif
13352 }
13353 }
13354
13355 /*
13356 * Temporary fix:
13357 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13358 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13359 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13360 * Driver / ADL bug?
13361 */
13362
13363 #ifdef HAVE_ADL
13364 if (powertune_enable == 1)
13365 {
13366 hc_thread_mutex_lock (mux_adl);
13367
13368 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13369 {
13370 hc_device_param_t *device_param = &data.devices_param[device_id];
13371
13372 if (device_param->skipped) continue;
13373
13374 if (data.hm_device[device_id].od_version == 6)
13375 {
13376 // set powertune value only
13377
13378 int powertune_supported = 0;
13379
13380 int ADL_rc = 0;
13381
13382 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13383 {
13384 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13385
13386 return (-1);
13387 }
13388
13389 if (powertune_supported != 0)
13390 {
13391 // powertune set
13392 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13393
13394 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13395 {
13396 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13397
13398 return (-1);
13399 }
13400
13401 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13402 {
13403 log_error ("ERROR: Failed to set new ADL PowerControl values");
13404
13405 return (-1);
13406 }
13407 }
13408 }
13409 }
13410
13411 hc_thread_mutex_unlock (mux_adl);
13412 }
13413 #endif // HAVE_ADK
13414 #endif // HAVE_HWMON
13415
13416 #ifdef OSX
13417 if (hash_mode == 3000 || hash_mode == 1500 || hash_mode == 10700)
13418 {
13419 if (force == 0)
13420 {
13421 log_info ("");
13422 log_info ("Warning: Hash mode %d is not stable with OSX.", hash_mode);
13423 log_info ("You can use --force to override this but do not post error reports if you do so");
13424 log_info ("");
13425
13426 continue;
13427 }
13428 }
13429 #endif
13430
13431 #ifdef DEBUG
13432 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
13433 #endif
13434
13435 uint kernel_blocks_all = 0;
13436
13437 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13438 {
13439 /**
13440 * host buffer
13441 */
13442
13443 hc_device_param_t *device_param = &data.devices_param[device_id];
13444
13445 if (device_param->skipped) continue;
13446
13447 /**
13448 * device properties
13449 */
13450
13451 char *device_name_chksum = device_param->device_name_chksum;
13452
13453 uint device_processors = device_param->device_processors;
13454
13455 uint device_processor_cores = device_param->device_processor_cores;
13456
13457 cl_device_type device_type = device_param->device_type;
13458
13459 /**
13460 * create context for each device
13461 */
13462
13463 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
13464
13465 /**
13466 * create command-queue
13467 */
13468
13469 // not supported with NV
13470 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13471
13472 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, 0);
13473
13474 /**
13475 * create input buffers on device
13476 */
13477
13478 uint kernel_threads = KERNEL_THREADS;
13479
13480 // bcrypt
13481 if (hash_mode == 3200) kernel_threads = 8;
13482 if (hash_mode == 9000) kernel_threads = 8;
13483
13484 if (device_type & CL_DEVICE_TYPE_CPU)
13485 {
13486 if (benchmark_mode == 0)
13487 {
13488 if (device_param->kernel_accel > 16)
13489 {
13490 device_param->kernel_accel = 16;
13491 }
13492 }
13493 else
13494 {
13495 if (device_param->kernel_accel > 64)
13496 {
13497 device_param->kernel_accel = 64;
13498 }
13499 }
13500 }
13501
13502 uint kernel_power = device_processors * kernel_threads * device_param->kernel_accel;
13503 uint kernel_blocks = kernel_power;
13504
13505 device_param->kernel_threads = kernel_threads;
13506 device_param->kernel_power_user = kernel_power;
13507 device_param->kernel_blocks_user = kernel_blocks;
13508
13509 kernel_blocks_all += kernel_blocks;
13510
13511 uint size_pws = kernel_power * sizeof (pw_t);
13512
13513 uint size_tmps = 4;
13514
13515 switch (hash_mode)
13516 {
13517 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13518 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13519 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13520 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13521 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13522 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13523 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13524 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13525 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13526 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13527 case 6211:
13528 case 6212:
13529 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13530 case 6221:
13531 case 6222:
13532 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13533 case 6231:
13534 case 6232:
13535 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13536 case 6241:
13537 case 6242:
13538 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13539 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13540 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13541 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13542 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13543 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13544 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13545 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13546 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13547 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13548 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13549 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13550 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13551 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13552 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13553 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13554 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13555 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13556 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13557 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13558 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13559 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13560 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13561 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13562 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13563 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13564 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13565 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13566 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13567 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13568 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13569 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13570 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13571 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13572 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13573 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13574 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13575 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13576 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13577 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13578 };
13579
13580 uint size_hooks = 4;
13581
13582 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13583 {
13584 // insert correct hook size
13585 }
13586
13587 // we can optimize some stuff here...
13588
13589 device_param->size_pws = size_pws;
13590 device_param->size_tmps = size_tmps;
13591 device_param->size_hooks = size_hooks;
13592
13593 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13594 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13595
13596 device_param->size_root_css = size_root_css;
13597 device_param->size_markov_css = size_markov_css;
13598
13599 uint size_results = KERNEL_THREADS * sizeof (uint);
13600
13601 device_param->size_results = size_results;
13602
13603 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13604 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13605
13606 uint size_plains = digests_cnt * sizeof (plain_t);
13607 uint size_salts = salts_cnt * sizeof (salt_t);
13608 uint size_esalts = salts_cnt * esalt_size;
13609
13610 device_param->size_plains = size_plains;
13611 device_param->size_digests = size_digests;
13612 device_param->size_shown = size_shown;
13613 device_param->size_salts = size_salts;
13614
13615 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13616 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13617 uint size_tm = 32 * sizeof (bs_word_t);
13618
13619 u64 size_scryptV = 1;
13620
13621 if ((hash_mode == 8900) || (hash_mode == 9300))
13622 {
13623 uint tmto_start = 0;
13624 uint tmto_stop = 10;
13625
13626 if (scrypt_tmto)
13627 {
13628 tmto_start = scrypt_tmto;
13629 }
13630 else
13631 {
13632 // in case the user did not specify the tmto manually
13633 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13634 // but set the lower end only in case the user has a device with too less memory
13635
13636 if (hash_mode == 8900)
13637 {
13638 if (device_param->vendor_id == VENDOR_ID_AMD)
13639 {
13640 tmto_start = 1;
13641 }
13642 else if (device_param->vendor_id == VENDOR_ID_NV)
13643 {
13644 tmto_start = 3;
13645 }
13646 }
13647 else if (hash_mode == 9300)
13648 {
13649 if (device_param->vendor_id == VENDOR_ID_AMD)
13650 {
13651 tmto_start = 3;
13652 }
13653 else if (device_param->vendor_id == VENDOR_ID_NV)
13654 {
13655 tmto_start = 5;
13656 }
13657 }
13658 }
13659
13660 if (quiet == 0) log_info ("");
13661
13662 uint shader_per_mp = 1;
13663
13664 if (device_param->vendor_id == VENDOR_ID_AMD)
13665 {
13666 shader_per_mp = 8;
13667 }
13668 else if (device_param->vendor_id == VENDOR_ID_NV)
13669 {
13670 shader_per_mp = 32;
13671 }
13672
13673 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13674 {
13675 // TODO: in theory the following calculation needs to be done per salt, not global
13676 // we assume all hashes have the same scrypt settings
13677
13678 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13679
13680 size_scryptV /= 1 << tmto;
13681
13682 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13683
13684 if (size_scryptV > device_param->device_maxmem_alloc)
13685 {
13686 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13687
13688 continue;
13689 }
13690
13691 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13692 {
13693 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13694 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13695 }
13696
13697 break;
13698 }
13699
13700 if (data.salts_buf[0].scrypt_phy == 0)
13701 {
13702 log_error ("ERROR: can't allocate enough device memory");
13703
13704 return -1;
13705 }
13706
13707 if (quiet == 0) log_info ("");
13708 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13709 }
13710
13711 /**
13712 * default building options
13713 */
13714
13715 char build_opts[1024] = { 0 };
13716
13717 // we don't have sm_* on vendors not NV but it doesn't matter
13718
13719 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);
13720
13721 /**
13722 * main kernel
13723 */
13724
13725 {
13726 /**
13727 * kernel source filename
13728 */
13729
13730 char source_file[256] = { 0 };
13731
13732 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13733
13734 struct stat sst;
13735
13736 if (stat (source_file, &sst) == -1)
13737 {
13738 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13739
13740 return -1;
13741 }
13742
13743 /**
13744 * kernel cached filename
13745 */
13746
13747 char cached_file[256] = { 0 };
13748
13749 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13750
13751 int cached = 1;
13752
13753 struct stat cst;
13754
13755 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
13756 {
13757 cached = 0;
13758 }
13759
13760 /**
13761 * kernel compile or load
13762 */
13763
13764 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13765
13766 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13767
13768 if (force_jit_compilation == -1)
13769 {
13770 if (cached == 0)
13771 {
13772 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13773
13774 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13775
13776 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13777
13778 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
13779
13780 if (rc != 0)
13781 {
13782 device_param->skipped = true;
13783 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13784 continue;
13785 }
13786
13787 size_t binary_size;
13788
13789 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13790
13791 u8 *binary = (u8 *) mymalloc (binary_size);
13792
13793 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13794
13795 writeProgramBin (cached_file, binary, binary_size);
13796
13797 local_free (binary);
13798 }
13799 else
13800 {
13801 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13802
13803 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13804
13805 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13806
13807 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
13808 }
13809 }
13810 else
13811 {
13812 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13813
13814 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13815
13816 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13817
13818 char build_opts_update[1024] = { 0 };
13819
13820 if (force_jit_compilation == 1500)
13821 {
13822 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13823 }
13824 else if (force_jit_compilation == 8900)
13825 {
13826 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);
13827 }
13828
13829 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
13830
13831 if (rc != 0)
13832 {
13833 device_param->skipped = true;
13834 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13835 }
13836 }
13837
13838 local_free (kernel_lengths);
13839 local_free (kernel_sources[0]);
13840 local_free (kernel_sources);
13841 }
13842
13843 /**
13844 * word generator kernel
13845 */
13846
13847 if (attack_mode != ATTACK_MODE_STRAIGHT)
13848 {
13849 /**
13850 * kernel mp source filename
13851 */
13852
13853 char source_file[256] = { 0 };
13854
13855 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13856
13857 struct stat sst;
13858
13859 if (stat (source_file, &sst) == -1)
13860 {
13861 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13862
13863 return -1;
13864 }
13865
13866 /**
13867 * kernel mp cached filename
13868 */
13869
13870 char cached_file[256] = { 0 };
13871
13872 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13873
13874 int cached = 1;
13875
13876 struct stat cst;
13877
13878 if (stat (cached_file, &cst) == -1)
13879 {
13880 cached = 0;
13881 }
13882
13883 /**
13884 * kernel compile or load
13885 */
13886
13887 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13888
13889 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13890
13891 if (cached == 0)
13892 {
13893 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13894
13895 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13896
13897 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13898
13899 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
13900
13901 if (rc != 0)
13902 {
13903 device_param->skipped = true;
13904 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
13905 continue;
13906 }
13907
13908 size_t binary_size;
13909
13910 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13911
13912 u8 *binary = (u8 *) mymalloc (binary_size);
13913
13914 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13915
13916 writeProgramBin (cached_file, binary, binary_size);
13917
13918 local_free (binary);
13919 }
13920 else
13921 {
13922 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13923
13924 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13925
13926 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13927
13928 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
13929 }
13930
13931 local_free (kernel_lengths);
13932 local_free (kernel_sources[0]);
13933 local_free (kernel_sources);
13934 }
13935
13936 /**
13937 * amplifier kernel
13938 */
13939
13940 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13941 {
13942
13943 }
13944 else
13945 {
13946 /**
13947 * kernel amp source filename
13948 */
13949
13950 char source_file[256] = { 0 };
13951
13952 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13953
13954 struct stat sst;
13955
13956 if (stat (source_file, &sst) == -1)
13957 {
13958 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13959
13960 return -1;
13961 }
13962
13963 /**
13964 * kernel amp cached filename
13965 */
13966
13967 char cached_file[256] = { 0 };
13968
13969 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13970
13971 int cached = 1;
13972
13973 struct stat cst;
13974
13975 if (stat (cached_file, &cst) == -1)
13976 {
13977 cached = 0;
13978 }
13979
13980 /**
13981 * kernel compile or load
13982 */
13983
13984 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13985
13986 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13987
13988 if (cached == 0)
13989 {
13990 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13991
13992 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13993
13994 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
13995
13996 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
13997
13998 if (rc != 0)
13999 {
14000 device_param->skipped = true;
14001 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14002 continue;
14003 }
14004
14005 size_t binary_size;
14006
14007 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14008
14009 u8 *binary = (u8 *) mymalloc (binary_size);
14010
14011 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14012
14013 writeProgramBin (cached_file, binary, binary_size);
14014
14015 local_free (binary);
14016 }
14017 else
14018 {
14019 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14020
14021 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14022
14023 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14024
14025 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14026 }
14027
14028 local_free (kernel_lengths);
14029 local_free (kernel_sources[0]);
14030 local_free (kernel_sources);
14031 }
14032
14033 /**
14034 * global buffers
14035 */
14036
14037 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14038 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14039 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14040 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14041 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14042 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14043 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14044 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14045 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14046 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14047 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14048 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14049 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14050 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14051 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14052 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14053 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14054 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14055
14056 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);
14057 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);
14058 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);
14059 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);
14060 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);
14061 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);
14062 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);
14063 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);
14064 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14065 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14066 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14067
14068 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14069 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14070 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14071 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14072 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14073 run_kernel_bzero (device_param, device_param->d_result, size_results);
14074
14075 /**
14076 * special buffers
14077 */
14078
14079 if (attack_kern == ATTACK_KERN_STRAIGHT)
14080 {
14081 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14082 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14083
14084 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14085
14086 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14087 }
14088 else if (attack_kern == ATTACK_KERN_COMBI)
14089 {
14090 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14091 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14092 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14093 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14094
14095 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14096 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14097 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14098 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14099 }
14100 else if (attack_kern == ATTACK_KERN_BF)
14101 {
14102 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14103 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14104 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14105 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14106 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14107
14108 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14109 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14110 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14111 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14112 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14113 }
14114
14115 if (size_esalts)
14116 {
14117 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
14118
14119 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
14120 }
14121
14122 /**
14123 * main host data
14124 */
14125
14126 uint *result = (uint *) mymalloc (size_results);
14127
14128 device_param->result = result;
14129
14130 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
14131
14132 device_param->pws_buf = pws_buf;
14133
14134 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
14135
14136 for (int i = 0; i < 64; i++)
14137 {
14138 pw_caches[i].pw_buf.pw_len = i;
14139 pw_caches[i].cnt = 0;
14140 }
14141
14142 device_param->pw_caches = pw_caches;
14143
14144 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
14145
14146 device_param->combs_buf = combs_buf;
14147
14148 void *hooks_buf = mymalloc (size_hooks);
14149
14150 device_param->hooks_buf = hooks_buf;
14151
14152 device_param->pw_transpose = pw_transpose_to_hi1;
14153 device_param->pw_add = pw_add_to_hc1;
14154
14155 /**
14156 * kernel args
14157 */
14158
14159 device_param->kernel_params_buf32[21] = bitmap_mask;
14160 device_param->kernel_params_buf32[22] = bitmap_shift1;
14161 device_param->kernel_params_buf32[23] = bitmap_shift2;
14162 device_param->kernel_params_buf32[24] = 0; // salt_pos
14163 device_param->kernel_params_buf32[25] = 0; // loop_pos
14164 device_param->kernel_params_buf32[26] = 0; // loop_cnt
14165 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
14166 device_param->kernel_params_buf32[28] = 0; // digests_cnt
14167 device_param->kernel_params_buf32[29] = 0; // digests_offset
14168 device_param->kernel_params_buf32[30] = 0; // combs_mode
14169 device_param->kernel_params_buf32[31] = 0; // gid_max
14170
14171 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14172 ? &device_param->d_pws_buf
14173 : &device_param->d_pws_amp_buf;
14174 device_param->kernel_params[ 1] = &device_param->d_rules_c;
14175 device_param->kernel_params[ 2] = &device_param->d_combs_c;
14176 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
14177 device_param->kernel_params[ 4] = &device_param->d_tmps;
14178 device_param->kernel_params[ 5] = &device_param->d_hooks;
14179 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
14180 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
14181 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
14182 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
14183 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
14184 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
14185 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
14186 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
14187 device_param->kernel_params[14] = &device_param->d_plain_bufs;
14188 device_param->kernel_params[15] = &device_param->d_digests_buf;
14189 device_param->kernel_params[16] = &device_param->d_digests_shown;
14190 device_param->kernel_params[17] = &device_param->d_salt_bufs;
14191 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
14192 device_param->kernel_params[19] = &device_param->d_result;
14193 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
14194 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
14195 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
14196 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
14197 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
14198 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
14199 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
14200 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
14201 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
14202 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
14203 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
14204 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
14205
14206 device_param->kernel_params_mp_buf64[3] = 0;
14207 device_param->kernel_params_mp_buf32[4] = 0;
14208 device_param->kernel_params_mp_buf32[5] = 0;
14209 device_param->kernel_params_mp_buf32[6] = 0;
14210 device_param->kernel_params_mp_buf32[7] = 0;
14211 device_param->kernel_params_mp_buf32[8] = 0;
14212
14213 device_param->kernel_params_mp[0] = NULL;
14214 device_param->kernel_params_mp[1] = NULL;
14215 device_param->kernel_params_mp[2] = NULL;
14216 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
14217 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
14218 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
14219 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
14220 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
14221 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
14222
14223 device_param->kernel_params_mp_l_buf64[3] = 0;
14224 device_param->kernel_params_mp_l_buf32[4] = 0;
14225 device_param->kernel_params_mp_l_buf32[5] = 0;
14226 device_param->kernel_params_mp_l_buf32[6] = 0;
14227 device_param->kernel_params_mp_l_buf32[7] = 0;
14228 device_param->kernel_params_mp_l_buf32[8] = 0;
14229 device_param->kernel_params_mp_l_buf32[9] = 0;
14230
14231 device_param->kernel_params_mp_l[0] = NULL;
14232 device_param->kernel_params_mp_l[1] = NULL;
14233 device_param->kernel_params_mp_l[2] = NULL;
14234 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14235 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14236 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14237 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14238 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14239 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14240 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14241
14242 device_param->kernel_params_mp_r_buf64[3] = 0;
14243 device_param->kernel_params_mp_r_buf32[4] = 0;
14244 device_param->kernel_params_mp_r_buf32[5] = 0;
14245 device_param->kernel_params_mp_r_buf32[6] = 0;
14246 device_param->kernel_params_mp_r_buf32[7] = 0;
14247 device_param->kernel_params_mp_r_buf32[8] = 0;
14248
14249 device_param->kernel_params_mp_r[0] = NULL;
14250 device_param->kernel_params_mp_r[1] = NULL;
14251 device_param->kernel_params_mp_r[2] = NULL;
14252 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14253 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14254 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14255 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14256 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14257 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14258
14259 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14260 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14261
14262 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14263 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14264 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14265 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14266 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14267 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14268 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14269
14270 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14271
14272 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14273 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14274
14275 /**
14276 * kernel name
14277 */
14278
14279 char kernel_name[64] = { 0 };
14280
14281 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14282 {
14283 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14284 {
14285 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14286
14287 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14288
14289 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14290
14291 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14292
14293 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14294
14295 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14296 }
14297 else
14298 {
14299 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14300
14301 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14302
14303 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14304
14305 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14306
14307 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14308
14309 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14310 }
14311
14312 if (data.attack_mode == ATTACK_MODE_BF)
14313 {
14314 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14315 {
14316 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14317
14318 device_param->kernel_tb = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14319
14320 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14321
14322 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14323 }
14324 }
14325 }
14326 else
14327 {
14328 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14329
14330 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14331
14332 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14333
14334 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14335
14336 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14337
14338 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14339
14340 if (opts_type & OPTS_TYPE_HOOK12)
14341 {
14342 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14343
14344 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14345 }
14346
14347 if (opts_type & OPTS_TYPE_HOOK23)
14348 {
14349 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14350
14351 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
14352 }
14353 }
14354
14355 for (uint i = 0; i <= 20; i++)
14356 {
14357 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14358 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14359 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14360
14361 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14362 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14363 }
14364
14365 for (uint i = 21; i <= 31; i++)
14366 {
14367 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14368 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14369 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14370
14371 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14372 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14373 }
14374
14375 if (attack_mode == ATTACK_MODE_BF)
14376 {
14377 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
14378 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
14379
14380 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14381 {
14382 hc_clSetKernelArg (data.ocl, device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14383
14384 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14385 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14386 }
14387 }
14388 else if (attack_mode == ATTACK_MODE_HYBRID1)
14389 {
14390 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14391 }
14392 else if (attack_mode == ATTACK_MODE_HYBRID2)
14393 {
14394 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
14395 }
14396
14397 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14398 {
14399 // nothing to do
14400 }
14401 else
14402 {
14403 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
14404 }
14405
14406 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14407 {
14408 // nothing to do
14409 }
14410 else
14411 {
14412 for (uint i = 0; i < 5; i++)
14413 {
14414 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14415 }
14416
14417 for (uint i = 5; i < 7; i++)
14418 {
14419 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14420 }
14421 }
14422
14423 /**
14424 * Store initial fanspeed if gpu_temp_retain is enabled
14425 */
14426
14427 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14428 int gpu_temp_retain_set = 0;
14429
14430 if (gpu_temp_disable == 0)
14431 {
14432 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14433 {
14434 hc_thread_mutex_lock (mux_adl);
14435
14436 if (data.hm_device[device_id].fan_supported == 1)
14437 {
14438 if (gpu_temp_retain_chgd == 0)
14439 {
14440 uint cur_temp = 0;
14441 uint default_temp = 0;
14442
14443 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);
14444
14445 if (ADL_rc == ADL_OK)
14446 {
14447 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14448
14449 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14450
14451 // special case with multi gpu setups: always use minimum retain
14452
14453 if (gpu_temp_retain_set == 0)
14454 {
14455 gpu_temp_retain = gpu_temp_retain_target;
14456 gpu_temp_retain_set = 1;
14457 }
14458 else
14459 {
14460 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14461 }
14462
14463 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14464 }
14465 }
14466
14467 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14468
14469 temp_retain_fanspeed_value[device_id] = fan_speed;
14470
14471 if (fan_speed == -1)
14472 {
14473 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14474
14475 temp_retain_fanspeed_value[device_id] = 0;
14476 }
14477 }
14478
14479 hc_thread_mutex_unlock (mux_adl);
14480 }
14481 }
14482
14483 /**
14484 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14485 */
14486
14487 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14488 {
14489 hc_thread_mutex_lock (mux_adl);
14490
14491 if (data.hm_device[device_id].od_version == 6)
14492 {
14493 int ADL_rc;
14494
14495 // check powertune capabilities first, if not available then skip device
14496
14497 int powertune_supported = 0;
14498
14499 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14500 {
14501 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14502
14503 return (-1);
14504 }
14505
14506 if (powertune_supported != 0)
14507 {
14508 // powercontrol settings
14509
14510 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14511
14512 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14513 {
14514 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14515 }
14516
14517 if (ADL_rc != ADL_OK)
14518 {
14519 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14520
14521 return (-1);
14522 }
14523
14524 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14525 {
14526 log_error ("ERROR: Failed to set new ADL PowerControl values");
14527
14528 return (-1);
14529 }
14530
14531 // clocks
14532
14533 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14534
14535 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14536
14537 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)
14538 {
14539 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14540
14541 return (-1);
14542 }
14543
14544 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14545
14546 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14547
14548 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14549 {
14550 log_error ("ERROR: Failed to get ADL device capabilities");
14551
14552 return (-1);
14553 }
14554
14555 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14556 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14557
14558 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14559 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14560
14561 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14562 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14563
14564 // warning if profile has too low max values
14565
14566 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14567 {
14568 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14569 }
14570
14571 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14572 {
14573 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14574 }
14575
14576 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14577
14578 performance_state->iNumberOfPerformanceLevels = 2;
14579
14580 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14581 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14582 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14583 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14584
14585 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)
14586 {
14587 log_info ("ERROR: Failed to set ADL performance state");
14588
14589 return (-1);
14590 }
14591
14592 local_free (performance_state);
14593 }
14594 }
14595
14596 hc_thread_mutex_unlock (mux_adl);
14597 }
14598 #endif // HAVE_HWMON && HAVE_ADL
14599 }
14600
14601 data.kernel_blocks_all = kernel_blocks_all;
14602
14603 if (data.quiet == 0) log_info ("");
14604
14605 /**
14606 * Inform user which algorithm is checked and at which workload setting
14607 */
14608
14609 if (benchmark == 1)
14610 {
14611 quiet = 0;
14612
14613 data.quiet = quiet;
14614
14615 char *hash_type = strhashtype (data.hash_mode); // not a bug
14616
14617 log_info ("Hashtype: %s", hash_type);
14618 //log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14619 log_info ("");
14620 }
14621
14622 /**
14623 * keep track of the progress
14624 */
14625
14626 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14627 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14628 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14629
14630 /**
14631 * open filehandles
14632 */
14633
14634 #if _WIN
14635 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14636 {
14637 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14638
14639 return (-1);
14640 }
14641
14642 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14643 {
14644 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14645
14646 return (-1);
14647 }
14648
14649 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14650 {
14651 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14652
14653 return (-1);
14654 }
14655 #endif
14656
14657 /**
14658 * dictionary pad
14659 */
14660
14661 segment_size *= (1024 * 1024);
14662
14663 data.segment_size = segment_size;
14664
14665 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14666
14667 wl_data->buf = (char *) mymalloc (segment_size);
14668 wl_data->avail = segment_size;
14669 wl_data->incr = segment_size;
14670 wl_data->cnt = 0;
14671 wl_data->pos = 0;
14672
14673 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14674
14675 data.wordlist_mode = wordlist_mode;
14676
14677 cs_t *css_buf = NULL;
14678 uint css_cnt = 0;
14679 uint dictcnt = 0;
14680 uint maskcnt = 1;
14681 char **masks = NULL;
14682 char **dictfiles = NULL;
14683
14684 uint mask_from_file = 0;
14685
14686 if (attack_mode == ATTACK_MODE_STRAIGHT)
14687 {
14688 if (wordlist_mode == WL_MODE_FILE)
14689 {
14690 int wls_left = myargc - (optind + 1);
14691
14692 for (int i = 0; i < wls_left; i++)
14693 {
14694 char *l0_filename = myargv[optind + 1 + i];
14695
14696 struct stat l0_stat;
14697
14698 if (stat (l0_filename, &l0_stat) == -1)
14699 {
14700 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14701
14702 return (-1);
14703 }
14704
14705 uint is_dir = S_ISDIR (l0_stat.st_mode);
14706
14707 if (is_dir == 0)
14708 {
14709 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14710
14711 dictcnt++;
14712
14713 dictfiles[dictcnt - 1] = l0_filename;
14714 }
14715 else
14716 {
14717 // do not allow --keyspace w/ a directory
14718
14719 if (keyspace == 1)
14720 {
14721 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14722
14723 return (-1);
14724 }
14725
14726 char **dictionary_files = NULL;
14727
14728 dictionary_files = scan_directory (l0_filename);
14729
14730 if (dictionary_files != NULL)
14731 {
14732 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14733
14734 for (int d = 0; dictionary_files[d] != NULL; d++)
14735 {
14736 char *l1_filename = dictionary_files[d];
14737
14738 struct stat l1_stat;
14739
14740 if (stat (l1_filename, &l1_stat) == -1)
14741 {
14742 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14743
14744 return (-1);
14745 }
14746
14747 if (S_ISREG (l1_stat.st_mode))
14748 {
14749 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14750
14751 dictcnt++;
14752
14753 dictfiles[dictcnt - 1] = strdup (l1_filename);
14754 }
14755 }
14756 }
14757
14758 local_free (dictionary_files);
14759 }
14760 }
14761
14762 if (dictcnt < 1)
14763 {
14764 log_error ("ERROR: No usable dictionary file found.");
14765
14766 return (-1);
14767 }
14768 }
14769 else if (wordlist_mode == WL_MODE_STDIN)
14770 {
14771 dictcnt = 1;
14772 }
14773 }
14774 else if (attack_mode == ATTACK_MODE_COMBI)
14775 {
14776 // display
14777
14778 char *dictfile1 = myargv[optind + 1 + 0];
14779 char *dictfile2 = myargv[optind + 1 + 1];
14780
14781 // find the bigger dictionary and use as base
14782
14783 FILE *fp1 = NULL;
14784 FILE *fp2 = NULL;
14785
14786 struct stat tmp_stat;
14787
14788 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14789 {
14790 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14791
14792 return (-1);
14793 }
14794
14795 if (stat (dictfile1, &tmp_stat) == -1)
14796 {
14797 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14798
14799 fclose (fp1);
14800
14801 return (-1);
14802 }
14803
14804 if (S_ISDIR (tmp_stat.st_mode))
14805 {
14806 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14807
14808 fclose (fp1);
14809
14810 return (-1);
14811 }
14812
14813 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14814 {
14815 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14816
14817 fclose (fp1);
14818
14819 return (-1);
14820 }
14821
14822 if (stat (dictfile2, &tmp_stat) == -1)
14823 {
14824 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14825
14826 fclose (fp1);
14827 fclose (fp2);
14828
14829 return (-1);
14830 }
14831
14832 if (S_ISDIR (tmp_stat.st_mode))
14833 {
14834 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14835
14836 fclose (fp1);
14837 fclose (fp2);
14838
14839 return (-1);
14840 }
14841
14842 data.combs_cnt = 1;
14843
14844 data.quiet = 1;
14845
14846 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14847
14848 data.quiet = quiet;
14849
14850 if (words1_cnt == 0)
14851 {
14852 log_error ("ERROR: %s: empty file", dictfile1);
14853
14854 fclose (fp1);
14855 fclose (fp2);
14856
14857 return (-1);
14858 }
14859
14860 data.combs_cnt = 1;
14861
14862 data.quiet = 1;
14863
14864 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14865
14866 data.quiet = quiet;
14867
14868 if (words2_cnt == 0)
14869 {
14870 log_error ("ERROR: %s: empty file", dictfile2);
14871
14872 fclose (fp1);
14873 fclose (fp2);
14874
14875 return (-1);
14876 }
14877
14878 fclose (fp1);
14879 fclose (fp2);
14880
14881 data.dictfile = dictfile1;
14882 data.dictfile2 = dictfile2;
14883
14884 if (words1_cnt >= words2_cnt)
14885 {
14886 data.combs_cnt = words2_cnt;
14887 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14888
14889 dictfiles = &data.dictfile;
14890
14891 dictcnt = 1;
14892 }
14893 else
14894 {
14895 data.combs_cnt = words1_cnt;
14896 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14897
14898 dictfiles = &data.dictfile2;
14899
14900 dictcnt = 1;
14901
14902 // we also have to switch wordlist related rules!
14903
14904 char *tmpc = data.rule_buf_l;
14905
14906 data.rule_buf_l = data.rule_buf_r;
14907 data.rule_buf_r = tmpc;
14908
14909 int tmpi = data.rule_len_l;
14910
14911 data.rule_len_l = data.rule_len_r;
14912 data.rule_len_r = tmpi;
14913 }
14914 }
14915 else if (attack_mode == ATTACK_MODE_BF)
14916 {
14917 char *mask = NULL;
14918
14919 maskcnt = 0;
14920
14921 if (benchmark == 0)
14922 {
14923 mask = myargv[optind + 1];
14924
14925 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14926
14927 if ((optind + 2) <= myargc)
14928 {
14929 struct stat file_stat;
14930
14931 if (stat (mask, &file_stat) == -1)
14932 {
14933 maskcnt = 1;
14934
14935 masks[maskcnt - 1] = mystrdup (mask);
14936 }
14937 else
14938 {
14939 int wls_left = myargc - (optind + 1);
14940
14941 uint masks_avail = INCR_MASKS;
14942
14943 for (int i = 0; i < wls_left; i++)
14944 {
14945 if (i != 0)
14946 {
14947 mask = myargv[optind + 1 + i];
14948
14949 if (stat (mask, &file_stat) == -1)
14950 {
14951 log_error ("ERROR: %s: %s", mask, strerror (errno));
14952
14953 return (-1);
14954 }
14955 }
14956
14957 uint is_file = S_ISREG (file_stat.st_mode);
14958
14959 if (is_file == 1)
14960 {
14961 FILE *mask_fp;
14962
14963 if ((mask_fp = fopen (mask, "r")) == NULL)
14964 {
14965 log_error ("ERROR: %s: %s", mask, strerror (errno));
14966
14967 return (-1);
14968 }
14969
14970 char line_buf[BUFSIZ] = { 0 };
14971
14972 while (!feof (mask_fp))
14973 {
14974 memset (line_buf, 0, BUFSIZ);
14975
14976 int line_len = fgetl (mask_fp, line_buf);
14977
14978 if (line_len == 0) continue;
14979
14980 if (line_buf[0] == '#') continue;
14981
14982 if (masks_avail == maskcnt)
14983 {
14984 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14985
14986 masks_avail += INCR_MASKS;
14987 }
14988
14989 masks[maskcnt] = mystrdup (line_buf);
14990
14991 maskcnt++;
14992 }
14993
14994 fclose (mask_fp);
14995 }
14996 else
14997 {
14998 log_error ("ERROR: %s: unsupported file-type", mask);
14999
15000 return (-1);
15001 }
15002 }
15003
15004 mask_from_file = 1;
15005 }
15006 }
15007 else
15008 {
15009 custom_charset_1 = (char *) "?l?d?u";
15010 custom_charset_2 = (char *) "?l?d";
15011 custom_charset_3 = (char *) "?l?d*!$@_";
15012
15013 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15014 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15015 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15016
15017 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15018
15019 wordlist_mode = WL_MODE_MASK;
15020
15021 data.wordlist_mode = wordlist_mode;
15022
15023 increment = 1;
15024
15025 maskcnt = 1;
15026 }
15027 }
15028 else
15029 {
15030 /**
15031 * generate full masks and charsets
15032 */
15033
15034 masks = (char **) mymalloc (sizeof (char *));
15035
15036 switch (hash_mode)
15037 {
15038 case 1731: pw_min = 5;
15039 pw_max = 5;
15040 mask = mystrdup ("?b?b?b?b?b");
15041 break;
15042 case 12500: pw_min = 5;
15043 pw_max = 5;
15044 mask = mystrdup ("?b?b?b?b?b");
15045 break;
15046 default: pw_min = 7;
15047 pw_max = 7;
15048 mask = mystrdup ("?b?b?b?b?b?b?b");
15049 break;
15050 }
15051
15052 maskcnt = 1;
15053
15054 masks[maskcnt - 1] = mystrdup (mask);
15055
15056 wordlist_mode = WL_MODE_MASK;
15057
15058 data.wordlist_mode = wordlist_mode;
15059
15060 increment = 1;
15061 }
15062
15063 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15064
15065 if (increment)
15066 {
15067 if (increment_min > pw_min) pw_min = increment_min;
15068
15069 if (increment_max < pw_max) pw_max = increment_max;
15070 }
15071 }
15072 else if (attack_mode == ATTACK_MODE_HYBRID1)
15073 {
15074 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15075
15076 // display
15077
15078 char *mask = myargv[myargc - 1];
15079
15080 maskcnt = 0;
15081
15082 masks = (char **) mymalloc (1 * sizeof (char *));
15083
15084 // mod
15085
15086 struct stat file_stat;
15087
15088 if (stat (mask, &file_stat) == -1)
15089 {
15090 maskcnt = 1;
15091
15092 masks[maskcnt - 1] = mystrdup (mask);
15093 }
15094 else
15095 {
15096 uint is_file = S_ISREG (file_stat.st_mode);
15097
15098 if (is_file == 1)
15099 {
15100 FILE *mask_fp;
15101
15102 if ((mask_fp = fopen (mask, "r")) == NULL)
15103 {
15104 log_error ("ERROR: %s: %s", mask, strerror (errno));
15105
15106 return (-1);
15107 }
15108
15109 char line_buf[BUFSIZ] = { 0 };
15110
15111 uint masks_avail = 1;
15112
15113 while (!feof (mask_fp))
15114 {
15115 memset (line_buf, 0, BUFSIZ);
15116
15117 int line_len = fgetl (mask_fp, line_buf);
15118
15119 if (line_len == 0) continue;
15120
15121 if (line_buf[0] == '#') continue;
15122
15123 if (masks_avail == maskcnt)
15124 {
15125 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15126
15127 masks_avail += INCR_MASKS;
15128 }
15129
15130 masks[maskcnt] = mystrdup (line_buf);
15131
15132 maskcnt++;
15133 }
15134
15135 fclose (mask_fp);
15136
15137 mask_from_file = 1;
15138 }
15139 else
15140 {
15141 maskcnt = 1;
15142
15143 masks[maskcnt - 1] = mystrdup (mask);
15144 }
15145 }
15146
15147 // base
15148
15149 int wls_left = myargc - (optind + 2);
15150
15151 for (int i = 0; i < wls_left; i++)
15152 {
15153 char *filename = myargv[optind + 1 + i];
15154
15155 struct stat file_stat;
15156
15157 if (stat (filename, &file_stat) == -1)
15158 {
15159 log_error ("ERROR: %s: %s", filename, strerror (errno));
15160
15161 return (-1);
15162 }
15163
15164 uint is_dir = S_ISDIR (file_stat.st_mode);
15165
15166 if (is_dir == 0)
15167 {
15168 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15169
15170 dictcnt++;
15171
15172 dictfiles[dictcnt - 1] = filename;
15173 }
15174 else
15175 {
15176 // do not allow --keyspace w/ a directory
15177
15178 if (keyspace == 1)
15179 {
15180 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15181
15182 return (-1);
15183 }
15184
15185 char **dictionary_files = NULL;
15186
15187 dictionary_files = scan_directory (filename);
15188
15189 if (dictionary_files != NULL)
15190 {
15191 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15192
15193 for (int d = 0; dictionary_files[d] != NULL; d++)
15194 {
15195 char *l1_filename = dictionary_files[d];
15196
15197 struct stat l1_stat;
15198
15199 if (stat (l1_filename, &l1_stat) == -1)
15200 {
15201 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15202
15203 return (-1);
15204 }
15205
15206 if (S_ISREG (l1_stat.st_mode))
15207 {
15208 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15209
15210 dictcnt++;
15211
15212 dictfiles[dictcnt - 1] = strdup (l1_filename);
15213 }
15214 }
15215 }
15216
15217 local_free (dictionary_files);
15218 }
15219 }
15220
15221 if (dictcnt < 1)
15222 {
15223 log_error ("ERROR: No usable dictionary file found.");
15224
15225 return (-1);
15226 }
15227
15228 if (increment)
15229 {
15230 maskcnt = 0;
15231
15232 uint mask_min = increment_min; // we can't reject smaller masks here
15233 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15234
15235 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15236 {
15237 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15238
15239 if (cur_mask == NULL) break;
15240
15241 masks[maskcnt] = cur_mask;
15242
15243 maskcnt++;
15244
15245 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15246 }
15247 }
15248 }
15249 else if (attack_mode == ATTACK_MODE_HYBRID2)
15250 {
15251 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15252
15253 // display
15254
15255 char *mask = myargv[optind + 1 + 0];
15256
15257 maskcnt = 0;
15258
15259 masks = (char **) mymalloc (1 * sizeof (char *));
15260
15261 // mod
15262
15263 struct stat file_stat;
15264
15265 if (stat (mask, &file_stat) == -1)
15266 {
15267 maskcnt = 1;
15268
15269 masks[maskcnt - 1] = mystrdup (mask);
15270 }
15271 else
15272 {
15273 uint is_file = S_ISREG (file_stat.st_mode);
15274
15275 if (is_file == 1)
15276 {
15277 FILE *mask_fp;
15278
15279 if ((mask_fp = fopen (mask, "r")) == NULL)
15280 {
15281 log_error ("ERROR: %s: %s", mask, strerror (errno));
15282
15283 return (-1);
15284 }
15285
15286 char line_buf[BUFSIZ] = { 0 };
15287
15288 uint masks_avail = 1;
15289
15290 while (!feof (mask_fp))
15291 {
15292 memset (line_buf, 0, BUFSIZ);
15293
15294 int line_len = fgetl (mask_fp, line_buf);
15295
15296 if (line_len == 0) continue;
15297
15298 if (line_buf[0] == '#') continue;
15299
15300 if (masks_avail == maskcnt)
15301 {
15302 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15303
15304 masks_avail += INCR_MASKS;
15305 }
15306
15307 masks[maskcnt] = mystrdup (line_buf);
15308
15309 maskcnt++;
15310 }
15311
15312 fclose (mask_fp);
15313
15314 mask_from_file = 1;
15315 }
15316 else
15317 {
15318 maskcnt = 1;
15319
15320 masks[maskcnt - 1] = mystrdup (mask);
15321 }
15322 }
15323
15324 // base
15325
15326 int wls_left = myargc - (optind + 2);
15327
15328 for (int i = 0; i < wls_left; i++)
15329 {
15330 char *filename = myargv[optind + 2 + i];
15331
15332 struct stat file_stat;
15333
15334 if (stat (filename, &file_stat) == -1)
15335 {
15336 log_error ("ERROR: %s: %s", filename, strerror (errno));
15337
15338 return (-1);
15339 }
15340
15341 uint is_dir = S_ISDIR (file_stat.st_mode);
15342
15343 if (is_dir == 0)
15344 {
15345 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15346
15347 dictcnt++;
15348
15349 dictfiles[dictcnt - 1] = filename;
15350 }
15351 else
15352 {
15353 // do not allow --keyspace w/ a directory
15354
15355 if (keyspace == 1)
15356 {
15357 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15358
15359 return (-1);
15360 }
15361
15362 char **dictionary_files = NULL;
15363
15364 dictionary_files = scan_directory (filename);
15365
15366 if (dictionary_files != NULL)
15367 {
15368 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15369
15370 for (int d = 0; dictionary_files[d] != NULL; d++)
15371 {
15372 char *l1_filename = dictionary_files[d];
15373
15374 struct stat l1_stat;
15375
15376 if (stat (l1_filename, &l1_stat) == -1)
15377 {
15378 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15379
15380 return (-1);
15381 }
15382
15383 if (S_ISREG (l1_stat.st_mode))
15384 {
15385 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15386
15387 dictcnt++;
15388
15389 dictfiles[dictcnt - 1] = strdup (l1_filename);
15390 }
15391 }
15392 }
15393
15394 local_free (dictionary_files);
15395 }
15396 }
15397
15398 if (dictcnt < 1)
15399 {
15400 log_error ("ERROR: No usable dictionary file found.");
15401
15402 return (-1);
15403 }
15404
15405 if (increment)
15406 {
15407 maskcnt = 0;
15408
15409 uint mask_min = increment_min; // we can't reject smaller masks here
15410 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15411
15412 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15413 {
15414 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15415
15416 if (cur_mask == NULL) break;
15417
15418 masks[maskcnt] = cur_mask;
15419
15420 maskcnt++;
15421
15422 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15423 }
15424 }
15425 }
15426
15427 data.pw_min = pw_min;
15428 data.pw_max = pw_max;
15429
15430 /**
15431 * weak hash check
15432 */
15433
15434 if (weak_hash_threshold >= salts_cnt)
15435 {
15436 hc_device_param_t *device_param = NULL;
15437
15438 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15439 {
15440 device_param = &data.devices_param[device_id];
15441
15442 if (device_param->skipped) continue;
15443
15444 break;
15445 }
15446
15447 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15448
15449 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15450 {
15451 weak_hash_check (device_param, salt_pos, devices_param->kernel_loops);
15452 }
15453 }
15454
15455 // Display hack, guarantee that there is at least one \r before real start
15456
15457 if (data.quiet == 0) log_info_nn ("");
15458
15459 /**
15460 * status and monitor threads
15461 */
15462
15463 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15464
15465 hc_thread_t i_thread = 0;
15466
15467 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15468 {
15469 hc_thread_create (i_thread, thread_keypress, &benchmark);
15470 }
15471
15472 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15473
15474 uint ni_threads_cnt = 0;
15475
15476 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15477
15478 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15479
15480 ni_threads_cnt++;
15481
15482 /**
15483 * Outfile remove
15484 */
15485
15486 if (keyspace == 0)
15487 {
15488 if (outfile_check_timer != 0)
15489 {
15490 if (data.outfile_check_directory != NULL)
15491 {
15492 if ((hash_mode != 5200) &&
15493 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15494 (hash_mode != 9000))
15495 {
15496 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15497
15498 ni_threads_cnt++;
15499 }
15500 else
15501 {
15502 outfile_check_timer = 0;
15503 }
15504 }
15505 else
15506 {
15507 outfile_check_timer = 0;
15508 }
15509 }
15510 }
15511
15512 /**
15513 * Inform the user if we got some hashes remove because of the pot file remove feature
15514 */
15515
15516 if (data.quiet == 0)
15517 {
15518 if (potfile_remove_cracks > 0)
15519 {
15520 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15521 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15522 }
15523 }
15524
15525 data.outfile_check_timer = outfile_check_timer;
15526
15527 /**
15528 * main loop
15529 */
15530
15531 char **induction_dictionaries = NULL;
15532
15533 int induction_dictionaries_cnt = 0;
15534
15535 hcstat_table_t *root_table_buf = NULL;
15536 hcstat_table_t *markov_table_buf = NULL;
15537
15538 uint initial_restore_done = 0;
15539
15540 data.maskcnt = maskcnt;
15541
15542 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15543 {
15544 if (data.devices_status == STATUS_CRACKED) break;
15545
15546 data.devices_status = STATUS_INIT;
15547
15548 if (maskpos > rd->maskpos)
15549 {
15550 rd->dictpos = 0;
15551 }
15552
15553 rd->maskpos = maskpos;
15554 data.maskpos = maskpos;
15555
15556 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15557 {
15558 char *mask = masks[maskpos];
15559
15560 if (mask_from_file == 1)
15561 {
15562 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15563
15564 char *str_ptr;
15565 uint str_pos;
15566
15567 uint mask_offset = 0;
15568
15569 uint separator_cnt;
15570
15571 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15572 {
15573 str_ptr = strstr (mask + mask_offset, ",");
15574
15575 if (str_ptr == NULL) break;
15576
15577 str_pos = str_ptr - mask;
15578
15579 // escaped separator, i.e. "\,"
15580
15581 if (str_pos > 0)
15582 {
15583 if (mask[str_pos - 1] == '\\')
15584 {
15585 separator_cnt --;
15586
15587 mask_offset = str_pos + 1;
15588
15589 continue;
15590 }
15591 }
15592
15593 // reset the offset
15594
15595 mask_offset = 0;
15596
15597 mask[str_pos] = '\0';
15598
15599 switch (separator_cnt)
15600 {
15601 case 0:
15602 mp_reset_usr (mp_usr, 0);
15603
15604 custom_charset_1 = mask;
15605 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15606 break;
15607
15608 case 1:
15609 mp_reset_usr (mp_usr, 1);
15610
15611 custom_charset_2 = mask;
15612 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15613 break;
15614
15615 case 2:
15616 mp_reset_usr (mp_usr, 2);
15617
15618 custom_charset_3 = mask;
15619 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15620 break;
15621
15622 case 3:
15623 mp_reset_usr (mp_usr, 3);
15624
15625 custom_charset_4 = mask;
15626 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15627 break;
15628 }
15629
15630 mask = mask + str_pos + 1;
15631 }
15632 }
15633
15634 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15635 {
15636 if (maskpos > 0)
15637 {
15638 local_free (css_buf);
15639 local_free (data.root_css_buf);
15640 local_free (data.markov_css_buf);
15641
15642 local_free (masks[maskpos - 1]);
15643 }
15644
15645 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15646
15647 data.mask = mask;
15648 data.css_cnt = css_cnt;
15649 data.css_buf = css_buf;
15650
15651 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15652
15653 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15654
15655 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15656 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15657
15658 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15659
15660 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15661
15662 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15663 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15664
15665 data.root_css_buf = root_css_buf;
15666 data.markov_css_buf = markov_css_buf;
15667
15668 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15669
15670 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15671
15672 local_free (root_table_buf);
15673 local_free (markov_table_buf);
15674
15675 // args
15676
15677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15678 {
15679 hc_device_param_t *device_param = &data.devices_param[device_id];
15680
15681 if (device_param->skipped) continue;
15682
15683 device_param->kernel_params_mp[0] = &device_param->d_combs;
15684 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15685 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15686
15687 device_param->kernel_params_mp_buf64[3] = 0;
15688 device_param->kernel_params_mp_buf32[4] = css_cnt;
15689 device_param->kernel_params_mp_buf32[5] = 0;
15690 device_param->kernel_params_mp_buf32[6] = 0;
15691 device_param->kernel_params_mp_buf32[7] = 0;
15692
15693 if (attack_mode == ATTACK_MODE_HYBRID1)
15694 {
15695 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15696 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15697 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15698 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15699 }
15700 else if (attack_mode == ATTACK_MODE_HYBRID2)
15701 {
15702 device_param->kernel_params_mp_buf32[5] = 0;
15703 device_param->kernel_params_mp_buf32[6] = 0;
15704 device_param->kernel_params_mp_buf32[7] = 0;
15705 }
15706
15707 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]);
15708 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]);
15709 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]);
15710
15711 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);
15712 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);
15713 }
15714 }
15715 else if (attack_mode == ATTACK_MODE_BF)
15716 {
15717 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15718
15719 if (increment)
15720 {
15721 for (uint i = 0; i < dictcnt; i++)
15722 {
15723 local_free (dictfiles[i]);
15724 }
15725
15726 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15727 {
15728 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15729
15730 if (l1_filename == NULL) break;
15731
15732 dictcnt++;
15733
15734 dictfiles[dictcnt - 1] = l1_filename;
15735 }
15736 }
15737 else
15738 {
15739 dictcnt++;
15740
15741 dictfiles[dictcnt - 1] = mask;
15742 }
15743
15744 if (dictcnt == 0)
15745 {
15746 log_error ("ERROR: Mask is too small");
15747
15748 return (-1);
15749 }
15750 }
15751 }
15752
15753 free (induction_dictionaries);
15754
15755 // induction_dictionaries_cnt = 0; // implied
15756
15757 if (attack_mode != ATTACK_MODE_BF)
15758 {
15759 if (keyspace == 0)
15760 {
15761 induction_dictionaries = scan_directory (induction_directory);
15762
15763 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15764 }
15765 }
15766
15767 if (induction_dictionaries_cnt)
15768 {
15769 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15770 }
15771
15772 /**
15773 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15774 */
15775 if (keyspace == 1)
15776 {
15777 if ((maskcnt > 1) || (dictcnt > 1))
15778 {
15779 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15780
15781 return (-1);
15782 }
15783 }
15784
15785 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15786 {
15787 char *subid = logfile_generate_subid ();
15788
15789 data.subid = subid;
15790
15791 logfile_sub_msg ("START");
15792
15793 data.devices_status = STATUS_INIT;
15794
15795 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15796 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15797 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15798
15799 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15800
15801 data.cpt_pos = 0;
15802
15803 data.cpt_start = time (NULL);
15804
15805 data.cpt_total = 0;
15806
15807 if (data.restore == 0)
15808 {
15809 rd->words_cur = skip;
15810
15811 skip = 0;
15812
15813 data.skip = 0;
15814 }
15815
15816 data.ms_paused = 0;
15817
15818 data.words_cur = rd->words_cur;
15819
15820 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15821 {
15822 hc_device_param_t *device_param = &data.devices_param[device_id];
15823
15824 if (device_param->skipped) continue;
15825
15826 device_param->speed_pos = 0;
15827
15828 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15829 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15830 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15831
15832 device_param->kernel_power = device_param->kernel_power_user;
15833 device_param->kernel_blocks = device_param->kernel_blocks_user;
15834
15835 device_param->outerloop_pos = 0;
15836 device_param->outerloop_left = 0;
15837 device_param->innerloop_pos = 0;
15838 device_param->innerloop_left = 0;
15839
15840 // some more resets:
15841
15842 if (device_param->pw_caches) memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15843
15844 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
15845
15846 device_param->pw_cnt = 0;
15847 device_param->pws_cnt = 0;
15848
15849 device_param->words_off = 0;
15850 device_param->words_done = 0;
15851 }
15852
15853 data.kernel_blocks_div = 0;
15854
15855 // figure out some workload
15856
15857 if (attack_mode == ATTACK_MODE_STRAIGHT)
15858 {
15859 if (data.wordlist_mode == WL_MODE_FILE)
15860 {
15861 char *dictfile = NULL;
15862
15863 if (induction_dictionaries_cnt)
15864 {
15865 dictfile = induction_dictionaries[0];
15866 }
15867 else
15868 {
15869 dictfile = dictfiles[dictpos];
15870 }
15871
15872 data.dictfile = dictfile;
15873
15874 logfile_sub_string (dictfile);
15875
15876 for (uint i = 0; i < rp_files_cnt; i++)
15877 {
15878 logfile_sub_var_string ("rulefile", rp_files[i]);
15879 }
15880
15881 FILE *fd2 = fopen (dictfile, "rb");
15882
15883 if (fd2 == NULL)
15884 {
15885 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15886
15887 return (-1);
15888 }
15889
15890 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15891
15892 fclose (fd2);
15893
15894 if (data.words_cnt == 0)
15895 {
15896 if (data.devices_status == STATUS_CRACKED) break;
15897 if (data.devices_status == STATUS_ABORTED) break;
15898
15899 dictpos++;
15900
15901 continue;
15902 }
15903 }
15904 }
15905 else if (attack_mode == ATTACK_MODE_COMBI)
15906 {
15907 char *dictfile = data.dictfile;
15908 char *dictfile2 = data.dictfile2;
15909
15910 logfile_sub_string (dictfile);
15911 logfile_sub_string (dictfile2);
15912
15913 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15914 {
15915 FILE *fd2 = fopen (dictfile, "rb");
15916
15917 if (fd2 == NULL)
15918 {
15919 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15920
15921 return (-1);
15922 }
15923
15924 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15925
15926 fclose (fd2);
15927 }
15928 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15929 {
15930 FILE *fd2 = fopen (dictfile2, "rb");
15931
15932 if (fd2 == NULL)
15933 {
15934 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15935
15936 return (-1);
15937 }
15938
15939 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15940
15941 fclose (fd2);
15942 }
15943
15944 if (data.words_cnt == 0)
15945 {
15946 if (data.devices_status == STATUS_CRACKED) break;
15947 if (data.devices_status == STATUS_ABORTED) break;
15948
15949 dictpos++;
15950
15951 continue;
15952 }
15953 }
15954 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15955 {
15956 char *dictfile = NULL;
15957
15958 if (induction_dictionaries_cnt)
15959 {
15960 dictfile = induction_dictionaries[0];
15961 }
15962 else
15963 {
15964 dictfile = dictfiles[dictpos];
15965 }
15966
15967 data.dictfile = dictfile;
15968
15969 char *mask = data.mask;
15970
15971 logfile_sub_string (dictfile);
15972 logfile_sub_string (mask);
15973
15974 FILE *fd2 = fopen (dictfile, "rb");
15975
15976 if (fd2 == NULL)
15977 {
15978 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15979
15980 return (-1);
15981 }
15982
15983 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15984
15985 fclose (fd2);
15986
15987 if (data.words_cnt == 0)
15988 {
15989 if (data.devices_status == STATUS_CRACKED) break;
15990 if (data.devices_status == STATUS_ABORTED) break;
15991
15992 dictpos++;
15993
15994 continue;
15995 }
15996 }
15997 else if (attack_mode == ATTACK_MODE_BF)
15998 {
15999 local_free (css_buf);
16000 local_free (data.root_css_buf);
16001 local_free (data.markov_css_buf);
16002
16003 char *mask = dictfiles[dictpos];
16004
16005 logfile_sub_string (mask);
16006
16007 // base
16008
16009 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16010
16011 if (opts_type & OPTS_TYPE_PT_UNICODE)
16012 {
16013 uint css_cnt_unicode = css_cnt * 2;
16014
16015 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16016
16017 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16018 {
16019 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16020
16021 css_buf_unicode[j + 1].cs_buf[0] = 0;
16022 css_buf_unicode[j + 1].cs_len = 1;
16023 }
16024
16025 free (css_buf);
16026
16027 css_buf = css_buf_unicode;
16028 css_cnt = css_cnt_unicode;
16029 }
16030
16031 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16032
16033 uint mask_min = pw_min;
16034 uint mask_max = pw_max;
16035
16036 if (opts_type & OPTS_TYPE_PT_UNICODE)
16037 {
16038 mask_min *= 2;
16039 mask_max *= 2;
16040 }
16041
16042 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16043 {
16044 if (css_cnt < mask_min)
16045 {
16046 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16047 }
16048
16049 if (css_cnt > mask_max)
16050 {
16051 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16052 }
16053
16054 // skip to next mask
16055
16056 dictpos++;
16057
16058 rd->dictpos = dictpos;
16059
16060 logfile_sub_msg ("STOP");
16061
16062 continue;
16063 }
16064
16065 uint save_css_cnt = css_cnt;
16066
16067 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16068 {
16069 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16070 {
16071 uint salt_len = (uint) data.salts_buf[0].salt_len;
16072 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16073
16074 uint css_cnt_salt = css_cnt + salt_len;
16075
16076 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16077
16078 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16079
16080 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16081 {
16082 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16083 css_buf_salt[j].cs_len = 1;
16084 }
16085
16086 free (css_buf);
16087
16088 css_buf = css_buf_salt;
16089 css_cnt = css_cnt_salt;
16090 }
16091 }
16092
16093 data.mask = mask;
16094 data.css_cnt = css_cnt;
16095 data.css_buf = css_buf;
16096
16097 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16098
16099 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16100
16101 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16102
16103 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16104 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16105
16106 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16107
16108 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16109
16110 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16111 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16112
16113 data.root_css_buf = root_css_buf;
16114 data.markov_css_buf = markov_css_buf;
16115
16116 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16117
16118 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16119
16120 local_free (root_table_buf);
16121 local_free (markov_table_buf);
16122
16123 // copy + args
16124
16125 uint css_cnt_l = css_cnt;
16126 uint css_cnt_r;
16127
16128 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16129 {
16130 if (save_css_cnt < 6)
16131 {
16132 css_cnt_r = 1;
16133 }
16134 else if (save_css_cnt == 6)
16135 {
16136 css_cnt_r = 2;
16137 }
16138 else
16139 {
16140 if (opts_type & OPTS_TYPE_PT_UNICODE)
16141 {
16142 if (save_css_cnt == 8 || save_css_cnt == 10)
16143 {
16144 css_cnt_r = 2;
16145 }
16146 else
16147 {
16148 css_cnt_r = 4;
16149 }
16150 }
16151 else
16152 {
16153 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
16154 {
16155 css_cnt_r = 3;
16156 }
16157 else
16158 {
16159 css_cnt_r = 4;
16160 }
16161 }
16162 }
16163 }
16164 else
16165 {
16166 css_cnt_r = 1;
16167
16168 /* unfinished code?
16169 int sum = css_buf[css_cnt_r - 1].cs_len;
16170
16171 for (uint i = 1; i < 4 && i < css_cnt; i++)
16172 {
16173 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
16174
16175 css_cnt_r++;
16176
16177 sum *= css_buf[css_cnt_r - 1].cs_len;
16178 }
16179 */
16180 }
16181
16182 css_cnt_l -= css_cnt_r;
16183
16184 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
16185
16186 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16187 {
16188 hc_device_param_t *device_param = &data.devices_param[device_id];
16189
16190 if (device_param->skipped) continue;
16191
16192 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
16193 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
16194 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
16195
16196 device_param->kernel_params_mp_l_buf64[3] = 0;
16197 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
16198 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
16199 device_param->kernel_params_mp_l_buf32[6] = 0;
16200 device_param->kernel_params_mp_l_buf32[7] = 0;
16201 device_param->kernel_params_mp_l_buf32[8] = 0;
16202
16203 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
16204 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
16205 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
16206 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
16207
16208 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
16209 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
16210 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
16211
16212 device_param->kernel_params_mp_r_buf64[3] = 0;
16213 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
16214 device_param->kernel_params_mp_r_buf32[5] = 0;
16215 device_param->kernel_params_mp_r_buf32[6] = 0;
16216 device_param->kernel_params_mp_r_buf32[7] = 0;
16217
16218 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]);
16219 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]);
16220 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]);
16221
16222 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]);
16223 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]);
16224 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]);
16225
16226 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);
16227 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);
16228 }
16229 }
16230
16231 u64 words_base = data.words_cnt;
16232
16233 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16234 {
16235 if (data.kernel_rules_cnt)
16236 {
16237 words_base /= data.kernel_rules_cnt;
16238 }
16239 }
16240 else if (data.attack_kern == ATTACK_KERN_COMBI)
16241 {
16242 if (data.combs_cnt)
16243 {
16244 words_base /= data.combs_cnt;
16245 }
16246 }
16247 else if (data.attack_kern == ATTACK_KERN_BF)
16248 {
16249 if (data.bfs_cnt)
16250 {
16251 words_base /= data.bfs_cnt;
16252 }
16253 }
16254
16255 data.words_base = words_base;
16256
16257 if (keyspace == 1)
16258 {
16259 log_info ("%llu", (unsigned long long int) words_base);
16260
16261 return (0);
16262 }
16263
16264 if (data.words_cur > data.words_base)
16265 {
16266 log_error ("ERROR: restore value greater keyspace");
16267
16268 return (-1);
16269 }
16270
16271 if (data.words_cur)
16272 {
16273 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16274 {
16275 for (uint i = 0; i < data.salts_cnt; i++)
16276 {
16277 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16278 }
16279 }
16280 else if (data.attack_kern == ATTACK_KERN_COMBI)
16281 {
16282 for (uint i = 0; i < data.salts_cnt; i++)
16283 {
16284 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16285 }
16286 }
16287 else if (data.attack_kern == ATTACK_KERN_BF)
16288 {
16289 for (uint i = 0; i < data.salts_cnt; i++)
16290 {
16291 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16292 }
16293 }
16294 }
16295
16296 /*
16297 * Inform user about possible slow speeds
16298 */
16299
16300 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16301 {
16302 if (data.words_base < kernel_blocks_all)
16303 {
16304 if (quiet == 0)
16305 {
16306 log_info ("");
16307 log_info ("ATTENTION!");
16308 log_info (" The wordlist or mask you are using is too small.");
16309 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16310 log_info (" The cracking speed will drop.");
16311 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16312 log_info ("");
16313 }
16314 }
16315 }
16316
16317 /*
16318 * Update loopback file
16319 */
16320
16321 if (loopback == 1)
16322 {
16323 time_t now;
16324
16325 time (&now);
16326
16327 uint random_num = get_random_num (0, 9999);
16328
16329 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16330
16331 data.loopback_file = loopback_file;
16332 }
16333
16334 /*
16335 * Update dictionary statistic
16336 */
16337
16338 if (keyspace == 0)
16339 {
16340 dictstat_fp = fopen (dictstat, "wb");
16341
16342 if (dictstat_fp)
16343 {
16344 lock_file (dictstat_fp);
16345
16346 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16347
16348 fclose (dictstat_fp);
16349 }
16350 }
16351
16352 data.devices_status = STATUS_RUNNING;
16353
16354 if (initial_restore_done == 0)
16355 {
16356 if (data.restore_disable == 0) cycle_restore ();
16357
16358 initial_restore_done = 1;
16359 }
16360
16361 hc_timer_set (&data.timer_running);
16362
16363 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16364 {
16365 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16366 {
16367 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16368 if (quiet == 0) fflush (stdout);
16369 }
16370 }
16371 else if (wordlist_mode == WL_MODE_STDIN)
16372 {
16373 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16374 if (data.quiet == 0) log_info ("");
16375 }
16376
16377 time_t runtime_start;
16378
16379 time (&runtime_start);
16380
16381 data.runtime_start = runtime_start;
16382
16383 /**
16384 * create cracker threads
16385 */
16386
16387 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
16388
16389 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16390 {
16391 hc_device_param_t *device_param = &devices_param[device_id];
16392
16393 if (wordlist_mode == WL_MODE_STDIN)
16394 {
16395 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16396 }
16397 else
16398 {
16399 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16400 }
16401 }
16402
16403 // wait for crack threads to exit
16404
16405 hc_thread_wait (data.devices_cnt, c_threads);
16406
16407 local_free (c_threads);
16408
16409 data.restore = 0;
16410
16411 // finalize task
16412
16413 logfile_sub_var_uint ("status-after-work", data.devices_status);
16414
16415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16416
16417 if (data.devices_status == STATUS_CRACKED) break;
16418 if (data.devices_status == STATUS_ABORTED) break;
16419
16420 if (data.devices_status == STATUS_BYPASS)
16421 {
16422 data.devices_status = STATUS_RUNNING;
16423 }
16424
16425 if (induction_dictionaries_cnt)
16426 {
16427 unlink (induction_dictionaries[0]);
16428 }
16429
16430 free (induction_dictionaries);
16431
16432 if (attack_mode != ATTACK_MODE_BF)
16433 {
16434 induction_dictionaries = scan_directory (induction_directory);
16435
16436 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16437 }
16438
16439 if (benchmark == 0)
16440 {
16441 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16442 {
16443 if (quiet == 0) clear_prompt ();
16444
16445 if (quiet == 0) log_info ("");
16446
16447 if (status == 1)
16448 {
16449 status_display ();
16450 }
16451 else
16452 {
16453 if (quiet == 0) status_display ();
16454 }
16455
16456 if (quiet == 0) log_info ("");
16457 }
16458 }
16459
16460 if (attack_mode == ATTACK_MODE_BF)
16461 {
16462 dictpos++;
16463
16464 rd->dictpos = dictpos;
16465 }
16466 else
16467 {
16468 if (induction_dictionaries_cnt)
16469 {
16470 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16471 }
16472 else
16473 {
16474 dictpos++;
16475
16476 rd->dictpos = dictpos;
16477 }
16478 }
16479
16480 time_t runtime_stop;
16481
16482 time (&runtime_stop);
16483
16484 data.runtime_stop = runtime_stop;
16485
16486 logfile_sub_uint (runtime_start);
16487 logfile_sub_uint (runtime_stop);
16488
16489 logfile_sub_msg ("STOP");
16490
16491 global_free (subid);
16492 }
16493
16494 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16495
16496 if (data.devices_status == STATUS_CRACKED) break;
16497 if (data.devices_status == STATUS_ABORTED) break;
16498 if (data.devices_status == STATUS_QUIT) break;
16499
16500 if (data.devices_status == STATUS_BYPASS)
16501 {
16502 data.devices_status = STATUS_RUNNING;
16503 }
16504 }
16505
16506 // 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
16507
16508 if (attack_mode == ATTACK_MODE_STRAIGHT)
16509 {
16510 if (data.wordlist_mode == WL_MODE_FILE)
16511 {
16512 if (data.dictfile == NULL)
16513 {
16514 if (dictfiles != NULL)
16515 {
16516 data.dictfile = dictfiles[0];
16517
16518 hc_timer_set (&data.timer_running);
16519 }
16520 }
16521 }
16522 }
16523 // NOTE: combi is okay because it is already set beforehand
16524 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16525 {
16526 if (data.dictfile == NULL)
16527 {
16528 if (dictfiles != NULL)
16529 {
16530 hc_timer_set (&data.timer_running);
16531
16532 data.dictfile = dictfiles[0];
16533 }
16534 }
16535 }
16536 else if (attack_mode == ATTACK_MODE_BF)
16537 {
16538 if (data.mask == NULL)
16539 {
16540 hc_timer_set (&data.timer_running);
16541
16542 data.mask = masks[0];
16543 }
16544 }
16545
16546 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16547 {
16548 data.devices_status = STATUS_EXHAUSTED;
16549 }
16550
16551 // if cracked / aborted remove last induction dictionary
16552
16553 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16554 {
16555 struct stat induct_stat;
16556
16557 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16558 {
16559 unlink (induction_dictionaries[file_pos]);
16560 }
16561 }
16562
16563 // wait for non-interactive threads
16564
16565 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16566 {
16567 hc_thread_wait (1, &ni_threads[thread_idx]);
16568 }
16569
16570 local_free (ni_threads);
16571
16572 // wait for interactive threads
16573
16574 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16575 {
16576 hc_thread_wait (1, &i_thread);
16577 }
16578
16579 // we dont need restore file anymore
16580 if (data.restore_disable == 0)
16581 {
16582 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16583 {
16584 unlink (eff_restore_file);
16585 unlink (new_restore_file);
16586 }
16587 else
16588 {
16589 cycle_restore ();
16590 }
16591 }
16592
16593 // finally save left hashes
16594
16595 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16596 {
16597 save_hash ();
16598 }
16599
16600 /**
16601 * Clean up
16602 */
16603
16604 if (benchmark == 1)
16605 {
16606 status_benchmark ();
16607
16608 log_info ("");
16609 }
16610 else
16611 {
16612 if (quiet == 0) clear_prompt ();
16613
16614 if (quiet == 0) log_info ("");
16615
16616 if (status == 1)
16617 {
16618 status_display ();
16619 }
16620 else
16621 {
16622 if (quiet == 0) status_display ();
16623 }
16624
16625 if (quiet == 0) log_info ("");
16626 }
16627
16628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16629 {
16630 hc_device_param_t *device_param = &data.devices_param[device_id];
16631
16632 if (device_param->skipped) continue;
16633
16634 local_free (device_param->result);
16635
16636 local_free (device_param->pw_caches);
16637
16638 local_free (device_param->combs_buf);
16639
16640 local_free (device_param->hooks_buf);
16641
16642 local_free (device_param->device_name);
16643
16644 local_free (device_param->device_name_chksum);
16645
16646 local_free (device_param->device_version);
16647
16648 local_free (device_param->driver_version);
16649
16650 if (device_param->pws_buf) myfree (device_param->pws_buf);
16651 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
16652 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
16653 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
16654 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
16655 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
16656 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
16657 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
16658 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
16659 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
16660 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
16661 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
16662 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
16663 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
16664 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
16665 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
16666 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
16667 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
16668 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
16669 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
16670 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
16671 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
16672 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
16673 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
16674 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
16675 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
16676 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
16677 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
16678 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
16679
16680 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
16681 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
16682 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
16683 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
16684 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
16685 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
16686 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
16687 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
16688 if (device_param->kernel_tb) hc_clReleaseKernel (data.ocl, device_param->kernel_tb);
16689 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
16690 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
16691
16692 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
16693 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
16694 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
16695
16696 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
16697 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
16698 }
16699
16700 // reset default fan speed
16701
16702 #ifdef HAVE_HWMON
16703 if (gpu_temp_disable == 0)
16704 {
16705 #ifdef HAVE_ADL
16706 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16707 {
16708 hc_thread_mutex_lock (mux_adl);
16709
16710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16711 {
16712 hc_device_param_t *device_param = &data.devices_param[device_id];
16713
16714 if (device_param->skipped) continue;
16715
16716 if (data.hm_device[device_id].fan_supported == 1)
16717 {
16718 int fanspeed = temp_retain_fanspeed_value[device_id];
16719
16720 if (fanspeed == -1) continue;
16721
16722 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16723
16724 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16725 }
16726 }
16727
16728 hc_thread_mutex_unlock (mux_adl);
16729 }
16730 #endif // HAVE_ADL
16731 }
16732
16733 #ifdef HAVE_ADL
16734 // reset power tuning
16735
16736 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16737 {
16738 hc_thread_mutex_lock (mux_adl);
16739
16740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16741 {
16742 hc_device_param_t *device_param = &data.devices_param[device_id];
16743
16744 if (device_param->skipped) continue;
16745
16746 if (data.hm_device[device_id].od_version == 6)
16747 {
16748 // check powertune capabilities first, if not available then skip device
16749
16750 int powertune_supported = 0;
16751
16752 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16753 {
16754 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16755
16756 return (-1);
16757 }
16758
16759 if (powertune_supported != 0)
16760 {
16761 // powercontrol settings
16762
16763 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)
16764 {
16765 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16766
16767 return (-1);
16768 }
16769
16770 // clocks
16771
16772 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16773
16774 performance_state->iNumberOfPerformanceLevels = 2;
16775
16776 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16777 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16778 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16779 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16780
16781 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)
16782 {
16783 log_info ("ERROR: Failed to restore ADL performance state");
16784
16785 return (-1);
16786 }
16787
16788 local_free (performance_state);
16789 }
16790 }
16791 }
16792
16793 hc_thread_mutex_unlock (mux_adl);
16794 }
16795 #endif // HAVE_ADL
16796
16797 if (gpu_temp_disable == 0)
16798 {
16799 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
16800 if (data.hm_nv)
16801 {
16802 #if defined(LINUX) && defined(HAVE_NVML)
16803
16804 hm_NVML_nvmlShutdown (data.hm_nv);
16805
16806 nvml_close (data.hm_nv);
16807
16808 #elif defined(WIN) && (HAVE_NVAPI)
16809
16810 hm_NvAPI_Unload (data.hm_nv);
16811
16812 nvapi_close (data.hm_nv);
16813
16814 #endif
16815
16816 data.hm_nv = NULL;
16817 }
16818 #endif
16819
16820 #ifdef HAVE_ADL
16821 if (data.hm_amd)
16822 {
16823 hm_ADL_Main_Control_Destroy (data.hm_amd);
16824
16825 adl_close (data.hm_amd);
16826 data.hm_amd = NULL;
16827 }
16828 #endif
16829 }
16830 #endif // HAVE_HWMON
16831
16832 // free memory
16833
16834 local_free (masks);
16835
16836 local_free (dictstat_base);
16837
16838 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16839 {
16840 pot_t *pot_ptr = &pot[pot_pos];
16841
16842 hash_t *hash = &pot_ptr->hash;
16843
16844 local_free (hash->digest);
16845
16846 if (isSalted)
16847 {
16848 local_free (hash->salt);
16849 }
16850 }
16851
16852 local_free (pot);
16853
16854 local_free (all_kernel_rules_cnt);
16855 local_free (all_kernel_rules_buf);
16856
16857 local_free (wl_data->buf);
16858 local_free (wl_data);
16859
16860 local_free (bitmap_s1_a);
16861 local_free (bitmap_s1_b);
16862 local_free (bitmap_s1_c);
16863 local_free (bitmap_s1_d);
16864 local_free (bitmap_s2_a);
16865 local_free (bitmap_s2_b);
16866 local_free (bitmap_s2_c);
16867 local_free (bitmap_s2_d);
16868
16869 #ifdef HAVE_HWMON
16870 local_free (temp_retain_fanspeed_value);
16871 #ifdef HAVE_ADL
16872 local_free (od_clock_mem_status);
16873 local_free (od_power_control_status);
16874 #endif // ADL
16875 #endif
16876
16877 global_free (devices_param);
16878
16879 global_free (kernel_rules_buf);
16880
16881 global_free (root_css_buf);
16882 global_free (markov_css_buf);
16883
16884 global_free (digests_buf);
16885 global_free (digests_shown);
16886 global_free (digests_shown_tmp);
16887
16888 global_free (salts_buf);
16889 global_free (salts_shown);
16890
16891 global_free (esalts_buf);
16892
16893 global_free (words_progress_done);
16894 global_free (words_progress_rejected);
16895 global_free (words_progress_restored);
16896
16897 if (pot_fp) fclose (pot_fp);
16898
16899 if (data.devices_status == STATUS_QUIT) break;
16900 }
16901
16902 // destroy others mutex
16903
16904 hc_thread_mutex_delete (mux_dispatcher);
16905 hc_thread_mutex_delete (mux_counter);
16906 hc_thread_mutex_delete (mux_display);
16907 hc_thread_mutex_delete (mux_adl);
16908
16909 // free memory
16910
16911 local_free (eff_restore_file);
16912 local_free (new_restore_file);
16913
16914 local_free (rd);
16915
16916 // loopback
16917
16918 local_free (loopback_file);
16919
16920 if (loopback == 1) unlink (loopback_file);
16921
16922 // induction directory
16923
16924 if (induction_dir == NULL)
16925 {
16926 if (attack_mode != ATTACK_MODE_BF)
16927 {
16928 if (rmdir (induction_directory) == -1)
16929 {
16930 if (errno == ENOENT)
16931 {
16932 // good, we can ignore
16933 }
16934 else if (errno == ENOTEMPTY)
16935 {
16936 // good, we can ignore
16937 }
16938 else
16939 {
16940 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16941
16942 return (-1);
16943 }
16944 }
16945
16946 local_free (induction_directory);
16947 }
16948 }
16949
16950 // outfile-check directory
16951
16952 if (outfile_check_dir == NULL)
16953 {
16954 if (rmdir (outfile_check_directory) == -1)
16955 {
16956 if (errno == ENOENT)
16957 {
16958 // good, we can ignore
16959 }
16960 else if (errno == ENOTEMPTY)
16961 {
16962 // good, we can ignore
16963 }
16964 else
16965 {
16966 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16967
16968 return (-1);
16969 }
16970 }
16971
16972 local_free (outfile_check_directory);
16973 }
16974
16975 time_t proc_stop;
16976
16977 time (&proc_stop);
16978
16979 logfile_top_uint (proc_start);
16980 logfile_top_uint (proc_stop);
16981
16982 logfile_top_msg ("STOP");
16983
16984 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16985 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16986
16987 if (data.ocl) ocl_close (data.ocl);
16988
16989 if (data.devices_status == STATUS_ABORTED) return 2;
16990 if (data.devices_status == STATUS_QUIT) return 2;
16991 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16992 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16993 if (data.devices_status == STATUS_CRACKED) return 0;
16994
16995 return -1;
16996 }
Hashcat additions to support pwdhash