projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed some memory allocations and other small things
[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 = (char *) mymalloc (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 myfree (in);
10808 }
10809 else if (hash_mode == 3000)
10810 {
10811 if (hash_len == 32)
10812 {
10813 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10814
10815 hash_t *lm_hash_left = NULL;
10816
10817 if (parser_status == PARSER_OK)
10818 {
10819 lm_hash_left = &hashes_buf[hashes_cnt];
10820
10821 hashes_cnt++;
10822 }
10823 else
10824 {
10825 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10826 }
10827
10828
10829 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10830
10831 hash_t *lm_hash_right = NULL;
10832
10833 if (parser_status == PARSER_OK)
10834 {
10835 lm_hash_right = &hashes_buf[hashes_cnt];
10836
10837 hashes_cnt++;
10838 }
10839 else
10840 {
10841 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10842 }
10843
10844 // show / left
10845
10846 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10847 {
10848 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);
10849 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);
10850 }
10851 }
10852 else
10853 {
10854 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10855
10856 if (parser_status == PARSER_OK)
10857 {
10858 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10859 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10860 }
10861
10862 if (parser_status == PARSER_OK)
10863 {
10864 hashes_cnt++;
10865 }
10866 else
10867 {
10868 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10869 }
10870 }
10871 }
10872 else
10873 {
10874 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10875
10876 if (parser_status == PARSER_OK)
10877 {
10878 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10879 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10880 }
10881
10882 if (parser_status == PARSER_OK)
10883 {
10884 hashes_cnt++;
10885 }
10886 else
10887 {
10888 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10889 }
10890 }
10891 }
10892 }
10893 else if (hashlist_mode == HL_MODE_FILE)
10894 {
10895 char *hashfile = data.hashfile;
10896
10897 FILE *fp;
10898
10899 if ((fp = fopen (hashfile, "rb")) == NULL)
10900 {
10901 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10902
10903 return (-1);
10904 }
10905
10906 uint line_num = 0;
10907
10908 while (!feof (fp))
10909 {
10910 line_num++;
10911
10912 char line_buf[BUFSIZ];
10913
10914 int line_len = fgetl (fp, line_buf);
10915
10916 if (line_len == 0) continue;
10917
10918 char *hash_buf = NULL;
10919 int hash_len = 0;
10920
10921 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10922
10923 if (username)
10924 {
10925 char *user_buf = NULL;
10926 int user_len = 0;
10927
10928 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10929
10930 if (remove || show)
10931 {
10932 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10933
10934 *user = (user_t *) malloc (sizeof (user_t));
10935
10936 user_t *user_ptr = *user;
10937
10938 if (user_buf != NULL)
10939 {
10940 user_ptr->user_name = mystrdup (user_buf);
10941 }
10942 else
10943 {
10944 user_ptr->user_name = mystrdup ("");
10945 }
10946
10947 user_ptr->user_len = user_len;
10948 }
10949 }
10950
10951 if (opts_type & OPTS_TYPE_HASH_COPY)
10952 {
10953 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10954
10955 hash_info_tmp->orighash = mystrdup (hash_buf);
10956 }
10957
10958 if (isSalted)
10959 {
10960 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10961 }
10962
10963 if (hash_mode == 3000)
10964 {
10965 if (hash_len == 32)
10966 {
10967 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10968
10969 if (parser_status < PARSER_GLOBAL_ZERO)
10970 {
10971 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10972
10973 continue;
10974 }
10975
10976 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10977
10978 hashes_cnt++;
10979
10980 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10981
10982 if (parser_status < PARSER_GLOBAL_ZERO)
10983 {
10984 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10985
10986 continue;
10987 }
10988
10989 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10990
10991 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);
10992
10993 hashes_cnt++;
10994
10995 // show / left
10996
10997 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);
10998 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);
10999 }
11000 else
11001 {
11002 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11003
11004 if (parser_status < PARSER_GLOBAL_ZERO)
11005 {
11006 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11007
11008 continue;
11009 }
11010
11011 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);
11012
11013 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11014 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11015
11016 hashes_cnt++;
11017 }
11018 }
11019 else
11020 {
11021 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11022
11023 if (parser_status < PARSER_GLOBAL_ZERO)
11024 {
11025 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11026
11027 continue;
11028 }
11029
11030 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);
11031
11032 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11033 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11034
11035 hashes_cnt++;
11036 }
11037 }
11038
11039 fclose (fp);
11040
11041 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11042
11043 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11044 }
11045 }
11046 else
11047 {
11048 if (isSalted)
11049 {
11050 hashes_buf[0].salt->salt_len = 8;
11051
11052 // special salt handling
11053
11054 switch (hash_mode)
11055 {
11056 case 1500: hashes_buf[0].salt->salt_len = 2;
11057 break;
11058 case 1731: hashes_buf[0].salt->salt_len = 4;
11059 break;
11060 case 2410: hashes_buf[0].salt->salt_len = 4;
11061 break;
11062 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11063 break;
11064 case 3100: hashes_buf[0].salt->salt_len = 1;
11065 break;
11066 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11067 break;
11068 case 5800: hashes_buf[0].salt->salt_len = 16;
11069 break;
11070 case 6800: hashes_buf[0].salt->salt_len = 32;
11071 break;
11072 case 8400: hashes_buf[0].salt->salt_len = 40;
11073 break;
11074 case 8800: hashes_buf[0].salt->salt_len = 16;
11075 break;
11076 case 8900: hashes_buf[0].salt->salt_len = 16;
11077 hashes_buf[0].salt->scrypt_N = 1024;
11078 hashes_buf[0].salt->scrypt_r = 1;
11079 hashes_buf[0].salt->scrypt_p = 1;
11080 break;
11081 case 9100: hashes_buf[0].salt->salt_len = 16;
11082 break;
11083 case 9300: hashes_buf[0].salt->salt_len = 14;
11084 hashes_buf[0].salt->scrypt_N = 16384;
11085 hashes_buf[0].salt->scrypt_r = 1;
11086 hashes_buf[0].salt->scrypt_p = 1;
11087 break;
11088 case 9400: hashes_buf[0].salt->salt_len = 16;
11089 break;
11090 case 9500: hashes_buf[0].salt->salt_len = 16;
11091 break;
11092 case 9600: hashes_buf[0].salt->salt_len = 16;
11093 break;
11094 case 9700: hashes_buf[0].salt->salt_len = 16;
11095 break;
11096 case 9710: hashes_buf[0].salt->salt_len = 16;
11097 break;
11098 case 9720: hashes_buf[0].salt->salt_len = 16;
11099 break;
11100 case 9800: hashes_buf[0].salt->salt_len = 16;
11101 break;
11102 case 9810: hashes_buf[0].salt->salt_len = 16;
11103 break;
11104 case 9820: hashes_buf[0].salt->salt_len = 16;
11105 break;
11106 case 10300: hashes_buf[0].salt->salt_len = 12;
11107 break;
11108 case 11500: hashes_buf[0].salt->salt_len = 4;
11109 break;
11110 case 11600: hashes_buf[0].salt->salt_len = 4;
11111 break;
11112 case 12400: hashes_buf[0].salt->salt_len = 4;
11113 break;
11114 case 12500: hashes_buf[0].salt->salt_len = 8;
11115 break;
11116 case 12600: hashes_buf[0].salt->salt_len = 64;
11117 break;
11118 }
11119
11120 // special esalt handling
11121
11122 switch (hash_mode)
11123 {
11124 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11125 break;
11126 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11127 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11128 break;
11129 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11130 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11131 break;
11132 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11133 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11134 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11135 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11136 break;
11137 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11138 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11139 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11140 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11141 break;
11142 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11143 break;
11144 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11145 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11146 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11147 break;
11148 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11149 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11150 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11151 break;
11152 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11153 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11154 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11155 break;
11156 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11157 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11158 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11159 break;
11160 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11161 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11162 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11163 break;
11164 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11165 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11166 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11167 break;
11168 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11169 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11170 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11171 break;
11172 }
11173 }
11174
11175 // set hashfile
11176
11177 switch (hash_mode)
11178 {
11179 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11180 break;
11181 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11182 break;
11183 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11184 break;
11185 case 6211:
11186 case 6212:
11187 case 6213:
11188 case 6221:
11189 case 6222:
11190 case 6223:
11191 case 6231:
11192 case 6232:
11193 case 6233:
11194 case 6241:
11195 case 6242:
11196 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11197 break;
11198 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11199 break;
11200 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11201 break;
11202 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11203 break;
11204 }
11205
11206 // set default iterations
11207
11208 switch (hash_mode)
11209 {
11210 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11211 break;
11212 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11213 break;
11214 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11215 break;
11216 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11217 break;
11218 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11219 break;
11220 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11221 break;
11222 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11223 break;
11224 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11225 break;
11226 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11227 break;
11228 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11229 break;
11230 case 6211:
11231 case 6212:
11232 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11233 break;
11234 case 6221:
11235 case 6222:
11236 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11237 break;
11238 case 6231:
11239 case 6232:
11240 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11241 break;
11242 case 6241:
11243 case 6242:
11244 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11245 break;
11246 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11247 break;
11248 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11249 break;
11250 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11251 break;
11252 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11253 break;
11254 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11255 break;
11256 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11257 break;
11258 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11259 break;
11260 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11261 break;
11262 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11263 break;
11264 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11265 break;
11266 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11267 break;
11268 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11269 break;
11270 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11271 break;
11272 case 8900: hashes_buf[0].salt->salt_iter = 1;
11273 break;
11274 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11275 break;
11276 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11277 break;
11278 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11279 break;
11280 case 9300: hashes_buf[0].salt->salt_iter = 1;
11281 break;
11282 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11283 break;
11284 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11285 break;
11286 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11287 break;
11288 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11289 break;
11290 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11291 break;
11292 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11293 break;
11294 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11295 break;
11296 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11297 break;
11298 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11299 break;
11300 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11301 break;
11302 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11303 break;
11304 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11305 break;
11306 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11307 break;
11308 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11309 break;
11310 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11311 break;
11312 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11313 break;
11314 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11315 break;
11316 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11317 break;
11318 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11319 break;
11320 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11321 break;
11322 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11323 break;
11324 }
11325
11326 // set special tuning for benchmark-mode 1
11327
11328 if (benchmark_mode == 1)
11329 {
11330 kernel_loops *= 8;
11331 kernel_accel *= 4;
11332
11333 switch (hash_mode)
11334 {
11335 case 400: kernel_loops = ROUNDS_PHPASS;
11336 kernel_accel = 32;
11337 break;
11338 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11339 kernel_accel = 32;
11340 break;
11341 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11342 kernel_accel = 32;
11343 break;
11344 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11345 kernel_accel = 32;
11346 break;
11347 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11348 kernel_accel = 16;
11349 break;
11350 case 2100: kernel_loops = ROUNDS_DCC2;
11351 kernel_accel = 16;
11352 break;
11353 case 2500: kernel_loops = ROUNDS_WPA2;
11354 kernel_accel = 32;
11355 break;
11356 case 3200: kernel_loops = ROUNDS_BCRYPT;
11357 kernel_accel = 8;
11358 break;
11359 case 5200: kernel_loops = ROUNDS_PSAFE3;
11360 kernel_accel = 16;
11361 break;
11362 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11363 kernel_accel = 16;
11364 break;
11365 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11366 kernel_accel = 64;
11367 break;
11368 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11369 kernel_accel = 32;
11370 break;
11371 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11372 kernel_accel = 32;
11373 break;
11374 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11375 kernel_accel = 8;
11376 break;
11377 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11378 kernel_accel = 8;
11379 break;
11380 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11381 kernel_accel = 8;
11382 break;
11383 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11384 kernel_accel = 8;
11385 break;
11386 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11387 kernel_accel = 8;
11388 break;
11389 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11390 kernel_accel = 8;
11391 break;
11392 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11393 kernel_accel = 128;
11394 break;
11395 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11396 kernel_accel = 64;
11397 break;
11398 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11399 kernel_accel = 64;
11400 break;
11401 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11402 kernel_accel = 32;
11403 break;
11404 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11405 kernel_accel = 128;
11406 break;
11407 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11408 kernel_accel = 128;
11409 break;
11410 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11411 kernel_accel = 32;
11412 break;
11413 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11414 kernel_accel = 64;
11415 break;
11416 case 6800: kernel_loops = ROUNDS_LASTPASS;
11417 kernel_accel = 64;
11418 break;
11419 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11420 kernel_accel = 8;
11421 break;
11422 case 7200: kernel_loops = ROUNDS_GRUB;
11423 kernel_accel = 16;
11424 break;
11425 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11426 kernel_accel = 8;
11427 break;
11428 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11429 kernel_accel = 8;
11430 break;
11431 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11432 kernel_accel = 8;
11433 break;
11434 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11435 kernel_accel = 32;
11436 break;
11437 case 8900: kernel_loops = 1;
11438 kernel_accel = 64;
11439 break;
11440 case 9000: kernel_loops = ROUNDS_PSAFE2;
11441 kernel_accel = 16;
11442 break;
11443 case 9100: kernel_loops = ROUNDS_LOTUS8;
11444 kernel_accel = 64;
11445 break;
11446 case 9200: kernel_loops = ROUNDS_CISCO8;
11447 kernel_accel = 8;
11448 break;
11449 case 9300: kernel_loops = 1;
11450 kernel_accel = 4;
11451 break;
11452 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11453 kernel_accel = 32;
11454 break;
11455 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11456 kernel_accel = 32;
11457 break;
11458 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11459 kernel_accel = 8;
11460 break;
11461 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11462 kernel_accel = 8;
11463 break;
11464 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11465 kernel_accel = 16;
11466 break;
11467 case 10500: kernel_loops = ROUNDS_PDF14;
11468 kernel_accel = 256;
11469 break;
11470 case 10700: kernel_loops = ROUNDS_PDF17L8;
11471 kernel_accel = 8;
11472 break;
11473 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11474 kernel_accel = 8;
11475 break;
11476 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11477 kernel_accel = 8;
11478 break;
11479 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11480 kernel_accel = 8;
11481 break;
11482 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11483 kernel_accel = 8;
11484 break;
11485 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11486 kernel_accel = 8;
11487 break;
11488 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11489 kernel_accel = 8;
11490 break;
11491 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11492 kernel_accel = 8;
11493 break;
11494 case 12300: kernel_loops = ROUNDS_ORACLET;
11495 kernel_accel = 8;
11496 break;
11497 case 12500: kernel_loops = ROUNDS_RAR3;
11498 kernel_accel = 32;
11499 break;
11500 case 12700: kernel_loops = ROUNDS_MYWALLET;
11501 kernel_accel = 512;
11502 break;
11503 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11504 kernel_accel = 512;
11505 break;
11506 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11507 kernel_accel = 8;
11508 break;
11509 case 13000: kernel_loops = ROUNDS_RAR5;
11510 kernel_accel = 8;
11511 break;
11512 }
11513
11514 // some algorithm collide too fast, make that impossible
11515
11516 switch (hash_mode)
11517 {
11518 case 11500: ((uint *) digests_buf)[1] = 1;
11519 break;
11520 }
11521
11522 if (kernel_loops > 1024) kernel_loops = 1024;
11523 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11524 }
11525
11526 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11527 {
11528 kernel_loops = 1024;
11529 }
11530
11531 if (hash_mode == 12500)
11532 {
11533 kernel_loops = ROUNDS_RAR3 / 16;
11534 }
11535
11536 data.kernel_accel = kernel_accel;
11537 data.kernel_loops = kernel_loops;
11538
11539 hashes_cnt = 1;
11540 }
11541
11542 if (show == 1 || left == 1)
11543 {
11544 for (uint i = 0; i < pot_cnt; i++)
11545 {
11546 pot_t *pot_ptr = &pot[i];
11547
11548 hash_t *hashes_buf = &pot_ptr->hash;
11549
11550 local_free (hashes_buf->digest);
11551
11552 if (isSalted)
11553 {
11554 local_free (hashes_buf->salt);
11555 }
11556 }
11557
11558 local_free (pot);
11559
11560 if (data.quiet == 0) log_info_nn ("");
11561
11562 return (0);
11563 }
11564
11565 if (keyspace == 0)
11566 {
11567 if (hashes_cnt == 0)
11568 {
11569 log_error ("ERROR: No hashes loaded");
11570
11571 return (-1);
11572 }
11573 }
11574
11575 /**
11576 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11577 */
11578
11579 if (data.outfile != NULL)
11580 {
11581 if (data.hashfile != NULL)
11582 {
11583 #ifdef _POSIX
11584 struct stat tmpstat_outfile;
11585 struct stat tmpstat_hashfile;
11586 #endif
11587
11588 #ifdef _WIN
11589 struct stat64 tmpstat_outfile;
11590 struct stat64 tmpstat_hashfile;
11591 #endif
11592
11593 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11594
11595 if (tmp_outfile_fp)
11596 {
11597 #ifdef _POSIX
11598 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11599 #endif
11600
11601 #ifdef _WIN
11602 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11603 #endif
11604
11605 fclose (tmp_outfile_fp);
11606 }
11607
11608 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11609
11610 if (tmp_hashfile_fp)
11611 {
11612 #ifdef _POSIX
11613 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11614 #endif
11615
11616 #ifdef _WIN
11617 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11618 #endif
11619
11620 fclose (tmp_hashfile_fp);
11621 }
11622
11623 if (tmp_outfile_fp && tmp_outfile_fp)
11624 {
11625 tmpstat_outfile.st_mode = 0;
11626 tmpstat_outfile.st_nlink = 0;
11627 tmpstat_outfile.st_uid = 0;
11628 tmpstat_outfile.st_gid = 0;
11629 tmpstat_outfile.st_rdev = 0;
11630 tmpstat_outfile.st_atime = 0;
11631
11632 tmpstat_hashfile.st_mode = 0;
11633 tmpstat_hashfile.st_nlink = 0;
11634 tmpstat_hashfile.st_uid = 0;
11635 tmpstat_hashfile.st_gid = 0;
11636 tmpstat_hashfile.st_rdev = 0;
11637 tmpstat_hashfile.st_atime = 0;
11638
11639 #ifdef _POSIX
11640 tmpstat_outfile.st_blksize = 0;
11641 tmpstat_outfile.st_blocks = 0;
11642
11643 tmpstat_hashfile.st_blksize = 0;
11644 tmpstat_hashfile.st_blocks = 0;
11645 #endif
11646
11647 #ifdef _POSIX
11648 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11649 {
11650 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11651
11652 return (-1);
11653 }
11654 #endif
11655
11656 #ifdef _WIN
11657 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11658 {
11659 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11660
11661 return (-1);
11662 }
11663 #endif
11664 }
11665 }
11666 }
11667
11668 /**
11669 * Remove duplicates
11670 */
11671
11672 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11673
11674 if (isSalted)
11675 {
11676 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11677 }
11678 else
11679 {
11680 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11681 }
11682
11683 uint hashes_cnt_orig = hashes_cnt;
11684
11685 hashes_cnt = 1;
11686
11687 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11688 {
11689 if (isSalted)
11690 {
11691 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11692 {
11693 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11694 }
11695 }
11696 else
11697 {
11698 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11699 }
11700
11701 if (hashes_pos > hashes_cnt)
11702 {
11703 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11704 }
11705
11706 hashes_cnt++;
11707 }
11708
11709 /**
11710 * Potfile removes
11711 */
11712
11713 uint potfile_remove_cracks = 0;
11714
11715 if (potfile_disable == 0)
11716 {
11717 hash_t hash_buf;
11718
11719 hash_buf.digest = mymalloc (dgst_size);
11720 hash_buf.salt = NULL;
11721 hash_buf.esalt = NULL;
11722 hash_buf.hash_info = NULL;
11723 hash_buf.cracked = 0;
11724
11725 if (isSalted)
11726 {
11727 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11728 }
11729
11730 if (esalt_size)
11731 {
11732 hash_buf.esalt = mymalloc (esalt_size);
11733 }
11734
11735 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11736
11737 // no solution for these special hash types (for instane because they use hashfile in output etc)
11738 if ((hash_mode != 5200) &&
11739 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11740 (hash_mode != 9000))
11741 {
11742 FILE *fp = fopen (potfile, "rb");
11743
11744 if (fp != NULL)
11745 {
11746 while (!feof (fp))
11747 {
11748 char line_buf[BUFSIZ];
11749
11750 memset (line_buf, 0, BUFSIZ);
11751
11752 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11753
11754 if (ptr == NULL) break;
11755
11756 int line_len = strlen (line_buf);
11757
11758 if (line_len == 0) continue;
11759
11760 int iter = MAX_CUT_TRIES;
11761
11762 for (int i = line_len - 1; i && iter; i--, line_len--)
11763 {
11764 if (line_buf[i] != ':') continue;
11765
11766 if (isSalted)
11767 {
11768 memset (hash_buf.salt, 0, sizeof (salt_t));
11769 }
11770
11771 hash_t *found = NULL;
11772
11773 if (hash_mode == 6800)
11774 {
11775 if (i < 48) // 48 = 12 * uint in salt_buf[]
11776 {
11777 // manipulate salt_buf
11778 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11779
11780 hash_buf.salt->salt_len = i;
11781
11782 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11783 }
11784 }
11785 else if (hash_mode == 2500)
11786 {
11787 if (i < 48) // 48 = 12 * uint in salt_buf[]
11788 {
11789 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11790 // manipulate salt_buf
11791
11792 // to be safe work with a copy (because of line_len loop, i etc)
11793
11794 char line_buf_cpy[BUFSIZ];
11795 memset (line_buf_cpy, 0, BUFSIZ);
11796
11797 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11798
11799 memcpy (line_buf_cpy, line_buf, i);
11800
11801 char *mac2_pos = strrchr (line_buf_cpy, ':');
11802
11803 if (mac2_pos == NULL) continue;
11804
11805 mac2_pos[0] = 0;
11806 mac2_pos++;
11807
11808 if (strlen (mac2_pos) != 12) continue;
11809
11810 char *mac1_pos = strrchr (line_buf_cpy, ':');
11811
11812 if (mac1_pos == NULL) continue;
11813
11814 mac1_pos[0] = 0;
11815 mac1_pos++;
11816
11817 if (strlen (mac1_pos) != 12) continue;
11818
11819 uint essid_length = mac1_pos - line_buf_cpy - 1;
11820
11821 // here we need the ESSID
11822 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11823
11824 hash_buf.salt->salt_len = essid_length;
11825
11826 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11827
11828 if (found)
11829 {
11830 wpa_t *wpa = (wpa_t *) found->esalt;
11831
11832 uint pke[25];
11833
11834 char *pke_ptr = (char *) pke;
11835
11836 for (uint i = 0; i < 25; i++)
11837 {
11838 pke[i] = byte_swap_32 (wpa->pke[i]);
11839 }
11840
11841 u8 mac1[6];
11842 u8 mac2[6];
11843
11844 memcpy (mac1, pke_ptr + 23, 6);
11845 memcpy (mac2, pke_ptr + 29, 6);
11846
11847 // compare hex string(s) vs binary MAC address(es)
11848
11849 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11850 {
11851 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11852 {
11853 found = NULL;
11854 break;
11855 }
11856 }
11857
11858 // early skip ;)
11859 if (!found) continue;
11860
11861 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11862 {
11863 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11864 {
11865 found = NULL;
11866 break;
11867 }
11868 }
11869 }
11870 }
11871 }
11872 else
11873 {
11874 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11875
11876 if (parser_status == PARSER_OK)
11877 {
11878 if (isSalted)
11879 {
11880 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11881 }
11882 else
11883 {
11884 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11885 }
11886 }
11887 }
11888
11889 if (found == NULL) continue;
11890
11891 if (!found->cracked) potfile_remove_cracks++;
11892
11893 found->cracked = 1;
11894
11895 if (found) break;
11896
11897 iter--;
11898 }
11899 }
11900
11901 fclose (fp);
11902 }
11903 }
11904
11905 if (esalt_size)
11906 {
11907 local_free (hash_buf.esalt);
11908 }
11909
11910 if (isSalted)
11911 {
11912 local_free (hash_buf.salt);
11913 }
11914
11915 local_free (hash_buf.digest);
11916 }
11917
11918 /**
11919 * Now generate all the buffers required for later
11920 */
11921
11922 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11923
11924 salt_t *salts_buf_new = NULL;
11925 void *esalts_buf_new = NULL;
11926
11927 if (isSalted)
11928 {
11929 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11930
11931 if (esalt_size)
11932 {
11933 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11934 }
11935 }
11936 else
11937 {
11938 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11939 }
11940
11941 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11942
11943 uint digests_cnt = hashes_cnt;
11944 uint digests_done = 0;
11945
11946 uint size_digests = digests_cnt * dgst_size;
11947 uint size_shown = digests_cnt * sizeof (uint);
11948
11949 uint *digests_shown = (uint *) mymalloc (size_shown);
11950 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11951
11952 uint salts_cnt = 0;
11953 uint salts_done = 0;
11954
11955 hashinfo_t **hash_info = NULL;
11956
11957 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11958 {
11959 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11960
11961 if (username && (remove || show))
11962 {
11963 uint user_pos;
11964
11965 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11966 {
11967 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11968
11969 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11970 }
11971 }
11972 }
11973
11974 uint *salts_shown = (uint *) mymalloc (size_shown);
11975
11976 salt_t *salt_buf;
11977
11978 {
11979 // copied from inner loop
11980
11981 salt_buf = &salts_buf_new[salts_cnt];
11982
11983 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11984
11985 if (esalt_size)
11986 {
11987 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11988 }
11989
11990 salt_buf->digests_cnt = 0;
11991 salt_buf->digests_done = 0;
11992 salt_buf->digests_offset = 0;
11993
11994 salts_cnt++;
11995 }
11996
11997 if (hashes_buf[0].cracked == 1)
11998 {
11999 digests_shown[0] = 1;
12000
12001 digests_done++;
12002
12003 salt_buf->digests_done++;
12004 }
12005
12006 salt_buf->digests_cnt++;
12007
12008 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12009
12010 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12011 {
12012 hash_info[0] = hashes_buf[0].hash_info;
12013 }
12014
12015 // copy from inner loop
12016
12017 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12018 {
12019 if (isSalted)
12020 {
12021 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12022 {
12023 salt_buf = &salts_buf_new[salts_cnt];
12024
12025 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12026
12027 if (esalt_size)
12028 {
12029 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12030 }
12031
12032 salt_buf->digests_cnt = 0;
12033 salt_buf->digests_done = 0;
12034 salt_buf->digests_offset = hashes_pos;
12035
12036 salts_cnt++;
12037 }
12038 }
12039
12040 if (hashes_buf[hashes_pos].cracked == 1)
12041 {
12042 digests_shown[hashes_pos] = 1;
12043
12044 digests_done++;
12045
12046 salt_buf->digests_done++;
12047 }
12048
12049 salt_buf->digests_cnt++;
12050
12051 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12052
12053 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12054 {
12055 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12056 }
12057 }
12058
12059 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12060 {
12061 salt_t *salt_buf = &salts_buf_new[salt_pos];
12062
12063 if (salt_buf->digests_done == salt_buf->digests_cnt)
12064 {
12065 salts_shown[salt_pos] = 1;
12066
12067 salts_done++;
12068 }
12069
12070 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12071 }
12072
12073 local_free (digests_buf);
12074 local_free (salts_buf);
12075 local_free (esalts_buf);
12076
12077 digests_buf = digests_buf_new;
12078 salts_buf = salts_buf_new;
12079 esalts_buf = esalts_buf_new;
12080
12081 local_free (hashes_buf);
12082
12083 /**
12084 * special modification not set from parser
12085 */
12086
12087 switch (hash_mode)
12088 {
12089 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12090 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12091 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12092 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12093 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12094 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12095 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12096 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12097 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12098 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12099 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12100 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12101 }
12102
12103 if (truecrypt_keyfiles)
12104 {
12105 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12106
12107 char *keyfiles = strdup (truecrypt_keyfiles);
12108
12109 char *keyfile = strtok (keyfiles, ",");
12110
12111 do
12112 {
12113 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12114
12115 } while ((keyfile = strtok (NULL, ",")) != NULL);
12116
12117 free (keyfiles);
12118 }
12119
12120 data.digests_cnt = digests_cnt;
12121 data.digests_done = digests_done;
12122 data.digests_buf = digests_buf;
12123 data.digests_shown = digests_shown;
12124 data.digests_shown_tmp = digests_shown_tmp;
12125
12126 data.salts_cnt = salts_cnt;
12127 data.salts_done = salts_done;
12128 data.salts_buf = salts_buf;
12129 data.salts_shown = salts_shown;
12130
12131 data.esalts_buf = esalts_buf;
12132 data.hash_info = hash_info;
12133
12134 /**
12135 * Automatic Optimizers
12136 */
12137
12138 if (salts_cnt == 1)
12139 opti_type |= OPTI_TYPE_SINGLE_SALT;
12140
12141 if (digests_cnt == 1)
12142 opti_type |= OPTI_TYPE_SINGLE_HASH;
12143
12144 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12145 opti_type |= OPTI_TYPE_NOT_ITERATED;
12146
12147 if (attack_mode == ATTACK_MODE_BF)
12148 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12149
12150 data.opti_type = opti_type;
12151
12152 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12153 {
12154 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12155 {
12156 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12157 {
12158 if (opts_type & OPTS_TYPE_ST_ADD80)
12159 {
12160 opts_type &= ~OPTS_TYPE_ST_ADD80;
12161 opts_type |= OPTS_TYPE_PT_ADD80;
12162 }
12163
12164 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12165 {
12166 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12167 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12168 }
12169
12170 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12171 {
12172 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12173 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12174 }
12175 }
12176 }
12177 }
12178
12179 /**
12180 * Some algorithm, like descrypt, can benefit from JIT compilation
12181 */
12182
12183 int force_jit_compilation = -1;
12184
12185 if (hash_mode == 8900)
12186 {
12187 force_jit_compilation = 8900;
12188 }
12189 else if (hash_mode == 9300)
12190 {
12191 force_jit_compilation = 8900;
12192 }
12193 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12194 {
12195 force_jit_compilation = 1500;
12196 }
12197
12198 /**
12199 * generate bitmap tables
12200 */
12201
12202 const uint bitmap_shift1 = 5;
12203 const uint bitmap_shift2 = 13;
12204
12205 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12206
12207 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12208 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12209 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12210 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12211 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12212 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12213 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12214 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12215
12216 uint bitmap_bits;
12217 uint bitmap_nums;
12218 uint bitmap_mask;
12219 uint bitmap_size;
12220
12221 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12222 {
12223 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12224
12225 bitmap_nums = 1 << bitmap_bits;
12226
12227 bitmap_mask = bitmap_nums - 1;
12228
12229 bitmap_size = bitmap_nums * sizeof (uint);
12230
12231 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12232
12233 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;
12234 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;
12235
12236 break;
12237 }
12238
12239 bitmap_nums = 1 << bitmap_bits;
12240
12241 bitmap_mask = bitmap_nums - 1;
12242
12243 bitmap_size = bitmap_nums * sizeof (uint);
12244
12245 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);
12246 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);
12247
12248 /**
12249 * prepare quick rule
12250 */
12251
12252 data.rule_buf_l = rule_buf_l;
12253 data.rule_buf_r = rule_buf_r;
12254
12255 int rule_len_l = (int) strlen (rule_buf_l);
12256 int rule_len_r = (int) strlen (rule_buf_r);
12257
12258 data.rule_len_l = rule_len_l;
12259 data.rule_len_r = rule_len_r;
12260
12261 /**
12262 * load rules
12263 */
12264
12265 uint *all_kernel_rules_cnt = NULL;
12266
12267 kernel_rule_t **all_kernel_rules_buf = NULL;
12268
12269 if (rp_files_cnt)
12270 {
12271 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12272
12273 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12274 }
12275
12276 char rule_buf[BUFSIZ];
12277
12278 int rule_len = 0;
12279
12280 for (uint i = 0; i < rp_files_cnt; i++)
12281 {
12282 uint kernel_rules_avail = 0;
12283
12284 uint kernel_rules_cnt = 0;
12285
12286 kernel_rule_t *kernel_rules_buf = NULL;
12287
12288 char *rp_file = rp_files[i];
12289
12290 char in[BLOCK_SIZE];
12291 char out[BLOCK_SIZE];
12292
12293 FILE *fp = NULL;
12294
12295 uint rule_line = 0;
12296
12297 if ((fp = fopen (rp_file, "rb")) == NULL)
12298 {
12299 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12300
12301 return (-1);
12302 }
12303
12304 while (!feof (fp))
12305 {
12306 memset (rule_buf, 0, BUFSIZ);
12307
12308 rule_len = fgetl (fp, rule_buf);
12309
12310 rule_line++;
12311
12312 if (rule_len == 0) continue;
12313
12314 if (rule_buf[0] == '#') continue;
12315
12316 if (kernel_rules_avail == kernel_rules_cnt)
12317 {
12318 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12319
12320 kernel_rules_avail += INCR_RULES;
12321 }
12322
12323 memset (in, 0, BLOCK_SIZE);
12324 memset (out, 0, BLOCK_SIZE);
12325
12326 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12327
12328 if (result == -1)
12329 {
12330 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12331
12332 continue;
12333 }
12334
12335 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12336 {
12337 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12338
12339 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12340
12341 continue;
12342 }
12343
12344 /* its so slow
12345 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12346 {
12347 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12348
12349 continue;
12350 }
12351 */
12352
12353 kernel_rules_cnt++;
12354 }
12355
12356 fclose (fp);
12357
12358 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12359
12360 all_kernel_rules_buf[i] = kernel_rules_buf;
12361 }
12362
12363 /**
12364 * merge rules or automatic rule generator
12365 */
12366
12367 uint kernel_rules_cnt = 0;
12368
12369 kernel_rule_t *kernel_rules_buf = NULL;
12370
12371 if (attack_mode == ATTACK_MODE_STRAIGHT)
12372 {
12373 if (rp_files_cnt)
12374 {
12375 kernel_rules_cnt = 1;
12376
12377 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12378
12379 repeats[0] = kernel_rules_cnt;
12380
12381 for (uint i = 0; i < rp_files_cnt; i++)
12382 {
12383 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12384
12385 repeats[i + 1] = kernel_rules_cnt;
12386 }
12387
12388 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12389
12390 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12391
12392 for (uint i = 0; i < kernel_rules_cnt; i++)
12393 {
12394 uint out_pos = 0;
12395
12396 kernel_rule_t *out = &kernel_rules_buf[i];
12397
12398 for (uint j = 0; j < rp_files_cnt; j++)
12399 {
12400 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12401 uint in_pos;
12402
12403 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12404
12405 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12406 {
12407 if (out_pos == RULES_MAX - 1)
12408 {
12409 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12410
12411 break;
12412 }
12413
12414 out->cmds[out_pos] = in->cmds[in_pos];
12415 }
12416 }
12417 }
12418
12419 local_free (repeats);
12420 }
12421 else if (rp_gen)
12422 {
12423 uint kernel_rules_avail = 0;
12424
12425 while (kernel_rules_cnt < rp_gen)
12426 {
12427 if (kernel_rules_avail == kernel_rules_cnt)
12428 {
12429 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12430
12431 kernel_rules_avail += INCR_RULES;
12432 }
12433
12434 memset (rule_buf, 0, BLOCK_SIZE);
12435
12436 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12437
12438 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12439
12440 kernel_rules_cnt++;
12441 }
12442 }
12443 }
12444
12445 /**
12446 * generate NOP rules
12447 */
12448
12449 if (kernel_rules_cnt == 0)
12450 {
12451 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12452
12453 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12454
12455 kernel_rules_cnt++;
12456 }
12457
12458 data.kernel_rules_cnt = kernel_rules_cnt;
12459 data.kernel_rules_buf = kernel_rules_buf;
12460
12461 /**
12462 * OpenCL platforms: detect
12463 */
12464
12465 cl_platform_id platforms[CL_PLATFORMS_MAX];
12466
12467 cl_uint platforms_cnt = 0;
12468
12469 cl_device_id platform_devices[DEVICES_MAX];
12470
12471 cl_uint platform_devices_cnt;
12472
12473 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12474
12475 if (platforms_cnt == 0)
12476 {
12477 log_error ("ERROR: No OpenCL compatible platform found");
12478
12479 return (-1);
12480 }
12481
12482 /**
12483 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12484 */
12485
12486 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12487 {
12488 cl_platform_id platform = platforms[platform_id];
12489
12490 char platform_vendor[INFOSZ] = { 0 };
12491
12492 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12493
12494 #ifdef HAVE_HWMON
12495 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12496 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12497 {
12498 // make sure that we do not directly control the fan for NVidia
12499
12500 gpu_temp_retain = 0;
12501
12502 data.gpu_temp_retain = gpu_temp_retain;
12503 }
12504 #endif // HAVE_NVML || HAVE_NVAPI
12505 #endif
12506 }
12507
12508 /**
12509 * OpenCL devices: simply push all devices from all platforms into the same device array
12510 */
12511
12512 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12513
12514 data.devices_param = devices_param;
12515
12516 uint devices_cnt = 0;
12517
12518 uint devices_active = 0;
12519
12520 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12521 {
12522 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12523
12524 cl_platform_id platform = platforms[platform_id];
12525
12526 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12527
12528 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12529 {
12530 const uint device_id = devices_cnt;
12531
12532 hc_device_param_t *device_param = &data.devices_param[device_id];
12533
12534 device_param->device = platform_devices[platform_devices_id];
12535
12536 device_param->device_id = device_id;
12537
12538 device_param->platform_devices_id = platform_devices_id;
12539
12540 // vendor_id
12541
12542 cl_uint vendor_id = 0;
12543
12544 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12545
12546 device_param->vendor_id = vendor_id;
12547
12548 // device_type
12549
12550 cl_device_type device_type;
12551
12552 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12553
12554 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12555
12556 device_param->device_type = device_type;
12557
12558 // device_name
12559
12560 char *device_name = (char *) mymalloc (INFOSZ);
12561
12562 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12563
12564 device_param->device_name = device_name;
12565
12566 // device_version
12567
12568 char *device_version = (char *) mymalloc (INFOSZ);
12569
12570 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12571
12572 device_param->device_version = device_version;
12573
12574 if (strstr (device_version, "pocl"))
12575 {
12576 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12577 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12578
12579 cl_uint vendor_id = 0xffff;
12580
12581 device_param->vendor_id = vendor_id;
12582 }
12583
12584 // max_compute_units
12585
12586 cl_uint vector_width;
12587
12588 if (1) // can be removed as soon as all kernel are migrated; if (attack_mode == ATTACK_MODE_BF)
12589 {
12590 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12591 {
12592 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12593 }
12594 else
12595 {
12596 vector_width = opencl_vector_width;
12597 }
12598 }
12599 else
12600 {
12601 vector_width = 1;
12602 }
12603
12604 if (vector_width > 8) vector_width = 8;
12605
12606 device_param->vector_width = vector_width;
12607
12608 // max_compute_units
12609
12610 cl_uint device_processors;
12611
12612 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12613
12614 device_param->device_processors = device_processors;
12615
12616 // max_mem_alloc_size
12617
12618 cl_ulong device_maxmem_alloc;
12619
12620 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12621
12622 device_param->device_maxmem_alloc = device_maxmem_alloc;
12623
12624 // max_mem_alloc_size
12625
12626 cl_ulong device_global_mem;
12627
12628 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12629
12630 device_param->device_global_mem = device_global_mem;
12631
12632 // max_clock_frequency
12633
12634 cl_uint device_maxclock_frequency;
12635
12636 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12637
12638 device_param->device_maxclock_frequency = device_maxclock_frequency;
12639
12640 // skipped
12641
12642 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12643 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12644
12645 device_param->skipped = (skipped1 || skipped2);
12646
12647 // driver_version
12648
12649 char *driver_version = (char *) mymalloc (INFOSZ);
12650
12651 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12652
12653 device_param->driver_version = driver_version;
12654
12655 // device_name_chksum
12656
12657 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12658
12659 #if __x86_64__
12660 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);
12661 #else
12662 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);
12663 #endif
12664
12665 uint device_name_digest[4];
12666
12667 device_name_digest[0] = 0;
12668 device_name_digest[1] = 0;
12669 device_name_digest[2] = 0;
12670 device_name_digest[3] = 0;
12671
12672 md5_64 ((uint *) device_name_chksum, device_name_digest);
12673
12674 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12675
12676 device_param->device_name_chksum = device_name_chksum;
12677
12678 // device_processor_cores
12679
12680 if (device_type & CL_DEVICE_TYPE_CPU)
12681 {
12682 cl_uint device_processor_cores = 1;
12683
12684 device_param->device_processor_cores = device_processor_cores;
12685 }
12686
12687 if (device_type & CL_DEVICE_TYPE_GPU)
12688 {
12689 if (vendor_id == VENDOR_ID_AMD)
12690 {
12691 cl_uint device_processor_cores = 0;
12692
12693 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12694
12695 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12696
12697 device_param->device_processor_cores = device_processor_cores;
12698 }
12699 else if (vendor_id == VENDOR_ID_NV)
12700 {
12701 cl_uint kernel_exec_timeout = 0;
12702
12703 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12704
12705 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12706
12707 device_param->kernel_exec_timeout = kernel_exec_timeout;
12708
12709 cl_uint device_processor_cores = 0;
12710
12711 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12712
12713 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12714
12715 device_param->device_processor_cores = device_processor_cores;
12716
12717 cl_uint sm_minor = 0;
12718 cl_uint sm_major = 0;
12719
12720 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12721 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12722
12723 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12724 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12725
12726 device_param->sm_minor = sm_minor;
12727 device_param->sm_major = sm_major;
12728 }
12729 else
12730 {
12731 cl_uint device_processor_cores = 1;
12732
12733 device_param->device_processor_cores = device_processor_cores;
12734 }
12735 }
12736
12737 // display results
12738
12739 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12740 {
12741 if (device_param->skipped == 0)
12742 {
12743 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12744 device_id + 1,
12745 device_name,
12746 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12747 (unsigned int) (device_global_mem / 1024 / 1024),
12748 (unsigned int) (device_maxclock_frequency),
12749 (unsigned int) device_processors);
12750 }
12751 else
12752 {
12753 log_info ("Device #%u: %s, skipped",
12754 device_id + 1,
12755 device_name);
12756 }
12757 }
12758
12759 // common driver check
12760
12761 if (device_param->skipped == 0)
12762 {
12763 if (strstr (device_version, "pocl"))
12764 {
12765 if (force == 0)
12766 {
12767 log_info ("");
12768 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12769 log_info ("You are STRONGLY encouraged not to use it");
12770 log_info ("You can use --force to override this but do not post error reports if you do so");
12771 log_info ("");
12772
12773 return (-1);
12774 }
12775 }
12776
12777 if (device_type & CL_DEVICE_TYPE_GPU)
12778 {
12779 if (vendor_id == VENDOR_ID_NV)
12780 {
12781 if (device_param->kernel_exec_timeout != 0)
12782 {
12783 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);
12784 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12785 }
12786 }
12787 else if (vendor_id == VENDOR_ID_AMD)
12788 {
12789 int catalyst_check = (force == 1) ? 0 : 1;
12790
12791 int catalyst_warn = 0;
12792
12793 int catalyst_broken = 0;
12794
12795 if (catalyst_check == 1)
12796 {
12797 catalyst_warn = 1;
12798
12799 // v14.9 and higher
12800 if (atoi (device_param->driver_version) >= 1573)
12801 {
12802 catalyst_warn = 0;
12803 }
12804
12805 catalyst_check = 0;
12806 }
12807
12808 if (catalyst_broken == 1)
12809 {
12810 log_info ("");
12811 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12812 log_info ("It will pass over cracked hashes and does not report them as cracked");
12813 log_info ("You are STRONGLY encouraged not to use it");
12814 log_info ("You can use --force to override this but do not post error reports if you do so");
12815 log_info ("");
12816
12817 return (-1);
12818 }
12819
12820 if (catalyst_warn == 1)
12821 {
12822 log_info ("");
12823 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12824 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12825 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12826 #ifdef _WIN
12827 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12828 #endif
12829 log_info ("You can use --force to override this but do not post error reports if you do so");
12830 log_info ("");
12831
12832 return (-1);
12833 }
12834 }
12835 }
12836
12837 devices_active++;
12838 }
12839
12840 // next please
12841
12842 devices_cnt++;
12843 }
12844 }
12845
12846 if (devices_active == 0)
12847 {
12848 log_error ("ERROR: No devices found/left");
12849
12850 return (-1);
12851 }
12852
12853 data.devices_cnt = devices_cnt;
12854
12855 data.devices_active = devices_active;
12856
12857 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12858 {
12859 log_info ("");
12860 }
12861
12862 /**
12863 * OpenCL devices: allocate buffer for device specific information
12864 */
12865
12866 #ifdef HAVE_HWMON
12867 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12868
12869 #ifdef HAVE_ADL
12870 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12871
12872 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12873 #endif // ADL
12874 #endif
12875
12876 /**
12877 * enable custom signal handler(s)
12878 */
12879
12880 if (benchmark == 0)
12881 {
12882 hc_signal (sigHandler_default);
12883 }
12884 else
12885 {
12886 hc_signal (sigHandler_benchmark);
12887 }
12888
12889 /**
12890 * User-defined GPU temp handling
12891 */
12892
12893 #ifdef HAVE_HWMON
12894 if (gpu_temp_disable == 1)
12895 {
12896 gpu_temp_abort = 0;
12897 gpu_temp_retain = 0;
12898 }
12899
12900 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12901 {
12902 if (gpu_temp_abort < gpu_temp_retain)
12903 {
12904 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12905
12906 return (-1);
12907 }
12908 }
12909
12910 data.gpu_temp_disable = gpu_temp_disable;
12911 data.gpu_temp_abort = gpu_temp_abort;
12912 data.gpu_temp_retain = gpu_temp_retain;
12913 #endif
12914
12915 /**
12916 * inform the user
12917 */
12918
12919 if (data.quiet == 0)
12920 {
12921 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12922
12923 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);
12924
12925 if (attack_mode == ATTACK_MODE_STRAIGHT)
12926 {
12927 log_info ("Rules: %u", kernel_rules_cnt);
12928 }
12929
12930 if (opti_type)
12931 {
12932 log_info ("Applicable Optimizers:");
12933
12934 for (uint i = 0; i < 32; i++)
12935 {
12936 const uint opti_bit = 1u << i;
12937
12938 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12939 }
12940 }
12941
12942 /**
12943 * Watchdog and Temperature balance
12944 */
12945
12946 #ifdef HAVE_HWMON
12947 if (gpu_temp_abort == 0)
12948 {
12949 log_info ("Watchdog: Temperature abort trigger disabled");
12950 }
12951 else
12952 {
12953 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12954 }
12955
12956 if (gpu_temp_retain == 0)
12957 {
12958 log_info ("Watchdog: Temperature retain trigger disabled");
12959 }
12960 else
12961 {
12962 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12963 }
12964 #endif
12965 }
12966
12967 if (data.quiet == 0) log_info ("");
12968
12969 /**
12970 * HM devices: init
12971 */
12972
12973 #ifdef HAVE_HWMON
12974 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12975 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12976 #endif
12977
12978 #ifdef HAVE_ADL
12979 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12980 #endif
12981
12982 if (gpu_temp_disable == 0)
12983 {
12984 #if defined(WIN) && defined(HAVE_NVAPI)
12985 if (NvAPI_Initialize () == NVAPI_OK)
12986 {
12987 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12988
12989 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12990
12991 int tmp_out = 0;
12992
12993 for (int i = 0; i < tmp_in; i++)
12994 {
12995 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12996 }
12997
12998 for (int i = 0; i < tmp_out; i++)
12999 {
13000 NvU32 speed;
13001
13002 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13003 }
13004 }
13005 #endif // WIN && HAVE_NVAPI
13006
13007 #if defined(LINUX) && defined(HAVE_NVML)
13008 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13009
13010 data.hm_dll_nv = hm_dll_nv;
13011
13012 if (hm_dll_nv)
13013 {
13014 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13015 {
13016 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
13017
13018 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13019
13020 int tmp_out = 0;
13021
13022 for (int i = 0; i < tmp_in; i++)
13023 {
13024 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13025 }
13026
13027 for (int i = 0; i < tmp_out; i++)
13028 {
13029 unsigned int speed;
13030
13031 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;
13032 }
13033 }
13034 }
13035 #endif // LINUX && HAVE_NVML
13036
13037 #ifdef HAVE_ADL
13038 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13039
13040 data.hm_dll_amd = hm_dll_amd;
13041
13042 if (hm_dll_amd)
13043 {
13044 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13045 {
13046 // total number of adapters
13047
13048 int hm_adapters_num;
13049
13050 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13051
13052 // adapter info
13053
13054 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13055
13056 if (lpAdapterInfo == NULL) return (-1);
13057
13058 // get a list (of ids of) valid/usable adapters
13059
13060 int num_adl_adapters = 0;
13061
13062 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13063
13064 if (num_adl_adapters > 0)
13065 {
13066 hc_thread_mutex_lock (mux_adl);
13067
13068 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13069
13070 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13071
13072 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13073 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13074
13075 hc_thread_mutex_unlock (mux_adl);
13076 }
13077
13078 myfree (valid_adl_device_list);
13079 myfree (lpAdapterInfo);
13080 }
13081 }
13082 #endif // HAVE_ADL
13083 }
13084
13085 /**
13086 * HM devices: copy
13087 */
13088
13089 if (gpu_temp_disable == 0)
13090 {
13091 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13092 {
13093 hc_device_param_t *device_param = &data.devices_param[device_id];
13094
13095 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13096
13097 if (device_param->skipped) continue;
13098
13099 const uint platform_devices_id = device_param->platform_devices_id;
13100
13101 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13102 if (device_param->vendor_id == VENDOR_ID_NV)
13103 {
13104 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13105 }
13106 #endif
13107
13108 #ifdef HAVE_ADL
13109 if (device_param->vendor_id == VENDOR_ID_AMD)
13110 {
13111 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13112 }
13113 #endif
13114 }
13115 }
13116
13117 /*
13118 * Temporary fix:
13119 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13120 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13121 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13122 * Driver / ADL bug?
13123 */
13124
13125 #ifdef HAVE_ADL
13126 if (powertune_enable == 1)
13127 {
13128 hc_thread_mutex_lock (mux_adl);
13129
13130 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13131 {
13132 hc_device_param_t *device_param = &data.devices_param[device_id];
13133
13134 if (device_param->skipped) continue;
13135
13136 if (data.hm_device[device_id].od_version == 6)
13137 {
13138 // set powertune value only
13139
13140 int powertune_supported = 0;
13141
13142 int ADL_rc = 0;
13143
13144 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13145 {
13146 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13147
13148 return (-1);
13149 }
13150
13151 if (powertune_supported != 0)
13152 {
13153 // powertune set
13154 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13155
13156 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13157 {
13158 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13159
13160 return (-1);
13161 }
13162
13163 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13164 {
13165 log_error ("ERROR: Failed to set new ADL PowerControl values");
13166
13167 return (-1);
13168 }
13169 }
13170 }
13171 }
13172
13173 hc_thread_mutex_unlock (mux_adl);
13174 }
13175 #endif // HAVE_ADK
13176 #endif // HAVE_HWMON
13177
13178 uint kernel_blocks_all = 0;
13179
13180 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13181 {
13182 /**
13183 * host buffer
13184 */
13185
13186 hc_device_param_t *device_param = &data.devices_param[device_id];
13187
13188 if (device_param->skipped) continue;
13189
13190 /**
13191 * device properties
13192 */
13193
13194 char *device_name_chksum = device_param->device_name_chksum;
13195
13196 uint device_processors = device_param->device_processors;
13197
13198 uint device_processor_cores = device_param->device_processor_cores;
13199
13200 cl_device_type device_type = device_param->device_type;
13201
13202 /**
13203 * create context for each device
13204 */
13205
13206 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13207
13208 /**
13209 * create command-queue
13210 */
13211
13212 // not support with NV
13213 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13214
13215 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13216
13217 /**
13218 * create input buffers on device
13219 */
13220
13221 uint kernel_threads = KERNEL_THREADS;
13222
13223 // bcrypt
13224 if (hash_mode == 3200) kernel_threads = 8;
13225 if (hash_mode == 9000) kernel_threads = 8;
13226
13227 if (device_type & CL_DEVICE_TYPE_CPU)
13228 {
13229 // CPU still need lots of workitems, don't know why...
13230 // for testing phase, lets start with this
13231
13232 // kernel_accel = 1;
13233 }
13234
13235 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13236 uint kernel_blocks = kernel_power;
13237
13238 device_param->kernel_threads = kernel_threads;
13239 device_param->kernel_power_user = kernel_power;
13240 device_param->kernel_blocks_user = kernel_blocks;
13241
13242 kernel_blocks_all += kernel_blocks;
13243
13244 uint size_pws = kernel_power * sizeof (pw_t);
13245
13246 uint size_tmps = 4;
13247
13248 switch (hash_mode)
13249 {
13250 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13251 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13252 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13253 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13254 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13255 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13256 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13257 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13258 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13259 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13260 case 6211:
13261 case 6212:
13262 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13263 case 6221:
13264 case 6222:
13265 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13266 case 6231:
13267 case 6232:
13268 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13269 case 6241:
13270 case 6242:
13271 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13272 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13273 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13274 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13275 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13276 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13277 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13278 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13279 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13280 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13281 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13282 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13283 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13284 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13285 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13286 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13287 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13288 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13289 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13290 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13291 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13292 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13293 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13294 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13295 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13296 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13297 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13298 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13299 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13300 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13301 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13302 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13303 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13304 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13305 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13306 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13307 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13308 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13309 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13310 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13311 };
13312
13313 uint size_hooks = 4;
13314
13315 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13316 {
13317 // insert correct hook size
13318 }
13319
13320 // we can optimize some stuff here...
13321
13322 device_param->size_pws = size_pws;
13323 device_param->size_tmps = size_tmps;
13324 device_param->size_hooks = size_hooks;
13325
13326 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13327 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13328
13329 device_param->size_root_css = size_root_css;
13330 device_param->size_markov_css = size_markov_css;
13331
13332 uint size_results = KERNEL_THREADS * sizeof (uint);
13333
13334 device_param->size_results = size_results;
13335
13336 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13337 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13338
13339 uint size_plains = digests_cnt * sizeof (plain_t);
13340 uint size_salts = salts_cnt * sizeof (salt_t);
13341 uint size_esalts = salts_cnt * esalt_size;
13342
13343 device_param->size_plains = size_plains;
13344 device_param->size_digests = size_digests;
13345 device_param->size_shown = size_shown;
13346 device_param->size_salts = size_salts;
13347
13348 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13349 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13350 uint size_tm = 32 * sizeof (bs_word_t);
13351
13352 u64 size_scryptV = 1;
13353
13354 if ((hash_mode == 8900) || (hash_mode == 9300))
13355 {
13356 uint tmto_start = 0;
13357 uint tmto_stop = 10;
13358
13359 if (scrypt_tmto)
13360 {
13361 tmto_start = scrypt_tmto;
13362 }
13363 else
13364 {
13365 // in case the user did not specify the tmto manually
13366 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13367 // but set the lower end only in case the user has a device with too less memory
13368
13369 if (hash_mode == 8900)
13370 {
13371 if (device_param->vendor_id == VENDOR_ID_AMD)
13372 {
13373 tmto_start = 1;
13374 }
13375 else if (device_param->vendor_id == VENDOR_ID_NV)
13376 {
13377 tmto_start = 3;
13378 }
13379 }
13380 else if (hash_mode == 9300)
13381 {
13382 if (device_param->vendor_id == VENDOR_ID_AMD)
13383 {
13384 tmto_start = 3;
13385 }
13386 else if (device_param->vendor_id == VENDOR_ID_NV)
13387 {
13388 tmto_start = 5;
13389 }
13390 }
13391 }
13392
13393 if (quiet == 0) log_info ("");
13394
13395 uint shader_per_mp = 1;
13396
13397 if (device_param->vendor_id == VENDOR_ID_AMD)
13398 {
13399 shader_per_mp = 8;
13400 }
13401 else if (device_param->vendor_id == VENDOR_ID_NV)
13402 {
13403 shader_per_mp = 32;
13404 }
13405
13406 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13407 {
13408 // TODO: in theory the following calculation needs to be done per salt, not global
13409 // we assume all hashes have the same scrypt settings
13410
13411 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13412
13413 size_scryptV /= 1 << tmto;
13414
13415 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13416
13417 if (size_scryptV > device_param->device_maxmem_alloc)
13418 {
13419 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13420
13421 continue;
13422 }
13423
13424 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13425 {
13426 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13427 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13428 }
13429
13430 break;
13431 }
13432
13433 if (data.salts_buf[0].scrypt_phy == 0)
13434 {
13435 log_error ("ERROR: can't allocate enough device memory");
13436
13437 return -1;
13438 }
13439
13440 if (quiet == 0) log_info ("");
13441 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13442 }
13443
13444 /**
13445 * default building options
13446 */
13447
13448 char build_opts[1024];
13449
13450 // we don't have sm_* on vendors not NV but it doesn't matter
13451
13452 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);
13453
13454 /**
13455 * main kernel
13456 */
13457
13458 {
13459 /**
13460 * kernel source filename
13461 */
13462
13463 char source_file[256] = { 0 };
13464
13465 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13466
13467 struct stat sst;
13468
13469 if (stat (source_file, &sst) == -1)
13470 {
13471 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13472
13473 return -1;
13474 }
13475
13476 /**
13477 * kernel cached filename
13478 */
13479
13480 char cached_file[256] = { 0 };
13481
13482 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13483
13484 int cached = 1;
13485
13486 struct stat cst;
13487
13488 if (stat (cached_file, &cst) == -1)
13489 {
13490 cached = 0;
13491 }
13492
13493 /**
13494 * kernel compile or load
13495 */
13496
13497 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13498
13499 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13500
13501 if (force_jit_compilation == -1)
13502 {
13503 if (cached == 0)
13504 {
13505 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13506
13507 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13508
13509 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13510
13511 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13512
13513 size_t binary_size;
13514
13515 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13516
13517 u8 *binary = (u8 *) mymalloc (binary_size);
13518
13519 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13520
13521 writeProgramBin (cached_file, binary, binary_size);
13522
13523 local_free (binary);
13524 }
13525 else
13526 {
13527 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13528
13529 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13530
13531 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13532
13533 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13534 }
13535 }
13536 else
13537 {
13538 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13539
13540 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13541
13542 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13543
13544 if (force_jit_compilation == 1500)
13545 {
13546 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13547 }
13548 else if (force_jit_compilation == 8900)
13549 {
13550 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);
13551 }
13552
13553 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13554 }
13555
13556 local_free (kernel_lengths);
13557 local_free (kernel_sources[0]);
13558 local_free (kernel_sources);
13559
13560 // this is mostly for debug
13561
13562 size_t ret_val_size = 0;
13563
13564 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13565
13566 if (ret_val_size > 2)
13567 {
13568 char *build_log = (char *) mymalloc (ret_val_size + 1);
13569
13570 memset (build_log, 0, ret_val_size + 1);
13571
13572 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13573
13574 puts (build_log);
13575
13576 myfree (build_log);
13577 }
13578 }
13579
13580 /**
13581 * word generator kernel
13582 */
13583
13584 if (attack_mode != ATTACK_MODE_STRAIGHT)
13585 {
13586 /**
13587 * kernel mp source filename
13588 */
13589
13590 char source_file[256] = { 0 };
13591
13592 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13593
13594 struct stat sst;
13595
13596 if (stat (source_file, &sst) == -1)
13597 {
13598 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13599
13600 return -1;
13601 }
13602
13603 /**
13604 * kernel mp cached filename
13605 */
13606
13607 char cached_file[256] = { 0 };
13608
13609 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13610
13611 int cached = 1;
13612
13613 struct stat cst;
13614
13615 if (stat (cached_file, &cst) == -1)
13616 {
13617 cached = 0;
13618 }
13619
13620 /**
13621 * kernel compile or load
13622 */
13623
13624 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13625
13626 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13627
13628 if (cached == 0)
13629 {
13630 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13631
13632 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13633
13634 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13635
13636 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13637
13638 size_t binary_size;
13639
13640 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13641
13642 u8 *binary = (u8 *) mymalloc (binary_size);
13643
13644 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13645
13646 writeProgramBin (cached_file, binary, binary_size);
13647
13648 local_free (binary);
13649 }
13650 else
13651 {
13652 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13653
13654 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13655
13656 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13657
13658 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13659 }
13660
13661 local_free (kernel_lengths);
13662 local_free (kernel_sources[0]);
13663 local_free (kernel_sources);
13664
13665 // this is mostly for debug
13666
13667 size_t ret_val_size = 0;
13668
13669 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13670
13671 if (ret_val_size > 2)
13672 {
13673 char *build_log = (char *) mymalloc (ret_val_size + 1);
13674
13675 memset (build_log, 0, ret_val_size + 1);
13676
13677 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13678
13679 puts (build_log);
13680
13681 myfree (build_log);
13682 }
13683 }
13684
13685 /**
13686 * amplifier kernel
13687 */
13688
13689 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13690 {
13691
13692 }
13693 else
13694 {
13695 /**
13696 * kernel amp source filename
13697 */
13698
13699 char source_file[256] = { 0 };
13700
13701 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13702
13703 struct stat sst;
13704
13705 if (stat (source_file, &sst) == -1)
13706 {
13707 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13708
13709 return -1;
13710 }
13711
13712 /**
13713 * kernel amp cached filename
13714 */
13715
13716 char cached_file[256] = { 0 };
13717
13718 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13719
13720 int cached = 1;
13721
13722 struct stat cst;
13723
13724 if (stat (cached_file, &cst) == -1)
13725 {
13726 cached = 0;
13727 }
13728
13729 /**
13730 * kernel compile or load
13731 */
13732
13733 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13734
13735 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13736
13737 if (cached == 0)
13738 {
13739 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13740
13741 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13742
13743 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13744
13745 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13746
13747 size_t binary_size;
13748
13749 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13750
13751 u8 *binary = (u8 *) mymalloc (binary_size);
13752
13753 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13754
13755 writeProgramBin (cached_file, binary, binary_size);
13756
13757 local_free (binary);
13758 }
13759 else
13760 {
13761 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13762
13763 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13764
13765 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13766
13767 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13768 }
13769
13770 local_free (kernel_lengths);
13771 local_free (kernel_sources[0]);
13772 local_free (kernel_sources);
13773
13774 // this is mostly for debug
13775
13776 size_t ret_val_size = 0;
13777
13778 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13779
13780 if (ret_val_size > 2)
13781 {
13782 char *build_log = (char *) mymalloc (ret_val_size + 1);
13783
13784 memset (build_log, 0, ret_val_size + 1);
13785
13786 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13787
13788 puts (build_log);
13789
13790 myfree (build_log);
13791 }
13792 }
13793
13794 /**
13795 * global buffers
13796 */
13797
13798 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13799 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13800 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13801 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13802 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13803 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13804 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13805 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13806 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13807 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13808 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13809 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13810 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13811 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13812 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13813 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13814 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13815 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13816
13817 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13818 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13819 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13820 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13821 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13822 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13823 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13824 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13825 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13826 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13827 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13828
13829 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13830 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13831 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13832 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13833 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13834 run_kernel_bzero (device_param, device_param->d_result, size_results);
13835
13836 /**
13837 * special buffers
13838 */
13839
13840 if (attack_kern == ATTACK_KERN_STRAIGHT)
13841 {
13842 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13843 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13844
13845 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13846
13847 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13848 }
13849 else if (attack_kern == ATTACK_KERN_COMBI)
13850 {
13851 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13852 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13853 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13854 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13855
13856 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13857 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13858 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13859 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13860 }
13861 else if (attack_kern == ATTACK_KERN_BF)
13862 {
13863 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13864 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13865 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13866 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13867 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13868
13869 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13870 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13871 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13872 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13873 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13874 }
13875
13876 if (size_esalts)
13877 {
13878 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13879
13880 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13881 }
13882
13883 /**
13884 * main host data
13885 */
13886
13887 uint *result = (uint *) mymalloc (size_results);
13888
13889 memset (result, 0, size_results);
13890
13891 device_param->result = result;
13892
13893 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13894
13895 memset (pws_buf, 0, size_pws);
13896
13897 device_param->pws_buf = pws_buf;
13898
13899 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13900
13901 for (int i = 0; i < 64; i++)
13902 {
13903 pw_caches[i].pw_buf.pw_len = i;
13904 pw_caches[i].cnt = 0;
13905 }
13906
13907 device_param->pw_caches = pw_caches;
13908
13909 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13910
13911 device_param->combs_buf = combs_buf;
13912
13913 void *hooks_buf = mymalloc (size_hooks);
13914
13915 device_param->hooks_buf = hooks_buf;
13916
13917 device_param->pw_transpose = pw_transpose_to_hi1;
13918 device_param->pw_add = pw_add_to_hc1;
13919
13920 /**
13921 * kernel args
13922 */
13923
13924 device_param->kernel_params_buf32[21] = bitmap_mask;
13925 device_param->kernel_params_buf32[22] = bitmap_shift1;
13926 device_param->kernel_params_buf32[23] = bitmap_shift2;
13927 device_param->kernel_params_buf32[24] = 0; // salt_pos
13928 device_param->kernel_params_buf32[25] = 0; // loop_pos
13929 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13930 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13931 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13932 device_param->kernel_params_buf32[29] = 0; // digests_offset
13933 device_param->kernel_params_buf32[30] = 0; // combs_mode
13934 device_param->kernel_params_buf32[31] = 0; // gid_max
13935
13936 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13937 ? &device_param->d_pws_buf
13938 : &device_param->d_pws_amp_buf;
13939 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13940 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13941 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13942 device_param->kernel_params[ 4] = &device_param->d_tmps;
13943 device_param->kernel_params[ 5] = &device_param->d_hooks;
13944 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13945 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13946 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13947 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13948 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13949 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13950 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13951 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13952 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13953 device_param->kernel_params[15] = &device_param->d_digests_buf;
13954 device_param->kernel_params[16] = &device_param->d_digests_shown;
13955 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13956 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13957 device_param->kernel_params[19] = &device_param->d_result;
13958 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13959 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13960 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13961 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13962 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13963 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13964 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13965 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13966 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13967 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13968 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13969 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13970
13971 device_param->kernel_params_mp_buf64[3] = 0;
13972 device_param->kernel_params_mp_buf32[4] = 0;
13973 device_param->kernel_params_mp_buf32[5] = 0;
13974 device_param->kernel_params_mp_buf32[6] = 0;
13975 device_param->kernel_params_mp_buf32[7] = 0;
13976 device_param->kernel_params_mp_buf32[8] = 0;
13977
13978 device_param->kernel_params_mp[0] = NULL;
13979 device_param->kernel_params_mp[1] = NULL;
13980 device_param->kernel_params_mp[2] = NULL;
13981 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13982 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13983 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13984 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13985 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13986 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13987
13988 device_param->kernel_params_mp_l_buf64[3] = 0;
13989 device_param->kernel_params_mp_l_buf32[4] = 0;
13990 device_param->kernel_params_mp_l_buf32[5] = 0;
13991 device_param->kernel_params_mp_l_buf32[6] = 0;
13992 device_param->kernel_params_mp_l_buf32[7] = 0;
13993 device_param->kernel_params_mp_l_buf32[8] = 0;
13994 device_param->kernel_params_mp_l_buf32[9] = 0;
13995
13996 device_param->kernel_params_mp_l[0] = NULL;
13997 device_param->kernel_params_mp_l[1] = NULL;
13998 device_param->kernel_params_mp_l[2] = NULL;
13999 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
14000 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14001 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14002 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14003 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14004 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14005 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14006
14007 device_param->kernel_params_mp_r_buf64[3] = 0;
14008 device_param->kernel_params_mp_r_buf32[4] = 0;
14009 device_param->kernel_params_mp_r_buf32[5] = 0;
14010 device_param->kernel_params_mp_r_buf32[6] = 0;
14011 device_param->kernel_params_mp_r_buf32[7] = 0;
14012 device_param->kernel_params_mp_r_buf32[8] = 0;
14013
14014 device_param->kernel_params_mp_r[0] = NULL;
14015 device_param->kernel_params_mp_r[1] = NULL;
14016 device_param->kernel_params_mp_r[2] = NULL;
14017 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14018 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14019 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14020 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14021 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14022 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14023
14024 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14025 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14026
14027 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14028 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14029 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14030 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14031 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14032 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14033 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14034
14035 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14036
14037 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14038 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14039
14040 /**
14041 * kernel name
14042 */
14043
14044 char kernel_name[64] = { 0 };
14045
14046 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14047 {
14048 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14049 {
14050 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14051
14052 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14053
14054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14055
14056 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14057
14058 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14059
14060 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14061 }
14062 else
14063 {
14064 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14065
14066 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14067
14068 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14069
14070 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14071
14072 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14073
14074 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14075 }
14076
14077 if (data.attack_mode == ATTACK_MODE_BF)
14078 {
14079 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14080 {
14081 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14082
14083 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14084
14085 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14086
14087 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14088 }
14089 }
14090 }
14091 else
14092 {
14093 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14094
14095 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14096
14097 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14098
14099 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14100
14101 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14102
14103 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14104
14105 if (opts_type & OPTS_TYPE_HOOK12)
14106 {
14107 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14108
14109 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14110 }
14111
14112 if (opts_type & OPTS_TYPE_HOOK23)
14113 {
14114 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14115
14116 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14117 }
14118 }
14119
14120 for (uint i = 0; i <= 20; i++)
14121 {
14122 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14123 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14124 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14125
14126 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14127 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14128 }
14129
14130 for (uint i = 21; i <= 31; i++)
14131 {
14132 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14133 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14134 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14135
14136 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14137 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14138 }
14139
14140 if (attack_mode == ATTACK_MODE_BF)
14141 {
14142 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14143 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14144
14145 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14146 {
14147 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14148
14149 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14150 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14151 }
14152 }
14153 else if (attack_mode == ATTACK_MODE_HYBRID1)
14154 {
14155 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14156 }
14157 else if (attack_mode == ATTACK_MODE_HYBRID2)
14158 {
14159 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14160 }
14161
14162 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14163 {
14164 // nothing to do
14165 }
14166 else
14167 {
14168 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14169 }
14170
14171 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14172 {
14173 // nothing to do
14174 }
14175 else
14176 {
14177 for (uint i = 0; i < 5; i++)
14178 {
14179 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14180 }
14181
14182 for (uint i = 5; i < 7; i++)
14183 {
14184 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14185 }
14186 }
14187
14188 /**
14189 * Store initial fanspeed if gpu_temp_retain is enabled
14190 */
14191
14192 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14193 int gpu_temp_retain_set = 0;
14194
14195 if (gpu_temp_disable == 0)
14196 {
14197 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14198 {
14199 hc_thread_mutex_lock (mux_adl);
14200
14201 if (data.hm_device[device_id].fan_supported == 1)
14202 {
14203 if (gpu_temp_retain_chgd == 0)
14204 {
14205 uint cur_temp = 0;
14206 uint default_temp = 0;
14207
14208 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);
14209
14210 if (ADL_rc == ADL_OK)
14211 {
14212 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14213
14214 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14215
14216 // special case with multi gpu setups: always use minimum retain
14217
14218 if (gpu_temp_retain_set == 0)
14219 {
14220 gpu_temp_retain = gpu_temp_retain_target;
14221 gpu_temp_retain_set = 1;
14222 }
14223 else
14224 {
14225 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14226 }
14227
14228 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14229 }
14230 }
14231
14232 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14233
14234 temp_retain_fanspeed_value[device_id] = fan_speed;
14235
14236 if (fan_speed == -1)
14237 {
14238 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14239
14240 temp_retain_fanspeed_value[device_id] = 0;
14241 }
14242 }
14243
14244 hc_thread_mutex_unlock (mux_adl);
14245 }
14246 }
14247
14248 /**
14249 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14250 */
14251
14252 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14253 {
14254 hc_thread_mutex_lock (mux_adl);
14255
14256 if (data.hm_device[device_id].od_version == 6)
14257 {
14258 int ADL_rc;
14259
14260 // check powertune capabilities first, if not available then skip device
14261
14262 int powertune_supported = 0;
14263
14264 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14265 {
14266 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14267
14268 return (-1);
14269 }
14270
14271 if (powertune_supported != 0)
14272 {
14273 // powercontrol settings
14274
14275 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14276
14277 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14278 {
14279 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]);
14280 }
14281
14282 if (ADL_rc != ADL_OK)
14283 {
14284 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14285
14286 return (-1);
14287 }
14288
14289 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14290 {
14291 log_error ("ERROR: Failed to set new ADL PowerControl values");
14292
14293 return (-1);
14294 }
14295
14296 // clocks
14297
14298 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14299
14300 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14301
14302 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)
14303 {
14304 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14305
14306 return (-1);
14307 }
14308
14309 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14310
14311 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14312
14313 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14314 {
14315 log_error ("ERROR: Failed to get ADL device capabilities");
14316
14317 return (-1);
14318 }
14319
14320 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14321 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14322
14323 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14324 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14325
14326 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14327 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14328
14329 // warning if profile has too low max values
14330
14331 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14332 {
14333 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14334 }
14335
14336 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14337 {
14338 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14339 }
14340
14341 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14342
14343 performance_state->iNumberOfPerformanceLevels = 2;
14344
14345 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14346 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14347 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14348 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14349
14350 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)
14351 {
14352 log_info ("ERROR: Failed to set ADL performance state");
14353
14354 return (-1);
14355 }
14356
14357 local_free (performance_state);
14358 }
14359 }
14360
14361 hc_thread_mutex_unlock (mux_adl);
14362 }
14363 #endif // HAVE_HWMON && HAVE_ADL
14364 }
14365
14366 data.kernel_blocks_all = kernel_blocks_all;
14367
14368 if (data.quiet == 0) log_info ("");
14369
14370 /**
14371 * Inform user which algorithm is checked and at which workload setting
14372 */
14373
14374 if (benchmark == 1)
14375 {
14376 quiet = 0;
14377
14378 data.quiet = quiet;
14379
14380 char *hash_type = strhashtype (data.hash_mode); // not a bug
14381
14382 log_info ("Hashtype: %s", hash_type);
14383 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14384 log_info ("");
14385 }
14386
14387 /**
14388 * keep track of the progress
14389 */
14390
14391 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14392 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14393 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14394
14395 /**
14396 * open filehandles
14397 */
14398
14399 #if _WIN
14400 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14401 {
14402 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14403
14404 return (-1);
14405 }
14406
14407 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14408 {
14409 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14410
14411 return (-1);
14412 }
14413
14414 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14415 {
14416 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14417
14418 return (-1);
14419 }
14420 #endif
14421
14422 /**
14423 * dictionary pad
14424 */
14425
14426 segment_size *= (1024 * 1024);
14427
14428 data.segment_size = segment_size;
14429
14430 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14431
14432 wl_data->buf = (char *) mymalloc (segment_size);
14433 wl_data->avail = segment_size;
14434 wl_data->incr = segment_size;
14435 wl_data->cnt = 0;
14436 wl_data->pos = 0;
14437
14438 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14439
14440 data.wordlist_mode = wordlist_mode;
14441
14442 cs_t *css_buf = NULL;
14443 uint css_cnt = 0;
14444 uint dictcnt = 0;
14445 uint maskcnt = 1;
14446 char **masks = NULL;
14447 char **dictfiles = NULL;
14448
14449 uint mask_from_file = 0;
14450
14451 if (attack_mode == ATTACK_MODE_STRAIGHT)
14452 {
14453 if (wordlist_mode == WL_MODE_FILE)
14454 {
14455 int wls_left = myargc - (optind + 1);
14456
14457 for (int i = 0; i < wls_left; i++)
14458 {
14459 char *l0_filename = myargv[optind + 1 + i];
14460
14461 struct stat l0_stat;
14462
14463 if (stat (l0_filename, &l0_stat) == -1)
14464 {
14465 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14466
14467 return (-1);
14468 }
14469
14470 uint is_dir = S_ISDIR (l0_stat.st_mode);
14471
14472 if (is_dir == 0)
14473 {
14474 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14475
14476 dictcnt++;
14477
14478 dictfiles[dictcnt - 1] = l0_filename;
14479 }
14480 else
14481 {
14482 // do not allow --keyspace w/ a directory
14483
14484 if (keyspace == 1)
14485 {
14486 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14487
14488 return (-1);
14489 }
14490
14491 char **dictionary_files = NULL;
14492
14493 dictionary_files = scan_directory (l0_filename);
14494
14495 if (dictionary_files != NULL)
14496 {
14497 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14498
14499 for (int d = 0; dictionary_files[d] != NULL; d++)
14500 {
14501 char *l1_filename = dictionary_files[d];
14502
14503 struct stat l1_stat;
14504
14505 if (stat (l1_filename, &l1_stat) == -1)
14506 {
14507 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14508
14509 return (-1);
14510 }
14511
14512 if (S_ISREG (l1_stat.st_mode))
14513 {
14514 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14515
14516 dictcnt++;
14517
14518 dictfiles[dictcnt - 1] = strdup (l1_filename);
14519 }
14520 }
14521 }
14522
14523 local_free (dictionary_files);
14524 }
14525 }
14526
14527 if (dictcnt < 1)
14528 {
14529 log_error ("ERROR: No usable dictionary file found.");
14530
14531 return (-1);
14532 }
14533 }
14534 else if (wordlist_mode == WL_MODE_STDIN)
14535 {
14536 dictcnt = 1;
14537 }
14538 }
14539 else if (attack_mode == ATTACK_MODE_COMBI)
14540 {
14541 // display
14542
14543 char *dictfile1 = myargv[optind + 1 + 0];
14544 char *dictfile2 = myargv[optind + 1 + 1];
14545
14546 // find the bigger dictionary and use as base
14547
14548 FILE *fp1;
14549 FILE *fp2;
14550
14551 struct stat tmp_stat;
14552
14553 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14554 {
14555 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14556
14557 return (-1);
14558 }
14559
14560 if (stat (dictfile1, &tmp_stat) == -1)
14561 {
14562 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14563
14564 fclose (fp1);
14565
14566 return (-1);
14567 }
14568
14569 if (S_ISDIR (tmp_stat.st_mode))
14570 {
14571 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14572
14573 fclose (fp1);
14574
14575 return (-1);
14576 }
14577
14578 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14579 {
14580 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14581
14582 fclose (fp1);
14583
14584 return (-1);
14585 }
14586
14587 if (stat (dictfile2, &tmp_stat) == -1)
14588 {
14589 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14590
14591 fclose (fp1);
14592 fclose (fp2);
14593
14594 return (-1);
14595 }
14596
14597 if (S_ISDIR (tmp_stat.st_mode))
14598 {
14599 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14600
14601 fclose (fp1);
14602 fclose (fp2);
14603
14604 return (-1);
14605 }
14606
14607 data.combs_cnt = 1;
14608
14609 data.quiet = 1;
14610
14611 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14612
14613 data.quiet = quiet;
14614
14615 if (words1_cnt == 0)
14616 {
14617 log_error ("ERROR: %s: empty file", dictfile1);
14618
14619 fclose (fp1);
14620 fclose (fp2);
14621
14622 return (-1);
14623 }
14624
14625 data.combs_cnt = 1;
14626
14627 data.quiet = 1;
14628
14629 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14630
14631 data.quiet = quiet;
14632
14633 if (words2_cnt == 0)
14634 {
14635 log_error ("ERROR: %s: empty file", dictfile2);
14636
14637 fclose (fp1);
14638 fclose (fp2);
14639
14640 return (-1);
14641 }
14642
14643 fclose (fp1);
14644 fclose (fp2);
14645
14646 data.dictfile = dictfile1;
14647 data.dictfile2 = dictfile2;
14648
14649 if (words1_cnt >= words2_cnt)
14650 {
14651 data.combs_cnt = words2_cnt;
14652 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14653
14654 dictfiles = &data.dictfile;
14655
14656 dictcnt = 1;
14657 }
14658 else
14659 {
14660 data.combs_cnt = words1_cnt;
14661 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14662
14663 dictfiles = &data.dictfile2;
14664
14665 dictcnt = 1;
14666
14667 // we also have to switch wordlist related rules!
14668
14669 char *tmpc = data.rule_buf_l;
14670
14671 data.rule_buf_l = data.rule_buf_r;
14672 data.rule_buf_r = tmpc;
14673
14674 int tmpi = data.rule_len_l;
14675
14676 data.rule_len_l = data.rule_len_r;
14677 data.rule_len_r = tmpi;
14678 }
14679 }
14680 else if (attack_mode == ATTACK_MODE_BF)
14681 {
14682 char *mask = NULL;
14683
14684 maskcnt = 0;
14685
14686 if (benchmark == 0)
14687 {
14688 mask = myargv[optind + 1];
14689
14690 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14691
14692 if ((optind + 2) <= myargc)
14693 {
14694 struct stat file_stat;
14695
14696 if (stat (mask, &file_stat) == -1)
14697 {
14698 maskcnt = 1;
14699
14700 masks[maskcnt - 1] = mystrdup (mask);
14701 }
14702 else
14703 {
14704 int wls_left = myargc - (optind + 1);
14705
14706 uint masks_avail = INCR_MASKS;
14707
14708 for (int i = 0; i < wls_left; i++)
14709 {
14710 if (i != 0)
14711 {
14712 mask = myargv[optind + 1 + i];
14713
14714 if (stat (mask, &file_stat) == -1)
14715 {
14716 log_error ("ERROR: %s: %s", mask, strerror (errno));
14717
14718 return (-1);
14719 }
14720 }
14721
14722 uint is_file = S_ISREG (file_stat.st_mode);
14723
14724 if (is_file == 1)
14725 {
14726 FILE *mask_fp;
14727
14728 if ((mask_fp = fopen (mask, "r")) == NULL)
14729 {
14730 log_error ("ERROR: %s: %s", mask, strerror (errno));
14731
14732 return (-1);
14733 }
14734
14735 char line_buf[BUFSIZ];
14736
14737 while (!feof (mask_fp))
14738 {
14739 memset (line_buf, 0, BUFSIZ);
14740
14741 int line_len = fgetl (mask_fp, line_buf);
14742
14743 if (line_len == 0) continue;
14744
14745 if (line_buf[0] == '#') continue;
14746
14747 if (masks_avail == maskcnt)
14748 {
14749 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14750
14751 masks_avail += INCR_MASKS;
14752 }
14753
14754 masks[maskcnt] = mystrdup (line_buf);
14755
14756 maskcnt++;
14757 }
14758
14759 fclose (mask_fp);
14760 }
14761 else
14762 {
14763 log_error ("ERROR: %s: unsupported file-type", mask);
14764
14765 return (-1);
14766 }
14767 }
14768
14769 mask_from_file = 1;
14770 }
14771 }
14772 else
14773 {
14774 custom_charset_1 = (char *) "?l?d?u";
14775 custom_charset_2 = (char *) "?l?d";
14776 custom_charset_3 = (char *) "?l?d*!$@_";
14777
14778 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14779 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14780 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14781
14782 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14783
14784 wordlist_mode = WL_MODE_MASK;
14785
14786 data.wordlist_mode = wordlist_mode;
14787
14788 increment = 1;
14789
14790 maskcnt = 1;
14791 }
14792 }
14793 else
14794 {
14795 /**
14796 * generate full masks and charsets
14797 */
14798
14799 masks = (char **) mymalloc (sizeof (char *));
14800
14801 switch (hash_mode)
14802 {
14803 case 1731: pw_min = 5;
14804 pw_max = 5;
14805 mask = mystrdup ("?b?b?b?b?b");
14806 break;
14807 case 12500: pw_min = 5;
14808 pw_max = 5;
14809 mask = mystrdup ("?b?b?b?b?b");
14810 break;
14811 default: pw_min = 7;
14812 pw_max = 7;
14813 mask = mystrdup ("?b?b?b?b?b?b?b");
14814 break;
14815 }
14816
14817 maskcnt = 1;
14818
14819 masks[maskcnt - 1] = mystrdup (mask);
14820
14821 wordlist_mode = WL_MODE_MASK;
14822
14823 data.wordlist_mode = wordlist_mode;
14824
14825 increment = 1;
14826 }
14827
14828 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14829
14830 if (increment)
14831 {
14832 if (increment_min > pw_min) pw_min = increment_min;
14833
14834 if (increment_max < pw_max) pw_max = increment_max;
14835 }
14836 }
14837 else if (attack_mode == ATTACK_MODE_HYBRID1)
14838 {
14839 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14840
14841 // display
14842
14843 char *mask = myargv[myargc - 1];
14844
14845 maskcnt = 0;
14846
14847 masks = (char **) mymalloc (1 * sizeof (char *));
14848
14849 // mod
14850
14851 struct stat file_stat;
14852
14853 if (stat (mask, &file_stat) == -1)
14854 {
14855 maskcnt = 1;
14856
14857 masks[maskcnt - 1] = mystrdup (mask);
14858 }
14859 else
14860 {
14861 uint is_file = S_ISREG (file_stat.st_mode);
14862
14863 if (is_file == 1)
14864 {
14865 FILE *mask_fp;
14866
14867 if ((mask_fp = fopen (mask, "r")) == NULL)
14868 {
14869 log_error ("ERROR: %s: %s", mask, strerror (errno));
14870
14871 return (-1);
14872 }
14873
14874 char line_buf[BUFSIZ];
14875
14876 uint masks_avail = 1;
14877
14878 while (!feof (mask_fp))
14879 {
14880 memset (line_buf, 0, BUFSIZ);
14881
14882 int line_len = fgetl (mask_fp, line_buf);
14883
14884 if (line_len == 0) continue;
14885
14886 if (line_buf[0] == '#') continue;
14887
14888 if (masks_avail == maskcnt)
14889 {
14890 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14891
14892 masks_avail += INCR_MASKS;
14893 }
14894
14895 masks[maskcnt] = mystrdup (line_buf);
14896
14897 maskcnt++;
14898 }
14899
14900 fclose (mask_fp);
14901
14902 mask_from_file = 1;
14903 }
14904 else
14905 {
14906 maskcnt = 1;
14907
14908 masks[maskcnt - 1] = mystrdup (mask);
14909 }
14910 }
14911
14912 // base
14913
14914 int wls_left = myargc - (optind + 2);
14915
14916 for (int i = 0; i < wls_left; i++)
14917 {
14918 char *filename = myargv[optind + 1 + i];
14919
14920 struct stat file_stat;
14921
14922 if (stat (filename, &file_stat) == -1)
14923 {
14924 log_error ("ERROR: %s: %s", filename, strerror (errno));
14925
14926 return (-1);
14927 }
14928
14929 uint is_dir = S_ISDIR (file_stat.st_mode);
14930
14931 if (is_dir == 0)
14932 {
14933 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14934
14935 dictcnt++;
14936
14937 dictfiles[dictcnt - 1] = filename;
14938 }
14939 else
14940 {
14941 // do not allow --keyspace w/ a directory
14942
14943 if (keyspace == 1)
14944 {
14945 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14946
14947 return (-1);
14948 }
14949
14950 char **dictionary_files = NULL;
14951
14952 dictionary_files = scan_directory (filename);
14953
14954 if (dictionary_files != NULL)
14955 {
14956 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14957
14958 for (int d = 0; dictionary_files[d] != NULL; d++)
14959 {
14960 char *l1_filename = dictionary_files[d];
14961
14962 struct stat l1_stat;
14963
14964 if (stat (l1_filename, &l1_stat) == -1)
14965 {
14966 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14967
14968 return (-1);
14969 }
14970
14971 if (S_ISREG (l1_stat.st_mode))
14972 {
14973 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14974
14975 dictcnt++;
14976
14977 dictfiles[dictcnt - 1] = strdup (l1_filename);
14978 }
14979 }
14980 }
14981
14982 local_free (dictionary_files);
14983 }
14984 }
14985
14986 if (dictcnt < 1)
14987 {
14988 log_error ("ERROR: No usable dictionary file found.");
14989
14990 return (-1);
14991 }
14992
14993 if (increment)
14994 {
14995 maskcnt = 0;
14996
14997 uint mask_min = increment_min; // we can't reject smaller masks here
14998 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14999
15000 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15001 {
15002 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15003
15004 if (cur_mask == NULL) break;
15005
15006 masks[maskcnt] = cur_mask;
15007
15008 maskcnt++;
15009
15010 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15011 }
15012 }
15013 }
15014 else if (attack_mode == ATTACK_MODE_HYBRID2)
15015 {
15016 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15017
15018 // display
15019
15020 char *mask = myargv[optind + 1 + 0];
15021
15022 maskcnt = 0;
15023
15024 masks = (char **) mymalloc (1 * sizeof (char *));
15025
15026 // mod
15027
15028 struct stat file_stat;
15029
15030 if (stat (mask, &file_stat) == -1)
15031 {
15032 maskcnt = 1;
15033
15034 masks[maskcnt - 1] = mystrdup (mask);
15035 }
15036 else
15037 {
15038 uint is_file = S_ISREG (file_stat.st_mode);
15039
15040 if (is_file == 1)
15041 {
15042 FILE *mask_fp;
15043
15044 if ((mask_fp = fopen (mask, "r")) == NULL)
15045 {
15046 log_error ("ERROR: %s: %s", mask, strerror (errno));
15047
15048 return (-1);
15049 }
15050
15051 char line_buf[BUFSIZ];
15052
15053 uint masks_avail = 1;
15054
15055 while (!feof (mask_fp))
15056 {
15057 memset (line_buf, 0, BUFSIZ);
15058
15059 int line_len = fgetl (mask_fp, line_buf);
15060
15061 if (line_len == 0) continue;
15062
15063 if (line_buf[0] == '#') continue;
15064
15065 if (masks_avail == maskcnt)
15066 {
15067 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15068
15069 masks_avail += INCR_MASKS;
15070 }
15071
15072 masks[maskcnt] = mystrdup (line_buf);
15073
15074 maskcnt++;
15075 }
15076
15077 fclose (mask_fp);
15078
15079 mask_from_file = 1;
15080 }
15081 else
15082 {
15083 maskcnt = 1;
15084
15085 masks[maskcnt - 1] = mystrdup (mask);
15086 }
15087 }
15088
15089 // base
15090
15091 int wls_left = myargc - (optind + 2);
15092
15093 for (int i = 0; i < wls_left; i++)
15094 {
15095 char *filename = myargv[optind + 2 + i];
15096
15097 struct stat file_stat;
15098
15099 if (stat (filename, &file_stat) == -1)
15100 {
15101 log_error ("ERROR: %s: %s", filename, strerror (errno));
15102
15103 return (-1);
15104 }
15105
15106 uint is_dir = S_ISDIR (file_stat.st_mode);
15107
15108 if (is_dir == 0)
15109 {
15110 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15111
15112 dictcnt++;
15113
15114 dictfiles[dictcnt - 1] = filename;
15115 }
15116 else
15117 {
15118 // do not allow --keyspace w/ a directory
15119
15120 if (keyspace == 1)
15121 {
15122 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15123
15124 return (-1);
15125 }
15126
15127 char **dictionary_files = NULL;
15128
15129 dictionary_files = scan_directory (filename);
15130
15131 if (dictionary_files != NULL)
15132 {
15133 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15134
15135 for (int d = 0; dictionary_files[d] != NULL; d++)
15136 {
15137 char *l1_filename = dictionary_files[d];
15138
15139 struct stat l1_stat;
15140
15141 if (stat (l1_filename, &l1_stat) == -1)
15142 {
15143 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15144
15145 return (-1);
15146 }
15147
15148 if (S_ISREG (l1_stat.st_mode))
15149 {
15150 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15151
15152 dictcnt++;
15153
15154 dictfiles[dictcnt - 1] = strdup (l1_filename);
15155 }
15156 }
15157 }
15158
15159 local_free (dictionary_files);
15160 }
15161 }
15162
15163 if (dictcnt < 1)
15164 {
15165 log_error ("ERROR: No usable dictionary file found.");
15166
15167 return (-1);
15168 }
15169
15170 if (increment)
15171 {
15172 maskcnt = 0;
15173
15174 uint mask_min = increment_min; // we can't reject smaller masks here
15175 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15176
15177 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15178 {
15179 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15180
15181 if (cur_mask == NULL) break;
15182
15183 masks[maskcnt] = cur_mask;
15184
15185 maskcnt++;
15186
15187 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15188 }
15189 }
15190 }
15191
15192 data.pw_min = pw_min;
15193 data.pw_max = pw_max;
15194
15195 /**
15196 * weak hash check
15197 */
15198
15199 if (weak_hash_threshold >= salts_cnt)
15200 {
15201 uint first_device_id = 0;
15202
15203 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15204 {
15205 hc_device_param_t *device_param = &data.devices_param[device_id];
15206
15207 if (device_param->skipped) continue;
15208
15209 first_device_id = device_id;
15210
15211 break;
15212 }
15213
15214 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15215
15216 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15217 {
15218 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15219 }
15220 }
15221
15222 // Display hack, guarantee that there is at least one \r before real start
15223
15224 if (data.quiet == 0) log_info_nn ("");
15225
15226 /**
15227 * status and monitor threads
15228 */
15229
15230 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15231
15232 hc_thread_t i_thread = 0;
15233
15234 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15235 {
15236 hc_thread_create (i_thread, thread_keypress, &benchmark);
15237 }
15238
15239 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15240
15241 uint ni_threads_cnt = 0;
15242
15243 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15244
15245 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15246
15247 ni_threads_cnt++;
15248
15249 /**
15250 * Outfile remove
15251 */
15252
15253 if (keyspace == 0)
15254 {
15255 if (outfile_check_timer != 0)
15256 {
15257 if (data.outfile_check_directory != NULL)
15258 {
15259 if ((hash_mode != 5200) &&
15260 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15261 (hash_mode != 9000))
15262 {
15263 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15264
15265 ni_threads_cnt++;
15266 }
15267 else
15268 {
15269 outfile_check_timer = 0;
15270 }
15271 }
15272 else
15273 {
15274 outfile_check_timer = 0;
15275 }
15276 }
15277 }
15278
15279 /**
15280 * Inform the user if we got some hashes remove because of the pot file remove feature
15281 */
15282
15283 if (data.quiet == 0)
15284 {
15285 if (potfile_remove_cracks > 0)
15286 {
15287 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15288 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15289 }
15290 }
15291
15292 data.outfile_check_timer = outfile_check_timer;
15293
15294 /**
15295 * main loop
15296 */
15297
15298 char **induction_dictionaries = NULL;
15299
15300 int induction_dictionaries_cnt = 0;
15301
15302 hcstat_table_t *root_table_buf = NULL;
15303 hcstat_table_t *markov_table_buf = NULL;
15304
15305 uint initial_restore_done = 0;
15306
15307 data.maskcnt = maskcnt;
15308
15309 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15310 {
15311 if (data.devices_status == STATUS_CRACKED) break;
15312
15313 data.devices_status = STATUS_INIT;
15314
15315 if (maskpos > rd->maskpos)
15316 {
15317 rd->dictpos = 0;
15318 }
15319
15320 rd->maskpos = maskpos;
15321 data.maskpos = maskpos;
15322
15323 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15324 {
15325 char *mask = masks[maskpos];
15326
15327 if (mask_from_file == 1)
15328 {
15329 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15330
15331 char *str_ptr;
15332 uint str_pos;
15333
15334 uint mask_offset = 0;
15335
15336 uint separator_cnt;
15337
15338 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15339 {
15340 str_ptr = strstr (mask + mask_offset, ",");
15341
15342 if (str_ptr == NULL) break;
15343
15344 str_pos = str_ptr - mask;
15345
15346 // escaped separator, i.e. "\,"
15347
15348 if (str_pos > 0)
15349 {
15350 if (mask[str_pos - 1] == '\\')
15351 {
15352 separator_cnt --;
15353
15354 mask_offset = str_pos + 1;
15355
15356 continue;
15357 }
15358 }
15359
15360 // reset the offset
15361
15362 mask_offset = 0;
15363
15364 mask[str_pos] = '\0';
15365
15366 switch (separator_cnt)
15367 {
15368 case 0:
15369 mp_reset_usr (mp_usr, 0);
15370
15371 custom_charset_1 = mask;
15372 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15373 break;
15374
15375 case 1:
15376 mp_reset_usr (mp_usr, 1);
15377
15378 custom_charset_2 = mask;
15379 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15380 break;
15381
15382 case 2:
15383 mp_reset_usr (mp_usr, 2);
15384
15385 custom_charset_3 = mask;
15386 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15387 break;
15388
15389 case 3:
15390 mp_reset_usr (mp_usr, 3);
15391
15392 custom_charset_4 = mask;
15393 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15394 break;
15395 }
15396
15397 mask = mask + str_pos + 1;
15398 }
15399 }
15400
15401 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15402 {
15403 if (maskpos > 0)
15404 {
15405 local_free (css_buf);
15406 local_free (data.root_css_buf);
15407 local_free (data.markov_css_buf);
15408
15409 local_free (masks[maskpos - 1]);
15410 }
15411
15412 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15413
15414 data.mask = mask;
15415 data.css_cnt = css_cnt;
15416 data.css_buf = css_buf;
15417
15418 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15419
15420 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15421
15422 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15423 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15424
15425 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15426
15427 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15428
15429 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15430 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15431
15432 data.root_css_buf = root_css_buf;
15433 data.markov_css_buf = markov_css_buf;
15434
15435 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15436
15437 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15438
15439 local_free (root_table_buf);
15440 local_free (markov_table_buf);
15441
15442 // args
15443
15444 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15445 {
15446 hc_device_param_t *device_param = &data.devices_param[device_id];
15447
15448 if (device_param->skipped) continue;
15449
15450 device_param->kernel_params_mp[0] = &device_param->d_combs;
15451 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15452 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15453
15454 device_param->kernel_params_mp_buf64[3] = 0;
15455 device_param->kernel_params_mp_buf32[4] = css_cnt;
15456 device_param->kernel_params_mp_buf32[5] = 0;
15457 device_param->kernel_params_mp_buf32[6] = 0;
15458 device_param->kernel_params_mp_buf32[7] = 0;
15459
15460 if (attack_mode == ATTACK_MODE_HYBRID1)
15461 {
15462 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15463 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15464 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15465 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15466 }
15467 else if (attack_mode == ATTACK_MODE_HYBRID2)
15468 {
15469 device_param->kernel_params_mp_buf32[5] = 0;
15470 device_param->kernel_params_mp_buf32[6] = 0;
15471 device_param->kernel_params_mp_buf32[7] = 0;
15472 }
15473
15474 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15475 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15476 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15477
15478 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);
15479 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);
15480 }
15481 }
15482 else if (attack_mode == ATTACK_MODE_BF)
15483 {
15484 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15485
15486 if (increment)
15487 {
15488 for (uint i = 0; i < dictcnt; i++)
15489 {
15490 local_free (dictfiles[i]);
15491 }
15492
15493 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15494 {
15495 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15496
15497 if (l1_filename == NULL) break;
15498
15499 dictcnt++;
15500
15501 dictfiles[dictcnt - 1] = l1_filename;
15502 }
15503 }
15504 else
15505 {
15506 dictcnt++;
15507
15508 dictfiles[dictcnt - 1] = mask;
15509 }
15510
15511 if (dictcnt == 0)
15512 {
15513 log_error ("ERROR: Mask is too small");
15514
15515 return (-1);
15516 }
15517 }
15518 }
15519
15520 free (induction_dictionaries);
15521
15522 // induction_dictionaries_cnt = 0; // implied
15523
15524 if (attack_mode != ATTACK_MODE_BF)
15525 {
15526 if (keyspace == 0)
15527 {
15528 induction_dictionaries = scan_directory (induction_directory);
15529
15530 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15531 }
15532 }
15533
15534 if (induction_dictionaries_cnt)
15535 {
15536 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15537 }
15538
15539 /**
15540 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15541 */
15542 if (keyspace == 1)
15543 {
15544 if ((maskcnt > 1) || (dictcnt > 1))
15545 {
15546 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15547
15548 return (-1);
15549 }
15550 }
15551
15552 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15553 {
15554 char *subid = logfile_generate_subid ();
15555
15556 data.subid = subid;
15557
15558 logfile_sub_msg ("START");
15559
15560 data.devices_status = STATUS_INIT;
15561
15562 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15563 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15564 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15565
15566 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15567
15568 data.cpt_pos = 0;
15569
15570 data.cpt_start = time (NULL);
15571
15572 data.cpt_total = 0;
15573
15574 if (data.restore == 0)
15575 {
15576 rd->words_cur = skip;
15577
15578 skip = 0;
15579
15580 data.skip = 0;
15581 }
15582
15583 data.ms_paused = 0;
15584
15585 data.words_cur = rd->words_cur;
15586
15587 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15588 {
15589 hc_device_param_t *device_param = &data.devices_param[device_id];
15590
15591 if (device_param->skipped) continue;
15592
15593 device_param->speed_pos = 0;
15594
15595 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15596 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15597 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15598
15599 device_param->kernel_power = device_param->kernel_power_user;
15600 device_param->kernel_blocks = device_param->kernel_blocks_user;
15601
15602 device_param->outerloop_pos = 0;
15603 device_param->outerloop_left = 0;
15604 device_param->innerloop_pos = 0;
15605 device_param->innerloop_left = 0;
15606
15607 // some more resets:
15608
15609 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15610
15611 memset (device_param->pws_buf, 0, device_param->size_pws);
15612
15613 device_param->pw_cnt = 0;
15614 device_param->pws_cnt = 0;
15615
15616 device_param->words_off = 0;
15617 device_param->words_done = 0;
15618 }
15619
15620 data.kernel_blocks_div = 0;
15621
15622 // figure out some workload
15623
15624 if (attack_mode == ATTACK_MODE_STRAIGHT)
15625 {
15626 if (data.wordlist_mode == WL_MODE_FILE)
15627 {
15628 char *dictfile = NULL;
15629
15630 if (induction_dictionaries_cnt)
15631 {
15632 dictfile = induction_dictionaries[0];
15633 }
15634 else
15635 {
15636 dictfile = dictfiles[dictpos];
15637 }
15638
15639 data.dictfile = dictfile;
15640
15641 logfile_sub_string (dictfile);
15642
15643 for (uint i = 0; i < rp_files_cnt; i++)
15644 {
15645 logfile_sub_var_string ("rulefile", rp_files[i]);
15646 }
15647
15648 FILE *fd2 = fopen (dictfile, "rb");
15649
15650 if (fd2 == NULL)
15651 {
15652 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15653
15654 return (-1);
15655 }
15656
15657 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15658
15659 fclose (fd2);
15660
15661 if (data.words_cnt == 0)
15662 {
15663 if (data.devices_status == STATUS_CRACKED) break;
15664 if (data.devices_status == STATUS_ABORTED) break;
15665
15666 dictpos++;
15667
15668 continue;
15669 }
15670 }
15671 }
15672 else if (attack_mode == ATTACK_MODE_COMBI)
15673 {
15674 char *dictfile = data.dictfile;
15675 char *dictfile2 = data.dictfile2;
15676
15677 logfile_sub_string (dictfile);
15678 logfile_sub_string (dictfile2);
15679
15680 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15681 {
15682 FILE *fd2 = fopen (dictfile, "rb");
15683
15684 if (fd2 == NULL)
15685 {
15686 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15687
15688 return (-1);
15689 }
15690
15691 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15692
15693 fclose (fd2);
15694 }
15695 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15696 {
15697 FILE *fd2 = fopen (dictfile2, "rb");
15698
15699 if (fd2 == NULL)
15700 {
15701 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15702
15703 return (-1);
15704 }
15705
15706 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15707
15708 fclose (fd2);
15709 }
15710
15711 if (data.words_cnt == 0)
15712 {
15713 if (data.devices_status == STATUS_CRACKED) break;
15714 if (data.devices_status == STATUS_ABORTED) break;
15715
15716 dictpos++;
15717
15718 continue;
15719 }
15720 }
15721 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15722 {
15723 char *dictfile = NULL;
15724
15725 if (induction_dictionaries_cnt)
15726 {
15727 dictfile = induction_dictionaries[0];
15728 }
15729 else
15730 {
15731 dictfile = dictfiles[dictpos];
15732 }
15733
15734 data.dictfile = dictfile;
15735
15736 char *mask = data.mask;
15737
15738 logfile_sub_string (dictfile);
15739 logfile_sub_string (mask);
15740
15741 FILE *fd2 = fopen (dictfile, "rb");
15742
15743 if (fd2 == NULL)
15744 {
15745 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15746
15747 return (-1);
15748 }
15749
15750 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15751
15752 fclose (fd2);
15753
15754 if (data.words_cnt == 0)
15755 {
15756 if (data.devices_status == STATUS_CRACKED) break;
15757 if (data.devices_status == STATUS_ABORTED) break;
15758
15759 dictpos++;
15760
15761 continue;
15762 }
15763 }
15764 else if (attack_mode == ATTACK_MODE_BF)
15765 {
15766 local_free (css_buf);
15767 local_free (data.root_css_buf);
15768 local_free (data.markov_css_buf);
15769
15770 char *mask = dictfiles[dictpos];
15771
15772 logfile_sub_string (mask);
15773
15774 // base
15775
15776 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15777
15778 if (opts_type & OPTS_TYPE_PT_UNICODE)
15779 {
15780 uint css_cnt_unicode = css_cnt * 2;
15781
15782 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15783
15784 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15785 {
15786 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15787
15788 css_buf_unicode[j + 1].cs_buf[0] = 0;
15789 css_buf_unicode[j + 1].cs_len = 1;
15790 }
15791
15792 free (css_buf);
15793
15794 css_buf = css_buf_unicode;
15795 css_cnt = css_cnt_unicode;
15796 }
15797
15798 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15799
15800 uint mask_min = pw_min;
15801 uint mask_max = pw_max;
15802
15803 if (opts_type & OPTS_TYPE_PT_UNICODE)
15804 {
15805 mask_min *= 2;
15806 mask_max *= 2;
15807 }
15808
15809 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15810 {
15811 if (css_cnt < mask_min)
15812 {
15813 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15814 }
15815
15816 if (css_cnt > mask_max)
15817 {
15818 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15819 }
15820
15821 // skip to next mask
15822
15823 dictpos++;
15824
15825 rd->dictpos = dictpos;
15826
15827 logfile_sub_msg ("STOP");
15828
15829 continue;
15830 }
15831
15832 uint save_css_cnt = css_cnt;
15833
15834 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15835 {
15836 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15837 {
15838 uint salt_len = (uint) data.salts_buf[0].salt_len;
15839 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15840
15841 uint css_cnt_salt = css_cnt + salt_len;
15842
15843 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15844
15845 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15846
15847 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15848 {
15849 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15850 css_buf_salt[j].cs_len = 1;
15851 }
15852
15853 free (css_buf);
15854
15855 css_buf = css_buf_salt;
15856 css_cnt = css_cnt_salt;
15857 }
15858 }
15859
15860 data.mask = mask;
15861 data.css_cnt = css_cnt;
15862 data.css_buf = css_buf;
15863
15864 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15865
15866 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15867
15868 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15869
15870 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15871 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15872
15873 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15874
15875 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15876
15877 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15878 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15879
15880 data.root_css_buf = root_css_buf;
15881 data.markov_css_buf = markov_css_buf;
15882
15883 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15884
15885 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15886
15887 local_free (root_table_buf);
15888 local_free (markov_table_buf);
15889
15890 // copy + args
15891
15892 uint css_cnt_l = css_cnt;
15893 uint css_cnt_r;
15894
15895 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15896 {
15897 if (save_css_cnt < 6)
15898 {
15899 css_cnt_r = 1;
15900 }
15901 else if (save_css_cnt == 6)
15902 {
15903 css_cnt_r = 2;
15904 }
15905 else
15906 {
15907 if (opts_type & OPTS_TYPE_PT_UNICODE)
15908 {
15909 if (save_css_cnt == 8 || save_css_cnt == 10)
15910 {
15911 css_cnt_r = 2;
15912 }
15913 else
15914 {
15915 css_cnt_r = 4;
15916 }
15917 }
15918 else
15919 {
15920 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15921 {
15922 css_cnt_r = 3;
15923 }
15924 else
15925 {
15926 css_cnt_r = 4;
15927 }
15928 }
15929 }
15930 }
15931 else
15932 {
15933 css_cnt_r = 1;
15934
15935 /* unfinished code?
15936 int sum = css_buf[css_cnt_r - 1].cs_len;
15937
15938 for (uint i = 1; i < 4 && i < css_cnt; i++)
15939 {
15940 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15941
15942 css_cnt_r++;
15943
15944 sum *= css_buf[css_cnt_r - 1].cs_len;
15945 }
15946 */
15947 }
15948
15949 css_cnt_l -= css_cnt_r;
15950
15951 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15952
15953 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15954 {
15955 hc_device_param_t *device_param = &data.devices_param[device_id];
15956
15957 if (device_param->skipped) continue;
15958
15959 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15960 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15961 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15962
15963 device_param->kernel_params_mp_l_buf64[3] = 0;
15964 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15965 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15966 device_param->kernel_params_mp_l_buf32[6] = 0;
15967 device_param->kernel_params_mp_l_buf32[7] = 0;
15968 device_param->kernel_params_mp_l_buf32[8] = 0;
15969
15970 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15971 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15972 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15973 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15974
15975 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15976 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15977 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15978
15979 device_param->kernel_params_mp_r_buf64[3] = 0;
15980 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15981 device_param->kernel_params_mp_r_buf32[5] = 0;
15982 device_param->kernel_params_mp_r_buf32[6] = 0;
15983 device_param->kernel_params_mp_r_buf32[7] = 0;
15984
15985 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]);
15986 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]);
15987 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]);
15988
15989 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]);
15990 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]);
15991 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]);
15992
15993 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);
15994 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);
15995 }
15996 }
15997
15998 u64 words_base = data.words_cnt;
15999
16000 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16001 {
16002 if (data.kernel_rules_cnt)
16003 {
16004 words_base /= data.kernel_rules_cnt;
16005 }
16006 }
16007 else if (data.attack_kern == ATTACK_KERN_COMBI)
16008 {
16009 if (data.combs_cnt)
16010 {
16011 words_base /= data.combs_cnt;
16012 }
16013 }
16014 else if (data.attack_kern == ATTACK_KERN_BF)
16015 {
16016 if (data.bfs_cnt)
16017 {
16018 words_base /= data.bfs_cnt;
16019 }
16020 }
16021
16022 data.words_base = words_base;
16023
16024 if (keyspace == 1)
16025 {
16026 log_info ("%llu", (unsigned long long int) words_base);
16027
16028 return (0);
16029 }
16030
16031 if (data.words_cur > data.words_base)
16032 {
16033 log_error ("ERROR: restore value greater keyspace");
16034
16035 return (-1);
16036 }
16037
16038 if (data.words_cur)
16039 {
16040 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16041 {
16042 for (uint i = 0; i < data.salts_cnt; i++)
16043 {
16044 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16045 }
16046 }
16047 else if (data.attack_kern == ATTACK_KERN_COMBI)
16048 {
16049 for (uint i = 0; i < data.salts_cnt; i++)
16050 {
16051 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16052 }
16053 }
16054 else if (data.attack_kern == ATTACK_KERN_BF)
16055 {
16056 for (uint i = 0; i < data.salts_cnt; i++)
16057 {
16058 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16059 }
16060 }
16061 }
16062
16063 /*
16064 * Inform user about possible slow speeds
16065 */
16066
16067 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16068 {
16069 if (data.words_base < kernel_blocks_all)
16070 {
16071 if (quiet == 0)
16072 {
16073 log_info ("");
16074 log_info ("ATTENTION!");
16075 log_info (" The wordlist or mask you are using is too small.");
16076 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16077 log_info (" The cracking speed will drop.");
16078 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16079 log_info ("");
16080 }
16081 }
16082 }
16083
16084 /*
16085 * Update loopback file
16086 */
16087
16088 if (loopback == 1)
16089 {
16090 time_t now;
16091
16092 time (&now);
16093
16094 uint random_num = get_random_num (0, 9999);
16095
16096 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16097
16098 data.loopback_file = loopback_file;
16099 }
16100
16101 /*
16102 * Update dictionary statistic
16103 */
16104
16105 if (keyspace == 0)
16106 {
16107 dictstat_fp = fopen (dictstat, "wb");
16108
16109 if (dictstat_fp)
16110 {
16111 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16112
16113 fclose (dictstat_fp);
16114 }
16115 }
16116
16117 data.devices_status = STATUS_RUNNING;
16118
16119 if (initial_restore_done == 0)
16120 {
16121 if (data.restore_disable == 0) cycle_restore ();
16122
16123 initial_restore_done = 1;
16124 }
16125
16126 hc_timer_set (&data.timer_running);
16127
16128 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16129 {
16130 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16131 {
16132 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16133 if (quiet == 0) fflush (stdout);
16134 }
16135 }
16136 else if (wordlist_mode == WL_MODE_STDIN)
16137 {
16138 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16139 if (data.quiet == 0) log_info ("");
16140 }
16141
16142 time_t runtime_start;
16143
16144 time (&runtime_start);
16145
16146 data.runtime_start = runtime_start;
16147
16148 /**
16149 * create cracker threads
16150 */
16151
16152 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16153
16154 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16155 {
16156 hc_device_param_t *device_param = &devices_param[device_id];
16157
16158 if (wordlist_mode == WL_MODE_STDIN)
16159 {
16160 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16161 }
16162 else
16163 {
16164 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16165 }
16166 }
16167
16168 // wait for crack threads to exit
16169
16170 hc_thread_wait (devices_cnt, c_threads);
16171
16172 local_free (c_threads);
16173
16174 data.restore = 0;
16175
16176 // finalize task
16177
16178 logfile_sub_var_uint ("status-after-work", data.devices_status);
16179
16180 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16181
16182 if (data.devices_status == STATUS_CRACKED) break;
16183 if (data.devices_status == STATUS_ABORTED) break;
16184
16185 if (data.devices_status == STATUS_BYPASS)
16186 {
16187 data.devices_status = STATUS_RUNNING;
16188 }
16189
16190 if (induction_dictionaries_cnt)
16191 {
16192 unlink (induction_dictionaries[0]);
16193 }
16194
16195 free (induction_dictionaries);
16196
16197 if (attack_mode != ATTACK_MODE_BF)
16198 {
16199 induction_dictionaries = scan_directory (induction_directory);
16200
16201 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16202 }
16203
16204 if (benchmark == 0)
16205 {
16206 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16207 {
16208 if (quiet == 0) clear_prompt ();
16209
16210 if (quiet == 0) log_info ("");
16211
16212 if (status == 1)
16213 {
16214 status_display ();
16215 }
16216 else
16217 {
16218 if (quiet == 0) status_display ();
16219 }
16220
16221 if (quiet == 0) log_info ("");
16222 }
16223 }
16224
16225 if (attack_mode == ATTACK_MODE_BF)
16226 {
16227 dictpos++;
16228
16229 rd->dictpos = dictpos;
16230 }
16231 else
16232 {
16233 if (induction_dictionaries_cnt)
16234 {
16235 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16236 }
16237 else
16238 {
16239 dictpos++;
16240
16241 rd->dictpos = dictpos;
16242 }
16243 }
16244
16245 time_t runtime_stop;
16246
16247 time (&runtime_stop);
16248
16249 data.runtime_stop = runtime_stop;
16250
16251 logfile_sub_uint (runtime_start);
16252 logfile_sub_uint (runtime_stop);
16253
16254 logfile_sub_msg ("STOP");
16255
16256 global_free (subid);
16257 }
16258
16259 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16260
16261 if (data.devices_status == STATUS_CRACKED) break;
16262 if (data.devices_status == STATUS_ABORTED) break;
16263 if (data.devices_status == STATUS_QUIT) break;
16264
16265 if (data.devices_status == STATUS_BYPASS)
16266 {
16267 data.devices_status = STATUS_RUNNING;
16268 }
16269 }
16270
16271 // 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
16272
16273 if (attack_mode == ATTACK_MODE_STRAIGHT)
16274 {
16275 if (data.wordlist_mode == WL_MODE_FILE)
16276 {
16277 if (data.dictfile == NULL)
16278 {
16279 if (dictfiles != NULL)
16280 {
16281 data.dictfile = dictfiles[0];
16282
16283 hc_timer_set (&data.timer_running);
16284 }
16285 }
16286 }
16287 }
16288 // NOTE: combi is okay because it is already set beforehand
16289 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16290 {
16291 if (data.dictfile == NULL)
16292 {
16293 if (dictfiles != NULL)
16294 {
16295 hc_timer_set (&data.timer_running);
16296
16297 data.dictfile = dictfiles[0];
16298 }
16299 }
16300 }
16301 else if (attack_mode == ATTACK_MODE_BF)
16302 {
16303 if (data.mask == NULL)
16304 {
16305 hc_timer_set (&data.timer_running);
16306
16307 data.mask = masks[0];
16308 }
16309 }
16310
16311 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16312 {
16313 data.devices_status = STATUS_EXHAUSTED;
16314 }
16315
16316 // if cracked / aborted remove last induction dictionary
16317
16318 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16319 {
16320 struct stat induct_stat;
16321
16322 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16323 {
16324 unlink (induction_dictionaries[file_pos]);
16325 }
16326 }
16327
16328 // wait for non-interactive threads
16329
16330 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16331 {
16332 hc_thread_wait (1, &ni_threads[thread_idx]);
16333 }
16334
16335 local_free (ni_threads);
16336
16337 // wait for interactive threads
16338
16339 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16340 {
16341 hc_thread_wait (1, &i_thread);
16342 }
16343
16344 // we dont need restore file anymore
16345 if (data.restore_disable == 0)
16346 {
16347 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16348 {
16349 unlink (eff_restore_file);
16350 unlink (new_restore_file);
16351 }
16352 else
16353 {
16354 cycle_restore ();
16355 }
16356 }
16357
16358 // finally save left hashes
16359
16360 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16361 {
16362 save_hash ();
16363 }
16364
16365 /**
16366 * Clean up
16367 */
16368
16369 if (benchmark == 1)
16370 {
16371 status_benchmark ();
16372
16373 log_info ("");
16374 }
16375 else
16376 {
16377 if (quiet == 0) clear_prompt ();
16378
16379 if (quiet == 0) log_info ("");
16380
16381 if (status == 1)
16382 {
16383 status_display ();
16384 }
16385 else
16386 {
16387 if (quiet == 0) status_display ();
16388 }
16389
16390 if (quiet == 0) log_info ("");
16391 }
16392
16393 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16394 {
16395 hc_device_param_t *device_param = &data.devices_param[device_id];
16396
16397 if (device_param->skipped) continue;
16398
16399 local_free (device_param->result);
16400
16401 local_free (device_param->pw_caches);
16402
16403 local_free (device_param->combs_buf);
16404
16405 local_free (device_param->hooks_buf);
16406
16407 local_free (device_param->device_name);
16408
16409 local_free (device_param->device_name_chksum);
16410
16411 local_free (device_param->device_version);
16412
16413 local_free (device_param->driver_version);
16414
16415 if (device_param->pws_buf) myfree (device_param->pws_buf);
16416 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16417 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16418 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16419 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16420 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16421 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16422 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16423 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16424 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16425 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16426 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16427 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16428 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16429 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16430 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16431 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16432 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16433 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16434 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16435 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16436 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16437 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16438 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16439 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16440 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16441 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16442 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16443 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16444
16445 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16446 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16447 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16448 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16449 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16450 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16451 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16452 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16453 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16454 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16455 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16456
16457 if (device_param->program) hc_clReleaseProgram (device_param->program);
16458 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16459 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16460
16461 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16462 if (device_param->context) hc_clReleaseContext (device_param->context);
16463 }
16464
16465 // reset default fan speed
16466
16467 #ifdef HAVE_HWMON
16468 if (gpu_temp_disable == 0)
16469 {
16470 #ifdef HAVE_ADL
16471 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16472 {
16473 hc_thread_mutex_lock (mux_adl);
16474
16475 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16476 {
16477 hc_device_param_t *device_param = &data.devices_param[device_id];
16478
16479 if (device_param->skipped) continue;
16480
16481 if (data.hm_device[device_id].fan_supported == 1)
16482 {
16483 int fanspeed = temp_retain_fanspeed_value[device_id];
16484
16485 if (fanspeed == -1) continue;
16486
16487 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16488
16489 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16490 }
16491 }
16492
16493 hc_thread_mutex_unlock (mux_adl);
16494 }
16495 #endif // HAVE_ADL
16496 }
16497
16498 // reset power tuning
16499
16500 #ifdef HAVE_ADL
16501 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16502 {
16503 hc_thread_mutex_lock (mux_adl);
16504
16505 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16506 {
16507 hc_device_param_t *device_param = &data.devices_param[device_id];
16508
16509 if (device_param->skipped) continue;
16510
16511 if (data.hm_device[device_id].od_version == 6)
16512 {
16513 // check powertune capabilities first, if not available then skip device
16514
16515 int powertune_supported = 0;
16516
16517 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16518 {
16519 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16520
16521 return (-1);
16522 }
16523
16524 if (powertune_supported != 0)
16525 {
16526 // powercontrol settings
16527
16528 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)
16529 {
16530 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16531
16532 return (-1);
16533 }
16534
16535 // clocks
16536
16537 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16538
16539 performance_state->iNumberOfPerformanceLevels = 2;
16540
16541 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16542 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16543 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16544 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16545
16546 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)
16547 {
16548 log_info ("ERROR: Failed to restore ADL performance state");
16549
16550 return (-1);
16551 }
16552
16553 local_free (performance_state);
16554 }
16555 }
16556 }
16557
16558 hc_thread_mutex_unlock (mux_adl);
16559 }
16560 #endif // HAVE_ADL
16561
16562 if (gpu_temp_disable == 0)
16563 {
16564 #if defined(LINUX) && defined(HAVE_NVML)
16565 if (data.hm_dll_nv)
16566 {
16567 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16568
16569 hm_close (data.hm_dll_nv);
16570 }
16571 #endif
16572
16573 #if defined(WIN) && (HAVE_NVAPI)
16574 NvAPI_Unload ();
16575 #endif
16576
16577 #ifdef HAVE_ADL
16578 if (data.hm_dll_amd)
16579 {
16580 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16581
16582 hm_close (data.hm_dll_amd);
16583 }
16584 #endif
16585 }
16586 #endif // HAVE_HWMON
16587
16588 // free memory
16589
16590 local_free (masks);
16591
16592 local_free (dictstat_base);
16593
16594 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16595 {
16596 pot_t *pot_ptr = &pot[pot_pos];
16597
16598 hash_t *hash = &pot_ptr->hash;
16599
16600 local_free (hash->digest);
16601
16602 if (isSalted)
16603 {
16604 local_free (hash->salt);
16605 }
16606 }
16607
16608 local_free (pot);
16609
16610 local_free (all_kernel_rules_cnt);
16611 local_free (all_kernel_rules_buf);
16612
16613 local_free (wl_data->buf);
16614 local_free (wl_data);
16615
16616 local_free (bitmap_s1_a);
16617 local_free (bitmap_s1_b);
16618 local_free (bitmap_s1_c);
16619 local_free (bitmap_s1_d);
16620 local_free (bitmap_s2_a);
16621 local_free (bitmap_s2_b);
16622 local_free (bitmap_s2_c);
16623 local_free (bitmap_s2_d);
16624
16625 #ifdef HAVE_HWMON
16626 local_free (temp_retain_fanspeed_value);
16627 #ifdef HAVE_ADL
16628 local_free (od_clock_mem_status);
16629 local_free (od_power_control_status);
16630 #endif // ADL
16631 #endif
16632
16633 global_free (devices_param);
16634
16635 global_free (kernel_rules_buf);
16636
16637 global_free (root_css_buf);
16638 global_free (markov_css_buf);
16639
16640 global_free (digests_buf);
16641 global_free (digests_shown);
16642 global_free (digests_shown_tmp);
16643
16644 global_free (salts_buf);
16645 global_free (salts_shown);
16646
16647 global_free (esalts_buf);
16648
16649 global_free (words_progress_done);
16650 global_free (words_progress_rejected);
16651 global_free (words_progress_restored);
16652
16653 if (pot_fp) fclose (pot_fp);
16654
16655 if (data.devices_status == STATUS_QUIT) break;
16656 }
16657
16658 // destroy others mutex
16659
16660 hc_thread_mutex_delete (mux_dispatcher);
16661 hc_thread_mutex_delete (mux_counter);
16662 hc_thread_mutex_delete (mux_display);
16663 hc_thread_mutex_delete (mux_adl);
16664
16665 // free memory
16666
16667 local_free (eff_restore_file);
16668 local_free (new_restore_file);
16669
16670 local_free (rd);
16671
16672 // loopback
16673
16674 local_free (loopback_file);
16675
16676 if (loopback == 1) unlink (loopback_file);
16677
16678 // induction directory
16679
16680 if (induction_dir == NULL)
16681 {
16682 if (attack_mode != ATTACK_MODE_BF)
16683 {
16684 if (rmdir (induction_directory) == -1)
16685 {
16686 if (errno == ENOENT)
16687 {
16688 // good, we can ignore
16689 }
16690 else if (errno == ENOTEMPTY)
16691 {
16692 // good, we can ignore
16693 }
16694 else
16695 {
16696 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16697
16698 return (-1);
16699 }
16700 }
16701
16702 local_free (induction_directory);
16703 }
16704 }
16705
16706 // outfile-check directory
16707
16708 if (outfile_check_dir == NULL)
16709 {
16710 if (rmdir (outfile_check_directory) == -1)
16711 {
16712 if (errno == ENOENT)
16713 {
16714 // good, we can ignore
16715 }
16716 else if (errno == ENOTEMPTY)
16717 {
16718 // good, we can ignore
16719 }
16720 else
16721 {
16722 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16723
16724 return (-1);
16725 }
16726 }
16727
16728 local_free (outfile_check_directory);
16729 }
16730
16731 time_t proc_stop;
16732
16733 time (&proc_stop);
16734
16735 logfile_top_uint (proc_start);
16736 logfile_top_uint (proc_stop);
16737
16738 logfile_top_msg ("STOP");
16739
16740 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16741 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16742
16743 if (data.devices_status == STATUS_ABORTED) return 2;
16744 if (data.devices_status == STATUS_QUIT) return 2;
16745 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16746 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16747 if (data.devices_status == STATUS_CRACKED) return 0;
16748
16749 return -1;
16750 }
Hashcat additions to support pwdhash