projects / hashcat.git / blob
? search:


1039de4a19a20e85e6a4136e61ac7c51552ac89a
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #ifdef OSX
7 #include <stdio.h>
8 #endif
9
10 #include <common.h>
11 #include <shared.h>
12 #include <rp_kernel_on_cpu.h>
13 #include <getopt.h>
14
15 const char *PROGNAME = "oclHashcat";
16 const uint VERSION_BIN = 210;
17 const uint RESTORE_MIN = 210;
18
19 #define INCR_RULES 10000
20 #define INCR_SALTS 100000
21 #define INCR_MASKS 1000
22 #define INCR_POT 1000
23
24 #define USAGE 0
25 #define VERSION 0
26 #define QUIET 0
27 #define MARKOV_THRESHOLD 0
28 #define MARKOV_DISABLE 0
29 #define MARKOV_CLASSIC 0
30 #define BENCHMARK 0
31 #define BENCHMARK_MODE 1
32 #define RESTORE 0
33 #define RESTORE_TIMER 60
34 #define RESTORE_DISABLE 0
35 #define STATUS 0
36 #define STATUS_TIMER 10
37 #define STATUS_AUTOMAT 0
38 #define LOOPBACK 0
39 #define WEAK_HASH_THRESHOLD 100
40 #define SHOW 0
41 #define LEFT 0
42 #define USERNAME 0
43 #define REMOVE 0
44 #define REMOVE_TIMER 60
45 #define SKIP 0
46 #define LIMIT 0
47 #define KEYSPACE 0
48 #define POTFILE_DISABLE 0
49 #define DEBUG_MODE 0
50 #define RP_GEN 0
51 #define RP_GEN_FUNC_MIN 1
52 #define RP_GEN_FUNC_MAX 4
53 #define RP_GEN_SEED 0
54 #define RULE_BUF_L ":"
55 #define RULE_BUF_R ":"
56 #define FORCE 0
57 #define RUNTIME 0
58 #define HEX_CHARSET 0
59 #define HEX_SALT 0
60 #define HEX_WORDLIST 0
61 #define OUTFILE_FORMAT 3
62 #define OUTFILE_AUTOHEX 1
63 #define OUTFILE_CHECK_TIMER 5
64 #define ATTACK_MODE 0
65 #define HASH_MODE 0
66 #define SEGMENT_SIZE 32
67 #define INCREMENT 0
68 #define INCREMENT_MIN 1
69 #define INCREMENT_MAX PW_MAX
70 #define SEPARATOR ':'
71 #define BITMAP_MIN 16
72 #define BITMAP_MAX 24
73 #define GPU_TEMP_DISABLE 0
74 #define GPU_TEMP_ABORT 90
75 #define GPU_TEMP_RETAIN 80
76 #define WORKLOAD_PROFILE 2
77 #define KERNEL_ACCEL 0
78 #define KERNEL_LOOPS 0
79 #define KERNEL_RULES 1024
80 #define KERNEL_COMBS 1024
81 #define KERNEL_BFS 1024
82 #define KERNEL_THREADS 64
83 #define POWERTUNE_ENABLE 0
84 #define LOGFILE_DISABLE 0
85 #define SCRYPT_TMTO 0
86 #define OPENCL_VECTOR_WIDTH 0
87
88 #define WL_MODE_STDIN 1
89 #define WL_MODE_FILE 2
90 #define WL_MODE_MASK 3
91
92 #define HL_MODE_FILE 4
93 #define HL_MODE_ARG 5
94
95 #define HLFMT_HASHCAT 0
96 #define HLFMT_PWDUMP 1
97 #define HLFMT_PASSWD 2
98 #define HLFMT_SHADOW 3
99 #define HLFMT_DCC 4
100 #define HLFMT_DCC2 5
101 #define HLFMT_NETNTLM1 7
102 #define HLFMT_NETNTLM2 8
103 #define HLFMT_NSLDAP 9
104 #define HLFMT_NSLDAPS 10
105 #define HLFMTS_CNT 11
106
107 #define ATTACK_MODE_STRAIGHT 0
108 #define ATTACK_MODE_COMBI 1
109 #define ATTACK_MODE_TOGGLE 2
110 #define ATTACK_MODE_BF 3
111 #define ATTACK_MODE_PERM 4
112 #define ATTACK_MODE_TABLE 5
113 #define ATTACK_MODE_HYBRID1 6
114 #define ATTACK_MODE_HYBRID2 7
115 #define ATTACK_MODE_NONE 100
116
117 #define ATTACK_KERN_STRAIGHT 0
118 #define ATTACK_KERN_COMBI 1
119 #define ATTACK_KERN_BF 3
120 #define ATTACK_KERN_NONE 100
121
122 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
123 #define ATTACK_EXEC_INSIDE_KERNEL 11
124
125 #define COMBINATOR_MODE_BASE_LEFT 10001
126 #define COMBINATOR_MODE_BASE_RIGHT 10002
127
128 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
129 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
130
131 #define MAX_CUT_TRIES 4
132
133 #define MAX_DICTSTAT 10000
134
135 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
136
137 #define global_free(attr) \
138 { \
139 myfree ((void *) data.attr); \
140 \
141 data.attr = NULL; \
142 }
143
144 #define local_free(attr) \
145 { \
146 myfree ((void *) attr); \
147 \
148 attr = NULL; \
149 }
150
151 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
152 {
153 900,
154 0,
155 5100,
156 100,
157 1400,
158 10800,
159 1700,
160 5000,
161 10100,
162 6000,
163 6100,
164 6900,
165 11700,
166 11800,
167 400,
168 8900,
169 11900,
170 12000,
171 10900,
172 12100,
173 23,
174 2500,
175 5300,
176 5400,
177 5500,
178 5600,
179 7300,
180 7500,
181 8300,
182 11100,
183 11200,
184 11400,
185 121,
186 2611,
187 2711,
188 2811,
189 8400,
190 11,
191 2612,
192 7900,
193 21,
194 11000,
195 124,
196 10000,
197 3711,
198 7600,
199 12,
200 131,
201 132,
202 1731,
203 200,
204 300,
205 3100,
206 112,
207 12300,
208 8000,
209 141,
210 1441,
211 1600,
212 12600,
213 1421,
214 101,
215 111,
216 1711,
217 3000,
218 1000,
219 1100,
220 2100,
221 12800,
222 1500,
223 12400,
224 500,
225 3200,
226 7400,
227 1800,
228 122,
229 1722,
230 7100,
231 6300,
232 6700,
233 6400,
234 6500,
235 2400,
236 2410,
237 5700,
238 9200,
239 9300,
240 22,
241 501,
242 5800,
243 8100,
244 8500,
245 7200,
246 9900,
247 7700,
248 7800,
249 10300,
250 8600,
251 8700,
252 9100,
253 133,
254 11600,
255 12500,
256 13000,
257 6211,
258 6221,
259 6231,
260 6241,
261 8800,
262 12900,
263 12200,
264 9700,
265 9710,
266 9800,
267 9810,
268 9400,
269 9500,
270 9600,
271 10400,
272 10410,
273 10500,
274 10600,
275 10700,
276 9000,
277 5200,
278 6800,
279 6600,
280 8200,
281 11300,
282 12700
283 };
284
285 /**
286 * types
287 */
288
289 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
290
291 /**
292 * globals
293 */
294
295 static unsigned int full01 = 0x01010101;
296 static unsigned int full80 = 0x80808080;
297
298 int SUPPRESS_OUTPUT = 0;
299
300 hc_thread_mutex_t mux_adl;
301 hc_thread_mutex_t mux_counter;
302 hc_thread_mutex_t mux_dispatcher;
303 hc_thread_mutex_t mux_display;
304
305 hc_global_data_t data;
306
307 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
308
309 const char *USAGE_MINI[] =
310 {
311 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
312 "",
313 "Try --help for more help.",
314 NULL
315 };
316
317 const char *USAGE_BIG[] =
318 {
319 "%s, advanced password recovery",
320 "",
321 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
322 "",
323 "=======",
324 "Options",
325 "=======",
326 "",
327 "* General:",
328 "",
329 " -m, --hash-type=NUM Hash-type, see references below",
330 " -a, --attack-mode=NUM Attack-mode, see references below",
331 " -V, --version Print version",
332 " -h, --help Print help",
333 " --quiet Suppress output",
334 "",
335 "* Benchmark:",
336 "",
337 " -b, --benchmark Run benchmark",
338 " --benchmark-mode=NUM Benchmark-mode, see references below",
339 "",
340 "* Misc:",
341 "",
342 " --hex-charset Assume charset is given in hex",
343 " --hex-salt Assume salt is given in hex",
344 " --hex-wordlist Assume words in wordlist is given in hex",
345 " --force Ignore warnings",
346 " --status Enable automatic update of the status-screen",
347 " --status-timer=NUM Seconds between status-screen update",
348 " --status-automat Display the status view in a machine readable format",
349 " --loopback Add new plains to induct directory",
350 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
351 "",
352 "* Markov:",
353 "",
354 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
355 " --markov-disable Disables markov-chains, emulates classic brute-force",
356 " --markov-classic Enables classic markov-chains, no per-position enhancement",
357 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
358 "",
359 "* Session:",
360 "",
361 " --runtime=NUM Abort session after NUM seconds of runtime",
362 " --session=STR Define specific session name",
363 " --restore Restore session from --session",
364 " --restore-disable Do not write restore file",
365 "",
366 "* Files:",
367 "",
368 " -o, --outfile=FILE Define outfile for recovered hash",
369 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
370 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
371 " --outfile-check-timer=NUM Seconds between outfile checks",
372 " -p, --separator=CHAR Separator char for hashlists and outfile",
373 " --show Show cracked passwords only",
374 " --left Show un-cracked passwords only",
375 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
376 " --remove Enable remove of hash once it is cracked",
377 " --remove-timer=NUM Update input hash file each NUM seconds",
378 " --potfile-disable Do not write potfile",
379 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
380 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
381 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
382 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
383 " --logfile-disable Disable the logfile",
384 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
385 "",
386 "* Resources:",
387 "",
388 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
389 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
390 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
391 #ifndef OSX
392 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
393 #else
394 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
395 #endif
396 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
397 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
398 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
399 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
400 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
401 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
402 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
403 #ifdef HAVE_HWMON
404 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
405 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
406 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
407 #ifdef HAVE_ADL
408 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
409 #endif
410 #endif
411 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
412 "",
413 "* Distributed:",
414 "",
415 " -s, --skip=NUM Skip number of words",
416 " -l, --limit=NUM Limit number of words",
417 " --keyspace Show keyspace base:mod values and quit",
418 "",
419 "* Rules:",
420 "",
421 " -j, --rule-left=RULE Single rule applied to each word from left dict",
422 " -k, --rule-right=RULE Single rule applied to each word from right dict",
423 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
424 " -g, --generate-rules=NUM Generate NUM random rules",
425 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
426 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
427 " --generate-rules-seed=NUM Force RNG seed to NUM",
428 "",
429 "* Custom charsets:",
430 "",
431 " -1, --custom-charset1=CS User-defined charsets",
432 " -2, --custom-charset2=CS Example:",
433 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
434 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
435 "",
436 "* Increment:",
437 "",
438 " -i, --increment Enable increment mode",
439 " --increment-min=NUM Start incrementing at NUM",
440 " --increment-max=NUM Stop incrementing at NUM",
441 "",
442 "==========",
443 "References",
444 "==========",
445 "",
446 "* Workload Profile:",
447 "",
448 " 1 = Reduced performance profile (low latency desktop)",
449 " 2 = Default performance profile",
450 " 3 = Tuned performance profile (high latency desktop)",
451 "",
452 "* Benchmark Settings:",
453 "",
454 " 0 = Manual Tuning",
455 " 1 = Performance Tuning, default",
456 "",
457 "* OpenCL device-types:",
458 "",
459 " 1 = CPU devices",
460 " 2 = GPU devices",
461 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
462 "",
463 "* Outfile Formats:",
464 "",
465 " 1 = hash[:salt]",
466 " 2 = plain",
467 " 3 = hash[:salt]:plain",
468 " 4 = hex_plain",
469 " 5 = hash[:salt]:hex_plain",
470 " 6 = plain:hex_plain",
471 " 7 = hash[:salt]:plain:hex_plain",
472 " 8 = crackpos",
473 " 9 = hash[:salt]:crackpos",
474 " 10 = plain:crackpos",
475 " 11 = hash[:salt]:plain:crackpos",
476 " 12 = hex_plain:crackpos",
477 " 13 = hash[:salt]:hex_plain:crackpos",
478 " 14 = plain:hex_plain:crackpos",
479 " 15 = hash[:salt]:plain:hex_plain:crackpos",
480 "",
481 "* Debug mode output formats (for hybrid mode only, by using rules):",
482 "",
483 " 1 = save finding rule",
484 " 2 = save original word",
485 " 3 = save original word and finding rule",
486 " 4 = save original word, finding rule and modified plain",
487 "",
488 "* Built-in charsets:",
489 "",
490 " ?l = abcdefghijklmnopqrstuvwxyz",
491 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
492 " ?d = 0123456789",
493 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
494 " ?a = ?l?u?d?s",
495 " ?b = 0x00 - 0xff",
496 "",
497 "* Attack modes:",
498 "",
499 " 0 = Straight",
500 " 1 = Combination",
501 " 3 = Brute-force",
502 " 6 = Hybrid dict + mask",
503 " 7 = Hybrid mask + dict",
504 "",
505 "* Hash types:",
506 "",
507 "[[ Roll-your-own: Raw Hashes ]]",
508 "",
509 " 900 = MD4",
510 " 0 = MD5",
511 " 5100 = Half MD5",
512 " 100 = SHA1",
513 " 10800 = SHA-384",
514 " 1400 = SHA-256",
515 " 1700 = SHA-512",
516 " 5000 = SHA-3(Keccak)",
517 " 10100 = SipHash",
518 " 6000 = RipeMD160",
519 " 6100 = Whirlpool",
520 " 6900 = GOST R 34.11-94",
521 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
522 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
523 "",
524 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
525 "",
526 " 10 = md5($pass.$salt)",
527 " 20 = md5($salt.$pass)",
528 " 30 = md5(unicode($pass).$salt)",
529 " 40 = md5($salt.unicode($pass))",
530 " 3800 = md5($salt.$pass.$salt)",
531 " 3710 = md5($salt.md5($pass))",
532 " 2600 = md5(md5($pass)",
533 " 4300 = md5(strtoupper(md5($pass)))",
534 " 4400 = md5(sha1($pass))",
535 " 110 = sha1($pass.$salt)",
536 " 120 = sha1($salt.$pass)",
537 " 130 = sha1(unicode($pass).$salt)",
538 " 140 = sha1($salt.unicode($pass))",
539 " 4500 = sha1(sha1($pass)",
540 " 4700 = sha1(md5($pass))",
541 " 4900 = sha1($salt.$pass.$salt)",
542 " 1410 = sha256($pass.$salt)",
543 " 1420 = sha256($salt.$pass)",
544 " 1430 = sha256(unicode($pass).$salt)",
545 " 1440 = sha256($salt.unicode($pass))",
546 " 1710 = sha512($pass.$salt)",
547 " 1720 = sha512($salt.$pass)",
548 " 1730 = sha512(unicode($pass).$salt)",
549 " 1740 = sha512($salt.unicode($pass))",
550 "",
551 "[[ Roll-your-own: Authenticated Hashes ]]",
552 "",
553 " 50 = HMAC-MD5 (key = $pass)",
554 " 60 = HMAC-MD5 (key = $salt)",
555 " 150 = HMAC-SHA1 (key = $pass)",
556 " 160 = HMAC-SHA1 (key = $salt)",
557 " 1450 = HMAC-SHA256 (key = $pass)",
558 " 1460 = HMAC-SHA256 (key = $salt)",
559 " 1750 = HMAC-SHA512 (key = $pass)",
560 " 1760 = HMAC-SHA512 (key = $salt)",
561 "",
562 "[[ Generic KDF ]]",
563 "",
564 " 400 = phpass",
565 " 8900 = scrypt",
566 " 11900 = PBKDF2-HMAC-MD5",
567 " 12000 = PBKDF2-HMAC-SHA1",
568 " 10900 = PBKDF2-HMAC-SHA256",
569 " 12100 = PBKDF2-HMAC-SHA512",
570 "",
571 "[[ Network protocols, Challenge-Response ]]",
572 "",
573 " 23 = Skype",
574 " 2500 = WPA/WPA2",
575 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
576 " 5300 = IKE-PSK MD5",
577 " 5400 = IKE-PSK SHA1",
578 " 5500 = NetNTLMv1",
579 " 5500 = NetNTLMv1 + ESS",
580 " 5600 = NetNTLMv2",
581 " 7300 = IPMI2 RAKP HMAC-SHA1",
582 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
583 " 8300 = DNSSEC (NSEC3)",
584 " 10200 = Cram MD5",
585 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
586 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
587 " 11400 = SIP digest authentication (MD5)",
588 "",
589 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
590 "",
591 " 121 = SMF (Simple Machines Forum)",
592 " 400 = phpBB3",
593 " 2611 = vBulletin < v3.8.5",
594 " 2711 = vBulletin > v3.8.5",
595 " 2811 = MyBB",
596 " 2811 = IPB (Invison Power Board)",
597 " 8400 = WBB3 (Woltlab Burning Board)",
598 " 11 = Joomla < 2.5.18",
599 " 400 = Joomla > 2.5.18",
600 " 400 = Wordpress",
601 " 2612 = PHPS",
602 " 7900 = Drupal7",
603 " 21 = osCommerce",
604 " 21 = xt:Commerce",
605 " 11000 = PrestaShop",
606 " 124 = Django (SHA-1)",
607 " 10000 = Django (PBKDF2-SHA256)",
608 " 3711 = Mediawiki B type",
609 " 7600 = Redmine",
610 "",
611 "[[ Database Server ]]",
612 "",
613 " 12 = PostgreSQL",
614 " 131 = MSSQL(2000)",
615 " 132 = MSSQL(2005)",
616 " 1731 = MSSQL(2012)",
617 " 1731 = MSSQL(2014)",
618 " 200 = MySQL323",
619 " 300 = MySQL4.1/MySQL5",
620 " 3100 = Oracle H: Type (Oracle 7+)",
621 " 112 = Oracle S: Type (Oracle 11+)",
622 " 12300 = Oracle T: Type (Oracle 12+)",
623 " 8000 = Sybase ASE",
624 "",
625 "[[ HTTP, SMTP, LDAP Server ]]",
626 "",
627 " 141 = EPiServer 6.x < v4",
628 " 1441 = EPiServer 6.x > v4",
629 " 1600 = Apache $apr1$",
630 " 12600 = ColdFusion 10+",
631 " 1421 = hMailServer",
632 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
633 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
634 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
635 "",
636 "[[ Checksums ]]",
637 "",
638 " 11500 = CRC32",
639 "",
640 "[[ Operating-Systems ]]",
641 "",
642 " 3000 = LM",
643 " 1000 = NTLM",
644 " 1100 = Domain Cached Credentials (DCC), MS Cache",
645 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
646 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
647 " 1500 = descrypt, DES(Unix), Traditional DES",
648 " 12400 = BSDiCrypt, Extended DES",
649 " 500 = md5crypt $1$, MD5(Unix)",
650 " 3200 = bcrypt $2*$, Blowfish(Unix)",
651 " 7400 = sha256crypt $5$, SHA256(Unix)",
652 " 1800 = sha512crypt $6$, SHA512(Unix)",
653 " 122 = OSX v10.4",
654 " 122 = OSX v10.5",
655 " 122 = OSX v10.6",
656 " 1722 = OSX v10.7",
657 " 7100 = OSX v10.8",
658 " 7100 = OSX v10.9",
659 " 7100 = OSX v10.10",
660 " 6300 = AIX {smd5}",
661 " 6700 = AIX {ssha1}",
662 " 6400 = AIX {ssha256}",
663 " 6500 = AIX {ssha512}",
664 " 2400 = Cisco-PIX",
665 " 2410 = Cisco-ASA",
666 " 500 = Cisco-IOS $1$",
667 " 5700 = Cisco-IOS $4$",
668 " 9200 = Cisco-IOS $8$",
669 " 9300 = Cisco-IOS $9$",
670 " 22 = Juniper Netscreen/SSG (ScreenOS)",
671 " 501 = Juniper IVE",
672 " 5800 = Android PIN",
673 " 8100 = Citrix Netscaler",
674 " 8500 = RACF",
675 " 7200 = GRUB 2",
676 " 9900 = Radmin2",
677 "",
678 "[[ Enterprise Application Software (EAS) ]]",
679 "",
680 " 7700 = SAP CODVN B (BCODE)",
681 " 7800 = SAP CODVN F/G (PASSCODE)",
682 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
683 " 8600 = Lotus Notes/Domino 5",
684 " 8700 = Lotus Notes/Domino 6",
685 " 9100 = Lotus Notes/Domino 8",
686 " 133 = PeopleSoft",
687 "",
688 "[[ Archives ]]",
689 "",
690 " 11600 = 7-Zip",
691 " 12500 = RAR3-hp",
692 " 13000 = RAR5",
693 "",
694 "[[ Full-Disk encryptions (FDE) ]]",
695 "",
696 " 62XY = TrueCrypt 5.0+",
697 " X = 1 = PBKDF2-HMAC-RipeMD160",
698 " X = 2 = PBKDF2-HMAC-SHA512",
699 " X = 3 = PBKDF2-HMAC-Whirlpool",
700 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
701 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
702 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
703 " Y = 3 = XTS 1536 bit (Ciphers: All)",
704 " 8800 = Android FDE < v4.3",
705 " 12900 = Android FDE (Samsung DEK)",
706 " 12200 = eCryptfs",
707 "",
708 "[[ Documents ]]",
709 "",
710 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
711 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
712 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
713 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
714 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
715 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
716 " 9400 = MS Office 2007",
717 " 9500 = MS Office 2010",
718 " 9600 = MS Office 2013",
719 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
720 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
721 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
722 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
723 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
724 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
725 "",
726 "[[ Password Managers ]]",
727 "",
728 " 9000 = Password Safe v2",
729 " 5200 = Password Safe v3",
730 " 6800 = Lastpass",
731 " 6600 = 1Password, agilekeychain",
732 " 8200 = 1Password, cloudkeychain",
733 " 11300 = Bitcoin/Litecoin wallet.dat",
734 " 12700 = Blockchain, My Wallet",
735 "",
736 NULL
737 };
738
739 /**
740 * oclHashcat specific functions
741 */
742
743 void status_display_automat ()
744 {
745 FILE *out = stdout;
746
747 fprintf (out, "STATUS\t%u\t", data.devices_status);
748
749 /**
750 * speed new
751 */
752
753 fprintf (out, "SPEED\t");
754
755 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
756 {
757 hc_device_param_t *device_param = &data.devices_param[device_id];
758
759 if (device_param->skipped) continue;
760
761 u64 speed_cnt = 0;
762 float speed_ms = 0;
763
764 for (int i = 0; i < SPEED_CACHE; i++)
765 {
766 float rec_ms;
767
768 hc_timer_get (device_param->speed_rec[i], rec_ms);
769
770 if (rec_ms > SPEED_MAXAGE) continue;
771
772 speed_cnt += device_param->speed_cnt[i];
773 speed_ms += device_param->speed_ms[i];
774 }
775
776 speed_cnt /= SPEED_CACHE;
777 speed_ms /= SPEED_CACHE;
778
779 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
780 }
781
782 /**
783 * words_cur
784 */
785
786 u64 words_cur = get_lowest_words_done ();
787
788 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
789
790 /**
791 * counter
792 */
793
794 uint salts_left = data.salts_cnt - data.salts_done;
795
796 if (salts_left == 0) salts_left = 1;
797
798 u64 progress_total = data.words_cnt * salts_left;
799
800 u64 all_done = 0;
801 u64 all_rejected = 0;
802 u64 all_restored = 0;
803
804 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
805 {
806 if (salts_left > 1)
807 {
808 // otherwise the final cracked status shows 0/XXX progress
809
810 if (data.salts_shown[salt_pos] == 1) continue;
811 }
812
813 all_done += data.words_progress_done[salt_pos];
814 all_rejected += data.words_progress_rejected[salt_pos];
815 all_restored += data.words_progress_restored[salt_pos];
816 }
817
818 u64 progress_cur = all_restored + all_done + all_rejected;
819 u64 progress_end = progress_total;
820
821 u64 progress_skip = 0;
822
823 if (data.skip)
824 {
825 progress_skip = MIN (data.skip, data.words_base) * salts_left;
826
827 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
828 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
829 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
830 }
831
832 if (data.limit)
833 {
834 progress_end = MIN (data.limit, data.words_base) * salts_left;
835
836 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
837 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
838 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
839 }
840
841 u64 progress_cur_relative_skip = progress_cur - progress_skip;
842 u64 progress_end_relative_skip = progress_end - progress_skip;
843
844 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
845
846 /**
847 * cracks
848 */
849
850 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
851 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
852
853 /**
854 * temperature
855 */
856
857 #ifdef HAVE_HWMON
858 if (data.gpu_temp_disable == 0)
859 {
860 fprintf (out, "TEMP\t");
861
862 hc_thread_mutex_lock (mux_adl);
863
864 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
865 {
866 hc_device_param_t *device_param = &data.devices_param[device_id];
867
868 if (device_param->skipped) continue;
869
870 int temp = hm_get_temperature_with_device_id (device_id);
871
872 fprintf (out, "%d\t", temp);
873 }
874
875 hc_thread_mutex_unlock (mux_adl);
876 }
877 #endif // HAVE_HWMON
878
879 #ifdef _WIN
880 fputc ('\r', out);
881 fputc ('\n', out);
882 #endif
883
884 #ifdef _POSIX
885 fputc ('\n', out);
886 #endif
887
888 fflush (out);
889 }
890
891 void status_display ()
892 {
893 if (data.devices_status == STATUS_INIT) return;
894 if (data.devices_status == STATUS_STARTING) return;
895 if (data.devices_status == STATUS_BYPASS) return;
896
897 if (data.status_automat == 1)
898 {
899 status_display_automat ();
900
901 return;
902 }
903
904 char tmp_buf[1000];
905
906 uint tmp_len = 0;
907
908 log_info ("Session.Name...: %s", data.session);
909
910 char *status_type = strstatus (data.devices_status);
911
912 uint hash_mode = data.hash_mode;
913
914 char *hash_type = strhashtype (hash_mode); // not a bug
915
916 log_info ("Status.........: %s", status_type);
917
918 /**
919 * show rules
920 */
921
922 if (data.rp_files_cnt)
923 {
924 uint i;
925
926 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
927 {
928 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
929 }
930
931 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
932
933 log_info ("Rules.Type.....: %s", tmp_buf);
934
935 tmp_len = 0;
936 }
937
938 if (data.rp_gen)
939 {
940 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
941
942 if (data.rp_gen_seed)
943 {
944 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
945 }
946 }
947
948 /**
949 * show input
950 */
951
952 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
953 {
954 if (data.wordlist_mode == WL_MODE_FILE)
955 {
956 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
957 }
958 else if (data.wordlist_mode == WL_MODE_STDIN)
959 {
960 log_info ("Input.Mode.....: Pipe");
961 }
962 }
963 else if (data.attack_mode == ATTACK_MODE_COMBI)
964 {
965 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
966 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
967 }
968 else if (data.attack_mode == ATTACK_MODE_BF)
969 {
970 char *mask = data.mask;
971
972 if (mask != NULL)
973 {
974 uint mask_len = data.css_cnt;
975
976 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
977
978 if (mask_len > 0)
979 {
980 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
981 {
982 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
983 {
984 mask_len -= data.salts_buf[0].salt_len;
985 }
986 }
987
988 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
989
990 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
991 }
992
993 if (data.maskcnt > 1)
994 {
995 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
996
997 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
998 }
999
1000 log_info ("Input.Mode.....: %s", tmp_buf);
1001 }
1002
1003 tmp_len = 0;
1004 }
1005 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1006 {
1007 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1008 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1009 }
1010 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1011 {
1012 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1013 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1014 }
1015
1016 if (data.digests_cnt == 1)
1017 {
1018 if (data.hash_mode == 2500)
1019 {
1020 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1021
1022 uint pke[25];
1023
1024 char *pke_ptr = (char *) pke;
1025
1026 for (uint i = 0; i < 25; i++)
1027 {
1028 pke[i] = byte_swap_32 (wpa->pke[i]);
1029 }
1030
1031 char mac1[6];
1032 char mac2[6];
1033
1034 memcpy (mac1, pke_ptr + 23, 6);
1035 memcpy (mac2, pke_ptr + 29, 6);
1036
1037 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1038 (char *) data.salts_buf[0].salt_buf,
1039 mac1[0] & 0xff,
1040 mac1[1] & 0xff,
1041 mac1[2] & 0xff,
1042 mac1[3] & 0xff,
1043 mac1[4] & 0xff,
1044 mac1[5] & 0xff,
1045 mac2[0] & 0xff,
1046 mac2[1] & 0xff,
1047 mac2[2] & 0xff,
1048 mac2[3] & 0xff,
1049 mac2[4] & 0xff,
1050 mac2[5] & 0xff);
1051 }
1052 else if (data.hash_mode == 5200)
1053 {
1054 log_info ("Hash.Target....: File (%s)", data.hashfile);
1055 }
1056 else if (data.hash_mode == 9000)
1057 {
1058 log_info ("Hash.Target....: File (%s)", data.hashfile);
1059 }
1060 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1061 {
1062 log_info ("Hash.Target....: File (%s)", data.hashfile);
1063 }
1064 else
1065 {
1066 char out_buf[4096];
1067
1068 ascii_digest (out_buf, 0, 0);
1069
1070 // limit length
1071 if (strlen (out_buf) > 40)
1072 {
1073 out_buf[41] = '.';
1074 out_buf[42] = '.';
1075 out_buf[43] = '.';
1076 out_buf[44] = 0;
1077 }
1078
1079 log_info ("Hash.Target....: %s", out_buf);
1080 }
1081 }
1082 else
1083 {
1084 if (data.hash_mode == 3000)
1085 {
1086 char out_buf1[4096];
1087 char out_buf2[4096];
1088
1089 ascii_digest (out_buf1, 0, 0);
1090 ascii_digest (out_buf2, 0, 1);
1091
1092 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1093 }
1094 else
1095 {
1096 log_info ("Hash.Target....: File (%s)", data.hashfile);
1097 }
1098 }
1099
1100 log_info ("Hash.Type......: %s", hash_type);
1101
1102 /**
1103 * speed new
1104 */
1105
1106 u64 speed_cnt[DEVICES_MAX];
1107 float speed_ms[DEVICES_MAX];
1108
1109 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1110 {
1111 hc_device_param_t *device_param = &data.devices_param[device_id];
1112
1113 if (device_param->skipped) continue;
1114
1115 // we need to clear values (set to 0) because in case the device does
1116 // not get new candidates it idles around but speed display would
1117 // show it as working.
1118 // if we instantly set it to 0 after reading it happens that the
1119 // speed can be shown as zero if the users refreshes too fast.
1120 // therefore, we add a timestamp when a stat was recorded and if its
1121 // too old we will not use it
1122
1123 speed_cnt[device_id] = 0;
1124 speed_ms[device_id] = 0;
1125
1126 for (int i = 0; i < SPEED_CACHE; i++)
1127 {
1128 float rec_ms;
1129
1130 hc_timer_get (device_param->speed_rec[i], rec_ms);
1131
1132 if (rec_ms > SPEED_MAXAGE) continue;
1133
1134 speed_cnt[device_id] += device_param->speed_cnt[i];
1135 speed_ms[device_id] += device_param->speed_ms[i];
1136 }
1137
1138 speed_cnt[device_id] /= SPEED_CACHE;
1139 speed_ms[device_id] /= SPEED_CACHE;
1140 }
1141
1142 float hashes_all_ms = 0;
1143
1144 float hashes_dev_ms[DEVICES_MAX];
1145
1146 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1147 {
1148 hc_device_param_t *device_param = &data.devices_param[device_id];
1149
1150 if (device_param->skipped) continue;
1151
1152 hashes_dev_ms[device_id] = 0;
1153
1154 if (speed_ms[device_id])
1155 {
1156 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1157
1158 hashes_all_ms += hashes_dev_ms[device_id];
1159 }
1160 }
1161
1162 /**
1163 * timers
1164 */
1165
1166 float ms_running = 0;
1167
1168 hc_timer_get (data.timer_running, ms_running);
1169
1170 float ms_paused = data.ms_paused;
1171
1172 if (data.devices_status == STATUS_PAUSED)
1173 {
1174 float ms_paused_tmp = 0;
1175
1176 hc_timer_get (data.timer_paused, ms_paused_tmp);
1177
1178 ms_paused += ms_paused_tmp;
1179 }
1180
1181 #ifdef WIN
1182
1183 __time64_t sec_run = ms_running / 1000;
1184
1185 #else
1186
1187 time_t sec_run = ms_running / 1000;
1188
1189 #endif
1190
1191 if (sec_run)
1192 {
1193 char display_run[32];
1194
1195 struct tm tm_run;
1196
1197 struct tm *tmp;
1198
1199 #ifdef WIN
1200
1201 tmp = _gmtime64 (&sec_run);
1202
1203 #else
1204
1205 tmp = gmtime (&sec_run);
1206
1207 #endif
1208
1209 if (tmp != NULL)
1210 {
1211 memcpy (&tm_run, tmp, sizeof (struct tm));
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];
1324
1325 struct tm tm_etc;
1326
1327 struct tm *tmp;
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 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1342
1343 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1344
1345 time_t now;
1346
1347 time (&now);
1348
1349 now += sec_etc;
1350
1351 char *etc = ctime (&now);
1352
1353 size_t etc_len = strlen (etc);
1354
1355 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1356 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1357
1358 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1359 }
1360 }
1361 }
1362 }
1363
1364 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1365 {
1366 hc_device_param_t *device_param = &data.devices_param[device_id];
1367
1368 if (device_param->skipped) continue;
1369
1370 char display_dev_cur[16] = { 0 };
1371
1372 strncpy (display_dev_cur, "0.00", 4);
1373
1374 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1375
1376 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1377 }
1378
1379 char display_all_cur[16] = { 0 };
1380
1381 strncpy (display_all_cur, "0.00", 4);
1382
1383 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1384
1385 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1386
1387 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1388 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1389
1390 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);
1391
1392 // crack-per-time
1393
1394 if (data.digests_cnt > 100)
1395 {
1396 time_t now = time (NULL);
1397
1398 int cpt_cur_min = 0;
1399 int cpt_cur_hour = 0;
1400 int cpt_cur_day = 0;
1401
1402 for (int i = 0; i < CPT_BUF; i++)
1403 {
1404 const uint cracked = data.cpt_buf[i].cracked;
1405 const time_t timestamp = data.cpt_buf[i].timestamp;
1406
1407 if ((timestamp + 60) > now)
1408 {
1409 cpt_cur_min += cracked;
1410 }
1411
1412 if ((timestamp + 3600) > now)
1413 {
1414 cpt_cur_hour += cracked;
1415 }
1416
1417 if ((timestamp + 86400) > now)
1418 {
1419 cpt_cur_day += cracked;
1420 }
1421 }
1422
1423 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1424 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1425 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1426
1427 if ((data.cpt_start + 86400) < now)
1428 {
1429 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1430 cpt_cur_min,
1431 cpt_cur_hour,
1432 cpt_cur_day,
1433 cpt_avg_min,
1434 cpt_avg_hour,
1435 cpt_avg_day);
1436 }
1437 else if ((data.cpt_start + 3600) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_avg_min,
1443 cpt_avg_hour,
1444 cpt_avg_day);
1445 }
1446 else if ((data.cpt_start + 60) < now)
1447 {
1448 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1449 cpt_cur_min,
1450 cpt_avg_min,
1451 cpt_avg_hour,
1452 cpt_avg_day);
1453 }
1454 else
1455 {
1456 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1457 cpt_avg_min,
1458 cpt_avg_hour,
1459 cpt_avg_day);
1460 }
1461 }
1462
1463 // Restore point
1464
1465 u64 restore_point = get_lowest_words_done ();
1466
1467 u64 restore_total = data.words_base;
1468
1469 float percent_restore = 0;
1470
1471 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1472
1473 if (progress_end_relative_skip)
1474 {
1475 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1476 {
1477 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1478 float percent_rejected = 0.0;
1479
1480 if (progress_cur)
1481 {
1482 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1483 }
1484
1485 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);
1486 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1487
1488 if (data.restore_disable == 0)
1489 {
1490 if (percent_finished != 1)
1491 {
1492 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1493 }
1494 }
1495 }
1496 }
1497 else
1498 {
1499 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1500 {
1501 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1502 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1503
1504 if (data.restore_disable == 0)
1505 {
1506 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1507 }
1508 }
1509 else
1510 {
1511 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1512 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1513
1514 // --restore not allowed if stdin is used -- really? why?
1515
1516 //if (data.restore_disable == 0)
1517 //{
1518 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1519 //}
1520 }
1521 }
1522
1523 #ifdef HAVE_HWMON
1524 if (data.gpu_temp_disable == 0)
1525 {
1526 hc_thread_mutex_lock (mux_adl);
1527
1528 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1529 {
1530 hc_device_param_t *device_param = &data.devices_param[device_id];
1531
1532 if (device_param->skipped) continue;
1533
1534 #define HM_STR_BUF_SIZE 255
1535
1536 if (data.hm_device[device_id].fan_supported == 1)
1537 {
1538 char utilization[HM_STR_BUF_SIZE];
1539 char temperature[HM_STR_BUF_SIZE];
1540 char fanspeed[HM_STR_BUF_SIZE];
1541
1542 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1543 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1544
1545 if (device_param->vendor_id == VENDOR_ID_AMD)
1546 {
1547 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1548 }
1549 else if (device_param->vendor_id == VENDOR_ID_NV)
1550 {
1551 #ifdef LINUX
1552 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1553 #else
1554 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1555 #endif
1556 }
1557
1558 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1559 }
1560 else
1561 {
1562 char utilization[HM_STR_BUF_SIZE];
1563 char temperature[HM_STR_BUF_SIZE];
1564
1565 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1566 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1567
1568 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1569 }
1570 }
1571
1572 hc_thread_mutex_unlock (mux_adl);
1573 }
1574 #endif // HAVE_HWMON
1575 }
1576
1577 static void status_benchmark ()
1578 {
1579 if (data.devices_status == STATUS_INIT) return;
1580 if (data.devices_status == STATUS_STARTING) return;
1581
1582 if (data.words_cnt == 0) return;
1583
1584 u64 speed_cnt[DEVICES_MAX];
1585 float speed_ms[DEVICES_MAX];
1586
1587 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1588 {
1589 hc_device_param_t *device_param = &data.devices_param[device_id];
1590
1591 if (device_param->skipped) continue;
1592
1593 speed_cnt[device_id] = 0;
1594 speed_ms[device_id] = 0;
1595
1596 for (int i = 0; i < SPEED_CACHE; i++)
1597 {
1598 speed_cnt[device_id] += device_param->speed_cnt[i];
1599 speed_ms[device_id] += device_param->speed_ms[i];
1600 }
1601
1602 speed_cnt[device_id] /= SPEED_CACHE;
1603 speed_ms[device_id] /= SPEED_CACHE;
1604 }
1605
1606 float hashes_all_ms = 0;
1607
1608 float hashes_dev_ms[DEVICES_MAX];
1609
1610 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1611 {
1612 hc_device_param_t *device_param = &data.devices_param[device_id];
1613
1614 if (device_param->skipped) continue;
1615
1616 hashes_dev_ms[device_id] = 0;
1617
1618 if (speed_ms[device_id])
1619 {
1620 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1621
1622 hashes_all_ms += hashes_dev_ms[device_id];
1623 }
1624 }
1625
1626 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1627 {
1628 hc_device_param_t *device_param = &data.devices_param[device_id];
1629
1630 if (device_param->skipped) continue;
1631
1632 char display_dev_cur[16] = { 0 };
1633
1634 strncpy (display_dev_cur, "0.00", 4);
1635
1636 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1637
1638 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1639 }
1640
1641 char display_all_cur[16] = { 0 };
1642
1643 strncpy (display_all_cur, "0.00", 4);
1644
1645 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1646
1647 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1648 }
1649
1650 /**
1651 * oclHashcat -only- functions
1652 */
1653
1654 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1655 {
1656 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1657 {
1658 if (attack_kern == ATTACK_KERN_STRAIGHT)
1659 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1660 else if (attack_kern == ATTACK_KERN_COMBI)
1661 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1662 else if (attack_kern == ATTACK_KERN_BF)
1663 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1664 }
1665 else
1666 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1667 }
1668
1669 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)
1670 {
1671 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1672 {
1673 if (attack_kern == ATTACK_KERN_STRAIGHT)
1674 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1675 else if (attack_kern == ATTACK_KERN_COMBI)
1676 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1677 else if (attack_kern == ATTACK_KERN_BF)
1678 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1679 }
1680 else
1681 {
1682 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1683 }
1684 }
1685
1686 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1687 {
1688 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1689 {
1690 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1691 }
1692 else
1693 {
1694 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1695 }
1696 }
1697
1698 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)
1699 {
1700 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1701 {
1702 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1703 }
1704 else
1705 {
1706 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1707 }
1708 }
1709
1710 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1711 {
1712 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1713 }
1714
1715 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1716 {
1717 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1718 }
1719
1720 static uint convert_from_hex (char *line_buf, const uint line_len)
1721 {
1722 if (line_len & 1) return (line_len); // not in hex
1723
1724 if (data.hex_wordlist == 1)
1725 {
1726 uint i;
1727 uint j;
1728
1729 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1730 {
1731 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1732 }
1733
1734 memset (line_buf + i, 0, line_len - i);
1735
1736 return (i);
1737 }
1738 else if (line_len >= 6) // $HEX[] = 6
1739 {
1740 if (line_buf[0] != '$') return (line_len);
1741 if (line_buf[1] != 'H') return (line_len);
1742 if (line_buf[2] != 'E') return (line_len);
1743 if (line_buf[3] != 'X') return (line_len);
1744 if (line_buf[4] != '[') return (line_len);
1745 if (line_buf[line_len - 1] != ']') return (line_len);
1746
1747 uint i;
1748 uint j;
1749
1750 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1751 {
1752 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1753 }
1754
1755 memset (line_buf + i, 0, line_len - i);
1756
1757 return (i);
1758 }
1759
1760 return (line_len);
1761 }
1762
1763 static uint count_lines (FILE *fd)
1764 {
1765 uint cnt = 0;
1766
1767 char *buf = (char *) mymalloc (BUFSIZ + 1);
1768
1769 size_t nread_tmp = 0;
1770
1771 char *ptr = buf;
1772
1773 while (!feof (fd))
1774 {
1775 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1776 nread_tmp = nread;
1777
1778 if (nread < 1) continue;
1779
1780 ptr = buf;
1781
1782 do
1783 {
1784 if (*ptr++ == '\n') cnt++;
1785
1786 } while (nread--);
1787 }
1788
1789 // special case (if last line did not contain a newline char ... at the very end of the file)
1790
1791 if (nread_tmp > 3)
1792 {
1793 ptr -= 2;
1794
1795 if (*ptr != '\n')
1796 {
1797 ptr--;
1798
1799 if (*ptr != '\n') // needed ? different on windows systems?
1800 {
1801 cnt++;
1802 }
1803 }
1804 }
1805
1806 myfree (buf);
1807
1808 return cnt;
1809 }
1810
1811 static void clear_prompt ()
1812 {
1813 fputc ('\r', stdout);
1814
1815 for (size_t i = 0; i < strlen (PROMPT); i++)
1816 {
1817 fputc (' ', stdout);
1818 }
1819
1820 fputc ('\r', stdout);
1821
1822 fflush (stdout);
1823 }
1824
1825 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1826 {
1827 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1828 }
1829
1830 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1831 {
1832 char *outfile = data.outfile;
1833 uint quiet = data.quiet;
1834 FILE *pot_fp = data.pot_fp;
1835 uint loopback = data.loopback;
1836 uint debug_mode = data.debug_mode;
1837 char *debug_file = data.debug_file;
1838
1839 char debug_rule_buf[BLOCK_SIZE];
1840 int debug_rule_len = 0; // -1 error
1841 uint debug_plain_len = 0;
1842
1843 u8 debug_plain_ptr[BLOCK_SIZE];
1844
1845 // hash
1846
1847 char out_buf[4096] = { 0 };
1848
1849 ascii_digest (out_buf, salt_pos, digest_pos);
1850
1851 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1852
1853 // plain
1854
1855 plain_t plain;
1856
1857 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1858
1859 uint gidvid = plain.gidvid;
1860 uint il_pos = plain.il_pos;
1861
1862 u64 crackpos = device_param->words_off;
1863
1864 uint plain_buf[16];
1865
1866 u8 *plain_ptr = (u8 *) plain_buf;
1867 unsigned int plain_len = 0;
1868
1869 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1870 {
1871 u64 gidd = gidvid;
1872 u64 gidm = 0;
1873
1874 pw_t pw;
1875
1876 gidd_to_pw_t (device_param, gidd, &pw);
1877
1878 for (int i = 0, j = gidm; i < 16; i++, j++)
1879 {
1880 plain_buf[i] = pw.hi1[0][j];
1881 }
1882
1883 plain_len = pw.pw_len;
1884
1885 const uint off = device_param->innerloop_pos + il_pos;
1886
1887 if (debug_mode > 0)
1888 {
1889 debug_rule_len = 0;
1890
1891 // save rule
1892 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1893 {
1894 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1895
1896 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1897 }
1898
1899 // save plain
1900 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1901 {
1902 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1903
1904 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1905
1906 debug_plain_len = plain_len;
1907 }
1908 }
1909
1910 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1911
1912 crackpos += gidvid;
1913 crackpos *= data.kernel_rules_cnt;
1914 crackpos += device_param->innerloop_pos + il_pos;
1915
1916 if (plain_len > data.pw_max) plain_len = data.pw_max;
1917 }
1918 else if (data.attack_mode == ATTACK_MODE_COMBI)
1919 {
1920 u64 gidd = gidvid;
1921 u64 gidm = 0;
1922
1923 pw_t pw;
1924
1925 gidd_to_pw_t (device_param, gidd, &pw);
1926
1927 for (int i = 0, j = gidm; i < 16; i++, j++)
1928 {
1929 plain_buf[i] = pw.hi1[0][j];
1930 }
1931
1932 plain_len = pw.pw_len;
1933
1934 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1935 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1936
1937 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1938 {
1939 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1940 }
1941 else
1942 {
1943 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1944
1945 memcpy (plain_ptr, comb_buf, comb_len);
1946 }
1947
1948 plain_len += comb_len;
1949
1950 crackpos += gidvid;
1951 crackpos *= data.combs_cnt;
1952 crackpos += device_param->innerloop_pos + il_pos;
1953
1954 if (data.pw_max != PW_DICTMAX1)
1955 {
1956 if (plain_len > data.pw_max) plain_len = data.pw_max;
1957 }
1958 }
1959 else if (data.attack_mode == ATTACK_MODE_BF)
1960 {
1961 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1962 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1963
1964 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1965 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1966
1967 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1968 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1969
1970 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1971 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1972
1973 plain_len = data.css_cnt;
1974
1975 crackpos += gidvid;
1976 crackpos *= data.bfs_cnt;
1977 crackpos += device_param->innerloop_pos + il_pos;
1978 }
1979 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1980 {
1981 u64 gidd = gidvid;
1982 u64 gidm = 0;
1983
1984 pw_t pw;
1985
1986 gidd_to_pw_t (device_param, gidd, &pw);
1987
1988 for (int i = 0, j = gidm; i < 16; i++, j++)
1989 {
1990 plain_buf[i] = pw.hi1[0][j];
1991 }
1992
1993 plain_len = pw.pw_len;
1994
1995 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1996
1997 uint start = 0;
1998 uint stop = device_param->kernel_params_mp_buf32[4];
1999
2000 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2001
2002 plain_len += start + stop;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.combs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007
2008 if (data.pw_max != PW_DICTMAX1)
2009 {
2010 if (plain_len > data.pw_max) plain_len = data.pw_max;
2011 }
2012 }
2013 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2014 {
2015 u64 gidd = gidvid;
2016 u64 gidm = 0;
2017
2018 pw_t pw;
2019
2020 gidd_to_pw_t (device_param, gidd, &pw);
2021
2022 for (int i = 0, j = gidm; i < 16; i++, j++)
2023 {
2024 plain_buf[i] = pw.hi1[0][j];
2025 }
2026
2027 plain_len = pw.pw_len;
2028
2029 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2030
2031 uint start = 0;
2032 uint stop = device_param->kernel_params_mp_buf32[4];
2033
2034 memmove (plain_ptr + stop, plain_ptr, plain_len);
2035
2036 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2037
2038 plain_len += start + stop;
2039
2040 crackpos += gidvid;
2041 crackpos *= data.combs_cnt;
2042 crackpos += device_param->innerloop_pos + il_pos;
2043
2044 if (data.pw_max != PW_DICTMAX1)
2045 {
2046 if (plain_len > data.pw_max) plain_len = data.pw_max;
2047 }
2048 }
2049
2050 if (data.attack_mode == ATTACK_MODE_BF)
2051 {
2052 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2053 {
2054 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2055 {
2056 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2057 {
2058 plain_len = plain_len - data.salts_buf[0].salt_len;
2059 }
2060 }
2061
2062 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2063 {
2064 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2065 {
2066 plain_ptr[j] = plain_ptr[i];
2067 }
2068
2069 plain_len = plain_len / 2;
2070 }
2071 }
2072 }
2073
2074 // if enabled, update also the potfile
2075
2076 if (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
2087 // outfile
2088
2089 FILE *out_fp = NULL;
2090
2091 if (outfile != NULL)
2092 {
2093 if ((out_fp = fopen (outfile, "ab")) == NULL)
2094 {
2095 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2096
2097 out_fp = stdout;
2098 }
2099 }
2100 else
2101 {
2102 out_fp = stdout;
2103
2104 if (quiet == 0) clear_prompt ();
2105 }
2106
2107 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2108
2109 if (outfile != NULL)
2110 {
2111 if (out_fp != stdout)
2112 {
2113 fclose (out_fp);
2114 }
2115 }
2116 else
2117 {
2118 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2119 {
2120 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2121 {
2122 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2123 if (quiet == 0) fflush (stdout);
2124 }
2125 }
2126 }
2127
2128 // loopback
2129
2130 if (loopback)
2131 {
2132 char *loopback_file = data.loopback_file;
2133
2134 FILE *fb_fp = NULL;
2135
2136 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2137 {
2138 format_plain (fb_fp, plain_ptr, plain_len, 1);
2139
2140 fputc ('\n', fb_fp);
2141
2142 fclose (fb_fp);
2143 }
2144 }
2145
2146 // (rule) debug mode
2147
2148 // the next check implies that:
2149 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2150 // - debug_mode > 0
2151
2152 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2153 {
2154 if (debug_rule_len < 0) debug_rule_len = 0;
2155
2156 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2157
2158 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2159
2160 if ((quiet == 0) && (debug_file == NULL))
2161 {
2162 fprintf (stdout, "%s", PROMPT);
2163 fflush (stdout);
2164 }
2165 }
2166 }
2167
2168 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2169 {
2170 salt_t *salt_buf = &data.salts_buf[salt_pos];
2171
2172 int found = 0;
2173
2174 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2175
2176 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2177
2178 if (found == 1)
2179 {
2180 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2181
2182 log_info_nn ("");
2183
2184 hc_clEnqueueReadBuffer (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);
2185
2186 uint cpt_cracked = 0;
2187
2188 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2189 {
2190 uint idx = salt_buf->digests_offset + digest_pos;
2191
2192 if (data.digests_shown_tmp[idx] == 0) continue;
2193
2194 if (data.digests_shown[idx] == 1) continue;
2195
2196 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2197 {
2198 data.digests_shown[idx] = 1;
2199
2200 data.digests_done++;
2201
2202 cpt_cracked++;
2203
2204 salt_buf->digests_done++;
2205
2206 if (salt_buf->digests_done == salt_buf->digests_cnt)
2207 {
2208 data.salts_shown[salt_pos] = 1;
2209
2210 data.salts_done++;
2211 }
2212 }
2213
2214 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2215
2216 check_hash (device_param, salt_pos, digest_pos);
2217 }
2218
2219 if (cpt_cracked > 0)
2220 {
2221 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2222 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2223
2224 data.cpt_pos++;
2225
2226 data.cpt_total += cpt_cracked;
2227
2228 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2229 }
2230
2231 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2232 {
2233 // we need to reset cracked state on the device
2234 // otherwise host thinks again and again the hash was cracked
2235 // and returns invalid password each time
2236
2237 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2238
2239 hc_clEnqueueWriteBuffer (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);
2240 }
2241
2242 memset (device_param->result, 0, device_param->size_results);
2243
2244 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2245 }
2246 }
2247
2248 static void save_hash ()
2249 {
2250 char *hashfile = data.hashfile;
2251
2252 char new_hashfile[256] = { 0 };
2253 char old_hashfile[256] = { 0 };
2254
2255 snprintf (new_hashfile, 255, "%s.new", hashfile);
2256 snprintf (old_hashfile, 255, "%s.old", hashfile);
2257
2258 unlink (new_hashfile);
2259
2260 char separator = data.separator;
2261
2262 FILE *fp = fopen (new_hashfile, "wb");
2263
2264 if (fp == NULL)
2265 {
2266 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2267
2268 exit (-1);
2269 }
2270
2271 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2272 {
2273 if (data.salts_shown[salt_pos] == 1) continue;
2274
2275 salt_t *salt_buf = &data.salts_buf[salt_pos];
2276
2277 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2278 {
2279 uint idx = salt_buf->digests_offset + digest_pos;
2280
2281 if (data.digests_shown[idx] == 1) continue;
2282
2283 if (data.hash_mode != 2500)
2284 {
2285 char out_buf[4096] = { 0 };
2286
2287 if (data.username == 1)
2288 {
2289 user_t *user = data.hash_info[idx]->user;
2290
2291 uint i;
2292
2293 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2294
2295 fputc (separator, fp);
2296 }
2297
2298 ascii_digest (out_buf, salt_pos, digest_pos);
2299
2300 fputs (out_buf, fp);
2301
2302 log_out (fp, "");
2303 }
2304 else
2305 {
2306 hccap_t hccap;
2307
2308 to_hccap_t (&hccap, salt_pos, digest_pos);
2309
2310 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2311 }
2312 }
2313 }
2314
2315 fflush (fp);
2316
2317 fclose (fp);
2318
2319 unlink (old_hashfile);
2320
2321 if (rename (hashfile, old_hashfile) != 0)
2322 {
2323 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2324
2325 exit (-1);
2326 }
2327
2328 unlink (hashfile);
2329
2330 if (rename (new_hashfile, hashfile) != 0)
2331 {
2332 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2333
2334 exit (-1);
2335 }
2336
2337 unlink (old_hashfile);
2338 }
2339
2340 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2341 {
2342 // function called only in case kernel_blocks_all > words_left)
2343
2344 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2345
2346 kernel_blocks_div += kernel_blocks_div / 100;
2347
2348 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2349
2350 while (kernel_blocks_new < total_left)
2351 {
2352 kernel_blocks_div += kernel_blocks_div / 100;
2353
2354 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2355 }
2356
2357 if (data.quiet == 0)
2358 {
2359 clear_prompt ();
2360
2361 log_info ("");
2362
2363 log_info ("INFO: approaching final keyspace, workload adjusted");
2364
2365 log_info ("");
2366
2367 fprintf (stdout, "%s", PROMPT);
2368
2369 fflush (stdout);
2370 }
2371
2372 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2373
2374 return kernel_blocks_div;
2375 }
2376
2377 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2378 {
2379 uint num_elements = num;
2380
2381 device_param->kernel_params_buf32[30] = data.combs_mode;
2382 device_param->kernel_params_buf32[31] = num;
2383
2384 uint kernel_threads = device_param->kernel_threads;
2385
2386 while (num_elements % kernel_threads) num_elements++;
2387
2388 cl_kernel kernel = NULL;
2389
2390 switch (kern_run)
2391 {
2392 case KERN_RUN_1: kernel = device_param->kernel1; break;
2393 case KERN_RUN_12: kernel = device_param->kernel12; break;
2394 case KERN_RUN_2: kernel = device_param->kernel2; break;
2395 case KERN_RUN_23: kernel = device_param->kernel23; break;
2396 case KERN_RUN_3: kernel = device_param->kernel3; break;
2397 }
2398
2399 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2400 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2401 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2402 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2403 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2404 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2405 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2406 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2407 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2408 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2409 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2410
2411 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2412 {
2413 const size_t global_work_size[3] = { num_elements, 32, 1 };
2414 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2415
2416 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2417 }
2418 else
2419 {
2420 const size_t global_work_size[3] = { num_elements, 1, 1 };
2421 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2422
2423 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2424 }
2425
2426 hc_clFlush (device_param->command_queue);
2427
2428 hc_clFinish (device_param->command_queue);
2429 }
2430
2431 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2432 {
2433 uint num_elements = num;
2434
2435 switch (kern_run)
2436 {
2437 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2438 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2439 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2440 }
2441
2442 // causes problems with special threads like in bcrypt
2443 // const uint kernel_threads = device_param->kernel_threads;
2444
2445 const uint kernel_threads = KERNEL_THREADS;
2446
2447 while (num_elements % kernel_threads) num_elements++;
2448
2449 cl_kernel kernel = NULL;
2450
2451 switch (kern_run)
2452 {
2453 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2454 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2455 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2456 }
2457
2458 switch (kern_run)
2459 {
2460 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2461 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2462 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2463 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2464 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2465 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2466 break;
2467 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2468 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2469 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2470 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2471 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2472 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2473 break;
2474 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2475 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2476 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2477 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2478 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2479 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2480 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2481 break;
2482 }
2483
2484 const size_t global_work_size[3] = { num_elements, 1, 1 };
2485 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2486
2487 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2488
2489 hc_clFlush (device_param->command_queue);
2490
2491 hc_clFinish (device_param->command_queue);
2492 }
2493
2494 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2495 {
2496 uint num_elements = num;
2497
2498 uint kernel_threads = device_param->kernel_threads;
2499
2500 while (num_elements % kernel_threads) num_elements++;
2501
2502 cl_kernel kernel = device_param->kernel_tb;
2503
2504 const size_t global_work_size[3] = { num_elements, 1, 1 };
2505 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2506
2507 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2508
2509 hc_clFlush (device_param->command_queue);
2510
2511 hc_clFinish (device_param->command_queue);
2512 }
2513
2514 static void run_kernel_tm (hc_device_param_t *device_param)
2515 {
2516 const uint num_elements = 1024; // fixed
2517
2518 const uint kernel_threads = 32;
2519
2520 cl_kernel kernel = device_param->kernel_tm;
2521
2522 const size_t global_work_size[3] = { num_elements, 1, 1 };
2523 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2524
2525 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2526
2527 hc_clFlush (device_param->command_queue);
2528
2529 hc_clFinish (device_param->command_queue);
2530 }
2531
2532 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2533 {
2534 uint num_elements = num;
2535
2536 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2537 device_param->kernel_params_amp_buf32[6] = num_elements;
2538
2539 // causes problems with special threads like in bcrypt
2540 // const uint kernel_threads = device_param->kernel_threads;
2541
2542 const uint kernel_threads = KERNEL_THREADS;
2543
2544 while (num_elements % kernel_threads) num_elements++;
2545
2546 cl_kernel kernel = device_param->kernel_amp;
2547
2548 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2549 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2550
2551 const size_t global_work_size[3] = { num_elements, 1, 1 };
2552 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2553
2554 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2555
2556 hc_clFlush (device_param->command_queue);
2557
2558 hc_clFinish (device_param->command_queue);
2559 }
2560
2561 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2562 {
2563 if (device_param->vendor_id == VENDOR_ID_AMD)
2564 {
2565 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2566
2567 const cl_uchar zero = 0;
2568
2569 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2570 }
2571 else
2572 {
2573 // NOTE: clEnqueueFillBuffer () always fails with -59
2574 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2575 // How's that possible, OpenCL 1.2 support is advertised??
2576 // We need to workaround...
2577
2578 #define FILLSZ 0x100000
2579
2580 char *tmp = (char *) mymalloc (FILLSZ);
2581
2582 memset (tmp, 0, FILLSZ);
2583
2584 for (uint i = 0; i < size; i += FILLSZ)
2585 {
2586 const int left = size - i;
2587
2588 const int fillsz = MIN (FILLSZ, left);
2589
2590 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2591 }
2592
2593 myfree (tmp);
2594 }
2595 }
2596
2597 static int run_rule_engine (const int rule_len, const char *rule_buf)
2598 {
2599 if (rule_len == 0)
2600 {
2601 return 0;
2602 }
2603 else if (rule_len == 1)
2604 {
2605 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2606 }
2607
2608 return 1;
2609 }
2610
2611 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2612 {
2613 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2614 {
2615 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2616 }
2617 else if (data.attack_kern == ATTACK_KERN_COMBI)
2618 {
2619 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2620 }
2621 else if (data.attack_kern == ATTACK_KERN_BF)
2622 {
2623 const u64 off = device_param->words_off;
2624
2625 device_param->kernel_params_mp_l_buf64[3] = off;
2626
2627 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2628 }
2629 }
2630
2631 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2632 {
2633 const uint kernel_loops = data.kernel_loops;
2634
2635 // init speed timer
2636
2637 uint speed_pos = device_param->speed_pos;
2638
2639 #ifdef _POSIX
2640 if (device_param->timer_speed.tv_sec == 0)
2641 {
2642 hc_timer_set (&device_param->timer_speed);
2643 }
2644 #endif
2645
2646 #ifdef _WIN
2647 if (device_param->timer_speed.QuadPart == 0)
2648 {
2649 hc_timer_set (&device_param->timer_speed);
2650 }
2651 #endif
2652
2653 // find higest password length, this is for optimization stuff
2654
2655 uint highest_pw_len = 0;
2656
2657 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2658 {
2659 }
2660 else if (data.attack_kern == ATTACK_KERN_COMBI)
2661 {
2662 }
2663 else if (data.attack_kern == ATTACK_KERN_BF)
2664 {
2665 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2666 + device_param->kernel_params_mp_l_buf32[5];
2667 }
2668
2669 // bitslice optimization stuff
2670
2671 if (data.attack_mode == ATTACK_MODE_BF)
2672 {
2673 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2674 {
2675 run_kernel_tb (device_param, pws_cnt);
2676 }
2677 }
2678
2679 // iteration type
2680
2681 uint innerloop_step = 0;
2682 uint innerloop_cnt = 0;
2683
2684 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2685 else innerloop_step = 1;
2686
2687 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2688 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2689 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2690
2691 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2692
2693 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2694 {
2695 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2696
2697 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2698
2699 if (data.devices_status == STATUS_CRACKED) break;
2700 if (data.devices_status == STATUS_ABORTED) break;
2701 if (data.devices_status == STATUS_QUIT) break;
2702 if (data.devices_status == STATUS_BYPASS) break;
2703
2704 if (data.salts_shown[salt_pos] == 1) continue;
2705
2706 salt_t *salt_buf = &data.salts_buf[salt_pos];
2707
2708 device_param->kernel_params_buf32[24] = salt_pos;
2709 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2710 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2711
2712 FILE *combs_fp = device_param->combs_fp;
2713
2714 if (data.attack_mode == ATTACK_MODE_COMBI)
2715 {
2716 rewind (combs_fp);
2717 }
2718
2719 // innerloops
2720
2721 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2722 {
2723 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2724
2725 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2726
2727 if (data.devices_status == STATUS_CRACKED) break;
2728 if (data.devices_status == STATUS_ABORTED) break;
2729 if (data.devices_status == STATUS_QUIT) break;
2730 if (data.devices_status == STATUS_BYPASS) break;
2731
2732 uint innerloop_left = innerloop_cnt - innerloop_pos;
2733
2734 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2735
2736 device_param->innerloop_pos = innerloop_pos;
2737 device_param->innerloop_left = innerloop_left;
2738
2739 device_param->kernel_params_buf32[27] = innerloop_left;
2740
2741 if (innerloop_left == 0) continue;
2742
2743 // initialize amplifiers
2744
2745 if (data.attack_mode == ATTACK_MODE_COMBI)
2746 {
2747 char line_buf[BUFSIZ];
2748
2749 uint i = 0;
2750
2751 while (i < innerloop_left)
2752 {
2753 if (feof (combs_fp)) break;
2754
2755 int line_len = fgetl (combs_fp, line_buf);
2756
2757 if (line_len >= PW_MAX1) continue;
2758
2759 line_len = convert_from_hex (line_buf, line_len);
2760
2761 char *line_buf_new = line_buf;
2762
2763 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2764 {
2765 char rule_buf_out[BLOCK_SIZE] = { 0 };
2766
2767 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2768
2769 if (rule_len_out < 0)
2770 {
2771 data.words_progress_rejected[salt_pos] += pw_cnt;
2772
2773 continue;
2774 }
2775
2776 line_len = rule_len_out;
2777
2778 line_buf_new = rule_buf_out;
2779 }
2780
2781 line_len = MIN (line_len, PW_DICTMAX);
2782
2783 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2784
2785 memcpy (ptr, line_buf_new, line_len);
2786
2787 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2788
2789 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2790 {
2791 uppercase (ptr, line_len);
2792 }
2793
2794 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2795 {
2796 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2797 {
2798 ptr[line_len] = 0x80;
2799 }
2800
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 ptr[line_len] = 0x01;
2804 }
2805 }
2806
2807 device_param->combs_buf[i].pw_len = line_len;
2808
2809 i++;
2810 }
2811
2812 for (uint j = i; j < innerloop_left; j++)
2813 {
2814 device_param->combs_buf[j].i[0] = 0;
2815 device_param->combs_buf[j].i[1] = 0;
2816 device_param->combs_buf[j].i[2] = 0;
2817 device_param->combs_buf[j].i[3] = 0;
2818 device_param->combs_buf[j].i[4] = 0;
2819 device_param->combs_buf[j].i[5] = 0;
2820 device_param->combs_buf[j].i[6] = 0;
2821 device_param->combs_buf[j].i[7] = 0;
2822
2823 device_param->combs_buf[j].pw_len = 0;
2824 }
2825
2826 innerloop_left = i;
2827 }
2828 else if (data.attack_mode == ATTACK_MODE_BF)
2829 {
2830 u64 off = innerloop_pos;
2831
2832 device_param->kernel_params_mp_r_buf64[3] = off;
2833
2834 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2835 }
2836 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2837 {
2838 u64 off = innerloop_pos;
2839
2840 device_param->kernel_params_mp_buf64[3] = off;
2841
2842 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2843 }
2844 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2845 {
2846 u64 off = innerloop_pos;
2847
2848 device_param->kernel_params_mp_buf64[3] = off;
2849
2850 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2851 }
2852
2853 // copy amplifiers
2854
2855 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2856 {
2857 hc_clEnqueueCopyBuffer (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);
2858 }
2859 else if (data.attack_mode == ATTACK_MODE_COMBI)
2860 {
2861 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2862 }
2863 else if (data.attack_mode == ATTACK_MODE_BF)
2864 {
2865 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2866 }
2867 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2868 {
2869 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2874 }
2875
2876 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2877 {
2878 if (data.attack_mode == ATTACK_MODE_BF)
2879 {
2880 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2881 {
2882 const uint size_tm = 32 * sizeof (bs_word_t);
2883
2884 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2885
2886 run_kernel_tm (device_param);
2887
2888 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2889 }
2890 }
2891
2892 if (highest_pw_len < 16)
2893 {
2894 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2895 }
2896 else if (highest_pw_len < 32)
2897 {
2898 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2899 }
2900 else
2901 {
2902 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2903 }
2904 }
2905 else
2906 {
2907 run_kernel_amp (device_param, pws_cnt);
2908
2909 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2910
2911 if (data.opts_type & OPTS_TYPE_HOOK12)
2912 {
2913 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2914 }
2915
2916 uint iter = salt_buf->salt_iter;
2917
2918 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2919 {
2920 uint loop_left = iter - loop_pos;
2921
2922 loop_left = MIN (loop_left, kernel_loops);
2923
2924 device_param->kernel_params_buf32[25] = loop_pos;
2925 device_param->kernel_params_buf32[26] = loop_left;
2926
2927 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2928
2929 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2930
2931 if (data.devices_status == STATUS_CRACKED) break;
2932 if (data.devices_status == STATUS_ABORTED) break;
2933 if (data.devices_status == STATUS_QUIT) break;
2934 }
2935
2936 if (data.opts_type & OPTS_TYPE_HOOK23)
2937 {
2938 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2939
2940 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2941
2942 // do something with data
2943
2944 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2945 }
2946
2947 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2948 }
2949
2950 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2951
2952 if (data.devices_status == STATUS_CRACKED) break;
2953 if (data.devices_status == STATUS_ABORTED) break;
2954 if (data.devices_status == STATUS_QUIT) break;
2955
2956 /**
2957 * result
2958 */
2959
2960 hc_thread_mutex_lock (mux_display);
2961
2962 check_cracked (device_param, salt_pos);
2963
2964 hc_thread_mutex_unlock (mux_display);
2965
2966 /**
2967 * progress
2968 */
2969
2970 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2971
2972 hc_thread_mutex_lock (mux_counter);
2973
2974 data.words_progress_done[salt_pos] += perf_sum_all;
2975
2976 hc_thread_mutex_unlock (mux_counter);
2977
2978 /**
2979 * speed
2980 */
2981
2982 float speed_ms;
2983
2984 hc_timer_get (device_param->timer_speed, speed_ms);
2985
2986 hc_timer_set (&device_param->timer_speed);
2987
2988 hc_thread_mutex_lock (mux_display);
2989
2990 device_param->speed_cnt[speed_pos] = perf_sum_all;
2991
2992 device_param->speed_ms[speed_pos] = speed_ms;
2993
2994 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2995
2996 hc_thread_mutex_unlock (mux_display);
2997
2998 speed_pos++;
2999
3000 if (speed_pos == SPEED_CACHE)
3001 {
3002 speed_pos = 0;
3003 }
3004 }
3005 }
3006
3007 device_param->speed_pos = speed_pos;
3008 }
3009
3010 static void load_segment (wl_data_t *wl_data, FILE *fd)
3011 {
3012 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3013
3014 wl_data->pos = 0;
3015
3016 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3017
3018 wl_data->buf[wl_data->cnt] = 0;
3019
3020 if (wl_data->cnt == 0) return;
3021
3022 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3023
3024 while (!feof (fd))
3025 {
3026 if (wl_data->cnt == wl_data->avail)
3027 {
3028 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3029
3030 wl_data->avail += wl_data->incr;
3031 }
3032
3033 const int c = fgetc (fd);
3034
3035 if (c == EOF) break;
3036
3037 wl_data->buf[wl_data->cnt] = (char) c;
3038
3039 wl_data->cnt++;
3040
3041 if (c == '\n') break;
3042 }
3043
3044 // ensure stream ends with a newline
3045
3046 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3047 {
3048 wl_data->cnt++;
3049
3050 wl_data->buf[wl_data->cnt - 1] = '\n';
3051 }
3052
3053 return;
3054 }
3055
3056 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3057 {
3058 char *ptr = buf;
3059
3060 for (u32 i = 0; i < sz; i++, ptr++)
3061 {
3062 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3063
3064 if (i == 7)
3065 {
3066 *off = i;
3067 *len = i;
3068
3069 return;
3070 }
3071
3072 if (*ptr != '\n') continue;
3073
3074 *off = i + 1;
3075
3076 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3077
3078 *len = i;
3079
3080 return;
3081 }
3082
3083 *off = sz;
3084 *len = sz;
3085 }
3086
3087 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3088 {
3089 char *ptr = buf;
3090
3091 for (u32 i = 0; i < sz; i++, ptr++)
3092 {
3093 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3094
3095 if (*ptr != '\n') continue;
3096
3097 *off = i + 1;
3098
3099 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3100
3101 *len = i;
3102
3103 return;
3104 }
3105
3106 *off = sz;
3107 *len = sz;
3108 }
3109
3110 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3111 {
3112 char *ptr = buf;
3113
3114 for (u32 i = 0; i < sz; i++, ptr++)
3115 {
3116 if (*ptr != '\n') continue;
3117
3118 *off = i + 1;
3119
3120 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3121
3122 *len = i;
3123
3124 return;
3125 }
3126
3127 *off = sz;
3128 *len = sz;
3129 }
3130
3131 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3132 {
3133 while (wl_data->pos < wl_data->cnt)
3134 {
3135 uint off;
3136 uint len;
3137
3138 char *ptr = wl_data->buf + wl_data->pos;
3139
3140 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3141
3142 wl_data->pos += off;
3143
3144 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3145 {
3146 char rule_buf_out[BLOCK_SIZE] = { 0 };
3147
3148 int rule_len_out = -1;
3149
3150 if (len < BLOCK_SIZE)
3151 {
3152 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3153 }
3154
3155 if (rule_len_out < 0)
3156 {
3157 continue;
3158 }
3159
3160 if (rule_len_out > PW_MAX)
3161 {
3162 continue;
3163 }
3164 }
3165 else
3166 {
3167 if (len > PW_MAX)
3168 {
3169 continue;
3170 }
3171 }
3172
3173 *out_buf = ptr;
3174 *out_len = len;
3175
3176 return;
3177 }
3178
3179 if (feof (fd))
3180 {
3181 fprintf (stderr, "bug!!\n");
3182
3183 return;
3184 }
3185
3186 load_segment (wl_data, fd);
3187
3188 get_next_word (wl_data, fd, out_buf, out_len);
3189 }
3190
3191 #ifdef _POSIX
3192 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3193 #endif
3194
3195 #ifdef _WIN
3196 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3197 #endif
3198 {
3199 hc_signal (NULL);
3200
3201 dictstat_t d;
3202
3203 d.cnt = 0;
3204
3205 #ifdef _POSIX
3206 fstat (fileno (fd), &d.stat);
3207 #endif
3208
3209 #ifdef _WIN
3210 _fstat64 (fileno (fd), &d.stat);
3211 #endif
3212
3213 d.stat.st_mode = 0;
3214 d.stat.st_nlink = 0;
3215 d.stat.st_uid = 0;
3216 d.stat.st_gid = 0;
3217 d.stat.st_rdev = 0;
3218 d.stat.st_atime = 0;
3219
3220 #ifdef _POSIX
3221 d.stat.st_blksize = 0;
3222 d.stat.st_blocks = 0;
3223 #endif
3224
3225 if (d.stat.st_size == 0) return 0;
3226
3227 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3228
3229 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3230 {
3231 if (d_cache)
3232 {
3233 u64 cnt = d_cache->cnt;
3234
3235 u64 keyspace = cnt;
3236
3237 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3238 {
3239 keyspace *= data.kernel_rules_cnt;
3240 }
3241 else if (data.attack_kern == ATTACK_KERN_COMBI)
3242 {
3243 keyspace *= data.combs_cnt;
3244 }
3245
3246 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);
3247 if (data.quiet == 0) log_info ("");
3248
3249 hc_signal (sigHandler_default);
3250
3251 return (keyspace);
3252 }
3253 }
3254
3255 time_t now = 0;
3256 time_t prev = 0;
3257
3258 u64 comp = 0;
3259 u64 cnt = 0;
3260 u64 cnt2 = 0;
3261
3262 while (!feof (fd))
3263 {
3264 load_segment (wl_data, fd);
3265
3266 comp += wl_data->cnt;
3267
3268 u32 i = 0;
3269
3270 while (i < wl_data->cnt)
3271 {
3272 u32 len;
3273 u32 off;
3274
3275 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3276
3277 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3278 {
3279 char rule_buf_out[BLOCK_SIZE] = { 0 };
3280
3281 int rule_len_out = -1;
3282
3283 if (len < BLOCK_SIZE)
3284 {
3285 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3286 }
3287
3288 if (rule_len_out < 0)
3289 {
3290 len = PW_MAX1;
3291 }
3292 else
3293 {
3294 len = rule_len_out;
3295 }
3296 }
3297
3298 if (len < PW_MAX1)
3299 {
3300 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3301 {
3302 cnt += data.kernel_rules_cnt;
3303 }
3304 else if (data.attack_kern == ATTACK_KERN_COMBI)
3305 {
3306 cnt += data.combs_cnt;
3307 }
3308
3309 d.cnt++;
3310 }
3311
3312 i += off;
3313
3314 cnt2++;
3315 }
3316
3317 time (&now);
3318
3319 if ((now - prev) == 0) continue;
3320
3321 float percent = (float) comp / (float) d.stat.st_size;
3322
3323 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);
3324
3325 time (&prev);
3326 }
3327
3328 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);
3329 if (data.quiet == 0) log_info ("");
3330
3331 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3332
3333 hc_signal (sigHandler_default);
3334
3335 return (cnt);
3336 }
3337
3338 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3339 {
3340 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3341 }
3342
3343 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3344 {
3345 if (data.devices_status == STATUS_BYPASS) return 0;
3346
3347 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3348
3349 uint cache_cnt = pw_cache->cnt;
3350
3351 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3352
3353 memcpy (pw_hc1, pw_buf, pw_len);
3354
3355 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3356
3357 uint pws_cnt = device_param->pws_cnt;
3358
3359 cache_cnt++;
3360
3361 pw_t *pw = device_param->pws_buf + pws_cnt;
3362
3363 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3364
3365 pw->pw_len = pw_len;
3366
3367 pws_cnt++;
3368
3369 device_param->pws_cnt = pws_cnt;
3370 device_param->pw_cnt = pws_cnt * 1;
3371
3372 cache_cnt = 0;
3373
3374 pw_cache->cnt = cache_cnt;
3375
3376 return pws_cnt;
3377 }
3378
3379 static void *thread_monitor (void *p)
3380 {
3381 uint runtime_check = 0;
3382 uint remove_check = 0;
3383 uint status_check = 0;
3384 uint restore_check = 0;
3385
3386 uint restore_left = data.restore_timer;
3387 uint remove_left = data.remove_timer;
3388 uint status_left = data.status_timer;
3389
3390 #ifdef HAVE_HWMON
3391 uint hwmon_check = 0;
3392
3393 // these variables are mainly used for fan control (AMD only)
3394
3395 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3396
3397 // temperature controller "loopback" values
3398
3399 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3400 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3401
3402 #ifdef HAVE_ADL
3403 int temp_threshold = 1; // degrees celcius
3404
3405 int fan_speed_min = 15; // in percentage
3406 int fan_speed_max = 100;
3407 #endif // HAVE_ADL
3408
3409 time_t last_temp_check_time;
3410 #endif // HAVE_HWMON
3411
3412 uint sleep_time = 1;
3413
3414 if (data.runtime)
3415 {
3416 runtime_check = 1;
3417 }
3418
3419 if (data.restore_timer)
3420 {
3421 restore_check = 1;
3422 }
3423
3424 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3425 {
3426 remove_check = 1;
3427 }
3428
3429 if (data.status == 1)
3430 {
3431 status_check = 1;
3432 }
3433
3434 #ifdef HAVE_HWMON
3435 if (data.gpu_temp_disable == 0)
3436 {
3437 time (&last_temp_check_time);
3438
3439 hwmon_check = 1;
3440 }
3441 #endif
3442
3443 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3444 {
3445 #ifdef HAVE_HWMON
3446 if (hwmon_check == 0)
3447 #endif
3448 return (p);
3449 }
3450
3451 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3452 {
3453 hc_sleep (sleep_time);
3454
3455 if (data.devices_status != STATUS_RUNNING) continue;
3456
3457 #ifdef HAVE_HWMON
3458 if (hwmon_check == 1)
3459 {
3460 hc_thread_mutex_lock (mux_adl);
3461
3462 time_t temp_check_time;
3463
3464 time (&temp_check_time);
3465
3466 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3467
3468 if (Ta == 0) Ta = 1;
3469
3470 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3471 {
3472 hc_device_param_t *device_param = &data.devices_param[device_id];
3473
3474 if (device_param->skipped) continue;
3475
3476 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3477
3478 const int temperature = hm_get_temperature_with_device_id (device_id);
3479
3480 if (temperature > (int) data.gpu_temp_abort)
3481 {
3482 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3483
3484 if (data.devices_status != STATUS_QUIT) myabort ();
3485
3486 break;
3487 }
3488
3489 #ifdef HAVE_ADL
3490 const int gpu_temp_retain = data.gpu_temp_retain;
3491
3492 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3493 {
3494 if (data.hm_device[device_id].fan_supported == 1)
3495 {
3496 int temp_cur = temperature;
3497
3498 int temp_diff_new = gpu_temp_retain - temp_cur;
3499
3500 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3501
3502 // calculate Ta value (time difference in seconds between the last check and this check)
3503
3504 last_temp_check_time = temp_check_time;
3505
3506 float Kp = 1.8;
3507 float Ki = 0.005;
3508 float Kd = 6;
3509
3510 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3511
3512 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);
3513
3514 if (abs (fan_diff_required) >= temp_threshold)
3515 {
3516 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3517
3518 int fan_speed_level = fan_speed_cur;
3519
3520 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3521
3522 int fan_speed_new = fan_speed_level - fan_diff_required;
3523
3524 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3525 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3526
3527 if (fan_speed_new != fan_speed_cur)
3528 {
3529 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3530 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3531
3532 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3533 {
3534 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3535
3536 fan_speed_chgd[device_id] = 1;
3537 }
3538
3539 temp_diff_old[device_id] = temp_diff_new;
3540 }
3541 }
3542 }
3543 }
3544 #endif // HAVE_ADL
3545 }
3546
3547 hc_thread_mutex_unlock (mux_adl);
3548 }
3549 #endif // HAVE_HWMON
3550
3551 if (restore_check == 1)
3552 {
3553 restore_left--;
3554
3555 if (restore_left == 0)
3556 {
3557 if (data.restore_disable == 0) cycle_restore ();
3558
3559 restore_left = data.restore_timer;
3560 }
3561 }
3562
3563 if ((runtime_check == 1) && (data.runtime_start > 0))
3564 {
3565 time_t runtime_cur;
3566
3567 time (&runtime_cur);
3568
3569 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3570
3571 if (runtime_left <= 0)
3572 {
3573 if (data.benchmark == 0)
3574 {
3575 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3576 }
3577
3578 if (data.devices_status != STATUS_QUIT) myabort ();
3579 }
3580 }
3581
3582 if (remove_check == 1)
3583 {
3584 remove_left--;
3585
3586 if (remove_left == 0)
3587 {
3588 if (data.digests_saved != data.digests_done)
3589 {
3590 data.digests_saved = data.digests_done;
3591
3592 save_hash ();
3593 }
3594
3595 remove_left = data.remove_timer;
3596 }
3597 }
3598
3599 if (status_check == 1)
3600 {
3601 status_left--;
3602
3603 if (status_left == 0)
3604 {
3605 hc_thread_mutex_lock (mux_display);
3606
3607 if (data.quiet == 0) clear_prompt ();
3608
3609 if (data.quiet == 0) log_info ("");
3610
3611 status_display ();
3612
3613 if (data.quiet == 0) log_info ("");
3614
3615 hc_thread_mutex_unlock (mux_display);
3616
3617 status_left = data.status_timer;
3618 }
3619 }
3620 }
3621
3622 #ifdef HAVE_HWMON
3623 myfree (fan_speed_chgd);
3624
3625 myfree (temp_diff_old);
3626 myfree (temp_diff_sum);
3627 #endif
3628
3629 p = NULL;
3630
3631 return (p);
3632 }
3633
3634 static void *thread_outfile_remove (void *p)
3635 {
3636 // some hash-dependent constants
3637 char *outfile_dir = data.outfile_check_directory;
3638 uint dgst_size = data.dgst_size;
3639 uint isSalted = data.isSalted;
3640 uint esalt_size = data.esalt_size;
3641 uint hash_mode = data.hash_mode;
3642
3643 uint outfile_check_timer = data.outfile_check_timer;
3644
3645 char separator = data.separator;
3646
3647 // some hash-dependent functions
3648 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3649 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3650
3651 // buffers
3652 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3653
3654 hash_buf.digest = mymalloc (dgst_size);
3655
3656 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3657
3658 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3659
3660 uint digest_buf[64];
3661
3662 outfile_data_t *out_info = NULL;
3663
3664 char **out_files = NULL;
3665
3666 time_t folder_mtime = 0;
3667
3668 int out_cnt = 0;
3669
3670 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3671
3672 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3673 {
3674 hc_sleep (1);
3675
3676 if (data.devices_status != STATUS_RUNNING) continue;
3677
3678 check_left--;
3679
3680 if (check_left == 0)
3681 {
3682 struct stat outfile_check_stat;
3683
3684 if (stat (outfile_dir, &outfile_check_stat) == 0)
3685 {
3686 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3687
3688 if (is_dir == 1)
3689 {
3690 if (outfile_check_stat.st_mtime > folder_mtime)
3691 {
3692 char **out_files_new = scan_directory (outfile_dir);
3693
3694 int out_cnt_new = count_dictionaries (out_files_new);
3695
3696 outfile_data_t *out_info_new = NULL;
3697
3698 if (out_cnt_new > 0)
3699 {
3700 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3701
3702 for (int i = 0; i < out_cnt_new; i++)
3703 {
3704 out_info_new[i].file_name = out_files_new[i];
3705
3706 // check if there are files that we have seen/checked before (and not changed)
3707
3708 for (int j = 0; j < out_cnt; j++)
3709 {
3710 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3711 {
3712 struct stat outfile_stat;
3713
3714 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3715 {
3716 if (outfile_stat.st_ctime == out_info[j].ctime)
3717 {
3718 out_info_new[i].ctime = out_info[j].ctime;
3719 out_info_new[i].seek = out_info[j].seek;
3720 }
3721 }
3722 }
3723 }
3724 }
3725 }
3726
3727 local_free (out_info);
3728 local_free (out_files);
3729
3730 out_files = out_files_new;
3731 out_cnt = out_cnt_new;
3732 out_info = out_info_new;
3733
3734 folder_mtime = outfile_check_stat.st_mtime;
3735 }
3736
3737 for (int j = 0; j < out_cnt; j++)
3738 {
3739 FILE *fp = fopen (out_info[j].file_name, "rb");
3740
3741 if (fp != NULL)
3742 {
3743 //hc_thread_mutex_lock (mux_display);
3744
3745 #ifdef _POSIX
3746 struct stat outfile_stat;
3747
3748 fstat (fileno (fp), &outfile_stat);
3749 #endif
3750
3751 #ifdef _WIN
3752 struct stat64 outfile_stat;
3753
3754 _fstat64 (fileno (fp), &outfile_stat);
3755 #endif
3756
3757 if (outfile_stat.st_ctime > out_info[j].ctime)
3758 {
3759 out_info[j].ctime = outfile_stat.st_ctime;
3760 out_info[j].seek = 0;
3761 }
3762
3763 fseek (fp, out_info[j].seek, SEEK_SET);
3764
3765 while (!feof (fp))
3766 {
3767 char line_buf[BUFSIZ];
3768
3769 memset (line_buf, 0, BUFSIZ);
3770
3771 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3772
3773 if (ptr == NULL) break;
3774
3775 int line_len = strlen (line_buf);
3776
3777 if (line_len <= 0) continue;
3778
3779 int iter = MAX_CUT_TRIES;
3780
3781 for (uint i = line_len - 1; i && iter; i--, line_len--)
3782 {
3783 if (line_buf[i] != separator) continue;
3784
3785 int parser_status = PARSER_OK;
3786
3787 if ((hash_mode != 2500) && (hash_mode != 6800))
3788 {
3789 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3790 }
3791
3792 uint found = 0;
3793
3794 if (parser_status == PARSER_OK)
3795 {
3796 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3797 {
3798 if (data.salts_shown[salt_pos] == 1) continue;
3799
3800 salt_t *salt_buf = &data.salts_buf[salt_pos];
3801
3802 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3803 {
3804 uint idx = salt_buf->digests_offset + digest_pos;
3805
3806 if (data.digests_shown[idx] == 1) continue;
3807
3808 uint cracked = 0;
3809
3810 if (hash_mode == 6800)
3811 {
3812 if (i == salt_buf->salt_len)
3813 {
3814 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3815 }
3816 }
3817 else if (hash_mode == 2500)
3818 {
3819 // BSSID : MAC1 : MAC2 (:plain)
3820 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3821 {
3822 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3823
3824 if (!cracked) continue;
3825
3826 // now compare MAC1 and MAC2 too, since we have this additional info
3827 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3828 char *mac2_pos = mac1_pos + 12 + 1;
3829
3830 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3831 wpa_t *wpa = &wpas[salt_pos];
3832
3833 uint pke[25];
3834
3835 char *pke_ptr = (char *) pke;
3836
3837 for (uint i = 0; i < 25; i++)
3838 {
3839 pke[i] = byte_swap_32 (wpa->pke[i]);
3840 }
3841
3842 u8 mac1[6];
3843 u8 mac2[6];
3844
3845 memcpy (mac1, pke_ptr + 23, 6);
3846 memcpy (mac2, pke_ptr + 29, 6);
3847
3848 // compare hex string(s) vs binary MAC address(es)
3849
3850 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3851 {
3852 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3853 {
3854 cracked = 0;
3855 break;
3856 }
3857 }
3858
3859 // early skip ;)
3860 if (!cracked) continue;
3861
3862 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3863 {
3864 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3865 {
3866 cracked = 0;
3867 break;
3868 }
3869 }
3870 }
3871 }
3872 else
3873 {
3874 char *digests_buf_ptr = (char *) data.digests_buf;
3875
3876 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3877
3878 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3879 }
3880
3881 if (cracked == 1)
3882 {
3883 found = 1;
3884
3885 data.digests_shown[idx] = 1;
3886
3887 data.digests_done++;
3888
3889 salt_buf->digests_done++;
3890
3891 if (salt_buf->digests_done == salt_buf->digests_cnt)
3892 {
3893 data.salts_shown[salt_pos] = 1;
3894
3895 data.salts_done++;
3896
3897 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3898 }
3899 }
3900 }
3901
3902 if (data.devices_status == STATUS_CRACKED) break;
3903 }
3904 }
3905
3906 if (found) break;
3907
3908 if (data.devices_status == STATUS_CRACKED) break;
3909
3910 iter--;
3911 }
3912
3913 if (data.devices_status == STATUS_CRACKED) break;
3914 }
3915
3916 out_info[j].seek = ftell (fp);
3917
3918 //hc_thread_mutex_unlock (mux_display);
3919
3920 fclose (fp);
3921 }
3922 }
3923 }
3924 }
3925
3926 check_left = outfile_check_timer;
3927 }
3928 }
3929
3930 if (esalt_size) local_free (hash_buf.esalt);
3931
3932 if (isSalted) local_free (hash_buf.salt);
3933
3934 local_free (hash_buf.digest);
3935
3936 local_free (out_info);
3937
3938 local_free (out_files);
3939
3940 p = NULL;
3941
3942 return (p);
3943 }
3944
3945 static uint get_work (hc_device_param_t *device_param, const u64 max)
3946 {
3947 hc_thread_mutex_lock (mux_dispatcher);
3948
3949 const u64 words_cur = data.words_cur;
3950 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3951
3952 device_param->words_off = words_cur;
3953
3954 const u64 words_left = words_base - words_cur;
3955
3956 if (data.kernel_blocks_all > words_left)
3957 {
3958 if (data.kernel_blocks_div == 0)
3959 {
3960 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3961 }
3962 }
3963
3964 if (data.kernel_blocks_div)
3965 {
3966 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3967 {
3968 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3969 const u32 kernel_power_new = kernel_blocks_new;
3970
3971 if (kernel_blocks_new < device_param->kernel_blocks)
3972 {
3973 device_param->kernel_blocks = kernel_blocks_new;
3974 device_param->kernel_power = kernel_power_new;
3975 }
3976 }
3977 }
3978
3979 const uint kernel_blocks = device_param->kernel_blocks;
3980
3981 uint work = MIN (words_left, kernel_blocks);
3982
3983 work = MIN (work, max);
3984
3985 data.words_cur += work;
3986
3987 hc_thread_mutex_unlock (mux_dispatcher);
3988
3989 return work;
3990 }
3991
3992 static void *thread_calc_stdin (void *p)
3993 {
3994 hc_device_param_t *device_param = (hc_device_param_t *) p;
3995
3996 if (device_param->skipped) return NULL;
3997
3998 const uint attack_kern = data.attack_kern;
3999
4000 const uint kernel_blocks = device_param->kernel_blocks;
4001
4002 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4003 {
4004 hc_thread_mutex_lock (mux_dispatcher);
4005
4006 if (feof (stdin) != 0)
4007 {
4008 hc_thread_mutex_unlock (mux_dispatcher);
4009
4010 break;
4011 }
4012
4013 uint words_cur = 0;
4014
4015 while (words_cur < kernel_blocks)
4016 {
4017 char buf[BUFSIZ];
4018
4019 char *line_buf = fgets (buf, sizeof (buf), stdin);
4020
4021 if (line_buf == NULL) break;
4022
4023 uint line_len = in_superchop (line_buf);
4024
4025 line_len = convert_from_hex (line_buf, line_len);
4026
4027 // post-process rule engine
4028
4029 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4030 {
4031 char rule_buf_out[BLOCK_SIZE] = { 0 };
4032
4033 int rule_len_out = -1;
4034
4035 if (line_len < BLOCK_SIZE)
4036 {
4037 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4038 }
4039
4040 if (rule_len_out < 0) continue;
4041
4042 line_buf = rule_buf_out;
4043 line_len = rule_len_out;
4044 }
4045
4046 if (line_len > PW_MAX)
4047 {
4048 continue;
4049 }
4050
4051 if (attack_kern == ATTACK_KERN_STRAIGHT)
4052 {
4053 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4054 {
4055 hc_thread_mutex_lock (mux_counter);
4056
4057 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4058 {
4059 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4060 }
4061
4062 hc_thread_mutex_unlock (mux_counter);
4063
4064 continue;
4065 }
4066 }
4067 else if (attack_kern == ATTACK_KERN_COMBI)
4068 {
4069 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4070 // since we still need to combine the plains
4071
4072 if (line_len > data.pw_max)
4073 {
4074 hc_thread_mutex_lock (mux_counter);
4075
4076 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4077 {
4078 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4079 }
4080
4081 hc_thread_mutex_unlock (mux_counter);
4082
4083 continue;
4084 }
4085 }
4086
4087 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4088
4089 words_cur++;
4090
4091 if (data.devices_status == STATUS_CRACKED) break;
4092 if (data.devices_status == STATUS_ABORTED) break;
4093 if (data.devices_status == STATUS_QUIT) break;
4094 if (data.devices_status == STATUS_BYPASS) break;
4095 }
4096
4097 hc_thread_mutex_unlock (mux_dispatcher);
4098
4099 if (data.devices_status == STATUS_CRACKED) break;
4100 if (data.devices_status == STATUS_ABORTED) break;
4101 if (data.devices_status == STATUS_QUIT) break;
4102 if (data.devices_status == STATUS_BYPASS) break;
4103
4104 // we need 2 flushing because we have two independant caches and it can occur
4105 // that one buffer is already at threshold plus for that length also exists
4106 // more data in the 2nd buffer so it would overflow
4107
4108 // flush session 1
4109
4110 {
4111 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4112 {
4113 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4114
4115 const uint pw_cache_cnt = pw_cache->cnt;
4116
4117 if (pw_cache_cnt == 0) continue;
4118
4119 pw_cache->cnt = 0;
4120
4121 uint pws_cnt = device_param->pws_cnt;
4122
4123 pw_t *pw = device_param->pws_buf + pws_cnt;
4124
4125 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4126
4127 pw->pw_len = pw_len;
4128
4129 uint pw_cnt = device_param->pw_cnt;
4130
4131 pw_cnt += pw_cache_cnt;
4132
4133 device_param->pw_cnt = pw_cnt;
4134
4135 pws_cnt++;
4136
4137 device_param->pws_cnt = pws_cnt;
4138
4139 if (pws_cnt == device_param->kernel_power_user) break;
4140 }
4141
4142 const uint pw_cnt = device_param->pw_cnt;
4143 const uint pws_cnt = device_param->pws_cnt;
4144
4145 if (pws_cnt)
4146 {
4147 run_copy (device_param, pws_cnt);
4148
4149 run_cracker (device_param, pw_cnt, pws_cnt);
4150
4151 device_param->pw_cnt = 0;
4152 device_param->pws_cnt = 0;
4153 }
4154 }
4155
4156 // flush session 2
4157
4158 {
4159 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4160 {
4161 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4162
4163 const uint pw_cache_cnt = pw_cache->cnt;
4164
4165 if (pw_cache_cnt == 0) continue;
4166
4167 pw_cache->cnt = 0;
4168
4169 uint pws_cnt = device_param->pws_cnt;
4170
4171 pw_t *pw = device_param->pws_buf + pws_cnt;
4172
4173 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4174
4175 pw->pw_len = pw_len;
4176
4177 uint pw_cnt = device_param->pw_cnt;
4178
4179 pw_cnt += pw_cache_cnt;
4180
4181 device_param->pw_cnt = pw_cnt;
4182
4183 pws_cnt++;
4184
4185 device_param->pws_cnt = pws_cnt;
4186 }
4187
4188 const uint pw_cnt = device_param->pw_cnt;
4189 const uint pws_cnt = device_param->pws_cnt;
4190
4191 if (pws_cnt)
4192 {
4193 run_copy (device_param, pws_cnt);
4194
4195 run_cracker (device_param, pw_cnt, pws_cnt);
4196
4197 device_param->pw_cnt = 0;
4198 device_param->pws_cnt = 0;
4199 }
4200 }
4201 }
4202
4203 return NULL;
4204 }
4205
4206 static void *thread_calc (void *p)
4207 {
4208 hc_device_param_t *device_param = (hc_device_param_t *) p;
4209
4210 if (device_param->skipped) return NULL;
4211
4212 const uint attack_mode = data.attack_mode;
4213 const uint attack_kern = data.attack_kern;
4214
4215 if (attack_mode == ATTACK_MODE_BF)
4216 {
4217 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4218 {
4219 const uint work = get_work (device_param, -1);
4220
4221 if (work == 0) break;
4222
4223 const u64 words_off = device_param->words_off;
4224 const u64 words_fin = words_off + work;
4225
4226 const uint pw_cnt = work;
4227 const uint pws_cnt = work;
4228
4229 device_param->pw_cnt = pw_cnt;
4230 device_param->pws_cnt = pws_cnt;
4231
4232 if (pws_cnt)
4233 {
4234 run_copy (device_param, pws_cnt);
4235
4236 run_cracker (device_param, pw_cnt, pws_cnt);
4237
4238 device_param->pw_cnt = 0;
4239 device_param->pws_cnt = 0;
4240 }
4241
4242 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4243
4244 if (data.devices_status == STATUS_CRACKED) break;
4245 if (data.devices_status == STATUS_ABORTED) break;
4246 if (data.devices_status == STATUS_QUIT) break;
4247 if (data.devices_status == STATUS_BYPASS) break;
4248
4249 device_param->words_done = words_fin;
4250 }
4251 }
4252 else
4253 {
4254 const uint segment_size = data.segment_size;
4255
4256 char *dictfile = data.dictfile;
4257
4258 if (attack_mode == ATTACK_MODE_COMBI)
4259 {
4260 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4261 {
4262 dictfile = data.dictfile2;
4263 }
4264 }
4265
4266 FILE *fd = fopen (dictfile, "rb");
4267
4268 if (fd == NULL)
4269 {
4270 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4271
4272 return NULL;
4273 }
4274
4275 if (attack_mode == ATTACK_MODE_COMBI)
4276 {
4277 const uint combs_mode = data.combs_mode;
4278
4279 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4280 {
4281 const char *dictfilec = data.dictfile2;
4282
4283 FILE *combs_fp = fopen (dictfilec, "rb");
4284
4285 if (combs_fp == NULL)
4286 {
4287 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4288
4289 fclose (fd);
4290
4291 return NULL;
4292 }
4293
4294 device_param->combs_fp = combs_fp;
4295 }
4296 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4297 {
4298 const char *dictfilec = data.dictfile;
4299
4300 FILE *combs_fp = fopen (dictfilec, "rb");
4301
4302 if (combs_fp == NULL)
4303 {
4304 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4305
4306 fclose (fd);
4307
4308 return NULL;
4309 }
4310
4311 device_param->combs_fp = combs_fp;
4312 }
4313 }
4314
4315 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4316
4317 wl_data->buf = (char *) mymalloc (segment_size);
4318 wl_data->avail = segment_size;
4319 wl_data->incr = segment_size;
4320 wl_data->cnt = 0;
4321 wl_data->pos = 0;
4322
4323 u64 words_cur = 0;
4324
4325 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4326 {
4327 u64 words_off = 0;
4328 u64 words_fin = 0;
4329
4330 u64 max = -1;
4331
4332 while (max)
4333 {
4334 const uint work = get_work (device_param, max);
4335
4336 if (work == 0) break;
4337
4338 words_off = device_param->words_off;
4339 words_fin = words_off + work;
4340
4341 char *line_buf;
4342 uint line_len;
4343
4344 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4345
4346 max = 0;
4347
4348 for ( ; words_cur < words_fin; words_cur++)
4349 {
4350 get_next_word (wl_data, fd, &line_buf, &line_len);
4351
4352 line_len = convert_from_hex (line_buf, line_len);
4353
4354 // post-process rule engine
4355
4356 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4357 {
4358 char rule_buf_out[BLOCK_SIZE] = { 0 };
4359
4360 int rule_len_out = -1;
4361
4362 if (line_len < BLOCK_SIZE)
4363 {
4364 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4365 }
4366
4367 if (rule_len_out < 0) continue;
4368
4369 line_buf = rule_buf_out;
4370 line_len = rule_len_out;
4371 }
4372
4373 if (attack_kern == ATTACK_KERN_STRAIGHT)
4374 {
4375 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4376 {
4377 max++;
4378
4379 hc_thread_mutex_lock (mux_counter);
4380
4381 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4382 {
4383 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4384 }
4385
4386 hc_thread_mutex_unlock (mux_counter);
4387
4388 continue;
4389 }
4390 }
4391 else if (attack_kern == ATTACK_KERN_COMBI)
4392 {
4393 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4394 // since we still need to combine the plains
4395
4396 if (line_len > data.pw_max)
4397 {
4398 max++;
4399
4400 hc_thread_mutex_lock (mux_counter);
4401
4402 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4403 {
4404 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4405 }
4406
4407 hc_thread_mutex_unlock (mux_counter);
4408
4409 continue;
4410 }
4411 }
4412
4413 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4414
4415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4416
4417 if (data.devices_status == STATUS_CRACKED) break;
4418 if (data.devices_status == STATUS_ABORTED) break;
4419 if (data.devices_status == STATUS_QUIT) break;
4420 if (data.devices_status == STATUS_BYPASS) break;
4421 }
4422
4423 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4424
4425 if (data.devices_status == STATUS_CRACKED) break;
4426 if (data.devices_status == STATUS_ABORTED) break;
4427 if (data.devices_status == STATUS_QUIT) break;
4428 if (data.devices_status == STATUS_BYPASS) break;
4429 }
4430
4431 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4432
4433 if (data.devices_status == STATUS_CRACKED) break;
4434 if (data.devices_status == STATUS_ABORTED) break;
4435 if (data.devices_status == STATUS_QUIT) break;
4436 if (data.devices_status == STATUS_BYPASS) break;
4437
4438 // we need 2 flushing because we have two independant caches and it can occur
4439 // that one buffer is already at threshold plus for that length also exists
4440 // more data in the 2nd buffer so it would overflow
4441
4442 //
4443 // flush session 1
4444 //
4445
4446 {
4447 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4448 {
4449 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4450
4451 const uint pw_cache_cnt = pw_cache->cnt;
4452
4453 if (pw_cache_cnt == 0) continue;
4454
4455 pw_cache->cnt = 0;
4456
4457 uint pws_cnt = device_param->pws_cnt;
4458
4459 pw_t *pw = device_param->pws_buf + pws_cnt;
4460
4461 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4462
4463 pw->pw_len = pw_len;
4464
4465 uint pw_cnt = device_param->pw_cnt;
4466
4467 pw_cnt += pw_cache_cnt;
4468
4469 device_param->pw_cnt = pw_cnt;
4470
4471 pws_cnt++;
4472
4473 device_param->pws_cnt = pws_cnt;
4474
4475 if (pws_cnt == device_param->kernel_power_user) break;
4476 }
4477
4478 const uint pw_cnt = device_param->pw_cnt;
4479 const uint pws_cnt = device_param->pws_cnt;
4480
4481 if (pws_cnt)
4482 {
4483 run_copy (device_param, pws_cnt);
4484
4485 run_cracker (device_param, pw_cnt, pws_cnt);
4486
4487 device_param->pw_cnt = 0;
4488 device_param->pws_cnt = 0;
4489 }
4490
4491 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4492
4493 if (data.devices_status == STATUS_CRACKED) break;
4494 if (data.devices_status == STATUS_ABORTED) break;
4495 if (data.devices_status == STATUS_QUIT) break;
4496 if (data.devices_status == STATUS_BYPASS) break;
4497 }
4498
4499 //
4500 // flush session 2
4501 //
4502
4503 {
4504 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4505 {
4506 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4507
4508 const uint pw_cache_cnt = pw_cache->cnt;
4509
4510 if (pw_cache_cnt == 0) continue;
4511
4512 pw_cache->cnt = 0;
4513
4514 uint pws_cnt = device_param->pws_cnt;
4515
4516 pw_t *pw = device_param->pws_buf + pws_cnt;
4517
4518 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4519
4520 pw->pw_len = pw_len;
4521
4522 uint pw_cnt = device_param->pw_cnt;
4523
4524 pw_cnt += pw_cache_cnt;
4525
4526 device_param->pw_cnt = pw_cnt;
4527
4528 pws_cnt++;
4529
4530 device_param->pws_cnt = pws_cnt;
4531 }
4532
4533 const uint pw_cnt = device_param->pw_cnt;
4534 const uint pws_cnt = device_param->pws_cnt;
4535
4536 if (pws_cnt)
4537 {
4538 run_copy (device_param, pws_cnt);
4539
4540 run_cracker (device_param, pw_cnt, pws_cnt);
4541
4542 device_param->pw_cnt = 0;
4543 device_param->pws_cnt = 0;
4544 }
4545
4546 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4547
4548 if (data.devices_status == STATUS_CRACKED) break;
4549 if (data.devices_status == STATUS_ABORTED) break;
4550 if (data.devices_status == STATUS_QUIT) break;
4551 if (data.devices_status == STATUS_BYPASS) break;
4552 }
4553
4554 if (words_fin == 0) break;
4555
4556 device_param->words_done = words_fin;
4557 }
4558
4559 if (attack_mode == ATTACK_MODE_COMBI)
4560 {
4561 fclose (device_param->combs_fp);
4562 }
4563
4564 free (wl_data->buf);
4565 free (wl_data);
4566
4567 fclose (fd);
4568 }
4569
4570 return NULL;
4571 }
4572
4573 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4574 {
4575 salt_t *salt_buf = &data.salts_buf[salt_pos];
4576
4577 device_param->kernel_params_buf32[24] = salt_pos;
4578 device_param->kernel_params_buf32[27] = 1;
4579 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4580 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4581 device_param->kernel_params_buf32[30] = 0;
4582 device_param->kernel_params_buf32[31] = 1;
4583
4584 char *dictfile_old = data.dictfile;
4585
4586 const char *weak_hash_check = "weak-hash-check";
4587
4588 data.dictfile = (char *) weak_hash_check;
4589
4590 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4591
4592 data.kernel_rules_buf[0].cmds[0] = 0;
4593
4594 /**
4595 * run the kernel
4596 */
4597
4598 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4599 {
4600 run_kernel (KERN_RUN_1, device_param, 1);
4601 }
4602 else
4603 {
4604 run_kernel (KERN_RUN_1, device_param, 1);
4605
4606 const uint iter = salt_buf->salt_iter;
4607
4608 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4609 {
4610 uint loop_left = iter - loop_pos;
4611
4612 loop_left = MIN (loop_left, kernel_loops);
4613
4614 device_param->kernel_params_buf32[25] = loop_pos;
4615 device_param->kernel_params_buf32[26] = loop_left;
4616
4617 run_kernel (KERN_RUN_2, device_param, 1);
4618 }
4619
4620 run_kernel (KERN_RUN_3, device_param, 1);
4621 }
4622
4623 /**
4624 * result
4625 */
4626
4627 check_cracked (device_param, salt_pos);
4628
4629 /**
4630 * cleanup
4631 */
4632
4633 device_param->kernel_params_buf32[24] = 0;
4634 device_param->kernel_params_buf32[25] = 0;
4635 device_param->kernel_params_buf32[26] = 0;
4636 device_param->kernel_params_buf32[27] = 0;
4637 device_param->kernel_params_buf32[28] = 0;
4638 device_param->kernel_params_buf32[29] = 0;
4639 device_param->kernel_params_buf32[30] = 0;
4640 device_param->kernel_params_buf32[31] = 0;
4641
4642 data.dictfile = dictfile_old;
4643
4644 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4645 }
4646
4647 // hlfmt hashcat
4648
4649 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4650 {
4651 if (data.username == 0)
4652 {
4653 *hashbuf_pos = line_buf;
4654 *hashbuf_len = line_len;
4655 }
4656 else
4657 {
4658 char *pos = line_buf;
4659 int len = line_len;
4660
4661 for (int i = 0; i < line_len; i++, pos++, len--)
4662 {
4663 if (line_buf[i] == data.separator)
4664 {
4665 pos++;
4666
4667 len--;
4668
4669 break;
4670 }
4671 }
4672
4673 *hashbuf_pos = pos;
4674 *hashbuf_len = len;
4675 }
4676 }
4677
4678 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4679 {
4680 char *pos = NULL;
4681 int len = 0;
4682
4683 int sep_cnt = 0;
4684
4685 for (int i = 0; i < line_len; i++)
4686 {
4687 if (line_buf[i] == data.separator)
4688 {
4689 sep_cnt++;
4690
4691 continue;
4692 }
4693
4694 if (sep_cnt == 0)
4695 {
4696 if (pos == NULL) pos = line_buf + i;
4697
4698 len++;
4699 }
4700 }
4701
4702 *userbuf_pos = pos;
4703 *userbuf_len = len;
4704 }
4705
4706 // hlfmt pwdump
4707
4708 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4709 {
4710 int sep_cnt = 0;
4711
4712 int sep2_len = 0;
4713 int sep3_len = 0;
4714
4715 for (int i = 0; i < line_len; i++)
4716 {
4717 if (line_buf[i] == ':')
4718 {
4719 sep_cnt++;
4720
4721 continue;
4722 }
4723
4724 if (sep_cnt == 2) sep2_len++;
4725 if (sep_cnt == 3) sep3_len++;
4726 }
4727
4728 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4729
4730 return 0;
4731 }
4732
4733 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4734 {
4735 char *pos = NULL;
4736 int len = 0;
4737
4738 int sep_cnt = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (data.hash_mode == 1000)
4750 {
4751 if (sep_cnt == 3)
4752 {
4753 if (pos == NULL) pos = line_buf + i;
4754
4755 len++;
4756 }
4757 }
4758 else if (data.hash_mode == 3000)
4759 {
4760 if (sep_cnt == 2)
4761 {
4762 if (pos == NULL) pos = line_buf + i;
4763
4764 len++;
4765 }
4766 }
4767 }
4768
4769 *hashbuf_pos = pos;
4770 *hashbuf_len = len;
4771 }
4772
4773 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4774 {
4775 char *pos = NULL;
4776 int len = 0;
4777
4778 int sep_cnt = 0;
4779
4780 for (int i = 0; i < line_len; i++)
4781 {
4782 if (line_buf[i] == ':')
4783 {
4784 sep_cnt++;
4785
4786 continue;
4787 }
4788
4789 if (sep_cnt == 0)
4790 {
4791 if (pos == NULL) pos = line_buf + i;
4792
4793 len++;
4794 }
4795 }
4796
4797 *userbuf_pos = pos;
4798 *userbuf_len = len;
4799 }
4800
4801 // hlfmt passwd
4802
4803 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4804 {
4805 int sep_cnt = 0;
4806
4807 char sep5_first = 0;
4808 char sep6_first = 0;
4809
4810 for (int i = 0; i < line_len; i++)
4811 {
4812 if (line_buf[i] == ':')
4813 {
4814 sep_cnt++;
4815
4816 continue;
4817 }
4818
4819 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4820 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4821 }
4822
4823 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4824
4825 return 0;
4826 }
4827
4828 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4829 {
4830 char *pos = NULL;
4831 int len = 0;
4832
4833 int sep_cnt = 0;
4834
4835 for (int i = 0; i < line_len; i++)
4836 {
4837 if (line_buf[i] == ':')
4838 {
4839 sep_cnt++;
4840
4841 continue;
4842 }
4843
4844 if (sep_cnt == 1)
4845 {
4846 if (pos == NULL) pos = line_buf + i;
4847
4848 len++;
4849 }
4850 }
4851
4852 *hashbuf_pos = pos;
4853 *hashbuf_len = len;
4854 }
4855
4856 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4857 {
4858 char *pos = NULL;
4859 int len = 0;
4860
4861 int sep_cnt = 0;
4862
4863 for (int i = 0; i < line_len; i++)
4864 {
4865 if (line_buf[i] == ':')
4866 {
4867 sep_cnt++;
4868
4869 continue;
4870 }
4871
4872 if (sep_cnt == 0)
4873 {
4874 if (pos == NULL) pos = line_buf + i;
4875
4876 len++;
4877 }
4878 }
4879
4880 *userbuf_pos = pos;
4881 *userbuf_len = len;
4882 }
4883
4884 // hlfmt shadow
4885
4886 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4887 {
4888 int sep_cnt = 0;
4889
4890 for (int i = 0; i < line_len; i++)
4891 {
4892 if (line_buf[i] == ':') sep_cnt++;
4893 }
4894
4895 if (sep_cnt == 8) return 1;
4896
4897 return 0;
4898 }
4899
4900 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4901 {
4902 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4903 }
4904
4905 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4906 {
4907 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4908 }
4909
4910 // hlfmt main
4911
4912 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4913 {
4914 switch (hashfile_format)
4915 {
4916 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4917 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4918 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4919 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4920 }
4921 }
4922
4923 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4924 {
4925 switch (hashfile_format)
4926 {
4927 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4928 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4929 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4930 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4931 }
4932 }
4933
4934 static uint hlfmt_detect (FILE *fp, uint max_check)
4935 {
4936 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4937
4938 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4939 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4940
4941 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4942
4943 uint num_check = 0;
4944
4945 while (!feof (fp))
4946 {
4947 char line_buf[BUFSIZ];
4948
4949 int line_len = fgetl (fp, line_buf);
4950
4951 if (line_len == 0) continue;
4952
4953 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4954 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4955 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4956
4957 if (num_check == max_check) break;
4958
4959 num_check++;
4960 }
4961
4962 uint hashlist_format = HLFMT_HASHCAT;
4963
4964 for (int i = 1; i < HLFMTS_CNT; i++)
4965 {
4966 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4967
4968 hashlist_format = i;
4969 }
4970
4971 free (formats_cnt);
4972
4973 return hashlist_format;
4974 }
4975
4976 /**
4977 * some further helper function
4978 */
4979
4980 // wrapper around mymalloc for ADL
4981
4982 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
4983 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4984 {
4985 return mymalloc (iSize);
4986 }
4987 #endif
4988
4989 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)
4990 {
4991 u64 collisions = 0;
4992
4993 const uint dgst_pos0 = data.dgst_pos0;
4994 const uint dgst_pos1 = data.dgst_pos1;
4995 const uint dgst_pos2 = data.dgst_pos2;
4996 const uint dgst_pos3 = data.dgst_pos3;
4997
4998 memset (bitmap_a, 0, bitmap_size);
4999 memset (bitmap_b, 0, bitmap_size);
5000 memset (bitmap_c, 0, bitmap_size);
5001 memset (bitmap_d, 0, bitmap_size);
5002
5003 for (uint i = 0; i < digests_cnt; i++)
5004 {
5005 uint *digest_ptr = (uint *) digests_buf_ptr;
5006
5007 digests_buf_ptr += dgst_size;
5008
5009 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5010 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5011 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5012 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5013
5014 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5015 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5016 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5017 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5018
5019 if (bitmap_a[idx0] & val0) collisions++;
5020 if (bitmap_b[idx1] & val1) collisions++;
5021 if (bitmap_c[idx2] & val2) collisions++;
5022 if (bitmap_d[idx3] & val3) collisions++;
5023
5024 bitmap_a[idx0] |= val0;
5025 bitmap_b[idx1] |= val1;
5026 bitmap_c[idx2] |= val2;
5027 bitmap_d[idx3] |= val3;
5028
5029 if (collisions >= collisions_max) return 0x7fffffff;
5030 }
5031
5032 return collisions;
5033 }
5034
5035 /**
5036 * main
5037 */
5038
5039 int main (int argc, char **argv)
5040 {
5041 /**
5042 * To help users a bit
5043 */
5044
5045 char *compute = getenv ("COMPUTE");
5046
5047 if (compute)
5048 {
5049 char display[100];
5050
5051 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5052
5053 putenv (display);
5054 }
5055 else
5056 {
5057 if (getenv ("DISPLAY") == NULL)
5058 putenv ((char *) "DISPLAY=:0");
5059 }
5060
5061 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5062 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5063
5064 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5065 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5066
5067 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5068 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5069
5070 /**
5071 * Real init
5072 */
5073
5074 memset (&data, 0, sizeof (hc_global_data_t));
5075
5076 time_t proc_start;
5077
5078 time (&proc_start);
5079
5080 data.proc_start = proc_start;
5081
5082 int myargc = argc;
5083 char **myargv = argv;
5084
5085 hc_thread_mutex_init (mux_dispatcher);
5086 hc_thread_mutex_init (mux_counter);
5087 hc_thread_mutex_init (mux_display);
5088 hc_thread_mutex_init (mux_adl);
5089
5090 /**
5091 * commandline parameters
5092 */
5093
5094 uint usage = USAGE;
5095 uint version = VERSION;
5096 uint quiet = QUIET;
5097 uint benchmark = BENCHMARK;
5098 uint benchmark_mode = BENCHMARK_MODE;
5099 uint show = SHOW;
5100 uint left = LEFT;
5101 uint username = USERNAME;
5102 uint remove = REMOVE;
5103 uint remove_timer = REMOVE_TIMER;
5104 u64 skip = SKIP;
5105 u64 limit = LIMIT;
5106 uint keyspace = KEYSPACE;
5107 uint potfile_disable = POTFILE_DISABLE;
5108 uint debug_mode = DEBUG_MODE;
5109 char *debug_file = NULL;
5110 char *induction_dir = NULL;
5111 char *outfile_check_dir = NULL;
5112 uint force = FORCE;
5113 uint runtime = RUNTIME;
5114 uint hash_mode = HASH_MODE;
5115 uint attack_mode = ATTACK_MODE;
5116 uint markov_disable = MARKOV_DISABLE;
5117 uint markov_classic = MARKOV_CLASSIC;
5118 uint markov_threshold = MARKOV_THRESHOLD;
5119 char *markov_hcstat = NULL;
5120 char *outfile = NULL;
5121 uint outfile_format = OUTFILE_FORMAT;
5122 uint outfile_autohex = OUTFILE_AUTOHEX;
5123 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5124 uint restore = RESTORE;
5125 uint restore_timer = RESTORE_TIMER;
5126 uint restore_disable = RESTORE_DISABLE;
5127 uint status = STATUS;
5128 uint status_timer = STATUS_TIMER;
5129 uint status_automat = STATUS_AUTOMAT;
5130 uint loopback = LOOPBACK;
5131 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5132 char *session = NULL;
5133 uint hex_charset = HEX_CHARSET;
5134 uint hex_salt = HEX_SALT;
5135 uint hex_wordlist = HEX_WORDLIST;
5136 uint rp_gen = RP_GEN;
5137 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5138 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5139 uint rp_gen_seed = RP_GEN_SEED;
5140 char *rule_buf_l = (char *) RULE_BUF_L;
5141 char *rule_buf_r = (char *) RULE_BUF_R;
5142 uint increment = INCREMENT;
5143 uint increment_min = INCREMENT_MIN;
5144 uint increment_max = INCREMENT_MAX;
5145 #ifndef OSX
5146 char *cpu_affinity = NULL;
5147 #endif
5148 char *opencl_devices = NULL;
5149 char *opencl_platforms = NULL;
5150 char *opencl_device_types = NULL;
5151 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5152 char *truecrypt_keyfiles = NULL;
5153 uint workload_profile = WORKLOAD_PROFILE;
5154 uint kernel_accel = KERNEL_ACCEL;
5155 uint kernel_loops = KERNEL_LOOPS;
5156 #ifdef HAVE_HWMON
5157 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5158 uint gpu_temp_abort = GPU_TEMP_ABORT;
5159 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5160 #ifdef HAVE_ADL
5161 uint powertune_enable = POWERTUNE_ENABLE;
5162 #endif
5163 #endif
5164 uint logfile_disable = LOGFILE_DISABLE;
5165 uint segment_size = SEGMENT_SIZE;
5166 uint scrypt_tmto = SCRYPT_TMTO;
5167 char separator = SEPARATOR;
5168 uint bitmap_min = BITMAP_MIN;
5169 uint bitmap_max = BITMAP_MAX;
5170 char *custom_charset_1 = NULL;
5171 char *custom_charset_2 = NULL;
5172 char *custom_charset_3 = NULL;
5173 char *custom_charset_4 = NULL;
5174
5175 #define IDX_HELP 'h'
5176 #define IDX_VERSION 'V'
5177 #define IDX_VERSION_LOWER 'v'
5178 #define IDX_QUIET 0xff02
5179 #define IDX_SHOW 0xff03
5180 #define IDX_LEFT 0xff04
5181 #define IDX_REMOVE 0xff05
5182 #define IDX_REMOVE_TIMER 0xff37
5183 #define IDX_SKIP 's'
5184 #define IDX_LIMIT 'l'
5185 #define IDX_KEYSPACE 0xff35
5186 #define IDX_POTFILE_DISABLE 0xff06
5187 #define IDX_DEBUG_MODE 0xff43
5188 #define IDX_DEBUG_FILE 0xff44
5189 #define IDX_INDUCTION_DIR 0xff46
5190 #define IDX_OUTFILE_CHECK_DIR 0xff47
5191 #define IDX_USERNAME 0xff07
5192 #define IDX_FORCE 0xff08
5193 #define IDX_RUNTIME 0xff09
5194 #define IDX_BENCHMARK 'b'
5195 #define IDX_BENCHMARK_MODE 0xff32
5196 #define IDX_HASH_MODE 'm'
5197 #define IDX_ATTACK_MODE 'a'
5198 #define IDX_RP_FILE 'r'
5199 #define IDX_RP_GEN 'g'
5200 #define IDX_RP_GEN_FUNC_MIN 0xff10
5201 #define IDX_RP_GEN_FUNC_MAX 0xff11
5202 #define IDX_RP_GEN_SEED 0xff34
5203 #define IDX_RULE_BUF_L 'j'
5204 #define IDX_RULE_BUF_R 'k'
5205 #define IDX_INCREMENT 'i'
5206 #define IDX_INCREMENT_MIN 0xff12
5207 #define IDX_INCREMENT_MAX 0xff13
5208 #define IDX_OUTFILE 'o'
5209 #define IDX_OUTFILE_FORMAT 0xff14
5210 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5211 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5212 #define IDX_RESTORE 0xff15
5213 #define IDX_RESTORE_DISABLE 0xff27
5214 #define IDX_STATUS 0xff17
5215 #define IDX_STATUS_TIMER 0xff18
5216 #define IDX_STATUS_AUTOMAT 0xff50
5217 #define IDX_LOOPBACK 0xff38
5218 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5219 #define IDX_SESSION 0xff19
5220 #define IDX_HEX_CHARSET 0xff20
5221 #define IDX_HEX_SALT 0xff21
5222 #define IDX_HEX_WORDLIST 0xff40
5223 #define IDX_MARKOV_DISABLE 0xff22
5224 #define IDX_MARKOV_CLASSIC 0xff23
5225 #define IDX_MARKOV_THRESHOLD 't'
5226 #define IDX_MARKOV_HCSTAT 0xff24
5227 #define IDX_CPU_AFFINITY 0xff25
5228 #define IDX_OPENCL_DEVICES 'd'
5229 #define IDX_OPENCL_PLATFORMS 0xff72
5230 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5231 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5232 #define IDX_WORKLOAD_PROFILE 'w'
5233 #define IDX_KERNEL_ACCEL 'n'
5234 #define IDX_KERNEL_LOOPS 'u'
5235 #define IDX_GPU_TEMP_DISABLE 0xff29
5236 #define IDX_GPU_TEMP_ABORT 0xff30
5237 #define IDX_GPU_TEMP_RETAIN 0xff31
5238 #define IDX_POWERTUNE_ENABLE 0xff41
5239 #define IDX_LOGFILE_DISABLE 0xff51
5240 #define IDX_TRUECRYPT_KEYFILES 0xff52
5241 #define IDX_SCRYPT_TMTO 0xff61
5242 #define IDX_SEGMENT_SIZE 'c'
5243 #define IDX_SEPARATOR 'p'
5244 #define IDX_BITMAP_MIN 0xff70
5245 #define IDX_BITMAP_MAX 0xff71
5246 #define IDX_CUSTOM_CHARSET_1 '1'
5247 #define IDX_CUSTOM_CHARSET_2 '2'
5248 #define IDX_CUSTOM_CHARSET_3 '3'
5249 #define IDX_CUSTOM_CHARSET_4 '4'
5250
5251 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5252
5253 struct option long_options[] =
5254 {
5255 {"help", no_argument, 0, IDX_HELP},
5256 {"version", no_argument, 0, IDX_VERSION},
5257 {"quiet", no_argument, 0, IDX_QUIET},
5258 {"show", no_argument, 0, IDX_SHOW},
5259 {"left", no_argument, 0, IDX_LEFT},
5260 {"username", no_argument, 0, IDX_USERNAME},
5261 {"remove", no_argument, 0, IDX_REMOVE},
5262 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5263 {"skip", required_argument, 0, IDX_SKIP},
5264 {"limit", required_argument, 0, IDX_LIMIT},
5265 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5266 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5267 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5268 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5269 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5270 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5271 {"force", no_argument, 0, IDX_FORCE},
5272 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5273 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5274 {"restore", no_argument, 0, IDX_RESTORE},
5275 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5276 {"status", no_argument, 0, IDX_STATUS},
5277 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5278 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5279 {"loopback", no_argument, 0, IDX_LOOPBACK},
5280 {"weak-hash-threshold",
5281 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5282 {"session", required_argument, 0, IDX_SESSION},
5283 {"runtime", required_argument, 0, IDX_RUNTIME},
5284 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5285 {"generate-rules-func-min",
5286 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5287 {"generate-rules-func-max",
5288 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5289 {"generate-rules-seed",
5290 required_argument, 0, IDX_RP_GEN_SEED},
5291 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5292 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5293 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5294 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5295 {"rules-file", required_argument, 0, IDX_RP_FILE},
5296 {"outfile", required_argument, 0, IDX_OUTFILE},
5297 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5298 {"outfile-autohex-disable",
5299 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5300 {"outfile-check-timer",
5301 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5302 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5303 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5304 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5305 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5306 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5307 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5308 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5309 #ifndef OSX
5310 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5311 #endif
5312 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5313 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5314 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5315 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5316 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5317 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5318 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5319 #ifdef HAVE_HWMON
5320 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5321 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5322 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5323 #ifdef HAVE_ADL
5324 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5325 #endif
5326 #endif // HAVE_HWMON
5327 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5328 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5329 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5330 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5331 // deprecated
5332 {"seperator", required_argument, 0, IDX_SEPARATOR},
5333 {"separator", required_argument, 0, IDX_SEPARATOR},
5334 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5335 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5336 {"increment", no_argument, 0, IDX_INCREMENT},
5337 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5338 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5339 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5340 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5341 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5342 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5343
5344 {0, 0, 0, 0}
5345 };
5346
5347 uint rp_files_cnt = 0;
5348
5349 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5350
5351 int option_index = 0;
5352 int c = -1;
5353
5354 optind = 1;
5355 optopt = 0;
5356
5357 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5358 {
5359 switch (c)
5360 {
5361 case IDX_HELP: usage = 1; break;
5362 case IDX_VERSION:
5363 case IDX_VERSION_LOWER: version = 1; break;
5364 case IDX_RESTORE: restore = 1; break;
5365 case IDX_SESSION: session = optarg; break;
5366 case IDX_SHOW: show = 1; break;
5367 case IDX_LEFT: left = 1; break;
5368 case '?': return (-1);
5369 }
5370 }
5371
5372 if (optopt != 0)
5373 {
5374 log_error ("ERROR: Invalid argument specified");
5375
5376 return (-1);
5377 }
5378
5379 /**
5380 * exit functions
5381 */
5382
5383 if (version)
5384 {
5385 log_info ("%s (%s)", VERSION_TAG, VERSION_SUM);
5386
5387 return (0);
5388 }
5389
5390 if (usage)
5391 {
5392 usage_big_print (PROGNAME);
5393
5394 return (0);
5395 }
5396
5397 /**
5398 * session needs to be set, always!
5399 */
5400
5401 if (session == NULL) session = (char *) PROGNAME;
5402
5403 /**
5404 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5405 */
5406
5407 char *exec_path = get_exec_path ();
5408
5409 #ifdef LINUX
5410
5411 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5412 char *resolved_exec_path = realpath (exec_path, NULL);
5413
5414 char *install_dir = get_install_dir (resolved_exec_path);
5415 char *profile_dir = NULL;
5416 char *session_dir = NULL;
5417 char *shared_dir = NULL;
5418
5419 if (strcmp (install_dir, resolved_install_folder) == 0)
5420 {
5421 struct passwd *pw = getpwuid (getuid ());
5422
5423 const char *homedir = pw->pw_dir;
5424
5425 profile_dir = get_profile_dir (homedir);
5426 session_dir = get_session_dir (profile_dir);
5427 shared_dir = strdup (SHARED_FOLDER);
5428
5429 mkdir (profile_dir, 0700);
5430 mkdir (session_dir, 0700);
5431 }
5432 else
5433 {
5434 profile_dir = install_dir;
5435 session_dir = install_dir;
5436 shared_dir = install_dir;
5437 }
5438
5439 myfree (resolved_install_folder);
5440 myfree (resolved_exec_path);
5441
5442 #else
5443
5444 char *install_dir = get_install_dir (exec_path);
5445 char *profile_dir = install_dir;
5446 char *session_dir = install_dir;
5447 char *shared_dir = install_dir;
5448
5449 #endif
5450
5451 data.install_dir = install_dir;
5452 data.profile_dir = profile_dir;
5453 data.session_dir = session_dir;
5454 data.shared_dir = shared_dir;
5455
5456 myfree (exec_path);
5457
5458 /**
5459 * kernel cache, we need to make sure folder exist
5460 */
5461
5462 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5463
5464 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5465
5466 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5467
5468 mkdir (kernels_folder, 0700);
5469
5470 myfree (kernels_folder);
5471
5472 /**
5473 * session
5474 */
5475
5476 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5477
5478 data.session = session;
5479
5480 char *eff_restore_file = (char *) mymalloc (session_size);
5481 char *new_restore_file = (char *) mymalloc (session_size);
5482
5483 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5484 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5485
5486 data.eff_restore_file = eff_restore_file;
5487 data.new_restore_file = new_restore_file;
5488
5489 if (((show == 1) || (left == 1)) && (restore == 1))
5490 {
5491 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5492 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5493
5494 return (-1);
5495 }
5496
5497 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5498 if ((show == 1) || (left == 1))
5499 {
5500 restore_disable = 1;
5501
5502 restore = 0;
5503 }
5504
5505 data.restore_disable = restore_disable;
5506
5507 restore_data_t *rd = init_restore (argc, argv);
5508
5509 data.rd = rd;
5510
5511 /**
5512 * restore file
5513 */
5514
5515 if (restore == 1)
5516 {
5517 read_restore (eff_restore_file, rd);
5518
5519 if (rd->version_bin < RESTORE_MIN)
5520 {
5521 log_error ("ERROR: Incompatible restore-file version");
5522
5523 return (-1);
5524 }
5525
5526 myargc = rd->argc;
5527 myargv = rd->argv;
5528
5529 #ifdef _POSIX
5530 rd->pid = getpid ();
5531 #elif _WIN
5532 rd->pid = GetCurrentProcessId ();
5533 #endif
5534 }
5535
5536 uint hash_mode_chgd = 0;
5537 uint runtime_chgd = 0;
5538 uint kernel_loops_chgd = 0;
5539 uint kernel_accel_chgd = 0;
5540 uint attack_mode_chgd = 0;
5541 uint outfile_format_chgd = 0;
5542 uint rp_gen_seed_chgd = 0;
5543 uint remove_timer_chgd = 0;
5544 uint increment_min_chgd = 0;
5545 uint increment_max_chgd = 0;
5546 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5547 uint gpu_temp_retain_chgd = 0;
5548 uint gpu_temp_abort_chgd = 0;
5549 #endif
5550
5551 optind = 1;
5552 optopt = 0;
5553 option_index = 0;
5554
5555 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5556 {
5557 switch (c)
5558 {
5559 //case IDX_HELP: usage = 1; break;
5560 //case IDX_VERSION: version = 1; break;
5561 //case IDX_RESTORE: restore = 1; break;
5562 case IDX_QUIET: quiet = 1; break;
5563 //case IDX_SHOW: show = 1; break;
5564 case IDX_SHOW: break;
5565 //case IDX_LEFT: left = 1; break;
5566 case IDX_LEFT: break;
5567 case IDX_USERNAME: username = 1; break;
5568 case IDX_REMOVE: remove = 1; break;
5569 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5570 remove_timer_chgd = 1; break;
5571 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5572 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5573 case IDX_DEBUG_FILE: debug_file = optarg; break;
5574 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5575 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5576 case IDX_FORCE: force = 1; break;
5577 case IDX_SKIP: skip = atoll (optarg); break;
5578 case IDX_LIMIT: limit = atoll (optarg); break;
5579 case IDX_KEYSPACE: keyspace = 1; break;
5580 case IDX_BENCHMARK: benchmark = 1; break;
5581 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5582 case IDX_RESTORE: break;
5583 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5584 case IDX_STATUS: status = 1; break;
5585 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5586 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5587 case IDX_LOOPBACK: loopback = 1; break;
5588 case IDX_WEAK_HASH_THRESHOLD:
5589 weak_hash_threshold = atoi (optarg); break;
5590 //case IDX_SESSION: session = optarg; break;
5591 case IDX_SESSION: break;
5592 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5593 hash_mode_chgd = 1; break;
5594 case IDX_RUNTIME: runtime = atoi (optarg);
5595 runtime_chgd = 1; break;
5596 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5597 attack_mode_chgd = 1; break;
5598 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5599 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5600 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5601 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5602 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5603 rp_gen_seed_chgd = 1; break;
5604 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5605 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5606 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5607 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5608 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5609 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5610 case IDX_OUTFILE: outfile = optarg; break;
5611 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5612 outfile_format_chgd = 1; break;
5613 case IDX_OUTFILE_AUTOHEX_DISABLE:
5614 outfile_autohex = 0; break;
5615 case IDX_OUTFILE_CHECK_TIMER:
5616 outfile_check_timer = atoi (optarg); break;
5617 case IDX_HEX_CHARSET: hex_charset = 1; break;
5618 case IDX_HEX_SALT: hex_salt = 1; break;
5619 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5620 #ifndef OSX
5621 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5622 #endif
5623 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5624 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5625 case IDX_OPENCL_DEVICE_TYPES:
5626 opencl_device_types = optarg; break;
5627 case IDX_OPENCL_VECTOR_WIDTH:
5628 opencl_vector_width = atoi (optarg); break;
5629 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5630 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5631 kernel_accel_chgd = 1; break;
5632 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5633 kernel_loops_chgd = 1; break;
5634 #ifdef HAVE_HWMON
5635 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5636 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5637 #ifdef HAVE_ADL
5638 gpu_temp_abort_chgd = 1;
5639 #endif
5640 break;
5641 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5642 #ifdef HAVE_ADL
5643 gpu_temp_retain_chgd = 1;
5644 #endif
5645 break;
5646 #ifdef HAVE_ADL
5647 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5648 #endif
5649 #endif // HAVE_HWMON
5650 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5651 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5652 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5653 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5654 case IDX_SEPARATOR: separator = optarg[0]; break;
5655 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5656 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5657 case IDX_INCREMENT: increment = 1; break;
5658 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5659 increment_min_chgd = 1; break;
5660 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5661 increment_max_chgd = 1; break;
5662 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5663 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5664 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5665 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5666
5667 default:
5668 log_error ("ERROR: Invalid argument specified");
5669 return (-1);
5670 }
5671 }
5672
5673 if (optopt != 0)
5674 {
5675 log_error ("ERROR: Invalid argument specified");
5676
5677 return (-1);
5678 }
5679
5680 /**
5681 * Inform user things getting started,
5682 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5683 * - we do not need to check algorithm_pos
5684 */
5685
5686 if (quiet == 0)
5687 {
5688 if (benchmark == 1)
5689 {
5690 log_info ("%s %s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5691
5692 log_info ("");
5693 }
5694 else if (restore == 1)
5695 {
5696 log_info ("%s %s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG, VERSION_SUM);
5697
5698 log_info ("");
5699 }
5700 else
5701 {
5702 log_info ("%s %s (%s) starting...", PROGNAME, VERSION_TAG, VERSION_SUM);
5703
5704 log_info ("");
5705 }
5706 }
5707
5708 /**
5709 * sanity check
5710 */
5711
5712 if (attack_mode > 7)
5713 {
5714 log_error ("ERROR: Invalid attack-mode specified");
5715
5716 return (-1);
5717 }
5718
5719 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5720 {
5721 log_error ("ERROR: Invalid runtime specified");
5722
5723 return (-1);
5724 }
5725
5726 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5727 {
5728 log_error ("ERROR: Invalid hash-type specified");
5729
5730 return (-1);
5731 }
5732
5733 // renamed hash modes
5734
5735 if (hash_mode_chgd)
5736 {
5737 int n = -1;
5738
5739 switch (hash_mode)
5740 {
5741 case 123: n = 124;
5742 break;
5743 }
5744
5745 if (n >= 0)
5746 {
5747 log_error ("Old -m specified, use -m %d instead", n);
5748
5749 return (-1);
5750 }
5751 }
5752
5753 if (username == 1)
5754 {
5755 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5756 {
5757 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5758
5759 return (-1);
5760 }
5761 }
5762
5763 if (outfile_format > 16)
5764 {
5765 log_error ("ERROR: Invalid outfile-format specified");
5766
5767 return (-1);
5768 }
5769
5770 if (left == 1)
5771 {
5772 if (outfile_format_chgd == 1)
5773 {
5774 if (outfile_format > 1)
5775 {
5776 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5777
5778 return (-1);
5779 }
5780 }
5781 else
5782 {
5783 outfile_format = OUTFILE_FMT_HASH;
5784 }
5785 }
5786
5787 if (show == 1)
5788 {
5789 if (outfile_format_chgd == 1)
5790 {
5791 if ((outfile_format > 7) && (outfile_format < 16))
5792 {
5793 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5794
5795 return (-1);
5796 }
5797 }
5798 }
5799
5800 if (increment_min < INCREMENT_MIN)
5801 {
5802 log_error ("ERROR: Invalid increment-min specified");
5803
5804 return (-1);
5805 }
5806
5807 if (increment_max > INCREMENT_MAX)
5808 {
5809 log_error ("ERROR: Invalid increment-max specified");
5810
5811 return (-1);
5812 }
5813
5814 if (increment_min > increment_max)
5815 {
5816 log_error ("ERROR: Invalid increment-min specified");
5817
5818 return (-1);
5819 }
5820
5821 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5822 {
5823 log_error ("ERROR: increment is not allowed in attack-mode 0");
5824
5825 return (-1);
5826 }
5827
5828 if ((increment == 0) && (increment_min_chgd == 1))
5829 {
5830 log_error ("ERROR: increment-min is only supported together with increment switch");
5831
5832 return (-1);
5833 }
5834
5835 if ((increment == 0) && (increment_max_chgd == 1))
5836 {
5837 log_error ("ERROR: increment-max is only supported together with increment switch");
5838
5839 return (-1);
5840 }
5841
5842 if (rp_files_cnt && rp_gen)
5843 {
5844 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5845
5846 return (-1);
5847 }
5848
5849 if (rp_files_cnt || rp_gen)
5850 {
5851 if (attack_mode != ATTACK_MODE_STRAIGHT)
5852 {
5853 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5854
5855 return (-1);
5856 }
5857 }
5858
5859 if (rp_gen_func_min > rp_gen_func_max)
5860 {
5861 log_error ("ERROR: Invalid rp-gen-func-min specified");
5862
5863 return (-1);
5864 }
5865
5866 if (kernel_accel_chgd == 1)
5867 {
5868 if (workload_profile != WORKLOAD_PROFILE)
5869 {
5870 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5871
5872 return (-1);
5873 }
5874
5875 if (kernel_accel < 1)
5876 {
5877 log_error ("ERROR: Invalid kernel-accel specified");
5878
5879 return (-1);
5880 }
5881
5882 if (kernel_accel > 800)
5883 {
5884 log_error ("ERROR: Invalid kernel-accel specified");
5885
5886 return (-1);
5887 }
5888 }
5889
5890 if (kernel_loops_chgd == 1)
5891 {
5892 if (workload_profile != WORKLOAD_PROFILE)
5893 {
5894 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5895
5896 return (-1);
5897 }
5898
5899 if (kernel_loops < 1)
5900 {
5901 log_error ("ERROR: Invalid kernel-loops specified");
5902
5903 return (-1);
5904 }
5905
5906 if (kernel_loops > 1024)
5907 {
5908 log_error ("ERROR: Invalid kernel-loops specified");
5909
5910 return (-1);
5911 }
5912 }
5913
5914 if (benchmark == 1)
5915 {
5916 if (workload_profile != WORKLOAD_PROFILE)
5917 {
5918 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5919
5920 return (-1);
5921 }
5922 }
5923
5924 if ((workload_profile < 1) || (workload_profile > 3))
5925 {
5926 log_error ("ERROR: workload-profile %i not available", workload_profile);
5927
5928 return (-1);
5929 }
5930
5931 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5932 {
5933 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5934
5935 return (-1);
5936 }
5937
5938 if (show == 1 || left == 1)
5939 {
5940 attack_mode = ATTACK_MODE_NONE;
5941
5942 if (remove == 1)
5943 {
5944 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5945
5946 return (-1);
5947 }
5948
5949 if (potfile_disable == 1)
5950 {
5951 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5952
5953 return (-1);
5954 }
5955 }
5956
5957 uint attack_kern = ATTACK_KERN_NONE;
5958
5959 switch (attack_mode)
5960 {
5961 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5962 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5963 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5964 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5965 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5966 }
5967
5968 if (benchmark == 0)
5969 {
5970 if (keyspace == 1)
5971 {
5972 int num_additional_params = 1;
5973
5974 if (attack_kern == ATTACK_KERN_COMBI)
5975 {
5976 num_additional_params = 2;
5977 }
5978
5979 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5980
5981 if (keyspace_wordlist_specified == 0) optind--;
5982 }
5983
5984 if (attack_kern == ATTACK_KERN_NONE)
5985 {
5986 if ((optind + 1) != myargc)
5987 {
5988 usage_mini_print (myargv[0]);
5989
5990 return (-1);
5991 }
5992 }
5993 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5994 {
5995 if ((optind + 1) > myargc)
5996 {
5997 usage_mini_print (myargv[0]);
5998
5999 return (-1);
6000 }
6001 }
6002 else if (attack_kern == ATTACK_KERN_COMBI)
6003 {
6004 if ((optind + 3) != myargc)
6005 {
6006 usage_mini_print (myargv[0]);
6007
6008 return (-1);
6009 }
6010 }
6011 else if (attack_kern == ATTACK_KERN_BF)
6012 {
6013 if ((optind + 1) > myargc)
6014 {
6015 usage_mini_print (myargv[0]);
6016
6017 return (-1);
6018 }
6019 }
6020 else
6021 {
6022 usage_mini_print (myargv[0]);
6023
6024 return (-1);
6025 }
6026 }
6027 else
6028 {
6029 if (myargv[optind] != 0)
6030 {
6031 log_error ("ERROR: Invalid argument for benchmark mode specified");
6032
6033 return (-1);
6034 }
6035
6036 if (attack_mode_chgd == 1)
6037 {
6038 if (attack_mode != ATTACK_MODE_BF)
6039 {
6040 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6041
6042 return (-1);
6043 }
6044 }
6045
6046 if (benchmark_mode == 0)
6047 {
6048 // nothing to do
6049 }
6050 else if (benchmark_mode == 1)
6051 {
6052 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6053 {
6054 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6055
6056 return (-1);
6057 }
6058 }
6059 else
6060 {
6061 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6062
6063 return (-1);
6064 }
6065 }
6066
6067 if (skip != 0 && limit != 0)
6068 {
6069 limit += skip;
6070 }
6071
6072 if (keyspace == 1)
6073 {
6074 if (show == 1)
6075 {
6076 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6077
6078 return (-1);
6079 }
6080 else if (left == 1)
6081 {
6082 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6083
6084 return (-1);
6085 }
6086
6087 potfile_disable = 1;
6088
6089 restore_disable = 1;
6090
6091 restore = 0;
6092
6093 weak_hash_threshold = 0;
6094
6095 quiet = 1;
6096 }
6097
6098 if (remove_timer_chgd == 1)
6099 {
6100 if (remove == 0)
6101 {
6102 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6103
6104 return (-1);
6105 }
6106
6107 if (remove_timer < 1)
6108 {
6109 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6110
6111 return (-1);
6112 }
6113 }
6114
6115 if (loopback == 1)
6116 {
6117 if (attack_mode == ATTACK_MODE_BF)
6118 {
6119 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6120
6121 return (-1);
6122 }
6123 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6124 {
6125 if ((rp_files_cnt == 0) && (rp_gen == 0))
6126 {
6127 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6128
6129 return (-1);
6130 }
6131 }
6132 }
6133
6134 if (debug_mode > 0)
6135 {
6136 if (attack_mode != ATTACK_MODE_STRAIGHT)
6137 {
6138 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6139
6140 return (-1);
6141 }
6142
6143 if ((rp_files_cnt == 0) && (rp_gen == 0))
6144 {
6145 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6146
6147 return (-1);
6148 }
6149 }
6150
6151 if (debug_mode > 4)
6152 {
6153 log_error ("ERROR: Invalid debug-mode specified");
6154
6155 return (-1);
6156 }
6157
6158 if (debug_file != NULL)
6159 {
6160 if (debug_mode < 1)
6161 {
6162 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6163
6164 return (-1);
6165 }
6166 }
6167
6168 if (induction_dir != NULL)
6169 {
6170 if (attack_mode == ATTACK_MODE_BF)
6171 {
6172 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (attack_mode != ATTACK_MODE_STRAIGHT)
6179 {
6180 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6181 {
6182 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6183
6184 return (-1);
6185 }
6186
6187 weak_hash_threshold = 0;
6188 }
6189
6190 /**
6191 * induction directory
6192 */
6193
6194 char *induction_directory = NULL;
6195
6196 if (attack_mode != ATTACK_MODE_BF)
6197 {
6198 if (induction_dir == NULL)
6199 {
6200 induction_directory = (char *) mymalloc (session_size);
6201
6202 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6203
6204 // create induction folder if it does not already exist
6205
6206 if (keyspace == 0)
6207 {
6208 if (rmdir (induction_directory) == -1)
6209 {
6210 if (errno == ENOENT)
6211 {
6212 // good, we can ignore
6213 }
6214 else if (errno == ENOTEMPTY)
6215 {
6216 char *induction_directory_mv = (char *) mymalloc (session_size);
6217
6218 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6219
6220 if (rename (induction_directory, induction_directory_mv) != 0)
6221 {
6222 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6223
6224 return (-1);
6225 }
6226 }
6227 else
6228 {
6229 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6230
6231 return (-1);
6232 }
6233 }
6234
6235 if (mkdir (induction_directory, 0700) == -1)
6236 {
6237 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6238
6239 return (-1);
6240 }
6241 }
6242 }
6243 else
6244 {
6245 induction_directory = induction_dir;
6246 }
6247 }
6248
6249 data.induction_directory = induction_directory;
6250
6251 /**
6252 * loopback
6253 */
6254
6255 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6256
6257 char *loopback_file = (char *) mymalloc (loopback_size);
6258
6259 /**
6260 * outfile-check directory
6261 */
6262
6263 char *outfile_check_directory = NULL;
6264
6265 if (outfile_check_dir == NULL)
6266 {
6267 outfile_check_directory = (char *) mymalloc (session_size);
6268
6269 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6270 }
6271 else
6272 {
6273 outfile_check_directory = outfile_check_dir;
6274 }
6275
6276 data.outfile_check_directory = outfile_check_directory;
6277
6278 if (keyspace == 0)
6279 {
6280 struct stat outfile_check_stat;
6281
6282 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6283 {
6284 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6285
6286 if (is_dir == 0)
6287 {
6288 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6289
6290 return (-1);
6291 }
6292 }
6293 else if (outfile_check_dir == NULL)
6294 {
6295 if (mkdir (outfile_check_directory, 0700) == -1)
6296 {
6297 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6298
6299 return (-1);
6300 }
6301 }
6302 }
6303
6304 /**
6305 * special other stuff
6306 */
6307
6308 if (hash_mode == 9710)
6309 {
6310 outfile_format = 5;
6311 outfile_format_chgd = 1;
6312 }
6313
6314 if (hash_mode == 9810)
6315 {
6316 outfile_format = 5;
6317 outfile_format_chgd = 1;
6318 }
6319
6320 if (hash_mode == 10410)
6321 {
6322 outfile_format = 5;
6323 outfile_format_chgd = 1;
6324 }
6325
6326 /**
6327 * store stuff
6328 */
6329
6330 data.hash_mode = hash_mode;
6331 data.restore = restore;
6332 data.restore_timer = restore_timer;
6333 data.restore_disable = restore_disable;
6334 data.status = status;
6335 data.status_timer = status_timer;
6336 data.status_automat = status_automat;
6337 data.loopback = loopback;
6338 data.runtime = runtime;
6339 data.remove = remove;
6340 data.remove_timer = remove_timer;
6341 data.debug_mode = debug_mode;
6342 data.debug_file = debug_file;
6343 data.username = username;
6344 data.quiet = quiet;
6345 data.outfile = outfile;
6346 data.outfile_format = outfile_format;
6347 data.outfile_autohex = outfile_autohex;
6348 data.hex_charset = hex_charset;
6349 data.hex_salt = hex_salt;
6350 data.hex_wordlist = hex_wordlist;
6351 data.separator = separator;
6352 data.rp_files = rp_files;
6353 data.rp_files_cnt = rp_files_cnt;
6354 data.rp_gen = rp_gen;
6355 data.rp_gen_seed = rp_gen_seed;
6356 data.force = force;
6357 data.benchmark = benchmark;
6358 data.skip = skip;
6359 data.limit = limit;
6360 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6361 data.powertune_enable = powertune_enable;
6362 #endif
6363 data.logfile_disable = logfile_disable;
6364 data.truecrypt_keyfiles = truecrypt_keyfiles;
6365 data.scrypt_tmto = scrypt_tmto;
6366
6367 /**
6368 * cpu affinity
6369 */
6370
6371 #ifndef OSX
6372 if (cpu_affinity)
6373 {
6374 set_cpu_affinity (cpu_affinity);
6375 }
6376 #endif
6377
6378 if (rp_gen_seed_chgd == 0)
6379 {
6380 srand (proc_start);
6381 }
6382 else
6383 {
6384 srand (rp_gen_seed);
6385 }
6386
6387 /**
6388 * logfile init
6389 */
6390
6391 if (logfile_disable == 0)
6392 {
6393 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6394
6395 char *logfile = (char *) mymalloc (logfile_size);
6396
6397 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6398
6399 data.logfile = logfile;
6400
6401 char *topid = logfile_generate_topid ();
6402
6403 data.topid = topid;
6404 }
6405
6406 // logfile_append() checks for logfile_disable internally to make it easier from here
6407
6408 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6409 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6410 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6411 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6412 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6413 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6414 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6415 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6416 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6417 #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));
6418
6419 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6420 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6421 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6422 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6423 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6424 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6425 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6426 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6427
6428 logfile_top_msg ("START");
6429
6430 logfile_top_uint (attack_mode);
6431 logfile_top_uint (attack_kern);
6432 logfile_top_uint (benchmark);
6433 logfile_top_uint (benchmark_mode);
6434 logfile_top_uint (bitmap_min);
6435 logfile_top_uint (bitmap_max);
6436 logfile_top_uint (debug_mode);
6437 logfile_top_uint (force);
6438 logfile_top_uint (kernel_accel);
6439 logfile_top_uint (kernel_loops);
6440 #ifdef HAVE_HWMON
6441 logfile_top_uint (gpu_temp_abort);
6442 logfile_top_uint (gpu_temp_disable);
6443 logfile_top_uint (gpu_temp_retain);
6444 #endif
6445 logfile_top_uint (hash_mode);
6446 logfile_top_uint (hex_charset);
6447 logfile_top_uint (hex_salt);
6448 logfile_top_uint (hex_wordlist);
6449 logfile_top_uint (increment);
6450 logfile_top_uint (increment_max);
6451 logfile_top_uint (increment_min);
6452 logfile_top_uint (keyspace);
6453 logfile_top_uint (left);
6454 logfile_top_uint (logfile_disable);
6455 logfile_top_uint (loopback);
6456 logfile_top_uint (markov_classic);
6457 logfile_top_uint (markov_disable);
6458 logfile_top_uint (markov_threshold);
6459 logfile_top_uint (outfile_autohex);
6460 logfile_top_uint (outfile_check_timer);
6461 logfile_top_uint (outfile_format);
6462 logfile_top_uint (potfile_disable);
6463 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6464 logfile_top_uint (powertune_enable);
6465 #endif
6466 logfile_top_uint (scrypt_tmto);
6467 logfile_top_uint (quiet);
6468 logfile_top_uint (remove);
6469 logfile_top_uint (remove_timer);
6470 logfile_top_uint (restore);
6471 logfile_top_uint (restore_disable);
6472 logfile_top_uint (restore_timer);
6473 logfile_top_uint (rp_gen);
6474 logfile_top_uint (rp_gen_func_max);
6475 logfile_top_uint (rp_gen_func_min);
6476 logfile_top_uint (rp_gen_seed);
6477 logfile_top_uint (runtime);
6478 logfile_top_uint (segment_size);
6479 logfile_top_uint (show);
6480 logfile_top_uint (status);
6481 logfile_top_uint (status_automat);
6482 logfile_top_uint (status_timer);
6483 logfile_top_uint (usage);
6484 logfile_top_uint (username);
6485 logfile_top_uint (version);
6486 logfile_top_uint (weak_hash_threshold);
6487 logfile_top_uint (workload_profile);
6488 logfile_top_uint64 (limit);
6489 logfile_top_uint64 (skip);
6490 logfile_top_char (separator);
6491 #ifndef OSX
6492 logfile_top_string (cpu_affinity);
6493 #endif
6494 logfile_top_string (custom_charset_1);
6495 logfile_top_string (custom_charset_2);
6496 logfile_top_string (custom_charset_3);
6497 logfile_top_string (custom_charset_4);
6498 logfile_top_string (debug_file);
6499 logfile_top_string (opencl_devices);
6500 logfile_top_string (opencl_platforms);
6501 logfile_top_string (opencl_device_types);
6502 logfile_top_uint (opencl_vector_width);
6503 logfile_top_string (induction_dir);
6504 logfile_top_string (markov_hcstat);
6505 logfile_top_string (outfile);
6506 logfile_top_string (outfile_check_dir);
6507 logfile_top_string (rule_buf_l);
6508 logfile_top_string (rule_buf_r);
6509 logfile_top_string (session);
6510 logfile_top_string (truecrypt_keyfiles);
6511
6512 /**
6513 * OpenCL platform selection
6514 */
6515
6516 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6517
6518 /**
6519 * OpenCL device selection
6520 */
6521
6522 u32 devices_filter = setup_devices_filter (opencl_devices);
6523
6524 /**
6525 * OpenCL device type selection
6526 */
6527
6528 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6529
6530 /**
6531 * benchmark
6532 */
6533
6534 if (benchmark == 1)
6535 {
6536 /**
6537 * disable useless stuff for benchmark
6538 */
6539
6540 restore_timer = 0;
6541 status_timer = 0;
6542 restore_disable = 1;
6543 potfile_disable = 1;
6544 weak_hash_threshold = 0;
6545
6546 data.restore_timer = restore_timer;
6547 data.status_timer = status_timer;
6548 data.restore_disable = restore_disable;
6549
6550 if (benchmark_mode == 1)
6551 {
6552 markov_disable = 1;
6553 }
6554
6555 /**
6556 * force attack mode to be bruteforce
6557 */
6558
6559 attack_mode = ATTACK_MODE_BF;
6560 attack_kern = ATTACK_KERN_BF;
6561
6562 if (runtime_chgd == 0)
6563 {
6564 runtime = 4;
6565
6566 if (benchmark_mode == 1) runtime = 17;
6567
6568 data.runtime = runtime;
6569 }
6570 }
6571
6572 /**
6573 * config
6574 */
6575
6576 uint hash_type = 0;
6577 uint salt_type = 0;
6578 uint attack_exec = 0;
6579 uint opts_type = 0;
6580 uint kern_type = 0;
6581 uint dgst_size = 0;
6582 uint esalt_size = 0;
6583 uint opti_type = 0;
6584 uint dgst_pos0 = -1;
6585 uint dgst_pos1 = -1;
6586 uint dgst_pos2 = -1;
6587 uint dgst_pos3 = -1;
6588
6589 int (*parse_func) (char *, uint, hash_t *);
6590 int (*sort_by_digest) (const void *, const void *);
6591
6592 uint algorithm_pos = 0;
6593 uint algorithm_max = 1;
6594
6595 uint *algorithms = default_benchmark_algorithms;
6596
6597 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6598
6599 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6600 {
6601 /*
6602 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6603 * the following algos are skipped entirely
6604 */
6605
6606 if (algorithm_pos > 0)
6607 {
6608 local_free (rd);
6609
6610 rd = init_restore (argc, argv);
6611
6612 data.rd = rd;
6613 }
6614
6615 /**
6616 * update hash_mode in case of multihash benchmark
6617 */
6618
6619 if (benchmark == 1)
6620 {
6621 if (hash_mode_chgd == 0)
6622 {
6623 hash_mode = algorithms[algorithm_pos];
6624
6625 data.hash_mode = hash_mode;
6626 }
6627
6628 quiet = 1;
6629
6630 data.quiet = quiet;
6631 }
6632
6633 switch (hash_mode)
6634 {
6635 case 0: hash_type = HASH_TYPE_MD5;
6636 salt_type = SALT_TYPE_NONE;
6637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6638 opts_type = OPTS_TYPE_PT_GENERATE_LE
6639 | OPTS_TYPE_PT_ADD80
6640 | OPTS_TYPE_PT_ADDBITS14;
6641 kern_type = KERN_TYPE_MD5;
6642 dgst_size = DGST_SIZE_4_4;
6643 parse_func = md5_parse_hash;
6644 sort_by_digest = sort_by_digest_4_4;
6645 opti_type = OPTI_TYPE_ZERO_BYTE
6646 | OPTI_TYPE_PRECOMPUTE_INIT
6647 | OPTI_TYPE_PRECOMPUTE_MERKLE
6648 | OPTI_TYPE_MEET_IN_MIDDLE
6649 | OPTI_TYPE_EARLY_SKIP
6650 | OPTI_TYPE_NOT_ITERATED
6651 | OPTI_TYPE_NOT_SALTED
6652 | OPTI_TYPE_RAW_HASH;
6653 dgst_pos0 = 0;
6654 dgst_pos1 = 3;
6655 dgst_pos2 = 2;
6656 dgst_pos3 = 1;
6657 break;
6658
6659 case 10: hash_type = HASH_TYPE_MD5;
6660 salt_type = SALT_TYPE_INTERN;
6661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6662 opts_type = OPTS_TYPE_PT_GENERATE_LE
6663 | OPTS_TYPE_ST_ADD80
6664 | OPTS_TYPE_ST_ADDBITS14;
6665 kern_type = KERN_TYPE_MD5_PWSLT;
6666 dgst_size = DGST_SIZE_4_4;
6667 parse_func = md5s_parse_hash;
6668 sort_by_digest = sort_by_digest_4_4;
6669 opti_type = OPTI_TYPE_ZERO_BYTE
6670 | OPTI_TYPE_PRECOMPUTE_INIT
6671 | OPTI_TYPE_PRECOMPUTE_MERKLE
6672 | OPTI_TYPE_MEET_IN_MIDDLE
6673 | OPTI_TYPE_EARLY_SKIP
6674 | OPTI_TYPE_NOT_ITERATED
6675 | OPTI_TYPE_APPENDED_SALT
6676 | OPTI_TYPE_RAW_HASH;
6677 dgst_pos0 = 0;
6678 dgst_pos1 = 3;
6679 dgst_pos2 = 2;
6680 dgst_pos3 = 1;
6681 break;
6682
6683 case 11: hash_type = HASH_TYPE_MD5;
6684 salt_type = SALT_TYPE_INTERN;
6685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6686 opts_type = OPTS_TYPE_PT_GENERATE_LE
6687 | OPTS_TYPE_ST_ADD80
6688 | OPTS_TYPE_ST_ADDBITS14;
6689 kern_type = KERN_TYPE_MD5_PWSLT;
6690 dgst_size = DGST_SIZE_4_4;
6691 parse_func = joomla_parse_hash;
6692 sort_by_digest = sort_by_digest_4_4;
6693 opti_type = OPTI_TYPE_ZERO_BYTE
6694 | OPTI_TYPE_PRECOMPUTE_INIT
6695 | OPTI_TYPE_PRECOMPUTE_MERKLE
6696 | OPTI_TYPE_MEET_IN_MIDDLE
6697 | OPTI_TYPE_EARLY_SKIP
6698 | OPTI_TYPE_NOT_ITERATED
6699 | OPTI_TYPE_APPENDED_SALT
6700 | OPTI_TYPE_RAW_HASH;
6701 dgst_pos0 = 0;
6702 dgst_pos1 = 3;
6703 dgst_pos2 = 2;
6704 dgst_pos3 = 1;
6705 break;
6706
6707 case 12: hash_type = HASH_TYPE_MD5;
6708 salt_type = SALT_TYPE_INTERN;
6709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6710 opts_type = OPTS_TYPE_PT_GENERATE_LE
6711 | OPTS_TYPE_ST_ADD80
6712 | OPTS_TYPE_ST_ADDBITS14;
6713 kern_type = KERN_TYPE_MD5_PWSLT;
6714 dgst_size = DGST_SIZE_4_4;
6715 parse_func = postgresql_parse_hash;
6716 sort_by_digest = sort_by_digest_4_4;
6717 opti_type = OPTI_TYPE_ZERO_BYTE
6718 | OPTI_TYPE_PRECOMPUTE_INIT
6719 | OPTI_TYPE_PRECOMPUTE_MERKLE
6720 | OPTI_TYPE_MEET_IN_MIDDLE
6721 | OPTI_TYPE_EARLY_SKIP
6722 | OPTI_TYPE_NOT_ITERATED
6723 | OPTI_TYPE_APPENDED_SALT
6724 | OPTI_TYPE_RAW_HASH;
6725 dgst_pos0 = 0;
6726 dgst_pos1 = 3;
6727 dgst_pos2 = 2;
6728 dgst_pos3 = 1;
6729 break;
6730
6731 case 20: hash_type = HASH_TYPE_MD5;
6732 salt_type = SALT_TYPE_INTERN;
6733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6734 opts_type = OPTS_TYPE_PT_GENERATE_LE
6735 | OPTS_TYPE_PT_ADD80
6736 | OPTS_TYPE_PT_ADDBITS14;
6737 kern_type = KERN_TYPE_MD5_SLTPW;
6738 dgst_size = DGST_SIZE_4_4;
6739 parse_func = md5s_parse_hash;
6740 sort_by_digest = sort_by_digest_4_4;
6741 opti_type = OPTI_TYPE_ZERO_BYTE
6742 | OPTI_TYPE_PRECOMPUTE_INIT
6743 | OPTI_TYPE_PRECOMPUTE_MERKLE
6744 | OPTI_TYPE_EARLY_SKIP
6745 | OPTI_TYPE_NOT_ITERATED
6746 | OPTI_TYPE_PREPENDED_SALT
6747 | OPTI_TYPE_RAW_HASH;
6748 dgst_pos0 = 0;
6749 dgst_pos1 = 3;
6750 dgst_pos2 = 2;
6751 dgst_pos3 = 1;
6752 break;
6753
6754 case 21: hash_type = HASH_TYPE_MD5;
6755 salt_type = SALT_TYPE_INTERN;
6756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6757 opts_type = OPTS_TYPE_PT_GENERATE_LE
6758 | OPTS_TYPE_PT_ADD80
6759 | OPTS_TYPE_PT_ADDBITS14;
6760 kern_type = KERN_TYPE_MD5_SLTPW;
6761 dgst_size = DGST_SIZE_4_4;
6762 parse_func = osc_parse_hash;
6763 sort_by_digest = sort_by_digest_4_4;
6764 opti_type = OPTI_TYPE_ZERO_BYTE
6765 | OPTI_TYPE_PRECOMPUTE_INIT
6766 | OPTI_TYPE_PRECOMPUTE_MERKLE
6767 | OPTI_TYPE_EARLY_SKIP
6768 | OPTI_TYPE_NOT_ITERATED
6769 | OPTI_TYPE_PREPENDED_SALT
6770 | OPTI_TYPE_RAW_HASH;
6771 dgst_pos0 = 0;
6772 dgst_pos1 = 3;
6773 dgst_pos2 = 2;
6774 dgst_pos3 = 1;
6775 break;
6776
6777 case 22: hash_type = HASH_TYPE_MD5;
6778 salt_type = SALT_TYPE_EMBEDDED;
6779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6780 opts_type = OPTS_TYPE_PT_GENERATE_LE
6781 | OPTS_TYPE_PT_ADD80
6782 | OPTS_TYPE_PT_ADDBITS14;
6783 kern_type = KERN_TYPE_MD5_SLTPW;
6784 dgst_size = DGST_SIZE_4_4;
6785 parse_func = netscreen_parse_hash;
6786 sort_by_digest = sort_by_digest_4_4;
6787 opti_type = OPTI_TYPE_ZERO_BYTE
6788 | OPTI_TYPE_PRECOMPUTE_INIT
6789 | OPTI_TYPE_PRECOMPUTE_MERKLE
6790 | OPTI_TYPE_EARLY_SKIP
6791 | OPTI_TYPE_NOT_ITERATED
6792 | OPTI_TYPE_PREPENDED_SALT
6793 | OPTI_TYPE_RAW_HASH;
6794 dgst_pos0 = 0;
6795 dgst_pos1 = 3;
6796 dgst_pos2 = 2;
6797 dgst_pos3 = 1;
6798 break;
6799
6800 case 23: hash_type = HASH_TYPE_MD5;
6801 salt_type = SALT_TYPE_EMBEDDED;
6802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6803 opts_type = OPTS_TYPE_PT_GENERATE_LE
6804 | OPTS_TYPE_PT_ADD80
6805 | OPTS_TYPE_PT_ADDBITS14;
6806 kern_type = KERN_TYPE_MD5_SLTPW;
6807 dgst_size = DGST_SIZE_4_4;
6808 parse_func = skype_parse_hash;
6809 sort_by_digest = sort_by_digest_4_4;
6810 opti_type = OPTI_TYPE_ZERO_BYTE
6811 | OPTI_TYPE_PRECOMPUTE_INIT
6812 | OPTI_TYPE_PRECOMPUTE_MERKLE
6813 | OPTI_TYPE_EARLY_SKIP
6814 | OPTI_TYPE_NOT_ITERATED
6815 | OPTI_TYPE_PREPENDED_SALT
6816 | OPTI_TYPE_RAW_HASH;
6817 dgst_pos0 = 0;
6818 dgst_pos1 = 3;
6819 dgst_pos2 = 2;
6820 dgst_pos3 = 1;
6821 break;
6822
6823 case 30: hash_type = HASH_TYPE_MD5;
6824 salt_type = SALT_TYPE_INTERN;
6825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6826 opts_type = OPTS_TYPE_PT_GENERATE_LE
6827 | OPTS_TYPE_PT_UNICODE
6828 | OPTS_TYPE_ST_ADD80
6829 | OPTS_TYPE_ST_ADDBITS14;
6830 kern_type = KERN_TYPE_MD5_PWUSLT;
6831 dgst_size = DGST_SIZE_4_4;
6832 parse_func = md5s_parse_hash;
6833 sort_by_digest = sort_by_digest_4_4;
6834 opti_type = OPTI_TYPE_ZERO_BYTE
6835 | OPTI_TYPE_PRECOMPUTE_INIT
6836 | OPTI_TYPE_PRECOMPUTE_MERKLE
6837 | OPTI_TYPE_MEET_IN_MIDDLE
6838 | OPTI_TYPE_EARLY_SKIP
6839 | OPTI_TYPE_NOT_ITERATED
6840 | OPTI_TYPE_APPENDED_SALT
6841 | OPTI_TYPE_RAW_HASH;
6842 dgst_pos0 = 0;
6843 dgst_pos1 = 3;
6844 dgst_pos2 = 2;
6845 dgst_pos3 = 1;
6846 break;
6847
6848 case 40: hash_type = HASH_TYPE_MD5;
6849 salt_type = SALT_TYPE_INTERN;
6850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6851 opts_type = OPTS_TYPE_PT_GENERATE_LE
6852 | OPTS_TYPE_PT_ADD80
6853 | OPTS_TYPE_PT_ADDBITS14
6854 | OPTS_TYPE_PT_UNICODE;
6855 kern_type = KERN_TYPE_MD5_SLTPWU;
6856 dgst_size = DGST_SIZE_4_4;
6857 parse_func = md5s_parse_hash;
6858 sort_by_digest = sort_by_digest_4_4;
6859 opti_type = OPTI_TYPE_ZERO_BYTE
6860 | OPTI_TYPE_PRECOMPUTE_INIT
6861 | OPTI_TYPE_PRECOMPUTE_MERKLE
6862 | OPTI_TYPE_EARLY_SKIP
6863 | OPTI_TYPE_NOT_ITERATED
6864 | OPTI_TYPE_PREPENDED_SALT
6865 | OPTI_TYPE_RAW_HASH;
6866 dgst_pos0 = 0;
6867 dgst_pos1 = 3;
6868 dgst_pos2 = 2;
6869 dgst_pos3 = 1;
6870 break;
6871
6872 case 50: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_INTERN;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_ST_ADD80
6877 | OPTS_TYPE_ST_ADDBITS14;
6878 kern_type = KERN_TYPE_HMACMD5_PW;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = hmacmd5_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_NOT_ITERATED;
6884 dgst_pos0 = 0;
6885 dgst_pos1 = 3;
6886 dgst_pos2 = 2;
6887 dgst_pos3 = 1;
6888 break;
6889
6890 case 60: hash_type = HASH_TYPE_MD5;
6891 salt_type = SALT_TYPE_INTERN;
6892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6893 opts_type = OPTS_TYPE_PT_GENERATE_LE
6894 | OPTS_TYPE_PT_ADD80
6895 | OPTS_TYPE_PT_ADDBITS14;
6896 kern_type = KERN_TYPE_HMACMD5_SLT;
6897 dgst_size = DGST_SIZE_4_4;
6898 parse_func = hmacmd5_parse_hash;
6899 sort_by_digest = sort_by_digest_4_4;
6900 opti_type = OPTI_TYPE_ZERO_BYTE
6901 | OPTI_TYPE_NOT_ITERATED;
6902 dgst_pos0 = 0;
6903 dgst_pos1 = 3;
6904 dgst_pos2 = 2;
6905 dgst_pos3 = 1;
6906 break;
6907
6908 case 100: hash_type = HASH_TYPE_SHA1;
6909 salt_type = SALT_TYPE_NONE;
6910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6911 opts_type = OPTS_TYPE_PT_GENERATE_BE
6912 | OPTS_TYPE_PT_ADD80
6913 | OPTS_TYPE_PT_ADDBITS15;
6914 kern_type = KERN_TYPE_SHA1;
6915 dgst_size = DGST_SIZE_4_5;
6916 parse_func = sha1_parse_hash;
6917 sort_by_digest = sort_by_digest_4_5;
6918 opti_type = OPTI_TYPE_ZERO_BYTE
6919 | OPTI_TYPE_PRECOMPUTE_INIT
6920 | OPTI_TYPE_PRECOMPUTE_MERKLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_NOT_SALTED
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 3;
6926 dgst_pos1 = 4;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 101: hash_type = HASH_TYPE_SHA1;
6932 salt_type = SALT_TYPE_NONE;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_BE
6935 | OPTS_TYPE_PT_ADD80
6936 | OPTS_TYPE_PT_ADDBITS15;
6937 kern_type = KERN_TYPE_SHA1;
6938 dgst_size = DGST_SIZE_4_5;
6939 parse_func = sha1b64_parse_hash;
6940 sort_by_digest = sort_by_digest_4_5;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_EARLY_SKIP
6945 | OPTI_TYPE_NOT_ITERATED
6946 | OPTI_TYPE_NOT_SALTED
6947 | OPTI_TYPE_RAW_HASH;
6948 dgst_pos0 = 3;
6949 dgst_pos1 = 4;
6950 dgst_pos2 = 2;
6951 dgst_pos3 = 1;
6952 break;
6953
6954 case 110: hash_type = HASH_TYPE_SHA1;
6955 salt_type = SALT_TYPE_INTERN;
6956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6957 opts_type = OPTS_TYPE_PT_GENERATE_BE
6958 | OPTS_TYPE_ST_ADD80
6959 | OPTS_TYPE_ST_ADDBITS15;
6960 kern_type = KERN_TYPE_SHA1_PWSLT;
6961 dgst_size = DGST_SIZE_4_5;
6962 parse_func = sha1s_parse_hash;
6963 sort_by_digest = sort_by_digest_4_5;
6964 opti_type = OPTI_TYPE_ZERO_BYTE
6965 | OPTI_TYPE_PRECOMPUTE_INIT
6966 | OPTI_TYPE_PRECOMPUTE_MERKLE
6967 | OPTI_TYPE_EARLY_SKIP
6968 | OPTI_TYPE_NOT_ITERATED
6969 | OPTI_TYPE_APPENDED_SALT
6970 | OPTI_TYPE_RAW_HASH;
6971 dgst_pos0 = 3;
6972 dgst_pos1 = 4;
6973 dgst_pos2 = 2;
6974 dgst_pos3 = 1;
6975 break;
6976
6977 case 111: hash_type = HASH_TYPE_SHA1;
6978 salt_type = SALT_TYPE_EMBEDDED;
6979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6980 opts_type = OPTS_TYPE_PT_GENERATE_BE
6981 | OPTS_TYPE_ST_ADD80
6982 | OPTS_TYPE_ST_ADDBITS15;
6983 kern_type = KERN_TYPE_SHA1_PWSLT;
6984 dgst_size = DGST_SIZE_4_5;
6985 parse_func = sha1b64s_parse_hash;
6986 sort_by_digest = sort_by_digest_4_5;
6987 opti_type = OPTI_TYPE_ZERO_BYTE
6988 | OPTI_TYPE_PRECOMPUTE_INIT
6989 | OPTI_TYPE_PRECOMPUTE_MERKLE
6990 | OPTI_TYPE_EARLY_SKIP
6991 | OPTI_TYPE_NOT_ITERATED
6992 | OPTI_TYPE_APPENDED_SALT
6993 | OPTI_TYPE_RAW_HASH;
6994 dgst_pos0 = 3;
6995 dgst_pos1 = 4;
6996 dgst_pos2 = 2;
6997 dgst_pos3 = 1;
6998 break;
6999
7000 case 112: hash_type = HASH_TYPE_SHA1;
7001 salt_type = SALT_TYPE_INTERN;
7002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7003 opts_type = OPTS_TYPE_PT_GENERATE_BE
7004 | OPTS_TYPE_ST_ADD80
7005 | OPTS_TYPE_ST_ADDBITS15
7006 | OPTS_TYPE_ST_HEX;
7007 kern_type = KERN_TYPE_SHA1_PWSLT;
7008 dgst_size = DGST_SIZE_4_5;
7009 parse_func = oracles_parse_hash;
7010 sort_by_digest = sort_by_digest_4_5;
7011 opti_type = OPTI_TYPE_ZERO_BYTE
7012 | OPTI_TYPE_PRECOMPUTE_INIT
7013 | OPTI_TYPE_PRECOMPUTE_MERKLE
7014 | OPTI_TYPE_EARLY_SKIP
7015 | OPTI_TYPE_NOT_ITERATED
7016 | OPTI_TYPE_APPENDED_SALT
7017 | OPTI_TYPE_RAW_HASH;
7018 dgst_pos0 = 3;
7019 dgst_pos1 = 4;
7020 dgst_pos2 = 2;
7021 dgst_pos3 = 1;
7022 break;
7023
7024 case 120: hash_type = HASH_TYPE_SHA1;
7025 salt_type = SALT_TYPE_INTERN;
7026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7027 opts_type = OPTS_TYPE_PT_GENERATE_BE
7028 | OPTS_TYPE_PT_ADD80
7029 | OPTS_TYPE_PT_ADDBITS15;
7030 kern_type = KERN_TYPE_SHA1_SLTPW;
7031 dgst_size = DGST_SIZE_4_5;
7032 parse_func = sha1s_parse_hash;
7033 sort_by_digest = sort_by_digest_4_5;
7034 opti_type = OPTI_TYPE_ZERO_BYTE
7035 | OPTI_TYPE_PRECOMPUTE_INIT
7036 | OPTI_TYPE_PRECOMPUTE_MERKLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_PREPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 3;
7042 dgst_pos1 = 4;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 121: hash_type = HASH_TYPE_SHA1;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_BE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS15
7053 | OPTS_TYPE_ST_LOWER;
7054 kern_type = KERN_TYPE_SHA1_SLTPW;
7055 dgst_size = DGST_SIZE_4_5;
7056 parse_func = smf_parse_hash;
7057 sort_by_digest = sort_by_digest_4_5;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_PRECOMPUTE_INIT
7060 | OPTI_TYPE_PRECOMPUTE_MERKLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_PREPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 3;
7066 dgst_pos1 = 4;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 122: hash_type = HASH_TYPE_SHA1;
7072 salt_type = SALT_TYPE_EMBEDDED;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_BE
7075 | OPTS_TYPE_PT_ADD80
7076 | OPTS_TYPE_PT_ADDBITS15
7077 | OPTS_TYPE_ST_HEX;
7078 kern_type = KERN_TYPE_SHA1_SLTPW;
7079 dgst_size = DGST_SIZE_4_5;
7080 parse_func = osx1_parse_hash;
7081 sort_by_digest = sort_by_digest_4_5;
7082 opti_type = OPTI_TYPE_ZERO_BYTE
7083 | OPTI_TYPE_PRECOMPUTE_INIT
7084 | OPTI_TYPE_PRECOMPUTE_MERKLE
7085 | OPTI_TYPE_EARLY_SKIP
7086 | OPTI_TYPE_NOT_ITERATED
7087 | OPTI_TYPE_PREPENDED_SALT
7088 | OPTI_TYPE_RAW_HASH;
7089 dgst_pos0 = 3;
7090 dgst_pos1 = 4;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 124: hash_type = HASH_TYPE_SHA1;
7096 salt_type = SALT_TYPE_EMBEDDED;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_BE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS15;
7101 kern_type = KERN_TYPE_SHA1_SLTPW;
7102 dgst_size = DGST_SIZE_4_5;
7103 parse_func = djangosha1_parse_hash;
7104 sort_by_digest = sort_by_digest_4_5;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_PRECOMPUTE_INIT
7107 | OPTI_TYPE_PRECOMPUTE_MERKLE
7108 | OPTI_TYPE_EARLY_SKIP
7109 | OPTI_TYPE_NOT_ITERATED
7110 | OPTI_TYPE_PREPENDED_SALT
7111 | OPTI_TYPE_RAW_HASH;
7112 dgst_pos0 = 3;
7113 dgst_pos1 = 4;
7114 dgst_pos2 = 2;
7115 dgst_pos3 = 1;
7116 break;
7117
7118 case 130: hash_type = HASH_TYPE_SHA1;
7119 salt_type = SALT_TYPE_INTERN;
7120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7121 opts_type = OPTS_TYPE_PT_GENERATE_BE
7122 | OPTS_TYPE_PT_UNICODE
7123 | OPTS_TYPE_ST_ADD80
7124 | OPTS_TYPE_ST_ADDBITS15;
7125 kern_type = KERN_TYPE_SHA1_PWUSLT;
7126 dgst_size = DGST_SIZE_4_5;
7127 parse_func = sha1s_parse_hash;
7128 sort_by_digest = sort_by_digest_4_5;
7129 opti_type = OPTI_TYPE_ZERO_BYTE
7130 | OPTI_TYPE_PRECOMPUTE_INIT
7131 | OPTI_TYPE_PRECOMPUTE_MERKLE
7132 | OPTI_TYPE_EARLY_SKIP
7133 | OPTI_TYPE_NOT_ITERATED
7134 | OPTI_TYPE_APPENDED_SALT
7135 | OPTI_TYPE_RAW_HASH;
7136 dgst_pos0 = 3;
7137 dgst_pos1 = 4;
7138 dgst_pos2 = 2;
7139 dgst_pos3 = 1;
7140 break;
7141
7142 case 131: hash_type = HASH_TYPE_SHA1;
7143 salt_type = SALT_TYPE_EMBEDDED;
7144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7145 opts_type = OPTS_TYPE_PT_GENERATE_BE
7146 | OPTS_TYPE_PT_UNICODE
7147 | OPTS_TYPE_PT_UPPER
7148 | OPTS_TYPE_ST_ADD80
7149 | OPTS_TYPE_ST_ADDBITS15
7150 | OPTS_TYPE_ST_HEX;
7151 kern_type = KERN_TYPE_SHA1_PWUSLT;
7152 dgst_size = DGST_SIZE_4_5;
7153 parse_func = mssql2000_parse_hash;
7154 sort_by_digest = sort_by_digest_4_5;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_APPENDED_SALT
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 132: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_EMBEDDED;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_PT_UNICODE
7173 | OPTS_TYPE_ST_ADD80
7174 | OPTS_TYPE_ST_ADDBITS15
7175 | OPTS_TYPE_ST_HEX;
7176 kern_type = KERN_TYPE_SHA1_PWUSLT;
7177 dgst_size = DGST_SIZE_4_5;
7178 parse_func = mssql2005_parse_hash;
7179 sort_by_digest = sort_by_digest_4_5;
7180 opti_type = OPTI_TYPE_ZERO_BYTE
7181 | OPTI_TYPE_PRECOMPUTE_INIT
7182 | OPTI_TYPE_PRECOMPUTE_MERKLE
7183 | OPTI_TYPE_EARLY_SKIP
7184 | OPTI_TYPE_NOT_ITERATED
7185 | OPTI_TYPE_APPENDED_SALT
7186 | OPTI_TYPE_RAW_HASH;
7187 dgst_pos0 = 3;
7188 dgst_pos1 = 4;
7189 dgst_pos2 = 2;
7190 dgst_pos3 = 1;
7191 break;
7192
7193 case 133: hash_type = HASH_TYPE_SHA1;
7194 salt_type = SALT_TYPE_EMBEDDED;
7195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7196 opts_type = OPTS_TYPE_PT_GENERATE_BE
7197 | OPTS_TYPE_PT_UNICODE
7198 | OPTS_TYPE_ST_ADD80
7199 | OPTS_TYPE_ST_ADDBITS15;
7200 kern_type = KERN_TYPE_SHA1_PWUSLT;
7201 dgst_size = DGST_SIZE_4_5;
7202 parse_func = peoplesoft_parse_hash;
7203 sort_by_digest = sort_by_digest_4_5;
7204 opti_type = OPTI_TYPE_ZERO_BYTE
7205 | OPTI_TYPE_PRECOMPUTE_INIT
7206 | OPTI_TYPE_PRECOMPUTE_MERKLE
7207 | OPTI_TYPE_EARLY_SKIP
7208 | OPTI_TYPE_NOT_ITERATED
7209 | OPTI_TYPE_APPENDED_SALT
7210 | OPTI_TYPE_RAW_HASH;
7211 dgst_pos0 = 3;
7212 dgst_pos1 = 4;
7213 dgst_pos2 = 2;
7214 dgst_pos3 = 1;
7215 break;
7216
7217 case 140: hash_type = HASH_TYPE_SHA1;
7218 salt_type = SALT_TYPE_INTERN;
7219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7220 opts_type = OPTS_TYPE_PT_GENERATE_BE
7221 | OPTS_TYPE_PT_ADD80
7222 | OPTS_TYPE_PT_ADDBITS15
7223 | OPTS_TYPE_PT_UNICODE;
7224 kern_type = KERN_TYPE_SHA1_SLTPWU;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = sha1s_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_PRECOMPUTE_MERKLE
7231 | OPTI_TYPE_EARLY_SKIP
7232 | OPTI_TYPE_NOT_ITERATED
7233 | OPTI_TYPE_PREPENDED_SALT
7234 | OPTI_TYPE_RAW_HASH;
7235 dgst_pos0 = 3;
7236 dgst_pos1 = 4;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 141: hash_type = HASH_TYPE_SHA1;
7242 salt_type = SALT_TYPE_EMBEDDED;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_BE
7245 | OPTS_TYPE_PT_ADD80
7246 | OPTS_TYPE_PT_ADDBITS15
7247 | OPTS_TYPE_PT_UNICODE
7248 | OPTS_TYPE_ST_BASE64;
7249 kern_type = KERN_TYPE_SHA1_SLTPWU;
7250 dgst_size = DGST_SIZE_4_5;
7251 parse_func = episerver_parse_hash;
7252 sort_by_digest = sort_by_digest_4_5;
7253 opti_type = OPTI_TYPE_ZERO_BYTE
7254 | OPTI_TYPE_PRECOMPUTE_INIT
7255 | OPTI_TYPE_PRECOMPUTE_MERKLE
7256 | OPTI_TYPE_EARLY_SKIP
7257 | OPTI_TYPE_NOT_ITERATED
7258 | OPTI_TYPE_PREPENDED_SALT
7259 | OPTI_TYPE_RAW_HASH;
7260 dgst_pos0 = 3;
7261 dgst_pos1 = 4;
7262 dgst_pos2 = 2;
7263 dgst_pos3 = 1;
7264 break;
7265
7266 case 150: hash_type = HASH_TYPE_SHA1;
7267 salt_type = SALT_TYPE_INTERN;
7268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7269 opts_type = OPTS_TYPE_PT_GENERATE_BE
7270 | OPTS_TYPE_ST_ADD80
7271 | OPTS_TYPE_ST_ADDBITS15;
7272 kern_type = KERN_TYPE_HMACSHA1_PW;
7273 dgst_size = DGST_SIZE_4_5;
7274 parse_func = hmacsha1_parse_hash;
7275 sort_by_digest = sort_by_digest_4_5;
7276 opti_type = OPTI_TYPE_ZERO_BYTE
7277 | OPTI_TYPE_NOT_ITERATED;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 160: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_INTERN;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15;
7290 kern_type = KERN_TYPE_HMACSHA1_SLT;
7291 dgst_size = DGST_SIZE_4_5;
7292 parse_func = hmacsha1_parse_hash;
7293 sort_by_digest = sort_by_digest_4_5;
7294 opti_type = OPTI_TYPE_ZERO_BYTE
7295 | OPTI_TYPE_NOT_ITERATED;
7296 dgst_pos0 = 3;
7297 dgst_pos1 = 4;
7298 dgst_pos2 = 2;
7299 dgst_pos3 = 1;
7300 break;
7301
7302 case 190: hash_type = HASH_TYPE_SHA1;
7303 salt_type = SALT_TYPE_NONE;
7304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7305 opts_type = OPTS_TYPE_PT_GENERATE_BE
7306 | OPTS_TYPE_PT_ADD80
7307 | OPTS_TYPE_PT_ADDBITS15;
7308 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7309 dgst_size = DGST_SIZE_4_5;
7310 parse_func = sha1linkedin_parse_hash;
7311 sort_by_digest = sort_by_digest_4_5;
7312 opti_type = OPTI_TYPE_ZERO_BYTE
7313 | OPTI_TYPE_PRECOMPUTE_INIT
7314 | OPTI_TYPE_EARLY_SKIP
7315 | OPTI_TYPE_NOT_ITERATED
7316 | OPTI_TYPE_NOT_SALTED;
7317 dgst_pos0 = 0;
7318 dgst_pos1 = 4;
7319 dgst_pos2 = 3;
7320 dgst_pos3 = 2;
7321 break;
7322
7323 case 200: hash_type = HASH_TYPE_MYSQL;
7324 salt_type = SALT_TYPE_NONE;
7325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7326 opts_type = 0;
7327 kern_type = KERN_TYPE_MYSQL;
7328 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7329 parse_func = mysql323_parse_hash;
7330 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7331 opti_type = OPTI_TYPE_ZERO_BYTE;
7332 dgst_pos0 = 0;
7333 dgst_pos1 = 1;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 3;
7336 break;
7337
7338 case 300: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_NONE;
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_MYSQL41;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = sha1_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_NOT_SALTED;
7354 dgst_pos0 = 3;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 2;
7357 dgst_pos3 = 1;
7358 break;
7359
7360 case 400: hash_type = HASH_TYPE_MD5;
7361 salt_type = SALT_TYPE_EMBEDDED;
7362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7364 kern_type = KERN_TYPE_PHPASS;
7365 dgst_size = DGST_SIZE_4_4;
7366 parse_func = phpass_parse_hash;
7367 sort_by_digest = sort_by_digest_4_4;
7368 opti_type = OPTI_TYPE_ZERO_BYTE;
7369 dgst_pos0 = 0;
7370 dgst_pos1 = 1;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 3;
7373 break;
7374
7375 case 500: hash_type = HASH_TYPE_MD5;
7376 salt_type = SALT_TYPE_EMBEDDED;
7377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7379 kern_type = KERN_TYPE_MD5CRYPT;
7380 dgst_size = DGST_SIZE_4_4;
7381 parse_func = md5crypt_parse_hash;
7382 sort_by_digest = sort_by_digest_4_4;
7383 opti_type = OPTI_TYPE_ZERO_BYTE;
7384 dgst_pos0 = 0;
7385 dgst_pos1 = 1;
7386 dgst_pos2 = 2;
7387 dgst_pos3 = 3;
7388 break;
7389
7390 case 501: hash_type = HASH_TYPE_MD5;
7391 salt_type = SALT_TYPE_EMBEDDED;
7392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7393 opts_type = OPTS_TYPE_PT_GENERATE_LE
7394 | OPTS_TYPE_HASH_COPY;
7395 kern_type = KERN_TYPE_MD5CRYPT;
7396 dgst_size = DGST_SIZE_4_4;
7397 parse_func = juniper_parse_hash;
7398 sort_by_digest = sort_by_digest_4_4;
7399 opti_type = OPTI_TYPE_ZERO_BYTE;
7400 dgst_pos0 = 0;
7401 dgst_pos1 = 1;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 3;
7404 break;
7405
7406 case 900: hash_type = HASH_TYPE_MD4;
7407 salt_type = SALT_TYPE_NONE;
7408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_LE
7410 | OPTS_TYPE_PT_ADD80
7411 | OPTS_TYPE_PT_ADDBITS14;
7412 kern_type = KERN_TYPE_MD4;
7413 dgst_size = DGST_SIZE_4_4;
7414 parse_func = md4_parse_hash;
7415 sort_by_digest = sort_by_digest_4_4;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_MEET_IN_MIDDLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_NOT_SALTED
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 0;
7425 dgst_pos1 = 3;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 1000: hash_type = HASH_TYPE_MD4;
7431 salt_type = SALT_TYPE_NONE;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_LE
7434 | OPTS_TYPE_PT_ADD80
7435 | OPTS_TYPE_PT_ADDBITS14
7436 | OPTS_TYPE_PT_UNICODE;
7437 kern_type = KERN_TYPE_MD4_PWU;
7438 dgst_size = DGST_SIZE_4_4;
7439 parse_func = md4_parse_hash;
7440 sort_by_digest = sort_by_digest_4_4;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_MEET_IN_MIDDLE
7445 | OPTI_TYPE_EARLY_SKIP
7446 | OPTI_TYPE_NOT_ITERATED
7447 | OPTI_TYPE_NOT_SALTED
7448 | OPTI_TYPE_RAW_HASH;
7449 dgst_pos0 = 0;
7450 dgst_pos1 = 3;
7451 dgst_pos2 = 2;
7452 dgst_pos3 = 1;
7453 break;
7454
7455 case 1100: hash_type = HASH_TYPE_MD4;
7456 salt_type = SALT_TYPE_INTERN;
7457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7458 opts_type = OPTS_TYPE_PT_GENERATE_LE
7459 | OPTS_TYPE_PT_ADD80
7460 | OPTS_TYPE_PT_ADDBITS14
7461 | OPTS_TYPE_PT_UNICODE
7462 | OPTS_TYPE_ST_ADD80
7463 | OPTS_TYPE_ST_UNICODE
7464 | OPTS_TYPE_ST_LOWER;
7465 kern_type = KERN_TYPE_MD44_PWUSLT;
7466 dgst_size = DGST_SIZE_4_4;
7467 parse_func = dcc_parse_hash;
7468 sort_by_digest = sort_by_digest_4_4;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_PRECOMPUTE_INIT
7471 | OPTI_TYPE_PRECOMPUTE_MERKLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED;
7474 dgst_pos0 = 0;
7475 dgst_pos1 = 3;
7476 dgst_pos2 = 2;
7477 dgst_pos3 = 1;
7478 break;
7479
7480 case 1400: hash_type = HASH_TYPE_SHA256;
7481 salt_type = SALT_TYPE_NONE;
7482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7483 opts_type = OPTS_TYPE_PT_GENERATE_BE
7484 | OPTS_TYPE_PT_ADD80
7485 | OPTS_TYPE_PT_ADDBITS15;
7486 kern_type = KERN_TYPE_SHA256;
7487 dgst_size = DGST_SIZE_4_8;
7488 parse_func = sha256_parse_hash;
7489 sort_by_digest = sort_by_digest_4_8;
7490 opti_type = OPTI_TYPE_ZERO_BYTE
7491 | OPTI_TYPE_PRECOMPUTE_INIT
7492 | OPTI_TYPE_PRECOMPUTE_MERKLE
7493 | OPTI_TYPE_EARLY_SKIP
7494 | OPTI_TYPE_NOT_ITERATED
7495 | OPTI_TYPE_NOT_SALTED
7496 | OPTI_TYPE_RAW_HASH;
7497 dgst_pos0 = 3;
7498 dgst_pos1 = 7;
7499 dgst_pos2 = 2;
7500 dgst_pos3 = 6;
7501 break;
7502
7503 case 1410: hash_type = HASH_TYPE_SHA256;
7504 salt_type = SALT_TYPE_INTERN;
7505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7506 opts_type = OPTS_TYPE_PT_GENERATE_BE
7507 | OPTS_TYPE_ST_ADD80
7508 | OPTS_TYPE_ST_ADDBITS15;
7509 kern_type = KERN_TYPE_SHA256_PWSLT;
7510 dgst_size = DGST_SIZE_4_8;
7511 parse_func = sha256s_parse_hash;
7512 sort_by_digest = sort_by_digest_4_8;
7513 opti_type = OPTI_TYPE_ZERO_BYTE
7514 | OPTI_TYPE_PRECOMPUTE_INIT
7515 | OPTI_TYPE_PRECOMPUTE_MERKLE
7516 | OPTI_TYPE_EARLY_SKIP
7517 | OPTI_TYPE_NOT_ITERATED
7518 | OPTI_TYPE_APPENDED_SALT
7519 | OPTI_TYPE_RAW_HASH;
7520 dgst_pos0 = 3;
7521 dgst_pos1 = 7;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 6;
7524 break;
7525
7526 case 1420: hash_type = HASH_TYPE_SHA256;
7527 salt_type = SALT_TYPE_INTERN;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_BE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS15;
7532 kern_type = KERN_TYPE_SHA256_SLTPW;
7533 dgst_size = DGST_SIZE_4_8;
7534 parse_func = sha256s_parse_hash;
7535 sort_by_digest = sort_by_digest_4_8;
7536 opti_type = OPTI_TYPE_ZERO_BYTE
7537 | OPTI_TYPE_PRECOMPUTE_INIT
7538 | OPTI_TYPE_PRECOMPUTE_MERKLE
7539 | OPTI_TYPE_EARLY_SKIP
7540 | OPTI_TYPE_NOT_ITERATED
7541 | OPTI_TYPE_PREPENDED_SALT
7542 | OPTI_TYPE_RAW_HASH;
7543 dgst_pos0 = 3;
7544 dgst_pos1 = 7;
7545 dgst_pos2 = 2;
7546 dgst_pos3 = 6;
7547 break;
7548
7549 case 1421: hash_type = HASH_TYPE_SHA256;
7550 salt_type = SALT_TYPE_EMBEDDED;
7551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7552 opts_type = OPTS_TYPE_PT_GENERATE_BE
7553 | OPTS_TYPE_PT_ADD80
7554 | OPTS_TYPE_PT_ADDBITS15;
7555 kern_type = KERN_TYPE_SHA256_SLTPW;
7556 dgst_size = DGST_SIZE_4_8;
7557 parse_func = hmailserver_parse_hash;
7558 sort_by_digest = sort_by_digest_4_8;
7559 opti_type = OPTI_TYPE_ZERO_BYTE
7560 | OPTI_TYPE_PRECOMPUTE_INIT
7561 | OPTI_TYPE_PRECOMPUTE_MERKLE
7562 | OPTI_TYPE_EARLY_SKIP
7563 | OPTI_TYPE_NOT_ITERATED
7564 | OPTI_TYPE_PREPENDED_SALT
7565 | OPTI_TYPE_RAW_HASH;
7566 dgst_pos0 = 3;
7567 dgst_pos1 = 7;
7568 dgst_pos2 = 2;
7569 dgst_pos3 = 6;
7570 break;
7571
7572 case 1430: hash_type = HASH_TYPE_SHA256;
7573 salt_type = SALT_TYPE_INTERN;
7574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7575 opts_type = OPTS_TYPE_PT_GENERATE_BE
7576 | OPTS_TYPE_PT_UNICODE
7577 | OPTS_TYPE_ST_ADD80
7578 | OPTS_TYPE_ST_ADDBITS15;
7579 kern_type = KERN_TYPE_SHA256_PWUSLT;
7580 dgst_size = DGST_SIZE_4_8;
7581 parse_func = sha256s_parse_hash;
7582 sort_by_digest = sort_by_digest_4_8;
7583 opti_type = OPTI_TYPE_ZERO_BYTE
7584 | OPTI_TYPE_PRECOMPUTE_INIT
7585 | OPTI_TYPE_PRECOMPUTE_MERKLE
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_APPENDED_SALT
7589 | OPTI_TYPE_RAW_HASH;
7590 dgst_pos0 = 3;
7591 dgst_pos1 = 7;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 6;
7594 break;
7595
7596 case 1440: hash_type = HASH_TYPE_SHA256;
7597 salt_type = SALT_TYPE_INTERN;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_BE
7600 | OPTS_TYPE_PT_ADD80
7601 | OPTS_TYPE_PT_ADDBITS15
7602 | OPTS_TYPE_PT_UNICODE;
7603 kern_type = KERN_TYPE_SHA256_SLTPWU;
7604 dgst_size = DGST_SIZE_4_8;
7605 parse_func = sha256s_parse_hash;
7606 sort_by_digest = sort_by_digest_4_8;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_PREPENDED_SALT
7613 | OPTI_TYPE_RAW_HASH;
7614 dgst_pos0 = 3;
7615 dgst_pos1 = 7;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 6;
7618 break;
7619
7620 case 1441: hash_type = HASH_TYPE_SHA256;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_BE
7624 | OPTS_TYPE_PT_ADD80
7625 | OPTS_TYPE_PT_ADDBITS15
7626 | OPTS_TYPE_PT_UNICODE
7627 | OPTS_TYPE_ST_BASE64;
7628 kern_type = KERN_TYPE_SHA256_SLTPWU;
7629 dgst_size = DGST_SIZE_4_8;
7630 parse_func = episerver4_parse_hash;
7631 sort_by_digest = sort_by_digest_4_8;
7632 opti_type = OPTI_TYPE_ZERO_BYTE
7633 | OPTI_TYPE_PRECOMPUTE_INIT
7634 | OPTI_TYPE_PRECOMPUTE_MERKLE
7635 | OPTI_TYPE_EARLY_SKIP
7636 | OPTI_TYPE_NOT_ITERATED
7637 | OPTI_TYPE_PREPENDED_SALT
7638 | OPTI_TYPE_RAW_HASH;
7639 dgst_pos0 = 3;
7640 dgst_pos1 = 7;
7641 dgst_pos2 = 2;
7642 dgst_pos3 = 6;
7643 break;
7644
7645 case 1450: hash_type = HASH_TYPE_SHA256;
7646 salt_type = SALT_TYPE_INTERN;
7647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7648 opts_type = OPTS_TYPE_PT_GENERATE_BE
7649 | OPTS_TYPE_ST_ADD80;
7650 kern_type = KERN_TYPE_HMACSHA256_PW;
7651 dgst_size = DGST_SIZE_4_8;
7652 parse_func = hmacsha256_parse_hash;
7653 sort_by_digest = sort_by_digest_4_8;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_NOT_ITERATED;
7656 dgst_pos0 = 3;
7657 dgst_pos1 = 7;
7658 dgst_pos2 = 2;
7659 dgst_pos3 = 6;
7660 break;
7661
7662 case 1460: hash_type = HASH_TYPE_SHA256;
7663 salt_type = SALT_TYPE_INTERN;
7664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7665 opts_type = OPTS_TYPE_PT_GENERATE_BE
7666 | OPTS_TYPE_PT_ADD80
7667 | OPTS_TYPE_PT_ADDBITS15;
7668 kern_type = KERN_TYPE_HMACSHA256_SLT;
7669 dgst_size = DGST_SIZE_4_8;
7670 parse_func = hmacsha256_parse_hash;
7671 sort_by_digest = sort_by_digest_4_8;
7672 opti_type = OPTI_TYPE_ZERO_BYTE
7673 | OPTI_TYPE_NOT_ITERATED;
7674 dgst_pos0 = 3;
7675 dgst_pos1 = 7;
7676 dgst_pos2 = 2;
7677 dgst_pos3 = 6;
7678 break;
7679
7680 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7681 salt_type = SALT_TYPE_EMBEDDED;
7682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7683 opts_type = OPTS_TYPE_PT_GENERATE_LE
7684 | OPTS_TYPE_PT_BITSLICE;
7685 kern_type = KERN_TYPE_DESCRYPT;
7686 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7687 parse_func = descrypt_parse_hash;
7688 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7691 dgst_pos0 = 0;
7692 dgst_pos1 = 1;
7693 dgst_pos2 = 2;
7694 dgst_pos3 = 3;
7695 break;
7696
7697 case 1600: hash_type = HASH_TYPE_MD5;
7698 salt_type = SALT_TYPE_EMBEDDED;
7699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7701 kern_type = KERN_TYPE_APR1CRYPT;
7702 dgst_size = DGST_SIZE_4_4;
7703 parse_func = md5apr1_parse_hash;
7704 sort_by_digest = sort_by_digest_4_4;
7705 opti_type = OPTI_TYPE_ZERO_BYTE;
7706 dgst_pos0 = 0;
7707 dgst_pos1 = 1;
7708 dgst_pos2 = 2;
7709 dgst_pos3 = 3;
7710 break;
7711
7712 case 1700: hash_type = HASH_TYPE_SHA512;
7713 salt_type = SALT_TYPE_NONE;
7714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7715 opts_type = OPTS_TYPE_PT_GENERATE_BE
7716 | OPTS_TYPE_PT_ADD80
7717 | OPTS_TYPE_PT_ADDBITS15;
7718 kern_type = KERN_TYPE_SHA512;
7719 dgst_size = DGST_SIZE_8_8;
7720 parse_func = sha512_parse_hash;
7721 sort_by_digest = sort_by_digest_8_8;
7722 opti_type = OPTI_TYPE_ZERO_BYTE
7723 | OPTI_TYPE_PRECOMPUTE_INIT
7724 | OPTI_TYPE_PRECOMPUTE_MERKLE
7725 | OPTI_TYPE_EARLY_SKIP
7726 | OPTI_TYPE_NOT_ITERATED
7727 | OPTI_TYPE_NOT_SALTED
7728 | OPTI_TYPE_RAW_HASH;
7729 dgst_pos0 = 14;
7730 dgst_pos1 = 15;
7731 dgst_pos2 = 6;
7732 dgst_pos3 = 7;
7733 break;
7734
7735 case 1710: hash_type = HASH_TYPE_SHA512;
7736 salt_type = SALT_TYPE_INTERN;
7737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7738 opts_type = OPTS_TYPE_PT_GENERATE_BE
7739 | OPTS_TYPE_ST_ADD80
7740 | OPTS_TYPE_ST_ADDBITS15;
7741 kern_type = KERN_TYPE_SHA512_PWSLT;
7742 dgst_size = DGST_SIZE_8_8;
7743 parse_func = sha512s_parse_hash;
7744 sort_by_digest = sort_by_digest_8_8;
7745 opti_type = OPTI_TYPE_ZERO_BYTE
7746 | OPTI_TYPE_PRECOMPUTE_INIT
7747 | OPTI_TYPE_PRECOMPUTE_MERKLE
7748 | OPTI_TYPE_EARLY_SKIP
7749 | OPTI_TYPE_NOT_ITERATED
7750 | OPTI_TYPE_APPENDED_SALT
7751 | OPTI_TYPE_RAW_HASH;
7752 dgst_pos0 = 14;
7753 dgst_pos1 = 15;
7754 dgst_pos2 = 6;
7755 dgst_pos3 = 7;
7756 break;
7757
7758 case 1711: hash_type = HASH_TYPE_SHA512;
7759 salt_type = SALT_TYPE_EMBEDDED;
7760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7761 opts_type = OPTS_TYPE_PT_GENERATE_BE
7762 | OPTS_TYPE_ST_ADD80
7763 | OPTS_TYPE_ST_ADDBITS15;
7764 kern_type = KERN_TYPE_SHA512_PWSLT;
7765 dgst_size = DGST_SIZE_8_8;
7766 parse_func = sha512b64s_parse_hash;
7767 sort_by_digest = sort_by_digest_8_8;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED
7773 | OPTI_TYPE_APPENDED_SALT
7774 | OPTI_TYPE_RAW_HASH;
7775 dgst_pos0 = 14;
7776 dgst_pos1 = 15;
7777 dgst_pos2 = 6;
7778 dgst_pos3 = 7;
7779 break;
7780
7781 case 1720: hash_type = HASH_TYPE_SHA512;
7782 salt_type = SALT_TYPE_INTERN;
7783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_BE
7785 | OPTS_TYPE_PT_ADD80
7786 | OPTS_TYPE_PT_ADDBITS15;
7787 kern_type = KERN_TYPE_SHA512_SLTPW;
7788 dgst_size = DGST_SIZE_8_8;
7789 parse_func = sha512s_parse_hash;
7790 sort_by_digest = sort_by_digest_8_8;
7791 opti_type = OPTI_TYPE_ZERO_BYTE
7792 | OPTI_TYPE_PRECOMPUTE_INIT
7793 | OPTI_TYPE_PRECOMPUTE_MERKLE
7794 | OPTI_TYPE_EARLY_SKIP
7795 | OPTI_TYPE_NOT_ITERATED
7796 | OPTI_TYPE_PREPENDED_SALT
7797 | OPTI_TYPE_RAW_HASH;
7798 dgst_pos0 = 14;
7799 dgst_pos1 = 15;
7800 dgst_pos2 = 6;
7801 dgst_pos3 = 7;
7802 break;
7803
7804 case 1722: hash_type = HASH_TYPE_SHA512;
7805 salt_type = SALT_TYPE_EMBEDDED;
7806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_BE
7808 | OPTS_TYPE_PT_ADD80
7809 | OPTS_TYPE_PT_ADDBITS15
7810 | OPTS_TYPE_ST_HEX;
7811 kern_type = KERN_TYPE_SHA512_SLTPW;
7812 dgst_size = DGST_SIZE_8_8;
7813 parse_func = osx512_parse_hash;
7814 sort_by_digest = sort_by_digest_8_8;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_PRECOMPUTE_INIT
7817 | OPTI_TYPE_PRECOMPUTE_MERKLE
7818 | OPTI_TYPE_EARLY_SKIP
7819 | OPTI_TYPE_NOT_ITERATED
7820 | OPTI_TYPE_PREPENDED_SALT
7821 | OPTI_TYPE_RAW_HASH;
7822 dgst_pos0 = 14;
7823 dgst_pos1 = 15;
7824 dgst_pos2 = 6;
7825 dgst_pos3 = 7;
7826 break;
7827
7828 case 1730: hash_type = HASH_TYPE_SHA512;
7829 salt_type = SALT_TYPE_INTERN;
7830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7831 opts_type = OPTS_TYPE_PT_GENERATE_BE
7832 | OPTS_TYPE_PT_UNICODE
7833 | OPTS_TYPE_ST_ADD80
7834 | OPTS_TYPE_ST_ADDBITS15;
7835 kern_type = KERN_TYPE_SHA512_PWSLTU;
7836 dgst_size = DGST_SIZE_8_8;
7837 parse_func = sha512s_parse_hash;
7838 sort_by_digest = sort_by_digest_8_8;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_PRECOMPUTE_MERKLE
7842 | OPTI_TYPE_EARLY_SKIP
7843 | OPTI_TYPE_NOT_ITERATED
7844 | OPTI_TYPE_APPENDED_SALT
7845 | OPTI_TYPE_RAW_HASH;
7846 dgst_pos0 = 14;
7847 dgst_pos1 = 15;
7848 dgst_pos2 = 6;
7849 dgst_pos3 = 7;
7850 break;
7851
7852 case 1731: hash_type = HASH_TYPE_SHA512;
7853 salt_type = SALT_TYPE_EMBEDDED;
7854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_BE
7856 | OPTS_TYPE_PT_UNICODE
7857 | OPTS_TYPE_ST_ADD80
7858 | OPTS_TYPE_ST_ADDBITS15
7859 | OPTS_TYPE_ST_HEX;
7860 kern_type = KERN_TYPE_SHA512_PWSLTU;
7861 dgst_size = DGST_SIZE_8_8;
7862 parse_func = mssql2012_parse_hash;
7863 sort_by_digest = sort_by_digest_8_8;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_EARLY_SKIP
7868 | OPTI_TYPE_NOT_ITERATED
7869 | OPTI_TYPE_APPENDED_SALT
7870 | OPTI_TYPE_RAW_HASH;
7871 dgst_pos0 = 14;
7872 dgst_pos1 = 15;
7873 dgst_pos2 = 6;
7874 dgst_pos3 = 7;
7875 break;
7876
7877 case 1740: hash_type = HASH_TYPE_SHA512;
7878 salt_type = SALT_TYPE_INTERN;
7879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7880 opts_type = OPTS_TYPE_PT_GENERATE_BE
7881 | OPTS_TYPE_PT_ADD80
7882 | OPTS_TYPE_PT_ADDBITS15
7883 | OPTS_TYPE_PT_UNICODE;
7884 kern_type = KERN_TYPE_SHA512_SLTPWU;
7885 dgst_size = DGST_SIZE_8_8;
7886 parse_func = sha512s_parse_hash;
7887 sort_by_digest = sort_by_digest_8_8;
7888 opti_type = OPTI_TYPE_ZERO_BYTE
7889 | OPTI_TYPE_PRECOMPUTE_INIT
7890 | OPTI_TYPE_PRECOMPUTE_MERKLE
7891 | OPTI_TYPE_EARLY_SKIP
7892 | OPTI_TYPE_NOT_ITERATED
7893 | OPTI_TYPE_PREPENDED_SALT
7894 | OPTI_TYPE_RAW_HASH;
7895 dgst_pos0 = 14;
7896 dgst_pos1 = 15;
7897 dgst_pos2 = 6;
7898 dgst_pos3 = 7;
7899 break;
7900
7901 case 1750: hash_type = HASH_TYPE_SHA512;
7902 salt_type = SALT_TYPE_INTERN;
7903 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7904 opts_type = OPTS_TYPE_PT_GENERATE_BE
7905 | OPTS_TYPE_ST_ADD80;
7906 kern_type = KERN_TYPE_HMACSHA512_PW;
7907 dgst_size = DGST_SIZE_8_8;
7908 parse_func = hmacsha512_parse_hash;
7909 sort_by_digest = sort_by_digest_8_8;
7910 opti_type = OPTI_TYPE_ZERO_BYTE
7911 | OPTI_TYPE_NOT_ITERATED;
7912 dgst_pos0 = 14;
7913 dgst_pos1 = 15;
7914 dgst_pos2 = 6;
7915 dgst_pos3 = 7;
7916 break;
7917
7918 case 1760: hash_type = HASH_TYPE_SHA512;
7919 salt_type = SALT_TYPE_INTERN;
7920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7921 opts_type = OPTS_TYPE_PT_GENERATE_BE
7922 | OPTS_TYPE_PT_ADD80
7923 | OPTS_TYPE_PT_ADDBITS15;
7924 kern_type = KERN_TYPE_HMACSHA512_SLT;
7925 dgst_size = DGST_SIZE_8_8;
7926 parse_func = hmacsha512_parse_hash;
7927 sort_by_digest = sort_by_digest_8_8;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_NOT_ITERATED;
7930 dgst_pos0 = 14;
7931 dgst_pos1 = 15;
7932 dgst_pos2 = 6;
7933 dgst_pos3 = 7;
7934 break;
7935
7936 case 1800: hash_type = HASH_TYPE_SHA512;
7937 salt_type = SALT_TYPE_EMBEDDED;
7938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7940 kern_type = KERN_TYPE_SHA512CRYPT;
7941 dgst_size = DGST_SIZE_8_8;
7942 parse_func = sha512crypt_parse_hash;
7943 sort_by_digest = sort_by_digest_8_8;
7944 opti_type = OPTI_TYPE_ZERO_BYTE;
7945 dgst_pos0 = 0;
7946 dgst_pos1 = 1;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 3;
7949 break;
7950
7951 case 2100: hash_type = HASH_TYPE_DCC2;
7952 salt_type = SALT_TYPE_EMBEDDED;
7953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_LOWER
7956 | OPTS_TYPE_ST_UNICODE;
7957 kern_type = KERN_TYPE_DCC2;
7958 dgst_size = DGST_SIZE_4_4;
7959 parse_func = dcc2_parse_hash;
7960 sort_by_digest = sort_by_digest_4_4;
7961 opti_type = OPTI_TYPE_ZERO_BYTE;
7962 dgst_pos0 = 0;
7963 dgst_pos1 = 1;
7964 dgst_pos2 = 2;
7965 dgst_pos3 = 3;
7966 break;
7967
7968 case 2400: hash_type = HASH_TYPE_MD5;
7969 salt_type = SALT_TYPE_NONE;
7970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7971 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7972 kern_type = KERN_TYPE_MD5PIX;
7973 dgst_size = DGST_SIZE_4_4;
7974 parse_func = md5pix_parse_hash;
7975 sort_by_digest = sort_by_digest_4_4;
7976 opti_type = OPTI_TYPE_ZERO_BYTE
7977 | OPTI_TYPE_PRECOMPUTE_INIT
7978 | OPTI_TYPE_PRECOMPUTE_MERKLE
7979 | OPTI_TYPE_EARLY_SKIP
7980 | OPTI_TYPE_NOT_ITERATED
7981 | OPTI_TYPE_NOT_SALTED;
7982 dgst_pos0 = 0;
7983 dgst_pos1 = 3;
7984 dgst_pos2 = 2;
7985 dgst_pos3 = 1;
7986 break;
7987
7988 case 2410: hash_type = HASH_TYPE_MD5;
7989 salt_type = SALT_TYPE_INTERN;
7990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7992 kern_type = KERN_TYPE_MD5ASA;
7993 dgst_size = DGST_SIZE_4_4;
7994 parse_func = md5asa_parse_hash;
7995 sort_by_digest = sort_by_digest_4_4;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_PRECOMPUTE_INIT
7998 | OPTI_TYPE_PRECOMPUTE_MERKLE
7999 | OPTI_TYPE_EARLY_SKIP
8000 | OPTI_TYPE_NOT_ITERATED;
8001 dgst_pos0 = 0;
8002 dgst_pos1 = 3;
8003 dgst_pos2 = 2;
8004 dgst_pos3 = 1;
8005 break;
8006
8007 case 2500: hash_type = HASH_TYPE_WPA;
8008 salt_type = SALT_TYPE_EMBEDDED;
8009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8010 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8011 kern_type = KERN_TYPE_WPA;
8012 dgst_size = DGST_SIZE_4_4;
8013 parse_func = wpa_parse_hash;
8014 sort_by_digest = sort_by_digest_4_4;
8015 opti_type = OPTI_TYPE_ZERO_BYTE;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 1;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 3;
8020 break;
8021
8022 case 2600: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_VIRTUAL;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS14
8028 | OPTS_TYPE_ST_ADD80;
8029 kern_type = KERN_TYPE_MD55_PWSLT1;
8030 dgst_size = DGST_SIZE_4_4;
8031 parse_func = md5md5_parse_hash;
8032 sort_by_digest = sort_by_digest_4_4;
8033 opti_type = OPTI_TYPE_ZERO_BYTE
8034 | OPTI_TYPE_PRECOMPUTE_INIT
8035 | OPTI_TYPE_PRECOMPUTE_MERKLE
8036 | OPTI_TYPE_EARLY_SKIP;
8037 dgst_pos0 = 0;
8038 dgst_pos1 = 3;
8039 dgst_pos2 = 2;
8040 dgst_pos3 = 1;
8041 break;
8042
8043 case 2611: hash_type = HASH_TYPE_MD5;
8044 salt_type = SALT_TYPE_INTERN;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_LE
8047 | OPTS_TYPE_PT_ADD80
8048 | OPTS_TYPE_PT_ADDBITS14
8049 | OPTS_TYPE_ST_ADD80;
8050 kern_type = KERN_TYPE_MD55_PWSLT1;
8051 dgst_size = DGST_SIZE_4_4;
8052 parse_func = vb3_parse_hash;
8053 sort_by_digest = sort_by_digest_4_4;
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_INIT
8056 | OPTI_TYPE_PRECOMPUTE_MERKLE
8057 | OPTI_TYPE_EARLY_SKIP;
8058 dgst_pos0 = 0;
8059 dgst_pos1 = 3;
8060 dgst_pos2 = 2;
8061 dgst_pos3 = 1;
8062 break;
8063
8064 case 2612: hash_type = HASH_TYPE_MD5;
8065 salt_type = SALT_TYPE_EMBEDDED;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_LE
8068 | OPTS_TYPE_PT_ADD80
8069 | OPTS_TYPE_PT_ADDBITS14
8070 | OPTS_TYPE_ST_ADD80
8071 | OPTS_TYPE_ST_HEX;
8072 kern_type = KERN_TYPE_MD55_PWSLT1;
8073 dgst_size = DGST_SIZE_4_4;
8074 parse_func = phps_parse_hash;
8075 sort_by_digest = sort_by_digest_4_4;
8076 opti_type = OPTI_TYPE_ZERO_BYTE
8077 | OPTI_TYPE_PRECOMPUTE_INIT
8078 | OPTI_TYPE_PRECOMPUTE_MERKLE
8079 | OPTI_TYPE_EARLY_SKIP;
8080 dgst_pos0 = 0;
8081 dgst_pos1 = 3;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 1;
8084 break;
8085
8086 case 2711: hash_type = HASH_TYPE_MD5;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_LE
8090 | OPTS_TYPE_PT_ADD80
8091 | OPTS_TYPE_PT_ADDBITS14
8092 | OPTS_TYPE_ST_ADD80;
8093 kern_type = KERN_TYPE_MD55_PWSLT2;
8094 dgst_size = DGST_SIZE_4_4;
8095 parse_func = vb30_parse_hash;
8096 sort_by_digest = sort_by_digest_4_4;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_PRECOMPUTE_INIT
8099 | OPTI_TYPE_EARLY_SKIP;
8100 dgst_pos0 = 0;
8101 dgst_pos1 = 3;
8102 dgst_pos2 = 2;
8103 dgst_pos3 = 1;
8104 break;
8105
8106 case 2811: hash_type = HASH_TYPE_MD5;
8107 salt_type = SALT_TYPE_INTERN;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_LE
8110 | OPTS_TYPE_PT_ADD80
8111 | OPTS_TYPE_PT_ADDBITS14;
8112 kern_type = KERN_TYPE_MD55_SLTPW;
8113 dgst_size = DGST_SIZE_4_4;
8114 parse_func = ipb2_parse_hash;
8115 sort_by_digest = sort_by_digest_4_4;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_PRECOMPUTE_INIT
8118 | OPTI_TYPE_EARLY_SKIP;
8119 dgst_pos0 = 0;
8120 dgst_pos1 = 3;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 1;
8123 break;
8124
8125 case 3000: hash_type = HASH_TYPE_LM;
8126 salt_type = SALT_TYPE_NONE;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE
8129 | OPTS_TYPE_PT_UPPER
8130 | OPTS_TYPE_PT_BITSLICE;
8131 kern_type = KERN_TYPE_LM;
8132 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8133 parse_func = lm_parse_hash;
8134 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8137 dgst_pos0 = 0;
8138 dgst_pos1 = 1;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 3;
8141 break;
8142
8143 case 3100: hash_type = HASH_TYPE_ORACLEH;
8144 salt_type = SALT_TYPE_INTERN;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_LE
8147 | OPTS_TYPE_PT_UPPER
8148 | OPTS_TYPE_ST_UPPER;
8149 kern_type = KERN_TYPE_ORACLEH;
8150 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8151 parse_func = oracleh_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8153 opti_type = OPTI_TYPE_ZERO_BYTE;
8154 dgst_pos0 = 0;
8155 dgst_pos1 = 1;
8156 dgst_pos2 = 2;
8157 dgst_pos3 = 3;
8158 break;
8159
8160 case 3200: hash_type = HASH_TYPE_BCRYPT;
8161 salt_type = SALT_TYPE_EMBEDDED;
8162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_LE
8164 | OPTS_TYPE_ST_GENERATE_LE;
8165 kern_type = KERN_TYPE_BCRYPT;
8166 dgst_size = DGST_SIZE_4_6;
8167 parse_func = bcrypt_parse_hash;
8168 sort_by_digest = sort_by_digest_4_6;
8169 opti_type = OPTI_TYPE_ZERO_BYTE;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 1;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 3;
8174 break;
8175
8176 case 3710: hash_type = HASH_TYPE_MD5;
8177 salt_type = SALT_TYPE_INTERN;
8178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE
8180 | OPTS_TYPE_PT_ADD80
8181 | OPTS_TYPE_PT_ADDBITS14;
8182 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8183 dgst_size = DGST_SIZE_4_4;
8184 parse_func = md5s_parse_hash;
8185 sort_by_digest = sort_by_digest_4_4;
8186 opti_type = OPTI_TYPE_ZERO_BYTE
8187 | OPTI_TYPE_PRECOMPUTE_INIT
8188 | OPTI_TYPE_PRECOMPUTE_MERKLE
8189 | OPTI_TYPE_EARLY_SKIP;
8190 dgst_pos0 = 0;
8191 dgst_pos1 = 3;
8192 dgst_pos2 = 2;
8193 dgst_pos3 = 1;
8194 break;
8195
8196 case 3711: hash_type = HASH_TYPE_MD5;
8197 salt_type = SALT_TYPE_EMBEDDED;
8198 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8199 opts_type = OPTS_TYPE_PT_GENERATE_LE
8200 | OPTS_TYPE_PT_ADD80
8201 | OPTS_TYPE_PT_ADDBITS14;
8202 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8203 dgst_size = DGST_SIZE_4_4;
8204 parse_func = mediawiki_b_parse_hash;
8205 sort_by_digest = sort_by_digest_4_4;
8206 opti_type = OPTI_TYPE_ZERO_BYTE
8207 | OPTI_TYPE_PRECOMPUTE_INIT
8208 | OPTI_TYPE_PRECOMPUTE_MERKLE
8209 | OPTI_TYPE_EARLY_SKIP;
8210 dgst_pos0 = 0;
8211 dgst_pos1 = 3;
8212 dgst_pos2 = 2;
8213 dgst_pos3 = 1;
8214 break;
8215
8216 case 3800: hash_type = HASH_TYPE_MD5;
8217 salt_type = SALT_TYPE_INTERN;
8218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8219 opts_type = OPTS_TYPE_PT_GENERATE_LE
8220 | OPTS_TYPE_ST_ADDBITS14;
8221 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8222 dgst_size = DGST_SIZE_4_4;
8223 parse_func = md5s_parse_hash;
8224 sort_by_digest = sort_by_digest_4_4;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP
8229 | OPTI_TYPE_NOT_ITERATED
8230 | OPTI_TYPE_RAW_HASH;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 3;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 1;
8235 break;
8236
8237 case 4300: hash_type = HASH_TYPE_MD5;
8238 salt_type = SALT_TYPE_VIRTUAL;
8239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE
8241 | OPTS_TYPE_PT_ADD80
8242 | OPTS_TYPE_PT_ADDBITS14
8243 | OPTS_TYPE_ST_ADD80;
8244 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8245 dgst_size = DGST_SIZE_4_4;
8246 parse_func = md5md5_parse_hash;
8247 sort_by_digest = sort_by_digest_4_4;
8248 opti_type = OPTI_TYPE_ZERO_BYTE
8249 | OPTI_TYPE_PRECOMPUTE_INIT
8250 | OPTI_TYPE_PRECOMPUTE_MERKLE
8251 | OPTI_TYPE_EARLY_SKIP;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258
8259 case 4400: hash_type = HASH_TYPE_MD5;
8260 salt_type = SALT_TYPE_NONE;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_BE
8263 | OPTS_TYPE_PT_ADD80
8264 | OPTS_TYPE_PT_ADDBITS15;
8265 kern_type = KERN_TYPE_MD5_SHA1;
8266 dgst_size = DGST_SIZE_4_4;
8267 parse_func = md5_parse_hash;
8268 sort_by_digest = sort_by_digest_4_4;
8269 opti_type = OPTI_TYPE_ZERO_BYTE
8270 | OPTI_TYPE_PRECOMPUTE_INIT
8271 | OPTI_TYPE_PRECOMPUTE_MERKLE
8272 | OPTI_TYPE_EARLY_SKIP
8273 | OPTI_TYPE_NOT_ITERATED
8274 | OPTI_TYPE_NOT_SALTED
8275 | OPTI_TYPE_RAW_HASH;
8276 dgst_pos0 = 0;
8277 dgst_pos1 = 3;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 1;
8280 break;
8281
8282 case 4500: hash_type = HASH_TYPE_SHA1;
8283 salt_type = SALT_TYPE_NONE;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_BE
8286 | OPTS_TYPE_PT_ADD80
8287 | OPTS_TYPE_PT_ADDBITS15;
8288 kern_type = KERN_TYPE_SHA11;
8289 dgst_size = DGST_SIZE_4_5;
8290 parse_func = sha1_parse_hash;
8291 sort_by_digest = sort_by_digest_4_5;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_SALTED;
8297 dgst_pos0 = 3;
8298 dgst_pos1 = 4;
8299 dgst_pos2 = 2;
8300 dgst_pos3 = 1;
8301 break;
8302
8303 case 4700: hash_type = HASH_TYPE_SHA1;
8304 salt_type = SALT_TYPE_NONE;
8305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8306 opts_type = OPTS_TYPE_PT_GENERATE_LE
8307 | OPTS_TYPE_PT_ADD80
8308 | OPTS_TYPE_PT_ADDBITS14;
8309 kern_type = KERN_TYPE_SHA1_MD5;
8310 dgst_size = DGST_SIZE_4_5;
8311 parse_func = sha1_parse_hash;
8312 sort_by_digest = sort_by_digest_4_5;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP
8317 | OPTI_TYPE_NOT_ITERATED
8318 | OPTI_TYPE_NOT_SALTED
8319 | OPTI_TYPE_RAW_HASH;
8320 dgst_pos0 = 3;
8321 dgst_pos1 = 4;
8322 dgst_pos2 = 2;
8323 dgst_pos3 = 1;
8324 break;
8325
8326 case 4800: hash_type = HASH_TYPE_MD5;
8327 salt_type = SALT_TYPE_EMBEDDED;
8328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8329 opts_type = OPTS_TYPE_PT_GENERATE_LE
8330 | OPTS_TYPE_PT_ADDBITS14;
8331 kern_type = KERN_TYPE_MD5_CHAP;
8332 dgst_size = DGST_SIZE_4_4;
8333 parse_func = chap_parse_hash;
8334 sort_by_digest = sort_by_digest_4_4;
8335 opti_type = OPTI_TYPE_ZERO_BYTE
8336 | OPTI_TYPE_PRECOMPUTE_INIT
8337 | OPTI_TYPE_PRECOMPUTE_MERKLE
8338 | OPTI_TYPE_MEET_IN_MIDDLE
8339 | OPTI_TYPE_EARLY_SKIP
8340 | OPTI_TYPE_NOT_ITERATED
8341 | OPTI_TYPE_RAW_HASH;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 3;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 1;
8346 break;
8347
8348 case 4900: hash_type = HASH_TYPE_SHA1;
8349 salt_type = SALT_TYPE_INTERN;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8352 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8353 dgst_size = DGST_SIZE_4_5;
8354 parse_func = sha1s_parse_hash;
8355 sort_by_digest = sort_by_digest_4_5;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_PRECOMPUTE_MERKLE
8359 | OPTI_TYPE_EARLY_SKIP;
8360 dgst_pos0 = 3;
8361 dgst_pos1 = 4;
8362 dgst_pos2 = 2;
8363 dgst_pos3 = 1;
8364 break;
8365
8366 case 5000: hash_type = HASH_TYPE_KECCAK;
8367 salt_type = SALT_TYPE_EMBEDDED;
8368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8369 opts_type = OPTS_TYPE_PT_GENERATE_LE
8370 | OPTS_TYPE_PT_ADD01;
8371 kern_type = KERN_TYPE_KECCAK;
8372 dgst_size = DGST_SIZE_8_25;
8373 parse_func = keccak_parse_hash;
8374 sort_by_digest = sort_by_digest_8_25;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_RAW_HASH;
8377 dgst_pos0 = 2;
8378 dgst_pos1 = 3;
8379 dgst_pos2 = 4;
8380 dgst_pos3 = 5;
8381 break;
8382
8383 case 5100: hash_type = HASH_TYPE_MD5H;
8384 salt_type = SALT_TYPE_NONE;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE
8387 | OPTS_TYPE_PT_ADD80
8388 | OPTS_TYPE_PT_ADDBITS14;
8389 kern_type = KERN_TYPE_MD5H;
8390 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8391 parse_func = md5half_parse_hash;
8392 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8393 opti_type = OPTI_TYPE_ZERO_BYTE
8394 | OPTI_TYPE_RAW_HASH;
8395 dgst_pos0 = 0;
8396 dgst_pos1 = 1;
8397 dgst_pos2 = 2;
8398 dgst_pos3 = 3;
8399 break;
8400
8401 case 5200: hash_type = HASH_TYPE_SHA256;
8402 salt_type = SALT_TYPE_EMBEDDED;
8403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8404 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8405 kern_type = KERN_TYPE_PSAFE3;
8406 dgst_size = DGST_SIZE_4_8;
8407 parse_func = psafe3_parse_hash;
8408 sort_by_digest = sort_by_digest_4_8;
8409 opti_type = OPTI_TYPE_ZERO_BYTE;
8410 dgst_pos0 = 0;
8411 dgst_pos1 = 1;
8412 dgst_pos2 = 2;
8413 dgst_pos3 = 3;
8414 break;
8415
8416 case 5300: hash_type = HASH_TYPE_MD5;
8417 salt_type = SALT_TYPE_EMBEDDED;
8418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8419 opts_type = OPTS_TYPE_PT_GENERATE_LE
8420 | OPTS_TYPE_ST_ADD80;
8421 kern_type = KERN_TYPE_IKEPSK_MD5;
8422 dgst_size = DGST_SIZE_4_4;
8423 parse_func = ikepsk_md5_parse_hash;
8424 sort_by_digest = sort_by_digest_4_4;
8425 opti_type = OPTI_TYPE_ZERO_BYTE;
8426 dgst_pos0 = 0;
8427 dgst_pos1 = 3;
8428 dgst_pos2 = 2;
8429 dgst_pos3 = 1;
8430 break;
8431
8432 case 5400: hash_type = HASH_TYPE_SHA1;
8433 salt_type = SALT_TYPE_EMBEDDED;
8434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_BE
8436 | OPTS_TYPE_ST_ADD80;
8437 kern_type = KERN_TYPE_IKEPSK_SHA1;
8438 dgst_size = DGST_SIZE_4_5;
8439 parse_func = ikepsk_sha1_parse_hash;
8440 sort_by_digest = sort_by_digest_4_5;
8441 opti_type = OPTI_TYPE_ZERO_BYTE;
8442 dgst_pos0 = 3;
8443 dgst_pos1 = 4;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 5500: hash_type = HASH_TYPE_NETNTLM;
8449 salt_type = SALT_TYPE_EMBEDDED;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE
8452 | OPTS_TYPE_PT_ADD80
8453 | OPTS_TYPE_PT_ADDBITS14
8454 | OPTS_TYPE_PT_UNICODE
8455 | OPTS_TYPE_ST_HEX;
8456 kern_type = KERN_TYPE_NETNTLMv1;
8457 dgst_size = DGST_SIZE_4_4;
8458 parse_func = netntlmv1_parse_hash;
8459 sort_by_digest = sort_by_digest_4_4;
8460 opti_type = OPTI_TYPE_ZERO_BYTE
8461 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8462 dgst_pos0 = 0;
8463 dgst_pos1 = 1;
8464 dgst_pos2 = 2;
8465 dgst_pos3 = 3;
8466 break;
8467
8468 case 5600: hash_type = HASH_TYPE_MD5;
8469 salt_type = SALT_TYPE_EMBEDDED;
8470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8471 opts_type = OPTS_TYPE_PT_GENERATE_LE
8472 | OPTS_TYPE_PT_ADD80
8473 | OPTS_TYPE_PT_ADDBITS14
8474 | OPTS_TYPE_PT_UNICODE;
8475 kern_type = KERN_TYPE_NETNTLMv2;
8476 dgst_size = DGST_SIZE_4_4;
8477 parse_func = netntlmv2_parse_hash;
8478 sort_by_digest = sort_by_digest_4_4;
8479 opti_type = OPTI_TYPE_ZERO_BYTE;
8480 dgst_pos0 = 0;
8481 dgst_pos1 = 3;
8482 dgst_pos2 = 2;
8483 dgst_pos3 = 1;
8484 break;
8485
8486 case 5700: hash_type = HASH_TYPE_SHA256;
8487 salt_type = SALT_TYPE_NONE;
8488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8489 opts_type = OPTS_TYPE_PT_GENERATE_BE
8490 | OPTS_TYPE_PT_ADD80
8491 | OPTS_TYPE_PT_ADDBITS15;
8492 kern_type = KERN_TYPE_SHA256;
8493 dgst_size = DGST_SIZE_4_8;
8494 parse_func = cisco4_parse_hash;
8495 sort_by_digest = sort_by_digest_4_8;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP
8500 | OPTI_TYPE_NOT_ITERATED
8501 | OPTI_TYPE_NOT_SALTED
8502 | OPTI_TYPE_RAW_HASH;
8503 dgst_pos0 = 3;
8504 dgst_pos1 = 7;
8505 dgst_pos2 = 2;
8506 dgst_pos3 = 6;
8507 break;
8508
8509 case 5800: hash_type = HASH_TYPE_SHA1;
8510 salt_type = SALT_TYPE_INTERN;
8511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8512 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8513 | OPTS_TYPE_ST_ADD80;
8514 kern_type = KERN_TYPE_ANDROIDPIN;
8515 dgst_size = DGST_SIZE_4_5;
8516 parse_func = androidpin_parse_hash;
8517 sort_by_digest = sort_by_digest_4_5;
8518 opti_type = OPTI_TYPE_ZERO_BYTE;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 1;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 3;
8523 break;
8524
8525 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8526 salt_type = SALT_TYPE_NONE;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80;
8530 kern_type = KERN_TYPE_RIPEMD160;
8531 dgst_size = DGST_SIZE_4_5;
8532 parse_func = ripemd160_parse_hash;
8533 sort_by_digest = sort_by_digest_4_5;
8534 opti_type = OPTI_TYPE_ZERO_BYTE;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 1;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 3;
8539 break;
8540
8541 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8542 salt_type = SALT_TYPE_NONE;
8543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_BE
8545 | OPTS_TYPE_PT_ADD80;
8546 kern_type = KERN_TYPE_WHIRLPOOL;
8547 dgst_size = DGST_SIZE_4_16;
8548 parse_func = whirlpool_parse_hash;
8549 sort_by_digest = sort_by_digest_4_16;
8550 opti_type = OPTI_TYPE_ZERO_BYTE;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 1;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 3;
8555 break;
8556
8557 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8558 salt_type = SALT_TYPE_EMBEDDED;
8559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8561 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8562 dgst_size = DGST_SIZE_4_5;
8563 parse_func = truecrypt_parse_hash_2k;
8564 sort_by_digest = sort_by_digest_4_5;
8565 opti_type = OPTI_TYPE_ZERO_BYTE;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 1;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 3;
8570 break;
8571
8572 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8576 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8577 dgst_size = DGST_SIZE_4_5;
8578 parse_func = truecrypt_parse_hash_2k;
8579 sort_by_digest = sort_by_digest_4_5;
8580 opti_type = OPTI_TYPE_ZERO_BYTE;
8581 dgst_pos0 = 0;
8582 dgst_pos1 = 1;
8583 dgst_pos2 = 2;
8584 dgst_pos3 = 3;
8585 break;
8586
8587 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8588 salt_type = SALT_TYPE_EMBEDDED;
8589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8591 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8592 dgst_size = DGST_SIZE_4_5;
8593 parse_func = truecrypt_parse_hash_2k;
8594 sort_by_digest = sort_by_digest_4_5;
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 1;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 3;
8600 break;
8601
8602 case 6221: hash_type = HASH_TYPE_SHA512;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8606 kern_type = KERN_TYPE_TCSHA512_XTS512;
8607 dgst_size = DGST_SIZE_8_8;
8608 parse_func = truecrypt_parse_hash_1k;
8609 sort_by_digest = sort_by_digest_8_8;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 6222: hash_type = HASH_TYPE_SHA512;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8621 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8622 dgst_size = DGST_SIZE_8_8;
8623 parse_func = truecrypt_parse_hash_1k;
8624 sort_by_digest = sort_by_digest_8_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 6223: hash_type = HASH_TYPE_SHA512;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8636 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = truecrypt_parse_hash_1k;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 1;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 3;
8645 break;
8646
8647 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8651 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8652 dgst_size = DGST_SIZE_4_8;
8653 parse_func = truecrypt_parse_hash_1k;
8654 sort_by_digest = sort_by_digest_4_8;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8666 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8667 dgst_size = DGST_SIZE_4_8;
8668 parse_func = truecrypt_parse_hash_1k;
8669 sort_by_digest = sort_by_digest_4_8;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8682 dgst_size = DGST_SIZE_4_8;
8683 parse_func = truecrypt_parse_hash_1k;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8696 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8697 dgst_size = DGST_SIZE_4_5;
8698 parse_func = truecrypt_parse_hash_1k;
8699 sort_by_digest = sort_by_digest_4_5;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8711 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8712 dgst_size = DGST_SIZE_4_5;
8713 parse_func = truecrypt_parse_hash_1k;
8714 sort_by_digest = sort_by_digest_4_5;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8726 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8727 dgst_size = DGST_SIZE_4_5;
8728 parse_func = truecrypt_parse_hash_1k;
8729 sort_by_digest = sort_by_digest_4_5;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 6300: hash_type = HASH_TYPE_MD5;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8741 kern_type = KERN_TYPE_MD5AIX;
8742 dgst_size = DGST_SIZE_4_4;
8743 parse_func = md5aix_parse_hash;
8744 sort_by_digest = sort_by_digest_4_4;
8745 opti_type = OPTI_TYPE_ZERO_BYTE;
8746 dgst_pos0 = 0;
8747 dgst_pos1 = 1;
8748 dgst_pos2 = 2;
8749 dgst_pos3 = 3;
8750 break;
8751
8752 case 6400: hash_type = HASH_TYPE_SHA256;
8753 salt_type = SALT_TYPE_EMBEDDED;
8754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8756 kern_type = KERN_TYPE_SHA256AIX;
8757 dgst_size = DGST_SIZE_4_8;
8758 parse_func = sha256aix_parse_hash;
8759 sort_by_digest = sort_by_digest_4_8;
8760 opti_type = OPTI_TYPE_ZERO_BYTE;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 1;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 3;
8765 break;
8766
8767 case 6500: hash_type = HASH_TYPE_SHA512;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8771 kern_type = KERN_TYPE_SHA512AIX;
8772 dgst_size = DGST_SIZE_8_8;
8773 parse_func = sha512aix_parse_hash;
8774 sort_by_digest = sort_by_digest_8_8;
8775 opti_type = OPTI_TYPE_ZERO_BYTE;
8776 dgst_pos0 = 0;
8777 dgst_pos1 = 1;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 3;
8780 break;
8781
8782 case 6600: hash_type = HASH_TYPE_AES;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8786 kern_type = KERN_TYPE_AGILEKEY;
8787 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8788 parse_func = agilekey_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6700: hash_type = HASH_TYPE_SHA1;
8798 salt_type = SALT_TYPE_EMBEDDED;
8799 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8801 kern_type = KERN_TYPE_SHA1AIX;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = sha1aix_parse_hash;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6800: hash_type = HASH_TYPE_AES;
8813 salt_type = SALT_TYPE_EMBEDDED;
8814 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8816 kern_type = KERN_TYPE_LASTPASS;
8817 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8818 parse_func = lastpass_parse_hash;
8819 sort_by_digest = sort_by_digest_4_8;
8820 opti_type = OPTI_TYPE_ZERO_BYTE;
8821 dgst_pos0 = 0;
8822 dgst_pos1 = 1;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 3;
8825 break;
8826
8827 case 6900: hash_type = HASH_TYPE_GOST;
8828 salt_type = SALT_TYPE_NONE;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8831 kern_type = KERN_TYPE_GOST;
8832 dgst_size = DGST_SIZE_4_8;
8833 parse_func = gost_parse_hash;
8834 sort_by_digest = sort_by_digest_4_8;
8835 opti_type = OPTI_TYPE_ZERO_BYTE;
8836 dgst_pos0 = 0;
8837 dgst_pos1 = 1;
8838 dgst_pos2 = 2;
8839 dgst_pos3 = 3;
8840 break;
8841
8842 case 7100: hash_type = HASH_TYPE_SHA512;
8843 salt_type = SALT_TYPE_EMBEDDED;
8844 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8845 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8846 kern_type = KERN_TYPE_PBKDF2_SHA512;
8847 dgst_size = DGST_SIZE_8_16;
8848 parse_func = sha512osx_parse_hash;
8849 sort_by_digest = sort_by_digest_8_16;
8850 opti_type = OPTI_TYPE_ZERO_BYTE;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 1;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 3;
8855 break;
8856
8857 case 7200: hash_type = HASH_TYPE_SHA512;
8858 salt_type = SALT_TYPE_EMBEDDED;
8859 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8861 kern_type = KERN_TYPE_PBKDF2_SHA512;
8862 dgst_size = DGST_SIZE_8_16;
8863 parse_func = sha512grub_parse_hash;
8864 sort_by_digest = sort_by_digest_8_16;
8865 opti_type = OPTI_TYPE_ZERO_BYTE;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 1;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 3;
8870 break;
8871
8872 case 7300: hash_type = HASH_TYPE_SHA1;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_BE
8876 | OPTS_TYPE_ST_ADD80
8877 | OPTS_TYPE_ST_ADDBITS15;
8878 kern_type = KERN_TYPE_RAKP;
8879 dgst_size = DGST_SIZE_4_5;
8880 parse_func = rakp_parse_hash;
8881 sort_by_digest = sort_by_digest_4_5;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_NOT_ITERATED;
8884 dgst_pos0 = 3;
8885 dgst_pos1 = 4;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 1;
8888 break;
8889
8890 case 7400: hash_type = HASH_TYPE_SHA256;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_SHA256CRYPT;
8895 dgst_size = DGST_SIZE_4_8;
8896 parse_func = sha256crypt_parse_hash;
8897 sort_by_digest = sort_by_digest_4_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 7500: hash_type = HASH_TYPE_KRB5PA;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8909 kern_type = KERN_TYPE_KRB5PA;
8910 dgst_size = DGST_SIZE_4_4;
8911 parse_func = krb5pa_parse_hash;
8912 sort_by_digest = sort_by_digest_4_4;
8913 opti_type = OPTI_TYPE_ZERO_BYTE
8914 | OPTI_TYPE_NOT_ITERATED;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 7600: hash_type = HASH_TYPE_SHA1;
8922 salt_type = SALT_TYPE_INTERN;
8923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_BE
8925 | OPTS_TYPE_PT_ADD80
8926 | OPTS_TYPE_PT_ADDBITS15;
8927 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8928 dgst_size = DGST_SIZE_4_5;
8929 parse_func = redmine_parse_hash;
8930 sort_by_digest = sort_by_digest_4_5;
8931 opti_type = OPTI_TYPE_ZERO_BYTE
8932 | OPTI_TYPE_PRECOMPUTE_INIT
8933 | OPTI_TYPE_EARLY_SKIP
8934 | OPTI_TYPE_NOT_ITERATED
8935 | OPTI_TYPE_PREPENDED_SALT;
8936 dgst_pos0 = 3;
8937 dgst_pos1 = 4;
8938 dgst_pos2 = 2;
8939 dgst_pos3 = 1;
8940 break;
8941
8942 case 7700: hash_type = HASH_TYPE_SAPB;
8943 salt_type = SALT_TYPE_EMBEDDED;
8944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8945 opts_type = OPTS_TYPE_PT_GENERATE_LE
8946 | OPTS_TYPE_PT_UPPER
8947 | OPTS_TYPE_ST_UPPER;
8948 kern_type = KERN_TYPE_SAPB;
8949 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8950 parse_func = sapb_parse_hash;
8951 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8952 opti_type = OPTI_TYPE_ZERO_BYTE
8953 | OPTI_TYPE_PRECOMPUTE_INIT
8954 | OPTI_TYPE_NOT_ITERATED;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 1;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 3;
8959 break;
8960
8961 case 7800: hash_type = HASH_TYPE_SAPG;
8962 salt_type = SALT_TYPE_EMBEDDED;
8963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_BE
8965 | OPTS_TYPE_ST_ADD80
8966 | OPTS_TYPE_ST_UPPER;
8967 kern_type = KERN_TYPE_SAPG;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = sapg_parse_hash;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE
8972 | OPTI_TYPE_PRECOMPUTE_INIT
8973 | OPTI_TYPE_NOT_ITERATED;
8974 dgst_pos0 = 3;
8975 dgst_pos1 = 4;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 1;
8978 break;
8979
8980 case 7900: hash_type = HASH_TYPE_SHA512;
8981 salt_type = SALT_TYPE_EMBEDDED;
8982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8984 kern_type = KERN_TYPE_DRUPAL7;
8985 dgst_size = DGST_SIZE_8_8;
8986 parse_func = drupal7_parse_hash;
8987 sort_by_digest = sort_by_digest_8_8;
8988 opti_type = OPTI_TYPE_ZERO_BYTE;
8989 dgst_pos0 = 0;
8990 dgst_pos1 = 1;
8991 dgst_pos2 = 2;
8992 dgst_pos3 = 3;
8993 break;
8994
8995 case 8000: hash_type = HASH_TYPE_SHA256;
8996 salt_type = SALT_TYPE_EMBEDDED;
8997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8998 opts_type = OPTS_TYPE_PT_GENERATE_BE
8999 | OPTS_TYPE_PT_UNICODE
9000 | OPTS_TYPE_ST_ADD80
9001 | OPTS_TYPE_ST_HEX;
9002 kern_type = KERN_TYPE_SYBASEASE;
9003 dgst_size = DGST_SIZE_4_8;
9004 parse_func = sybasease_parse_hash;
9005 sort_by_digest = sort_by_digest_4_8;
9006 opti_type = OPTI_TYPE_ZERO_BYTE
9007 | OPTI_TYPE_PRECOMPUTE_INIT
9008 | OPTI_TYPE_EARLY_SKIP
9009 | OPTI_TYPE_NOT_ITERATED
9010 | OPTI_TYPE_RAW_HASH;
9011 dgst_pos0 = 3;
9012 dgst_pos1 = 7;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 6;
9015 break;
9016
9017 case 8100: hash_type = HASH_TYPE_SHA1;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9021 kern_type = KERN_TYPE_NETSCALER;
9022 dgst_size = DGST_SIZE_4_5;
9023 parse_func = netscaler_parse_hash;
9024 sort_by_digest = sort_by_digest_4_5;
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_PRECOMPUTE_INIT
9027 | OPTI_TYPE_PRECOMPUTE_MERKLE
9028 | OPTI_TYPE_EARLY_SKIP
9029 | OPTI_TYPE_NOT_ITERATED
9030 | OPTI_TYPE_PREPENDED_SALT
9031 | OPTI_TYPE_RAW_HASH;
9032 dgst_pos0 = 3;
9033 dgst_pos1 = 4;
9034 dgst_pos2 = 2;
9035 dgst_pos3 = 1;
9036 break;
9037
9038 case 8200: hash_type = HASH_TYPE_SHA256;
9039 salt_type = SALT_TYPE_EMBEDDED;
9040 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9041 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9042 kern_type = KERN_TYPE_CLOUDKEY;
9043 dgst_size = DGST_SIZE_4_8;
9044 parse_func = cloudkey_parse_hash;
9045 sort_by_digest = sort_by_digest_4_8;
9046 opti_type = OPTI_TYPE_ZERO_BYTE;
9047 dgst_pos0 = 0;
9048 dgst_pos1 = 1;
9049 dgst_pos2 = 2;
9050 dgst_pos3 = 3;
9051 break;
9052
9053 case 8300: hash_type = HASH_TYPE_SHA1;
9054 salt_type = SALT_TYPE_EMBEDDED;
9055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9056 opts_type = OPTS_TYPE_PT_GENERATE_LE
9057 | OPTS_TYPE_ST_HEX
9058 | OPTS_TYPE_ST_ADD80;
9059 kern_type = KERN_TYPE_NSEC3;
9060 dgst_size = DGST_SIZE_4_5;
9061 parse_func = nsec3_parse_hash;
9062 sort_by_digest = sort_by_digest_4_5;
9063 opti_type = OPTI_TYPE_ZERO_BYTE;
9064 dgst_pos0 = 3;
9065 dgst_pos1 = 4;
9066 dgst_pos2 = 2;
9067 dgst_pos3 = 1;
9068 break;
9069
9070 case 8400: hash_type = HASH_TYPE_SHA1;
9071 salt_type = SALT_TYPE_INTERN;
9072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9073 opts_type = OPTS_TYPE_PT_GENERATE_BE
9074 | OPTS_TYPE_PT_ADD80
9075 | OPTS_TYPE_PT_ADDBITS15;
9076 kern_type = KERN_TYPE_WBB3;
9077 dgst_size = DGST_SIZE_4_5;
9078 parse_func = wbb3_parse_hash;
9079 sort_by_digest = sort_by_digest_4_5;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_PRECOMPUTE_INIT
9082 | OPTI_TYPE_NOT_ITERATED;
9083 dgst_pos0 = 3;
9084 dgst_pos1 = 4;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 1;
9087 break;
9088
9089 case 8500: hash_type = HASH_TYPE_DESRACF;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE
9093 | OPTS_TYPE_ST_UPPER;
9094 kern_type = KERN_TYPE_RACF;
9095 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9096 parse_func = racf_parse_hash;
9097 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 8600: hash_type = HASH_TYPE_LOTUS5;
9107 salt_type = SALT_TYPE_NONE;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9110 kern_type = KERN_TYPE_LOTUS5;
9111 dgst_size = DGST_SIZE_4_4;
9112 parse_func = lotus5_parse_hash;
9113 sort_by_digest = sort_by_digest_4_4;
9114 opti_type = OPTI_TYPE_EARLY_SKIP
9115 | OPTI_TYPE_NOT_ITERATED
9116 | OPTI_TYPE_NOT_SALTED
9117 | OPTI_TYPE_RAW_HASH;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 8700: hash_type = HASH_TYPE_LOTUS6;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9128 kern_type = KERN_TYPE_LOTUS6;
9129 dgst_size = DGST_SIZE_4_4;
9130 parse_func = lotus6_parse_hash;
9131 sort_by_digest = sort_by_digest_4_4;
9132 opti_type = OPTI_TYPE_EARLY_SKIP
9133 | OPTI_TYPE_NOT_ITERATED
9134 | OPTI_TYPE_RAW_HASH;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 1;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 3;
9139 break;
9140
9141 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9142 salt_type = SALT_TYPE_EMBEDDED;
9143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9144 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9145 kern_type = KERN_TYPE_ANDROIDFDE;
9146 dgst_size = DGST_SIZE_4_4;
9147 parse_func = androidfde_parse_hash;
9148 sort_by_digest = sort_by_digest_4_4;
9149 opti_type = OPTI_TYPE_ZERO_BYTE;
9150 dgst_pos0 = 0;
9151 dgst_pos1 = 1;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 3;
9154 break;
9155
9156 case 8900: hash_type = HASH_TYPE_SCRYPT;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9160 kern_type = KERN_TYPE_SCRYPT;
9161 dgst_size = DGST_SIZE_4_8;
9162 parse_func = scrypt_parse_hash;
9163 sort_by_digest = sort_by_digest_4_8;
9164 opti_type = OPTI_TYPE_ZERO_BYTE;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 9000: hash_type = HASH_TYPE_SHA1;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE
9175 | OPTS_TYPE_ST_GENERATE_LE;
9176 kern_type = KERN_TYPE_PSAFE2;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = psafe2_parse_hash;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 9100: hash_type = HASH_TYPE_LOTUS8;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_LOTUS8;
9192 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9193 parse_func = lotus8_parse_hash;
9194 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 9200: hash_type = HASH_TYPE_SHA256;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9206 kern_type = KERN_TYPE_PBKDF2_SHA256;
9207 dgst_size = DGST_SIZE_4_32;
9208 parse_func = cisco8_parse_hash;
9209 sort_by_digest = sort_by_digest_4_32;
9210 opti_type = OPTI_TYPE_ZERO_BYTE;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 9300: hash_type = HASH_TYPE_SCRYPT;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9221 kern_type = KERN_TYPE_SCRYPT;
9222 dgst_size = DGST_SIZE_4_8;
9223 parse_func = cisco9_parse_hash;
9224 sort_by_digest = sort_by_digest_4_8;
9225 opti_type = OPTI_TYPE_ZERO_BYTE;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9236 kern_type = KERN_TYPE_OFFICE2007;
9237 dgst_size = DGST_SIZE_4_4;
9238 parse_func = office2007_parse_hash;
9239 sort_by_digest = sort_by_digest_4_4;
9240 opti_type = OPTI_TYPE_ZERO_BYTE;
9241 dgst_pos0 = 0;
9242 dgst_pos1 = 1;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 3;
9245 break;
9246
9247 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9248 salt_type = SALT_TYPE_EMBEDDED;
9249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9251 kern_type = KERN_TYPE_OFFICE2010;
9252 dgst_size = DGST_SIZE_4_4;
9253 parse_func = office2010_parse_hash;
9254 sort_by_digest = sort_by_digest_4_4;
9255 opti_type = OPTI_TYPE_ZERO_BYTE;
9256 dgst_pos0 = 0;
9257 dgst_pos1 = 1;
9258 dgst_pos2 = 2;
9259 dgst_pos3 = 3;
9260 break;
9261
9262 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9263 salt_type = SALT_TYPE_EMBEDDED;
9264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9266 kern_type = KERN_TYPE_OFFICE2013;
9267 dgst_size = DGST_SIZE_4_4;
9268 parse_func = office2013_parse_hash;
9269 sort_by_digest = sort_by_digest_4_4;
9270 opti_type = OPTI_TYPE_ZERO_BYTE;
9271 dgst_pos0 = 0;
9272 dgst_pos1 = 1;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 3;
9275 break;
9276
9277 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9278 salt_type = SALT_TYPE_EMBEDDED;
9279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_LE
9281 | OPTS_TYPE_PT_ADD80
9282 | OPTS_TYPE_PT_UNICODE;
9283 kern_type = KERN_TYPE_OLDOFFICE01;
9284 dgst_size = DGST_SIZE_4_4;
9285 parse_func = oldoffice01_parse_hash;
9286 sort_by_digest = sort_by_digest_4_4;
9287 opti_type = OPTI_TYPE_ZERO_BYTE
9288 | OPTI_TYPE_PRECOMPUTE_INIT
9289 | OPTI_TYPE_NOT_ITERATED;
9290 dgst_pos0 = 0;
9291 dgst_pos1 = 1;
9292 dgst_pos2 = 2;
9293 dgst_pos3 = 3;
9294 break;
9295
9296 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9297 salt_type = SALT_TYPE_EMBEDDED;
9298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9299 opts_type = OPTS_TYPE_PT_GENERATE_LE
9300 | OPTS_TYPE_PT_ADD80;
9301 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9302 dgst_size = DGST_SIZE_4_4;
9303 parse_func = oldoffice01cm1_parse_hash;
9304 sort_by_digest = sort_by_digest_4_4;
9305 opti_type = OPTI_TYPE_ZERO_BYTE
9306 | OPTI_TYPE_PRECOMPUTE_INIT
9307 | OPTI_TYPE_NOT_ITERATED;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE
9318 | OPTS_TYPE_PT_ADD80
9319 | OPTS_TYPE_PT_UNICODE
9320 | OPTS_TYPE_PT_NEVERCRACK;
9321 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9322 dgst_size = DGST_SIZE_4_4;
9323 parse_func = oldoffice01cm2_parse_hash;
9324 sort_by_digest = sort_by_digest_4_4;
9325 opti_type = OPTI_TYPE_ZERO_BYTE
9326 | OPTI_TYPE_PRECOMPUTE_INIT
9327 | OPTI_TYPE_NOT_ITERATED;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_BE
9338 | OPTS_TYPE_PT_ADD80
9339 | OPTS_TYPE_PT_UNICODE;
9340 kern_type = KERN_TYPE_OLDOFFICE34;
9341 dgst_size = DGST_SIZE_4_4;
9342 parse_func = oldoffice34_parse_hash;
9343 sort_by_digest = sort_by_digest_4_4;
9344 opti_type = OPTI_TYPE_ZERO_BYTE
9345 | OPTI_TYPE_PRECOMPUTE_INIT
9346 | OPTI_TYPE_NOT_ITERATED;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = oldoffice34cm1_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_NOT_ITERATED;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_BE
9374 | OPTS_TYPE_PT_ADD80
9375 | OPTS_TYPE_PT_UNICODE
9376 | OPTS_TYPE_PT_NEVERCRACK;
9377 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9378 dgst_size = DGST_SIZE_4_4;
9379 parse_func = oldoffice34cm2_parse_hash;
9380 sort_by_digest = sort_by_digest_4_4;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_PRECOMPUTE_INIT
9383 | OPTI_TYPE_NOT_ITERATED;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 9900: hash_type = HASH_TYPE_MD5;
9391 salt_type = SALT_TYPE_NONE;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_RADMIN2;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = radmin2_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_EARLY_SKIP
9401 | OPTI_TYPE_NOT_ITERATED
9402 | OPTI_TYPE_NOT_SALTED;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 3;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 1;
9407 break;
9408
9409 case 10000: hash_type = HASH_TYPE_SHA256;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9413 kern_type = KERN_TYPE_PBKDF2_SHA256;
9414 dgst_size = DGST_SIZE_4_32;
9415 parse_func = djangopbkdf2_parse_hash;
9416 sort_by_digest = sort_by_digest_4_32;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 10100: hash_type = HASH_TYPE_SIPHASH;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9428 kern_type = KERN_TYPE_SIPHASH;
9429 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9430 parse_func = siphash_parse_hash;
9431 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9432 opti_type = OPTI_TYPE_ZERO_BYTE
9433 | OPTI_TYPE_NOT_ITERATED
9434 | OPTI_TYPE_RAW_HASH;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 10200: hash_type = HASH_TYPE_MD5;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE
9445 | OPTS_TYPE_ST_ADD80
9446 | OPTS_TYPE_ST_ADDBITS14;
9447 kern_type = KERN_TYPE_HMACMD5_PW;
9448 dgst_size = DGST_SIZE_4_4;
9449 parse_func = crammd5_parse_hash;
9450 sort_by_digest = sort_by_digest_4_4;
9451 opti_type = OPTI_TYPE_ZERO_BYTE
9452 | OPTI_TYPE_NOT_ITERATED;
9453 dgst_pos0 = 0;
9454 dgst_pos1 = 3;
9455 dgst_pos2 = 2;
9456 dgst_pos3 = 1;
9457 break;
9458
9459 case 10300: hash_type = HASH_TYPE_SHA1;
9460 salt_type = SALT_TYPE_EMBEDDED;
9461 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9462 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9463 kern_type = KERN_TYPE_SAPH_SHA1;
9464 dgst_size = DGST_SIZE_4_5;
9465 parse_func = saph_sha1_parse_hash;
9466 sort_by_digest = sort_by_digest_4_5;
9467 opti_type = OPTI_TYPE_ZERO_BYTE;
9468 dgst_pos0 = 0;
9469 dgst_pos1 = 1;
9470 dgst_pos2 = 2;
9471 dgst_pos3 = 3;
9472 break;
9473
9474 case 10400: hash_type = HASH_TYPE_PDFU16;
9475 salt_type = SALT_TYPE_EMBEDDED;
9476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9477 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9478 kern_type = KERN_TYPE_PDF11;
9479 dgst_size = DGST_SIZE_4_4;
9480 parse_func = pdf11_parse_hash;
9481 sort_by_digest = sort_by_digest_4_4;
9482 opti_type = OPTI_TYPE_ZERO_BYTE
9483 | OPTI_TYPE_NOT_ITERATED;
9484 dgst_pos0 = 0;
9485 dgst_pos1 = 1;
9486 dgst_pos2 = 2;
9487 dgst_pos3 = 3;
9488 break;
9489
9490 case 10410: hash_type = HASH_TYPE_PDFU16;
9491 salt_type = SALT_TYPE_EMBEDDED;
9492 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9493 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9494 kern_type = KERN_TYPE_PDF11CM1;
9495 dgst_size = DGST_SIZE_4_4;
9496 parse_func = pdf11cm1_parse_hash;
9497 sort_by_digest = sort_by_digest_4_4;
9498 opti_type = OPTI_TYPE_ZERO_BYTE
9499 | OPTI_TYPE_NOT_ITERATED;
9500 dgst_pos0 = 0;
9501 dgst_pos1 = 1;
9502 dgst_pos2 = 2;
9503 dgst_pos3 = 3;
9504 break;
9505
9506 case 10420: hash_type = HASH_TYPE_PDFU16;
9507 salt_type = SALT_TYPE_EMBEDDED;
9508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9510 kern_type = KERN_TYPE_PDF11CM2;
9511 dgst_size = DGST_SIZE_4_4;
9512 parse_func = pdf11cm2_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4;
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_NOT_ITERATED;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 1;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 3;
9520 break;
9521
9522 case 10500: hash_type = HASH_TYPE_PDFU16;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9526 kern_type = KERN_TYPE_PDF14;
9527 dgst_size = DGST_SIZE_4_4;
9528 parse_func = pdf14_parse_hash;
9529 sort_by_digest = sort_by_digest_4_4;
9530 opti_type = OPTI_TYPE_ZERO_BYTE
9531 | OPTI_TYPE_NOT_ITERATED;
9532 dgst_pos0 = 0;
9533 dgst_pos1 = 1;
9534 dgst_pos2 = 2;
9535 dgst_pos3 = 3;
9536 break;
9537
9538 case 10600: hash_type = HASH_TYPE_SHA256;
9539 salt_type = SALT_TYPE_EMBEDDED;
9540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9541 opts_type = OPTS_TYPE_PT_GENERATE_BE
9542 | OPTS_TYPE_ST_ADD80
9543 | OPTS_TYPE_ST_ADDBITS15
9544 | OPTS_TYPE_HASH_COPY;
9545 kern_type = KERN_TYPE_SHA256_PWSLT;
9546 dgst_size = DGST_SIZE_4_8;
9547 parse_func = pdf17l3_parse_hash;
9548 sort_by_digest = sort_by_digest_4_8;
9549 opti_type = OPTI_TYPE_ZERO_BYTE
9550 | OPTI_TYPE_PRECOMPUTE_INIT
9551 | OPTI_TYPE_PRECOMPUTE_MERKLE
9552 | OPTI_TYPE_EARLY_SKIP
9553 | OPTI_TYPE_NOT_ITERATED
9554 | OPTI_TYPE_APPENDED_SALT
9555 | OPTI_TYPE_RAW_HASH;
9556 dgst_pos0 = 3;
9557 dgst_pos1 = 7;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 6;
9560 break;
9561
9562 case 10700: hash_type = HASH_TYPE_PDFU32;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE
9566 | OPTS_TYPE_HASH_COPY;
9567 kern_type = KERN_TYPE_PDF17L8;
9568 dgst_size = DGST_SIZE_4_8;
9569 parse_func = pdf17l8_parse_hash;
9570 sort_by_digest = sort_by_digest_4_8;
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 10800: hash_type = HASH_TYPE_SHA384;
9580 salt_type = SALT_TYPE_NONE;
9581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9582 opts_type = OPTS_TYPE_PT_GENERATE_BE
9583 | OPTS_TYPE_PT_ADD80
9584 | OPTS_TYPE_PT_ADDBITS15;
9585 kern_type = KERN_TYPE_SHA384;
9586 dgst_size = DGST_SIZE_8_8;
9587 parse_func = sha384_parse_hash;
9588 sort_by_digest = sort_by_digest_8_8;
9589 opti_type = OPTI_TYPE_ZERO_BYTE
9590 | OPTI_TYPE_PRECOMPUTE_INIT
9591 | OPTI_TYPE_PRECOMPUTE_MERKLE
9592 | OPTI_TYPE_EARLY_SKIP
9593 | OPTI_TYPE_NOT_ITERATED
9594 | OPTI_TYPE_NOT_SALTED
9595 | OPTI_TYPE_RAW_HASH;
9596 dgst_pos0 = 6;
9597 dgst_pos1 = 7;
9598 dgst_pos2 = 4;
9599 dgst_pos3 = 5;
9600 break;
9601
9602 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE
9606 | OPTS_TYPE_ST_BASE64
9607 | OPTS_TYPE_HASH_COPY;
9608 kern_type = KERN_TYPE_PBKDF2_SHA256;
9609 dgst_size = DGST_SIZE_4_32;
9610 parse_func = pbkdf2_sha256_parse_hash;
9611 sort_by_digest = sort_by_digest_4_32;
9612 opti_type = OPTI_TYPE_ZERO_BYTE;
9613 dgst_pos0 = 0;
9614 dgst_pos1 = 1;
9615 dgst_pos2 = 2;
9616 dgst_pos3 = 3;
9617 break;
9618
9619 case 11000: hash_type = HASH_TYPE_MD5;
9620 salt_type = SALT_TYPE_INTERN;
9621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9622 opts_type = OPTS_TYPE_PT_GENERATE_LE
9623 | OPTS_TYPE_PT_ADD80;
9624 kern_type = KERN_TYPE_PRESTASHOP;
9625 dgst_size = DGST_SIZE_4_4;
9626 parse_func = prestashop_parse_hash;
9627 sort_by_digest = sort_by_digest_4_4;
9628 opti_type = OPTI_TYPE_ZERO_BYTE
9629 | OPTI_TYPE_PRECOMPUTE_INIT
9630 | OPTI_TYPE_NOT_ITERATED
9631 | OPTI_TYPE_PREPENDED_SALT;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 3;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 1;
9636 break;
9637
9638 case 11100: hash_type = HASH_TYPE_MD5;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE
9642 | OPTS_TYPE_ST_ADD80;
9643 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9644 dgst_size = DGST_SIZE_4_4;
9645 parse_func = postgresql_auth_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4;
9647 opti_type = OPTI_TYPE_ZERO_BYTE
9648 | OPTI_TYPE_PRECOMPUTE_INIT
9649 | OPTI_TYPE_PRECOMPUTE_MERKLE
9650 | OPTI_TYPE_EARLY_SKIP;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 3;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 1;
9655 break;
9656
9657 case 11200: hash_type = HASH_TYPE_SHA1;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_BE
9661 | OPTS_TYPE_PT_ADD80
9662 | OPTS_TYPE_ST_HEX;
9663 kern_type = KERN_TYPE_MYSQL_AUTH;
9664 dgst_size = DGST_SIZE_4_5;
9665 parse_func = mysql_auth_parse_hash;
9666 sort_by_digest = sort_by_digest_4_5;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_EARLY_SKIP;
9669 dgst_pos0 = 3;
9670 dgst_pos1 = 4;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 1;
9673 break;
9674
9675 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE
9679 | OPTS_TYPE_ST_HEX
9680 | OPTS_TYPE_ST_ADD80;
9681 kern_type = KERN_TYPE_BITCOIN_WALLET;
9682 dgst_size = DGST_SIZE_4_4;
9683 parse_func = bitcoin_wallet_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4;
9685 opti_type = OPTI_TYPE_ZERO_BYTE;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 11400: hash_type = HASH_TYPE_MD5;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE
9696 | OPTS_TYPE_PT_ADD80
9697 | OPTS_TYPE_HASH_COPY;
9698 kern_type = KERN_TYPE_SIP_AUTH;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = sip_auth_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 3;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 1;
9707 break;
9708
9709 case 11500: hash_type = HASH_TYPE_CRC32;
9710 salt_type = SALT_TYPE_INTERN;
9711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE
9713 | OPTS_TYPE_ST_GENERATE_LE
9714 | OPTS_TYPE_ST_HEX;
9715 kern_type = KERN_TYPE_CRC32;
9716 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9717 parse_func = crc32_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9719 opti_type = OPTI_TYPE_ZERO_BYTE;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 11600: hash_type = HASH_TYPE_AES;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE
9730 | OPTS_TYPE_PT_NEVERCRACK;
9731 kern_type = KERN_TYPE_SEVEN_ZIP;
9732 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9733 parse_func = seven_zip_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9735 opti_type = OPTI_TYPE_ZERO_BYTE;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9743 salt_type = SALT_TYPE_NONE;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE
9746 | OPTS_TYPE_PT_ADD01;
9747 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9748 dgst_size = DGST_SIZE_4_8;
9749 parse_func = gost2012sbog_256_parse_hash;
9750 sort_by_digest = sort_by_digest_4_8;
9751 opti_type = OPTI_TYPE_ZERO_BYTE;
9752 dgst_pos0 = 0;
9753 dgst_pos1 = 1;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 3;
9756 break;
9757
9758 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9759 salt_type = SALT_TYPE_NONE;
9760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_LE
9762 | OPTS_TYPE_PT_ADD01;
9763 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9764 dgst_size = DGST_SIZE_4_16;
9765 parse_func = gost2012sbog_512_parse_hash;
9766 sort_by_digest = sort_by_digest_4_16;
9767 opti_type = OPTI_TYPE_ZERO_BYTE;
9768 dgst_pos0 = 0;
9769 dgst_pos1 = 1;
9770 dgst_pos2 = 2;
9771 dgst_pos3 = 3;
9772 break;
9773
9774 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9775 salt_type = SALT_TYPE_EMBEDDED;
9776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9777 opts_type = OPTS_TYPE_PT_GENERATE_LE
9778 | OPTS_TYPE_ST_BASE64
9779 | OPTS_TYPE_HASH_COPY;
9780 kern_type = KERN_TYPE_PBKDF2_MD5;
9781 dgst_size = DGST_SIZE_4_32;
9782 parse_func = pbkdf2_md5_parse_hash;
9783 sort_by_digest = sort_by_digest_4_32;
9784 opti_type = OPTI_TYPE_ZERO_BYTE;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 1;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 3;
9789 break;
9790
9791 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9792 salt_type = SALT_TYPE_EMBEDDED;
9793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE
9795 | OPTS_TYPE_ST_BASE64
9796 | OPTS_TYPE_HASH_COPY;
9797 kern_type = KERN_TYPE_PBKDF2_SHA1;
9798 dgst_size = DGST_SIZE_4_32;
9799 parse_func = pbkdf2_sha1_parse_hash;
9800 sort_by_digest = sort_by_digest_4_32;
9801 opti_type = OPTI_TYPE_ZERO_BYTE;
9802 dgst_pos0 = 0;
9803 dgst_pos1 = 1;
9804 dgst_pos2 = 2;
9805 dgst_pos3 = 3;
9806 break;
9807
9808 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9809 salt_type = SALT_TYPE_EMBEDDED;
9810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9811 opts_type = OPTS_TYPE_PT_GENERATE_LE
9812 | OPTS_TYPE_ST_BASE64
9813 | OPTS_TYPE_HASH_COPY;
9814 kern_type = KERN_TYPE_PBKDF2_SHA512;
9815 dgst_size = DGST_SIZE_8_16;
9816 parse_func = pbkdf2_sha512_parse_hash;
9817 sort_by_digest = sort_by_digest_8_16;
9818 opti_type = OPTI_TYPE_ZERO_BYTE;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9829 kern_type = KERN_TYPE_ECRYPTFS;
9830 dgst_size = DGST_SIZE_8_8;
9831 parse_func = ecryptfs_parse_hash;
9832 sort_by_digest = sort_by_digest_8_8;
9833 opti_type = OPTI_TYPE_ZERO_BYTE;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 12300: hash_type = HASH_TYPE_ORACLET;
9841 salt_type = SALT_TYPE_EMBEDDED;
9842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9844 kern_type = KERN_TYPE_ORACLET;
9845 dgst_size = DGST_SIZE_8_16;
9846 parse_func = oraclet_parse_hash;
9847 sort_by_digest = sort_by_digest_8_16;
9848 opti_type = OPTI_TYPE_ZERO_BYTE;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9856 salt_type = SALT_TYPE_EMBEDDED;
9857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9859 kern_type = KERN_TYPE_BSDICRYPT;
9860 dgst_size = DGST_SIZE_4_4;
9861 parse_func = bsdicrypt_parse_hash;
9862 sort_by_digest = sort_by_digest_4_4;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9865 dgst_pos0 = 0;
9866 dgst_pos1 = 1;
9867 dgst_pos2 = 2;
9868 dgst_pos3 = 3;
9869 break;
9870
9871 case 12500: hash_type = HASH_TYPE_RAR3HP;
9872 salt_type = SALT_TYPE_EMBEDDED;
9873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9874 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9875 kern_type = KERN_TYPE_RAR3;
9876 dgst_size = DGST_SIZE_4_4;
9877 parse_func = rar3hp_parse_hash;
9878 sort_by_digest = sort_by_digest_4_4;
9879 opti_type = OPTI_TYPE_ZERO_BYTE;
9880 dgst_pos0 = 0;
9881 dgst_pos1 = 1;
9882 dgst_pos2 = 2;
9883 dgst_pos3 = 3;
9884 break;
9885
9886 case 12600: hash_type = HASH_TYPE_SHA256;
9887 salt_type = SALT_TYPE_INTERN;
9888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_BE
9890 | OPTS_TYPE_PT_ADD80;
9891 kern_type = KERN_TYPE_CF10;
9892 dgst_size = DGST_SIZE_4_8;
9893 parse_func = cf10_parse_hash;
9894 sort_by_digest = sort_by_digest_4_8;
9895 opti_type = OPTI_TYPE_ZERO_BYTE
9896 | OPTI_TYPE_PRECOMPUTE_INIT
9897 | OPTI_TYPE_EARLY_SKIP
9898 | OPTI_TYPE_NOT_ITERATED;
9899 dgst_pos0 = 3;
9900 dgst_pos1 = 7;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 6;
9903 break;
9904
9905 case 12700: hash_type = HASH_TYPE_AES;
9906 salt_type = SALT_TYPE_EMBEDDED;
9907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9908 opts_type = OPTS_TYPE_PT_GENERATE_LE
9909 | OPTS_TYPE_HASH_COPY;
9910 kern_type = KERN_TYPE_MYWALLET;
9911 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9912 parse_func = mywallet_parse_hash;
9913 sort_by_digest = sort_by_digest_4_5;
9914 opti_type = OPTI_TYPE_ZERO_BYTE;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9925 kern_type = KERN_TYPE_MS_DRSR;
9926 dgst_size = DGST_SIZE_4_8;
9927 parse_func = ms_drsr_parse_hash;
9928 sort_by_digest = sort_by_digest_4_8;
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9937 salt_type = SALT_TYPE_EMBEDDED;
9938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9940 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9941 dgst_size = DGST_SIZE_4_8;
9942 parse_func = androidfde_samsung_parse_hash;
9943 sort_by_digest = sort_by_digest_4_8;
9944 opti_type = OPTI_TYPE_ZERO_BYTE;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 1;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 3;
9949 break;
9950
9951 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9952 salt_type = SALT_TYPE_EMBEDDED;
9953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9955 kern_type = KERN_TYPE_RAR5;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = rar5_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 default: usage_mini_print (PROGNAME); return (-1);
9967 }
9968
9969 /**
9970 * transpose
9971 */
9972
9973 data.parse_func = parse_func;
9974
9975 /**
9976 * misc stuff
9977 */
9978
9979 if (hex_salt)
9980 {
9981 if (salt_type == SALT_TYPE_INTERN)
9982 {
9983 opts_type |= OPTS_TYPE_ST_HEX;
9984 }
9985 else
9986 {
9987 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9988
9989 return (-1);
9990 }
9991 }
9992
9993 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9994 | (salt_type == SALT_TYPE_EXTERN)
9995 | (salt_type == SALT_TYPE_EMBEDDED)
9996 | (salt_type == SALT_TYPE_VIRTUAL));
9997
9998 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9999
10000 data.hash_type = hash_type;
10001 data.attack_mode = attack_mode;
10002 data.attack_kern = attack_kern;
10003 data.attack_exec = attack_exec;
10004 data.kern_type = kern_type;
10005 data.opts_type = opts_type;
10006 data.dgst_size = dgst_size;
10007 data.salt_type = salt_type;
10008 data.isSalted = isSalted;
10009 data.sort_by_digest = sort_by_digest;
10010 data.dgst_pos0 = dgst_pos0;
10011 data.dgst_pos1 = dgst_pos1;
10012 data.dgst_pos2 = dgst_pos2;
10013 data.dgst_pos3 = dgst_pos3;
10014
10015 esalt_size = 0;
10016
10017 switch (hash_mode)
10018 {
10019 case 2500: esalt_size = sizeof (wpa_t); break;
10020 case 5300: esalt_size = sizeof (ikepsk_t); break;
10021 case 5400: esalt_size = sizeof (ikepsk_t); break;
10022 case 5500: esalt_size = sizeof (netntlm_t); break;
10023 case 5600: esalt_size = sizeof (netntlm_t); break;
10024 case 6211:
10025 case 6212:
10026 case 6213:
10027 case 6221:
10028 case 6222:
10029 case 6223:
10030 case 6231:
10031 case 6232:
10032 case 6233:
10033 case 6241:
10034 case 6242:
10035 case 6243: esalt_size = sizeof (tc_t); break;
10036 case 6600: esalt_size = sizeof (agilekey_t); break;
10037 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10038 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10039 case 7300: esalt_size = sizeof (rakp_t); break;
10040 case 7500: esalt_size = sizeof (krb5pa_t); break;
10041 case 8200: esalt_size = sizeof (cloudkey_t); break;
10042 case 8800: esalt_size = sizeof (androidfde_t); break;
10043 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10044 case 9400: esalt_size = sizeof (office2007_t); break;
10045 case 9500: esalt_size = sizeof (office2010_t); break;
10046 case 9600: esalt_size = sizeof (office2013_t); break;
10047 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10048 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10049 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10050 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10051 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10052 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10053 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10054 case 10200: esalt_size = sizeof (cram_md5_t); break;
10055 case 10400: esalt_size = sizeof (pdf_t); break;
10056 case 10410: esalt_size = sizeof (pdf_t); break;
10057 case 10420: esalt_size = sizeof (pdf_t); break;
10058 case 10500: esalt_size = sizeof (pdf_t); break;
10059 case 10600: esalt_size = sizeof (pdf_t); break;
10060 case 10700: esalt_size = sizeof (pdf_t); break;
10061 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10062 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10063 case 11400: esalt_size = sizeof (sip_t); break;
10064 case 11600: esalt_size = sizeof (seven_zip_t); break;
10065 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10066 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10067 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10068 case 13000: esalt_size = sizeof (rar5_t); break;
10069 }
10070
10071 data.esalt_size = esalt_size;
10072
10073 /**
10074 * choose dictionary parser
10075 */
10076
10077 if (hash_type == HASH_TYPE_LM)
10078 {
10079 get_next_word_func = get_next_word_lm;
10080 }
10081 else if (opts_type & OPTS_TYPE_PT_UPPER)
10082 {
10083 get_next_word_func = get_next_word_uc;
10084 }
10085 else
10086 {
10087 get_next_word_func = get_next_word_std;
10088 }
10089
10090 /**
10091 * dictstat
10092 */
10093
10094 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10095
10096 #ifdef _POSIX
10097 size_t dictstat_nmemb = 0;
10098 #endif
10099
10100 #ifdef _WIN
10101 uint dictstat_nmemb = 0;
10102 #endif
10103
10104 char dictstat[256];
10105
10106 FILE *dictstat_fp = NULL;
10107
10108 if (keyspace == 0)
10109 {
10110 memset (dictstat, 0, sizeof (dictstat));
10111
10112 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10113
10114 dictstat_fp = fopen (dictstat, "rb");
10115
10116 if (dictstat_fp)
10117 {
10118 #ifdef _POSIX
10119 struct stat tmpstat;
10120
10121 fstat (fileno (dictstat_fp), &tmpstat);
10122 #endif
10123
10124 #ifdef _WIN
10125 struct stat64 tmpstat;
10126
10127 _fstat64 (fileno (dictstat_fp), &tmpstat);
10128 #endif
10129
10130 if (tmpstat.st_mtime < COMPTIME)
10131 {
10132 /* with v0.15 the format changed so we have to ensure user is using a good version
10133 since there is no version-header in the dictstat file */
10134
10135 fclose (dictstat_fp);
10136
10137 unlink (dictstat);
10138 }
10139 else
10140 {
10141 while (!feof (dictstat_fp))
10142 {
10143 dictstat_t d;
10144
10145 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10146
10147 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10148
10149 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10150 {
10151 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10152
10153 return -1;
10154 }
10155 }
10156
10157 fclose (dictstat_fp);
10158 }
10159 }
10160 }
10161
10162 /**
10163 * potfile
10164 */
10165
10166 char potfile[256] = { 0 };
10167
10168 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10169
10170 data.pot_fp = NULL;
10171
10172 FILE *out_fp = NULL;
10173 FILE *pot_fp = NULL;
10174
10175 if (show == 1 || left == 1)
10176 {
10177 pot_fp = fopen (potfile, "rb");
10178
10179 if (pot_fp == NULL)
10180 {
10181 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10182
10183 return (-1);
10184 }
10185
10186 if (outfile != NULL)
10187 {
10188 if ((out_fp = fopen (outfile, "ab")) == NULL)
10189 {
10190 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10191
10192 fclose (pot_fp);
10193
10194 return (-1);
10195 }
10196 }
10197 else
10198 {
10199 out_fp = stdout;
10200 }
10201 }
10202 else
10203 {
10204 if (potfile_disable == 0)
10205 {
10206 pot_fp = fopen (potfile, "ab");
10207
10208 if (pot_fp == NULL)
10209 {
10210 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10211
10212 return (-1);
10213 }
10214
10215 data.pot_fp = pot_fp;
10216 }
10217 }
10218
10219 pot_t *pot = NULL;
10220
10221 uint pot_cnt = 0;
10222 uint pot_avail = 0;
10223
10224 if (show == 1 || left == 1)
10225 {
10226 SUPPRESS_OUTPUT = 1;
10227
10228 pot_avail = count_lines (pot_fp);
10229
10230 rewind (pot_fp);
10231
10232 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10233
10234 uint pot_hashes_avail = 0;
10235
10236 uint line_num = 0;
10237
10238 while (!feof (pot_fp))
10239 {
10240 line_num++;
10241
10242 char line_buf[BUFSIZ];
10243
10244 int line_len = fgetl (pot_fp, line_buf);
10245
10246 if (line_len == 0) continue;
10247
10248 char *plain_buf = line_buf + line_len;
10249
10250 pot_t *pot_ptr = &pot[pot_cnt];
10251
10252 hash_t *hashes_buf = &pot_ptr->hash;
10253
10254 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10255 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10256
10257 if (pot_cnt == pot_hashes_avail)
10258 {
10259 uint pos = 0;
10260
10261 for (pos = 0; pos < INCR_POT; pos++)
10262 {
10263 if ((pot_cnt + pos) >= pot_avail) break;
10264
10265 pot_t *tmp_pot = &pot[pot_cnt + pos];
10266
10267 hash_t *tmp_hash = &tmp_pot->hash;
10268
10269 tmp_hash->digest = mymalloc (dgst_size);
10270
10271 if (isSalted)
10272 {
10273 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10274 }
10275
10276 if (esalt_size)
10277 {
10278 tmp_hash->esalt = mymalloc (esalt_size);
10279 }
10280
10281 pot_hashes_avail++;
10282 }
10283 }
10284
10285 int plain_len = 0;
10286
10287 int parser_status;
10288
10289 int iter = MAX_CUT_TRIES;
10290
10291 do
10292 {
10293 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10294 {
10295 if (line_buf[i] == ':')
10296 {
10297 line_len--;
10298
10299 break;
10300 }
10301 }
10302
10303 if (data.hash_mode != 2500)
10304 {
10305 parser_status = parse_func (line_buf, line_len, hashes_buf);
10306 }
10307 else
10308 {
10309 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10310
10311 if (line_len > max_salt_size)
10312 {
10313 parser_status = PARSER_GLOBAL_LENGTH;
10314 }
10315 else
10316 {
10317 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10318
10319 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10320
10321 hashes_buf->salt->salt_len = line_len;
10322
10323 parser_status = PARSER_OK;
10324 }
10325 }
10326
10327 // if NOT parsed without error, we add the ":" to the plain
10328
10329 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10330 {
10331 plain_len++;
10332 plain_buf--;
10333 }
10334
10335 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10336
10337 if (parser_status < PARSER_GLOBAL_ZERO)
10338 {
10339 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10340
10341 continue;
10342 }
10343
10344 if (plain_len >= 255) continue;
10345
10346 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10347
10348 pot_ptr->plain_len = plain_len;
10349
10350 pot_cnt++;
10351 }
10352
10353 fclose (pot_fp);
10354
10355 SUPPRESS_OUTPUT = 0;
10356
10357 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10358 }
10359
10360 /**
10361 * kernel accel and loops auto adjustment
10362 */
10363
10364 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10365 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10366
10367 if (workload_profile == 1)
10368 {
10369 kernel_loops /= 8;
10370 kernel_accel /= 4;
10371
10372 if (kernel_loops == 0) kernel_loops = 8;
10373 if (kernel_accel == 0) kernel_accel = 2;
10374 }
10375 else if (workload_profile == 3)
10376 {
10377 kernel_loops *= 8;
10378 kernel_accel *= 4;
10379
10380 if (kernel_loops > 1024) kernel_loops = 1024;
10381 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10382 }
10383
10384 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10385
10386 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10387 {
10388 kernel_loops = 1024;
10389 }
10390
10391 if (hash_mode == 12500)
10392 {
10393 kernel_loops = ROUNDS_RAR3 / 16;
10394 }
10395
10396 data.kernel_accel = kernel_accel;
10397 data.kernel_loops = kernel_loops;
10398
10399 /**
10400 * word len
10401 */
10402
10403 uint pw_min = PW_MIN;
10404 uint pw_max = PW_MAX;
10405
10406 switch (hash_mode)
10407 {
10408 case 400: if (pw_max > 40) pw_max = 40;
10409 break;
10410 case 500: if (pw_max > 16) pw_max = 16;
10411 break;
10412 case 1500: if (pw_max > 8) pw_max = 8;
10413 break;
10414 case 1600: if (pw_max > 16) pw_max = 16;
10415 break;
10416 case 1800: if (pw_max > 16) pw_max = 16;
10417 break;
10418 case 2100: if (pw_max > 16) pw_max = 16;
10419 break;
10420 case 2500: if (pw_min < 8) pw_min = 8;
10421 break;
10422 case 3000: if (pw_max > 7) pw_max = 7;
10423 break;
10424 case 5200: if (pw_max > 24) pw_max = 24;
10425 break;
10426 case 5800: if (pw_max > 16) pw_max = 16;
10427 break;
10428 case 6300: if (pw_max > 16) pw_max = 16;
10429 break;
10430 case 7400: if (pw_max > 16) pw_max = 16;
10431 break;
10432 case 7900: if (pw_max > 48) pw_max = 48;
10433 break;
10434 case 8500: if (pw_max > 8) pw_max = 8;
10435 break;
10436 case 8600: if (pw_max > 16) pw_max = 16;
10437 break;
10438 case 9710: pw_min = 5;
10439 pw_max = 5;
10440 break;
10441 case 9810: pw_min = 5;
10442 pw_max = 5;
10443 break;
10444 case 10410: pw_min = 5;
10445 pw_max = 5;
10446 break;
10447 case 10300: if (pw_max < 3) pw_min = 3;
10448 if (pw_max > 40) pw_max = 40;
10449 break;
10450 case 10500: if (pw_max < 3) pw_min = 3;
10451 if (pw_max > 40) pw_max = 40;
10452 break;
10453 case 10700: if (pw_max > 16) pw_max = 16;
10454 break;
10455 case 11300: if (pw_max > 40) pw_max = 40;
10456 break;
10457 case 12500: if (pw_max > 20) pw_max = 20;
10458 break;
10459 case 12800: if (pw_max > 24) pw_max = 24;
10460 break;
10461 }
10462
10463 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10464 {
10465 switch (attack_kern)
10466 {
10467 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10468 break;
10469 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10470 break;
10471 }
10472 }
10473
10474 /**
10475 * charsets : keep them together for more easy maintainnce
10476 */
10477
10478 cs_t mp_sys[6] = { { { 0 }, 0 } };
10479 cs_t mp_usr[4] = { { { 0 }, 0 } };
10480
10481 mp_setup_sys (mp_sys);
10482
10483 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10484 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10485 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10486 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10487
10488 /**
10489 * load hashes, part I: find input mode, count hashes
10490 */
10491
10492 uint hashlist_mode = 0;
10493 uint hashlist_format = HLFMT_HASHCAT;
10494
10495 uint hashes_avail = 0;
10496
10497 if (benchmark == 0)
10498 {
10499 struct stat f;
10500
10501 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10502
10503 if ((hash_mode == 2500) ||
10504 (hash_mode == 5200) ||
10505 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10506 (hash_mode == 9000))
10507 {
10508 hashlist_mode = HL_MODE_ARG;
10509
10510 char *hashfile = myargv[optind];
10511
10512 data.hashfile = hashfile;
10513
10514 logfile_top_var_string ("target", hashfile);
10515 }
10516
10517 if (hashlist_mode == HL_MODE_ARG)
10518 {
10519 if (hash_mode == 2500)
10520 {
10521 struct stat st;
10522
10523 if (stat (data.hashfile, &st) == -1)
10524 {
10525 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10526
10527 return (-1);
10528 }
10529
10530 hashes_avail = st.st_size / sizeof (hccap_t);
10531 }
10532 else
10533 {
10534 hashes_avail = 1;
10535 }
10536 }
10537 else if (hashlist_mode == HL_MODE_FILE)
10538 {
10539 char *hashfile = myargv[optind];
10540
10541 data.hashfile = hashfile;
10542
10543 logfile_top_var_string ("target", hashfile);
10544
10545 FILE *fp = NULL;
10546
10547 if ((fp = fopen (hashfile, "rb")) == NULL)
10548 {
10549 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10550
10551 return (-1);
10552 }
10553
10554 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10555
10556 hashes_avail = count_lines (fp);
10557
10558 rewind (fp);
10559
10560 if (hashes_avail == 0)
10561 {
10562 log_error ("ERROR: hashfile is empty or corrupt");
10563
10564 fclose (fp);
10565
10566 return (-1);
10567 }
10568
10569 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10570
10571 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10572 {
10573 log_error ("ERROR: remove not supported in native hashfile-format mode");
10574
10575 fclose (fp);
10576
10577 return (-1);
10578 }
10579
10580 fclose (fp);
10581 }
10582 }
10583 else
10584 {
10585 hashlist_mode = HL_MODE_ARG;
10586
10587 hashes_avail = 1;
10588 }
10589
10590 if (hash_mode == 3000) hashes_avail *= 2;
10591
10592 data.hashlist_mode = hashlist_mode;
10593 data.hashlist_format = hashlist_format;
10594
10595 logfile_top_uint (hashlist_mode);
10596 logfile_top_uint (hashlist_format);
10597
10598 /**
10599 * load hashes, part II: allocate required memory, set pointers
10600 */
10601
10602 hash_t *hashes_buf = NULL;
10603 void *digests_buf = NULL;
10604 salt_t *salts_buf = NULL;
10605 void *esalts_buf = NULL;
10606
10607 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10608
10609 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10610
10611 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10612 {
10613 u32 hash_pos;
10614
10615 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10616 {
10617 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10618
10619 hashes_buf[hash_pos].hash_info = hash_info;
10620
10621 if (username && (remove || show || left))
10622 {
10623 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10624 }
10625
10626 if (benchmark)
10627 {
10628 hash_info->orighash = (char *) mymalloc (256);
10629 }
10630 }
10631 }
10632
10633 if (isSalted)
10634 {
10635 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10636
10637 if (esalt_size)
10638 {
10639 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10640 }
10641 }
10642 else
10643 {
10644 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10645 }
10646
10647 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10648 {
10649 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10650
10651 if (isSalted)
10652 {
10653 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10654
10655 if (esalt_size)
10656 {
10657 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10658 }
10659 }
10660 else
10661 {
10662 hashes_buf[hash_pos].salt = &salts_buf[0];
10663 }
10664 }
10665
10666 /**
10667 * load hashes, part III: parse hashes or generate them if benchmark
10668 */
10669
10670 uint hashes_cnt = 0;
10671
10672 if (benchmark == 0)
10673 {
10674 if (keyspace == 1)
10675 {
10676 // useless to read hash file for keyspace, cheat a little bit w/ optind
10677 }
10678 else if (hashes_avail == 0)
10679 {
10680 }
10681 else if (hashlist_mode == HL_MODE_ARG)
10682 {
10683 char *input_buf = myargv[optind];
10684
10685 uint input_len = strlen (input_buf);
10686
10687 logfile_top_var_string ("target", input_buf);
10688
10689 char *hash_buf = NULL;
10690 int hash_len = 0;
10691
10692 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10693
10694 if (hash_len)
10695 {
10696 if (opts_type & OPTS_TYPE_HASH_COPY)
10697 {
10698 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10699
10700 hash_info_tmp->orighash = mystrdup (hash_buf);
10701 }
10702
10703 if (isSalted)
10704 {
10705 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10706 }
10707
10708 int parser_status = PARSER_OK;
10709
10710 if (hash_mode == 2500)
10711 {
10712 if (hash_len == 0)
10713 {
10714 log_error ("ERROR: hccap file not specified");
10715
10716 return (-1);
10717 }
10718
10719 hashlist_mode = HL_MODE_FILE;
10720
10721 data.hashlist_mode = hashlist_mode;
10722
10723 FILE *fp = fopen (hash_buf, "rb");
10724
10725 if (fp == NULL)
10726 {
10727 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10728
10729 return (-1);
10730 }
10731
10732 if (hashes_avail < 1)
10733 {
10734 log_error ("ERROR: hccap file is empty or corrupt");
10735
10736 fclose (fp);
10737
10738 return (-1);
10739 }
10740
10741 uint hccap_size = sizeof (hccap_t);
10742
10743 char in[hccap_size];
10744
10745 while (!feof (fp))
10746 {
10747 int n = fread (&in, hccap_size, 1, fp);
10748
10749 if (n != 1)
10750 {
10751 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10752
10753 break;
10754 }
10755
10756 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10757
10758 if (parser_status != PARSER_OK)
10759 {
10760 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10761
10762 continue;
10763 }
10764
10765 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10766
10767 if ((show == 1) || (left == 1))
10768 {
10769 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10770
10771 char *salt_ptr = (char *) tmp_salt->salt_buf;
10772
10773 int cur_pos = tmp_salt->salt_len;
10774 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10775
10776 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10777
10778 u8 *pke_ptr = (u8 *) wpa->pke;
10779
10780 // do the appending task
10781
10782 snprintf (salt_ptr + cur_pos,
10783 rem_len,
10784 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10785 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10786 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10787
10788
10789 // memset () the remaining part of the salt
10790
10791 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10792 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10793
10794 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10795
10796 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10797 }
10798
10799 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);
10800 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);
10801
10802 hashes_cnt++;
10803 }
10804
10805 fclose (fp);
10806 }
10807 else if (hash_mode == 3000)
10808 {
10809 if (hash_len == 32)
10810 {
10811 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10812
10813 hash_t *lm_hash_left = NULL;
10814
10815 if (parser_status == PARSER_OK)
10816 {
10817 lm_hash_left = &hashes_buf[hashes_cnt];
10818
10819 hashes_cnt++;
10820 }
10821 else
10822 {
10823 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10824 }
10825
10826
10827 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10828
10829 hash_t *lm_hash_right = NULL;
10830
10831 if (parser_status == PARSER_OK)
10832 {
10833 lm_hash_right = &hashes_buf[hashes_cnt];
10834
10835 hashes_cnt++;
10836 }
10837 else
10838 {
10839 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10840 }
10841
10842 // show / left
10843
10844 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10845 {
10846 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);
10847 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);
10848 }
10849 }
10850 else
10851 {
10852 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10853
10854 if (parser_status == PARSER_OK)
10855 {
10856 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10857 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10858 }
10859
10860 if (parser_status == PARSER_OK)
10861 {
10862 hashes_cnt++;
10863 }
10864 else
10865 {
10866 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10867 }
10868 }
10869 }
10870 else
10871 {
10872 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10873
10874 if (parser_status == PARSER_OK)
10875 {
10876 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10877 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10878 }
10879
10880 if (parser_status == PARSER_OK)
10881 {
10882 hashes_cnt++;
10883 }
10884 else
10885 {
10886 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10887 }
10888 }
10889 }
10890 }
10891 else if (hashlist_mode == HL_MODE_FILE)
10892 {
10893 char *hashfile = data.hashfile;
10894
10895 FILE *fp;
10896
10897 if ((fp = fopen (hashfile, "rb")) == NULL)
10898 {
10899 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10900
10901 return (-1);
10902 }
10903
10904 uint line_num = 0;
10905
10906 while (!feof (fp))
10907 {
10908 line_num++;
10909
10910 char line_buf[BUFSIZ];
10911
10912 int line_len = fgetl (fp, line_buf);
10913
10914 if (line_len == 0) continue;
10915
10916 char *hash_buf = NULL;
10917 int hash_len = 0;
10918
10919 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10920
10921 if (username)
10922 {
10923 char *user_buf = NULL;
10924 int user_len = 0;
10925
10926 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10927
10928 if (remove || show)
10929 {
10930 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10931
10932 *user = (user_t *) malloc (sizeof (user_t));
10933
10934 user_t *user_ptr = *user;
10935
10936 if (user_buf != NULL)
10937 {
10938 user_ptr->user_name = mystrdup (user_buf);
10939 }
10940 else
10941 {
10942 user_ptr->user_name = mystrdup ("");
10943 }
10944
10945 user_ptr->user_len = user_len;
10946 }
10947 }
10948
10949 if (opts_type & OPTS_TYPE_HASH_COPY)
10950 {
10951 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10952
10953 hash_info_tmp->orighash = mystrdup (hash_buf);
10954 }
10955
10956 if (isSalted)
10957 {
10958 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10959 }
10960
10961 if (hash_mode == 3000)
10962 {
10963 if (hash_len == 32)
10964 {
10965 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10966
10967 if (parser_status < PARSER_GLOBAL_ZERO)
10968 {
10969 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10970
10971 continue;
10972 }
10973
10974 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10975
10976 hashes_cnt++;
10977
10978 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10979
10980 if (parser_status < PARSER_GLOBAL_ZERO)
10981 {
10982 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10983
10984 continue;
10985 }
10986
10987 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10988
10989 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);
10990
10991 hashes_cnt++;
10992
10993 // show / left
10994
10995 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);
10996 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);
10997 }
10998 else
10999 {
11000 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11001
11002 if (parser_status < PARSER_GLOBAL_ZERO)
11003 {
11004 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11005
11006 continue;
11007 }
11008
11009 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);
11010
11011 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11012 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11013
11014 hashes_cnt++;
11015 }
11016 }
11017 else
11018 {
11019 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11020
11021 if (parser_status < PARSER_GLOBAL_ZERO)
11022 {
11023 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11024
11025 continue;
11026 }
11027
11028 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);
11029
11030 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11031 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11032
11033 hashes_cnt++;
11034 }
11035 }
11036
11037 fclose (fp);
11038
11039 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11040
11041 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11042 }
11043 }
11044 else
11045 {
11046 if (isSalted)
11047 {
11048 hashes_buf[0].salt->salt_len = 8;
11049
11050 // special salt handling
11051
11052 switch (hash_mode)
11053 {
11054 case 1500: hashes_buf[0].salt->salt_len = 2;
11055 break;
11056 case 1731: hashes_buf[0].salt->salt_len = 4;
11057 break;
11058 case 2410: hashes_buf[0].salt->salt_len = 4;
11059 break;
11060 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11061 break;
11062 case 3100: hashes_buf[0].salt->salt_len = 1;
11063 break;
11064 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11065 break;
11066 case 5800: hashes_buf[0].salt->salt_len = 16;
11067 break;
11068 case 6800: hashes_buf[0].salt->salt_len = 32;
11069 break;
11070 case 8400: hashes_buf[0].salt->salt_len = 40;
11071 break;
11072 case 8800: hashes_buf[0].salt->salt_len = 16;
11073 break;
11074 case 8900: hashes_buf[0].salt->salt_len = 16;
11075 hashes_buf[0].salt->scrypt_N = 1024;
11076 hashes_buf[0].salt->scrypt_r = 1;
11077 hashes_buf[0].salt->scrypt_p = 1;
11078 break;
11079 case 9100: hashes_buf[0].salt->salt_len = 16;
11080 break;
11081 case 9300: hashes_buf[0].salt->salt_len = 14;
11082 hashes_buf[0].salt->scrypt_N = 16384;
11083 hashes_buf[0].salt->scrypt_r = 1;
11084 hashes_buf[0].salt->scrypt_p = 1;
11085 break;
11086 case 9400: hashes_buf[0].salt->salt_len = 16;
11087 break;
11088 case 9500: hashes_buf[0].salt->salt_len = 16;
11089 break;
11090 case 9600: hashes_buf[0].salt->salt_len = 16;
11091 break;
11092 case 9700: hashes_buf[0].salt->salt_len = 16;
11093 break;
11094 case 9710: hashes_buf[0].salt->salt_len = 16;
11095 break;
11096 case 9720: hashes_buf[0].salt->salt_len = 16;
11097 break;
11098 case 9800: hashes_buf[0].salt->salt_len = 16;
11099 break;
11100 case 9810: hashes_buf[0].salt->salt_len = 16;
11101 break;
11102 case 9820: hashes_buf[0].salt->salt_len = 16;
11103 break;
11104 case 10300: hashes_buf[0].salt->salt_len = 12;
11105 break;
11106 case 11500: hashes_buf[0].salt->salt_len = 4;
11107 break;
11108 case 11600: hashes_buf[0].salt->salt_len = 4;
11109 break;
11110 case 12400: hashes_buf[0].salt->salt_len = 4;
11111 break;
11112 case 12500: hashes_buf[0].salt->salt_len = 8;
11113 break;
11114 case 12600: hashes_buf[0].salt->salt_len = 64;
11115 break;
11116 }
11117
11118 // special esalt handling
11119
11120 switch (hash_mode)
11121 {
11122 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11123 break;
11124 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11125 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11126 break;
11127 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11128 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11129 break;
11130 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11131 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11132 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11133 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11134 break;
11135 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11136 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11137 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11138 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11139 break;
11140 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11141 break;
11142 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11143 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11144 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11145 break;
11146 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11147 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11148 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11149 break;
11150 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11151 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11152 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11153 break;
11154 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11155 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11156 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11157 break;
11158 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11159 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11160 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11161 break;
11162 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11163 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11164 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11165 break;
11166 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11167 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11168 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11169 break;
11170 }
11171 }
11172
11173 // set hashfile
11174
11175 switch (hash_mode)
11176 {
11177 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11178 break;
11179 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11180 break;
11181 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11182 break;
11183 case 6211:
11184 case 6212:
11185 case 6213:
11186 case 6221:
11187 case 6222:
11188 case 6223:
11189 case 6231:
11190 case 6232:
11191 case 6233:
11192 case 6241:
11193 case 6242:
11194 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11195 break;
11196 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11197 break;
11198 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11199 break;
11200 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11201 break;
11202 }
11203
11204 // set default iterations
11205
11206 switch (hash_mode)
11207 {
11208 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11209 break;
11210 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11211 break;
11212 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11213 break;
11214 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11215 break;
11216 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11217 break;
11218 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11219 break;
11220 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11221 break;
11222 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11223 break;
11224 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11225 break;
11226 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11227 break;
11228 case 6211:
11229 case 6212:
11230 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11231 break;
11232 case 6221:
11233 case 6222:
11234 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11235 break;
11236 case 6231:
11237 case 6232:
11238 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11239 break;
11240 case 6241:
11241 case 6242:
11242 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11243 break;
11244 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11245 break;
11246 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11247 break;
11248 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11249 break;
11250 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11251 break;
11252 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11253 break;
11254 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11255 break;
11256 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11257 break;
11258 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11259 break;
11260 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11261 break;
11262 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11263 break;
11264 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11265 break;
11266 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11267 break;
11268 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11269 break;
11270 case 8900: hashes_buf[0].salt->salt_iter = 1;
11271 break;
11272 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11273 break;
11274 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11275 break;
11276 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11277 break;
11278 case 9300: hashes_buf[0].salt->salt_iter = 1;
11279 break;
11280 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11281 break;
11282 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11283 break;
11284 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11285 break;
11286 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11287 break;
11288 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11289 break;
11290 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11291 break;
11292 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11293 break;
11294 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11295 break;
11296 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11297 break;
11298 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11299 break;
11300 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11301 break;
11302 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11303 break;
11304 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11305 break;
11306 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11307 break;
11308 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11309 break;
11310 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11311 break;
11312 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11313 break;
11314 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11315 break;
11316 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11317 break;
11318 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11319 break;
11320 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11321 break;
11322 }
11323
11324 // set special tuning for benchmark-mode 1
11325
11326 if (benchmark_mode == 1)
11327 {
11328 kernel_loops *= 8;
11329 kernel_accel *= 4;
11330
11331 switch (hash_mode)
11332 {
11333 case 400: kernel_loops = ROUNDS_PHPASS;
11334 kernel_accel = 32;
11335 break;
11336 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11337 kernel_accel = 32;
11338 break;
11339 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11340 kernel_accel = 32;
11341 break;
11342 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11343 kernel_accel = 32;
11344 break;
11345 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11346 kernel_accel = 16;
11347 break;
11348 case 2100: kernel_loops = ROUNDS_DCC2;
11349 kernel_accel = 16;
11350 break;
11351 case 2500: kernel_loops = ROUNDS_WPA2;
11352 kernel_accel = 32;
11353 break;
11354 case 3200: kernel_loops = ROUNDS_BCRYPT;
11355 kernel_accel = 8;
11356 break;
11357 case 5200: kernel_loops = ROUNDS_PSAFE3;
11358 kernel_accel = 16;
11359 break;
11360 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11361 kernel_accel = 16;
11362 break;
11363 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11364 kernel_accel = 64;
11365 break;
11366 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11367 kernel_accel = 32;
11368 break;
11369 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11370 kernel_accel = 32;
11371 break;
11372 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11373 kernel_accel = 8;
11374 break;
11375 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11376 kernel_accel = 8;
11377 break;
11378 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11379 kernel_accel = 8;
11380 break;
11381 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11382 kernel_accel = 8;
11383 break;
11384 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11385 kernel_accel = 8;
11386 break;
11387 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11388 kernel_accel = 8;
11389 break;
11390 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11391 kernel_accel = 128;
11392 break;
11393 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11394 kernel_accel = 64;
11395 break;
11396 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11397 kernel_accel = 64;
11398 break;
11399 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11400 kernel_accel = 32;
11401 break;
11402 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11403 kernel_accel = 128;
11404 break;
11405 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11406 kernel_accel = 128;
11407 break;
11408 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11409 kernel_accel = 32;
11410 break;
11411 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11412 kernel_accel = 64;
11413 break;
11414 case 6800: kernel_loops = ROUNDS_LASTPASS;
11415 kernel_accel = 64;
11416 break;
11417 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11418 kernel_accel = 8;
11419 break;
11420 case 7200: kernel_loops = ROUNDS_GRUB;
11421 kernel_accel = 16;
11422 break;
11423 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11424 kernel_accel = 8;
11425 break;
11426 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11427 kernel_accel = 8;
11428 break;
11429 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11430 kernel_accel = 8;
11431 break;
11432 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11433 kernel_accel = 32;
11434 break;
11435 case 8900: kernel_loops = 1;
11436 kernel_accel = 64;
11437 break;
11438 case 9000: kernel_loops = ROUNDS_PSAFE2;
11439 kernel_accel = 16;
11440 break;
11441 case 9100: kernel_loops = ROUNDS_LOTUS8;
11442 kernel_accel = 64;
11443 break;
11444 case 9200: kernel_loops = ROUNDS_CISCO8;
11445 kernel_accel = 8;
11446 break;
11447 case 9300: kernel_loops = 1;
11448 kernel_accel = 4;
11449 break;
11450 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11451 kernel_accel = 32;
11452 break;
11453 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11454 kernel_accel = 32;
11455 break;
11456 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11457 kernel_accel = 8;
11458 break;
11459 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11460 kernel_accel = 8;
11461 break;
11462 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11463 kernel_accel = 16;
11464 break;
11465 case 10500: kernel_loops = ROUNDS_PDF14;
11466 kernel_accel = 256;
11467 break;
11468 case 10700: kernel_loops = ROUNDS_PDF17L8;
11469 kernel_accel = 8;
11470 break;
11471 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11472 kernel_accel = 8;
11473 break;
11474 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11475 kernel_accel = 8;
11476 break;
11477 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11478 kernel_accel = 8;
11479 break;
11480 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11481 kernel_accel = 8;
11482 break;
11483 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11484 kernel_accel = 8;
11485 break;
11486 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11487 kernel_accel = 8;
11488 break;
11489 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11490 kernel_accel = 8;
11491 break;
11492 case 12300: kernel_loops = ROUNDS_ORACLET;
11493 kernel_accel = 8;
11494 break;
11495 case 12500: kernel_loops = ROUNDS_RAR3;
11496 kernel_accel = 32;
11497 break;
11498 case 12700: kernel_loops = ROUNDS_MYWALLET;
11499 kernel_accel = 512;
11500 break;
11501 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11502 kernel_accel = 512;
11503 break;
11504 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11505 kernel_accel = 8;
11506 break;
11507 case 13000: kernel_loops = ROUNDS_RAR5;
11508 kernel_accel = 8;
11509 break;
11510 }
11511
11512 // some algorithm collide too fast, make that impossible
11513
11514 switch (hash_mode)
11515 {
11516 case 11500: ((uint *) digests_buf)[1] = 1;
11517 break;
11518 }
11519
11520 if (kernel_loops > 1024) kernel_loops = 1024;
11521 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11522 }
11523
11524 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11525 {
11526 kernel_loops = 1024;
11527 }
11528
11529 if (hash_mode == 12500)
11530 {
11531 kernel_loops = ROUNDS_RAR3 / 16;
11532 }
11533
11534 data.kernel_accel = kernel_accel;
11535 data.kernel_loops = kernel_loops;
11536
11537 hashes_cnt = 1;
11538 }
11539
11540 if (show == 1 || left == 1)
11541 {
11542 for (uint i = 0; i < pot_cnt; i++)
11543 {
11544 pot_t *pot_ptr = &pot[i];
11545
11546 hash_t *hashes_buf = &pot_ptr->hash;
11547
11548 local_free (hashes_buf->digest);
11549
11550 if (isSalted)
11551 {
11552 local_free (hashes_buf->salt);
11553 }
11554 }
11555
11556 local_free (pot);
11557
11558 if (data.quiet == 0) log_info_nn ("");
11559
11560 return (0);
11561 }
11562
11563 if (keyspace == 0)
11564 {
11565 if (hashes_cnt == 0)
11566 {
11567 log_error ("ERROR: No hashes loaded");
11568
11569 return (-1);
11570 }
11571 }
11572
11573 /**
11574 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11575 */
11576
11577 if (data.outfile != NULL)
11578 {
11579 if (data.hashfile != NULL)
11580 {
11581 #ifdef _POSIX
11582 struct stat tmpstat_outfile;
11583 struct stat tmpstat_hashfile;
11584 #endif
11585
11586 #ifdef _WIN
11587 struct stat64 tmpstat_outfile;
11588 struct stat64 tmpstat_hashfile;
11589 #endif
11590
11591 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11592
11593 if (tmp_outfile_fp)
11594 {
11595 #ifdef _POSIX
11596 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11597 #endif
11598
11599 #ifdef _WIN
11600 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11601 #endif
11602
11603 fclose (tmp_outfile_fp);
11604 }
11605
11606 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11607
11608 if (tmp_hashfile_fp)
11609 {
11610 #ifdef _POSIX
11611 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11612 #endif
11613
11614 #ifdef _WIN
11615 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11616 #endif
11617
11618 fclose (tmp_hashfile_fp);
11619 }
11620
11621 if (tmp_outfile_fp && tmp_outfile_fp)
11622 {
11623 tmpstat_outfile.st_mode = 0;
11624 tmpstat_outfile.st_nlink = 0;
11625 tmpstat_outfile.st_uid = 0;
11626 tmpstat_outfile.st_gid = 0;
11627 tmpstat_outfile.st_rdev = 0;
11628 tmpstat_outfile.st_atime = 0;
11629
11630 tmpstat_hashfile.st_mode = 0;
11631 tmpstat_hashfile.st_nlink = 0;
11632 tmpstat_hashfile.st_uid = 0;
11633 tmpstat_hashfile.st_gid = 0;
11634 tmpstat_hashfile.st_rdev = 0;
11635 tmpstat_hashfile.st_atime = 0;
11636
11637 #ifdef _POSIX
11638 tmpstat_outfile.st_blksize = 0;
11639 tmpstat_outfile.st_blocks = 0;
11640
11641 tmpstat_hashfile.st_blksize = 0;
11642 tmpstat_hashfile.st_blocks = 0;
11643 #endif
11644
11645 #ifdef _POSIX
11646 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11647 {
11648 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11649
11650 return (-1);
11651 }
11652 #endif
11653
11654 #ifdef _WIN
11655 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11656 {
11657 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11658
11659 return (-1);
11660 }
11661 #endif
11662 }
11663 }
11664 }
11665
11666 /**
11667 * Remove duplicates
11668 */
11669
11670 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11671
11672 if (isSalted)
11673 {
11674 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11675 }
11676 else
11677 {
11678 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11679 }
11680
11681 uint hashes_cnt_orig = hashes_cnt;
11682
11683 hashes_cnt = 1;
11684
11685 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11686 {
11687 if (isSalted)
11688 {
11689 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11690 {
11691 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11692 }
11693 }
11694 else
11695 {
11696 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11697 }
11698
11699 if (hashes_pos > hashes_cnt)
11700 {
11701 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11702 }
11703
11704 hashes_cnt++;
11705 }
11706
11707 /**
11708 * Potfile removes
11709 */
11710
11711 uint potfile_remove_cracks = 0;
11712
11713 if (potfile_disable == 0)
11714 {
11715 hash_t hash_buf;
11716
11717 hash_buf.digest = mymalloc (dgst_size);
11718 hash_buf.salt = NULL;
11719 hash_buf.esalt = NULL;
11720 hash_buf.hash_info = NULL;
11721 hash_buf.cracked = 0;
11722
11723 if (isSalted)
11724 {
11725 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11726 }
11727
11728 if (esalt_size)
11729 {
11730 hash_buf.esalt = mymalloc (esalt_size);
11731 }
11732
11733 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11734
11735 // no solution for these special hash types (for instane because they use hashfile in output etc)
11736 if ((hash_mode != 5200) &&
11737 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11738 (hash_mode != 9000))
11739 {
11740 FILE *fp = fopen (potfile, "rb");
11741
11742 if (fp != NULL)
11743 {
11744 while (!feof (fp))
11745 {
11746 char line_buf[BUFSIZ];
11747
11748 memset (line_buf, 0, BUFSIZ);
11749
11750 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11751
11752 if (ptr == NULL) break;
11753
11754 int line_len = strlen (line_buf);
11755
11756 if (line_len == 0) continue;
11757
11758 int iter = MAX_CUT_TRIES;
11759
11760 for (int i = line_len - 1; i && iter; i--, line_len--)
11761 {
11762 if (line_buf[i] != ':') continue;
11763
11764 if (isSalted)
11765 {
11766 memset (hash_buf.salt, 0, sizeof (salt_t));
11767 }
11768
11769 hash_t *found = NULL;
11770
11771 if (hash_mode == 6800)
11772 {
11773 if (i < 48) // 48 = 12 * uint in salt_buf[]
11774 {
11775 // manipulate salt_buf
11776 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11777
11778 hash_buf.salt->salt_len = i;
11779
11780 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11781 }
11782 }
11783 else if (hash_mode == 2500)
11784 {
11785 if (i < 48) // 48 = 12 * uint in salt_buf[]
11786 {
11787 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11788 // manipulate salt_buf
11789
11790 // to be safe work with a copy (because of line_len loop, i etc)
11791
11792 char line_buf_cpy[BUFSIZ];
11793 memset (line_buf_cpy, 0, BUFSIZ);
11794
11795 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11796
11797 memcpy (line_buf_cpy, line_buf, i);
11798
11799 char *mac2_pos = strrchr (line_buf_cpy, ':');
11800
11801 if (mac2_pos == NULL) continue;
11802
11803 mac2_pos[0] = 0;
11804 mac2_pos++;
11805
11806 if (strlen (mac2_pos) != 12) continue;
11807
11808 char *mac1_pos = strrchr (line_buf_cpy, ':');
11809
11810 if (mac1_pos == NULL) continue;
11811
11812 mac1_pos[0] = 0;
11813 mac1_pos++;
11814
11815 if (strlen (mac1_pos) != 12) continue;
11816
11817 uint essid_length = mac1_pos - line_buf_cpy - 1;
11818
11819 // here we need the ESSID
11820 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11821
11822 hash_buf.salt->salt_len = essid_length;
11823
11824 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11825
11826 if (found)
11827 {
11828 wpa_t *wpa = (wpa_t *) found->esalt;
11829
11830 uint pke[25];
11831
11832 char *pke_ptr = (char *) pke;
11833
11834 for (uint i = 0; i < 25; i++)
11835 {
11836 pke[i] = byte_swap_32 (wpa->pke[i]);
11837 }
11838
11839 u8 mac1[6];
11840 u8 mac2[6];
11841
11842 memcpy (mac1, pke_ptr + 23, 6);
11843 memcpy (mac2, pke_ptr + 29, 6);
11844
11845 // compare hex string(s) vs binary MAC address(es)
11846
11847 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11848 {
11849 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11850 {
11851 found = NULL;
11852 break;
11853 }
11854 }
11855
11856 // early skip ;)
11857 if (!found) continue;
11858
11859 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11860 {
11861 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11862 {
11863 found = NULL;
11864 break;
11865 }
11866 }
11867 }
11868 }
11869 }
11870 else
11871 {
11872 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11873
11874 if (parser_status == PARSER_OK)
11875 {
11876 if (isSalted)
11877 {
11878 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11879 }
11880 else
11881 {
11882 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11883 }
11884 }
11885 }
11886
11887 if (found == NULL) continue;
11888
11889 if (!found->cracked) potfile_remove_cracks++;
11890
11891 found->cracked = 1;
11892
11893 if (found) break;
11894
11895 iter--;
11896 }
11897 }
11898
11899 fclose (fp);
11900 }
11901 }
11902
11903 if (esalt_size)
11904 {
11905 local_free (hash_buf.esalt);
11906 }
11907
11908 if (isSalted)
11909 {
11910 local_free (hash_buf.salt);
11911 }
11912
11913 local_free (hash_buf.digest);
11914 }
11915
11916 /**
11917 * Now generate all the buffers required for later
11918 */
11919
11920 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11921
11922 salt_t *salts_buf_new = NULL;
11923 void *esalts_buf_new = NULL;
11924
11925 if (isSalted)
11926 {
11927 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11928
11929 if (esalt_size)
11930 {
11931 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11932 }
11933 }
11934 else
11935 {
11936 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11937 }
11938
11939 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11940
11941 uint digests_cnt = hashes_cnt;
11942 uint digests_done = 0;
11943
11944 uint size_digests = digests_cnt * dgst_size;
11945 uint size_shown = digests_cnt * sizeof (uint);
11946
11947 uint *digests_shown = (uint *) mymalloc (size_shown);
11948 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11949
11950 uint salts_cnt = 0;
11951 uint salts_done = 0;
11952
11953 hashinfo_t **hash_info = NULL;
11954
11955 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11956 {
11957 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11958
11959 if (username && (remove || show))
11960 {
11961 uint user_pos;
11962
11963 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11964 {
11965 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11966
11967 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11968 }
11969 }
11970 }
11971
11972 uint *salts_shown = (uint *) mymalloc (size_shown);
11973
11974 salt_t *salt_buf;
11975
11976 {
11977 // copied from inner loop
11978
11979 salt_buf = &salts_buf_new[salts_cnt];
11980
11981 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11982
11983 if (esalt_size)
11984 {
11985 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11986 }
11987
11988 salt_buf->digests_cnt = 0;
11989 salt_buf->digests_done = 0;
11990 salt_buf->digests_offset = 0;
11991
11992 salts_cnt++;
11993 }
11994
11995 if (hashes_buf[0].cracked == 1)
11996 {
11997 digests_shown[0] = 1;
11998
11999 digests_done++;
12000
12001 salt_buf->digests_done++;
12002 }
12003
12004 salt_buf->digests_cnt++;
12005
12006 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12007
12008 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12009 {
12010 hash_info[0] = hashes_buf[0].hash_info;
12011 }
12012
12013 // copy from inner loop
12014
12015 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12016 {
12017 if (isSalted)
12018 {
12019 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12020 {
12021 salt_buf = &salts_buf_new[salts_cnt];
12022
12023 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12024
12025 if (esalt_size)
12026 {
12027 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12028 }
12029
12030 salt_buf->digests_cnt = 0;
12031 salt_buf->digests_done = 0;
12032 salt_buf->digests_offset = hashes_pos;
12033
12034 salts_cnt++;
12035 }
12036 }
12037
12038 if (hashes_buf[hashes_pos].cracked == 1)
12039 {
12040 digests_shown[hashes_pos] = 1;
12041
12042 digests_done++;
12043
12044 salt_buf->digests_done++;
12045 }
12046
12047 salt_buf->digests_cnt++;
12048
12049 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12050
12051 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12052 {
12053 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12054 }
12055 }
12056
12057 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12058 {
12059 salt_t *salt_buf = &salts_buf_new[salt_pos];
12060
12061 if (salt_buf->digests_done == salt_buf->digests_cnt)
12062 {
12063 salts_shown[salt_pos] = 1;
12064
12065 salts_done++;
12066 }
12067
12068 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12069 }
12070
12071 local_free (digests_buf);
12072 local_free (salts_buf);
12073 local_free (esalts_buf);
12074
12075 digests_buf = digests_buf_new;
12076 salts_buf = salts_buf_new;
12077 esalts_buf = esalts_buf_new;
12078
12079 local_free (hashes_buf);
12080
12081 /**
12082 * special modification not set from parser
12083 */
12084
12085 switch (hash_mode)
12086 {
12087 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12088 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12089 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12090 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12091 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12092 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12093 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12094 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12095 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12096 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12097 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12098 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12099 }
12100
12101 if (truecrypt_keyfiles)
12102 {
12103 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12104
12105 char *keyfiles = strdup (truecrypt_keyfiles);
12106
12107 char *keyfile = strtok (keyfiles, ",");
12108
12109 do
12110 {
12111 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12112
12113 } while ((keyfile = strtok (NULL, ",")) != NULL);
12114
12115 free (keyfiles);
12116 }
12117
12118 data.digests_cnt = digests_cnt;
12119 data.digests_done = digests_done;
12120 data.digests_buf = digests_buf;
12121 data.digests_shown = digests_shown;
12122 data.digests_shown_tmp = digests_shown_tmp;
12123
12124 data.salts_cnt = salts_cnt;
12125 data.salts_done = salts_done;
12126 data.salts_buf = salts_buf;
12127 data.salts_shown = salts_shown;
12128
12129 data.esalts_buf = esalts_buf;
12130 data.hash_info = hash_info;
12131
12132 /**
12133 * Automatic Optimizers
12134 */
12135
12136 if (salts_cnt == 1)
12137 opti_type |= OPTI_TYPE_SINGLE_SALT;
12138
12139 if (digests_cnt == 1)
12140 opti_type |= OPTI_TYPE_SINGLE_HASH;
12141
12142 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12143 opti_type |= OPTI_TYPE_NOT_ITERATED;
12144
12145 if (attack_mode == ATTACK_MODE_BF)
12146 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12147
12148 data.opti_type = opti_type;
12149
12150 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12151 {
12152 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12153 {
12154 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12155 {
12156 if (opts_type & OPTS_TYPE_ST_ADD80)
12157 {
12158 opts_type &= ~OPTS_TYPE_ST_ADD80;
12159 opts_type |= OPTS_TYPE_PT_ADD80;
12160 }
12161
12162 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12163 {
12164 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12165 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12166 }
12167
12168 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12169 {
12170 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12171 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12172 }
12173 }
12174 }
12175 }
12176
12177 /**
12178 * Some algorithm, like descrypt, can benefit from JIT compilation
12179 */
12180
12181 int force_jit_compilation = -1;
12182
12183 if (hash_mode == 8900)
12184 {
12185 force_jit_compilation = 8900;
12186 }
12187 else if (hash_mode == 9300)
12188 {
12189 force_jit_compilation = 8900;
12190 }
12191 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12192 {
12193 force_jit_compilation = 1500;
12194 }
12195
12196 /**
12197 * generate bitmap tables
12198 */
12199
12200 const uint bitmap_shift1 = 5;
12201 const uint bitmap_shift2 = 13;
12202
12203 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12204
12205 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12206 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12207 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12208 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12209 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12210 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12211 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12212 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12213
12214 uint bitmap_bits;
12215 uint bitmap_nums;
12216 uint bitmap_mask;
12217 uint bitmap_size;
12218
12219 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12220 {
12221 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12222
12223 bitmap_nums = 1 << bitmap_bits;
12224
12225 bitmap_mask = bitmap_nums - 1;
12226
12227 bitmap_size = bitmap_nums * sizeof (uint);
12228
12229 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12230
12231 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;
12232 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;
12233
12234 break;
12235 }
12236
12237 bitmap_nums = 1 << bitmap_bits;
12238
12239 bitmap_mask = bitmap_nums - 1;
12240
12241 bitmap_size = bitmap_nums * sizeof (uint);
12242
12243 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);
12244 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);
12245
12246 /**
12247 * prepare quick rule
12248 */
12249
12250 data.rule_buf_l = rule_buf_l;
12251 data.rule_buf_r = rule_buf_r;
12252
12253 int rule_len_l = (int) strlen (rule_buf_l);
12254 int rule_len_r = (int) strlen (rule_buf_r);
12255
12256 data.rule_len_l = rule_len_l;
12257 data.rule_len_r = rule_len_r;
12258
12259 /**
12260 * load rules
12261 */
12262
12263 uint *all_kernel_rules_cnt = NULL;
12264
12265 kernel_rule_t **all_kernel_rules_buf = NULL;
12266
12267 if (rp_files_cnt)
12268 {
12269 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12270
12271 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12272 }
12273
12274 char rule_buf[BUFSIZ];
12275
12276 int rule_len = 0;
12277
12278 for (uint i = 0; i < rp_files_cnt; i++)
12279 {
12280 uint kernel_rules_avail = 0;
12281
12282 uint kernel_rules_cnt = 0;
12283
12284 kernel_rule_t *kernel_rules_buf = NULL;
12285
12286 char *rp_file = rp_files[i];
12287
12288 char in[BLOCK_SIZE];
12289 char out[BLOCK_SIZE];
12290
12291 FILE *fp = NULL;
12292
12293 uint rule_line = 0;
12294
12295 if ((fp = fopen (rp_file, "rb")) == NULL)
12296 {
12297 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12298
12299 return (-1);
12300 }
12301
12302 while (!feof (fp))
12303 {
12304 memset (rule_buf, 0, BUFSIZ);
12305
12306 rule_len = fgetl (fp, rule_buf);
12307
12308 rule_line++;
12309
12310 if (rule_len == 0) continue;
12311
12312 if (rule_buf[0] == '#') continue;
12313
12314 if (kernel_rules_avail == kernel_rules_cnt)
12315 {
12316 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12317
12318 kernel_rules_avail += INCR_RULES;
12319 }
12320
12321 memset (in, 0, BLOCK_SIZE);
12322 memset (out, 0, BLOCK_SIZE);
12323
12324 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12325
12326 if (result == -1)
12327 {
12328 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12329
12330 continue;
12331 }
12332
12333 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12334 {
12335 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12336
12337 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12338
12339 continue;
12340 }
12341
12342 /* its so slow
12343 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12344 {
12345 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12346
12347 continue;
12348 }
12349 */
12350
12351 kernel_rules_cnt++;
12352 }
12353
12354 fclose (fp);
12355
12356 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12357
12358 all_kernel_rules_buf[i] = kernel_rules_buf;
12359 }
12360
12361 /**
12362 * merge rules or automatic rule generator
12363 */
12364
12365 uint kernel_rules_cnt = 0;
12366
12367 kernel_rule_t *kernel_rules_buf = NULL;
12368
12369 if (attack_mode == ATTACK_MODE_STRAIGHT)
12370 {
12371 if (rp_files_cnt)
12372 {
12373 kernel_rules_cnt = 1;
12374
12375 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12376
12377 repeats[0] = kernel_rules_cnt;
12378
12379 for (uint i = 0; i < rp_files_cnt; i++)
12380 {
12381 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12382
12383 repeats[i + 1] = kernel_rules_cnt;
12384 }
12385
12386 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12387
12388 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12389
12390 for (uint i = 0; i < kernel_rules_cnt; i++)
12391 {
12392 uint out_pos = 0;
12393
12394 kernel_rule_t *out = &kernel_rules_buf[i];
12395
12396 for (uint j = 0; j < rp_files_cnt; j++)
12397 {
12398 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12399 uint in_pos;
12400
12401 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12402
12403 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12404 {
12405 if (out_pos == RULES_MAX - 1)
12406 {
12407 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12408
12409 break;
12410 }
12411
12412 out->cmds[out_pos] = in->cmds[in_pos];
12413 }
12414 }
12415 }
12416
12417 local_free (repeats);
12418 }
12419 else if (rp_gen)
12420 {
12421 uint kernel_rules_avail = 0;
12422
12423 while (kernel_rules_cnt < rp_gen)
12424 {
12425 if (kernel_rules_avail == kernel_rules_cnt)
12426 {
12427 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12428
12429 kernel_rules_avail += INCR_RULES;
12430 }
12431
12432 memset (rule_buf, 0, BLOCK_SIZE);
12433
12434 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12435
12436 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12437
12438 kernel_rules_cnt++;
12439 }
12440 }
12441 }
12442
12443 /**
12444 * generate NOP rules
12445 */
12446
12447 if (kernel_rules_cnt == 0)
12448 {
12449 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12450
12451 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12452
12453 kernel_rules_cnt++;
12454 }
12455
12456 data.kernel_rules_cnt = kernel_rules_cnt;
12457 data.kernel_rules_buf = kernel_rules_buf;
12458
12459 /**
12460 * OpenCL platforms: detect
12461 */
12462
12463 cl_platform_id platforms[CL_PLATFORMS_MAX];
12464
12465 cl_uint platforms_cnt = 0;
12466
12467 cl_device_id platform_devices[DEVICES_MAX];
12468
12469 cl_uint platform_devices_cnt;
12470
12471 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12472
12473 if (platforms_cnt == 0)
12474 {
12475 log_error ("ERROR: No OpenCL compatible platform found");
12476
12477 return (-1);
12478 }
12479
12480 /**
12481 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12482 */
12483
12484 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12485 {
12486 cl_platform_id platform = platforms[platform_id];
12487
12488 char platform_vendor[INFOSZ] = { 0 };
12489
12490 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12491
12492 #ifdef HAVE_HWMON
12493 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12494 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12495 {
12496 // make sure that we do not directly control the fan for NVidia
12497
12498 gpu_temp_retain = 0;
12499
12500 data.gpu_temp_retain = gpu_temp_retain;
12501 }
12502 #endif // HAVE_NVML || HAVE_NVAPI
12503 #endif
12504 }
12505
12506 /**
12507 * OpenCL devices: simply push all devices from all platforms into the same device array
12508 */
12509
12510 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12511
12512 data.devices_param = devices_param;
12513
12514 uint devices_cnt = 0;
12515
12516 uint devices_active = 0;
12517
12518 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12519 {
12520 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12521
12522 cl_platform_id platform = platforms[platform_id];
12523
12524 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12525
12526 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12527 {
12528 const uint device_id = devices_cnt;
12529
12530 hc_device_param_t *device_param = &data.devices_param[device_id];
12531
12532 device_param->device = platform_devices[platform_devices_id];
12533
12534 device_param->device_id = device_id;
12535
12536 device_param->platform_devices_id = platform_devices_id;
12537
12538 // vendor_id
12539
12540 cl_uint vendor_id = 0;
12541
12542 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12543
12544 device_param->vendor_id = vendor_id;
12545
12546 // device_type
12547
12548 cl_device_type device_type;
12549
12550 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12551
12552 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12553
12554 device_param->device_type = device_type;
12555
12556 // device_name
12557
12558 char *device_name = (char *) mymalloc (INFOSZ);
12559
12560 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12561
12562 device_param->device_name = device_name;
12563
12564 // device_version
12565
12566 char *device_version = (char *) mymalloc (INFOSZ);
12567
12568 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12569
12570 device_param->device_version = device_version;
12571
12572 if (strstr (device_version, "pocl"))
12573 {
12574 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12575 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12576
12577 cl_uint vendor_id = 0xffff;
12578
12579 device_param->vendor_id = vendor_id;
12580 }
12581
12582 // max_compute_units
12583
12584 cl_uint vector_width;
12585
12586 if (attack_mode == ATTACK_MODE_BF)
12587 {
12588 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12589 {
12590 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12591 }
12592 else
12593 {
12594 vector_width = opencl_vector_width;
12595 }
12596 }
12597 else
12598 {
12599 vector_width = 1;
12600 }
12601
12602 if (vector_width > 8) vector_width = 8;
12603
12604 device_param->vector_width = vector_width;
12605
12606 // max_compute_units
12607
12608 cl_uint device_processors;
12609
12610 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12611
12612 device_param->device_processors = device_processors;
12613
12614 // max_mem_alloc_size
12615
12616 cl_ulong device_maxmem_alloc;
12617
12618 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12619
12620 device_param->device_maxmem_alloc = device_maxmem_alloc;
12621
12622 // max_mem_alloc_size
12623
12624 cl_ulong device_global_mem;
12625
12626 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12627
12628 device_param->device_global_mem = device_global_mem;
12629
12630 // max_clock_frequency
12631
12632 cl_uint device_maxclock_frequency;
12633
12634 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12635
12636 device_param->device_maxclock_frequency = device_maxclock_frequency;
12637
12638 // skipped
12639
12640 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12641 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12642
12643 device_param->skipped = (skipped1 || skipped2);
12644
12645 // driver_version
12646
12647 char *driver_version = (char *) mymalloc (INFOSZ);
12648
12649 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12650
12651 device_param->driver_version = driver_version;
12652
12653 // device_name_chksum
12654
12655 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12656
12657 #if __x86_64__
12658 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);
12659 #else
12660 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);
12661 #endif
12662
12663 uint device_name_digest[4];
12664
12665 device_name_digest[0] = 0;
12666 device_name_digest[1] = 0;
12667 device_name_digest[2] = 0;
12668 device_name_digest[3] = 0;
12669
12670 md5_64 ((uint *) device_name_chksum, device_name_digest);
12671
12672 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12673
12674 device_param->device_name_chksum = device_name_chksum;
12675
12676 // device_processor_cores
12677
12678 if (device_type & CL_DEVICE_TYPE_CPU)
12679 {
12680 cl_uint device_processor_cores = 1;
12681
12682 device_param->device_processor_cores = device_processor_cores;
12683 }
12684
12685 if (device_type & CL_DEVICE_TYPE_GPU)
12686 {
12687 if (vendor_id == VENDOR_ID_AMD)
12688 {
12689 cl_uint device_processor_cores = 0;
12690
12691 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12692
12693 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12694
12695 device_param->device_processor_cores = device_processor_cores;
12696 }
12697 else if (vendor_id == VENDOR_ID_NV)
12698 {
12699 cl_uint kernel_exec_timeout = 0;
12700
12701 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12702
12703 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12704
12705 device_param->kernel_exec_timeout = kernel_exec_timeout;
12706
12707 cl_uint device_processor_cores = 0;
12708
12709 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12710
12711 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12712
12713 device_param->device_processor_cores = device_processor_cores;
12714
12715 cl_uint sm_minor = 0;
12716 cl_uint sm_major = 0;
12717
12718 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12719 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12720
12721 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12722 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12723
12724 device_param->sm_minor = sm_minor;
12725 device_param->sm_major = sm_major;
12726 }
12727 else
12728 {
12729 cl_uint device_processor_cores = 1;
12730
12731 device_param->device_processor_cores = device_processor_cores;
12732 }
12733 }
12734
12735 // display results
12736
12737 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12738 {
12739 if (device_param->skipped == 0)
12740 {
12741 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12742 device_id + 1,
12743 device_name,
12744 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12745 (unsigned int) (device_global_mem / 1024 / 1024),
12746 (unsigned int) (device_maxclock_frequency),
12747 (unsigned int) device_processors);
12748 }
12749 else
12750 {
12751 log_info ("Device #%u: %s, skipped",
12752 device_id + 1,
12753 device_name);
12754 }
12755 }
12756
12757 // common driver check
12758
12759 if (device_param->skipped == 0)
12760 {
12761 if (strstr (device_version, "pocl"))
12762 {
12763 if (force == 0)
12764 {
12765 log_info ("");
12766 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12767 log_info ("You are STRONGLY encouraged not to use it");
12768 log_info ("You can use --force to override this but do not post error reports if you do so");
12769 log_info ("");
12770
12771 return (-1);
12772 }
12773 }
12774
12775 if (device_type & CL_DEVICE_TYPE_GPU)
12776 {
12777 if (vendor_id == VENDOR_ID_NV)
12778 {
12779 if (device_param->kernel_exec_timeout != 0)
12780 {
12781 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);
12782 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12783 }
12784 }
12785 else if (vendor_id == VENDOR_ID_AMD)
12786 {
12787 int catalyst_check = (force == 1) ? 0 : 1;
12788
12789 int catalyst_warn = 0;
12790
12791 int catalyst_broken = 0;
12792
12793 if (catalyst_check == 1)
12794 {
12795 catalyst_warn = 1;
12796
12797 // v14.9 and higher
12798 if (atoi (device_param->driver_version) >= 1573)
12799 {
12800 catalyst_warn = 0;
12801 }
12802
12803 catalyst_check = 0;
12804 }
12805
12806 if (catalyst_broken == 1)
12807 {
12808 log_info ("");
12809 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12810 log_info ("It will pass over cracked hashes and does not report them as cracked");
12811 log_info ("You are STRONGLY encouraged not to use it");
12812 log_info ("You can use --force to override this but do not post error reports if you do so");
12813 log_info ("");
12814
12815 return (-1);
12816 }
12817
12818 if (catalyst_warn == 1)
12819 {
12820 log_info ("");
12821 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12822 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12823 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12824 #ifdef _WIN
12825 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12826 #endif
12827 log_info ("You can use --force to override this but do not post error reports if you do so");
12828 log_info ("");
12829
12830 return (-1);
12831 }
12832 }
12833 }
12834
12835 devices_active++;
12836 }
12837
12838 // next please
12839
12840 devices_cnt++;
12841 }
12842 }
12843
12844 if (devices_active == 0)
12845 {
12846 log_error ("ERROR: No devices found/left");
12847
12848 return (-1);
12849 }
12850
12851 data.devices_cnt = devices_cnt;
12852
12853 data.devices_active = devices_active;
12854
12855 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12856 {
12857 log_info ("");
12858 }
12859
12860 /**
12861 * OpenCL devices: allocate buffer for device specific information
12862 */
12863
12864 #ifdef HAVE_HWMON
12865 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12866
12867 #ifdef HAVE_ADL
12868 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12869
12870 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12871 #endif // ADL
12872 #endif
12873
12874 /**
12875 * enable custom signal handler(s)
12876 */
12877
12878 if (benchmark == 0)
12879 {
12880 hc_signal (sigHandler_default);
12881 }
12882 else
12883 {
12884 hc_signal (sigHandler_benchmark);
12885 }
12886
12887 /**
12888 * User-defined GPU temp handling
12889 */
12890
12891 #ifdef HAVE_HWMON
12892 if (gpu_temp_disable == 1)
12893 {
12894 gpu_temp_abort = 0;
12895 gpu_temp_retain = 0;
12896 }
12897
12898 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12899 {
12900 if (gpu_temp_abort < gpu_temp_retain)
12901 {
12902 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12903
12904 return (-1);
12905 }
12906 }
12907
12908 data.gpu_temp_disable = gpu_temp_disable;
12909 data.gpu_temp_abort = gpu_temp_abort;
12910 data.gpu_temp_retain = gpu_temp_retain;
12911 #endif
12912
12913 /**
12914 * inform the user
12915 */
12916
12917 if (data.quiet == 0)
12918 {
12919 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12920
12921 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);
12922
12923 if (attack_mode == ATTACK_MODE_STRAIGHT)
12924 {
12925 log_info ("Rules: %u", kernel_rules_cnt);
12926 }
12927
12928 if (opti_type)
12929 {
12930 log_info ("Applicable Optimizers:");
12931
12932 for (uint i = 0; i < 32; i++)
12933 {
12934 const uint opti_bit = 1u << i;
12935
12936 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12937 }
12938 }
12939
12940 /**
12941 * Watchdog and Temperature balance
12942 */
12943
12944 #ifdef HAVE_HWMON
12945 if (gpu_temp_abort == 0)
12946 {
12947 log_info ("Watchdog: Temperature abort trigger disabled");
12948 }
12949 else
12950 {
12951 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12952 }
12953
12954 if (gpu_temp_retain == 0)
12955 {
12956 log_info ("Watchdog: Temperature retain trigger disabled");
12957 }
12958 else
12959 {
12960 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12961 }
12962 #endif
12963 }
12964
12965 if (data.quiet == 0) log_info ("");
12966
12967 /**
12968 * HM devices: init
12969 */
12970
12971 #ifdef HAVE_HWMON
12972 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12973 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12974 #endif
12975
12976 #ifdef HAVE_ADL
12977 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12978 #endif
12979
12980 if (gpu_temp_disable == 0)
12981 {
12982 #if defined(WIN) && defined(HAVE_NVAPI)
12983 if (NvAPI_Initialize () == NVAPI_OK)
12984 {
12985 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12986
12987 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12988
12989 int tmp_out = 0;
12990
12991 for (int i = 0; i < tmp_in; i++)
12992 {
12993 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12994 }
12995
12996 for (int i = 0; i < tmp_out; i++)
12997 {
12998 NvU32 speed;
12999
13000 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13001 }
13002 }
13003 #endif // WIN && HAVE_NVAPI
13004
13005 #if defined(LINUX) && defined(HAVE_NVML)
13006 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13007
13008 data.hm_dll_nv = hm_dll_nv;
13009
13010 if (hm_dll_nv)
13011 {
13012 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13013 {
13014 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
13015
13016 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13017
13018 int tmp_out = 0;
13019
13020 for (int i = 0; i < tmp_in; i++)
13021 {
13022 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13023 }
13024
13025 for (int i = 0; i < tmp_out; i++)
13026 {
13027 unsigned int speed;
13028
13029 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13030 }
13031 }
13032 }
13033 #endif // LINUX && HAVE_NVML
13034
13035 #ifdef HAVE_ADL
13036 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13037
13038 data.hm_dll_amd = hm_dll_amd;
13039
13040 if (hm_dll_amd)
13041 {
13042 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13043 {
13044 // total number of adapters
13045
13046 int hm_adapters_num;
13047
13048 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13049
13050 // adapter info
13051
13052 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13053
13054 if (lpAdapterInfo == NULL) return (-1);
13055
13056 // get a list (of ids of) valid/usable adapters
13057
13058 int num_adl_adapters = 0;
13059
13060 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13061
13062 if (num_adl_adapters > 0)
13063 {
13064 hc_thread_mutex_lock (mux_adl);
13065
13066 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13067
13068 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13069
13070 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13071 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13072
13073 hc_thread_mutex_unlock (mux_adl);
13074 }
13075
13076 myfree (valid_adl_device_list);
13077 myfree (lpAdapterInfo);
13078 }
13079 }
13080 #endif // HAVE_ADL
13081 }
13082
13083 /**
13084 * HM devices: copy
13085 */
13086
13087 if (gpu_temp_disable == 0)
13088 {
13089 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13090 {
13091 hc_device_param_t *device_param = &data.devices_param[device_id];
13092
13093 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13094
13095 if (device_param->skipped) continue;
13096
13097 const uint platform_devices_id = device_param->platform_devices_id;
13098
13099 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13100 if (device_param->vendor_id == VENDOR_ID_NV)
13101 {
13102 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13103 }
13104 #endif
13105
13106 #ifdef HAVE_ADL
13107 if (device_param->vendor_id == VENDOR_ID_AMD)
13108 {
13109 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13110 }
13111 #endif
13112 }
13113 }
13114
13115 /*
13116 * Temporary fix:
13117 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13118 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13119 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13120 * Driver / ADL bug?
13121 */
13122
13123 #ifdef HAVE_ADL
13124 if (powertune_enable == 1)
13125 {
13126 hc_thread_mutex_lock (mux_adl);
13127
13128 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13129 {
13130 hc_device_param_t *device_param = &data.devices_param[device_id];
13131
13132 if (device_param->skipped) continue;
13133
13134 if (data.hm_device[device_id].od_version == 6)
13135 {
13136 // set powertune value only
13137
13138 int powertune_supported = 0;
13139
13140 int ADL_rc = 0;
13141
13142 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13143 {
13144 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13145
13146 return (-1);
13147 }
13148
13149 if (powertune_supported != 0)
13150 {
13151 // powertune set
13152 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13153
13154 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13155 {
13156 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13157
13158 return (-1);
13159 }
13160
13161 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13162 {
13163 log_error ("ERROR: Failed to set new ADL PowerControl values");
13164
13165 return (-1);
13166 }
13167 }
13168 }
13169 }
13170
13171 hc_thread_mutex_unlock (mux_adl);
13172 }
13173 #endif // HAVE_ADK
13174 #endif // HAVE_HWMON
13175
13176 uint kernel_blocks_all = 0;
13177
13178 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13179 {
13180 /**
13181 * host buffer
13182 */
13183
13184 hc_device_param_t *device_param = &data.devices_param[device_id];
13185
13186 if (device_param->skipped) continue;
13187
13188 /**
13189 * device properties
13190 */
13191
13192 char *device_name_chksum = device_param->device_name_chksum;
13193
13194 uint device_processors = device_param->device_processors;
13195
13196 uint device_processor_cores = device_param->device_processor_cores;
13197
13198 cl_device_type device_type = device_param->device_type;
13199
13200 /**
13201 * create context for each device
13202 */
13203
13204 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13205
13206 /**
13207 * create command-queue
13208 */
13209
13210 // not support with NV
13211 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13212
13213 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13214
13215 /**
13216 * create input buffers on device
13217 */
13218
13219 uint kernel_threads = KERNEL_THREADS;
13220
13221 // bcrypt
13222 if (hash_mode == 3200) kernel_threads = 8;
13223 if (hash_mode == 9000) kernel_threads = 8;
13224
13225 if (device_type & CL_DEVICE_TYPE_CPU)
13226 {
13227 // CPU still need lots of workitems, don't know why...
13228 // for testing phase, lets start with this
13229
13230 // kernel_accel = 1;
13231 }
13232
13233 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13234 uint kernel_blocks = kernel_power;
13235
13236 device_param->kernel_threads = kernel_threads;
13237 device_param->kernel_power_user = kernel_power;
13238 device_param->kernel_blocks_user = kernel_blocks;
13239
13240 kernel_blocks_all += kernel_blocks;
13241
13242 uint size_pws = kernel_power * sizeof (pw_t);
13243
13244 uint size_tmps = 4;
13245
13246 switch (hash_mode)
13247 {
13248 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13249 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13250 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13251 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13252 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13253 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13254 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13255 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13256 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13257 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13258 case 6211:
13259 case 6212:
13260 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13261 case 6221:
13262 case 6222:
13263 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13264 case 6231:
13265 case 6232:
13266 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13267 case 6241:
13268 case 6242:
13269 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13270 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13271 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13272 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13273 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13274 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13275 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13276 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13277 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13278 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13279 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13280 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13281 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13282 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13283 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13284 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13285 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13286 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13287 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13288 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13289 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13290 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13291 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13292 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13293 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13294 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13295 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13296 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13297 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13298 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13299 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13300 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13301 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13302 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13303 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13304 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13305 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13306 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13307 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13308 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13309 };
13310
13311 uint size_hooks = 4;
13312
13313 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13314 {
13315 // insert correct hook size
13316 }
13317
13318 // we can optimize some stuff here...
13319
13320 device_param->size_pws = size_pws;
13321 device_param->size_tmps = size_tmps;
13322 device_param->size_hooks = size_hooks;
13323
13324 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13325 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13326
13327 device_param->size_root_css = size_root_css;
13328 device_param->size_markov_css = size_markov_css;
13329
13330 uint size_results = KERNEL_THREADS * sizeof (uint);
13331
13332 device_param->size_results = size_results;
13333
13334 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13335 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13336
13337 uint size_plains = digests_cnt * sizeof (plain_t);
13338 uint size_salts = salts_cnt * sizeof (salt_t);
13339 uint size_esalts = salts_cnt * esalt_size;
13340
13341 device_param->size_plains = size_plains;
13342 device_param->size_digests = size_digests;
13343 device_param->size_shown = size_shown;
13344 device_param->size_salts = size_salts;
13345
13346 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13347 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13348 uint size_tm = 32 * sizeof (bs_word_t);
13349
13350 u64 size_scryptV = 1;
13351
13352 if ((hash_mode == 8900) || (hash_mode == 9300))
13353 {
13354 uint tmto_start = 0;
13355 uint tmto_stop = 10;
13356
13357 if (scrypt_tmto)
13358 {
13359 tmto_start = scrypt_tmto;
13360 }
13361 else
13362 {
13363 // in case the user did not specify the tmto manually
13364 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13365 // but set the lower end only in case the user has a device with too less memory
13366
13367 if (hash_mode == 8900)
13368 {
13369 if (device_param->vendor_id == VENDOR_ID_AMD)
13370 {
13371 tmto_start = 1;
13372 }
13373 else if (device_param->vendor_id == VENDOR_ID_NV)
13374 {
13375 tmto_start = 3;
13376 }
13377 }
13378 else if (hash_mode == 9300)
13379 {
13380 if (device_param->vendor_id == VENDOR_ID_AMD)
13381 {
13382 tmto_start = 3;
13383 }
13384 else if (device_param->vendor_id == VENDOR_ID_NV)
13385 {
13386 tmto_start = 5;
13387 }
13388 }
13389 }
13390
13391 if (quiet == 0) log_info ("");
13392
13393 uint shader_per_mp = 1;
13394
13395 if (device_param->vendor_id == VENDOR_ID_AMD)
13396 {
13397 shader_per_mp = 8;
13398 }
13399 else if (device_param->vendor_id == VENDOR_ID_NV)
13400 {
13401 shader_per_mp = 32;
13402 }
13403
13404 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13405 {
13406 // TODO: in theory the following calculation needs to be done per salt, not global
13407 // we assume all hashes have the same scrypt settings
13408
13409 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13410
13411 size_scryptV /= 1 << tmto;
13412
13413 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13414
13415 if (size_scryptV > device_param->device_maxmem_alloc)
13416 {
13417 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13418
13419 continue;
13420 }
13421
13422 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13423 {
13424 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13425 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13426 }
13427
13428 break;
13429 }
13430
13431 if (data.salts_buf[0].scrypt_phy == 0)
13432 {
13433 log_error ("ERROR: can't allocate enough device memory");
13434
13435 return -1;
13436 }
13437
13438 if (quiet == 0) log_info ("");
13439 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13440 }
13441
13442 /**
13443 * default building options
13444 */
13445
13446 char build_opts[1024];
13447
13448 // we don't have sm_* on vendors not NV but it doesn't matter
13449
13450 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d -DVECT_SIZE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width);
13451
13452 /**
13453 * main kernel
13454 */
13455
13456 {
13457 /**
13458 * kernel source filename
13459 */
13460
13461 char source_file[256] = { 0 };
13462
13463 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13464
13465 struct stat sst;
13466
13467 if (stat (source_file, &sst) == -1)
13468 {
13469 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13470
13471 return -1;
13472 }
13473
13474 /**
13475 * kernel cached filename
13476 */
13477
13478 char cached_file[256] = { 0 };
13479
13480 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13481
13482 int cached = 1;
13483
13484 struct stat cst;
13485
13486 if (stat (cached_file, &cst) == -1)
13487 {
13488 cached = 0;
13489 }
13490
13491 /**
13492 * kernel compile or load
13493 */
13494
13495 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13496
13497 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13498
13499 if (force_jit_compilation == -1)
13500 {
13501 if (cached == 0)
13502 {
13503 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13504
13505 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13506
13507 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13508
13509 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13510
13511 size_t binary_size;
13512
13513 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13514
13515 u8 *binary = (u8 *) mymalloc (binary_size);
13516
13517 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13518
13519 writeProgramBin (cached_file, binary, binary_size);
13520
13521 local_free (binary);
13522 }
13523 else
13524 {
13525 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13526
13527 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13528
13529 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13530
13531 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13532 }
13533 }
13534 else
13535 {
13536 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13537
13538 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13539
13540 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13541
13542 if (force_jit_compilation == 1500)
13543 {
13544 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13545 }
13546 else if (force_jit_compilation == 8900)
13547 {
13548 sprintf (build_opts, "%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);
13549 }
13550
13551 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13552 }
13553
13554 local_free (kernel_lengths);
13555 local_free (kernel_sources[0]);
13556 local_free (kernel_sources);
13557
13558 // this is mostly for debug
13559
13560 size_t ret_val_size = 0;
13561
13562 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13563
13564 if (ret_val_size > 2)
13565 {
13566 char *build_log = (char *) mymalloc (ret_val_size + 1);
13567
13568 memset (build_log, 0, ret_val_size + 1);
13569
13570 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13571
13572 puts (build_log);
13573
13574 myfree (build_log);
13575 }
13576 }
13577
13578 /**
13579 * word generator kernel
13580 */
13581
13582 if (attack_mode != ATTACK_MODE_STRAIGHT)
13583 {
13584 /**
13585 * kernel mp source filename
13586 */
13587
13588 char source_file[256] = { 0 };
13589
13590 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13591
13592 struct stat sst;
13593
13594 if (stat (source_file, &sst) == -1)
13595 {
13596 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13597
13598 return -1;
13599 }
13600
13601 /**
13602 * kernel mp cached filename
13603 */
13604
13605 char cached_file[256] = { 0 };
13606
13607 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13608
13609 int cached = 1;
13610
13611 struct stat cst;
13612
13613 if (stat (cached_file, &cst) == -1)
13614 {
13615 cached = 0;
13616 }
13617
13618 /**
13619 * kernel compile or load
13620 */
13621
13622 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13623
13624 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13625
13626 if (cached == 0)
13627 {
13628 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13629
13630 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13631
13632 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13633
13634 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13635
13636 size_t binary_size;
13637
13638 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13639
13640 u8 *binary = (u8 *) mymalloc (binary_size);
13641
13642 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13643
13644 writeProgramBin (cached_file, binary, binary_size);
13645
13646 local_free (binary);
13647 }
13648 else
13649 {
13650 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13651
13652 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13653
13654 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13655
13656 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13657 }
13658
13659 local_free (kernel_lengths);
13660 local_free (kernel_sources[0]);
13661 local_free (kernel_sources);
13662
13663 // this is mostly for debug
13664
13665 size_t ret_val_size = 0;
13666
13667 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13668
13669 if (ret_val_size > 2)
13670 {
13671 char *build_log = (char *) mymalloc (ret_val_size + 1);
13672
13673 memset (build_log, 0, ret_val_size + 1);
13674
13675 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13676
13677 puts (build_log);
13678
13679 myfree (build_log);
13680 }
13681 }
13682
13683 /**
13684 * amplifier kernel
13685 */
13686
13687 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13688 {
13689
13690 }
13691 else
13692 {
13693 /**
13694 * kernel amp source filename
13695 */
13696
13697 char source_file[256] = { 0 };
13698
13699 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13700
13701 struct stat sst;
13702
13703 if (stat (source_file, &sst) == -1)
13704 {
13705 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13706
13707 return -1;
13708 }
13709
13710 /**
13711 * kernel amp cached filename
13712 */
13713
13714 char cached_file[256] = { 0 };
13715
13716 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13717
13718 int cached = 1;
13719
13720 struct stat cst;
13721
13722 if (stat (cached_file, &cst) == -1)
13723 {
13724 cached = 0;
13725 }
13726
13727 /**
13728 * kernel compile or load
13729 */
13730
13731 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13732
13733 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13734
13735 if (cached == 0)
13736 {
13737 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13738
13739 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13740
13741 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13742
13743 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13744
13745 size_t binary_size;
13746
13747 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13748
13749 u8 *binary = (u8 *) mymalloc (binary_size);
13750
13751 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13752
13753 writeProgramBin (cached_file, binary, binary_size);
13754
13755 local_free (binary);
13756 }
13757 else
13758 {
13759 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13760
13761 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13762
13763 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13764
13765 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13766 }
13767
13768 local_free (kernel_lengths);
13769 local_free (kernel_sources[0]);
13770 local_free (kernel_sources);
13771
13772 // this is mostly for debug
13773
13774 size_t ret_val_size = 0;
13775
13776 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13777
13778 if (ret_val_size > 2)
13779 {
13780 char *build_log = (char *) mymalloc (ret_val_size + 1);
13781
13782 memset (build_log, 0, ret_val_size + 1);
13783
13784 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13785
13786 puts (build_log);
13787
13788 myfree (build_log);
13789 }
13790 }
13791
13792 /**
13793 * global buffers
13794 */
13795
13796 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13797 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13798 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13799 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13800 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13801 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13802 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13803 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13804 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13805 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13806 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13807 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13808 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13809 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13810 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13811 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13812 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13813 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13814
13815 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13816 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13817 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13818 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13819 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13820 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13821 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13822 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13823 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13824 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13825 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13826
13827 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13828 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13829 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13830 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13831 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13832 run_kernel_bzero (device_param, device_param->d_result, size_results);
13833
13834 /**
13835 * special buffers
13836 */
13837
13838 if (attack_kern == ATTACK_KERN_STRAIGHT)
13839 {
13840 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13841 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13842
13843 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13844
13845 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13846 }
13847 else if (attack_kern == ATTACK_KERN_COMBI)
13848 {
13849 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13850 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13851 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13852 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13853
13854 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13855 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13856 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13857 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13858 }
13859 else if (attack_kern == ATTACK_KERN_BF)
13860 {
13861 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13862 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13863 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13864 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13865 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13866
13867 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13868 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13869 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13870 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13871 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13872 }
13873
13874 if (size_esalts)
13875 {
13876 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13877
13878 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13879 }
13880
13881 /**
13882 * main host data
13883 */
13884
13885 uint *result = (uint *) mymalloc (size_results);
13886
13887 memset (result, 0, size_results);
13888
13889 device_param->result = result;
13890
13891 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13892
13893 memset (pws_buf, 0, size_pws);
13894
13895 device_param->pws_buf = pws_buf;
13896
13897 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13898
13899 for (int i = 0; i < 64; i++)
13900 {
13901 pw_caches[i].pw_buf.pw_len = i;
13902 pw_caches[i].cnt = 0;
13903 }
13904
13905 device_param->pw_caches = pw_caches;
13906
13907 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13908
13909 device_param->combs_buf = combs_buf;
13910
13911 void *hooks_buf = mymalloc (size_hooks);
13912
13913 device_param->hooks_buf = hooks_buf;
13914
13915 device_param->pw_transpose = pw_transpose_to_hi1;
13916 device_param->pw_add = pw_add_to_hc1;
13917
13918 /**
13919 * kernel args
13920 */
13921
13922 device_param->kernel_params_buf32[21] = bitmap_mask;
13923 device_param->kernel_params_buf32[22] = bitmap_shift1;
13924 device_param->kernel_params_buf32[23] = bitmap_shift2;
13925 device_param->kernel_params_buf32[24] = 0; // salt_pos
13926 device_param->kernel_params_buf32[25] = 0; // loop_pos
13927 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13928 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13929 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13930 device_param->kernel_params_buf32[29] = 0; // digests_offset
13931 device_param->kernel_params_buf32[30] = 0; // combs_mode
13932 device_param->kernel_params_buf32[31] = 0; // gid_max
13933
13934 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13935 ? &device_param->d_pws_buf
13936 : &device_param->d_pws_amp_buf;
13937 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13938 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13939 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13940 device_param->kernel_params[ 4] = &device_param->d_tmps;
13941 device_param->kernel_params[ 5] = &device_param->d_hooks;
13942 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13943 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13944 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13945 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13946 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13947 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13948 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13949 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13950 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13951 device_param->kernel_params[15] = &device_param->d_digests_buf;
13952 device_param->kernel_params[16] = &device_param->d_digests_shown;
13953 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13954 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13955 device_param->kernel_params[19] = &device_param->d_result;
13956 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13957 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13958 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13959 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13960 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13961 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13962 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13963 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13964 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13965 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13966 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13967 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13968
13969 device_param->kernel_params_mp_buf64[3] = 0;
13970 device_param->kernel_params_mp_buf32[4] = 0;
13971 device_param->kernel_params_mp_buf32[5] = 0;
13972 device_param->kernel_params_mp_buf32[6] = 0;
13973 device_param->kernel_params_mp_buf32[7] = 0;
13974 device_param->kernel_params_mp_buf32[8] = 0;
13975
13976 device_param->kernel_params_mp[0] = NULL;
13977 device_param->kernel_params_mp[1] = NULL;
13978 device_param->kernel_params_mp[2] = NULL;
13979 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13980 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13981 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13982 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13983 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13984 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13985
13986 device_param->kernel_params_mp_l_buf64[3] = 0;
13987 device_param->kernel_params_mp_l_buf32[4] = 0;
13988 device_param->kernel_params_mp_l_buf32[5] = 0;
13989 device_param->kernel_params_mp_l_buf32[6] = 0;
13990 device_param->kernel_params_mp_l_buf32[7] = 0;
13991 device_param->kernel_params_mp_l_buf32[8] = 0;
13992 device_param->kernel_params_mp_l_buf32[9] = 0;
13993
13994 device_param->kernel_params_mp_l[0] = NULL;
13995 device_param->kernel_params_mp_l[1] = NULL;
13996 device_param->kernel_params_mp_l[2] = NULL;
13997 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13998 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13999 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14000 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14001 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14002 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14003 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14004
14005 device_param->kernel_params_mp_r_buf64[3] = 0;
14006 device_param->kernel_params_mp_r_buf32[4] = 0;
14007 device_param->kernel_params_mp_r_buf32[5] = 0;
14008 device_param->kernel_params_mp_r_buf32[6] = 0;
14009 device_param->kernel_params_mp_r_buf32[7] = 0;
14010 device_param->kernel_params_mp_r_buf32[8] = 0;
14011
14012 device_param->kernel_params_mp_r[0] = NULL;
14013 device_param->kernel_params_mp_r[1] = NULL;
14014 device_param->kernel_params_mp_r[2] = NULL;
14015 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14016 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14017 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14018 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14019 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14020 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14021
14022 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14023 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14024
14025 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14026 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14027 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14028 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14029 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14030 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14031 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14032
14033 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14034
14035 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14036 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14037
14038 /**
14039 * kernel name
14040 */
14041
14042 char kernel_name[64] = { 0 };
14043
14044 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14045 {
14046 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14047 {
14048 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14049
14050 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14051
14052 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14053
14054 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14055
14056 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14057
14058 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14059 }
14060 else
14061 {
14062 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14063
14064 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14065
14066 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14067
14068 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14069
14070 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14071
14072 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14073 }
14074
14075 if (data.attack_mode == ATTACK_MODE_BF)
14076 {
14077 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14078 {
14079 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14080
14081 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14082
14083 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14084
14085 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14086 }
14087 }
14088 }
14089 else
14090 {
14091 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14092
14093 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14094
14095 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14096
14097 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14098
14099 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14100
14101 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14102
14103 if (opts_type & OPTS_TYPE_HOOK12)
14104 {
14105 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14106
14107 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14108 }
14109
14110 if (opts_type & OPTS_TYPE_HOOK23)
14111 {
14112 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14113
14114 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14115 }
14116 }
14117
14118 for (uint i = 0; i <= 20; i++)
14119 {
14120 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14121 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14122 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14123
14124 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14125 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14126 }
14127
14128 for (uint i = 21; i <= 31; i++)
14129 {
14130 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14131 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14132 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14133
14134 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14135 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14136 }
14137
14138 if (attack_mode == ATTACK_MODE_BF)
14139 {
14140 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14141 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14142
14143 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14144 {
14145 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14146
14147 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14148 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14149 }
14150 }
14151 else if (attack_mode == ATTACK_MODE_HYBRID1)
14152 {
14153 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14154 }
14155 else if (attack_mode == ATTACK_MODE_HYBRID2)
14156 {
14157 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14158 }
14159
14160 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14161 {
14162 // nothing to do
14163 }
14164 else
14165 {
14166 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14167 }
14168
14169 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14170 {
14171 // nothing to do
14172 }
14173 else
14174 {
14175 for (uint i = 0; i < 5; i++)
14176 {
14177 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14178 }
14179
14180 for (uint i = 5; i < 7; i++)
14181 {
14182 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14183 }
14184 }
14185
14186 /**
14187 * Store initial fanspeed if gpu_temp_retain is enabled
14188 */
14189
14190 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14191 int gpu_temp_retain_set = 0;
14192
14193 if (gpu_temp_disable == 0)
14194 {
14195 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14196 {
14197 hc_thread_mutex_lock (mux_adl);
14198
14199 if (data.hm_device[device_id].fan_supported == 1)
14200 {
14201 if (gpu_temp_retain_chgd == 0)
14202 {
14203 uint cur_temp = 0;
14204 uint default_temp = 0;
14205
14206 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14207
14208 if (ADL_rc == ADL_OK)
14209 {
14210 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14211
14212 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14213
14214 // special case with multi gpu setups: always use minimum retain
14215
14216 if (gpu_temp_retain_set == 0)
14217 {
14218 gpu_temp_retain = gpu_temp_retain_target;
14219 gpu_temp_retain_set = 1;
14220 }
14221 else
14222 {
14223 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14224 }
14225
14226 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14227 }
14228 }
14229
14230 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14231
14232 temp_retain_fanspeed_value[device_id] = fan_speed;
14233
14234 if (fan_speed == -1)
14235 {
14236 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14237
14238 temp_retain_fanspeed_value[device_id] = 0;
14239 }
14240 }
14241
14242 hc_thread_mutex_unlock (mux_adl);
14243 }
14244 }
14245
14246 /**
14247 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14248 */
14249
14250 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14251 {
14252 hc_thread_mutex_lock (mux_adl);
14253
14254 if (data.hm_device[device_id].od_version == 6)
14255 {
14256 int ADL_rc;
14257
14258 // check powertune capabilities first, if not available then skip device
14259
14260 int powertune_supported = 0;
14261
14262 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14263 {
14264 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14265
14266 return (-1);
14267 }
14268
14269 if (powertune_supported != 0)
14270 {
14271 // powercontrol settings
14272
14273 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14274
14275 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14276 {
14277 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14278 }
14279
14280 if (ADL_rc != ADL_OK)
14281 {
14282 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14283
14284 return (-1);
14285 }
14286
14287 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14288 {
14289 log_error ("ERROR: Failed to set new ADL PowerControl values");
14290
14291 return (-1);
14292 }
14293
14294 // clocks
14295
14296 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14297
14298 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14299
14300 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14301 {
14302 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14303
14304 return (-1);
14305 }
14306
14307 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14308
14309 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14310
14311 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14312 {
14313 log_error ("ERROR: Failed to get ADL device capabilities");
14314
14315 return (-1);
14316 }
14317
14318 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14319 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14320
14321 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14322 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14323
14324 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14325 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14326
14327 // warning if profile has too low max values
14328
14329 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14330 {
14331 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14332 }
14333
14334 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14335 {
14336 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14337 }
14338
14339 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14340
14341 performance_state->iNumberOfPerformanceLevels = 2;
14342
14343 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14344 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14345 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14346 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14347
14348 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14349 {
14350 log_info ("ERROR: Failed to set ADL performance state");
14351
14352 return (-1);
14353 }
14354
14355 local_free (performance_state);
14356 }
14357 }
14358
14359 hc_thread_mutex_unlock (mux_adl);
14360 }
14361 #endif // HAVE_HWMON && HAVE_ADL
14362 }
14363
14364 data.kernel_blocks_all = kernel_blocks_all;
14365
14366 if (data.quiet == 0) log_info ("");
14367
14368 /**
14369 * Inform user which algorithm is checked and at which workload setting
14370 */
14371
14372 if (benchmark == 1)
14373 {
14374 quiet = 0;
14375
14376 data.quiet = quiet;
14377
14378 char *hash_type = strhashtype (data.hash_mode); // not a bug
14379
14380 log_info ("Hashtype: %s", hash_type);
14381 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14382 log_info ("");
14383 }
14384
14385 /**
14386 * keep track of the progress
14387 */
14388
14389 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14390 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14391 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14392
14393 /**
14394 * open filehandles
14395 */
14396
14397 #if _WIN
14398 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14399 {
14400 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14401
14402 return (-1);
14403 }
14404
14405 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14406 {
14407 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14408
14409 return (-1);
14410 }
14411
14412 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14413 {
14414 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14415
14416 return (-1);
14417 }
14418 #endif
14419
14420 /**
14421 * dictionary pad
14422 */
14423
14424 segment_size *= (1024 * 1024);
14425
14426 data.segment_size = segment_size;
14427
14428 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14429
14430 wl_data->buf = (char *) mymalloc (segment_size);
14431 wl_data->avail = segment_size;
14432 wl_data->incr = segment_size;
14433 wl_data->cnt = 0;
14434 wl_data->pos = 0;
14435
14436 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14437
14438 data.wordlist_mode = wordlist_mode;
14439
14440 cs_t *css_buf = NULL;
14441 uint css_cnt = 0;
14442 uint dictcnt = 0;
14443 uint maskcnt = 1;
14444 char **masks = NULL;
14445 char **dictfiles = NULL;
14446
14447 uint mask_from_file = 0;
14448
14449 if (attack_mode == ATTACK_MODE_STRAIGHT)
14450 {
14451 if (wordlist_mode == WL_MODE_FILE)
14452 {
14453 int wls_left = myargc - (optind + 1);
14454
14455 for (int i = 0; i < wls_left; i++)
14456 {
14457 char *l0_filename = myargv[optind + 1 + i];
14458
14459 struct stat l0_stat;
14460
14461 if (stat (l0_filename, &l0_stat) == -1)
14462 {
14463 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14464
14465 return (-1);
14466 }
14467
14468 uint is_dir = S_ISDIR (l0_stat.st_mode);
14469
14470 if (is_dir == 0)
14471 {
14472 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14473
14474 dictcnt++;
14475
14476 dictfiles[dictcnt - 1] = l0_filename;
14477 }
14478 else
14479 {
14480 // do not allow --keyspace w/ a directory
14481
14482 if (keyspace == 1)
14483 {
14484 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14485
14486 return (-1);
14487 }
14488
14489 char **dictionary_files = NULL;
14490
14491 dictionary_files = scan_directory (l0_filename);
14492
14493 if (dictionary_files != NULL)
14494 {
14495 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14496
14497 for (int d = 0; dictionary_files[d] != NULL; d++)
14498 {
14499 char *l1_filename = dictionary_files[d];
14500
14501 struct stat l1_stat;
14502
14503 if (stat (l1_filename, &l1_stat) == -1)
14504 {
14505 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14506
14507 return (-1);
14508 }
14509
14510 if (S_ISREG (l1_stat.st_mode))
14511 {
14512 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14513
14514 dictcnt++;
14515
14516 dictfiles[dictcnt - 1] = strdup (l1_filename);
14517 }
14518 }
14519 }
14520
14521 local_free (dictionary_files);
14522 }
14523 }
14524
14525 if (dictcnt < 1)
14526 {
14527 log_error ("ERROR: No usable dictionary file found.");
14528
14529 return (-1);
14530 }
14531 }
14532 else if (wordlist_mode == WL_MODE_STDIN)
14533 {
14534 dictcnt = 1;
14535 }
14536 }
14537 else if (attack_mode == ATTACK_MODE_COMBI)
14538 {
14539 // display
14540
14541 char *dictfile1 = myargv[optind + 1 + 0];
14542 char *dictfile2 = myargv[optind + 1 + 1];
14543
14544 // find the bigger dictionary and use as base
14545
14546 FILE *fp1;
14547 FILE *fp2;
14548
14549 struct stat tmp_stat;
14550
14551 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14552 {
14553 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14554
14555 return (-1);
14556 }
14557
14558 if (stat (dictfile1, &tmp_stat) == -1)
14559 {
14560 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14561
14562 fclose (fp1);
14563
14564 return (-1);
14565 }
14566
14567 if (S_ISDIR (tmp_stat.st_mode))
14568 {
14569 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14570
14571 fclose (fp1);
14572
14573 return (-1);
14574 }
14575
14576 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14577 {
14578 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14579
14580 fclose (fp1);
14581
14582 return (-1);
14583 }
14584
14585 if (stat (dictfile2, &tmp_stat) == -1)
14586 {
14587 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14588
14589 fclose (fp1);
14590 fclose (fp2);
14591
14592 return (-1);
14593 }
14594
14595 if (S_ISDIR (tmp_stat.st_mode))
14596 {
14597 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14598
14599 fclose (fp1);
14600 fclose (fp2);
14601
14602 return (-1);
14603 }
14604
14605 data.combs_cnt = 1;
14606
14607 data.quiet = 1;
14608
14609 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14610
14611 data.quiet = quiet;
14612
14613 if (words1_cnt == 0)
14614 {
14615 log_error ("ERROR: %s: empty file", dictfile1);
14616
14617 fclose (fp1);
14618 fclose (fp2);
14619
14620 return (-1);
14621 }
14622
14623 data.combs_cnt = 1;
14624
14625 data.quiet = 1;
14626
14627 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14628
14629 data.quiet = quiet;
14630
14631 if (words2_cnt == 0)
14632 {
14633 log_error ("ERROR: %s: empty file", dictfile2);
14634
14635 fclose (fp1);
14636 fclose (fp2);
14637
14638 return (-1);
14639 }
14640
14641 fclose (fp1);
14642 fclose (fp2);
14643
14644 data.dictfile = dictfile1;
14645 data.dictfile2 = dictfile2;
14646
14647 if (words1_cnt >= words2_cnt)
14648 {
14649 data.combs_cnt = words2_cnt;
14650 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14651
14652 dictfiles = &data.dictfile;
14653
14654 dictcnt = 1;
14655 }
14656 else
14657 {
14658 data.combs_cnt = words1_cnt;
14659 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14660
14661 dictfiles = &data.dictfile2;
14662
14663 dictcnt = 1;
14664
14665 // we also have to switch wordlist related rules!
14666
14667 char *tmpc = data.rule_buf_l;
14668
14669 data.rule_buf_l = data.rule_buf_r;
14670 data.rule_buf_r = tmpc;
14671
14672 int tmpi = data.rule_len_l;
14673
14674 data.rule_len_l = data.rule_len_r;
14675 data.rule_len_r = tmpi;
14676 }
14677 }
14678 else if (attack_mode == ATTACK_MODE_BF)
14679 {
14680 char *mask = NULL;
14681
14682 maskcnt = 0;
14683
14684 if (benchmark == 0)
14685 {
14686 mask = myargv[optind + 1];
14687
14688 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14689
14690 if ((optind + 2) <= myargc)
14691 {
14692 struct stat file_stat;
14693
14694 if (stat (mask, &file_stat) == -1)
14695 {
14696 maskcnt = 1;
14697
14698 masks[maskcnt - 1] = mystrdup (mask);
14699 }
14700 else
14701 {
14702 int wls_left = myargc - (optind + 1);
14703
14704 uint masks_avail = INCR_MASKS;
14705
14706 for (int i = 0; i < wls_left; i++)
14707 {
14708 if (i != 0)
14709 {
14710 mask = myargv[optind + 1 + i];
14711
14712 if (stat (mask, &file_stat) == -1)
14713 {
14714 log_error ("ERROR: %s: %s", mask, strerror (errno));
14715
14716 return (-1);
14717 }
14718 }
14719
14720 uint is_file = S_ISREG (file_stat.st_mode);
14721
14722 if (is_file == 1)
14723 {
14724 FILE *mask_fp;
14725
14726 if ((mask_fp = fopen (mask, "r")) == NULL)
14727 {
14728 log_error ("ERROR: %s: %s", mask, strerror (errno));
14729
14730 return (-1);
14731 }
14732
14733 char line_buf[BUFSIZ];
14734
14735 while (!feof (mask_fp))
14736 {
14737 memset (line_buf, 0, BUFSIZ);
14738
14739 int line_len = fgetl (mask_fp, line_buf);
14740
14741 if (line_len == 0) continue;
14742
14743 if (line_buf[0] == '#') continue;
14744
14745 if (masks_avail == maskcnt)
14746 {
14747 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14748
14749 masks_avail += INCR_MASKS;
14750 }
14751
14752 masks[maskcnt] = mystrdup (line_buf);
14753
14754 maskcnt++;
14755 }
14756
14757 fclose (mask_fp);
14758 }
14759 else
14760 {
14761 log_error ("ERROR: %s: unsupported file-type", mask);
14762
14763 return (-1);
14764 }
14765 }
14766
14767 mask_from_file = 1;
14768 }
14769 }
14770 else
14771 {
14772 custom_charset_1 = (char *) "?l?d?u";
14773 custom_charset_2 = (char *) "?l?d";
14774 custom_charset_3 = (char *) "?l?d*!$@_";
14775
14776 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14777 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14778 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14779
14780 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14781
14782 wordlist_mode = WL_MODE_MASK;
14783
14784 data.wordlist_mode = wordlist_mode;
14785
14786 increment = 1;
14787
14788 maskcnt = 1;
14789 }
14790 }
14791 else
14792 {
14793 /**
14794 * generate full masks and charsets
14795 */
14796
14797 masks = (char **) mymalloc (sizeof (char *));
14798
14799 switch (hash_mode)
14800 {
14801 case 1731: pw_min = 5;
14802 pw_max = 5;
14803 mask = mystrdup ("?b?b?b?b?b");
14804 break;
14805 case 12500: pw_min = 5;
14806 pw_max = 5;
14807 mask = mystrdup ("?b?b?b?b?b");
14808 break;
14809 default: pw_min = 7;
14810 pw_max = 7;
14811 mask = mystrdup ("?b?b?b?b?b?b?b");
14812 break;
14813 }
14814
14815 maskcnt = 1;
14816
14817 masks[maskcnt - 1] = mystrdup (mask);
14818
14819 wordlist_mode = WL_MODE_MASK;
14820
14821 data.wordlist_mode = wordlist_mode;
14822
14823 increment = 1;
14824 }
14825
14826 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14827
14828 if (increment)
14829 {
14830 if (increment_min > pw_min) pw_min = increment_min;
14831
14832 if (increment_max < pw_max) pw_max = increment_max;
14833 }
14834 }
14835 else if (attack_mode == ATTACK_MODE_HYBRID1)
14836 {
14837 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14838
14839 // display
14840
14841 char *mask = myargv[myargc - 1];
14842
14843 maskcnt = 0;
14844
14845 masks = (char **) mymalloc (1 * sizeof (char *));
14846
14847 // mod
14848
14849 struct stat file_stat;
14850
14851 if (stat (mask, &file_stat) == -1)
14852 {
14853 maskcnt = 1;
14854
14855 masks[maskcnt - 1] = mystrdup (mask);
14856 }
14857 else
14858 {
14859 uint is_file = S_ISREG (file_stat.st_mode);
14860
14861 if (is_file == 1)
14862 {
14863 FILE *mask_fp;
14864
14865 if ((mask_fp = fopen (mask, "r")) == NULL)
14866 {
14867 log_error ("ERROR: %s: %s", mask, strerror (errno));
14868
14869 return (-1);
14870 }
14871
14872 char line_buf[BUFSIZ];
14873
14874 uint masks_avail = 1;
14875
14876 while (!feof (mask_fp))
14877 {
14878 memset (line_buf, 0, BUFSIZ);
14879
14880 int line_len = fgetl (mask_fp, line_buf);
14881
14882 if (line_len == 0) continue;
14883
14884 if (line_buf[0] == '#') continue;
14885
14886 if (masks_avail == maskcnt)
14887 {
14888 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14889
14890 masks_avail += INCR_MASKS;
14891 }
14892
14893 masks[maskcnt] = mystrdup (line_buf);
14894
14895 maskcnt++;
14896 }
14897
14898 fclose (mask_fp);
14899
14900 mask_from_file = 1;
14901 }
14902 else
14903 {
14904 maskcnt = 1;
14905
14906 masks[maskcnt - 1] = mystrdup (mask);
14907 }
14908 }
14909
14910 // base
14911
14912 int wls_left = myargc - (optind + 2);
14913
14914 for (int i = 0; i < wls_left; i++)
14915 {
14916 char *filename = myargv[optind + 1 + i];
14917
14918 struct stat file_stat;
14919
14920 if (stat (filename, &file_stat) == -1)
14921 {
14922 log_error ("ERROR: %s: %s", filename, strerror (errno));
14923
14924 return (-1);
14925 }
14926
14927 uint is_dir = S_ISDIR (file_stat.st_mode);
14928
14929 if (is_dir == 0)
14930 {
14931 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14932
14933 dictcnt++;
14934
14935 dictfiles[dictcnt - 1] = filename;
14936 }
14937 else
14938 {
14939 // do not allow --keyspace w/ a directory
14940
14941 if (keyspace == 1)
14942 {
14943 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14944
14945 return (-1);
14946 }
14947
14948 char **dictionary_files = NULL;
14949
14950 dictionary_files = scan_directory (filename);
14951
14952 if (dictionary_files != NULL)
14953 {
14954 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14955
14956 for (int d = 0; dictionary_files[d] != NULL; d++)
14957 {
14958 char *l1_filename = dictionary_files[d];
14959
14960 struct stat l1_stat;
14961
14962 if (stat (l1_filename, &l1_stat) == -1)
14963 {
14964 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14965
14966 return (-1);
14967 }
14968
14969 if (S_ISREG (l1_stat.st_mode))
14970 {
14971 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14972
14973 dictcnt++;
14974
14975 dictfiles[dictcnt - 1] = strdup (l1_filename);
14976 }
14977 }
14978 }
14979
14980 local_free (dictionary_files);
14981 }
14982 }
14983
14984 if (dictcnt < 1)
14985 {
14986 log_error ("ERROR: No usable dictionary file found.");
14987
14988 return (-1);
14989 }
14990
14991 if (increment)
14992 {
14993 maskcnt = 0;
14994
14995 uint mask_min = increment_min; // we can't reject smaller masks here
14996 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14997
14998 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14999 {
15000 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15001
15002 if (cur_mask == NULL) break;
15003
15004 masks[maskcnt] = cur_mask;
15005
15006 maskcnt++;
15007
15008 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15009 }
15010 }
15011 }
15012 else if (attack_mode == ATTACK_MODE_HYBRID2)
15013 {
15014 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15015
15016 // display
15017
15018 char *mask = myargv[optind + 1 + 0];
15019
15020 maskcnt = 0;
15021
15022 masks = (char **) mymalloc (1 * sizeof (char *));
15023
15024 // mod
15025
15026 struct stat file_stat;
15027
15028 if (stat (mask, &file_stat) == -1)
15029 {
15030 maskcnt = 1;
15031
15032 masks[maskcnt - 1] = mystrdup (mask);
15033 }
15034 else
15035 {
15036 uint is_file = S_ISREG (file_stat.st_mode);
15037
15038 if (is_file == 1)
15039 {
15040 FILE *mask_fp;
15041
15042 if ((mask_fp = fopen (mask, "r")) == NULL)
15043 {
15044 log_error ("ERROR: %s: %s", mask, strerror (errno));
15045
15046 return (-1);
15047 }
15048
15049 char line_buf[BUFSIZ];
15050
15051 uint masks_avail = 1;
15052
15053 while (!feof (mask_fp))
15054 {
15055 memset (line_buf, 0, BUFSIZ);
15056
15057 int line_len = fgetl (mask_fp, line_buf);
15058
15059 if (line_len == 0) continue;
15060
15061 if (line_buf[0] == '#') continue;
15062
15063 if (masks_avail == maskcnt)
15064 {
15065 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15066
15067 masks_avail += INCR_MASKS;
15068 }
15069
15070 masks[maskcnt] = mystrdup (line_buf);
15071
15072 maskcnt++;
15073 }
15074
15075 fclose (mask_fp);
15076
15077 mask_from_file = 1;
15078 }
15079 else
15080 {
15081 maskcnt = 1;
15082
15083 masks[maskcnt - 1] = mystrdup (mask);
15084 }
15085 }
15086
15087 // base
15088
15089 int wls_left = myargc - (optind + 2);
15090
15091 for (int i = 0; i < wls_left; i++)
15092 {
15093 char *filename = myargv[optind + 2 + i];
15094
15095 struct stat file_stat;
15096
15097 if (stat (filename, &file_stat) == -1)
15098 {
15099 log_error ("ERROR: %s: %s", filename, strerror (errno));
15100
15101 return (-1);
15102 }
15103
15104 uint is_dir = S_ISDIR (file_stat.st_mode);
15105
15106 if (is_dir == 0)
15107 {
15108 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15109
15110 dictcnt++;
15111
15112 dictfiles[dictcnt - 1] = filename;
15113 }
15114 else
15115 {
15116 // do not allow --keyspace w/ a directory
15117
15118 if (keyspace == 1)
15119 {
15120 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15121
15122 return (-1);
15123 }
15124
15125 char **dictionary_files = NULL;
15126
15127 dictionary_files = scan_directory (filename);
15128
15129 if (dictionary_files != NULL)
15130 {
15131 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15132
15133 for (int d = 0; dictionary_files[d] != NULL; d++)
15134 {
15135 char *l1_filename = dictionary_files[d];
15136
15137 struct stat l1_stat;
15138
15139 if (stat (l1_filename, &l1_stat) == -1)
15140 {
15141 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15142
15143 return (-1);
15144 }
15145
15146 if (S_ISREG (l1_stat.st_mode))
15147 {
15148 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15149
15150 dictcnt++;
15151
15152 dictfiles[dictcnt - 1] = strdup (l1_filename);
15153 }
15154 }
15155 }
15156
15157 local_free (dictionary_files);
15158 }
15159 }
15160
15161 if (dictcnt < 1)
15162 {
15163 log_error ("ERROR: No usable dictionary file found.");
15164
15165 return (-1);
15166 }
15167
15168 if (increment)
15169 {
15170 maskcnt = 0;
15171
15172 uint mask_min = increment_min; // we can't reject smaller masks here
15173 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15174
15175 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15176 {
15177 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15178
15179 if (cur_mask == NULL) break;
15180
15181 masks[maskcnt] = cur_mask;
15182
15183 maskcnt++;
15184
15185 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15186 }
15187 }
15188 }
15189
15190 data.pw_min = pw_min;
15191 data.pw_max = pw_max;
15192
15193 /**
15194 * weak hash check
15195 */
15196
15197 if (weak_hash_threshold >= salts_cnt)
15198 {
15199 uint first_device_id = 0;
15200
15201 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15202 {
15203 hc_device_param_t *device_param = &data.devices_param[device_id];
15204
15205 if (device_param->skipped) continue;
15206
15207 first_device_id = device_id;
15208
15209 break;
15210 }
15211
15212 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15213
15214 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15215 {
15216 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15217 }
15218 }
15219
15220 // Display hack, guarantee that there is at least one \r before real start
15221
15222 if (data.quiet == 0) log_info_nn ("");
15223
15224 /**
15225 * status and monitor threads
15226 */
15227
15228 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15229
15230 hc_thread_t i_thread = 0;
15231
15232 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15233 {
15234 hc_thread_create (i_thread, thread_keypress, &benchmark);
15235 }
15236
15237 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15238
15239 uint ni_threads_cnt = 0;
15240
15241 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15242
15243 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15244
15245 ni_threads_cnt++;
15246
15247 /**
15248 * Outfile remove
15249 */
15250
15251 if (keyspace == 0)
15252 {
15253 if (outfile_check_timer != 0)
15254 {
15255 if (data.outfile_check_directory != NULL)
15256 {
15257 if ((hash_mode != 5200) &&
15258 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15259 (hash_mode != 9000))
15260 {
15261 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15262
15263 ni_threads_cnt++;
15264 }
15265 else
15266 {
15267 outfile_check_timer = 0;
15268 }
15269 }
15270 else
15271 {
15272 outfile_check_timer = 0;
15273 }
15274 }
15275 }
15276
15277 /**
15278 * Inform the user if we got some hashes remove because of the pot file remove feature
15279 */
15280
15281 if (data.quiet == 0)
15282 {
15283 if (potfile_remove_cracks > 0)
15284 {
15285 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15286 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15287 }
15288 }
15289
15290 data.outfile_check_timer = outfile_check_timer;
15291
15292 /**
15293 * main loop
15294 */
15295
15296 char **induction_dictionaries = NULL;
15297
15298 int induction_dictionaries_cnt = 0;
15299
15300 hcstat_table_t *root_table_buf = NULL;
15301 hcstat_table_t *markov_table_buf = NULL;
15302
15303 uint initial_restore_done = 0;
15304
15305 data.maskcnt = maskcnt;
15306
15307 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15308 {
15309 if (data.devices_status == STATUS_CRACKED) break;
15310
15311 data.devices_status = STATUS_INIT;
15312
15313 if (maskpos > rd->maskpos)
15314 {
15315 rd->dictpos = 0;
15316 }
15317
15318 rd->maskpos = maskpos;
15319 data.maskpos = maskpos;
15320
15321 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15322 {
15323 char *mask = masks[maskpos];
15324
15325 if (mask_from_file == 1)
15326 {
15327 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15328
15329 char *str_ptr;
15330 uint str_pos;
15331
15332 uint mask_offset = 0;
15333
15334 uint separator_cnt;
15335
15336 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15337 {
15338 str_ptr = strstr (mask + mask_offset, ",");
15339
15340 if (str_ptr == NULL) break;
15341
15342 str_pos = str_ptr - mask;
15343
15344 // escaped separator, i.e. "\,"
15345
15346 if (str_pos > 0)
15347 {
15348 if (mask[str_pos - 1] == '\\')
15349 {
15350 separator_cnt --;
15351
15352 mask_offset = str_pos + 1;
15353
15354 continue;
15355 }
15356 }
15357
15358 // reset the offset
15359
15360 mask_offset = 0;
15361
15362 mask[str_pos] = '\0';
15363
15364 switch (separator_cnt)
15365 {
15366 case 0:
15367 mp_reset_usr (mp_usr, 0);
15368
15369 custom_charset_1 = mask;
15370 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15371 break;
15372
15373 case 1:
15374 mp_reset_usr (mp_usr, 1);
15375
15376 custom_charset_2 = mask;
15377 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15378 break;
15379
15380 case 2:
15381 mp_reset_usr (mp_usr, 2);
15382
15383 custom_charset_3 = mask;
15384 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15385 break;
15386
15387 case 3:
15388 mp_reset_usr (mp_usr, 3);
15389
15390 custom_charset_4 = mask;
15391 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15392 break;
15393 }
15394
15395 mask = mask + str_pos + 1;
15396 }
15397 }
15398
15399 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15400 {
15401 if (maskpos > 0)
15402 {
15403 local_free (css_buf);
15404 local_free (data.root_css_buf);
15405 local_free (data.markov_css_buf);
15406
15407 local_free (masks[maskpos - 1]);
15408 }
15409
15410 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15411
15412 data.mask = mask;
15413 data.css_cnt = css_cnt;
15414 data.css_buf = css_buf;
15415
15416 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15417
15418 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15419
15420 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15421 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15422
15423 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15424
15425 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15426
15427 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15428 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15429
15430 data.root_css_buf = root_css_buf;
15431 data.markov_css_buf = markov_css_buf;
15432
15433 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15434
15435 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15436
15437 local_free (root_table_buf);
15438 local_free (markov_table_buf);
15439
15440 // args
15441
15442 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15443 {
15444 hc_device_param_t *device_param = &data.devices_param[device_id];
15445
15446 if (device_param->skipped) continue;
15447
15448 device_param->kernel_params_mp[0] = &device_param->d_combs;
15449 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15450 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15451
15452 device_param->kernel_params_mp_buf64[3] = 0;
15453 device_param->kernel_params_mp_buf32[4] = css_cnt;
15454 device_param->kernel_params_mp_buf32[5] = 0;
15455 device_param->kernel_params_mp_buf32[6] = 0;
15456 device_param->kernel_params_mp_buf32[7] = 0;
15457
15458 if (attack_mode == ATTACK_MODE_HYBRID1)
15459 {
15460 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15461 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15462 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15463 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15464 }
15465 else if (attack_mode == ATTACK_MODE_HYBRID2)
15466 {
15467 device_param->kernel_params_mp_buf32[5] = 0;
15468 device_param->kernel_params_mp_buf32[6] = 0;
15469 device_param->kernel_params_mp_buf32[7] = 0;
15470 }
15471
15472 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15473 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15474 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15475
15476 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15477 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15478 }
15479 }
15480 else if (attack_mode == ATTACK_MODE_BF)
15481 {
15482 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15483
15484 if (increment)
15485 {
15486 for (uint i = 0; i < dictcnt; i++)
15487 {
15488 local_free (dictfiles[i]);
15489 }
15490
15491 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15492 {
15493 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15494
15495 if (l1_filename == NULL) break;
15496
15497 dictcnt++;
15498
15499 dictfiles[dictcnt - 1] = l1_filename;
15500 }
15501 }
15502 else
15503 {
15504 dictcnt++;
15505
15506 dictfiles[dictcnt - 1] = mask;
15507 }
15508
15509 if (dictcnt == 0)
15510 {
15511 log_error ("ERROR: Mask is too small");
15512
15513 return (-1);
15514 }
15515 }
15516 }
15517
15518 free (induction_dictionaries);
15519
15520 // induction_dictionaries_cnt = 0; // implied
15521
15522 if (attack_mode != ATTACK_MODE_BF)
15523 {
15524 if (keyspace == 0)
15525 {
15526 induction_dictionaries = scan_directory (induction_directory);
15527
15528 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15529 }
15530 }
15531
15532 if (induction_dictionaries_cnt)
15533 {
15534 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15535 }
15536
15537 /**
15538 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15539 */
15540 if (keyspace == 1)
15541 {
15542 if ((maskcnt > 1) || (dictcnt > 1))
15543 {
15544 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15545
15546 return (-1);
15547 }
15548 }
15549
15550 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15551 {
15552 char *subid = logfile_generate_subid ();
15553
15554 data.subid = subid;
15555
15556 logfile_sub_msg ("START");
15557
15558 data.devices_status = STATUS_INIT;
15559
15560 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15561 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15562 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15563
15564 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15565
15566 data.cpt_pos = 0;
15567
15568 data.cpt_start = time (NULL);
15569
15570 data.cpt_total = 0;
15571
15572 if (data.restore == 0)
15573 {
15574 rd->words_cur = skip;
15575
15576 skip = 0;
15577
15578 data.skip = 0;
15579 }
15580
15581 data.ms_paused = 0;
15582
15583 data.words_cur = rd->words_cur;
15584
15585 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15586 {
15587 hc_device_param_t *device_param = &data.devices_param[device_id];
15588
15589 if (device_param->skipped) continue;
15590
15591 device_param->speed_pos = 0;
15592
15593 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15594 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15595 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15596
15597 device_param->kernel_power = device_param->kernel_power_user;
15598 device_param->kernel_blocks = device_param->kernel_blocks_user;
15599
15600 device_param->outerloop_pos = 0;
15601 device_param->outerloop_left = 0;
15602 device_param->innerloop_pos = 0;
15603 device_param->innerloop_left = 0;
15604
15605 // some more resets:
15606
15607 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15608
15609 memset (device_param->pws_buf, 0, device_param->size_pws);
15610
15611 device_param->pw_cnt = 0;
15612 device_param->pws_cnt = 0;
15613
15614 device_param->words_off = 0;
15615 device_param->words_done = 0;
15616 }
15617
15618 data.kernel_blocks_div = 0;
15619
15620 // figure out some workload
15621
15622 if (attack_mode == ATTACK_MODE_STRAIGHT)
15623 {
15624 if (data.wordlist_mode == WL_MODE_FILE)
15625 {
15626 char *dictfile = NULL;
15627
15628 if (induction_dictionaries_cnt)
15629 {
15630 dictfile = induction_dictionaries[0];
15631 }
15632 else
15633 {
15634 dictfile = dictfiles[dictpos];
15635 }
15636
15637 data.dictfile = dictfile;
15638
15639 logfile_sub_string (dictfile);
15640
15641 for (uint i = 0; i < rp_files_cnt; i++)
15642 {
15643 logfile_sub_var_string ("rulefile", rp_files[i]);
15644 }
15645
15646 FILE *fd2 = fopen (dictfile, "rb");
15647
15648 if (fd2 == NULL)
15649 {
15650 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15651
15652 return (-1);
15653 }
15654
15655 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15656
15657 fclose (fd2);
15658
15659 if (data.words_cnt == 0)
15660 {
15661 if (data.devices_status == STATUS_CRACKED) break;
15662 if (data.devices_status == STATUS_ABORTED) break;
15663
15664 dictpos++;
15665
15666 continue;
15667 }
15668 }
15669 }
15670 else if (attack_mode == ATTACK_MODE_COMBI)
15671 {
15672 char *dictfile = data.dictfile;
15673 char *dictfile2 = data.dictfile2;
15674
15675 logfile_sub_string (dictfile);
15676 logfile_sub_string (dictfile2);
15677
15678 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15679 {
15680 FILE *fd2 = fopen (dictfile, "rb");
15681
15682 if (fd2 == NULL)
15683 {
15684 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15685
15686 return (-1);
15687 }
15688
15689 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15690
15691 fclose (fd2);
15692 }
15693 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15694 {
15695 FILE *fd2 = fopen (dictfile2, "rb");
15696
15697 if (fd2 == NULL)
15698 {
15699 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15700
15701 return (-1);
15702 }
15703
15704 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15705
15706 fclose (fd2);
15707 }
15708
15709 if (data.words_cnt == 0)
15710 {
15711 if (data.devices_status == STATUS_CRACKED) break;
15712 if (data.devices_status == STATUS_ABORTED) break;
15713
15714 dictpos++;
15715
15716 continue;
15717 }
15718 }
15719 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15720 {
15721 char *dictfile = NULL;
15722
15723 if (induction_dictionaries_cnt)
15724 {
15725 dictfile = induction_dictionaries[0];
15726 }
15727 else
15728 {
15729 dictfile = dictfiles[dictpos];
15730 }
15731
15732 data.dictfile = dictfile;
15733
15734 char *mask = data.mask;
15735
15736 logfile_sub_string (dictfile);
15737 logfile_sub_string (mask);
15738
15739 FILE *fd2 = fopen (dictfile, "rb");
15740
15741 if (fd2 == NULL)
15742 {
15743 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15744
15745 return (-1);
15746 }
15747
15748 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15749
15750 fclose (fd2);
15751
15752 if (data.words_cnt == 0)
15753 {
15754 if (data.devices_status == STATUS_CRACKED) break;
15755 if (data.devices_status == STATUS_ABORTED) break;
15756
15757 dictpos++;
15758
15759 continue;
15760 }
15761 }
15762 else if (attack_mode == ATTACK_MODE_BF)
15763 {
15764 local_free (css_buf);
15765 local_free (data.root_css_buf);
15766 local_free (data.markov_css_buf);
15767
15768 char *mask = dictfiles[dictpos];
15769
15770 logfile_sub_string (mask);
15771
15772 // base
15773
15774 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15775
15776 if (opts_type & OPTS_TYPE_PT_UNICODE)
15777 {
15778 uint css_cnt_unicode = css_cnt * 2;
15779
15780 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15781
15782 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15783 {
15784 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15785
15786 css_buf_unicode[j + 1].cs_buf[0] = 0;
15787 css_buf_unicode[j + 1].cs_len = 1;
15788 }
15789
15790 free (css_buf);
15791
15792 css_buf = css_buf_unicode;
15793 css_cnt = css_cnt_unicode;
15794 }
15795
15796 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15797
15798 uint mask_min = pw_min;
15799 uint mask_max = pw_max;
15800
15801 if (opts_type & OPTS_TYPE_PT_UNICODE)
15802 {
15803 mask_min *= 2;
15804 mask_max *= 2;
15805 }
15806
15807 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15808 {
15809 if (css_cnt < mask_min)
15810 {
15811 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15812 }
15813
15814 if (css_cnt > mask_max)
15815 {
15816 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15817 }
15818
15819 // skip to next mask
15820
15821 dictpos++;
15822
15823 rd->dictpos = dictpos;
15824
15825 logfile_sub_msg ("STOP");
15826
15827 continue;
15828 }
15829
15830 uint save_css_cnt = css_cnt;
15831
15832 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15833 {
15834 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15835 {
15836 uint salt_len = (uint) data.salts_buf[0].salt_len;
15837 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15838
15839 uint css_cnt_salt = css_cnt + salt_len;
15840
15841 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15842
15843 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15844
15845 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15846 {
15847 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15848 css_buf_salt[j].cs_len = 1;
15849 }
15850
15851 free (css_buf);
15852
15853 css_buf = css_buf_salt;
15854 css_cnt = css_cnt_salt;
15855 }
15856 }
15857
15858 data.mask = mask;
15859 data.css_cnt = css_cnt;
15860 data.css_buf = css_buf;
15861
15862 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15863
15864 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15865
15866 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15867
15868 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15869 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15870
15871 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15872
15873 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15874
15875 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15876 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15877
15878 data.root_css_buf = root_css_buf;
15879 data.markov_css_buf = markov_css_buf;
15880
15881 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15882
15883 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15884
15885 local_free (root_table_buf);
15886 local_free (markov_table_buf);
15887
15888 // copy + args
15889
15890 uint css_cnt_l = css_cnt;
15891 uint css_cnt_r;
15892
15893 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15894 {
15895 if (save_css_cnt < 6)
15896 {
15897 css_cnt_r = 1;
15898 }
15899 else if (save_css_cnt == 6)
15900 {
15901 css_cnt_r = 2;
15902 }
15903 else
15904 {
15905 if (opts_type & OPTS_TYPE_PT_UNICODE)
15906 {
15907 if (save_css_cnt == 8 || save_css_cnt == 10)
15908 {
15909 css_cnt_r = 2;
15910 }
15911 else
15912 {
15913 css_cnt_r = 4;
15914 }
15915 }
15916 else
15917 {
15918 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15919 {
15920 css_cnt_r = 3;
15921 }
15922 else
15923 {
15924 css_cnt_r = 4;
15925 }
15926 }
15927 }
15928 }
15929 else
15930 {
15931 css_cnt_r = 1;
15932
15933 /* unfinished code?
15934 int sum = css_buf[css_cnt_r - 1].cs_len;
15935
15936 for (uint i = 1; i < 4 && i < css_cnt; i++)
15937 {
15938 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15939
15940 css_cnt_r++;
15941
15942 sum *= css_buf[css_cnt_r - 1].cs_len;
15943 }
15944 */
15945 }
15946
15947 css_cnt_l -= css_cnt_r;
15948
15949 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15950
15951 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15952 {
15953 hc_device_param_t *device_param = &data.devices_param[device_id];
15954
15955 if (device_param->skipped) continue;
15956
15957 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15958 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15959 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15960
15961 device_param->kernel_params_mp_l_buf64[3] = 0;
15962 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15963 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15964 device_param->kernel_params_mp_l_buf32[6] = 0;
15965 device_param->kernel_params_mp_l_buf32[7] = 0;
15966 device_param->kernel_params_mp_l_buf32[8] = 0;
15967
15968 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15969 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15970 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15971 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15972
15973 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15974 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15975 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15976
15977 device_param->kernel_params_mp_r_buf64[3] = 0;
15978 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15979 device_param->kernel_params_mp_r_buf32[5] = 0;
15980 device_param->kernel_params_mp_r_buf32[6] = 0;
15981 device_param->kernel_params_mp_r_buf32[7] = 0;
15982
15983 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
15984 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
15985 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
15986
15987 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
15988 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
15989 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
15990
15991 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
15992 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
15993 }
15994 }
15995
15996 u64 words_base = data.words_cnt;
15997
15998 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15999 {
16000 if (data.kernel_rules_cnt)
16001 {
16002 words_base /= data.kernel_rules_cnt;
16003 }
16004 }
16005 else if (data.attack_kern == ATTACK_KERN_COMBI)
16006 {
16007 if (data.combs_cnt)
16008 {
16009 words_base /= data.combs_cnt;
16010 }
16011 }
16012 else if (data.attack_kern == ATTACK_KERN_BF)
16013 {
16014 if (data.bfs_cnt)
16015 {
16016 words_base /= data.bfs_cnt;
16017 }
16018 }
16019
16020 data.words_base = words_base;
16021
16022 if (keyspace == 1)
16023 {
16024 log_info ("%llu", (unsigned long long int) words_base);
16025
16026 return (0);
16027 }
16028
16029 if (data.words_cur > data.words_base)
16030 {
16031 log_error ("ERROR: restore value greater keyspace");
16032
16033 return (-1);
16034 }
16035
16036 if (data.words_cur)
16037 {
16038 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16039 {
16040 for (uint i = 0; i < data.salts_cnt; i++)
16041 {
16042 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16043 }
16044 }
16045 else if (data.attack_kern == ATTACK_KERN_COMBI)
16046 {
16047 for (uint i = 0; i < data.salts_cnt; i++)
16048 {
16049 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16050 }
16051 }
16052 else if (data.attack_kern == ATTACK_KERN_BF)
16053 {
16054 for (uint i = 0; i < data.salts_cnt; i++)
16055 {
16056 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16057 }
16058 }
16059 }
16060
16061 /*
16062 * Inform user about possible slow speeds
16063 */
16064
16065 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16066 {
16067 if (data.words_base < kernel_blocks_all)
16068 {
16069 if (quiet == 0)
16070 {
16071 log_info ("");
16072 log_info ("ATTENTION!");
16073 log_info (" The wordlist or mask you are using is too small.");
16074 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16075 log_info (" The cracking speed will drop.");
16076 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16077 log_info ("");
16078 }
16079 }
16080 }
16081
16082 /*
16083 * Update loopback file
16084 */
16085
16086 if (loopback == 1)
16087 {
16088 time_t now;
16089
16090 time (&now);
16091
16092 uint random_num = get_random_num (0, 9999);
16093
16094 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16095
16096 data.loopback_file = loopback_file;
16097 }
16098
16099 /*
16100 * Update dictionary statistic
16101 */
16102
16103 if (keyspace == 0)
16104 {
16105 dictstat_fp = fopen (dictstat, "wb");
16106
16107 if (dictstat_fp)
16108 {
16109 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16110
16111 fclose (dictstat_fp);
16112 }
16113 }
16114
16115 data.devices_status = STATUS_RUNNING;
16116
16117 if (initial_restore_done == 0)
16118 {
16119 if (data.restore_disable == 0) cycle_restore ();
16120
16121 initial_restore_done = 1;
16122 }
16123
16124 hc_timer_set (&data.timer_running);
16125
16126 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16127 {
16128 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16129 {
16130 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16131 if (quiet == 0) fflush (stdout);
16132 }
16133 }
16134 else if (wordlist_mode == WL_MODE_STDIN)
16135 {
16136 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16137 if (data.quiet == 0) log_info ("");
16138 }
16139
16140 time_t runtime_start;
16141
16142 time (&runtime_start);
16143
16144 data.runtime_start = runtime_start;
16145
16146 /**
16147 * create cracker threads
16148 */
16149
16150 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16151
16152 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16153 {
16154 hc_device_param_t *device_param = &devices_param[device_id];
16155
16156 if (wordlist_mode == WL_MODE_STDIN)
16157 {
16158 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16159 }
16160 else
16161 {
16162 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16163 }
16164 }
16165
16166 // wait for crack threads to exit
16167
16168 hc_thread_wait (devices_cnt, c_threads);
16169
16170 local_free (c_threads);
16171
16172 data.restore = 0;
16173
16174 // finalize task
16175
16176 logfile_sub_var_uint ("status-after-work", data.devices_status);
16177
16178 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16179
16180 if (data.devices_status == STATUS_CRACKED) break;
16181 if (data.devices_status == STATUS_ABORTED) break;
16182
16183 if (data.devices_status == STATUS_BYPASS)
16184 {
16185 data.devices_status = STATUS_RUNNING;
16186 }
16187
16188 if (induction_dictionaries_cnt)
16189 {
16190 unlink (induction_dictionaries[0]);
16191 }
16192
16193 free (induction_dictionaries);
16194
16195 if (attack_mode != ATTACK_MODE_BF)
16196 {
16197 induction_dictionaries = scan_directory (induction_directory);
16198
16199 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16200 }
16201
16202 if (benchmark == 0)
16203 {
16204 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16205 {
16206 if (quiet == 0) clear_prompt ();
16207
16208 if (quiet == 0) log_info ("");
16209
16210 if (status == 1)
16211 {
16212 status_display ();
16213 }
16214 else
16215 {
16216 if (quiet == 0) status_display ();
16217 }
16218
16219 if (quiet == 0) log_info ("");
16220 }
16221 }
16222
16223 if (attack_mode == ATTACK_MODE_BF)
16224 {
16225 dictpos++;
16226
16227 rd->dictpos = dictpos;
16228 }
16229 else
16230 {
16231 if (induction_dictionaries_cnt)
16232 {
16233 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16234 }
16235 else
16236 {
16237 dictpos++;
16238
16239 rd->dictpos = dictpos;
16240 }
16241 }
16242
16243 time_t runtime_stop;
16244
16245 time (&runtime_stop);
16246
16247 data.runtime_stop = runtime_stop;
16248
16249 logfile_sub_uint (runtime_start);
16250 logfile_sub_uint (runtime_stop);
16251
16252 logfile_sub_msg ("STOP");
16253
16254 global_free (subid);
16255 }
16256
16257 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16258
16259 if (data.devices_status == STATUS_CRACKED) break;
16260 if (data.devices_status == STATUS_ABORTED) break;
16261 if (data.devices_status == STATUS_QUIT) break;
16262
16263 if (data.devices_status == STATUS_BYPASS)
16264 {
16265 data.devices_status = STATUS_RUNNING;
16266 }
16267 }
16268
16269 // 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
16270
16271 if (attack_mode == ATTACK_MODE_STRAIGHT)
16272 {
16273 if (data.wordlist_mode == WL_MODE_FILE)
16274 {
16275 if (data.dictfile == NULL)
16276 {
16277 if (dictfiles != NULL)
16278 {
16279 data.dictfile = dictfiles[0];
16280
16281 hc_timer_set (&data.timer_running);
16282 }
16283 }
16284 }
16285 }
16286 // NOTE: combi is okay because it is already set beforehand
16287 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16288 {
16289 if (data.dictfile == NULL)
16290 {
16291 if (dictfiles != NULL)
16292 {
16293 hc_timer_set (&data.timer_running);
16294
16295 data.dictfile = dictfiles[0];
16296 }
16297 }
16298 }
16299 else if (attack_mode == ATTACK_MODE_BF)
16300 {
16301 if (data.mask == NULL)
16302 {
16303 hc_timer_set (&data.timer_running);
16304
16305 data.mask = masks[0];
16306 }
16307 }
16308
16309 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16310 {
16311 data.devices_status = STATUS_EXHAUSTED;
16312 }
16313
16314 // if cracked / aborted remove last induction dictionary
16315
16316 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16317 {
16318 struct stat induct_stat;
16319
16320 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16321 {
16322 unlink (induction_dictionaries[file_pos]);
16323 }
16324 }
16325
16326 // wait for non-interactive threads
16327
16328 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16329 {
16330 hc_thread_wait (1, &ni_threads[thread_idx]);
16331 }
16332
16333 local_free (ni_threads);
16334
16335 // wait for interactive threads
16336
16337 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16338 {
16339 hc_thread_wait (1, &i_thread);
16340 }
16341
16342 // we dont need restore file anymore
16343 if (data.restore_disable == 0)
16344 {
16345 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16346 {
16347 unlink (eff_restore_file);
16348 unlink (new_restore_file);
16349 }
16350 else
16351 {
16352 cycle_restore ();
16353 }
16354 }
16355
16356 // finally save left hashes
16357
16358 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16359 {
16360 save_hash ();
16361 }
16362
16363 /**
16364 * Clean up
16365 */
16366
16367 if (benchmark == 1)
16368 {
16369 status_benchmark ();
16370
16371 log_info ("");
16372 }
16373 else
16374 {
16375 if (quiet == 0) clear_prompt ();
16376
16377 if (quiet == 0) log_info ("");
16378
16379 if (status == 1)
16380 {
16381 status_display ();
16382 }
16383 else
16384 {
16385 if (quiet == 0) status_display ();
16386 }
16387
16388 if (quiet == 0) log_info ("");
16389 }
16390
16391 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16392 {
16393 hc_device_param_t *device_param = &data.devices_param[device_id];
16394
16395 if (device_param->skipped) continue;
16396
16397 local_free (device_param->result);
16398
16399 local_free (device_param->pw_caches);
16400
16401 local_free (device_param->combs_buf);
16402
16403 local_free (device_param->hooks_buf);
16404
16405 local_free (device_param->device_name);
16406
16407 local_free (device_param->device_name_chksum);
16408
16409 local_free (device_param->device_version);
16410
16411 local_free (device_param->driver_version);
16412
16413 if (device_param->pws_buf) myfree (device_param->pws_buf);
16414 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16415 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16416 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16417 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16418 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16419 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16420 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16421 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16422 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16423 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16424 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16425 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16426 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16427 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16428 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16429 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16430 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16431 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16432 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16433 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16434 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16435 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16436 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16437 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16438 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16439 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16440 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16441 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16442
16443 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16444 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16445 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16446 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16447 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16448 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16449 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16450 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16451 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16452 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16453 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16454
16455 if (device_param->program) hc_clReleaseProgram (device_param->program);
16456 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16457 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16458
16459 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16460 if (device_param->context) hc_clReleaseContext (device_param->context);
16461 }
16462
16463 // reset default fan speed
16464
16465 #ifdef HAVE_HWMON
16466 if (gpu_temp_disable == 0)
16467 {
16468 #ifdef HAVE_ADL
16469 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16470 {
16471 hc_thread_mutex_lock (mux_adl);
16472
16473 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16474 {
16475 hc_device_param_t *device_param = &data.devices_param[device_id];
16476
16477 if (device_param->skipped) continue;
16478
16479 if (data.hm_device[device_id].fan_supported == 1)
16480 {
16481 int fanspeed = temp_retain_fanspeed_value[device_id];
16482
16483 if (fanspeed == -1) continue;
16484
16485 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16486
16487 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16488 }
16489 }
16490
16491 hc_thread_mutex_unlock (mux_adl);
16492 }
16493 #endif // HAVE_ADL
16494 }
16495
16496 // reset power tuning
16497
16498 #ifdef HAVE_ADL
16499 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16500 {
16501 hc_thread_mutex_lock (mux_adl);
16502
16503 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16504 {
16505 hc_device_param_t *device_param = &data.devices_param[device_id];
16506
16507 if (device_param->skipped) continue;
16508
16509 if (data.hm_device[device_id].od_version == 6)
16510 {
16511 // check powertune capabilities first, if not available then skip device
16512
16513 int powertune_supported = 0;
16514
16515 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16516 {
16517 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16518
16519 return (-1);
16520 }
16521
16522 if (powertune_supported != 0)
16523 {
16524 // powercontrol settings
16525
16526 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
16527 {
16528 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16529
16530 return (-1);
16531 }
16532
16533 // clocks
16534
16535 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16536
16537 performance_state->iNumberOfPerformanceLevels = 2;
16538
16539 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16540 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16541 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16542 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16543
16544 if ((hc_ADL_Overdrive_State_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16545 {
16546 log_info ("ERROR: Failed to restore ADL performance state");
16547
16548 return (-1);
16549 }
16550
16551 local_free (performance_state);
16552 }
16553 }
16554 }
16555
16556 hc_thread_mutex_unlock (mux_adl);
16557 }
16558 #endif // HAVE_ADL
16559
16560 if (gpu_temp_disable == 0)
16561 {
16562 #if defined(LINUX) && defined(HAVE_NVML)
16563 if (data.hm_dll_nv)
16564 {
16565 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16566
16567 hm_close (data.hm_dll_nv);
16568 }
16569 #endif
16570
16571 #if defined(WIN) && (HAVE_NVAPI)
16572 NvAPI_Unload ();
16573 #endif
16574
16575 #ifdef HAVE_ADL
16576 if (data.hm_dll_amd)
16577 {
16578 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16579
16580 hm_close (data.hm_dll_amd);
16581 }
16582 #endif
16583 }
16584 #endif // HAVE_HWMON
16585
16586 // free memory
16587
16588 local_free (masks);
16589
16590 local_free (dictstat_base);
16591
16592 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16593 {
16594 pot_t *pot_ptr = &pot[pot_pos];
16595
16596 hash_t *hash = &pot_ptr->hash;
16597
16598 local_free (hash->digest);
16599
16600 if (isSalted)
16601 {
16602 local_free (hash->salt);
16603 }
16604 }
16605
16606 local_free (pot);
16607
16608 local_free (all_kernel_rules_cnt);
16609 local_free (all_kernel_rules_buf);
16610
16611 local_free (wl_data->buf);
16612 local_free (wl_data);
16613
16614 local_free (bitmap_s1_a);
16615 local_free (bitmap_s1_b);
16616 local_free (bitmap_s1_c);
16617 local_free (bitmap_s1_d);
16618 local_free (bitmap_s2_a);
16619 local_free (bitmap_s2_b);
16620 local_free (bitmap_s2_c);
16621 local_free (bitmap_s2_d);
16622
16623 #ifdef HAVE_HWMON
16624 local_free (temp_retain_fanspeed_value);
16625 #ifdef HAVE_ADL
16626 local_free (od_clock_mem_status);
16627 local_free (od_power_control_status);
16628 #endif // ADL
16629 #endif
16630
16631 global_free (devices_param);
16632
16633 global_free (kernel_rules_buf);
16634
16635 global_free (root_css_buf);
16636 global_free (markov_css_buf);
16637
16638 global_free (digests_buf);
16639 global_free (digests_shown);
16640 global_free (digests_shown_tmp);
16641
16642 global_free (salts_buf);
16643 global_free (salts_shown);
16644
16645 global_free (esalts_buf);
16646
16647 global_free (words_progress_done);
16648 global_free (words_progress_rejected);
16649 global_free (words_progress_restored);
16650
16651 if (pot_fp) fclose (pot_fp);
16652
16653 if (data.devices_status == STATUS_QUIT) break;
16654 }
16655
16656 // destroy others mutex
16657
16658 hc_thread_mutex_delete (mux_dispatcher);
16659 hc_thread_mutex_delete (mux_counter);
16660 hc_thread_mutex_delete (mux_display);
16661 hc_thread_mutex_delete (mux_adl);
16662
16663 // free memory
16664
16665 local_free (eff_restore_file);
16666 local_free (new_restore_file);
16667
16668 local_free (rd);
16669
16670 // loopback
16671
16672 local_free (loopback_file);
16673
16674 if (loopback == 1) unlink (loopback_file);
16675
16676 // induction directory
16677
16678 if (induction_dir == NULL)
16679 {
16680 if (attack_mode != ATTACK_MODE_BF)
16681 {
16682 if (rmdir (induction_directory) == -1)
16683 {
16684 if (errno == ENOENT)
16685 {
16686 // good, we can ignore
16687 }
16688 else if (errno == ENOTEMPTY)
16689 {
16690 // good, we can ignore
16691 }
16692 else
16693 {
16694 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16695
16696 return (-1);
16697 }
16698 }
16699
16700 local_free (induction_directory);
16701 }
16702 }
16703
16704 // outfile-check directory
16705
16706 if (outfile_check_dir == NULL)
16707 {
16708 if (rmdir (outfile_check_directory) == -1)
16709 {
16710 if (errno == ENOENT)
16711 {
16712 // good, we can ignore
16713 }
16714 else if (errno == ENOTEMPTY)
16715 {
16716 // good, we can ignore
16717 }
16718 else
16719 {
16720 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16721
16722 return (-1);
16723 }
16724 }
16725
16726 local_free (outfile_check_directory);
16727 }
16728
16729 time_t proc_stop;
16730
16731 time (&proc_stop);
16732
16733 logfile_top_uint (proc_start);
16734 logfile_top_uint (proc_stop);
16735
16736 logfile_top_msg ("STOP");
16737
16738 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16739 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16740
16741 if (data.devices_status == STATUS_ABORTED) return 2;
16742 if (data.devices_status == STATUS_QUIT) return 2;
16743 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16744 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16745 if (data.devices_status == STATUS_CRACKED) return 0;
16746
16747 return -1;
16748 }
Hashcat additions to support pwdhash