projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #144 from gm4tr1x/master
[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 char *VERSION_TXT = "2.10";
17 const uint VERSION_BIN = 210;
18 const uint RESTORE_MIN = 210;
19
20 #define INCR_RULES 10000
21 #define INCR_SALTS 100000
22 #define INCR_MASKS 1000
23 #define INCR_POT 1000
24
25 #define USAGE 0
26 #define VERSION 0
27 #define QUIET 0
28 #define MARKOV_THRESHOLD 0
29 #define MARKOV_DISABLE 0
30 #define MARKOV_CLASSIC 0
31 #define BENCHMARK 0
32 #define BENCHMARK_MODE 1
33 #define RESTORE 0
34 #define RESTORE_TIMER 60
35 #define RESTORE_DISABLE 0
36 #define STATUS 0
37 #define STATUS_TIMER 10
38 #define STATUS_AUTOMAT 0
39 #define LOOPBACK 0
40 #define WEAK_HASH_THRESHOLD 100
41 #define SHOW 0
42 #define LEFT 0
43 #define USERNAME 0
44 #define REMOVE 0
45 #define REMOVE_TIMER 60
46 #define SKIP 0
47 #define LIMIT 0
48 #define KEYSPACE 0
49 #define POTFILE_DISABLE 0
50 #define DEBUG_MODE 0
51 #define RP_GEN 0
52 #define RP_GEN_FUNC_MIN 1
53 #define RP_GEN_FUNC_MAX 4
54 #define RP_GEN_SEED 0
55 #define RULE_BUF_L ":"
56 #define RULE_BUF_R ":"
57 #define FORCE 0
58 #define RUNTIME 0
59 #define HEX_CHARSET 0
60 #define HEX_SALT 0
61 #define HEX_WORDLIST 0
62 #define OUTFILE_FORMAT 3
63 #define OUTFILE_AUTOHEX 1
64 #define OUTFILE_CHECK_TIMER 5
65 #define ATTACK_MODE 0
66 #define HASH_MODE 0
67 #define SEGMENT_SIZE 32
68 #define INCREMENT 0
69 #define INCREMENT_MIN 1
70 #define INCREMENT_MAX PW_MAX
71 #define SEPARATOR ':'
72 #define BITMAP_MIN 16
73 #define BITMAP_MAX 24
74 #define GPU_TEMP_DISABLE 0
75 #define GPU_TEMP_ABORT 90
76 #define GPU_TEMP_RETAIN 80
77 #define WORKLOAD_PROFILE 2
78 #define KERNEL_ACCEL 0
79 #define KERNEL_LOOPS 0
80 #define KERNEL_RULES 1024
81 #define KERNEL_COMBS 1024
82 #define KERNEL_BFS 1024
83 #define KERNEL_THREADS 64
84 #define POWERTUNE_ENABLE 0
85 #define LOGFILE_DISABLE 0
86 #define SCRYPT_TMTO 0
87 #define OPENCL_VECTOR_WIDTH 0
88
89 #define WL_MODE_STDIN 1
90 #define WL_MODE_FILE 2
91 #define WL_MODE_MASK 3
92
93 #define HL_MODE_FILE 4
94 #define HL_MODE_ARG 5
95
96 #define HLFMT_HASHCAT 0
97 #define HLFMT_PWDUMP 1
98 #define HLFMT_PASSWD 2
99 #define HLFMT_SHADOW 3
100 #define HLFMT_DCC 4
101 #define HLFMT_DCC2 5
102 #define HLFMT_NETNTLM1 7
103 #define HLFMT_NETNTLM2 8
104 #define HLFMT_NSLDAP 9
105 #define HLFMT_NSLDAPS 10
106 #define HLFMTS_CNT 11
107
108 #define ATTACK_MODE_STRAIGHT 0
109 #define ATTACK_MODE_COMBI 1
110 #define ATTACK_MODE_TOGGLE 2
111 #define ATTACK_MODE_BF 3
112 #define ATTACK_MODE_PERM 4
113 #define ATTACK_MODE_TABLE 5
114 #define ATTACK_MODE_HYBRID1 6
115 #define ATTACK_MODE_HYBRID2 7
116 #define ATTACK_MODE_NONE 100
117
118 #define ATTACK_KERN_STRAIGHT 0
119 #define ATTACK_KERN_COMBI 1
120 #define ATTACK_KERN_BF 3
121 #define ATTACK_KERN_NONE 100
122
123 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
124 #define ATTACK_EXEC_INSIDE_KERNEL 11
125
126 #define COMBINATOR_MODE_BASE_LEFT 10001
127 #define COMBINATOR_MODE_BASE_RIGHT 10002
128
129 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
130 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
131
132 #define MAX_CUT_TRIES 4
133
134 #define MAX_DICTSTAT 10000
135
136 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
137
138 #define global_free(attr) \
139 { \
140 myfree ((void *) data.attr); \
141 \
142 data.attr = NULL; \
143 }
144
145 #define local_free(attr) \
146 { \
147 myfree ((void *) attr); \
148 \
149 attr = NULL; \
150 }
151
152 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
153 {
154 900,
155 0,
156 5100,
157 100,
158 1400,
159 10800,
160 1700,
161 5000,
162 10100,
163 6000,
164 6100,
165 6900,
166 11700,
167 11800,
168 400,
169 8900,
170 11900,
171 12000,
172 10900,
173 12100,
174 23,
175 2500,
176 5300,
177 5400,
178 5500,
179 5600,
180 7300,
181 7500,
182 8300,
183 11100,
184 11200,
185 11400,
186 121,
187 2611,
188 2711,
189 2811,
190 8400,
191 11,
192 2612,
193 7900,
194 21,
195 11000,
196 124,
197 10000,
198 3711,
199 7600,
200 12,
201 131,
202 132,
203 1731,
204 200,
205 300,
206 3100,
207 112,
208 12300,
209 8000,
210 141,
211 1441,
212 1600,
213 12600,
214 1421,
215 101,
216 111,
217 1711,
218 3000,
219 1000,
220 1100,
221 2100,
222 12800,
223 1500,
224 12400,
225 500,
226 3200,
227 7400,
228 1800,
229 122,
230 1722,
231 7100,
232 6300,
233 6700,
234 6400,
235 6500,
236 2400,
237 2410,
238 5700,
239 9200,
240 9300,
241 22,
242 501,
243 5800,
244 8100,
245 8500,
246 7200,
247 9900,
248 7700,
249 7800,
250 10300,
251 8600,
252 8700,
253 9100,
254 133,
255 11600,
256 12500,
257 13000,
258 6211,
259 6221,
260 6231,
261 6241,
262 8800,
263 12900,
264 12200,
265 9700,
266 9710,
267 9800,
268 9810,
269 9400,
270 9500,
271 9600,
272 10400,
273 10410,
274 10500,
275 10600,
276 10700,
277 9000,
278 5200,
279 6800,
280 6600,
281 8200,
282 11300,
283 12700
284 };
285
286 /**
287 * types
288 */
289
290 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
291
292 /**
293 * globals
294 */
295
296 static unsigned int full01 = 0x01010101;
297 static unsigned int full80 = 0x80808080;
298
299 int SUPPRESS_OUTPUT = 0;
300
301 hc_thread_mutex_t mux_adl;
302 hc_thread_mutex_t mux_counter;
303 hc_thread_mutex_t mux_dispatcher;
304 hc_thread_mutex_t mux_display;
305
306 hc_global_data_t data;
307
308 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
309
310 const char *USAGE_MINI[] =
311 {
312 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
313 "",
314 "Try --help for more help.",
315 NULL
316 };
317
318 const char *USAGE_BIG[] =
319 {
320 "%s, advanced password recovery",
321 "",
322 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
323 "",
324 "=======",
325 "Options",
326 "=======",
327 "",
328 "* General:",
329 "",
330 " -m, --hash-type=NUM Hash-type, see references below",
331 " -a, --attack-mode=NUM Attack-mode, see references below",
332 " -V, --version Print version",
333 " -h, --help Print help",
334 " --quiet Suppress output",
335 "",
336 "* Benchmark:",
337 "",
338 " -b, --benchmark Run benchmark",
339 " --benchmark-mode=NUM Benchmark-mode, see references below",
340 "",
341 "* Misc:",
342 "",
343 " --hex-charset Assume charset is given in hex",
344 " --hex-salt Assume salt is given in hex",
345 " --hex-wordlist Assume words in wordlist is given in hex",
346 " --force Ignore warnings",
347 " --status Enable automatic update of the status-screen",
348 " --status-timer=NUM Seconds between status-screen update",
349 " --status-automat Display the status view in a machine readable format",
350 " --loopback Add new plains to induct directory",
351 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
352 "",
353 "* Markov:",
354 "",
355 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
356 " --markov-disable Disables markov-chains, emulates classic brute-force",
357 " --markov-classic Enables classic markov-chains, no per-position enhancement",
358 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
359 "",
360 "* Session:",
361 "",
362 " --runtime=NUM Abort session after NUM seconds of runtime",
363 " --session=STR Define specific session name",
364 " --restore Restore session from --session",
365 " --restore-disable Do not write restore file",
366 "",
367 "* Files:",
368 "",
369 " -o, --outfile=FILE Define outfile for recovered hash",
370 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
371 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
372 " --outfile-check-timer=NUM Seconds between outfile checks",
373 " -p, --separator=CHAR Separator char for hashlists and outfile",
374 " --show Show cracked passwords only",
375 " --left Show un-cracked passwords only",
376 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
377 " --remove Enable remove of hash once it is cracked",
378 " --remove-timer=NUM Update input hash file each NUM seconds",
379 " --potfile-disable Do not write potfile",
380 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
381 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
382 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
383 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
384 " --logfile-disable Disable the logfile",
385 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
386 "",
387 "* Resources:",
388 "",
389 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
390 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
391 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
392 #ifndef OSX
393 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
394 #else
395 " --cpu-affinity=STR Locks to CPU devices, separate with comma (disabled on OSX)",
396 #endif
397 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
398 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
399 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
400 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
401 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
402 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
403 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
404 #ifdef HAVE_HWMON
405 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
406 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
407 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
408 #ifdef HAVE_ADL
409 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
410 #endif
411 #endif
412 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
413 "",
414 "* Distributed:",
415 "",
416 " -s, --skip=NUM Skip number of words",
417 " -l, --limit=NUM Limit number of words",
418 " --keyspace Show keyspace base:mod values and quit",
419 "",
420 "* Rules:",
421 "",
422 " -j, --rule-left=RULE Single rule applied to each word from left dict",
423 " -k, --rule-right=RULE Single rule applied to each word from right dict",
424 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
425 " -g, --generate-rules=NUM Generate NUM random rules",
426 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
427 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
428 " --generate-rules-seed=NUM Force RNG seed to NUM",
429 "",
430 "* Custom charsets:",
431 "",
432 " -1, --custom-charset1=CS User-defined charsets",
433 " -2, --custom-charset2=CS Example:",
434 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
435 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
436 "",
437 "* Increment:",
438 "",
439 " -i, --increment Enable increment mode",
440 " --increment-min=NUM Start incrementing at NUM",
441 " --increment-max=NUM Stop incrementing at NUM",
442 "",
443 "==========",
444 "References",
445 "==========",
446 "",
447 "* Workload Profile:",
448 "",
449 " 1 = Reduced performance profile (low latency desktop)",
450 " 2 = Default performance profile",
451 " 3 = Tuned performance profile (high latency desktop)",
452 "",
453 "* Benchmark Settings:",
454 "",
455 " 0 = Manual Tuning",
456 " 1 = Performance Tuning, default",
457 "",
458 "* OpenCL device-types:",
459 "",
460 " 1 = CPU devices",
461 " 2 = GPU devices",
462 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
463 "",
464 "* Outfile Formats:",
465 "",
466 " 1 = hash[:salt]",
467 " 2 = plain",
468 " 3 = hash[:salt]:plain",
469 " 4 = hex_plain",
470 " 5 = hash[:salt]:hex_plain",
471 " 6 = plain:hex_plain",
472 " 7 = hash[:salt]:plain:hex_plain",
473 " 8 = crackpos",
474 " 9 = hash[:salt]:crackpos",
475 " 10 = plain:crackpos",
476 " 11 = hash[:salt]:plain:crackpos",
477 " 12 = hex_plain:crackpos",
478 " 13 = hash[:salt]:hex_plain:crackpos",
479 " 14 = plain:hex_plain:crackpos",
480 " 15 = hash[:salt]:plain:hex_plain:crackpos",
481 "",
482 "* Debug mode output formats (for hybrid mode only, by using rules):",
483 "",
484 " 1 = save finding rule",
485 " 2 = save original word",
486 " 3 = save original word and finding rule",
487 " 4 = save original word, finding rule and modified plain",
488 "",
489 "* Built-in charsets:",
490 "",
491 " ?l = abcdefghijklmnopqrstuvwxyz",
492 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
493 " ?d = 0123456789",
494 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
495 " ?a = ?l?u?d?s",
496 " ?b = 0x00 - 0xff",
497 "",
498 "* Attack modes:",
499 "",
500 " 0 = Straight",
501 " 1 = Combination",
502 " 3 = Brute-force",
503 " 6 = Hybrid dict + mask",
504 " 7 = Hybrid mask + dict",
505 "",
506 "* Hash types:",
507 "",
508 "[[ Roll-your-own: Raw Hashes ]]",
509 "",
510 " 900 = MD4",
511 " 0 = MD5",
512 " 5100 = Half MD5",
513 " 100 = SHA1",
514 " 10800 = SHA-384",
515 " 1400 = SHA-256",
516 " 1700 = SHA-512",
517 " 5000 = SHA-3(Keccak)",
518 " 10100 = SipHash",
519 " 6000 = RipeMD160",
520 " 6100 = Whirlpool",
521 " 6900 = GOST R 34.11-94",
522 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
523 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
524 "",
525 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
526 "",
527 " 10 = md5($pass.$salt)",
528 " 20 = md5($salt.$pass)",
529 " 30 = md5(unicode($pass).$salt)",
530 " 40 = md5($salt.unicode($pass))",
531 " 3800 = md5($salt.$pass.$salt)",
532 " 3710 = md5($salt.md5($pass))",
533 " 2600 = md5(md5($pass)",
534 " 4300 = md5(strtoupper(md5($pass)))",
535 " 4400 = md5(sha1($pass))",
536 " 110 = sha1($pass.$salt)",
537 " 120 = sha1($salt.$pass)",
538 " 130 = sha1(unicode($pass).$salt)",
539 " 140 = sha1($salt.unicode($pass))",
540 " 4500 = sha1(sha1($pass)",
541 " 4700 = sha1(md5($pass))",
542 " 4900 = sha1($salt.$pass.$salt)",
543 " 1410 = sha256($pass.$salt)",
544 " 1420 = sha256($salt.$pass)",
545 " 1430 = sha256(unicode($pass).$salt)",
546 " 1440 = sha256($salt.unicode($pass))",
547 " 1710 = sha512($pass.$salt)",
548 " 1720 = sha512($salt.$pass)",
549 " 1730 = sha512(unicode($pass).$salt)",
550 " 1740 = sha512($salt.unicode($pass))",
551 "",
552 "[[ Roll-your-own: Authenticated Hashes ]]",
553 "",
554 " 50 = HMAC-MD5 (key = $pass)",
555 " 60 = HMAC-MD5 (key = $salt)",
556 " 150 = HMAC-SHA1 (key = $pass)",
557 " 160 = HMAC-SHA1 (key = $salt)",
558 " 1450 = HMAC-SHA256 (key = $pass)",
559 " 1460 = HMAC-SHA256 (key = $salt)",
560 " 1750 = HMAC-SHA512 (key = $pass)",
561 " 1760 = HMAC-SHA512 (key = $salt)",
562 "",
563 "[[ Generic KDF ]]",
564 "",
565 " 400 = phpass",
566 " 8900 = scrypt",
567 " 11900 = PBKDF2-HMAC-MD5",
568 " 12000 = PBKDF2-HMAC-SHA1",
569 " 10900 = PBKDF2-HMAC-SHA256",
570 " 12100 = PBKDF2-HMAC-SHA512",
571 "",
572 "[[ Network protocols, Challenge-Response ]]",
573 "",
574 " 23 = Skype",
575 " 2500 = WPA/WPA2",
576 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
577 " 5300 = IKE-PSK MD5",
578 " 5400 = IKE-PSK SHA1",
579 " 5500 = NetNTLMv1",
580 " 5500 = NetNTLMv1 + ESS",
581 " 5600 = NetNTLMv2",
582 " 7300 = IPMI2 RAKP HMAC-SHA1",
583 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
584 " 8300 = DNSSEC (NSEC3)",
585 " 10200 = Cram MD5",
586 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
587 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
588 " 11400 = SIP digest authentication (MD5)",
589 "",
590 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
591 "",
592 " 121 = SMF (Simple Machines Forum)",
593 " 400 = phpBB3",
594 " 2611 = vBulletin < v3.8.5",
595 " 2711 = vBulletin > v3.8.5",
596 " 2811 = MyBB",
597 " 2811 = IPB (Invison Power Board)",
598 " 8400 = WBB3 (Woltlab Burning Board)",
599 " 11 = Joomla < 2.5.18",
600 " 400 = Joomla > 2.5.18",
601 " 400 = Wordpress",
602 " 2612 = PHPS",
603 " 7900 = Drupal7",
604 " 21 = osCommerce",
605 " 21 = xt:Commerce",
606 " 11000 = PrestaShop",
607 " 124 = Django (SHA-1)",
608 " 10000 = Django (PBKDF2-SHA256)",
609 " 3711 = Mediawiki B type",
610 " 7600 = Redmine",
611 "",
612 "[[ Database Server ]]",
613 "",
614 " 12 = PostgreSQL",
615 " 131 = MSSQL(2000)",
616 " 132 = MSSQL(2005)",
617 " 1731 = MSSQL(2012)",
618 " 1731 = MSSQL(2014)",
619 " 200 = MySQL323",
620 " 300 = MySQL4.1/MySQL5",
621 " 3100 = Oracle H: Type (Oracle 7+)",
622 " 112 = Oracle S: Type (Oracle 11+)",
623 " 12300 = Oracle T: Type (Oracle 12+)",
624 " 8000 = Sybase ASE",
625 "",
626 "[[ HTTP, SMTP, LDAP Server ]]",
627 "",
628 " 141 = EPiServer 6.x < v4",
629 " 1441 = EPiServer 6.x > v4",
630 " 1600 = Apache $apr1$",
631 " 12600 = ColdFusion 10+",
632 " 1421 = hMailServer",
633 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
634 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
635 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
636 "",
637 "[[ Checksums ]]",
638 "",
639 " 11500 = CRC32",
640 "",
641 "[[ Operating-Systems ]]",
642 "",
643 " 3000 = LM",
644 " 1000 = NTLM",
645 " 1100 = Domain Cached Credentials (DCC), MS Cache",
646 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
647 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
648 " 1500 = descrypt, DES(Unix), Traditional DES",
649 " 12400 = BSDiCrypt, Extended DES",
650 " 500 = md5crypt $1$, MD5(Unix)",
651 " 3200 = bcrypt $2*$, Blowfish(Unix)",
652 " 7400 = sha256crypt $5$, SHA256(Unix)",
653 " 1800 = sha512crypt $6$, SHA512(Unix)",
654 " 122 = OSX v10.4",
655 " 122 = OSX v10.5",
656 " 122 = OSX v10.6",
657 " 1722 = OSX v10.7",
658 " 7100 = OSX v10.8",
659 " 7100 = OSX v10.9",
660 " 7100 = OSX v10.10",
661 " 6300 = AIX {smd5}",
662 " 6700 = AIX {ssha1}",
663 " 6400 = AIX {ssha256}",
664 " 6500 = AIX {ssha512}",
665 " 2400 = Cisco-PIX",
666 " 2410 = Cisco-ASA",
667 " 500 = Cisco-IOS $1$",
668 " 5700 = Cisco-IOS $4$",
669 " 9200 = Cisco-IOS $8$",
670 " 9300 = Cisco-IOS $9$",
671 " 22 = Juniper Netscreen/SSG (ScreenOS)",
672 " 501 = Juniper IVE",
673 " 5800 = Android PIN",
674 " 8100 = Citrix Netscaler",
675 " 8500 = RACF",
676 " 7200 = GRUB 2",
677 " 9900 = Radmin2",
678 "",
679 "[[ Enterprise Application Software (EAS) ]]",
680 "",
681 " 7700 = SAP CODVN B (BCODE)",
682 " 7800 = SAP CODVN F/G (PASSCODE)",
683 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
684 " 8600 = Lotus Notes/Domino 5",
685 " 8700 = Lotus Notes/Domino 6",
686 " 9100 = Lotus Notes/Domino 8",
687 " 133 = PeopleSoft",
688 "",
689 "[[ Archives ]]",
690 "",
691 " 11600 = 7-Zip",
692 " 12500 = RAR3-hp",
693 " 13000 = RAR5",
694 "",
695 "[[ Full-Disk encryptions (FDE) ]]",
696 "",
697 " 62XY = TrueCrypt 5.0+",
698 " X = 1 = PBKDF2-HMAC-RipeMD160",
699 " X = 2 = PBKDF2-HMAC-SHA512",
700 " X = 3 = PBKDF2-HMAC-Whirlpool",
701 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
702 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
703 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
704 " Y = 3 = XTS 1536 bit (Ciphers: All)",
705 " 8800 = Android FDE < v4.3",
706 " 12900 = Android FDE (Samsung DEK)",
707 " 12200 = eCryptfs",
708 "",
709 "[[ Documents ]]",
710 "",
711 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
712 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
713 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
714 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
715 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
716 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
717 " 9400 = MS Office 2007",
718 " 9500 = MS Office 2010",
719 " 9600 = MS Office 2013",
720 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
721 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
722 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
723 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
724 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
725 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
726 "",
727 "[[ Password Managers ]]",
728 "",
729 " 9000 = Password Safe v2",
730 " 5200 = Password Safe v3",
731 " 6800 = Lastpass",
732 " 6600 = 1Password, agilekeychain",
733 " 8200 = 1Password, cloudkeychain",
734 " 11300 = Bitcoin/Litecoin wallet.dat",
735 " 12700 = Blockchain, My Wallet",
736 "",
737 NULL
738 };
739
740 /**
741 * oclHashcat specific functions
742 */
743
744 void status_display_automat ()
745 {
746 FILE *out = stdout;
747
748 fprintf (out, "STATUS\t%u\t", data.devices_status);
749
750 /**
751 * speed new
752 */
753
754 fprintf (out, "SPEED\t");
755
756 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
757 {
758 hc_device_param_t *device_param = &data.devices_param[device_id];
759
760 if (device_param->skipped) continue;
761
762 u64 speed_cnt = 0;
763 float speed_ms = 0;
764
765 for (int i = 0; i < SPEED_CACHE; i++)
766 {
767 float rec_ms;
768
769 hc_timer_get (device_param->speed_rec[i], rec_ms);
770
771 if (rec_ms > SPEED_MAXAGE) continue;
772
773 speed_cnt += device_param->speed_cnt[i];
774 speed_ms += device_param->speed_ms[i];
775 }
776
777 speed_cnt /= SPEED_CACHE;
778 speed_ms /= SPEED_CACHE;
779
780 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
781 }
782
783 /**
784 * words_cur
785 */
786
787 u64 words_cur = get_lowest_words_done ();
788
789 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
790
791 /**
792 * counter
793 */
794
795 uint salts_left = data.salts_cnt - data.salts_done;
796
797 if (salts_left == 0) salts_left = 1;
798
799 u64 progress_total = data.words_cnt * salts_left;
800
801 u64 all_done = 0;
802 u64 all_rejected = 0;
803 u64 all_restored = 0;
804
805 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
806 {
807 if (salts_left > 1)
808 {
809 // otherwise the final cracked status shows 0/XXX progress
810
811 if (data.salts_shown[salt_pos] == 1) continue;
812 }
813
814 all_done += data.words_progress_done[salt_pos];
815 all_rejected += data.words_progress_rejected[salt_pos];
816 all_restored += data.words_progress_restored[salt_pos];
817 }
818
819 u64 progress_cur = all_restored + all_done + all_rejected;
820 u64 progress_end = progress_total;
821
822 u64 progress_skip = 0;
823
824 if (data.skip)
825 {
826 progress_skip = MIN (data.skip, data.words_base) * salts_left;
827
828 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
829 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
830 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
831 }
832
833 if (data.limit)
834 {
835 progress_end = MIN (data.limit, data.words_base) * salts_left;
836
837 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
838 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
839 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
840 }
841
842 u64 progress_cur_relative_skip = progress_cur - progress_skip;
843 u64 progress_end_relative_skip = progress_end - progress_skip;
844
845 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
846
847 /**
848 * cracks
849 */
850
851 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
852 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
853
854 /**
855 * temperature
856 */
857
858 #ifdef HAVE_HWMON
859 if (data.gpu_temp_disable == 0)
860 {
861 fprintf (out, "TEMP\t");
862
863 hc_thread_mutex_lock (mux_adl);
864
865 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
866 {
867 hc_device_param_t *device_param = &data.devices_param[device_id];
868
869 if (device_param->skipped) continue;
870
871 int temp = hm_get_temperature_with_device_id (device_id);
872
873 fprintf (out, "%d\t", temp);
874 }
875
876 hc_thread_mutex_unlock (mux_adl);
877 }
878 #endif // HAVE_HWMON
879
880 #ifdef _WIN
881 fputc ('\r', out);
882 fputc ('\n', out);
883 #endif
884
885 #ifdef _POSIX
886 fputc ('\n', out);
887 #endif
888
889 fflush (out);
890 }
891
892 void status_display ()
893 {
894 if (data.devices_status == STATUS_INIT) return;
895 if (data.devices_status == STATUS_STARTING) return;
896 if (data.devices_status == STATUS_BYPASS) return;
897
898 if (data.status_automat == 1)
899 {
900 status_display_automat ();
901
902 return;
903 }
904
905 char tmp_buf[1000];
906
907 uint tmp_len = 0;
908
909 log_info ("Session.Name...: %s", data.session);
910
911 char *status_type = strstatus (data.devices_status);
912
913 uint hash_mode = data.hash_mode;
914
915 char *hash_type = strhashtype (hash_mode); // not a bug
916
917 log_info ("Status.........: %s", status_type);
918
919 /**
920 * show rules
921 */
922
923 if (data.rp_files_cnt)
924 {
925 uint i;
926
927 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
928 {
929 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
930 }
931
932 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
933
934 log_info ("Rules.Type.....: %s", tmp_buf);
935
936 tmp_len = 0;
937 }
938
939 if (data.rp_gen)
940 {
941 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
942
943 if (data.rp_gen_seed)
944 {
945 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
946 }
947 }
948
949 /**
950 * show input
951 */
952
953 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
954 {
955 if (data.wordlist_mode == WL_MODE_FILE)
956 {
957 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
958 }
959 else if (data.wordlist_mode == WL_MODE_STDIN)
960 {
961 log_info ("Input.Mode.....: Pipe");
962 }
963 }
964 else if (data.attack_mode == ATTACK_MODE_COMBI)
965 {
966 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
967 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
968 }
969 else if (data.attack_mode == ATTACK_MODE_BF)
970 {
971 char *mask = data.mask;
972
973 if (mask != NULL)
974 {
975 uint mask_len = data.css_cnt;
976
977 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
978
979 if (mask_len > 0)
980 {
981 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
982 {
983 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
984 {
985 mask_len -= data.salts_buf[0].salt_len;
986 }
987 }
988
989 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
990
991 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
992 }
993
994 if (data.maskcnt > 1)
995 {
996 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
997
998 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
999 }
1000
1001 log_info ("Input.Mode.....: %s", tmp_buf);
1002 }
1003
1004 tmp_len = 0;
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1007 {
1008 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1009 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1010 }
1011 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1012 {
1013 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1014 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1015 }
1016
1017 if (data.digests_cnt == 1)
1018 {
1019 if (data.hash_mode == 2500)
1020 {
1021 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1022
1023 uint pke[25];
1024
1025 char *pke_ptr = (char *) pke;
1026
1027 for (uint i = 0; i < 25; i++)
1028 {
1029 pke[i] = byte_swap_32 (wpa->pke[i]);
1030 }
1031
1032 char mac1[6];
1033 char mac2[6];
1034
1035 memcpy (mac1, pke_ptr + 23, 6);
1036 memcpy (mac2, pke_ptr + 29, 6);
1037
1038 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1039 (char *) data.salts_buf[0].salt_buf,
1040 mac1[0] & 0xff,
1041 mac1[1] & 0xff,
1042 mac1[2] & 0xff,
1043 mac1[3] & 0xff,
1044 mac1[4] & 0xff,
1045 mac1[5] & 0xff,
1046 mac2[0] & 0xff,
1047 mac2[1] & 0xff,
1048 mac2[2] & 0xff,
1049 mac2[3] & 0xff,
1050 mac2[4] & 0xff,
1051 mac2[5] & 0xff);
1052 }
1053 else if (data.hash_mode == 5200)
1054 {
1055 log_info ("Hash.Target....: File (%s)", data.hashfile);
1056 }
1057 else if (data.hash_mode == 9000)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else
1066 {
1067 char out_buf[4096];
1068
1069 ascii_digest (out_buf, 0, 0);
1070
1071 // limit length
1072 if (strlen (out_buf) > 40)
1073 {
1074 out_buf[41] = '.';
1075 out_buf[42] = '.';
1076 out_buf[43] = '.';
1077 out_buf[44] = 0;
1078 }
1079
1080 log_info ("Hash.Target....: %s", out_buf);
1081 }
1082 }
1083 else
1084 {
1085 if (data.hash_mode == 3000)
1086 {
1087 char out_buf1[4096];
1088 char out_buf2[4096];
1089
1090 ascii_digest (out_buf1, 0, 0);
1091 ascii_digest (out_buf2, 0, 1);
1092
1093 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1094 }
1095 else
1096 {
1097 log_info ("Hash.Target....: File (%s)", data.hashfile);
1098 }
1099 }
1100
1101 log_info ("Hash.Type......: %s", hash_type);
1102
1103 /**
1104 * speed new
1105 */
1106
1107 u64 speed_cnt[DEVICES_MAX];
1108 float speed_ms[DEVICES_MAX];
1109
1110 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1111 {
1112 hc_device_param_t *device_param = &data.devices_param[device_id];
1113
1114 if (device_param->skipped) continue;
1115
1116 // we need to clear values (set to 0) because in case the device does
1117 // not get new candidates it idles around but speed display would
1118 // show it as working.
1119 // if we instantly set it to 0 after reading it happens that the
1120 // speed can be shown as zero if the users refreshes too fast.
1121 // therefore, we add a timestamp when a stat was recorded and if its
1122 // too old we will not use it
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 float rec_ms;
1130
1131 hc_timer_get (device_param->speed_rec[i], rec_ms);
1132
1133 if (rec_ms > SPEED_MAXAGE) continue;
1134
1135 speed_cnt[device_id] += device_param->speed_cnt[i];
1136 speed_ms[device_id] += device_param->speed_ms[i];
1137 }
1138
1139 speed_cnt[device_id] /= SPEED_CACHE;
1140 speed_ms[device_id] /= SPEED_CACHE;
1141 }
1142
1143 float hashes_all_ms = 0;
1144
1145 float hashes_dev_ms[DEVICES_MAX];
1146
1147 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1148 {
1149 hc_device_param_t *device_param = &data.devices_param[device_id];
1150
1151 if (device_param->skipped) continue;
1152
1153 hashes_dev_ms[device_id] = 0;
1154
1155 if (speed_ms[device_id])
1156 {
1157 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1158
1159 hashes_all_ms += hashes_dev_ms[device_id];
1160 }
1161 }
1162
1163 /**
1164 * timers
1165 */
1166
1167 float ms_running = 0;
1168
1169 hc_timer_get (data.timer_running, ms_running);
1170
1171 float ms_paused = data.ms_paused;
1172
1173 if (data.devices_status == STATUS_PAUSED)
1174 {
1175 float ms_paused_tmp = 0;
1176
1177 hc_timer_get (data.timer_paused, ms_paused_tmp);
1178
1179 ms_paused += ms_paused_tmp;
1180 }
1181
1182 #ifdef WIN
1183
1184 __time64_t sec_run = ms_running / 1000;
1185
1186 #else
1187
1188 time_t sec_run = ms_running / 1000;
1189
1190 #endif
1191
1192 if (sec_run)
1193 {
1194 char display_run[32];
1195
1196 struct tm tm_run;
1197
1198 struct tm *tmp;
1199
1200 #ifdef WIN
1201
1202 tmp = _gmtime64 (&sec_run);
1203
1204 #else
1205
1206 tmp = gmtime (&sec_run);
1207
1208 #endif
1209
1210 if (tmp != NULL)
1211 {
1212 memcpy (&tm_run, tmp, sizeof (struct tm));
1213
1214 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1215
1216 char *start = ctime (&data.proc_start);
1217
1218 size_t start_len = strlen (start);
1219
1220 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1221 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1222
1223 log_info ("Time.Started...: %s (%s)", start, display_run);
1224 }
1225 }
1226 else
1227 {
1228 log_info ("Time.Started...: 0 secs");
1229 }
1230
1231 /**
1232 * counters
1233 */
1234
1235 uint salts_left = data.salts_cnt - data.salts_done;
1236
1237 if (salts_left == 0) salts_left = 1;
1238
1239 u64 progress_total = data.words_cnt * salts_left;
1240
1241 u64 all_done = 0;
1242 u64 all_rejected = 0;
1243 u64 all_restored = 0;
1244
1245 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1246 {
1247 if (salts_left > 1)
1248 {
1249 // otherwise the final cracked status shows 0/XXX progress
1250
1251 if (data.salts_shown[salt_pos] == 1) continue;
1252 }
1253
1254 all_done += data.words_progress_done[salt_pos];
1255 all_rejected += data.words_progress_rejected[salt_pos];
1256 all_restored += data.words_progress_restored[salt_pos];
1257 }
1258
1259 u64 progress_cur = all_restored + all_done + all_rejected;
1260 u64 progress_end = progress_total;
1261
1262 u64 progress_skip = 0;
1263
1264 if (data.skip)
1265 {
1266 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1267
1268 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1269 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1270 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1271 }
1272
1273 if (data.limit)
1274 {
1275 progress_end = MIN (data.limit, data.words_base) * salts_left;
1276
1277 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1278 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1279 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1280 }
1281
1282 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1283 u64 progress_end_relative_skip = progress_end - progress_skip;
1284
1285 float speed_ms_real = ms_running - ms_paused;
1286 u64 speed_plains_real = all_done;
1287
1288 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1289 {
1290 if (data.devices_status != STATUS_CRACKED)
1291 {
1292 u64 words_per_ms = 0;
1293
1294 if (speed_plains_real && speed_ms_real)
1295 {
1296 words_per_ms = speed_plains_real / speed_ms_real;
1297 }
1298
1299 #ifdef WIN
1300 __time64_t sec_etc = 0;
1301 #else
1302 time_t sec_etc = 0;
1303 #endif
1304
1305 if (words_per_ms)
1306 {
1307 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1308
1309 u64 ms_left = progress_left_relative_skip / words_per_ms;
1310
1311 sec_etc = ms_left / 1000;
1312 }
1313
1314 if (sec_etc == 0)
1315 {
1316 log_info ("Time.Estimated.: 0 secs");
1317 }
1318 else if ((u64) sec_etc > ETC_MAX)
1319 {
1320 log_info ("Time.Estimated.: > 10 Years");
1321 }
1322 else
1323 {
1324 char display_etc[32];
1325
1326 struct tm tm_etc;
1327
1328 struct tm *tmp;
1329
1330 #ifdef WIN
1331
1332 tmp = _gmtime64 (&sec_etc);
1333
1334 #else
1335
1336 tmp = gmtime (&sec_etc);
1337
1338 #endif
1339
1340 if (tmp != NULL)
1341 {
1342 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1343
1344 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1345
1346 time_t now;
1347
1348 time (&now);
1349
1350 now += sec_etc;
1351
1352 char *etc = ctime (&now);
1353
1354 size_t etc_len = strlen (etc);
1355
1356 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1357 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1358
1359 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1360 }
1361 }
1362 }
1363 }
1364
1365 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1366 {
1367 hc_device_param_t *device_param = &data.devices_param[device_id];
1368
1369 if (device_param->skipped) continue;
1370
1371 char display_dev_cur[16] = { 0 };
1372
1373 strncpy (display_dev_cur, "0.00", 4);
1374
1375 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1376
1377 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1378 }
1379
1380 char display_all_cur[16] = { 0 };
1381
1382 strncpy (display_all_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1385
1386 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1387
1388 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1389 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1390
1391 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);
1392
1393 // crack-per-time
1394
1395 if (data.digests_cnt > 100)
1396 {
1397 time_t now = time (NULL);
1398
1399 int cpt_cur_min = 0;
1400 int cpt_cur_hour = 0;
1401 int cpt_cur_day = 0;
1402
1403 for (int i = 0; i < CPT_BUF; i++)
1404 {
1405 const uint cracked = data.cpt_buf[i].cracked;
1406 const time_t timestamp = data.cpt_buf[i].timestamp;
1407
1408 if ((timestamp + 60) > now)
1409 {
1410 cpt_cur_min += cracked;
1411 }
1412
1413 if ((timestamp + 3600) > now)
1414 {
1415 cpt_cur_hour += cracked;
1416 }
1417
1418 if ((timestamp + 86400) > now)
1419 {
1420 cpt_cur_day += cracked;
1421 }
1422 }
1423
1424 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1425 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1426 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1427
1428 if ((data.cpt_start + 86400) < now)
1429 {
1430 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1431 cpt_cur_min,
1432 cpt_cur_hour,
1433 cpt_cur_day,
1434 cpt_avg_min,
1435 cpt_avg_hour,
1436 cpt_avg_day);
1437 }
1438 else if ((data.cpt_start + 3600) < now)
1439 {
1440 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1441 cpt_cur_min,
1442 cpt_cur_hour,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 60) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_avg_min,
1452 cpt_avg_hour,
1453 cpt_avg_day);
1454 }
1455 else
1456 {
1457 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_avg_min,
1459 cpt_avg_hour,
1460 cpt_avg_day);
1461 }
1462 }
1463
1464 // Restore point
1465
1466 u64 restore_point = get_lowest_words_done ();
1467
1468 u64 restore_total = data.words_base;
1469
1470 float percent_restore = 0;
1471
1472 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1473
1474 if (progress_end_relative_skip)
1475 {
1476 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1477 {
1478 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1479 float percent_rejected = 0.0;
1480
1481 if (progress_cur)
1482 {
1483 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1484 }
1485
1486 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);
1487 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1488
1489 if (data.restore_disable == 0)
1490 {
1491 if (percent_finished != 1)
1492 {
1493 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1494 }
1495 }
1496 }
1497 }
1498 else
1499 {
1500 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1501 {
1502 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1503 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1504
1505 if (data.restore_disable == 0)
1506 {
1507 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1508 }
1509 }
1510 else
1511 {
1512 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1513 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1514
1515 // --restore not allowed if stdin is used -- really? why?
1516
1517 //if (data.restore_disable == 0)
1518 //{
1519 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1520 //}
1521 }
1522 }
1523
1524 #ifdef HAVE_HWMON
1525 if (data.gpu_temp_disable == 0)
1526 {
1527 hc_thread_mutex_lock (mux_adl);
1528
1529 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1530 {
1531 hc_device_param_t *device_param = &data.devices_param[device_id];
1532
1533 if (device_param->skipped) continue;
1534
1535 #define HM_STR_BUF_SIZE 255
1536
1537 if (data.hm_device[device_id].fan_supported == 1)
1538 {
1539 char utilization[HM_STR_BUF_SIZE];
1540 char temperature[HM_STR_BUF_SIZE];
1541 char fanspeed[HM_STR_BUF_SIZE];
1542
1543 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1544 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1545
1546 if (device_param->vendor_id == VENDOR_ID_AMD)
1547 {
1548 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1549 }
1550 else if (device_param->vendor_id == VENDOR_ID_NV)
1551 {
1552 #ifdef LINUX
1553 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1554 #else
1555 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1556 #endif
1557 }
1558
1559 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1560 }
1561 else
1562 {
1563 char utilization[HM_STR_BUF_SIZE];
1564 char temperature[HM_STR_BUF_SIZE];
1565
1566 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1567 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1568
1569 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1570 }
1571 }
1572
1573 hc_thread_mutex_unlock (mux_adl);
1574 }
1575 #endif // HAVE_HWMON
1576 }
1577
1578 static void status_benchmark ()
1579 {
1580 if (data.devices_status == STATUS_INIT) return;
1581 if (data.devices_status == STATUS_STARTING) return;
1582
1583 if (data.words_cnt == 0) return;
1584
1585 u64 speed_cnt[DEVICES_MAX];
1586 float speed_ms[DEVICES_MAX];
1587
1588 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1589 {
1590 hc_device_param_t *device_param = &data.devices_param[device_id];
1591
1592 if (device_param->skipped) continue;
1593
1594 speed_cnt[device_id] = 0;
1595 speed_ms[device_id] = 0;
1596
1597 for (int i = 0; i < SPEED_CACHE; i++)
1598 {
1599 speed_cnt[device_id] += device_param->speed_cnt[i];
1600 speed_ms[device_id] += device_param->speed_ms[i];
1601 }
1602
1603 speed_cnt[device_id] /= SPEED_CACHE;
1604 speed_ms[device_id] /= SPEED_CACHE;
1605 }
1606
1607 float hashes_all_ms = 0;
1608
1609 float hashes_dev_ms[DEVICES_MAX];
1610
1611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1612 {
1613 hc_device_param_t *device_param = &data.devices_param[device_id];
1614
1615 if (device_param->skipped) continue;
1616
1617 hashes_dev_ms[device_id] = 0;
1618
1619 if (speed_ms[device_id])
1620 {
1621 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1622
1623 hashes_all_ms += hashes_dev_ms[device_id];
1624 }
1625 }
1626
1627 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1628 {
1629 hc_device_param_t *device_param = &data.devices_param[device_id];
1630
1631 if (device_param->skipped) continue;
1632
1633 char display_dev_cur[16] = { 0 };
1634
1635 strncpy (display_dev_cur, "0.00", 4);
1636
1637 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1638
1639 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1640 }
1641
1642 char display_all_cur[16] = { 0 };
1643
1644 strncpy (display_all_cur, "0.00", 4);
1645
1646 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1647
1648 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1649 }
1650
1651 /**
1652 * oclHashcat -only- functions
1653 */
1654
1655 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1656 {
1657 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1658 {
1659 if (attack_kern == ATTACK_KERN_STRAIGHT)
1660 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1661 else if (attack_kern == ATTACK_KERN_COMBI)
1662 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1663 else if (attack_kern == ATTACK_KERN_BF)
1664 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1665 }
1666 else
1667 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1668 }
1669
1670 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)
1671 {
1672 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1673 {
1674 if (attack_kern == ATTACK_KERN_STRAIGHT)
1675 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1676 else if (attack_kern == ATTACK_KERN_COMBI)
1677 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1678 else if (attack_kern == ATTACK_KERN_BF)
1679 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1680 }
1681 else
1682 {
1683 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1684 }
1685 }
1686
1687 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1688 {
1689 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1690 {
1691 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1692 }
1693 else
1694 {
1695 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1696 }
1697 }
1698
1699 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)
1700 {
1701 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1702 {
1703 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1704 }
1705 else
1706 {
1707 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1708 }
1709 }
1710
1711 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1712 {
1713 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1714 }
1715
1716 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1717 {
1718 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1719 }
1720
1721 static uint convert_from_hex (char *line_buf, const uint line_len)
1722 {
1723 if (line_len & 1) return (line_len); // not in hex
1724
1725 if (data.hex_wordlist == 1)
1726 {
1727 uint i;
1728 uint j;
1729
1730 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1731 {
1732 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1733 }
1734
1735 memset (line_buf + i, 0, line_len - i);
1736
1737 return (i);
1738 }
1739 else if (line_len >= 6) // $HEX[] = 6
1740 {
1741 if (line_buf[0] != '$') return (line_len);
1742 if (line_buf[1] != 'H') return (line_len);
1743 if (line_buf[2] != 'E') return (line_len);
1744 if (line_buf[3] != 'X') return (line_len);
1745 if (line_buf[4] != '[') return (line_len);
1746 if (line_buf[line_len - 1] != ']') return (line_len);
1747
1748 uint i;
1749 uint j;
1750
1751 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1752 {
1753 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1754 }
1755
1756 memset (line_buf + i, 0, line_len - i);
1757
1758 return (i);
1759 }
1760
1761 return (line_len);
1762 }
1763
1764 static uint count_lines (FILE *fd)
1765 {
1766 uint cnt = 0;
1767
1768 char *buf = (char *) mymalloc (BUFSIZ + 1);
1769
1770 size_t nread_tmp = 0;
1771
1772 char *ptr = buf;
1773
1774 while (!feof (fd))
1775 {
1776 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1777 nread_tmp = nread;
1778
1779 if (nread < 1) continue;
1780
1781 ptr = buf;
1782
1783 do
1784 {
1785 if (*ptr++ == '\n') cnt++;
1786
1787 } while (nread--);
1788 }
1789
1790 // special case (if last line did not contain a newline char ... at the very end of the file)
1791
1792 if (nread_tmp > 3)
1793 {
1794 ptr -= 2;
1795
1796 if (*ptr != '\n')
1797 {
1798 ptr--;
1799
1800 if (*ptr != '\n') // needed ? different on windows systems?
1801 {
1802 cnt++;
1803 }
1804 }
1805 }
1806
1807 myfree (buf);
1808
1809 return cnt;
1810 }
1811
1812 static void clear_prompt ()
1813 {
1814 fputc ('\r', stdout);
1815
1816 for (size_t i = 0; i < strlen (PROMPT); i++)
1817 {
1818 fputc (' ', stdout);
1819 }
1820
1821 fputc ('\r', stdout);
1822
1823 fflush (stdout);
1824 }
1825
1826 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1827 {
1828 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1829 }
1830
1831 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1832 {
1833 char *outfile = data.outfile;
1834 uint quiet = data.quiet;
1835 FILE *pot_fp = data.pot_fp;
1836 uint loopback = data.loopback;
1837 uint debug_mode = data.debug_mode;
1838 char *debug_file = data.debug_file;
1839
1840 char debug_rule_buf[BLOCK_SIZE];
1841 int debug_rule_len = 0; // -1 error
1842 uint debug_plain_len = 0;
1843
1844 u8 debug_plain_ptr[BLOCK_SIZE];
1845
1846 // hash
1847
1848 char out_buf[4096] = { 0 };
1849
1850 ascii_digest (out_buf, salt_pos, digest_pos);
1851
1852 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1853
1854 // plain
1855
1856 plain_t plain;
1857
1858 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1859
1860 uint gidvid = plain.gidvid;
1861 uint il_pos = plain.il_pos;
1862
1863 u64 crackpos = device_param->words_off;
1864
1865 uint plain_buf[16];
1866
1867 u8 *plain_ptr = (u8 *) plain_buf;
1868 unsigned int plain_len = 0;
1869
1870 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1871 {
1872 u64 gidd = gidvid;
1873 u64 gidm = 0;
1874
1875 pw_t pw;
1876
1877 gidd_to_pw_t (device_param, gidd, &pw);
1878
1879 for (int i = 0, j = gidm; i < 16; i++, j++)
1880 {
1881 plain_buf[i] = pw.hi1[0][j];
1882 }
1883
1884 plain_len = pw.pw_len;
1885
1886 const uint off = device_param->innerloop_pos + il_pos;
1887
1888 if (debug_mode > 0)
1889 {
1890 debug_rule_len = 0;
1891
1892 // save rule
1893 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1894 {
1895 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1896
1897 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1898 }
1899
1900 // save plain
1901 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1902 {
1903 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1904
1905 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1906
1907 debug_plain_len = plain_len;
1908 }
1909 }
1910
1911 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1912
1913 crackpos += gidvid;
1914 crackpos *= data.kernel_rules_cnt;
1915 crackpos += device_param->innerloop_pos + il_pos;
1916
1917 if (plain_len > data.pw_max) plain_len = data.pw_max;
1918 }
1919 else if (data.attack_mode == ATTACK_MODE_COMBI)
1920 {
1921 u64 gidd = gidvid;
1922 u64 gidm = 0;
1923
1924 pw_t pw;
1925
1926 gidd_to_pw_t (device_param, gidd, &pw);
1927
1928 for (int i = 0, j = gidm; i < 16; i++, j++)
1929 {
1930 plain_buf[i] = pw.hi1[0][j];
1931 }
1932
1933 plain_len = pw.pw_len;
1934
1935 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1936 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1937
1938 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1939 {
1940 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1941 }
1942 else
1943 {
1944 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1945
1946 memcpy (plain_ptr, comb_buf, comb_len);
1947 }
1948
1949 plain_len += comb_len;
1950
1951 crackpos += gidvid;
1952 crackpos *= data.combs_cnt;
1953 crackpos += device_param->innerloop_pos + il_pos;
1954
1955 if (data.pw_max != PW_DICTMAX1)
1956 {
1957 if (plain_len > data.pw_max) plain_len = data.pw_max;
1958 }
1959 }
1960 else if (data.attack_mode == ATTACK_MODE_BF)
1961 {
1962 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1963 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1964
1965 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1966 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1967
1968 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1969 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1970
1971 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1972 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1973
1974 plain_len = data.css_cnt;
1975
1976 crackpos += gidvid;
1977 crackpos *= data.bfs_cnt;
1978 crackpos += device_param->innerloop_pos + il_pos;
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1981 {
1982 u64 gidd = gidvid;
1983 u64 gidm = 0;
1984
1985 pw_t pw;
1986
1987 gidd_to_pw_t (device_param, gidd, &pw);
1988
1989 for (int i = 0, j = gidm; i < 16; i++, j++)
1990 {
1991 plain_buf[i] = pw.hi1[0][j];
1992 }
1993
1994 plain_len = pw.pw_len;
1995
1996 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1997
1998 uint start = 0;
1999 uint stop = device_param->kernel_params_mp_buf32[4];
2000
2001 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2002
2003 plain_len += start + stop;
2004
2005 crackpos += gidvid;
2006 crackpos *= data.combs_cnt;
2007 crackpos += device_param->innerloop_pos + il_pos;
2008
2009 if (data.pw_max != PW_DICTMAX1)
2010 {
2011 if (plain_len > data.pw_max) plain_len = data.pw_max;
2012 }
2013 }
2014 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2015 {
2016 u64 gidd = gidvid;
2017 u64 gidm = 0;
2018
2019 pw_t pw;
2020
2021 gidd_to_pw_t (device_param, gidd, &pw);
2022
2023 for (int i = 0, j = gidm; i < 16; i++, j++)
2024 {
2025 plain_buf[i] = pw.hi1[0][j];
2026 }
2027
2028 plain_len = pw.pw_len;
2029
2030 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2031
2032 uint start = 0;
2033 uint stop = device_param->kernel_params_mp_buf32[4];
2034
2035 memmove (plain_ptr + stop, plain_ptr, plain_len);
2036
2037 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2038
2039 plain_len += start + stop;
2040
2041 crackpos += gidvid;
2042 crackpos *= data.combs_cnt;
2043 crackpos += device_param->innerloop_pos + il_pos;
2044
2045 if (data.pw_max != PW_DICTMAX1)
2046 {
2047 if (plain_len > data.pw_max) plain_len = data.pw_max;
2048 }
2049 }
2050
2051 if (data.attack_mode == ATTACK_MODE_BF)
2052 {
2053 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2054 {
2055 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2056 {
2057 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2058 {
2059 plain_len = plain_len - data.salts_buf[0].salt_len;
2060 }
2061 }
2062
2063 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2064 {
2065 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2066 {
2067 plain_ptr[j] = plain_ptr[i];
2068 }
2069
2070 plain_len = plain_len / 2;
2071 }
2072 }
2073 }
2074
2075 // if enabled, update also the potfile
2076
2077 if (pot_fp)
2078 {
2079 fprintf (pot_fp, "%s:", out_buf);
2080
2081 format_plain (pot_fp, plain_ptr, plain_len, 1);
2082
2083 fputc ('\n', pot_fp);
2084
2085 fflush (pot_fp);
2086 }
2087
2088 // outfile
2089
2090 FILE *out_fp = NULL;
2091
2092 if (outfile != NULL)
2093 {
2094 if ((out_fp = fopen (outfile, "ab")) == NULL)
2095 {
2096 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2097
2098 out_fp = stdout;
2099 }
2100 }
2101 else
2102 {
2103 out_fp = stdout;
2104
2105 if (quiet == 0) clear_prompt ();
2106 }
2107
2108 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2109
2110 if (outfile != NULL)
2111 {
2112 if (out_fp != stdout)
2113 {
2114 fclose (out_fp);
2115 }
2116 }
2117 else
2118 {
2119 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2120 {
2121 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2122 {
2123 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2124 if (quiet == 0) fflush (stdout);
2125 }
2126 }
2127 }
2128
2129 // loopback
2130
2131 if (loopback)
2132 {
2133 char *loopback_file = data.loopback_file;
2134
2135 FILE *fb_fp = NULL;
2136
2137 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2138 {
2139 format_plain (fb_fp, plain_ptr, plain_len, 1);
2140
2141 fputc ('\n', fb_fp);
2142
2143 fclose (fb_fp);
2144 }
2145 }
2146
2147 // (rule) debug mode
2148
2149 // the next check implies that:
2150 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2151 // - debug_mode > 0
2152
2153 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2154 {
2155 if (debug_rule_len < 0) debug_rule_len = 0;
2156
2157 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2158
2159 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2160
2161 if ((quiet == 0) && (debug_file == NULL))
2162 {
2163 fprintf (stdout, "%s", PROMPT);
2164 fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2170 {
2171 salt_t *salt_buf = &data.salts_buf[salt_pos];
2172
2173 int found = 0;
2174
2175 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2176
2177 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2178
2179 if (found == 1)
2180 {
2181 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2182
2183 log_info_nn ("");
2184
2185 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);
2186
2187 uint cpt_cracked = 0;
2188
2189 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2190 {
2191 uint idx = salt_buf->digests_offset + digest_pos;
2192
2193 if (data.digests_shown_tmp[idx] == 0) continue;
2194
2195 if (data.digests_shown[idx] == 1) continue;
2196
2197 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2198 {
2199 data.digests_shown[idx] = 1;
2200
2201 data.digests_done++;
2202
2203 cpt_cracked++;
2204
2205 salt_buf->digests_done++;
2206
2207 if (salt_buf->digests_done == salt_buf->digests_cnt)
2208 {
2209 data.salts_shown[salt_pos] = 1;
2210
2211 data.salts_done++;
2212 }
2213 }
2214
2215 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2216
2217 check_hash (device_param, salt_pos, digest_pos);
2218 }
2219
2220 if (cpt_cracked > 0)
2221 {
2222 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2223 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2224
2225 data.cpt_pos++;
2226
2227 data.cpt_total += cpt_cracked;
2228
2229 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2230 }
2231
2232 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2233 {
2234 // we need to reset cracked state on the device
2235 // otherwise host thinks again and again the hash was cracked
2236 // and returns invalid password each time
2237
2238 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2239
2240 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);
2241 }
2242
2243 memset (device_param->result, 0, device_param->size_results);
2244
2245 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2246 }
2247 }
2248
2249 static void save_hash ()
2250 {
2251 char *hashfile = data.hashfile;
2252
2253 char new_hashfile[256] = { 0 };
2254 char old_hashfile[256] = { 0 };
2255
2256 snprintf (new_hashfile, 255, "%s.new", hashfile);
2257 snprintf (old_hashfile, 255, "%s.old", hashfile);
2258
2259 unlink (new_hashfile);
2260
2261 char separator = data.separator;
2262
2263 FILE *fp = fopen (new_hashfile, "wb");
2264
2265 if (fp == NULL)
2266 {
2267 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2268
2269 exit (-1);
2270 }
2271
2272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2273 {
2274 if (data.salts_shown[salt_pos] == 1) continue;
2275
2276 salt_t *salt_buf = &data.salts_buf[salt_pos];
2277
2278 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2279 {
2280 uint idx = salt_buf->digests_offset + digest_pos;
2281
2282 if (data.digests_shown[idx] == 1) continue;
2283
2284 if (data.hash_mode != 2500)
2285 {
2286 char out_buf[4096] = { 0 };
2287
2288 if (data.username == 1)
2289 {
2290 user_t *user = data.hash_info[idx]->user;
2291
2292 uint i;
2293
2294 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2295
2296 fputc (separator, fp);
2297 }
2298
2299 ascii_digest (out_buf, salt_pos, digest_pos);
2300
2301 fputs (out_buf, fp);
2302
2303 log_out (fp, "");
2304 }
2305 else
2306 {
2307 hccap_t hccap;
2308
2309 to_hccap_t (&hccap, salt_pos, digest_pos);
2310
2311 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2312 }
2313 }
2314 }
2315
2316 fflush (fp);
2317
2318 fclose (fp);
2319
2320 unlink (old_hashfile);
2321
2322 if (rename (hashfile, old_hashfile) != 0)
2323 {
2324 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2325
2326 exit (-1);
2327 }
2328
2329 unlink (hashfile);
2330
2331 if (rename (new_hashfile, hashfile) != 0)
2332 {
2333 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2334
2335 exit (-1);
2336 }
2337
2338 unlink (old_hashfile);
2339 }
2340
2341 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2342 {
2343 // function called only in case kernel_blocks_all > words_left)
2344
2345 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2346
2347 kernel_blocks_div += kernel_blocks_div / 100;
2348
2349 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2350
2351 while (kernel_blocks_new < total_left)
2352 {
2353 kernel_blocks_div += kernel_blocks_div / 100;
2354
2355 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2356 }
2357
2358 if (data.quiet == 0)
2359 {
2360 clear_prompt ();
2361
2362 log_info ("");
2363
2364 log_info ("INFO: approaching final keyspace, workload adjusted");
2365
2366 log_info ("");
2367
2368 fprintf (stdout, "%s", PROMPT);
2369
2370 fflush (stdout);
2371 }
2372
2373 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2374
2375 return kernel_blocks_div;
2376 }
2377
2378 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2379 {
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint kernel_threads = device_param->kernel_threads;
2386
2387 while (num_elements % kernel_threads) num_elements++;
2388
2389 cl_kernel kernel = NULL;
2390
2391 switch (kern_run)
2392 {
2393 case KERN_RUN_1: kernel = device_param->kernel1; break;
2394 case KERN_RUN_12: kernel = device_param->kernel12; break;
2395 case KERN_RUN_2: kernel = device_param->kernel2; break;
2396 case KERN_RUN_23: kernel = device_param->kernel23; break;
2397 case KERN_RUN_3: kernel = device_param->kernel3; break;
2398 }
2399
2400 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2401 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2402 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2403 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2404 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2405 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2406 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2407 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2408 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2409 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2410 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2411
2412 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2413 {
2414 const size_t global_work_size[3] = { num_elements, 32, 1 };
2415 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2416
2417 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2418 }
2419 else
2420 {
2421 const size_t global_work_size[3] = { num_elements, 1, 1 };
2422 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2423
2424 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2425 }
2426
2427 hc_clFlush (device_param->command_queue);
2428
2429 hc_clFinish (device_param->command_queue);
2430 }
2431
2432 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2433 {
2434 uint num_elements = num;
2435
2436 switch (kern_run)
2437 {
2438 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2439 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2440 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2441 }
2442
2443 // causes problems with special threads like in bcrypt
2444 // const uint kernel_threads = device_param->kernel_threads;
2445
2446 const uint kernel_threads = KERNEL_THREADS;
2447
2448 while (num_elements % kernel_threads) num_elements++;
2449
2450 cl_kernel kernel = NULL;
2451
2452 switch (kern_run)
2453 {
2454 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2455 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2456 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2457 }
2458
2459 switch (kern_run)
2460 {
2461 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2462 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2463 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2464 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2465 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2466 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2467 break;
2468 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2469 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2470 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2471 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2472 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2473 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2474 break;
2475 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2476 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2477 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2478 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2479 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2480 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2481 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2482 break;
2483 }
2484
2485 const size_t global_work_size[3] = { num_elements, 1, 1 };
2486 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2487
2488 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2489
2490 hc_clFlush (device_param->command_queue);
2491
2492 hc_clFinish (device_param->command_queue);
2493 }
2494
2495 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2496 {
2497 uint num_elements = num;
2498
2499 uint kernel_threads = device_param->kernel_threads;
2500
2501 while (num_elements % kernel_threads) num_elements++;
2502
2503 cl_kernel kernel = device_param->kernel_tb;
2504
2505 const size_t global_work_size[3] = { num_elements, 1, 1 };
2506 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2507
2508 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2509
2510 hc_clFlush (device_param->command_queue);
2511
2512 hc_clFinish (device_param->command_queue);
2513 }
2514
2515 static void run_kernel_tm (hc_device_param_t *device_param)
2516 {
2517 const uint num_elements = 1024; // fixed
2518
2519 const uint kernel_threads = 32;
2520
2521 cl_kernel kernel = device_param->kernel_tm;
2522
2523 const size_t global_work_size[3] = { num_elements, 1, 1 };
2524 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2525
2526 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2527
2528 hc_clFlush (device_param->command_queue);
2529
2530 hc_clFinish (device_param->command_queue);
2531 }
2532
2533 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2534 {
2535 uint num_elements = num;
2536
2537 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2538 device_param->kernel_params_amp_buf32[6] = num_elements;
2539
2540 // causes problems with special threads like in bcrypt
2541 // const uint kernel_threads = device_param->kernel_threads;
2542
2543 const uint kernel_threads = KERNEL_THREADS;
2544
2545 while (num_elements % kernel_threads) num_elements++;
2546
2547 cl_kernel kernel = device_param->kernel_amp;
2548
2549 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2550 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2551
2552 const size_t global_work_size[3] = { num_elements, 1, 1 };
2553 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2554
2555 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2556
2557 hc_clFlush (device_param->command_queue);
2558
2559 hc_clFinish (device_param->command_queue);
2560 }
2561
2562 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2563 {
2564 if (device_param->vendor_id == VENDOR_ID_AMD)
2565 {
2566 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2567
2568 const cl_uchar zero = 0;
2569
2570 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2571 }
2572 else
2573 {
2574 // NOTE: clEnqueueFillBuffer () always fails with -59
2575 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2576 // How's that possible, OpenCL 1.2 support is advertised??
2577 // We need to workaround...
2578
2579 #define FILLSZ 0x100000
2580
2581 char *tmp = (char *) mymalloc (FILLSZ);
2582
2583 memset (tmp, 0, FILLSZ);
2584
2585 for (uint i = 0; i < size; i += FILLSZ)
2586 {
2587 const int left = size - i;
2588
2589 const int fillsz = MIN (FILLSZ, left);
2590
2591 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2592 }
2593
2594 myfree (tmp);
2595 }
2596 }
2597
2598 static int run_rule_engine (const int rule_len, const char *rule_buf)
2599 {
2600 if (rule_len == 0)
2601 {
2602 return 0;
2603 }
2604 else if (rule_len == 1)
2605 {
2606 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2607 }
2608
2609 return 1;
2610 }
2611
2612 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2613 {
2614 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2615 {
2616 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);
2617 }
2618 else if (data.attack_kern == ATTACK_KERN_COMBI)
2619 {
2620 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);
2621 }
2622 else if (data.attack_kern == ATTACK_KERN_BF)
2623 {
2624 const u64 off = device_param->words_off;
2625
2626 device_param->kernel_params_mp_l_buf64[3] = off;
2627
2628 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2629 }
2630 }
2631
2632 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2633 {
2634 const uint kernel_loops = data.kernel_loops;
2635
2636 // init speed timer
2637
2638 uint speed_pos = device_param->speed_pos;
2639
2640 #ifdef _POSIX
2641 if (device_param->timer_speed.tv_sec == 0)
2642 {
2643 hc_timer_set (&device_param->timer_speed);
2644 }
2645 #endif
2646
2647 #ifdef _WIN
2648 if (device_param->timer_speed.QuadPart == 0)
2649 {
2650 hc_timer_set (&device_param->timer_speed);
2651 }
2652 #endif
2653
2654 // find higest password length, this is for optimization stuff
2655
2656 uint highest_pw_len = 0;
2657
2658 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2659 {
2660 }
2661 else if (data.attack_kern == ATTACK_KERN_COMBI)
2662 {
2663 }
2664 else if (data.attack_kern == ATTACK_KERN_BF)
2665 {
2666 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2667 + device_param->kernel_params_mp_l_buf32[5];
2668 }
2669
2670 // bitslice optimization stuff
2671
2672 if (data.attack_mode == ATTACK_MODE_BF)
2673 {
2674 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2675 {
2676 run_kernel_tb (device_param, pws_cnt);
2677 }
2678 }
2679
2680 // iteration type
2681
2682 uint innerloop_step = 0;
2683 uint innerloop_cnt = 0;
2684
2685 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2686 else innerloop_step = 1;
2687
2688 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2689 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2690 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2691
2692 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2693
2694 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2695 {
2696 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2697
2698 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2699
2700 if (data.devices_status == STATUS_CRACKED) break;
2701 if (data.devices_status == STATUS_ABORTED) break;
2702 if (data.devices_status == STATUS_QUIT) break;
2703 if (data.devices_status == STATUS_BYPASS) break;
2704
2705 if (data.salts_shown[salt_pos] == 1) continue;
2706
2707 salt_t *salt_buf = &data.salts_buf[salt_pos];
2708
2709 device_param->kernel_params_buf32[24] = salt_pos;
2710 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2711 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2712
2713 FILE *combs_fp = device_param->combs_fp;
2714
2715 if (data.attack_mode == ATTACK_MODE_COMBI)
2716 {
2717 rewind (combs_fp);
2718 }
2719
2720 // innerloops
2721
2722 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2723 {
2724 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2725
2726 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2727
2728 if (data.devices_status == STATUS_CRACKED) break;
2729 if (data.devices_status == STATUS_ABORTED) break;
2730 if (data.devices_status == STATUS_QUIT) break;
2731 if (data.devices_status == STATUS_BYPASS) break;
2732
2733 uint innerloop_left = innerloop_cnt - innerloop_pos;
2734
2735 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2736
2737 device_param->innerloop_pos = innerloop_pos;
2738 device_param->innerloop_left = innerloop_left;
2739
2740 device_param->kernel_params_buf32[27] = innerloop_left;
2741
2742 if (innerloop_left == 0) continue;
2743
2744 // initialize amplifiers
2745
2746 if (data.attack_mode == ATTACK_MODE_COMBI)
2747 {
2748 char line_buf[BUFSIZ];
2749
2750 uint i = 0;
2751
2752 while (i < innerloop_left)
2753 {
2754 if (feof (combs_fp)) break;
2755
2756 int line_len = fgetl (combs_fp, line_buf);
2757
2758 if (line_len >= PW_MAX1) continue;
2759
2760 line_len = convert_from_hex (line_buf, line_len);
2761
2762 char *line_buf_new = line_buf;
2763
2764 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2765 {
2766 char rule_buf_out[BLOCK_SIZE] = { 0 };
2767
2768 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2769
2770 if (rule_len_out < 0)
2771 {
2772 data.words_progress_rejected[salt_pos] += pw_cnt;
2773
2774 continue;
2775 }
2776
2777 line_len = rule_len_out;
2778
2779 line_buf_new = rule_buf_out;
2780 }
2781
2782 line_len = MIN (line_len, PW_DICTMAX);
2783
2784 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2785
2786 memcpy (ptr, line_buf_new, line_len);
2787
2788 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2789
2790 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2791 {
2792 uppercase (ptr, line_len);
2793 }
2794
2795 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2796 {
2797 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2798 {
2799 ptr[line_len] = 0x80;
2800 }
2801
2802 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2803 {
2804 ptr[line_len] = 0x01;
2805 }
2806 }
2807
2808 device_param->combs_buf[i].pw_len = line_len;
2809
2810 i++;
2811 }
2812
2813 for (uint j = i; j < innerloop_left; j++)
2814 {
2815 device_param->combs_buf[j].i[0] = 0;
2816 device_param->combs_buf[j].i[1] = 0;
2817 device_param->combs_buf[j].i[2] = 0;
2818 device_param->combs_buf[j].i[3] = 0;
2819 device_param->combs_buf[j].i[4] = 0;
2820 device_param->combs_buf[j].i[5] = 0;
2821 device_param->combs_buf[j].i[6] = 0;
2822 device_param->combs_buf[j].i[7] = 0;
2823
2824 device_param->combs_buf[j].pw_len = 0;
2825 }
2826
2827 innerloop_left = i;
2828 }
2829 else if (data.attack_mode == ATTACK_MODE_BF)
2830 {
2831 u64 off = innerloop_pos;
2832
2833 device_param->kernel_params_mp_r_buf64[3] = off;
2834
2835 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2836 }
2837 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2838 {
2839 u64 off = innerloop_pos;
2840
2841 device_param->kernel_params_mp_buf64[3] = off;
2842
2843 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2844 }
2845 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2846 {
2847 u64 off = innerloop_pos;
2848
2849 device_param->kernel_params_mp_buf64[3] = off;
2850
2851 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2852 }
2853
2854 // copy amplifiers
2855
2856 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2857 {
2858 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);
2859 }
2860 else if (data.attack_mode == ATTACK_MODE_COMBI)
2861 {
2862 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);
2863 }
2864 else if (data.attack_mode == ATTACK_MODE_BF)
2865 {
2866 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);
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2869 {
2870 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);
2871 }
2872 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2873 {
2874 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);
2875 }
2876
2877 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2878 {
2879 if (data.attack_mode == ATTACK_MODE_BF)
2880 {
2881 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2882 {
2883 const uint size_tm = 32 * sizeof (bs_word_t);
2884
2885 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2886
2887 run_kernel_tm (device_param);
2888
2889 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2890 }
2891 }
2892
2893 if (highest_pw_len < 16)
2894 {
2895 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2896 }
2897 else if (highest_pw_len < 32)
2898 {
2899 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2900 }
2901 else
2902 {
2903 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2904 }
2905 }
2906 else
2907 {
2908 run_kernel_amp (device_param, pws_cnt);
2909
2910 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2911
2912 if (data.opts_type & OPTS_TYPE_HOOK12)
2913 {
2914 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2915 }
2916
2917 uint iter = salt_buf->salt_iter;
2918
2919 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2920 {
2921 uint loop_left = iter - loop_pos;
2922
2923 loop_left = MIN (loop_left, kernel_loops);
2924
2925 device_param->kernel_params_buf32[25] = loop_pos;
2926 device_param->kernel_params_buf32[26] = loop_left;
2927
2928 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2929
2930 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2931
2932 if (data.devices_status == STATUS_CRACKED) break;
2933 if (data.devices_status == STATUS_ABORTED) break;
2934 if (data.devices_status == STATUS_QUIT) break;
2935 }
2936
2937 if (data.opts_type & OPTS_TYPE_HOOK23)
2938 {
2939 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2940
2941 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2942
2943 // do something with data
2944
2945 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2946 }
2947
2948 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2949 }
2950
2951 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2952
2953 if (data.devices_status == STATUS_CRACKED) break;
2954 if (data.devices_status == STATUS_ABORTED) break;
2955 if (data.devices_status == STATUS_QUIT) break;
2956
2957 /**
2958 * result
2959 */
2960
2961 hc_thread_mutex_lock (mux_display);
2962
2963 check_cracked (device_param, salt_pos);
2964
2965 hc_thread_mutex_unlock (mux_display);
2966
2967 /**
2968 * progress
2969 */
2970
2971 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2972
2973 hc_thread_mutex_lock (mux_counter);
2974
2975 data.words_progress_done[salt_pos] += perf_sum_all;
2976
2977 hc_thread_mutex_unlock (mux_counter);
2978
2979 /**
2980 * speed
2981 */
2982
2983 float speed_ms;
2984
2985 hc_timer_get (device_param->timer_speed, speed_ms);
2986
2987 hc_timer_set (&device_param->timer_speed);
2988
2989 hc_thread_mutex_lock (mux_display);
2990
2991 device_param->speed_cnt[speed_pos] = perf_sum_all;
2992
2993 device_param->speed_ms[speed_pos] = speed_ms;
2994
2995 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2996
2997 hc_thread_mutex_unlock (mux_display);
2998
2999 speed_pos++;
3000
3001 if (speed_pos == SPEED_CACHE)
3002 {
3003 speed_pos = 0;
3004 }
3005 }
3006 }
3007
3008 device_param->speed_pos = speed_pos;
3009 }
3010
3011 static void load_segment (wl_data_t *wl_data, FILE *fd)
3012 {
3013 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3014
3015 wl_data->pos = 0;
3016
3017 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3018
3019 wl_data->buf[wl_data->cnt] = 0;
3020
3021 if (wl_data->cnt == 0) return;
3022
3023 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3024
3025 while (!feof (fd))
3026 {
3027 if (wl_data->cnt == wl_data->avail)
3028 {
3029 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3030
3031 wl_data->avail += wl_data->incr;
3032 }
3033
3034 const int c = fgetc (fd);
3035
3036 if (c == EOF) break;
3037
3038 wl_data->buf[wl_data->cnt] = (char) c;
3039
3040 wl_data->cnt++;
3041
3042 if (c == '\n') break;
3043 }
3044
3045 // ensure stream ends with a newline
3046
3047 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3048 {
3049 wl_data->cnt++;
3050
3051 wl_data->buf[wl_data->cnt - 1] = '\n';
3052 }
3053
3054 return;
3055 }
3056
3057 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3058 {
3059 char *ptr = buf;
3060
3061 for (u32 i = 0; i < sz; i++, ptr++)
3062 {
3063 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3064
3065 if (i == 7)
3066 {
3067 *off = i;
3068 *len = i;
3069
3070 return;
3071 }
3072
3073 if (*ptr != '\n') continue;
3074
3075 *off = i + 1;
3076
3077 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3078
3079 *len = i;
3080
3081 return;
3082 }
3083
3084 *off = sz;
3085 *len = sz;
3086 }
3087
3088 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3089 {
3090 char *ptr = buf;
3091
3092 for (u32 i = 0; i < sz; i++, ptr++)
3093 {
3094 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3095
3096 if (*ptr != '\n') continue;
3097
3098 *off = i + 1;
3099
3100 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3101
3102 *len = i;
3103
3104 return;
3105 }
3106
3107 *off = sz;
3108 *len = sz;
3109 }
3110
3111 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3112 {
3113 char *ptr = buf;
3114
3115 for (u32 i = 0; i < sz; i++, ptr++)
3116 {
3117 if (*ptr != '\n') continue;
3118
3119 *off = i + 1;
3120
3121 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3122
3123 *len = i;
3124
3125 return;
3126 }
3127
3128 *off = sz;
3129 *len = sz;
3130 }
3131
3132 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3133 {
3134 while (wl_data->pos < wl_data->cnt)
3135 {
3136 uint off;
3137 uint len;
3138
3139 char *ptr = wl_data->buf + wl_data->pos;
3140
3141 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3142
3143 wl_data->pos += off;
3144
3145 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3146 {
3147 char rule_buf_out[BLOCK_SIZE] = { 0 };
3148
3149 int rule_len_out = -1;
3150
3151 if (len < BLOCK_SIZE)
3152 {
3153 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3154 }
3155
3156 if (rule_len_out < 0)
3157 {
3158 continue;
3159 }
3160
3161 if (rule_len_out > PW_MAX)
3162 {
3163 continue;
3164 }
3165 }
3166 else
3167 {
3168 if (len > PW_MAX)
3169 {
3170 continue;
3171 }
3172 }
3173
3174 *out_buf = ptr;
3175 *out_len = len;
3176
3177 return;
3178 }
3179
3180 if (feof (fd))
3181 {
3182 fprintf (stderr, "bug!!\n");
3183
3184 return;
3185 }
3186
3187 load_segment (wl_data, fd);
3188
3189 get_next_word (wl_data, fd, out_buf, out_len);
3190 }
3191
3192 #ifdef _POSIX
3193 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3194 #endif
3195
3196 #ifdef _WIN
3197 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3198 #endif
3199 {
3200 hc_signal (NULL);
3201
3202 dictstat_t d;
3203
3204 d.cnt = 0;
3205
3206 #ifdef _POSIX
3207 fstat (fileno (fd), &d.stat);
3208 #endif
3209
3210 #ifdef _WIN
3211 _fstat64 (fileno (fd), &d.stat);
3212 #endif
3213
3214 d.stat.st_mode = 0;
3215 d.stat.st_nlink = 0;
3216 d.stat.st_uid = 0;
3217 d.stat.st_gid = 0;
3218 d.stat.st_rdev = 0;
3219 d.stat.st_atime = 0;
3220
3221 #ifdef _POSIX
3222 d.stat.st_blksize = 0;
3223 d.stat.st_blocks = 0;
3224 #endif
3225
3226 if (d.stat.st_size == 0) return 0;
3227
3228 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3229
3230 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3231 {
3232 if (d_cache)
3233 {
3234 u64 cnt = d_cache->cnt;
3235
3236 u64 keyspace = cnt;
3237
3238 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3239 {
3240 keyspace *= data.kernel_rules_cnt;
3241 }
3242 else if (data.attack_kern == ATTACK_KERN_COMBI)
3243 {
3244 keyspace *= data.combs_cnt;
3245 }
3246
3247 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);
3248 if (data.quiet == 0) log_info ("");
3249
3250 hc_signal (sigHandler_default);
3251
3252 return (keyspace);
3253 }
3254 }
3255
3256 time_t now = 0;
3257 time_t prev = 0;
3258
3259 u64 comp = 0;
3260 u64 cnt = 0;
3261 u64 cnt2 = 0;
3262
3263 while (!feof (fd))
3264 {
3265 load_segment (wl_data, fd);
3266
3267 comp += wl_data->cnt;
3268
3269 u32 i = 0;
3270
3271 while (i < wl_data->cnt)
3272 {
3273 u32 len;
3274 u32 off;
3275
3276 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3277
3278 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3279 {
3280 char rule_buf_out[BLOCK_SIZE] = { 0 };
3281
3282 int rule_len_out = -1;
3283
3284 if (len < BLOCK_SIZE)
3285 {
3286 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3287 }
3288
3289 if (rule_len_out < 0)
3290 {
3291 len = PW_MAX1;
3292 }
3293 else
3294 {
3295 len = rule_len_out;
3296 }
3297 }
3298
3299 if (len < PW_MAX1)
3300 {
3301 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3302 {
3303 cnt += data.kernel_rules_cnt;
3304 }
3305 else if (data.attack_kern == ATTACK_KERN_COMBI)
3306 {
3307 cnt += data.combs_cnt;
3308 }
3309
3310 d.cnt++;
3311 }
3312
3313 i += off;
3314
3315 cnt2++;
3316 }
3317
3318 time (&now);
3319
3320 if ((now - prev) == 0) continue;
3321
3322 float percent = (float) comp / (float) d.stat.st_size;
3323
3324 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);
3325
3326 time (&prev);
3327 }
3328
3329 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);
3330 if (data.quiet == 0) log_info ("");
3331
3332 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3333
3334 hc_signal (sigHandler_default);
3335
3336 return (cnt);
3337 }
3338
3339 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3340 {
3341 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3342 }
3343
3344 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3345 {
3346 if (data.devices_status == STATUS_BYPASS) return 0;
3347
3348 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3349
3350 uint cache_cnt = pw_cache->cnt;
3351
3352 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3353
3354 memcpy (pw_hc1, pw_buf, pw_len);
3355
3356 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3357
3358 uint pws_cnt = device_param->pws_cnt;
3359
3360 cache_cnt++;
3361
3362 pw_t *pw = device_param->pws_buf + pws_cnt;
3363
3364 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3365
3366 pw->pw_len = pw_len;
3367
3368 pws_cnt++;
3369
3370 device_param->pws_cnt = pws_cnt;
3371 device_param->pw_cnt = pws_cnt * 1;
3372
3373 cache_cnt = 0;
3374
3375 pw_cache->cnt = cache_cnt;
3376
3377 return pws_cnt;
3378 }
3379
3380 static void *thread_monitor (void *p)
3381 {
3382 uint runtime_check = 0;
3383 uint remove_check = 0;
3384 uint status_check = 0;
3385 uint restore_check = 0;
3386
3387 uint restore_left = data.restore_timer;
3388 uint remove_left = data.remove_timer;
3389 uint status_left = data.status_timer;
3390
3391 #ifdef HAVE_HWMON
3392 uint hwmon_check = 0;
3393
3394 // these variables are mainly used for fan control (AMD only)
3395
3396 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3397
3398 // temperature controller "loopback" values
3399
3400 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3401 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3402
3403 #ifdef HAVE_ADL
3404 int temp_threshold = 1; // degrees celcius
3405
3406 int fan_speed_min = 15; // in percentage
3407 int fan_speed_max = 100;
3408 #endif // HAVE_ADL
3409
3410 time_t last_temp_check_time;
3411 #endif // HAVE_HWMON
3412
3413 uint sleep_time = 1;
3414
3415 if (data.runtime)
3416 {
3417 runtime_check = 1;
3418 }
3419
3420 if (data.restore_timer)
3421 {
3422 restore_check = 1;
3423 }
3424
3425 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3426 {
3427 remove_check = 1;
3428 }
3429
3430 if (data.status == 1)
3431 {
3432 status_check = 1;
3433 }
3434
3435 #ifdef HAVE_HWMON
3436 if (data.gpu_temp_disable == 0)
3437 {
3438 time (&last_temp_check_time);
3439
3440 hwmon_check = 1;
3441 }
3442 #endif
3443
3444 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3445 {
3446 #ifdef HAVE_HWMON
3447 if (hwmon_check == 0)
3448 #endif
3449 return (p);
3450 }
3451
3452 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3453 {
3454 hc_sleep (sleep_time);
3455
3456 if (data.devices_status != STATUS_RUNNING) continue;
3457
3458 #ifdef HAVE_HWMON
3459 if (hwmon_check == 1)
3460 {
3461 hc_thread_mutex_lock (mux_adl);
3462
3463 time_t temp_check_time;
3464
3465 time (&temp_check_time);
3466
3467 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3468
3469 if (Ta == 0) Ta = 1;
3470
3471 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3472 {
3473 hc_device_param_t *device_param = &data.devices_param[device_id];
3474
3475 if (device_param->skipped) continue;
3476
3477 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3478
3479 const int temperature = hm_get_temperature_with_device_id (device_id);
3480
3481 if (temperature > (int) data.gpu_temp_abort)
3482 {
3483 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3484
3485 if (data.devices_status != STATUS_QUIT) myabort ();
3486
3487 break;
3488 }
3489
3490 #ifdef HAVE_ADL
3491 const int gpu_temp_retain = data.gpu_temp_retain;
3492
3493 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3494 {
3495 if (data.hm_device[device_id].fan_supported == 1)
3496 {
3497 int temp_cur = temperature;
3498
3499 int temp_diff_new = gpu_temp_retain - temp_cur;
3500
3501 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3502
3503 // calculate Ta value (time difference in seconds between the last check and this check)
3504
3505 last_temp_check_time = temp_check_time;
3506
3507 float Kp = 1.8;
3508 float Ki = 0.005;
3509 float Kd = 6;
3510
3511 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3512
3513 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);
3514
3515 if (abs (fan_diff_required) >= temp_threshold)
3516 {
3517 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3518
3519 int fan_speed_level = fan_speed_cur;
3520
3521 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3522
3523 int fan_speed_new = fan_speed_level - fan_diff_required;
3524
3525 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3526 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3527
3528 if (fan_speed_new != fan_speed_cur)
3529 {
3530 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3531 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3532
3533 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3534 {
3535 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3536
3537 fan_speed_chgd[device_id] = 1;
3538 }
3539
3540 temp_diff_old[device_id] = temp_diff_new;
3541 }
3542 }
3543 }
3544 }
3545 #endif // HAVE_ADL
3546 }
3547
3548 hc_thread_mutex_unlock (mux_adl);
3549 }
3550 #endif // HAVE_HWMON
3551
3552 if (restore_check == 1)
3553 {
3554 restore_left--;
3555
3556 if (restore_left == 0)
3557 {
3558 if (data.restore_disable == 0) cycle_restore ();
3559
3560 restore_left = data.restore_timer;
3561 }
3562 }
3563
3564 if ((runtime_check == 1) && (data.runtime_start > 0))
3565 {
3566 time_t runtime_cur;
3567
3568 time (&runtime_cur);
3569
3570 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3571
3572 if (runtime_left <= 0)
3573 {
3574 if (data.benchmark == 0)
3575 {
3576 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3577 }
3578
3579 if (data.devices_status != STATUS_QUIT) myabort ();
3580 }
3581 }
3582
3583 if (remove_check == 1)
3584 {
3585 remove_left--;
3586
3587 if (remove_left == 0)
3588 {
3589 if (data.digests_saved != data.digests_done)
3590 {
3591 data.digests_saved = data.digests_done;
3592
3593 save_hash ();
3594 }
3595
3596 remove_left = data.remove_timer;
3597 }
3598 }
3599
3600 if (status_check == 1)
3601 {
3602 status_left--;
3603
3604 if (status_left == 0)
3605 {
3606 hc_thread_mutex_lock (mux_display);
3607
3608 if (data.quiet == 0) clear_prompt ();
3609
3610 if (data.quiet == 0) log_info ("");
3611
3612 status_display ();
3613
3614 if (data.quiet == 0) log_info ("");
3615
3616 hc_thread_mutex_unlock (mux_display);
3617
3618 status_left = data.status_timer;
3619 }
3620 }
3621 }
3622
3623 #ifdef HAVE_HWMON
3624 myfree (fan_speed_chgd);
3625
3626 myfree (temp_diff_old);
3627 myfree (temp_diff_sum);
3628 #endif
3629
3630 p = NULL;
3631
3632 return (p);
3633 }
3634
3635 static void *thread_outfile_remove (void *p)
3636 {
3637 // some hash-dependent constants
3638 char *outfile_dir = data.outfile_check_directory;
3639 uint dgst_size = data.dgst_size;
3640 uint isSalted = data.isSalted;
3641 uint esalt_size = data.esalt_size;
3642 uint hash_mode = data.hash_mode;
3643
3644 uint outfile_check_timer = data.outfile_check_timer;
3645
3646 char separator = data.separator;
3647
3648 // some hash-dependent functions
3649 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3650 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3651
3652 // buffers
3653 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3654
3655 hash_buf.digest = mymalloc (dgst_size);
3656
3657 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3658
3659 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3660
3661 uint digest_buf[64];
3662
3663 outfile_data_t *out_info = NULL;
3664
3665 char **out_files = NULL;
3666
3667 time_t folder_mtime = 0;
3668
3669 int out_cnt = 0;
3670
3671 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3672
3673 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3674 {
3675 hc_sleep (1);
3676
3677 if (data.devices_status != STATUS_RUNNING) continue;
3678
3679 check_left--;
3680
3681 if (check_left == 0)
3682 {
3683 struct stat outfile_check_stat;
3684
3685 if (stat (outfile_dir, &outfile_check_stat) == 0)
3686 {
3687 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3688
3689 if (is_dir == 1)
3690 {
3691 if (outfile_check_stat.st_mtime > folder_mtime)
3692 {
3693 char **out_files_new = scan_directory (outfile_dir);
3694
3695 int out_cnt_new = count_dictionaries (out_files_new);
3696
3697 outfile_data_t *out_info_new = NULL;
3698
3699 if (out_cnt_new > 0)
3700 {
3701 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3702
3703 for (int i = 0; i < out_cnt_new; i++)
3704 {
3705 out_info_new[i].file_name = out_files_new[i];
3706
3707 // check if there are files that we have seen/checked before (and not changed)
3708
3709 for (int j = 0; j < out_cnt; j++)
3710 {
3711 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3712 {
3713 struct stat outfile_stat;
3714
3715 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3716 {
3717 if (outfile_stat.st_ctime == out_info[j].ctime)
3718 {
3719 out_info_new[i].ctime = out_info[j].ctime;
3720 out_info_new[i].seek = out_info[j].seek;
3721 }
3722 }
3723 }
3724 }
3725 }
3726 }
3727
3728 local_free (out_info);
3729 local_free (out_files);
3730
3731 out_files = out_files_new;
3732 out_cnt = out_cnt_new;
3733 out_info = out_info_new;
3734
3735 folder_mtime = outfile_check_stat.st_mtime;
3736 }
3737
3738 for (int j = 0; j < out_cnt; j++)
3739 {
3740 FILE *fp = fopen (out_info[j].file_name, "rb");
3741
3742 if (fp != NULL)
3743 {
3744 //hc_thread_mutex_lock (mux_display);
3745
3746 #ifdef _POSIX
3747 struct stat outfile_stat;
3748
3749 fstat (fileno (fp), &outfile_stat);
3750 #endif
3751
3752 #ifdef _WIN
3753 struct stat64 outfile_stat;
3754
3755 _fstat64 (fileno (fp), &outfile_stat);
3756 #endif
3757
3758 if (outfile_stat.st_ctime > out_info[j].ctime)
3759 {
3760 out_info[j].ctime = outfile_stat.st_ctime;
3761 out_info[j].seek = 0;
3762 }
3763
3764 fseek (fp, out_info[j].seek, SEEK_SET);
3765
3766 while (!feof (fp))
3767 {
3768 char line_buf[BUFSIZ];
3769
3770 memset (line_buf, 0, BUFSIZ);
3771
3772 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3773
3774 if (ptr == NULL) break;
3775
3776 int line_len = strlen (line_buf);
3777
3778 if (line_len <= 0) continue;
3779
3780 int iter = MAX_CUT_TRIES;
3781
3782 for (uint i = line_len - 1; i && iter; i--, line_len--)
3783 {
3784 if (line_buf[i] != separator) continue;
3785
3786 int parser_status = PARSER_OK;
3787
3788 if ((hash_mode != 2500) && (hash_mode != 6800))
3789 {
3790 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3791 }
3792
3793 uint found = 0;
3794
3795 if (parser_status == PARSER_OK)
3796 {
3797 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3798 {
3799 if (data.salts_shown[salt_pos] == 1) continue;
3800
3801 salt_t *salt_buf = &data.salts_buf[salt_pos];
3802
3803 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3804 {
3805 uint idx = salt_buf->digests_offset + digest_pos;
3806
3807 if (data.digests_shown[idx] == 1) continue;
3808
3809 uint cracked = 0;
3810
3811 if (hash_mode == 6800)
3812 {
3813 if (i == salt_buf->salt_len)
3814 {
3815 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3816 }
3817 }
3818 else if (hash_mode == 2500)
3819 {
3820 // BSSID : MAC1 : MAC2 (:plain)
3821 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3822 {
3823 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3824
3825 if (!cracked) continue;
3826
3827 // now compare MAC1 and MAC2 too, since we have this additional info
3828 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3829 char *mac2_pos = mac1_pos + 12 + 1;
3830
3831 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3832 wpa_t *wpa = &wpas[salt_pos];
3833
3834 uint pke[25];
3835
3836 char *pke_ptr = (char *) pke;
3837
3838 for (uint i = 0; i < 25; i++)
3839 {
3840 pke[i] = byte_swap_32 (wpa->pke[i]);
3841 }
3842
3843 u8 mac1[6];
3844 u8 mac2[6];
3845
3846 memcpy (mac1, pke_ptr + 23, 6);
3847 memcpy (mac2, pke_ptr + 29, 6);
3848
3849 // compare hex string(s) vs binary MAC address(es)
3850
3851 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3852 {
3853 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3854 {
3855 cracked = 0;
3856 break;
3857 }
3858 }
3859
3860 // early skip ;)
3861 if (!cracked) continue;
3862
3863 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3864 {
3865 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3866 {
3867 cracked = 0;
3868 break;
3869 }
3870 }
3871 }
3872 }
3873 else
3874 {
3875 char *digests_buf_ptr = (char *) data.digests_buf;
3876
3877 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3878
3879 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3880 }
3881
3882 if (cracked == 1)
3883 {
3884 found = 1;
3885
3886 data.digests_shown[idx] = 1;
3887
3888 data.digests_done++;
3889
3890 salt_buf->digests_done++;
3891
3892 if (salt_buf->digests_done == salt_buf->digests_cnt)
3893 {
3894 data.salts_shown[salt_pos] = 1;
3895
3896 data.salts_done++;
3897
3898 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3899 }
3900 }
3901 }
3902
3903 if (data.devices_status == STATUS_CRACKED) break;
3904 }
3905 }
3906
3907 if (found) break;
3908
3909 if (data.devices_status == STATUS_CRACKED) break;
3910
3911 iter--;
3912 }
3913
3914 if (data.devices_status == STATUS_CRACKED) break;
3915 }
3916
3917 out_info[j].seek = ftell (fp);
3918
3919 //hc_thread_mutex_unlock (mux_display);
3920
3921 fclose (fp);
3922 }
3923 }
3924 }
3925 }
3926
3927 check_left = outfile_check_timer;
3928 }
3929 }
3930
3931 if (esalt_size) local_free (hash_buf.esalt);
3932
3933 if (isSalted) local_free (hash_buf.salt);
3934
3935 local_free (hash_buf.digest);
3936
3937 local_free (out_info);
3938
3939 local_free (out_files);
3940
3941 p = NULL;
3942
3943 return (p);
3944 }
3945
3946 static uint get_work (hc_device_param_t *device_param, const u64 max)
3947 {
3948 hc_thread_mutex_lock (mux_dispatcher);
3949
3950 const u64 words_cur = data.words_cur;
3951 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3952
3953 device_param->words_off = words_cur;
3954
3955 const u64 words_left = words_base - words_cur;
3956
3957 if (data.kernel_blocks_all > words_left)
3958 {
3959 if (data.kernel_blocks_div == 0)
3960 {
3961 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3962 }
3963 }
3964
3965 if (data.kernel_blocks_div)
3966 {
3967 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3968 {
3969 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3970 const u32 kernel_power_new = kernel_blocks_new;
3971
3972 if (kernel_blocks_new < device_param->kernel_blocks)
3973 {
3974 device_param->kernel_blocks = kernel_blocks_new;
3975 device_param->kernel_power = kernel_power_new;
3976 }
3977 }
3978 }
3979
3980 const uint kernel_blocks = device_param->kernel_blocks;
3981
3982 uint work = MIN (words_left, kernel_blocks);
3983
3984 work = MIN (work, max);
3985
3986 data.words_cur += work;
3987
3988 hc_thread_mutex_unlock (mux_dispatcher);
3989
3990 return work;
3991 }
3992
3993 static void *thread_calc_stdin (void *p)
3994 {
3995 hc_device_param_t *device_param = (hc_device_param_t *) p;
3996
3997 if (device_param->skipped) return NULL;
3998
3999 const uint attack_kern = data.attack_kern;
4000
4001 const uint kernel_blocks = device_param->kernel_blocks;
4002
4003 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4004 {
4005 hc_thread_mutex_lock (mux_dispatcher);
4006
4007 if (feof (stdin) != 0)
4008 {
4009 hc_thread_mutex_unlock (mux_dispatcher);
4010
4011 break;
4012 }
4013
4014 uint words_cur = 0;
4015
4016 while (words_cur < kernel_blocks)
4017 {
4018 char buf[BUFSIZ];
4019
4020 char *line_buf = fgets (buf, sizeof (buf), stdin);
4021
4022 if (line_buf == NULL) break;
4023
4024 uint line_len = in_superchop (line_buf);
4025
4026 line_len = convert_from_hex (line_buf, line_len);
4027
4028 // post-process rule engine
4029
4030 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4031 {
4032 char rule_buf_out[BLOCK_SIZE] = { 0 };
4033
4034 int rule_len_out = -1;
4035
4036 if (line_len < BLOCK_SIZE)
4037 {
4038 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4039 }
4040
4041 if (rule_len_out < 0) continue;
4042
4043 line_buf = rule_buf_out;
4044 line_len = rule_len_out;
4045 }
4046
4047 if (line_len > PW_MAX)
4048 {
4049 continue;
4050 }
4051
4052 if (attack_kern == ATTACK_KERN_STRAIGHT)
4053 {
4054 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4055 {
4056 hc_thread_mutex_lock (mux_counter);
4057
4058 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4059 {
4060 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4061 }
4062
4063 hc_thread_mutex_unlock (mux_counter);
4064
4065 continue;
4066 }
4067 }
4068 else if (attack_kern == ATTACK_KERN_COMBI)
4069 {
4070 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4071 // since we still need to combine the plains
4072
4073 if (line_len > data.pw_max)
4074 {
4075 hc_thread_mutex_lock (mux_counter);
4076
4077 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4078 {
4079 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4080 }
4081
4082 hc_thread_mutex_unlock (mux_counter);
4083
4084 continue;
4085 }
4086 }
4087
4088 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4089
4090 words_cur++;
4091
4092 if (data.devices_status == STATUS_CRACKED) break;
4093 if (data.devices_status == STATUS_ABORTED) break;
4094 if (data.devices_status == STATUS_QUIT) break;
4095 if (data.devices_status == STATUS_BYPASS) break;
4096 }
4097
4098 hc_thread_mutex_unlock (mux_dispatcher);
4099
4100 if (data.devices_status == STATUS_CRACKED) break;
4101 if (data.devices_status == STATUS_ABORTED) break;
4102 if (data.devices_status == STATUS_QUIT) break;
4103 if (data.devices_status == STATUS_BYPASS) break;
4104
4105 // we need 2 flushing because we have two independant caches and it can occur
4106 // that one buffer is already at threshold plus for that length also exists
4107 // more data in the 2nd buffer so it would overflow
4108
4109 // flush session 1
4110
4111 {
4112 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4113 {
4114 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4115
4116 const uint pw_cache_cnt = pw_cache->cnt;
4117
4118 if (pw_cache_cnt == 0) continue;
4119
4120 pw_cache->cnt = 0;
4121
4122 uint pws_cnt = device_param->pws_cnt;
4123
4124 pw_t *pw = device_param->pws_buf + pws_cnt;
4125
4126 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4127
4128 pw->pw_len = pw_len;
4129
4130 uint pw_cnt = device_param->pw_cnt;
4131
4132 pw_cnt += pw_cache_cnt;
4133
4134 device_param->pw_cnt = pw_cnt;
4135
4136 pws_cnt++;
4137
4138 device_param->pws_cnt = pws_cnt;
4139
4140 if (pws_cnt == device_param->kernel_power_user) break;
4141 }
4142
4143 const uint pw_cnt = device_param->pw_cnt;
4144 const uint pws_cnt = device_param->pws_cnt;
4145
4146 if (pws_cnt)
4147 {
4148 run_copy (device_param, pws_cnt);
4149
4150 run_cracker (device_param, pw_cnt, pws_cnt);
4151
4152 device_param->pw_cnt = 0;
4153 device_param->pws_cnt = 0;
4154 }
4155 }
4156
4157 // flush session 2
4158
4159 {
4160 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4161 {
4162 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4163
4164 const uint pw_cache_cnt = pw_cache->cnt;
4165
4166 if (pw_cache_cnt == 0) continue;
4167
4168 pw_cache->cnt = 0;
4169
4170 uint pws_cnt = device_param->pws_cnt;
4171
4172 pw_t *pw = device_param->pws_buf + pws_cnt;
4173
4174 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4175
4176 pw->pw_len = pw_len;
4177
4178 uint pw_cnt = device_param->pw_cnt;
4179
4180 pw_cnt += pw_cache_cnt;
4181
4182 device_param->pw_cnt = pw_cnt;
4183
4184 pws_cnt++;
4185
4186 device_param->pws_cnt = pws_cnt;
4187 }
4188
4189 const uint pw_cnt = device_param->pw_cnt;
4190 const uint pws_cnt = device_param->pws_cnt;
4191
4192 if (pws_cnt)
4193 {
4194 run_copy (device_param, pws_cnt);
4195
4196 run_cracker (device_param, pw_cnt, pws_cnt);
4197
4198 device_param->pw_cnt = 0;
4199 device_param->pws_cnt = 0;
4200 }
4201 }
4202 }
4203
4204 return NULL;
4205 }
4206
4207 static void *thread_calc (void *p)
4208 {
4209 hc_device_param_t *device_param = (hc_device_param_t *) p;
4210
4211 if (device_param->skipped) return NULL;
4212
4213 const uint attack_mode = data.attack_mode;
4214 const uint attack_kern = data.attack_kern;
4215
4216 if (attack_mode == ATTACK_MODE_BF)
4217 {
4218 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4219 {
4220 const uint work = get_work (device_param, -1);
4221
4222 if (work == 0) break;
4223
4224 const u64 words_off = device_param->words_off;
4225 const u64 words_fin = words_off + work;
4226
4227 const uint pw_cnt = work;
4228 const uint pws_cnt = work;
4229
4230 device_param->pw_cnt = pw_cnt;
4231 device_param->pws_cnt = pws_cnt;
4232
4233 if (pws_cnt)
4234 {
4235 run_copy (device_param, pws_cnt);
4236
4237 run_cracker (device_param, pw_cnt, pws_cnt);
4238
4239 device_param->pw_cnt = 0;
4240 device_param->pws_cnt = 0;
4241 }
4242
4243 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4244
4245 if (data.devices_status == STATUS_CRACKED) break;
4246 if (data.devices_status == STATUS_ABORTED) break;
4247 if (data.devices_status == STATUS_QUIT) break;
4248 if (data.devices_status == STATUS_BYPASS) break;
4249
4250 device_param->words_done = words_fin;
4251 }
4252 }
4253 else
4254 {
4255 const uint segment_size = data.segment_size;
4256
4257 char *dictfile = data.dictfile;
4258
4259 if (attack_mode == ATTACK_MODE_COMBI)
4260 {
4261 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4262 {
4263 dictfile = data.dictfile2;
4264 }
4265 }
4266
4267 FILE *fd = fopen (dictfile, "rb");
4268
4269 if (fd == NULL)
4270 {
4271 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4272
4273 return NULL;
4274 }
4275
4276 if (attack_mode == ATTACK_MODE_COMBI)
4277 {
4278 const uint combs_mode = data.combs_mode;
4279
4280 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4281 {
4282 const char *dictfilec = data.dictfile2;
4283
4284 FILE *combs_fp = fopen (dictfilec, "rb");
4285
4286 if (combs_fp == NULL)
4287 {
4288 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4289
4290 fclose (fd);
4291
4292 return NULL;
4293 }
4294
4295 device_param->combs_fp = combs_fp;
4296 }
4297 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4298 {
4299 const char *dictfilec = data.dictfile;
4300
4301 FILE *combs_fp = fopen (dictfilec, "rb");
4302
4303 if (combs_fp == NULL)
4304 {
4305 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4306
4307 fclose (fd);
4308
4309 return NULL;
4310 }
4311
4312 device_param->combs_fp = combs_fp;
4313 }
4314 }
4315
4316 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4317
4318 wl_data->buf = (char *) mymalloc (segment_size);
4319 wl_data->avail = segment_size;
4320 wl_data->incr = segment_size;
4321 wl_data->cnt = 0;
4322 wl_data->pos = 0;
4323
4324 u64 words_cur = 0;
4325
4326 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4327 {
4328 u64 words_off = 0;
4329 u64 words_fin = 0;
4330
4331 u64 max = -1;
4332
4333 while (max)
4334 {
4335 const uint work = get_work (device_param, max);
4336
4337 if (work == 0) break;
4338
4339 words_off = device_param->words_off;
4340 words_fin = words_off + work;
4341
4342 char *line_buf;
4343 uint line_len;
4344
4345 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4346
4347 max = 0;
4348
4349 for ( ; words_cur < words_fin; words_cur++)
4350 {
4351 get_next_word (wl_data, fd, &line_buf, &line_len);
4352
4353 line_len = convert_from_hex (line_buf, line_len);
4354
4355 // post-process rule engine
4356
4357 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4358 {
4359 char rule_buf_out[BLOCK_SIZE] = { 0 };
4360
4361 int rule_len_out = -1;
4362
4363 if (line_len < BLOCK_SIZE)
4364 {
4365 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4366 }
4367
4368 if (rule_len_out < 0) continue;
4369
4370 line_buf = rule_buf_out;
4371 line_len = rule_len_out;
4372 }
4373
4374 if (attack_kern == ATTACK_KERN_STRAIGHT)
4375 {
4376 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4377 {
4378 max++;
4379
4380 hc_thread_mutex_lock (mux_counter);
4381
4382 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4383 {
4384 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4385 }
4386
4387 hc_thread_mutex_unlock (mux_counter);
4388
4389 continue;
4390 }
4391 }
4392 else if (attack_kern == ATTACK_KERN_COMBI)
4393 {
4394 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4395 // since we still need to combine the plains
4396
4397 if (line_len > data.pw_max)
4398 {
4399 max++;
4400
4401 hc_thread_mutex_lock (mux_counter);
4402
4403 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4404 {
4405 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4406 }
4407
4408 hc_thread_mutex_unlock (mux_counter);
4409
4410 continue;
4411 }
4412 }
4413
4414 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4415
4416 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4417
4418 if (data.devices_status == STATUS_CRACKED) break;
4419 if (data.devices_status == STATUS_ABORTED) break;
4420 if (data.devices_status == STATUS_QUIT) break;
4421 if (data.devices_status == STATUS_BYPASS) break;
4422 }
4423
4424 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4425
4426 if (data.devices_status == STATUS_CRACKED) break;
4427 if (data.devices_status == STATUS_ABORTED) break;
4428 if (data.devices_status == STATUS_QUIT) break;
4429 if (data.devices_status == STATUS_BYPASS) break;
4430 }
4431
4432 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438
4439 // we need 2 flushing because we have two independant caches and it can occur
4440 // that one buffer is already at threshold plus for that length also exists
4441 // more data in the 2nd buffer so it would overflow
4442
4443 //
4444 // flush session 1
4445 //
4446
4447 {
4448 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4449 {
4450 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4451
4452 const uint pw_cache_cnt = pw_cache->cnt;
4453
4454 if (pw_cache_cnt == 0) continue;
4455
4456 pw_cache->cnt = 0;
4457
4458 uint pws_cnt = device_param->pws_cnt;
4459
4460 pw_t *pw = device_param->pws_buf + pws_cnt;
4461
4462 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4463
4464 pw->pw_len = pw_len;
4465
4466 uint pw_cnt = device_param->pw_cnt;
4467
4468 pw_cnt += pw_cache_cnt;
4469
4470 device_param->pw_cnt = pw_cnt;
4471
4472 pws_cnt++;
4473
4474 device_param->pws_cnt = pws_cnt;
4475
4476 if (pws_cnt == device_param->kernel_power_user) break;
4477 }
4478
4479 const uint pw_cnt = device_param->pw_cnt;
4480 const uint pws_cnt = device_param->pws_cnt;
4481
4482 if (pws_cnt)
4483 {
4484 run_copy (device_param, pws_cnt);
4485
4486 run_cracker (device_param, pw_cnt, pws_cnt);
4487
4488 device_param->pw_cnt = 0;
4489 device_param->pws_cnt = 0;
4490 }
4491
4492 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4493
4494 if (data.devices_status == STATUS_CRACKED) break;
4495 if (data.devices_status == STATUS_ABORTED) break;
4496 if (data.devices_status == STATUS_QUIT) break;
4497 if (data.devices_status == STATUS_BYPASS) break;
4498 }
4499
4500 //
4501 // flush session 2
4502 //
4503
4504 {
4505 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4506 {
4507 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4508
4509 const uint pw_cache_cnt = pw_cache->cnt;
4510
4511 if (pw_cache_cnt == 0) continue;
4512
4513 pw_cache->cnt = 0;
4514
4515 uint pws_cnt = device_param->pws_cnt;
4516
4517 pw_t *pw = device_param->pws_buf + pws_cnt;
4518
4519 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4520
4521 pw->pw_len = pw_len;
4522
4523 uint pw_cnt = device_param->pw_cnt;
4524
4525 pw_cnt += pw_cache_cnt;
4526
4527 device_param->pw_cnt = pw_cnt;
4528
4529 pws_cnt++;
4530
4531 device_param->pws_cnt = pws_cnt;
4532 }
4533
4534 const uint pw_cnt = device_param->pw_cnt;
4535 const uint pws_cnt = device_param->pws_cnt;
4536
4537 if (pws_cnt)
4538 {
4539 run_copy (device_param, pws_cnt);
4540
4541 run_cracker (device_param, pw_cnt, pws_cnt);
4542
4543 device_param->pw_cnt = 0;
4544 device_param->pws_cnt = 0;
4545 }
4546
4547 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4548
4549 if (data.devices_status == STATUS_CRACKED) break;
4550 if (data.devices_status == STATUS_ABORTED) break;
4551 if (data.devices_status == STATUS_QUIT) break;
4552 if (data.devices_status == STATUS_BYPASS) break;
4553 }
4554
4555 if (words_fin == 0) break;
4556
4557 device_param->words_done = words_fin;
4558 }
4559
4560 if (attack_mode == ATTACK_MODE_COMBI)
4561 {
4562 fclose (device_param->combs_fp);
4563 }
4564
4565 free (wl_data->buf);
4566 free (wl_data);
4567
4568 fclose (fd);
4569 }
4570
4571 return NULL;
4572 }
4573
4574 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4575 {
4576 salt_t *salt_buf = &data.salts_buf[salt_pos];
4577
4578 device_param->kernel_params_buf32[24] = salt_pos;
4579 device_param->kernel_params_buf32[27] = 1;
4580 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4581 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4582 device_param->kernel_params_buf32[30] = 0;
4583 device_param->kernel_params_buf32[31] = 1;
4584
4585 char *dictfile_old = data.dictfile;
4586
4587 const char *weak_hash_check = "weak-hash-check";
4588
4589 data.dictfile = (char *) weak_hash_check;
4590
4591 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4592
4593 data.kernel_rules_buf[0].cmds[0] = 0;
4594
4595 /**
4596 * run the kernel
4597 */
4598
4599 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4600 {
4601 run_kernel (KERN_RUN_1, device_param, 1);
4602 }
4603 else
4604 {
4605 run_kernel (KERN_RUN_1, device_param, 1);
4606
4607 const uint iter = salt_buf->salt_iter;
4608
4609 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4610 {
4611 uint loop_left = iter - loop_pos;
4612
4613 loop_left = MIN (loop_left, kernel_loops);
4614
4615 device_param->kernel_params_buf32[25] = loop_pos;
4616 device_param->kernel_params_buf32[26] = loop_left;
4617
4618 run_kernel (KERN_RUN_2, device_param, 1);
4619 }
4620
4621 run_kernel (KERN_RUN_3, device_param, 1);
4622 }
4623
4624 /**
4625 * result
4626 */
4627
4628 check_cracked (device_param, salt_pos);
4629
4630 /**
4631 * cleanup
4632 */
4633
4634 device_param->kernel_params_buf32[24] = 0;
4635 device_param->kernel_params_buf32[25] = 0;
4636 device_param->kernel_params_buf32[26] = 0;
4637 device_param->kernel_params_buf32[27] = 0;
4638 device_param->kernel_params_buf32[28] = 0;
4639 device_param->kernel_params_buf32[29] = 0;
4640 device_param->kernel_params_buf32[30] = 0;
4641 device_param->kernel_params_buf32[31] = 0;
4642
4643 data.dictfile = dictfile_old;
4644
4645 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4646 }
4647
4648 // hlfmt hashcat
4649
4650 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4651 {
4652 if (data.username == 0)
4653 {
4654 *hashbuf_pos = line_buf;
4655 *hashbuf_len = line_len;
4656 }
4657 else
4658 {
4659 char *pos = line_buf;
4660 int len = line_len;
4661
4662 for (int i = 0; i < line_len; i++, pos++, len--)
4663 {
4664 if (line_buf[i] == data.separator)
4665 {
4666 pos++;
4667
4668 len--;
4669
4670 break;
4671 }
4672 }
4673
4674 *hashbuf_pos = pos;
4675 *hashbuf_len = len;
4676 }
4677 }
4678
4679 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4680 {
4681 char *pos = NULL;
4682 int len = 0;
4683
4684 int sep_cnt = 0;
4685
4686 for (int i = 0; i < line_len; i++)
4687 {
4688 if (line_buf[i] == data.separator)
4689 {
4690 sep_cnt++;
4691
4692 continue;
4693 }
4694
4695 if (sep_cnt == 0)
4696 {
4697 if (pos == NULL) pos = line_buf + i;
4698
4699 len++;
4700 }
4701 }
4702
4703 *userbuf_pos = pos;
4704 *userbuf_len = len;
4705 }
4706
4707 // hlfmt pwdump
4708
4709 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4710 {
4711 int sep_cnt = 0;
4712
4713 int sep2_len = 0;
4714 int sep3_len = 0;
4715
4716 for (int i = 0; i < line_len; i++)
4717 {
4718 if (line_buf[i] == ':')
4719 {
4720 sep_cnt++;
4721
4722 continue;
4723 }
4724
4725 if (sep_cnt == 2) sep2_len++;
4726 if (sep_cnt == 3) sep3_len++;
4727 }
4728
4729 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4730
4731 return 0;
4732 }
4733
4734 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4735 {
4736 char *pos = NULL;
4737 int len = 0;
4738
4739 int sep_cnt = 0;
4740
4741 for (int i = 0; i < line_len; i++)
4742 {
4743 if (line_buf[i] == ':')
4744 {
4745 sep_cnt++;
4746
4747 continue;
4748 }
4749
4750 if (data.hash_mode == 1000)
4751 {
4752 if (sep_cnt == 3)
4753 {
4754 if (pos == NULL) pos = line_buf + i;
4755
4756 len++;
4757 }
4758 }
4759 else if (data.hash_mode == 3000)
4760 {
4761 if (sep_cnt == 2)
4762 {
4763 if (pos == NULL) pos = line_buf + i;
4764
4765 len++;
4766 }
4767 }
4768 }
4769
4770 *hashbuf_pos = pos;
4771 *hashbuf_len = len;
4772 }
4773
4774 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4775 {
4776 char *pos = NULL;
4777 int len = 0;
4778
4779 int sep_cnt = 0;
4780
4781 for (int i = 0; i < line_len; i++)
4782 {
4783 if (line_buf[i] == ':')
4784 {
4785 sep_cnt++;
4786
4787 continue;
4788 }
4789
4790 if (sep_cnt == 0)
4791 {
4792 if (pos == NULL) pos = line_buf + i;
4793
4794 len++;
4795 }
4796 }
4797
4798 *userbuf_pos = pos;
4799 *userbuf_len = len;
4800 }
4801
4802 // hlfmt passwd
4803
4804 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4805 {
4806 int sep_cnt = 0;
4807
4808 char sep5_first = 0;
4809 char sep6_first = 0;
4810
4811 for (int i = 0; i < line_len; i++)
4812 {
4813 if (line_buf[i] == ':')
4814 {
4815 sep_cnt++;
4816
4817 continue;
4818 }
4819
4820 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4821 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4822 }
4823
4824 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4825
4826 return 0;
4827 }
4828
4829 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4830 {
4831 char *pos = NULL;
4832 int len = 0;
4833
4834 int sep_cnt = 0;
4835
4836 for (int i = 0; i < line_len; i++)
4837 {
4838 if (line_buf[i] == ':')
4839 {
4840 sep_cnt++;
4841
4842 continue;
4843 }
4844
4845 if (sep_cnt == 1)
4846 {
4847 if (pos == NULL) pos = line_buf + i;
4848
4849 len++;
4850 }
4851 }
4852
4853 *hashbuf_pos = pos;
4854 *hashbuf_len = len;
4855 }
4856
4857 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4858 {
4859 char *pos = NULL;
4860 int len = 0;
4861
4862 int sep_cnt = 0;
4863
4864 for (int i = 0; i < line_len; i++)
4865 {
4866 if (line_buf[i] == ':')
4867 {
4868 sep_cnt++;
4869
4870 continue;
4871 }
4872
4873 if (sep_cnt == 0)
4874 {
4875 if (pos == NULL) pos = line_buf + i;
4876
4877 len++;
4878 }
4879 }
4880
4881 *userbuf_pos = pos;
4882 *userbuf_len = len;
4883 }
4884
4885 // hlfmt shadow
4886
4887 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4888 {
4889 int sep_cnt = 0;
4890
4891 for (int i = 0; i < line_len; i++)
4892 {
4893 if (line_buf[i] == ':') sep_cnt++;
4894 }
4895
4896 if (sep_cnt == 8) return 1;
4897
4898 return 0;
4899 }
4900
4901 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4902 {
4903 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4904 }
4905
4906 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4907 {
4908 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4909 }
4910
4911 // hlfmt main
4912
4913 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4914 {
4915 switch (hashfile_format)
4916 {
4917 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4918 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4919 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4920 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4921 }
4922 }
4923
4924 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4925 {
4926 switch (hashfile_format)
4927 {
4928 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4929 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4930 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4931 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4932 }
4933 }
4934
4935 static uint hlfmt_detect (FILE *fp, uint max_check)
4936 {
4937 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4938
4939 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4940 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4941
4942 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4943
4944 uint num_check = 0;
4945
4946 while (!feof (fp))
4947 {
4948 char line_buf[BUFSIZ];
4949
4950 int line_len = fgetl (fp, line_buf);
4951
4952 if (line_len == 0) continue;
4953
4954 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4955 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4956 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4957
4958 if (num_check == max_check) break;
4959
4960 num_check++;
4961 }
4962
4963 uint hashlist_format = HLFMT_HASHCAT;
4964
4965 for (int i = 1; i < HLFMTS_CNT; i++)
4966 {
4967 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4968
4969 hashlist_format = i;
4970 }
4971
4972 free (formats_cnt);
4973
4974 return hashlist_format;
4975 }
4976
4977 /**
4978 * some further helper function
4979 */
4980
4981 // wrapper around mymalloc for ADL
4982
4983 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
4984 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4985 {
4986 return mymalloc (iSize);
4987 }
4988 #endif
4989
4990 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)
4991 {
4992 u64 collisions = 0;
4993
4994 const uint dgst_pos0 = data.dgst_pos0;
4995 const uint dgst_pos1 = data.dgst_pos1;
4996 const uint dgst_pos2 = data.dgst_pos2;
4997 const uint dgst_pos3 = data.dgst_pos3;
4998
4999 memset (bitmap_a, 0, bitmap_size);
5000 memset (bitmap_b, 0, bitmap_size);
5001 memset (bitmap_c, 0, bitmap_size);
5002 memset (bitmap_d, 0, bitmap_size);
5003
5004 for (uint i = 0; i < digests_cnt; i++)
5005 {
5006 uint *digest_ptr = (uint *) digests_buf_ptr;
5007
5008 digests_buf_ptr += dgst_size;
5009
5010 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5011 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5012 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5013 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5014
5015 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5016 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5017 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5018 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5019
5020 if (bitmap_a[idx0] & val0) collisions++;
5021 if (bitmap_b[idx1] & val1) collisions++;
5022 if (bitmap_c[idx2] & val2) collisions++;
5023 if (bitmap_d[idx3] & val3) collisions++;
5024
5025 bitmap_a[idx0] |= val0;
5026 bitmap_b[idx1] |= val1;
5027 bitmap_c[idx2] |= val2;
5028 bitmap_d[idx3] |= val3;
5029
5030 if (collisions >= collisions_max) return 0x7fffffff;
5031 }
5032
5033 return collisions;
5034 }
5035
5036 /**
5037 * main
5038 */
5039
5040 int main (int argc, char **argv)
5041 {
5042 /**
5043 * To help users a bit
5044 */
5045
5046 char *compute = getenv ("COMPUTE");
5047
5048 if (compute)
5049 {
5050 char display[100];
5051
5052 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5053
5054 putenv (display);
5055 }
5056 else
5057 {
5058 if (getenv ("DISPLAY") == NULL)
5059 putenv ((char *) "DISPLAY=:0");
5060 }
5061
5062 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5063 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5064
5065 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5066 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5067
5068 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5069 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5070
5071 /**
5072 * Real init
5073 */
5074
5075 memset (&data, 0, sizeof (hc_global_data_t));
5076
5077 time_t proc_start;
5078
5079 time (&proc_start);
5080
5081 data.proc_start = proc_start;
5082
5083 int myargc = argc;
5084 char **myargv = argv;
5085
5086 hc_thread_mutex_init (mux_dispatcher);
5087 hc_thread_mutex_init (mux_counter);
5088 hc_thread_mutex_init (mux_display);
5089 hc_thread_mutex_init (mux_adl);
5090
5091 /**
5092 * commandline parameters
5093 */
5094
5095 uint usage = USAGE;
5096 uint version = VERSION;
5097 uint quiet = QUIET;
5098 uint benchmark = BENCHMARK;
5099 uint benchmark_mode = BENCHMARK_MODE;
5100 uint show = SHOW;
5101 uint left = LEFT;
5102 uint username = USERNAME;
5103 uint remove = REMOVE;
5104 uint remove_timer = REMOVE_TIMER;
5105 u64 skip = SKIP;
5106 u64 limit = LIMIT;
5107 uint keyspace = KEYSPACE;
5108 uint potfile_disable = POTFILE_DISABLE;
5109 uint debug_mode = DEBUG_MODE;
5110 char *debug_file = NULL;
5111 char *induction_dir = NULL;
5112 char *outfile_check_dir = NULL;
5113 uint force = FORCE;
5114 uint runtime = RUNTIME;
5115 uint hash_mode = HASH_MODE;
5116 uint attack_mode = ATTACK_MODE;
5117 uint markov_disable = MARKOV_DISABLE;
5118 uint markov_classic = MARKOV_CLASSIC;
5119 uint markov_threshold = MARKOV_THRESHOLD;
5120 char *markov_hcstat = NULL;
5121 char *outfile = NULL;
5122 uint outfile_format = OUTFILE_FORMAT;
5123 uint outfile_autohex = OUTFILE_AUTOHEX;
5124 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5125 uint restore = RESTORE;
5126 uint restore_timer = RESTORE_TIMER;
5127 uint restore_disable = RESTORE_DISABLE;
5128 uint status = STATUS;
5129 uint status_timer = STATUS_TIMER;
5130 uint status_automat = STATUS_AUTOMAT;
5131 uint loopback = LOOPBACK;
5132 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5133 char *session = NULL;
5134 uint hex_charset = HEX_CHARSET;
5135 uint hex_salt = HEX_SALT;
5136 uint hex_wordlist = HEX_WORDLIST;
5137 uint rp_gen = RP_GEN;
5138 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5139 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5140 uint rp_gen_seed = RP_GEN_SEED;
5141 char *rule_buf_l = (char *) RULE_BUF_L;
5142 char *rule_buf_r = (char *) RULE_BUF_R;
5143 uint increment = INCREMENT;
5144 uint increment_min = INCREMENT_MIN;
5145 uint increment_max = INCREMENT_MAX;
5146 #ifndef OSX
5147 char *cpu_affinity = NULL;
5148 #endif
5149 char *opencl_devices = NULL;
5150 char *opencl_platforms = NULL;
5151 char *opencl_device_types = NULL;
5152 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5153 char *truecrypt_keyfiles = NULL;
5154 uint workload_profile = WORKLOAD_PROFILE;
5155 uint kernel_accel = KERNEL_ACCEL;
5156 uint kernel_loops = KERNEL_LOOPS;
5157 #ifdef HAVE_HWMON
5158 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5159 uint gpu_temp_abort = GPU_TEMP_ABORT;
5160 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5161 #ifdef HAVE_ADL
5162 uint powertune_enable = POWERTUNE_ENABLE;
5163 #endif
5164 #endif
5165 uint logfile_disable = LOGFILE_DISABLE;
5166 uint segment_size = SEGMENT_SIZE;
5167 uint scrypt_tmto = SCRYPT_TMTO;
5168 char separator = SEPARATOR;
5169 uint bitmap_min = BITMAP_MIN;
5170 uint bitmap_max = BITMAP_MAX;
5171 char *custom_charset_1 = NULL;
5172 char *custom_charset_2 = NULL;
5173 char *custom_charset_3 = NULL;
5174 char *custom_charset_4 = NULL;
5175
5176 #define IDX_HELP 'h'
5177 #define IDX_VERSION 'V'
5178 #define IDX_VERSION_LOWER 'v'
5179 #define IDX_QUIET 0xff02
5180 #define IDX_SHOW 0xff03
5181 #define IDX_LEFT 0xff04
5182 #define IDX_REMOVE 0xff05
5183 #define IDX_REMOVE_TIMER 0xff37
5184 #define IDX_SKIP 's'
5185 #define IDX_LIMIT 'l'
5186 #define IDX_KEYSPACE 0xff35
5187 #define IDX_POTFILE_DISABLE 0xff06
5188 #define IDX_DEBUG_MODE 0xff43
5189 #define IDX_DEBUG_FILE 0xff44
5190 #define IDX_INDUCTION_DIR 0xff46
5191 #define IDX_OUTFILE_CHECK_DIR 0xff47
5192 #define IDX_USERNAME 0xff07
5193 #define IDX_FORCE 0xff08
5194 #define IDX_RUNTIME 0xff09
5195 #define IDX_BENCHMARK 'b'
5196 #define IDX_BENCHMARK_MODE 0xff32
5197 #define IDX_HASH_MODE 'm'
5198 #define IDX_ATTACK_MODE 'a'
5199 #define IDX_RP_FILE 'r'
5200 #define IDX_RP_GEN 'g'
5201 #define IDX_RP_GEN_FUNC_MIN 0xff10
5202 #define IDX_RP_GEN_FUNC_MAX 0xff11
5203 #define IDX_RP_GEN_SEED 0xff34
5204 #define IDX_RULE_BUF_L 'j'
5205 #define IDX_RULE_BUF_R 'k'
5206 #define IDX_INCREMENT 'i'
5207 #define IDX_INCREMENT_MIN 0xff12
5208 #define IDX_INCREMENT_MAX 0xff13
5209 #define IDX_OUTFILE 'o'
5210 #define IDX_OUTFILE_FORMAT 0xff14
5211 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5212 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5213 #define IDX_RESTORE 0xff15
5214 #define IDX_RESTORE_DISABLE 0xff27
5215 #define IDX_STATUS 0xff17
5216 #define IDX_STATUS_TIMER 0xff18
5217 #define IDX_STATUS_AUTOMAT 0xff50
5218 #define IDX_LOOPBACK 0xff38
5219 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5220 #define IDX_SESSION 0xff19
5221 #define IDX_HEX_CHARSET 0xff20
5222 #define IDX_HEX_SALT 0xff21
5223 #define IDX_HEX_WORDLIST 0xff40
5224 #define IDX_MARKOV_DISABLE 0xff22
5225 #define IDX_MARKOV_CLASSIC 0xff23
5226 #define IDX_MARKOV_THRESHOLD 't'
5227 #define IDX_MARKOV_HCSTAT 0xff24
5228 #define IDX_CPU_AFFINITY 0xff25
5229 #define IDX_OPENCL_DEVICES 'd'
5230 #define IDX_OPENCL_PLATFORMS 0xff72
5231 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5232 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5233 #define IDX_WORKLOAD_PROFILE 'w'
5234 #define IDX_KERNEL_ACCEL 'n'
5235 #define IDX_KERNEL_LOOPS 'u'
5236 #define IDX_GPU_TEMP_DISABLE 0xff29
5237 #define IDX_GPU_TEMP_ABORT 0xff30
5238 #define IDX_GPU_TEMP_RETAIN 0xff31
5239 #define IDX_POWERTUNE_ENABLE 0xff41
5240 #define IDX_LOGFILE_DISABLE 0xff51
5241 #define IDX_TRUECRYPT_KEYFILES 0xff52
5242 #define IDX_SCRYPT_TMTO 0xff61
5243 #define IDX_SEGMENT_SIZE 'c'
5244 #define IDX_SEPARATOR 'p'
5245 #define IDX_BITMAP_MIN 0xff70
5246 #define IDX_BITMAP_MAX 0xff71
5247 #define IDX_CUSTOM_CHARSET_1 '1'
5248 #define IDX_CUSTOM_CHARSET_2 '2'
5249 #define IDX_CUSTOM_CHARSET_3 '3'
5250 #define IDX_CUSTOM_CHARSET_4 '4'
5251
5252 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5253
5254 struct option long_options[] =
5255 {
5256 {"help", no_argument, 0, IDX_HELP},
5257 {"version", no_argument, 0, IDX_VERSION},
5258 {"quiet", no_argument, 0, IDX_QUIET},
5259 {"show", no_argument, 0, IDX_SHOW},
5260 {"left", no_argument, 0, IDX_LEFT},
5261 {"username", no_argument, 0, IDX_USERNAME},
5262 {"remove", no_argument, 0, IDX_REMOVE},
5263 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5264 {"skip", required_argument, 0, IDX_SKIP},
5265 {"limit", required_argument, 0, IDX_LIMIT},
5266 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5267 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5268 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5269 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5270 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5271 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5272 {"force", no_argument, 0, IDX_FORCE},
5273 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5274 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5275 {"restore", no_argument, 0, IDX_RESTORE},
5276 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5277 {"status", no_argument, 0, IDX_STATUS},
5278 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5279 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5280 {"loopback", no_argument, 0, IDX_LOOPBACK},
5281 {"weak-hash-threshold",
5282 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5283 {"session", required_argument, 0, IDX_SESSION},
5284 {"runtime", required_argument, 0, IDX_RUNTIME},
5285 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5286 {"generate-rules-func-min",
5287 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5288 {"generate-rules-func-max",
5289 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5290 {"generate-rules-seed",
5291 required_argument, 0, IDX_RP_GEN_SEED},
5292 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5293 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5294 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5295 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5296 {"rules-file", required_argument, 0, IDX_RP_FILE},
5297 {"outfile", required_argument, 0, IDX_OUTFILE},
5298 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5299 {"outfile-autohex-disable",
5300 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5301 {"outfile-check-timer",
5302 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5303 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5304 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5305 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5306 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5307 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5308 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5309 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5310 #ifndef OSX
5311 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5312 #endif
5313 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5314 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5315 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5316 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5317 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5318 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5319 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5320 #ifdef HAVE_HWMON
5321 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5322 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5323 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5324 #ifdef HAVE_ADL
5325 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5326 #endif
5327 #endif // HAVE_HWMON
5328 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5329 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5330 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5331 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5332 // deprecated
5333 {"seperator", required_argument, 0, IDX_SEPARATOR},
5334 {"separator", required_argument, 0, IDX_SEPARATOR},
5335 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5336 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5337 {"increment", no_argument, 0, IDX_INCREMENT},
5338 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5339 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5340 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5341 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5342 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5343 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5344
5345 {0, 0, 0, 0}
5346 };
5347
5348 uint rp_files_cnt = 0;
5349
5350 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5351
5352 int option_index = 0;
5353 int c = -1;
5354
5355 optind = 1;
5356 optopt = 0;
5357
5358 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5359 {
5360 switch (c)
5361 {
5362 case IDX_HELP: usage = 1; break;
5363 case IDX_VERSION:
5364 case IDX_VERSION_LOWER: version = 1; break;
5365 case IDX_RESTORE: restore = 1; break;
5366 case IDX_SESSION: session = optarg; break;
5367 case IDX_SHOW: show = 1; break;
5368 case IDX_LEFT: left = 1; break;
5369 case '?': return (-1);
5370 }
5371 }
5372
5373 if (optopt != 0)
5374 {
5375 log_error ("ERROR: Invalid argument specified");
5376
5377 return (-1);
5378 }
5379
5380 /**
5381 * exit functions
5382 */
5383
5384 if (version)
5385 {
5386 log_info (VERSION_TXT);
5387
5388 return (0);
5389 }
5390
5391 if (usage)
5392 {
5393 usage_big_print (PROGNAME);
5394
5395 return (0);
5396 }
5397
5398 /**
5399 * session needs to be set, always!
5400 */
5401
5402 if (session == NULL) session = (char *) PROGNAME;
5403
5404 /**
5405 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5406 */
5407
5408 char *exec_path = get_exec_path ();
5409
5410 #ifdef LINUX
5411
5412 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5413 char *resolved_exec_path = realpath (exec_path, NULL);
5414
5415 char *install_dir = get_install_dir (resolved_exec_path);
5416 char *profile_dir = NULL;
5417 char *session_dir = NULL;
5418 char *shared_dir = NULL;
5419
5420 if (strcmp (install_dir, resolved_install_folder) == 0)
5421 {
5422 struct passwd *pw = getpwuid (getuid ());
5423
5424 const char *homedir = pw->pw_dir;
5425
5426 profile_dir = get_profile_dir (homedir);
5427 session_dir = get_session_dir (profile_dir);
5428 shared_dir = strdup (SHARED_FOLDER);
5429
5430 mkdir (profile_dir, 0700);
5431 mkdir (session_dir, 0700);
5432 }
5433 else
5434 {
5435 profile_dir = install_dir;
5436 session_dir = install_dir;
5437 shared_dir = install_dir;
5438 }
5439
5440 myfree (resolved_install_folder);
5441 myfree (resolved_exec_path);
5442
5443 #else
5444
5445 char *install_dir = get_install_dir (exec_path);
5446 char *profile_dir = install_dir;
5447 char *session_dir = install_dir;
5448 char *shared_dir = install_dir;
5449
5450 #endif
5451
5452 data.install_dir = install_dir;
5453 data.profile_dir = profile_dir;
5454 data.session_dir = session_dir;
5455 data.shared_dir = shared_dir;
5456
5457 myfree (exec_path);
5458
5459 /**
5460 * kernel cache, we need to make sure folder exist
5461 */
5462
5463 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5464
5465 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5466
5467 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5468
5469 mkdir (kernels_folder, 0700);
5470
5471 myfree (kernels_folder);
5472
5473 /**
5474 * session
5475 */
5476
5477 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5478
5479 data.session = session;
5480
5481 char *eff_restore_file = (char *) mymalloc (session_size);
5482 char *new_restore_file = (char *) mymalloc (session_size);
5483
5484 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5485 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5486
5487 data.eff_restore_file = eff_restore_file;
5488 data.new_restore_file = new_restore_file;
5489
5490 if (((show == 1) || (left == 1)) && (restore == 1))
5491 {
5492 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5493 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5494
5495 return (-1);
5496 }
5497
5498 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5499 if ((show == 1) || (left == 1))
5500 {
5501 restore_disable = 1;
5502
5503 restore = 0;
5504 }
5505
5506 data.restore_disable = restore_disable;
5507
5508 restore_data_t *rd = init_restore (argc, argv);
5509
5510 data.rd = rd;
5511
5512 /**
5513 * restore file
5514 */
5515
5516 if (restore == 1)
5517 {
5518 read_restore (eff_restore_file, rd);
5519
5520 if (rd->version_bin < RESTORE_MIN)
5521 {
5522 log_error ("ERROR: Incompatible restore-file version");
5523
5524 return (-1);
5525 }
5526
5527 myargc = rd->argc;
5528 myargv = rd->argv;
5529
5530 #ifdef _POSIX
5531 rd->pid = getpid ();
5532 #elif _WIN
5533 rd->pid = GetCurrentProcessId ();
5534 #endif
5535 }
5536
5537 uint hash_mode_chgd = 0;
5538 uint runtime_chgd = 0;
5539 uint kernel_loops_chgd = 0;
5540 uint kernel_accel_chgd = 0;
5541 uint attack_mode_chgd = 0;
5542 uint outfile_format_chgd = 0;
5543 uint rp_gen_seed_chgd = 0;
5544 uint remove_timer_chgd = 0;
5545 uint increment_min_chgd = 0;
5546 uint increment_max_chgd = 0;
5547 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5548 uint gpu_temp_retain_chgd = 0;
5549 uint gpu_temp_abort_chgd = 0;
5550 #endif
5551
5552 optind = 1;
5553 optopt = 0;
5554 option_index = 0;
5555
5556 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5557 {
5558 switch (c)
5559 {
5560 //case IDX_HELP: usage = 1; break;
5561 //case IDX_VERSION: version = 1; break;
5562 //case IDX_RESTORE: restore = 1; break;
5563 case IDX_QUIET: quiet = 1; break;
5564 //case IDX_SHOW: show = 1; break;
5565 case IDX_SHOW: break;
5566 //case IDX_LEFT: left = 1; break;
5567 case IDX_LEFT: break;
5568 case IDX_USERNAME: username = 1; break;
5569 case IDX_REMOVE: remove = 1; break;
5570 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5571 remove_timer_chgd = 1; break;
5572 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5573 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5574 case IDX_DEBUG_FILE: debug_file = optarg; break;
5575 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5576 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5577 case IDX_FORCE: force = 1; break;
5578 case IDX_SKIP: skip = atoll (optarg); break;
5579 case IDX_LIMIT: limit = atoll (optarg); break;
5580 case IDX_KEYSPACE: keyspace = 1; break;
5581 case IDX_BENCHMARK: benchmark = 1; break;
5582 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5583 case IDX_RESTORE: break;
5584 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5585 case IDX_STATUS: status = 1; break;
5586 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5587 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5588 case IDX_LOOPBACK: loopback = 1; break;
5589 case IDX_WEAK_HASH_THRESHOLD:
5590 weak_hash_threshold = atoi (optarg); break;
5591 //case IDX_SESSION: session = optarg; break;
5592 case IDX_SESSION: break;
5593 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5594 hash_mode_chgd = 1; break;
5595 case IDX_RUNTIME: runtime = atoi (optarg);
5596 runtime_chgd = 1; break;
5597 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5598 attack_mode_chgd = 1; break;
5599 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5600 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5601 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5602 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5603 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5604 rp_gen_seed_chgd = 1; break;
5605 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5606 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5607 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5608 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5609 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5610 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5611 case IDX_OUTFILE: outfile = optarg; break;
5612 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5613 outfile_format_chgd = 1; break;
5614 case IDX_OUTFILE_AUTOHEX_DISABLE:
5615 outfile_autohex = 0; break;
5616 case IDX_OUTFILE_CHECK_TIMER:
5617 outfile_check_timer = atoi (optarg); break;
5618 case IDX_HEX_CHARSET: hex_charset = 1; break;
5619 case IDX_HEX_SALT: hex_salt = 1; break;
5620 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5621 #ifndef OSX
5622 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5623 #endif
5624 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5625 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5626 case IDX_OPENCL_DEVICE_TYPES:
5627 opencl_device_types = optarg; break;
5628 case IDX_OPENCL_VECTOR_WIDTH:
5629 opencl_vector_width = atoi (optarg); break;
5630 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5631 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5632 kernel_accel_chgd = 1; break;
5633 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5634 kernel_loops_chgd = 1; break;
5635 #ifdef HAVE_HWMON
5636 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5637 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5638 #ifdef HAVE_ADL
5639 gpu_temp_abort_chgd = 1;
5640 #endif
5641 break;
5642 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5643 #ifdef HAVE_ADL
5644 gpu_temp_retain_chgd = 1;
5645 #endif
5646 break;
5647 #ifdef HAVE_ADL
5648 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5649 #endif
5650 #endif // HAVE_HWMON
5651 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5652 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5653 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5654 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5655 case IDX_SEPARATOR: separator = optarg[0]; break;
5656 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5657 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5658 case IDX_INCREMENT: increment = 1; break;
5659 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5660 increment_min_chgd = 1; break;
5661 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5662 increment_max_chgd = 1; break;
5663 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5664 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5665 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5666 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5667
5668 default:
5669 log_error ("ERROR: Invalid argument specified");
5670 return (-1);
5671 }
5672 }
5673
5674 if (optopt != 0)
5675 {
5676 log_error ("ERROR: Invalid argument specified");
5677
5678 return (-1);
5679 }
5680
5681 /**
5682 * Inform user things getting started,
5683 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5684 * - we do not need to check algorithm_pos
5685 */
5686
5687 if (quiet == 0)
5688 {
5689 if (benchmark == 1)
5690 {
5691 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5692
5693 log_info ("");
5694 }
5695 else if (restore == 1)
5696 {
5697 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5698
5699 log_info ("");
5700 }
5701 else
5702 {
5703 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5704
5705 log_info ("");
5706 }
5707 }
5708
5709 /**
5710 * sanity check
5711 */
5712
5713 if (attack_mode > 7)
5714 {
5715 log_error ("ERROR: Invalid attack-mode specified");
5716
5717 return (-1);
5718 }
5719
5720 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5721 {
5722 log_error ("ERROR: Invalid runtime specified");
5723
5724 return (-1);
5725 }
5726
5727 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5728 {
5729 log_error ("ERROR: Invalid hash-type specified");
5730
5731 return (-1);
5732 }
5733
5734 // renamed hash modes
5735
5736 if (hash_mode_chgd)
5737 {
5738 int n = -1;
5739
5740 switch (hash_mode)
5741 {
5742 case 123: n = 124;
5743 break;
5744 }
5745
5746 if (n >= 0)
5747 {
5748 log_error ("Old -m specified, use -m %d instead", n);
5749
5750 return (-1);
5751 }
5752 }
5753
5754 if (username == 1)
5755 {
5756 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5757 {
5758 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5759
5760 return (-1);
5761 }
5762 }
5763
5764 if (outfile_format > 16)
5765 {
5766 log_error ("ERROR: Invalid outfile-format specified");
5767
5768 return (-1);
5769 }
5770
5771 if (left == 1)
5772 {
5773 if (outfile_format_chgd == 1)
5774 {
5775 if (outfile_format > 1)
5776 {
5777 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5778
5779 return (-1);
5780 }
5781 }
5782 else
5783 {
5784 outfile_format = OUTFILE_FMT_HASH;
5785 }
5786 }
5787
5788 if (show == 1)
5789 {
5790 if (outfile_format_chgd == 1)
5791 {
5792 if ((outfile_format > 7) && (outfile_format < 16))
5793 {
5794 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5795
5796 return (-1);
5797 }
5798 }
5799 }
5800
5801 if (increment_min < INCREMENT_MIN)
5802 {
5803 log_error ("ERROR: Invalid increment-min specified");
5804
5805 return (-1);
5806 }
5807
5808 if (increment_max > INCREMENT_MAX)
5809 {
5810 log_error ("ERROR: Invalid increment-max specified");
5811
5812 return (-1);
5813 }
5814
5815 if (increment_min > increment_max)
5816 {
5817 log_error ("ERROR: Invalid increment-min specified");
5818
5819 return (-1);
5820 }
5821
5822 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5823 {
5824 log_error ("ERROR: increment is not allowed in attack-mode 0");
5825
5826 return (-1);
5827 }
5828
5829 if ((increment == 0) && (increment_min_chgd == 1))
5830 {
5831 log_error ("ERROR: increment-min is only supported together with increment switch");
5832
5833 return (-1);
5834 }
5835
5836 if ((increment == 0) && (increment_max_chgd == 1))
5837 {
5838 log_error ("ERROR: increment-max is only supported together with increment switch");
5839
5840 return (-1);
5841 }
5842
5843 if (rp_files_cnt && rp_gen)
5844 {
5845 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5846
5847 return (-1);
5848 }
5849
5850 if (rp_files_cnt || rp_gen)
5851 {
5852 if (attack_mode != ATTACK_MODE_STRAIGHT)
5853 {
5854 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5855
5856 return (-1);
5857 }
5858 }
5859
5860 if (rp_gen_func_min > rp_gen_func_max)
5861 {
5862 log_error ("ERROR: Invalid rp-gen-func-min specified");
5863
5864 return (-1);
5865 }
5866
5867 if (kernel_accel_chgd == 1)
5868 {
5869 if (workload_profile != WORKLOAD_PROFILE)
5870 {
5871 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5872
5873 return (-1);
5874 }
5875
5876 if (kernel_accel < 1)
5877 {
5878 log_error ("ERROR: Invalid kernel-accel specified");
5879
5880 return (-1);
5881 }
5882
5883 if (kernel_accel > 800)
5884 {
5885 log_error ("ERROR: Invalid kernel-accel specified");
5886
5887 return (-1);
5888 }
5889 }
5890
5891 if (kernel_loops_chgd == 1)
5892 {
5893 if (workload_profile != WORKLOAD_PROFILE)
5894 {
5895 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5896
5897 return (-1);
5898 }
5899
5900 if (kernel_loops < 1)
5901 {
5902 log_error ("ERROR: Invalid kernel-loops specified");
5903
5904 return (-1);
5905 }
5906
5907 if (kernel_loops > 1024)
5908 {
5909 log_error ("ERROR: Invalid kernel-loops specified");
5910
5911 return (-1);
5912 }
5913 }
5914
5915 if (benchmark == 1)
5916 {
5917 if (workload_profile != WORKLOAD_PROFILE)
5918 {
5919 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5920
5921 return (-1);
5922 }
5923 }
5924
5925 if ((workload_profile < 1) || (workload_profile > 3))
5926 {
5927 log_error ("ERROR: workload-profile %i not available", workload_profile);
5928
5929 return (-1);
5930 }
5931
5932 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5933 {
5934 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5935
5936 return (-1);
5937 }
5938
5939 if (show == 1 || left == 1)
5940 {
5941 attack_mode = ATTACK_MODE_NONE;
5942
5943 if (remove == 1)
5944 {
5945 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5946
5947 return (-1);
5948 }
5949
5950 if (potfile_disable == 1)
5951 {
5952 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5953
5954 return (-1);
5955 }
5956 }
5957
5958 uint attack_kern = ATTACK_KERN_NONE;
5959
5960 switch (attack_mode)
5961 {
5962 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5963 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5964 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5965 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5966 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5967 }
5968
5969 if (benchmark == 0)
5970 {
5971 if (keyspace == 1)
5972 {
5973 int num_additional_params = 1;
5974
5975 if (attack_kern == ATTACK_KERN_COMBI)
5976 {
5977 num_additional_params = 2;
5978 }
5979
5980 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5981
5982 if (keyspace_wordlist_specified == 0) optind--;
5983 }
5984
5985 if (attack_kern == ATTACK_KERN_NONE)
5986 {
5987 if ((optind + 1) != myargc)
5988 {
5989 usage_mini_print (myargv[0]);
5990
5991 return (-1);
5992 }
5993 }
5994 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5995 {
5996 if ((optind + 1) > myargc)
5997 {
5998 usage_mini_print (myargv[0]);
5999
6000 return (-1);
6001 }
6002 }
6003 else if (attack_kern == ATTACK_KERN_COMBI)
6004 {
6005 if ((optind + 3) != myargc)
6006 {
6007 usage_mini_print (myargv[0]);
6008
6009 return (-1);
6010 }
6011 }
6012 else if (attack_kern == ATTACK_KERN_BF)
6013 {
6014 if ((optind + 1) > myargc)
6015 {
6016 usage_mini_print (myargv[0]);
6017
6018 return (-1);
6019 }
6020 }
6021 else
6022 {
6023 usage_mini_print (myargv[0]);
6024
6025 return (-1);
6026 }
6027 }
6028 else
6029 {
6030 if (myargv[optind] != 0)
6031 {
6032 log_error ("ERROR: Invalid argument for benchmark mode specified");
6033
6034 return (-1);
6035 }
6036
6037 if (attack_mode_chgd == 1)
6038 {
6039 if (attack_mode != ATTACK_MODE_BF)
6040 {
6041 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6042
6043 return (-1);
6044 }
6045 }
6046
6047 if (benchmark_mode == 0)
6048 {
6049 // nothing to do
6050 }
6051 else if (benchmark_mode == 1)
6052 {
6053 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6054 {
6055 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6056
6057 return (-1);
6058 }
6059 }
6060 else
6061 {
6062 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6063
6064 return (-1);
6065 }
6066 }
6067
6068 if (skip != 0 && limit != 0)
6069 {
6070 limit += skip;
6071 }
6072
6073 if (keyspace == 1)
6074 {
6075 if (show == 1)
6076 {
6077 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6078
6079 return (-1);
6080 }
6081 else if (left == 1)
6082 {
6083 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6084
6085 return (-1);
6086 }
6087
6088 potfile_disable = 1;
6089
6090 restore_disable = 1;
6091
6092 restore = 0;
6093
6094 weak_hash_threshold = 0;
6095
6096 quiet = 1;
6097 }
6098
6099 if (remove_timer_chgd == 1)
6100 {
6101 if (remove == 0)
6102 {
6103 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6104
6105 return (-1);
6106 }
6107
6108 if (remove_timer < 1)
6109 {
6110 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6111
6112 return (-1);
6113 }
6114 }
6115
6116 if (loopback == 1)
6117 {
6118 if (attack_mode == ATTACK_MODE_BF)
6119 {
6120 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6121
6122 return (-1);
6123 }
6124 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6125 {
6126 if ((rp_files_cnt == 0) && (rp_gen == 0))
6127 {
6128 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6129
6130 return (-1);
6131 }
6132 }
6133 }
6134
6135 if (debug_mode > 0)
6136 {
6137 if (attack_mode != ATTACK_MODE_STRAIGHT)
6138 {
6139 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6140
6141 return (-1);
6142 }
6143
6144 if ((rp_files_cnt == 0) && (rp_gen == 0))
6145 {
6146 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6147
6148 return (-1);
6149 }
6150 }
6151
6152 if (debug_mode > 4)
6153 {
6154 log_error ("ERROR: Invalid debug-mode specified");
6155
6156 return (-1);
6157 }
6158
6159 if (debug_file != NULL)
6160 {
6161 if (debug_mode < 1)
6162 {
6163 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6164
6165 return (-1);
6166 }
6167 }
6168
6169 if (induction_dir != NULL)
6170 {
6171 if (attack_mode == ATTACK_MODE_BF)
6172 {
6173 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6174
6175 return (-1);
6176 }
6177 }
6178
6179 if (attack_mode != ATTACK_MODE_STRAIGHT)
6180 {
6181 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6182 {
6183 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6184
6185 return (-1);
6186 }
6187
6188 weak_hash_threshold = 0;
6189 }
6190
6191 /**
6192 * induction directory
6193 */
6194
6195 char *induction_directory = NULL;
6196
6197 if (attack_mode != ATTACK_MODE_BF)
6198 {
6199 if (induction_dir == NULL)
6200 {
6201 induction_directory = (char *) mymalloc (session_size);
6202
6203 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6204
6205 // create induction folder if it does not already exist
6206
6207 if (keyspace == 0)
6208 {
6209 if (rmdir (induction_directory) == -1)
6210 {
6211 if (errno == ENOENT)
6212 {
6213 // good, we can ignore
6214 }
6215 else if (errno == ENOTEMPTY)
6216 {
6217 char *induction_directory_mv = (char *) mymalloc (session_size);
6218
6219 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6220
6221 if (rename (induction_directory, induction_directory_mv) != 0)
6222 {
6223 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6224
6225 return (-1);
6226 }
6227 }
6228 else
6229 {
6230 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6231
6232 return (-1);
6233 }
6234 }
6235
6236 if (mkdir (induction_directory, 0700) == -1)
6237 {
6238 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6239
6240 return (-1);
6241 }
6242 }
6243 }
6244 else
6245 {
6246 induction_directory = induction_dir;
6247 }
6248 }
6249
6250 data.induction_directory = induction_directory;
6251
6252 /**
6253 * loopback
6254 */
6255
6256 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6257
6258 char *loopback_file = (char *) mymalloc (loopback_size);
6259
6260 /**
6261 * outfile-check directory
6262 */
6263
6264 char *outfile_check_directory = NULL;
6265
6266 if (outfile_check_dir == NULL)
6267 {
6268 outfile_check_directory = (char *) mymalloc (session_size);
6269
6270 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6271 }
6272 else
6273 {
6274 outfile_check_directory = outfile_check_dir;
6275 }
6276
6277 data.outfile_check_directory = outfile_check_directory;
6278
6279 if (keyspace == 0)
6280 {
6281 struct stat outfile_check_stat;
6282
6283 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6284 {
6285 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6286
6287 if (is_dir == 0)
6288 {
6289 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6290
6291 return (-1);
6292 }
6293 }
6294 else if (outfile_check_dir == NULL)
6295 {
6296 if (mkdir (outfile_check_directory, 0700) == -1)
6297 {
6298 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6299
6300 return (-1);
6301 }
6302 }
6303 }
6304
6305 /**
6306 * special other stuff
6307 */
6308
6309 if (hash_mode == 9710)
6310 {
6311 outfile_format = 5;
6312 outfile_format_chgd = 1;
6313 }
6314
6315 if (hash_mode == 9810)
6316 {
6317 outfile_format = 5;
6318 outfile_format_chgd = 1;
6319 }
6320
6321 if (hash_mode == 10410)
6322 {
6323 outfile_format = 5;
6324 outfile_format_chgd = 1;
6325 }
6326
6327 /**
6328 * store stuff
6329 */
6330
6331 data.hash_mode = hash_mode;
6332 data.restore = restore;
6333 data.restore_timer = restore_timer;
6334 data.restore_disable = restore_disable;
6335 data.status = status;
6336 data.status_timer = status_timer;
6337 data.status_automat = status_automat;
6338 data.loopback = loopback;
6339 data.runtime = runtime;
6340 data.remove = remove;
6341 data.remove_timer = remove_timer;
6342 data.debug_mode = debug_mode;
6343 data.debug_file = debug_file;
6344 data.username = username;
6345 data.quiet = quiet;
6346 data.outfile = outfile;
6347 data.outfile_format = outfile_format;
6348 data.outfile_autohex = outfile_autohex;
6349 data.hex_charset = hex_charset;
6350 data.hex_salt = hex_salt;
6351 data.hex_wordlist = hex_wordlist;
6352 data.separator = separator;
6353 data.rp_files = rp_files;
6354 data.rp_files_cnt = rp_files_cnt;
6355 data.rp_gen = rp_gen;
6356 data.rp_gen_seed = rp_gen_seed;
6357 data.force = force;
6358 data.benchmark = benchmark;
6359 data.skip = skip;
6360 data.limit = limit;
6361 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6362 data.powertune_enable = powertune_enable;
6363 #endif
6364 data.logfile_disable = logfile_disable;
6365 data.truecrypt_keyfiles = truecrypt_keyfiles;
6366 data.scrypt_tmto = scrypt_tmto;
6367
6368 /**
6369 * cpu affinity
6370 */
6371
6372 #ifndef OSX
6373 if (cpu_affinity)
6374 {
6375 set_cpu_affinity (cpu_affinity);
6376 }
6377 #endif
6378
6379 if (rp_gen_seed_chgd == 0)
6380 {
6381 srand (proc_start);
6382 }
6383 else
6384 {
6385 srand (rp_gen_seed);
6386 }
6387
6388 /**
6389 * logfile init
6390 */
6391
6392 if (logfile_disable == 0)
6393 {
6394 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6395
6396 char *logfile = (char *) mymalloc (logfile_size);
6397
6398 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6399
6400 data.logfile = logfile;
6401
6402 char *topid = logfile_generate_topid ();
6403
6404 data.topid = topid;
6405 }
6406
6407 // logfile_append() checks for logfile_disable internally to make it easier from here
6408
6409 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6410 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6411 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6412 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6413 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6414 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6415 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6416 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6417 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6418 #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));
6419
6420 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6421 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6422 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6423 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6424 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6425 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6426 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6427 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6428
6429 logfile_top_msg ("START");
6430
6431 logfile_top_uint (attack_mode);
6432 logfile_top_uint (attack_kern);
6433 logfile_top_uint (benchmark);
6434 logfile_top_uint (benchmark_mode);
6435 logfile_top_uint (bitmap_min);
6436 logfile_top_uint (bitmap_max);
6437 logfile_top_uint (debug_mode);
6438 logfile_top_uint (force);
6439 logfile_top_uint (kernel_accel);
6440 logfile_top_uint (kernel_loops);
6441 #ifdef HAVE_HWMON
6442 logfile_top_uint (gpu_temp_abort);
6443 logfile_top_uint (gpu_temp_disable);
6444 logfile_top_uint (gpu_temp_retain);
6445 #endif
6446 logfile_top_uint (hash_mode);
6447 logfile_top_uint (hex_charset);
6448 logfile_top_uint (hex_salt);
6449 logfile_top_uint (hex_wordlist);
6450 logfile_top_uint (increment);
6451 logfile_top_uint (increment_max);
6452 logfile_top_uint (increment_min);
6453 logfile_top_uint (keyspace);
6454 logfile_top_uint (left);
6455 logfile_top_uint (logfile_disable);
6456 logfile_top_uint (loopback);
6457 logfile_top_uint (markov_classic);
6458 logfile_top_uint (markov_disable);
6459 logfile_top_uint (markov_threshold);
6460 logfile_top_uint (outfile_autohex);
6461 logfile_top_uint (outfile_check_timer);
6462 logfile_top_uint (outfile_format);
6463 logfile_top_uint (potfile_disable);
6464 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6465 logfile_top_uint (powertune_enable);
6466 #endif
6467 logfile_top_uint (scrypt_tmto);
6468 logfile_top_uint (quiet);
6469 logfile_top_uint (remove);
6470 logfile_top_uint (remove_timer);
6471 logfile_top_uint (restore);
6472 logfile_top_uint (restore_disable);
6473 logfile_top_uint (restore_timer);
6474 logfile_top_uint (rp_gen);
6475 logfile_top_uint (rp_gen_func_max);
6476 logfile_top_uint (rp_gen_func_min);
6477 logfile_top_uint (rp_gen_seed);
6478 logfile_top_uint (runtime);
6479 logfile_top_uint (segment_size);
6480 logfile_top_uint (show);
6481 logfile_top_uint (status);
6482 logfile_top_uint (status_automat);
6483 logfile_top_uint (status_timer);
6484 logfile_top_uint (usage);
6485 logfile_top_uint (username);
6486 logfile_top_uint (version);
6487 logfile_top_uint (weak_hash_threshold);
6488 logfile_top_uint (workload_profile);
6489 logfile_top_uint64 (limit);
6490 logfile_top_uint64 (skip);
6491 logfile_top_char (separator);
6492 #ifndef OSX
6493 logfile_top_string (cpu_affinity);
6494 #endif
6495 logfile_top_string (custom_charset_1);
6496 logfile_top_string (custom_charset_2);
6497 logfile_top_string (custom_charset_3);
6498 logfile_top_string (custom_charset_4);
6499 logfile_top_string (debug_file);
6500 logfile_top_string (opencl_devices);
6501 logfile_top_string (opencl_platforms);
6502 logfile_top_string (opencl_device_types);
6503 logfile_top_uint (opencl_vector_width);
6504 logfile_top_string (induction_dir);
6505 logfile_top_string (markov_hcstat);
6506 logfile_top_string (outfile);
6507 logfile_top_string (outfile_check_dir);
6508 logfile_top_string (rule_buf_l);
6509 logfile_top_string (rule_buf_r);
6510 logfile_top_string (session);
6511 logfile_top_string (truecrypt_keyfiles);
6512
6513 /**
6514 * OpenCL platform selection
6515 */
6516
6517 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6518
6519 /**
6520 * OpenCL device selection
6521 */
6522
6523 u32 devices_filter = setup_devices_filter (opencl_devices);
6524
6525 /**
6526 * OpenCL device type selection
6527 */
6528
6529 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6530
6531 /**
6532 * benchmark
6533 */
6534
6535 if (benchmark == 1)
6536 {
6537 /**
6538 * disable useless stuff for benchmark
6539 */
6540
6541 restore_timer = 0;
6542 status_timer = 0;
6543 restore_disable = 1;
6544 potfile_disable = 1;
6545 weak_hash_threshold = 0;
6546
6547 data.restore_timer = restore_timer;
6548 data.status_timer = status_timer;
6549 data.restore_disable = restore_disable;
6550
6551 if (benchmark_mode == 1)
6552 {
6553 markov_disable = 1;
6554 }
6555
6556 /**
6557 * force attack mode to be bruteforce
6558 */
6559
6560 attack_mode = ATTACK_MODE_BF;
6561 attack_kern = ATTACK_KERN_BF;
6562
6563 if (runtime_chgd == 0)
6564 {
6565 runtime = 4;
6566
6567 if (benchmark_mode == 1) runtime = 17;
6568
6569 data.runtime = runtime;
6570 }
6571 }
6572
6573 /**
6574 * config
6575 */
6576
6577 uint hash_type = 0;
6578 uint salt_type = 0;
6579 uint attack_exec = 0;
6580 uint opts_type = 0;
6581 uint kern_type = 0;
6582 uint dgst_size = 0;
6583 uint esalt_size = 0;
6584 uint opti_type = 0;
6585 uint dgst_pos0 = -1;
6586 uint dgst_pos1 = -1;
6587 uint dgst_pos2 = -1;
6588 uint dgst_pos3 = -1;
6589
6590 int (*parse_func) (char *, uint, hash_t *);
6591 int (*sort_by_digest) (const void *, const void *);
6592
6593 uint algorithm_pos = 0;
6594 uint algorithm_max = 1;
6595
6596 uint *algorithms = default_benchmark_algorithms;
6597
6598 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6599
6600 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6601 {
6602 /*
6603 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6604 * the following algos are skipped entirely
6605 */
6606
6607 if (algorithm_pos > 0)
6608 {
6609 local_free (rd);
6610
6611 rd = init_restore (argc, argv);
6612
6613 data.rd = rd;
6614 }
6615
6616 /**
6617 * update hash_mode in case of multihash benchmark
6618 */
6619
6620 if (benchmark == 1)
6621 {
6622 if (hash_mode_chgd == 0)
6623 {
6624 hash_mode = algorithms[algorithm_pos];
6625
6626 data.hash_mode = hash_mode;
6627 }
6628
6629 quiet = 1;
6630
6631 data.quiet = quiet;
6632 }
6633
6634 switch (hash_mode)
6635 {
6636 case 0: hash_type = HASH_TYPE_MD5;
6637 salt_type = SALT_TYPE_NONE;
6638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6639 opts_type = OPTS_TYPE_PT_GENERATE_LE
6640 | OPTS_TYPE_PT_ADD80
6641 | OPTS_TYPE_PT_ADDBITS14;
6642 kern_type = KERN_TYPE_MD5;
6643 dgst_size = DGST_SIZE_4_4;
6644 parse_func = md5_parse_hash;
6645 sort_by_digest = sort_by_digest_4_4;
6646 opti_type = OPTI_TYPE_ZERO_BYTE
6647 | OPTI_TYPE_PRECOMPUTE_INIT
6648 | OPTI_TYPE_PRECOMPUTE_MERKLE
6649 | OPTI_TYPE_MEET_IN_MIDDLE
6650 | OPTI_TYPE_EARLY_SKIP
6651 | OPTI_TYPE_NOT_ITERATED
6652 | OPTI_TYPE_NOT_SALTED
6653 | OPTI_TYPE_RAW_HASH;
6654 dgst_pos0 = 0;
6655 dgst_pos1 = 3;
6656 dgst_pos2 = 2;
6657 dgst_pos3 = 1;
6658 break;
6659
6660 case 10: hash_type = HASH_TYPE_MD5;
6661 salt_type = SALT_TYPE_INTERN;
6662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6663 opts_type = OPTS_TYPE_PT_GENERATE_LE
6664 | OPTS_TYPE_ST_ADD80
6665 | OPTS_TYPE_ST_ADDBITS14;
6666 kern_type = KERN_TYPE_MD5_PWSLT;
6667 dgst_size = DGST_SIZE_4_4;
6668 parse_func = md5s_parse_hash;
6669 sort_by_digest = sort_by_digest_4_4;
6670 opti_type = OPTI_TYPE_ZERO_BYTE
6671 | OPTI_TYPE_PRECOMPUTE_INIT
6672 | OPTI_TYPE_PRECOMPUTE_MERKLE
6673 | OPTI_TYPE_MEET_IN_MIDDLE
6674 | OPTI_TYPE_EARLY_SKIP
6675 | OPTI_TYPE_NOT_ITERATED
6676 | OPTI_TYPE_APPENDED_SALT
6677 | OPTI_TYPE_RAW_HASH;
6678 dgst_pos0 = 0;
6679 dgst_pos1 = 3;
6680 dgst_pos2 = 2;
6681 dgst_pos3 = 1;
6682 break;
6683
6684 case 11: hash_type = HASH_TYPE_MD5;
6685 salt_type = SALT_TYPE_INTERN;
6686 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6687 opts_type = OPTS_TYPE_PT_GENERATE_LE
6688 | OPTS_TYPE_ST_ADD80
6689 | OPTS_TYPE_ST_ADDBITS14;
6690 kern_type = KERN_TYPE_MD5_PWSLT;
6691 dgst_size = DGST_SIZE_4_4;
6692 parse_func = joomla_parse_hash;
6693 sort_by_digest = sort_by_digest_4_4;
6694 opti_type = OPTI_TYPE_ZERO_BYTE
6695 | OPTI_TYPE_PRECOMPUTE_INIT
6696 | OPTI_TYPE_PRECOMPUTE_MERKLE
6697 | OPTI_TYPE_MEET_IN_MIDDLE
6698 | OPTI_TYPE_EARLY_SKIP
6699 | OPTI_TYPE_NOT_ITERATED
6700 | OPTI_TYPE_APPENDED_SALT
6701 | OPTI_TYPE_RAW_HASH;
6702 dgst_pos0 = 0;
6703 dgst_pos1 = 3;
6704 dgst_pos2 = 2;
6705 dgst_pos3 = 1;
6706 break;
6707
6708 case 12: hash_type = HASH_TYPE_MD5;
6709 salt_type = SALT_TYPE_INTERN;
6710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6711 opts_type = OPTS_TYPE_PT_GENERATE_LE
6712 | OPTS_TYPE_ST_ADD80
6713 | OPTS_TYPE_ST_ADDBITS14;
6714 kern_type = KERN_TYPE_MD5_PWSLT;
6715 dgst_size = DGST_SIZE_4_4;
6716 parse_func = postgresql_parse_hash;
6717 sort_by_digest = sort_by_digest_4_4;
6718 opti_type = OPTI_TYPE_ZERO_BYTE
6719 | OPTI_TYPE_PRECOMPUTE_INIT
6720 | OPTI_TYPE_PRECOMPUTE_MERKLE
6721 | OPTI_TYPE_MEET_IN_MIDDLE
6722 | OPTI_TYPE_EARLY_SKIP
6723 | OPTI_TYPE_NOT_ITERATED
6724 | OPTI_TYPE_APPENDED_SALT
6725 | OPTI_TYPE_RAW_HASH;
6726 dgst_pos0 = 0;
6727 dgst_pos1 = 3;
6728 dgst_pos2 = 2;
6729 dgst_pos3 = 1;
6730 break;
6731
6732 case 20: hash_type = HASH_TYPE_MD5;
6733 salt_type = SALT_TYPE_INTERN;
6734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6735 opts_type = OPTS_TYPE_PT_GENERATE_LE
6736 | OPTS_TYPE_PT_ADD80
6737 | OPTS_TYPE_PT_ADDBITS14;
6738 kern_type = KERN_TYPE_MD5_SLTPW;
6739 dgst_size = DGST_SIZE_4_4;
6740 parse_func = md5s_parse_hash;
6741 sort_by_digest = sort_by_digest_4_4;
6742 opti_type = OPTI_TYPE_ZERO_BYTE
6743 | OPTI_TYPE_PRECOMPUTE_INIT
6744 | OPTI_TYPE_PRECOMPUTE_MERKLE
6745 | OPTI_TYPE_EARLY_SKIP
6746 | OPTI_TYPE_NOT_ITERATED
6747 | OPTI_TYPE_PREPENDED_SALT
6748 | OPTI_TYPE_RAW_HASH;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 21: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_INTERN;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_MD5_SLTPW;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = osc_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_PRECOMPUTE_INIT
6767 | OPTI_TYPE_PRECOMPUTE_MERKLE
6768 | OPTI_TYPE_EARLY_SKIP
6769 | OPTI_TYPE_NOT_ITERATED
6770 | OPTI_TYPE_PREPENDED_SALT
6771 | OPTI_TYPE_RAW_HASH;
6772 dgst_pos0 = 0;
6773 dgst_pos1 = 3;
6774 dgst_pos2 = 2;
6775 dgst_pos3 = 1;
6776 break;
6777
6778 case 22: hash_type = HASH_TYPE_MD5;
6779 salt_type = SALT_TYPE_EMBEDDED;
6780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6781 opts_type = OPTS_TYPE_PT_GENERATE_LE
6782 | OPTS_TYPE_PT_ADD80
6783 | OPTS_TYPE_PT_ADDBITS14;
6784 kern_type = KERN_TYPE_MD5_SLTPW;
6785 dgst_size = DGST_SIZE_4_4;
6786 parse_func = netscreen_parse_hash;
6787 sort_by_digest = sort_by_digest_4_4;
6788 opti_type = OPTI_TYPE_ZERO_BYTE
6789 | OPTI_TYPE_PRECOMPUTE_INIT
6790 | OPTI_TYPE_PRECOMPUTE_MERKLE
6791 | OPTI_TYPE_EARLY_SKIP
6792 | OPTI_TYPE_NOT_ITERATED
6793 | OPTI_TYPE_PREPENDED_SALT
6794 | OPTI_TYPE_RAW_HASH;
6795 dgst_pos0 = 0;
6796 dgst_pos1 = 3;
6797 dgst_pos2 = 2;
6798 dgst_pos3 = 1;
6799 break;
6800
6801 case 23: hash_type = HASH_TYPE_MD5;
6802 salt_type = SALT_TYPE_EMBEDDED;
6803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6804 opts_type = OPTS_TYPE_PT_GENERATE_LE
6805 | OPTS_TYPE_PT_ADD80
6806 | OPTS_TYPE_PT_ADDBITS14;
6807 kern_type = KERN_TYPE_MD5_SLTPW;
6808 dgst_size = DGST_SIZE_4_4;
6809 parse_func = skype_parse_hash;
6810 sort_by_digest = sort_by_digest_4_4;
6811 opti_type = OPTI_TYPE_ZERO_BYTE
6812 | OPTI_TYPE_PRECOMPUTE_INIT
6813 | OPTI_TYPE_PRECOMPUTE_MERKLE
6814 | OPTI_TYPE_EARLY_SKIP
6815 | OPTI_TYPE_NOT_ITERATED
6816 | OPTI_TYPE_PREPENDED_SALT
6817 | OPTI_TYPE_RAW_HASH;
6818 dgst_pos0 = 0;
6819 dgst_pos1 = 3;
6820 dgst_pos2 = 2;
6821 dgst_pos3 = 1;
6822 break;
6823
6824 case 30: hash_type = HASH_TYPE_MD5;
6825 salt_type = SALT_TYPE_INTERN;
6826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6827 opts_type = OPTS_TYPE_PT_GENERATE_LE
6828 | OPTS_TYPE_PT_UNICODE
6829 | OPTS_TYPE_ST_ADD80
6830 | OPTS_TYPE_ST_ADDBITS14;
6831 kern_type = KERN_TYPE_MD5_PWUSLT;
6832 dgst_size = DGST_SIZE_4_4;
6833 parse_func = md5s_parse_hash;
6834 sort_by_digest = sort_by_digest_4_4;
6835 opti_type = OPTI_TYPE_ZERO_BYTE
6836 | OPTI_TYPE_PRECOMPUTE_INIT
6837 | OPTI_TYPE_PRECOMPUTE_MERKLE
6838 | OPTI_TYPE_MEET_IN_MIDDLE
6839 | OPTI_TYPE_EARLY_SKIP
6840 | OPTI_TYPE_NOT_ITERATED
6841 | OPTI_TYPE_APPENDED_SALT
6842 | OPTI_TYPE_RAW_HASH;
6843 dgst_pos0 = 0;
6844 dgst_pos1 = 3;
6845 dgst_pos2 = 2;
6846 dgst_pos3 = 1;
6847 break;
6848
6849 case 40: hash_type = HASH_TYPE_MD5;
6850 salt_type = SALT_TYPE_INTERN;
6851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6852 opts_type = OPTS_TYPE_PT_GENERATE_LE
6853 | OPTS_TYPE_PT_ADD80
6854 | OPTS_TYPE_PT_ADDBITS14
6855 | OPTS_TYPE_PT_UNICODE;
6856 kern_type = KERN_TYPE_MD5_SLTPWU;
6857 dgst_size = DGST_SIZE_4_4;
6858 parse_func = md5s_parse_hash;
6859 sort_by_digest = sort_by_digest_4_4;
6860 opti_type = OPTI_TYPE_ZERO_BYTE
6861 | OPTI_TYPE_PRECOMPUTE_INIT
6862 | OPTI_TYPE_PRECOMPUTE_MERKLE
6863 | OPTI_TYPE_EARLY_SKIP
6864 | OPTI_TYPE_NOT_ITERATED
6865 | OPTI_TYPE_PREPENDED_SALT
6866 | OPTI_TYPE_RAW_HASH;
6867 dgst_pos0 = 0;
6868 dgst_pos1 = 3;
6869 dgst_pos2 = 2;
6870 dgst_pos3 = 1;
6871 break;
6872
6873 case 50: hash_type = HASH_TYPE_MD5;
6874 salt_type = SALT_TYPE_INTERN;
6875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6876 opts_type = OPTS_TYPE_PT_GENERATE_LE
6877 | OPTS_TYPE_ST_ADD80
6878 | OPTS_TYPE_ST_ADDBITS14;
6879 kern_type = KERN_TYPE_HMACMD5_PW;
6880 dgst_size = DGST_SIZE_4_4;
6881 parse_func = hmacmd5_parse_hash;
6882 sort_by_digest = sort_by_digest_4_4;
6883 opti_type = OPTI_TYPE_ZERO_BYTE
6884 | OPTI_TYPE_NOT_ITERATED;
6885 dgst_pos0 = 0;
6886 dgst_pos1 = 3;
6887 dgst_pos2 = 2;
6888 dgst_pos3 = 1;
6889 break;
6890
6891 case 60: hash_type = HASH_TYPE_MD5;
6892 salt_type = SALT_TYPE_INTERN;
6893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6894 opts_type = OPTS_TYPE_PT_GENERATE_LE
6895 | OPTS_TYPE_PT_ADD80
6896 | OPTS_TYPE_PT_ADDBITS14;
6897 kern_type = KERN_TYPE_HMACMD5_SLT;
6898 dgst_size = DGST_SIZE_4_4;
6899 parse_func = hmacmd5_parse_hash;
6900 sort_by_digest = sort_by_digest_4_4;
6901 opti_type = OPTI_TYPE_ZERO_BYTE
6902 | OPTI_TYPE_NOT_ITERATED;
6903 dgst_pos0 = 0;
6904 dgst_pos1 = 3;
6905 dgst_pos2 = 2;
6906 dgst_pos3 = 1;
6907 break;
6908
6909 case 100: hash_type = HASH_TYPE_SHA1;
6910 salt_type = SALT_TYPE_NONE;
6911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6912 opts_type = OPTS_TYPE_PT_GENERATE_BE
6913 | OPTS_TYPE_PT_ADD80
6914 | OPTS_TYPE_PT_ADDBITS15;
6915 kern_type = KERN_TYPE_SHA1;
6916 dgst_size = DGST_SIZE_4_5;
6917 parse_func = sha1_parse_hash;
6918 sort_by_digest = sort_by_digest_4_5;
6919 opti_type = OPTI_TYPE_ZERO_BYTE
6920 | OPTI_TYPE_PRECOMPUTE_INIT
6921 | OPTI_TYPE_PRECOMPUTE_MERKLE
6922 | OPTI_TYPE_EARLY_SKIP
6923 | OPTI_TYPE_NOT_ITERATED
6924 | OPTI_TYPE_NOT_SALTED
6925 | OPTI_TYPE_RAW_HASH;
6926 dgst_pos0 = 3;
6927 dgst_pos1 = 4;
6928 dgst_pos2 = 2;
6929 dgst_pos3 = 1;
6930 break;
6931
6932 case 101: hash_type = HASH_TYPE_SHA1;
6933 salt_type = SALT_TYPE_NONE;
6934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6935 opts_type = OPTS_TYPE_PT_GENERATE_BE
6936 | OPTS_TYPE_PT_ADD80
6937 | OPTS_TYPE_PT_ADDBITS15;
6938 kern_type = KERN_TYPE_SHA1;
6939 dgst_size = DGST_SIZE_4_5;
6940 parse_func = sha1b64_parse_hash;
6941 sort_by_digest = sort_by_digest_4_5;
6942 opti_type = OPTI_TYPE_ZERO_BYTE
6943 | OPTI_TYPE_PRECOMPUTE_INIT
6944 | OPTI_TYPE_PRECOMPUTE_MERKLE
6945 | OPTI_TYPE_EARLY_SKIP
6946 | OPTI_TYPE_NOT_ITERATED
6947 | OPTI_TYPE_NOT_SALTED
6948 | OPTI_TYPE_RAW_HASH;
6949 dgst_pos0 = 3;
6950 dgst_pos1 = 4;
6951 dgst_pos2 = 2;
6952 dgst_pos3 = 1;
6953 break;
6954
6955 case 110: hash_type = HASH_TYPE_SHA1;
6956 salt_type = SALT_TYPE_INTERN;
6957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6958 opts_type = OPTS_TYPE_PT_GENERATE_BE
6959 | OPTS_TYPE_ST_ADD80
6960 | OPTS_TYPE_ST_ADDBITS15;
6961 kern_type = KERN_TYPE_SHA1_PWSLT;
6962 dgst_size = DGST_SIZE_4_5;
6963 parse_func = sha1s_parse_hash;
6964 sort_by_digest = sort_by_digest_4_5;
6965 opti_type = OPTI_TYPE_ZERO_BYTE
6966 | OPTI_TYPE_PRECOMPUTE_INIT
6967 | OPTI_TYPE_PRECOMPUTE_MERKLE
6968 | OPTI_TYPE_EARLY_SKIP
6969 | OPTI_TYPE_NOT_ITERATED
6970 | OPTI_TYPE_APPENDED_SALT
6971 | OPTI_TYPE_RAW_HASH;
6972 dgst_pos0 = 3;
6973 dgst_pos1 = 4;
6974 dgst_pos2 = 2;
6975 dgst_pos3 = 1;
6976 break;
6977
6978 case 111: hash_type = HASH_TYPE_SHA1;
6979 salt_type = SALT_TYPE_EMBEDDED;
6980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6981 opts_type = OPTS_TYPE_PT_GENERATE_BE
6982 | OPTS_TYPE_ST_ADD80
6983 | OPTS_TYPE_ST_ADDBITS15;
6984 kern_type = KERN_TYPE_SHA1_PWSLT;
6985 dgst_size = DGST_SIZE_4_5;
6986 parse_func = sha1b64s_parse_hash;
6987 sort_by_digest = sort_by_digest_4_5;
6988 opti_type = OPTI_TYPE_ZERO_BYTE
6989 | OPTI_TYPE_PRECOMPUTE_INIT
6990 | OPTI_TYPE_PRECOMPUTE_MERKLE
6991 | OPTI_TYPE_EARLY_SKIP
6992 | OPTI_TYPE_NOT_ITERATED
6993 | OPTI_TYPE_APPENDED_SALT
6994 | OPTI_TYPE_RAW_HASH;
6995 dgst_pos0 = 3;
6996 dgst_pos1 = 4;
6997 dgst_pos2 = 2;
6998 dgst_pos3 = 1;
6999 break;
7000
7001 case 112: hash_type = HASH_TYPE_SHA1;
7002 salt_type = SALT_TYPE_INTERN;
7003 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7004 opts_type = OPTS_TYPE_PT_GENERATE_BE
7005 | OPTS_TYPE_ST_ADD80
7006 | OPTS_TYPE_ST_ADDBITS15
7007 | OPTS_TYPE_ST_HEX;
7008 kern_type = KERN_TYPE_SHA1_PWSLT;
7009 dgst_size = DGST_SIZE_4_5;
7010 parse_func = oracles_parse_hash;
7011 sort_by_digest = sort_by_digest_4_5;
7012 opti_type = OPTI_TYPE_ZERO_BYTE
7013 | OPTI_TYPE_PRECOMPUTE_INIT
7014 | OPTI_TYPE_PRECOMPUTE_MERKLE
7015 | OPTI_TYPE_EARLY_SKIP
7016 | OPTI_TYPE_NOT_ITERATED
7017 | OPTI_TYPE_APPENDED_SALT
7018 | OPTI_TYPE_RAW_HASH;
7019 dgst_pos0 = 3;
7020 dgst_pos1 = 4;
7021 dgst_pos2 = 2;
7022 dgst_pos3 = 1;
7023 break;
7024
7025 case 120: hash_type = HASH_TYPE_SHA1;
7026 salt_type = SALT_TYPE_INTERN;
7027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7028 opts_type = OPTS_TYPE_PT_GENERATE_BE
7029 | OPTS_TYPE_PT_ADD80
7030 | OPTS_TYPE_PT_ADDBITS15;
7031 kern_type = KERN_TYPE_SHA1_SLTPW;
7032 dgst_size = DGST_SIZE_4_5;
7033 parse_func = sha1s_parse_hash;
7034 sort_by_digest = sort_by_digest_4_5;
7035 opti_type = OPTI_TYPE_ZERO_BYTE
7036 | OPTI_TYPE_PRECOMPUTE_INIT
7037 | OPTI_TYPE_PRECOMPUTE_MERKLE
7038 | OPTI_TYPE_EARLY_SKIP
7039 | OPTI_TYPE_NOT_ITERATED
7040 | OPTI_TYPE_PREPENDED_SALT
7041 | OPTI_TYPE_RAW_HASH;
7042 dgst_pos0 = 3;
7043 dgst_pos1 = 4;
7044 dgst_pos2 = 2;
7045 dgst_pos3 = 1;
7046 break;
7047
7048 case 121: hash_type = HASH_TYPE_SHA1;
7049 salt_type = SALT_TYPE_INTERN;
7050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7051 opts_type = OPTS_TYPE_PT_GENERATE_BE
7052 | OPTS_TYPE_PT_ADD80
7053 | OPTS_TYPE_PT_ADDBITS15
7054 | OPTS_TYPE_ST_LOWER;
7055 kern_type = KERN_TYPE_SHA1_SLTPW;
7056 dgst_size = DGST_SIZE_4_5;
7057 parse_func = smf_parse_hash;
7058 sort_by_digest = sort_by_digest_4_5;
7059 opti_type = OPTI_TYPE_ZERO_BYTE
7060 | OPTI_TYPE_PRECOMPUTE_INIT
7061 | OPTI_TYPE_PRECOMPUTE_MERKLE
7062 | OPTI_TYPE_EARLY_SKIP
7063 | OPTI_TYPE_NOT_ITERATED
7064 | OPTI_TYPE_PREPENDED_SALT
7065 | OPTI_TYPE_RAW_HASH;
7066 dgst_pos0 = 3;
7067 dgst_pos1 = 4;
7068 dgst_pos2 = 2;
7069 dgst_pos3 = 1;
7070 break;
7071
7072 case 122: hash_type = HASH_TYPE_SHA1;
7073 salt_type = SALT_TYPE_EMBEDDED;
7074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7075 opts_type = OPTS_TYPE_PT_GENERATE_BE
7076 | OPTS_TYPE_PT_ADD80
7077 | OPTS_TYPE_PT_ADDBITS15
7078 | OPTS_TYPE_ST_HEX;
7079 kern_type = KERN_TYPE_SHA1_SLTPW;
7080 dgst_size = DGST_SIZE_4_5;
7081 parse_func = osx1_parse_hash;
7082 sort_by_digest = sort_by_digest_4_5;
7083 opti_type = OPTI_TYPE_ZERO_BYTE
7084 | OPTI_TYPE_PRECOMPUTE_INIT
7085 | OPTI_TYPE_PRECOMPUTE_MERKLE
7086 | OPTI_TYPE_EARLY_SKIP
7087 | OPTI_TYPE_NOT_ITERATED
7088 | OPTI_TYPE_PREPENDED_SALT
7089 | OPTI_TYPE_RAW_HASH;
7090 dgst_pos0 = 3;
7091 dgst_pos1 = 4;
7092 dgst_pos2 = 2;
7093 dgst_pos3 = 1;
7094 break;
7095
7096 case 124: hash_type = HASH_TYPE_SHA1;
7097 salt_type = SALT_TYPE_EMBEDDED;
7098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7099 opts_type = OPTS_TYPE_PT_GENERATE_BE
7100 | OPTS_TYPE_PT_ADD80
7101 | OPTS_TYPE_PT_ADDBITS15;
7102 kern_type = KERN_TYPE_SHA1_SLTPW;
7103 dgst_size = DGST_SIZE_4_5;
7104 parse_func = djangosha1_parse_hash;
7105 sort_by_digest = sort_by_digest_4_5;
7106 opti_type = OPTI_TYPE_ZERO_BYTE
7107 | OPTI_TYPE_PRECOMPUTE_INIT
7108 | OPTI_TYPE_PRECOMPUTE_MERKLE
7109 | OPTI_TYPE_EARLY_SKIP
7110 | OPTI_TYPE_NOT_ITERATED
7111 | OPTI_TYPE_PREPENDED_SALT
7112 | OPTI_TYPE_RAW_HASH;
7113 dgst_pos0 = 3;
7114 dgst_pos1 = 4;
7115 dgst_pos2 = 2;
7116 dgst_pos3 = 1;
7117 break;
7118
7119 case 130: hash_type = HASH_TYPE_SHA1;
7120 salt_type = SALT_TYPE_INTERN;
7121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7122 opts_type = OPTS_TYPE_PT_GENERATE_BE
7123 | OPTS_TYPE_PT_UNICODE
7124 | OPTS_TYPE_ST_ADD80
7125 | OPTS_TYPE_ST_ADDBITS15;
7126 kern_type = KERN_TYPE_SHA1_PWUSLT;
7127 dgst_size = DGST_SIZE_4_5;
7128 parse_func = sha1s_parse_hash;
7129 sort_by_digest = sort_by_digest_4_5;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_PRECOMPUTE_INIT
7132 | OPTI_TYPE_PRECOMPUTE_MERKLE
7133 | OPTI_TYPE_EARLY_SKIP
7134 | OPTI_TYPE_NOT_ITERATED
7135 | OPTI_TYPE_APPENDED_SALT
7136 | OPTI_TYPE_RAW_HASH;
7137 dgst_pos0 = 3;
7138 dgst_pos1 = 4;
7139 dgst_pos2 = 2;
7140 dgst_pos3 = 1;
7141 break;
7142
7143 case 131: hash_type = HASH_TYPE_SHA1;
7144 salt_type = SALT_TYPE_EMBEDDED;
7145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7146 opts_type = OPTS_TYPE_PT_GENERATE_BE
7147 | OPTS_TYPE_PT_UNICODE
7148 | OPTS_TYPE_PT_UPPER
7149 | OPTS_TYPE_ST_ADD80
7150 | OPTS_TYPE_ST_ADDBITS15
7151 | OPTS_TYPE_ST_HEX;
7152 kern_type = KERN_TYPE_SHA1_PWUSLT;
7153 dgst_size = DGST_SIZE_4_5;
7154 parse_func = mssql2000_parse_hash;
7155 sort_by_digest = sort_by_digest_4_5;
7156 opti_type = OPTI_TYPE_ZERO_BYTE
7157 | OPTI_TYPE_PRECOMPUTE_INIT
7158 | OPTI_TYPE_PRECOMPUTE_MERKLE
7159 | OPTI_TYPE_EARLY_SKIP
7160 | OPTI_TYPE_NOT_ITERATED
7161 | OPTI_TYPE_APPENDED_SALT
7162 | OPTI_TYPE_RAW_HASH;
7163 dgst_pos0 = 3;
7164 dgst_pos1 = 4;
7165 dgst_pos2 = 2;
7166 dgst_pos3 = 1;
7167 break;
7168
7169 case 132: hash_type = HASH_TYPE_SHA1;
7170 salt_type = SALT_TYPE_EMBEDDED;
7171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7172 opts_type = OPTS_TYPE_PT_GENERATE_BE
7173 | OPTS_TYPE_PT_UNICODE
7174 | OPTS_TYPE_ST_ADD80
7175 | OPTS_TYPE_ST_ADDBITS15
7176 | OPTS_TYPE_ST_HEX;
7177 kern_type = KERN_TYPE_SHA1_PWUSLT;
7178 dgst_size = DGST_SIZE_4_5;
7179 parse_func = mssql2005_parse_hash;
7180 sort_by_digest = sort_by_digest_4_5;
7181 opti_type = OPTI_TYPE_ZERO_BYTE
7182 | OPTI_TYPE_PRECOMPUTE_INIT
7183 | OPTI_TYPE_PRECOMPUTE_MERKLE
7184 | OPTI_TYPE_EARLY_SKIP
7185 | OPTI_TYPE_NOT_ITERATED
7186 | OPTI_TYPE_APPENDED_SALT
7187 | OPTI_TYPE_RAW_HASH;
7188 dgst_pos0 = 3;
7189 dgst_pos1 = 4;
7190 dgst_pos2 = 2;
7191 dgst_pos3 = 1;
7192 break;
7193
7194 case 133: hash_type = HASH_TYPE_SHA1;
7195 salt_type = SALT_TYPE_EMBEDDED;
7196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7197 opts_type = OPTS_TYPE_PT_GENERATE_BE
7198 | OPTS_TYPE_PT_UNICODE
7199 | OPTS_TYPE_ST_ADD80
7200 | OPTS_TYPE_ST_ADDBITS15;
7201 kern_type = KERN_TYPE_SHA1_PWUSLT;
7202 dgst_size = DGST_SIZE_4_5;
7203 parse_func = peoplesoft_parse_hash;
7204 sort_by_digest = sort_by_digest_4_5;
7205 opti_type = OPTI_TYPE_ZERO_BYTE
7206 | OPTI_TYPE_PRECOMPUTE_INIT
7207 | OPTI_TYPE_PRECOMPUTE_MERKLE
7208 | OPTI_TYPE_EARLY_SKIP
7209 | OPTI_TYPE_NOT_ITERATED
7210 | OPTI_TYPE_APPENDED_SALT
7211 | OPTI_TYPE_RAW_HASH;
7212 dgst_pos0 = 3;
7213 dgst_pos1 = 4;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 140: hash_type = HASH_TYPE_SHA1;
7219 salt_type = SALT_TYPE_INTERN;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_BE
7222 | OPTS_TYPE_PT_ADD80
7223 | OPTS_TYPE_PT_ADDBITS15
7224 | OPTS_TYPE_PT_UNICODE;
7225 kern_type = KERN_TYPE_SHA1_SLTPWU;
7226 dgst_size = DGST_SIZE_4_5;
7227 parse_func = sha1s_parse_hash;
7228 sort_by_digest = sort_by_digest_4_5;
7229 opti_type = OPTI_TYPE_ZERO_BYTE
7230 | OPTI_TYPE_PRECOMPUTE_INIT
7231 | OPTI_TYPE_PRECOMPUTE_MERKLE
7232 | OPTI_TYPE_EARLY_SKIP
7233 | OPTI_TYPE_NOT_ITERATED
7234 | OPTI_TYPE_PREPENDED_SALT
7235 | OPTI_TYPE_RAW_HASH;
7236 dgst_pos0 = 3;
7237 dgst_pos1 = 4;
7238 dgst_pos2 = 2;
7239 dgst_pos3 = 1;
7240 break;
7241
7242 case 141: hash_type = HASH_TYPE_SHA1;
7243 salt_type = SALT_TYPE_EMBEDDED;
7244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7245 opts_type = OPTS_TYPE_PT_GENERATE_BE
7246 | OPTS_TYPE_PT_ADD80
7247 | OPTS_TYPE_PT_ADDBITS15
7248 | OPTS_TYPE_PT_UNICODE
7249 | OPTS_TYPE_ST_BASE64;
7250 kern_type = KERN_TYPE_SHA1_SLTPWU;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = episerver_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_PREPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 150: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_INTERN;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_ST_ADD80
7272 | OPTS_TYPE_ST_ADDBITS15;
7273 kern_type = KERN_TYPE_HMACSHA1_PW;
7274 dgst_size = DGST_SIZE_4_5;
7275 parse_func = hmacsha1_parse_hash;
7276 sort_by_digest = sort_by_digest_4_5;
7277 opti_type = OPTI_TYPE_ZERO_BYTE
7278 | OPTI_TYPE_NOT_ITERATED;
7279 dgst_pos0 = 3;
7280 dgst_pos1 = 4;
7281 dgst_pos2 = 2;
7282 dgst_pos3 = 1;
7283 break;
7284
7285 case 160: hash_type = HASH_TYPE_SHA1;
7286 salt_type = SALT_TYPE_INTERN;
7287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7288 opts_type = OPTS_TYPE_PT_GENERATE_BE
7289 | OPTS_TYPE_PT_ADD80
7290 | OPTS_TYPE_PT_ADDBITS15;
7291 kern_type = KERN_TYPE_HMACSHA1_SLT;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = hmacsha1_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_NOT_ITERATED;
7297 dgst_pos0 = 3;
7298 dgst_pos1 = 4;
7299 dgst_pos2 = 2;
7300 dgst_pos3 = 1;
7301 break;
7302
7303 case 190: hash_type = HASH_TYPE_SHA1;
7304 salt_type = SALT_TYPE_NONE;
7305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7306 opts_type = OPTS_TYPE_PT_GENERATE_BE
7307 | OPTS_TYPE_PT_ADD80
7308 | OPTS_TYPE_PT_ADDBITS15;
7309 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7310 dgst_size = DGST_SIZE_4_5;
7311 parse_func = sha1linkedin_parse_hash;
7312 sort_by_digest = sort_by_digest_4_5;
7313 opti_type = OPTI_TYPE_ZERO_BYTE
7314 | OPTI_TYPE_PRECOMPUTE_INIT
7315 | OPTI_TYPE_EARLY_SKIP
7316 | OPTI_TYPE_NOT_ITERATED
7317 | OPTI_TYPE_NOT_SALTED;
7318 dgst_pos0 = 0;
7319 dgst_pos1 = 4;
7320 dgst_pos2 = 3;
7321 dgst_pos3 = 2;
7322 break;
7323
7324 case 200: hash_type = HASH_TYPE_MYSQL;
7325 salt_type = SALT_TYPE_NONE;
7326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7327 opts_type = 0;
7328 kern_type = KERN_TYPE_MYSQL;
7329 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7330 parse_func = mysql323_parse_hash;
7331 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7332 opti_type = OPTI_TYPE_ZERO_BYTE;
7333 dgst_pos0 = 0;
7334 dgst_pos1 = 1;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 3;
7337 break;
7338
7339 case 300: hash_type = HASH_TYPE_SHA1;
7340 salt_type = SALT_TYPE_NONE;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_BE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS15;
7345 kern_type = KERN_TYPE_MYSQL41;
7346 dgst_size = DGST_SIZE_4_5;
7347 parse_func = sha1_parse_hash;
7348 sort_by_digest = sort_by_digest_4_5;
7349 opti_type = OPTI_TYPE_ZERO_BYTE
7350 | OPTI_TYPE_PRECOMPUTE_INIT
7351 | OPTI_TYPE_PRECOMPUTE_MERKLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_NOT_SALTED;
7355 dgst_pos0 = 3;
7356 dgst_pos1 = 4;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 400: hash_type = HASH_TYPE_MD5;
7362 salt_type = SALT_TYPE_EMBEDDED;
7363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7365 kern_type = KERN_TYPE_PHPASS;
7366 dgst_size = DGST_SIZE_4_4;
7367 parse_func = phpass_parse_hash;
7368 sort_by_digest = sort_by_digest_4_4;
7369 opti_type = OPTI_TYPE_ZERO_BYTE;
7370 dgst_pos0 = 0;
7371 dgst_pos1 = 1;
7372 dgst_pos2 = 2;
7373 dgst_pos3 = 3;
7374 break;
7375
7376 case 500: hash_type = HASH_TYPE_MD5;
7377 salt_type = SALT_TYPE_EMBEDDED;
7378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7380 kern_type = KERN_TYPE_MD5CRYPT;
7381 dgst_size = DGST_SIZE_4_4;
7382 parse_func = md5crypt_parse_hash;
7383 sort_by_digest = sort_by_digest_4_4;
7384 opti_type = OPTI_TYPE_ZERO_BYTE;
7385 dgst_pos0 = 0;
7386 dgst_pos1 = 1;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 3;
7389 break;
7390
7391 case 501: hash_type = HASH_TYPE_MD5;
7392 salt_type = SALT_TYPE_EMBEDDED;
7393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_LE
7395 | OPTS_TYPE_HASH_COPY;
7396 kern_type = KERN_TYPE_MD5CRYPT;
7397 dgst_size = DGST_SIZE_4_4;
7398 parse_func = juniper_parse_hash;
7399 sort_by_digest = sort_by_digest_4_4;
7400 opti_type = OPTI_TYPE_ZERO_BYTE;
7401 dgst_pos0 = 0;
7402 dgst_pos1 = 1;
7403 dgst_pos2 = 2;
7404 dgst_pos3 = 3;
7405 break;
7406
7407 case 900: hash_type = HASH_TYPE_MD4;
7408 salt_type = SALT_TYPE_NONE;
7409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7410 opts_type = OPTS_TYPE_PT_GENERATE_LE
7411 | OPTS_TYPE_PT_ADD80
7412 | OPTS_TYPE_PT_ADDBITS14;
7413 kern_type = KERN_TYPE_MD4;
7414 dgst_size = DGST_SIZE_4_4;
7415 parse_func = md4_parse_hash;
7416 sort_by_digest = sort_by_digest_4_4;
7417 opti_type = OPTI_TYPE_ZERO_BYTE
7418 | OPTI_TYPE_PRECOMPUTE_INIT
7419 | OPTI_TYPE_PRECOMPUTE_MERKLE
7420 | OPTI_TYPE_MEET_IN_MIDDLE
7421 | OPTI_TYPE_EARLY_SKIP
7422 | OPTI_TYPE_NOT_ITERATED
7423 | OPTI_TYPE_NOT_SALTED
7424 | OPTI_TYPE_RAW_HASH;
7425 dgst_pos0 = 0;
7426 dgst_pos1 = 3;
7427 dgst_pos2 = 2;
7428 dgst_pos3 = 1;
7429 break;
7430
7431 case 1000: hash_type = HASH_TYPE_MD4;
7432 salt_type = SALT_TYPE_NONE;
7433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7434 opts_type = OPTS_TYPE_PT_GENERATE_LE
7435 | OPTS_TYPE_PT_ADD80
7436 | OPTS_TYPE_PT_ADDBITS14
7437 | OPTS_TYPE_PT_UNICODE;
7438 kern_type = KERN_TYPE_MD4_PWU;
7439 dgst_size = DGST_SIZE_4_4;
7440 parse_func = md4_parse_hash;
7441 sort_by_digest = sort_by_digest_4_4;
7442 opti_type = OPTI_TYPE_ZERO_BYTE
7443 | OPTI_TYPE_PRECOMPUTE_INIT
7444 | OPTI_TYPE_PRECOMPUTE_MERKLE
7445 | OPTI_TYPE_MEET_IN_MIDDLE
7446 | OPTI_TYPE_EARLY_SKIP
7447 | OPTI_TYPE_NOT_ITERATED
7448 | OPTI_TYPE_NOT_SALTED
7449 | OPTI_TYPE_RAW_HASH;
7450 dgst_pos0 = 0;
7451 dgst_pos1 = 3;
7452 dgst_pos2 = 2;
7453 dgst_pos3 = 1;
7454 break;
7455
7456 case 1100: hash_type = HASH_TYPE_MD4;
7457 salt_type = SALT_TYPE_INTERN;
7458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7459 opts_type = OPTS_TYPE_PT_GENERATE_LE
7460 | OPTS_TYPE_PT_ADD80
7461 | OPTS_TYPE_PT_ADDBITS14
7462 | OPTS_TYPE_PT_UNICODE
7463 | OPTS_TYPE_ST_ADD80
7464 | OPTS_TYPE_ST_UNICODE
7465 | OPTS_TYPE_ST_LOWER;
7466 kern_type = KERN_TYPE_MD44_PWUSLT;
7467 dgst_size = DGST_SIZE_4_4;
7468 parse_func = dcc_parse_hash;
7469 sort_by_digest = sort_by_digest_4_4;
7470 opti_type = OPTI_TYPE_ZERO_BYTE
7471 | OPTI_TYPE_PRECOMPUTE_INIT
7472 | OPTI_TYPE_PRECOMPUTE_MERKLE
7473 | OPTI_TYPE_EARLY_SKIP
7474 | OPTI_TYPE_NOT_ITERATED;
7475 dgst_pos0 = 0;
7476 dgst_pos1 = 3;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 1;
7479 break;
7480
7481 case 1400: hash_type = HASH_TYPE_SHA256;
7482 salt_type = SALT_TYPE_NONE;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_ADD80
7486 | OPTS_TYPE_PT_ADDBITS15;
7487 kern_type = KERN_TYPE_SHA256;
7488 dgst_size = DGST_SIZE_4_8;
7489 parse_func = sha256_parse_hash;
7490 sort_by_digest = sort_by_digest_4_8;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_PRECOMPUTE_INIT
7493 | OPTI_TYPE_PRECOMPUTE_MERKLE
7494 | OPTI_TYPE_EARLY_SKIP
7495 | OPTI_TYPE_NOT_ITERATED
7496 | OPTI_TYPE_NOT_SALTED
7497 | OPTI_TYPE_RAW_HASH;
7498 dgst_pos0 = 3;
7499 dgst_pos1 = 7;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 6;
7502 break;
7503
7504 case 1410: hash_type = HASH_TYPE_SHA256;
7505 salt_type = SALT_TYPE_INTERN;
7506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_BE
7508 | OPTS_TYPE_ST_ADD80
7509 | OPTS_TYPE_ST_ADDBITS15;
7510 kern_type = KERN_TYPE_SHA256_PWSLT;
7511 dgst_size = DGST_SIZE_4_8;
7512 parse_func = sha256s_parse_hash;
7513 sort_by_digest = sort_by_digest_4_8;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_APPENDED_SALT
7520 | OPTI_TYPE_RAW_HASH;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1420: hash_type = HASH_TYPE_SHA256;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_PT_ADD80
7532 | OPTS_TYPE_PT_ADDBITS15;
7533 kern_type = KERN_TYPE_SHA256_SLTPW;
7534 dgst_size = DGST_SIZE_4_8;
7535 parse_func = sha256s_parse_hash;
7536 sort_by_digest = sort_by_digest_4_8;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_PRECOMPUTE_INIT
7539 | OPTI_TYPE_PRECOMPUTE_MERKLE
7540 | OPTI_TYPE_EARLY_SKIP
7541 | OPTI_TYPE_NOT_ITERATED
7542 | OPTI_TYPE_PREPENDED_SALT
7543 | OPTI_TYPE_RAW_HASH;
7544 dgst_pos0 = 3;
7545 dgst_pos1 = 7;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 6;
7548 break;
7549
7550 case 1421: hash_type = HASH_TYPE_SHA256;
7551 salt_type = SALT_TYPE_EMBEDDED;
7552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_BE
7554 | OPTS_TYPE_PT_ADD80
7555 | OPTS_TYPE_PT_ADDBITS15;
7556 kern_type = KERN_TYPE_SHA256_SLTPW;
7557 dgst_size = DGST_SIZE_4_8;
7558 parse_func = hmailserver_parse_hash;
7559 sort_by_digest = sort_by_digest_4_8;
7560 opti_type = OPTI_TYPE_ZERO_BYTE
7561 | OPTI_TYPE_PRECOMPUTE_INIT
7562 | OPTI_TYPE_PRECOMPUTE_MERKLE
7563 | OPTI_TYPE_EARLY_SKIP
7564 | OPTI_TYPE_NOT_ITERATED
7565 | OPTI_TYPE_PREPENDED_SALT
7566 | OPTI_TYPE_RAW_HASH;
7567 dgst_pos0 = 3;
7568 dgst_pos1 = 7;
7569 dgst_pos2 = 2;
7570 dgst_pos3 = 6;
7571 break;
7572
7573 case 1430: hash_type = HASH_TYPE_SHA256;
7574 salt_type = SALT_TYPE_INTERN;
7575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7576 opts_type = OPTS_TYPE_PT_GENERATE_BE
7577 | OPTS_TYPE_PT_UNICODE
7578 | OPTS_TYPE_ST_ADD80
7579 | OPTS_TYPE_ST_ADDBITS15;
7580 kern_type = KERN_TYPE_SHA256_PWUSLT;
7581 dgst_size = DGST_SIZE_4_8;
7582 parse_func = sha256s_parse_hash;
7583 sort_by_digest = sort_by_digest_4_8;
7584 opti_type = OPTI_TYPE_ZERO_BYTE
7585 | OPTI_TYPE_PRECOMPUTE_INIT
7586 | OPTI_TYPE_PRECOMPUTE_MERKLE
7587 | OPTI_TYPE_EARLY_SKIP
7588 | OPTI_TYPE_NOT_ITERATED
7589 | OPTI_TYPE_APPENDED_SALT
7590 | OPTI_TYPE_RAW_HASH;
7591 dgst_pos0 = 3;
7592 dgst_pos1 = 7;
7593 dgst_pos2 = 2;
7594 dgst_pos3 = 6;
7595 break;
7596
7597 case 1440: hash_type = HASH_TYPE_SHA256;
7598 salt_type = SALT_TYPE_INTERN;
7599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7600 opts_type = OPTS_TYPE_PT_GENERATE_BE
7601 | OPTS_TYPE_PT_ADD80
7602 | OPTS_TYPE_PT_ADDBITS15
7603 | OPTS_TYPE_PT_UNICODE;
7604 kern_type = KERN_TYPE_SHA256_SLTPWU;
7605 dgst_size = DGST_SIZE_4_8;
7606 parse_func = sha256s_parse_hash;
7607 sort_by_digest = sort_by_digest_4_8;
7608 opti_type = OPTI_TYPE_ZERO_BYTE
7609 | OPTI_TYPE_PRECOMPUTE_INIT
7610 | OPTI_TYPE_PRECOMPUTE_MERKLE
7611 | OPTI_TYPE_EARLY_SKIP
7612 | OPTI_TYPE_NOT_ITERATED
7613 | OPTI_TYPE_PREPENDED_SALT
7614 | OPTI_TYPE_RAW_HASH;
7615 dgst_pos0 = 3;
7616 dgst_pos1 = 7;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 6;
7619 break;
7620
7621 case 1441: hash_type = HASH_TYPE_SHA256;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_BE
7625 | OPTS_TYPE_PT_ADD80
7626 | OPTS_TYPE_PT_ADDBITS15
7627 | OPTS_TYPE_PT_UNICODE
7628 | OPTS_TYPE_ST_BASE64;
7629 kern_type = KERN_TYPE_SHA256_SLTPWU;
7630 dgst_size = DGST_SIZE_4_8;
7631 parse_func = episerver4_parse_hash;
7632 sort_by_digest = sort_by_digest_4_8;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_PREPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 3;
7641 dgst_pos1 = 7;
7642 dgst_pos2 = 2;
7643 dgst_pos3 = 6;
7644 break;
7645
7646 case 1450: hash_type = HASH_TYPE_SHA256;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_ST_ADD80;
7651 kern_type = KERN_TYPE_HMACSHA256_PW;
7652 dgst_size = DGST_SIZE_4_8;
7653 parse_func = hmacsha256_parse_hash;
7654 sort_by_digest = sort_by_digest_4_8;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_NOT_ITERATED;
7657 dgst_pos0 = 3;
7658 dgst_pos1 = 7;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 6;
7661 break;
7662
7663 case 1460: hash_type = HASH_TYPE_SHA256;
7664 salt_type = SALT_TYPE_INTERN;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15;
7669 kern_type = KERN_TYPE_HMACSHA256_SLT;
7670 dgst_size = DGST_SIZE_4_8;
7671 parse_func = hmacsha256_parse_hash;
7672 sort_by_digest = sort_by_digest_4_8;
7673 opti_type = OPTI_TYPE_ZERO_BYTE
7674 | OPTI_TYPE_NOT_ITERATED;
7675 dgst_pos0 = 3;
7676 dgst_pos1 = 7;
7677 dgst_pos2 = 2;
7678 dgst_pos3 = 6;
7679 break;
7680
7681 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7682 salt_type = SALT_TYPE_EMBEDDED;
7683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7684 opts_type = OPTS_TYPE_PT_GENERATE_LE
7685 | OPTS_TYPE_PT_BITSLICE;
7686 kern_type = KERN_TYPE_DESCRYPT;
7687 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7688 parse_func = descrypt_parse_hash;
7689 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7690 opti_type = OPTI_TYPE_ZERO_BYTE
7691 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7692 dgst_pos0 = 0;
7693 dgst_pos1 = 1;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 3;
7696 break;
7697
7698 case 1600: hash_type = HASH_TYPE_MD5;
7699 salt_type = SALT_TYPE_EMBEDDED;
7700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7702 kern_type = KERN_TYPE_APR1CRYPT;
7703 dgst_size = DGST_SIZE_4_4;
7704 parse_func = md5apr1_parse_hash;
7705 sort_by_digest = sort_by_digest_4_4;
7706 opti_type = OPTI_TYPE_ZERO_BYTE;
7707 dgst_pos0 = 0;
7708 dgst_pos1 = 1;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 3;
7711 break;
7712
7713 case 1700: hash_type = HASH_TYPE_SHA512;
7714 salt_type = SALT_TYPE_NONE;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS15;
7719 kern_type = KERN_TYPE_SHA512;
7720 dgst_size = DGST_SIZE_8_8;
7721 parse_func = sha512_parse_hash;
7722 sort_by_digest = sort_by_digest_8_8;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_NOT_SALTED
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 14;
7731 dgst_pos1 = 15;
7732 dgst_pos2 = 6;
7733 dgst_pos3 = 7;
7734 break;
7735
7736 case 1710: hash_type = HASH_TYPE_SHA512;
7737 salt_type = SALT_TYPE_INTERN;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_ST_ADD80
7741 | OPTS_TYPE_ST_ADDBITS15;
7742 kern_type = KERN_TYPE_SHA512_PWSLT;
7743 dgst_size = DGST_SIZE_8_8;
7744 parse_func = sha512s_parse_hash;
7745 sort_by_digest = sort_by_digest_8_8;
7746 opti_type = OPTI_TYPE_ZERO_BYTE
7747 | OPTI_TYPE_PRECOMPUTE_INIT
7748 | OPTI_TYPE_PRECOMPUTE_MERKLE
7749 | OPTI_TYPE_EARLY_SKIP
7750 | OPTI_TYPE_NOT_ITERATED
7751 | OPTI_TYPE_APPENDED_SALT
7752 | OPTI_TYPE_RAW_HASH;
7753 dgst_pos0 = 14;
7754 dgst_pos1 = 15;
7755 dgst_pos2 = 6;
7756 dgst_pos3 = 7;
7757 break;
7758
7759 case 1711: hash_type = HASH_TYPE_SHA512;
7760 salt_type = SALT_TYPE_EMBEDDED;
7761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7762 opts_type = OPTS_TYPE_PT_GENERATE_BE
7763 | OPTS_TYPE_ST_ADD80
7764 | OPTS_TYPE_ST_ADDBITS15;
7765 kern_type = KERN_TYPE_SHA512_PWSLT;
7766 dgst_size = DGST_SIZE_8_8;
7767 parse_func = sha512b64s_parse_hash;
7768 sort_by_digest = sort_by_digest_8_8;
7769 opti_type = OPTI_TYPE_ZERO_BYTE
7770 | OPTI_TYPE_PRECOMPUTE_INIT
7771 | OPTI_TYPE_PRECOMPUTE_MERKLE
7772 | OPTI_TYPE_EARLY_SKIP
7773 | OPTI_TYPE_NOT_ITERATED
7774 | OPTI_TYPE_APPENDED_SALT
7775 | OPTI_TYPE_RAW_HASH;
7776 dgst_pos0 = 14;
7777 dgst_pos1 = 15;
7778 dgst_pos2 = 6;
7779 dgst_pos3 = 7;
7780 break;
7781
7782 case 1720: hash_type = HASH_TYPE_SHA512;
7783 salt_type = SALT_TYPE_INTERN;
7784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_BE
7786 | OPTS_TYPE_PT_ADD80
7787 | OPTS_TYPE_PT_ADDBITS15;
7788 kern_type = KERN_TYPE_SHA512_SLTPW;
7789 dgst_size = DGST_SIZE_8_8;
7790 parse_func = sha512s_parse_hash;
7791 sort_by_digest = sort_by_digest_8_8;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_PRECOMPUTE_INIT
7794 | OPTI_TYPE_PRECOMPUTE_MERKLE
7795 | OPTI_TYPE_EARLY_SKIP
7796 | OPTI_TYPE_NOT_ITERATED
7797 | OPTI_TYPE_PREPENDED_SALT
7798 | OPTI_TYPE_RAW_HASH;
7799 dgst_pos0 = 14;
7800 dgst_pos1 = 15;
7801 dgst_pos2 = 6;
7802 dgst_pos3 = 7;
7803 break;
7804
7805 case 1722: hash_type = HASH_TYPE_SHA512;
7806 salt_type = SALT_TYPE_EMBEDDED;
7807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7808 opts_type = OPTS_TYPE_PT_GENERATE_BE
7809 | OPTS_TYPE_PT_ADD80
7810 | OPTS_TYPE_PT_ADDBITS15
7811 | OPTS_TYPE_ST_HEX;
7812 kern_type = KERN_TYPE_SHA512_SLTPW;
7813 dgst_size = DGST_SIZE_8_8;
7814 parse_func = osx512_parse_hash;
7815 sort_by_digest = sort_by_digest_8_8;
7816 opti_type = OPTI_TYPE_ZERO_BYTE
7817 | OPTI_TYPE_PRECOMPUTE_INIT
7818 | OPTI_TYPE_PRECOMPUTE_MERKLE
7819 | OPTI_TYPE_EARLY_SKIP
7820 | OPTI_TYPE_NOT_ITERATED
7821 | OPTI_TYPE_PREPENDED_SALT
7822 | OPTI_TYPE_RAW_HASH;
7823 dgst_pos0 = 14;
7824 dgst_pos1 = 15;
7825 dgst_pos2 = 6;
7826 dgst_pos3 = 7;
7827 break;
7828
7829 case 1730: hash_type = HASH_TYPE_SHA512;
7830 salt_type = SALT_TYPE_INTERN;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_BE
7833 | OPTS_TYPE_PT_UNICODE
7834 | OPTS_TYPE_ST_ADD80
7835 | OPTS_TYPE_ST_ADDBITS15;
7836 kern_type = KERN_TYPE_SHA512_PWSLTU;
7837 dgst_size = DGST_SIZE_8_8;
7838 parse_func = sha512s_parse_hash;
7839 sort_by_digest = sort_by_digest_8_8;
7840 opti_type = OPTI_TYPE_ZERO_BYTE
7841 | OPTI_TYPE_PRECOMPUTE_INIT
7842 | OPTI_TYPE_PRECOMPUTE_MERKLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_APPENDED_SALT
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 14;
7848 dgst_pos1 = 15;
7849 dgst_pos2 = 6;
7850 dgst_pos3 = 7;
7851 break;
7852
7853 case 1731: hash_type = HASH_TYPE_SHA512;
7854 salt_type = SALT_TYPE_EMBEDDED;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_BE
7857 | OPTS_TYPE_PT_UNICODE
7858 | OPTS_TYPE_ST_ADD80
7859 | OPTS_TYPE_ST_ADDBITS15
7860 | OPTS_TYPE_ST_HEX;
7861 kern_type = KERN_TYPE_SHA512_PWSLTU;
7862 dgst_size = DGST_SIZE_8_8;
7863 parse_func = mssql2012_parse_hash;
7864 sort_by_digest = sort_by_digest_8_8;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_APPENDED_SALT
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 14;
7873 dgst_pos1 = 15;
7874 dgst_pos2 = 6;
7875 dgst_pos3 = 7;
7876 break;
7877
7878 case 1740: hash_type = HASH_TYPE_SHA512;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS15
7884 | OPTS_TYPE_PT_UNICODE;
7885 kern_type = KERN_TYPE_SHA512_SLTPWU;
7886 dgst_size = DGST_SIZE_8_8;
7887 parse_func = sha512s_parse_hash;
7888 sort_by_digest = sort_by_digest_8_8;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_EARLY_SKIP
7893 | OPTI_TYPE_NOT_ITERATED
7894 | OPTI_TYPE_PREPENDED_SALT
7895 | OPTI_TYPE_RAW_HASH;
7896 dgst_pos0 = 14;
7897 dgst_pos1 = 15;
7898 dgst_pos2 = 6;
7899 dgst_pos3 = 7;
7900 break;
7901
7902 case 1750: hash_type = HASH_TYPE_SHA512;
7903 salt_type = SALT_TYPE_INTERN;
7904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7905 opts_type = OPTS_TYPE_PT_GENERATE_BE
7906 | OPTS_TYPE_ST_ADD80;
7907 kern_type = KERN_TYPE_HMACSHA512_PW;
7908 dgst_size = DGST_SIZE_8_8;
7909 parse_func = hmacsha512_parse_hash;
7910 sort_by_digest = sort_by_digest_8_8;
7911 opti_type = OPTI_TYPE_ZERO_BYTE
7912 | OPTI_TYPE_NOT_ITERATED;
7913 dgst_pos0 = 14;
7914 dgst_pos1 = 15;
7915 dgst_pos2 = 6;
7916 dgst_pos3 = 7;
7917 break;
7918
7919 case 1760: hash_type = HASH_TYPE_SHA512;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_PT_ADD80
7924 | OPTS_TYPE_PT_ADDBITS15;
7925 kern_type = KERN_TYPE_HMACSHA512_SLT;
7926 dgst_size = DGST_SIZE_8_8;
7927 parse_func = hmacsha512_parse_hash;
7928 sort_by_digest = sort_by_digest_8_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_NOT_ITERATED;
7931 dgst_pos0 = 14;
7932 dgst_pos1 = 15;
7933 dgst_pos2 = 6;
7934 dgst_pos3 = 7;
7935 break;
7936
7937 case 1800: hash_type = HASH_TYPE_SHA512;
7938 salt_type = SALT_TYPE_EMBEDDED;
7939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7941 kern_type = KERN_TYPE_SHA512CRYPT;
7942 dgst_size = DGST_SIZE_8_8;
7943 parse_func = sha512crypt_parse_hash;
7944 sort_by_digest = sort_by_digest_8_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE;
7946 dgst_pos0 = 0;
7947 dgst_pos1 = 1;
7948 dgst_pos2 = 2;
7949 dgst_pos3 = 3;
7950 break;
7951
7952 case 2100: hash_type = HASH_TYPE_DCC2;
7953 salt_type = SALT_TYPE_EMBEDDED;
7954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7955 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7956 | OPTS_TYPE_ST_LOWER
7957 | OPTS_TYPE_ST_UNICODE;
7958 kern_type = KERN_TYPE_DCC2;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = dcc2_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE;
7963 dgst_pos0 = 0;
7964 dgst_pos1 = 1;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 3;
7967 break;
7968
7969 case 2400: hash_type = HASH_TYPE_MD5;
7970 salt_type = SALT_TYPE_NONE;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7973 kern_type = KERN_TYPE_MD5PIX;
7974 dgst_size = DGST_SIZE_4_4;
7975 parse_func = md5pix_parse_hash;
7976 sort_by_digest = sort_by_digest_4_4;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_NOT_SALTED;
7983 dgst_pos0 = 0;
7984 dgst_pos1 = 3;
7985 dgst_pos2 = 2;
7986 dgst_pos3 = 1;
7987 break;
7988
7989 case 2410: hash_type = HASH_TYPE_MD5;
7990 salt_type = SALT_TYPE_INTERN;
7991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7993 kern_type = KERN_TYPE_MD5ASA;
7994 dgst_size = DGST_SIZE_4_4;
7995 parse_func = md5asa_parse_hash;
7996 sort_by_digest = sort_by_digest_4_4;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED;
8002 dgst_pos0 = 0;
8003 dgst_pos1 = 3;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 1;
8006 break;
8007
8008 case 2500: hash_type = HASH_TYPE_WPA;
8009 salt_type = SALT_TYPE_EMBEDDED;
8010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8012 kern_type = KERN_TYPE_WPA;
8013 dgst_size = DGST_SIZE_4_4;
8014 parse_func = wpa_parse_hash;
8015 sort_by_digest = sort_by_digest_4_4;
8016 opti_type = OPTI_TYPE_ZERO_BYTE;
8017 dgst_pos0 = 0;
8018 dgst_pos1 = 1;
8019 dgst_pos2 = 2;
8020 dgst_pos3 = 3;
8021 break;
8022
8023 case 2600: hash_type = HASH_TYPE_MD5;
8024 salt_type = SALT_TYPE_VIRTUAL;
8025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8026 opts_type = OPTS_TYPE_PT_GENERATE_LE
8027 | OPTS_TYPE_PT_ADD80
8028 | OPTS_TYPE_PT_ADDBITS14
8029 | OPTS_TYPE_ST_ADD80;
8030 kern_type = KERN_TYPE_MD55_PWSLT1;
8031 dgst_size = DGST_SIZE_4_4;
8032 parse_func = md5md5_parse_hash;
8033 sort_by_digest = sort_by_digest_4_4;
8034 opti_type = OPTI_TYPE_ZERO_BYTE
8035 | OPTI_TYPE_PRECOMPUTE_INIT
8036 | OPTI_TYPE_PRECOMPUTE_MERKLE
8037 | OPTI_TYPE_EARLY_SKIP;
8038 dgst_pos0 = 0;
8039 dgst_pos1 = 3;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 1;
8042 break;
8043
8044 case 2611: hash_type = HASH_TYPE_MD5;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_LE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS14
8050 | OPTS_TYPE_ST_ADD80;
8051 kern_type = KERN_TYPE_MD55_PWSLT1;
8052 dgst_size = DGST_SIZE_4_4;
8053 parse_func = vb3_parse_hash;
8054 sort_by_digest = sort_by_digest_4_4;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP;
8059 dgst_pos0 = 0;
8060 dgst_pos1 = 3;
8061 dgst_pos2 = 2;
8062 dgst_pos3 = 1;
8063 break;
8064
8065 case 2612: hash_type = HASH_TYPE_MD5;
8066 salt_type = SALT_TYPE_EMBEDDED;
8067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8068 opts_type = OPTS_TYPE_PT_GENERATE_LE
8069 | OPTS_TYPE_PT_ADD80
8070 | OPTS_TYPE_PT_ADDBITS14
8071 | OPTS_TYPE_ST_ADD80
8072 | OPTS_TYPE_ST_HEX;
8073 kern_type = KERN_TYPE_MD55_PWSLT1;
8074 dgst_size = DGST_SIZE_4_4;
8075 parse_func = phps_parse_hash;
8076 sort_by_digest = sort_by_digest_4_4;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_PRECOMPUTE_INIT
8079 | OPTI_TYPE_PRECOMPUTE_MERKLE
8080 | OPTI_TYPE_EARLY_SKIP;
8081 dgst_pos0 = 0;
8082 dgst_pos1 = 3;
8083 dgst_pos2 = 2;
8084 dgst_pos3 = 1;
8085 break;
8086
8087 case 2711: hash_type = HASH_TYPE_MD5;
8088 salt_type = SALT_TYPE_INTERN;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_LE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS14
8093 | OPTS_TYPE_ST_ADD80;
8094 kern_type = KERN_TYPE_MD55_PWSLT2;
8095 dgst_size = DGST_SIZE_4_4;
8096 parse_func = vb30_parse_hash;
8097 sort_by_digest = sort_by_digest_4_4;
8098 opti_type = OPTI_TYPE_ZERO_BYTE
8099 | OPTI_TYPE_PRECOMPUTE_INIT
8100 | OPTI_TYPE_EARLY_SKIP;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 3;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 1;
8105 break;
8106
8107 case 2811: hash_type = HASH_TYPE_MD5;
8108 salt_type = SALT_TYPE_INTERN;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_LE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS14;
8113 kern_type = KERN_TYPE_MD55_SLTPW;
8114 dgst_size = DGST_SIZE_4_4;
8115 parse_func = ipb2_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_EARLY_SKIP;
8120 dgst_pos0 = 0;
8121 dgst_pos1 = 3;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 1;
8124 break;
8125
8126 case 3000: hash_type = HASH_TYPE_LM;
8127 salt_type = SALT_TYPE_NONE;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_LE
8130 | OPTS_TYPE_PT_UPPER
8131 | OPTS_TYPE_PT_BITSLICE;
8132 kern_type = KERN_TYPE_LM;
8133 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8134 parse_func = lm_parse_hash;
8135 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8136 opti_type = OPTI_TYPE_ZERO_BYTE
8137 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8138 dgst_pos0 = 0;
8139 dgst_pos1 = 1;
8140 dgst_pos2 = 2;
8141 dgst_pos3 = 3;
8142 break;
8143
8144 case 3100: hash_type = HASH_TYPE_ORACLEH;
8145 salt_type = SALT_TYPE_INTERN;
8146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8147 opts_type = OPTS_TYPE_PT_GENERATE_LE
8148 | OPTS_TYPE_PT_UPPER
8149 | OPTS_TYPE_ST_UPPER;
8150 kern_type = KERN_TYPE_ORACLEH;
8151 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8152 parse_func = oracleh_parse_hash;
8153 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8154 opti_type = OPTI_TYPE_ZERO_BYTE;
8155 dgst_pos0 = 0;
8156 dgst_pos1 = 1;
8157 dgst_pos2 = 2;
8158 dgst_pos3 = 3;
8159 break;
8160
8161 case 3200: hash_type = HASH_TYPE_BCRYPT;
8162 salt_type = SALT_TYPE_EMBEDDED;
8163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_LE
8165 | OPTS_TYPE_ST_GENERATE_LE;
8166 kern_type = KERN_TYPE_BCRYPT;
8167 dgst_size = DGST_SIZE_4_6;
8168 parse_func = bcrypt_parse_hash;
8169 sort_by_digest = sort_by_digest_4_6;
8170 opti_type = OPTI_TYPE_ZERO_BYTE;
8171 dgst_pos0 = 0;
8172 dgst_pos1 = 1;
8173 dgst_pos2 = 2;
8174 dgst_pos3 = 3;
8175 break;
8176
8177 case 3710: hash_type = HASH_TYPE_MD5;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_LE
8181 | OPTS_TYPE_PT_ADD80
8182 | OPTS_TYPE_PT_ADDBITS14;
8183 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = md5s_parse_hash;
8186 sort_by_digest = sort_by_digest_4_4;
8187 opti_type = OPTI_TYPE_ZERO_BYTE
8188 | OPTI_TYPE_PRECOMPUTE_INIT
8189 | OPTI_TYPE_PRECOMPUTE_MERKLE
8190 | OPTI_TYPE_EARLY_SKIP;
8191 dgst_pos0 = 0;
8192 dgst_pos1 = 3;
8193 dgst_pos2 = 2;
8194 dgst_pos3 = 1;
8195 break;
8196
8197 case 3711: hash_type = HASH_TYPE_MD5;
8198 salt_type = SALT_TYPE_EMBEDDED;
8199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8200 opts_type = OPTS_TYPE_PT_GENERATE_LE
8201 | OPTS_TYPE_PT_ADD80
8202 | OPTS_TYPE_PT_ADDBITS14;
8203 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8204 dgst_size = DGST_SIZE_4_4;
8205 parse_func = mediawiki_b_parse_hash;
8206 sort_by_digest = sort_by_digest_4_4;
8207 opti_type = OPTI_TYPE_ZERO_BYTE
8208 | OPTI_TYPE_PRECOMPUTE_INIT
8209 | OPTI_TYPE_PRECOMPUTE_MERKLE
8210 | OPTI_TYPE_EARLY_SKIP;
8211 dgst_pos0 = 0;
8212 dgst_pos1 = 3;
8213 dgst_pos2 = 2;
8214 dgst_pos3 = 1;
8215 break;
8216
8217 case 3800: hash_type = HASH_TYPE_MD5;
8218 salt_type = SALT_TYPE_INTERN;
8219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8220 opts_type = OPTS_TYPE_PT_GENERATE_LE
8221 | OPTS_TYPE_ST_ADDBITS14;
8222 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8223 dgst_size = DGST_SIZE_4_4;
8224 parse_func = md5s_parse_hash;
8225 sort_by_digest = sort_by_digest_4_4;
8226 opti_type = OPTI_TYPE_ZERO_BYTE
8227 | OPTI_TYPE_PRECOMPUTE_INIT
8228 | OPTI_TYPE_PRECOMPUTE_MERKLE
8229 | OPTI_TYPE_EARLY_SKIP
8230 | OPTI_TYPE_NOT_ITERATED
8231 | OPTI_TYPE_RAW_HASH;
8232 dgst_pos0 = 0;
8233 dgst_pos1 = 3;
8234 dgst_pos2 = 2;
8235 dgst_pos3 = 1;
8236 break;
8237
8238 case 4300: hash_type = HASH_TYPE_MD5;
8239 salt_type = SALT_TYPE_VIRTUAL;
8240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8241 opts_type = OPTS_TYPE_PT_GENERATE_LE
8242 | OPTS_TYPE_PT_ADD80
8243 | OPTS_TYPE_PT_ADDBITS14
8244 | OPTS_TYPE_ST_ADD80;
8245 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8246 dgst_size = DGST_SIZE_4_4;
8247 parse_func = md5md5_parse_hash;
8248 sort_by_digest = sort_by_digest_4_4;
8249 opti_type = OPTI_TYPE_ZERO_BYTE
8250 | OPTI_TYPE_PRECOMPUTE_INIT
8251 | OPTI_TYPE_PRECOMPUTE_MERKLE
8252 | OPTI_TYPE_EARLY_SKIP;
8253 dgst_pos0 = 0;
8254 dgst_pos1 = 3;
8255 dgst_pos2 = 2;
8256 dgst_pos3 = 1;
8257 break;
8258
8259
8260 case 4400: hash_type = HASH_TYPE_MD5;
8261 salt_type = SALT_TYPE_NONE;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_BE
8264 | OPTS_TYPE_PT_ADD80
8265 | OPTS_TYPE_PT_ADDBITS15;
8266 kern_type = KERN_TYPE_MD5_SHA1;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md5_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED
8275 | OPTI_TYPE_NOT_SALTED
8276 | OPTI_TYPE_RAW_HASH;
8277 dgst_pos0 = 0;
8278 dgst_pos1 = 3;
8279 dgst_pos2 = 2;
8280 dgst_pos3 = 1;
8281 break;
8282
8283 case 4500: hash_type = HASH_TYPE_SHA1;
8284 salt_type = SALT_TYPE_NONE;
8285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8286 opts_type = OPTS_TYPE_PT_GENERATE_BE
8287 | OPTS_TYPE_PT_ADD80
8288 | OPTS_TYPE_PT_ADDBITS15;
8289 kern_type = KERN_TYPE_SHA11;
8290 dgst_size = DGST_SIZE_4_5;
8291 parse_func = sha1_parse_hash;
8292 sort_by_digest = sort_by_digest_4_5;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP
8297 | OPTI_TYPE_NOT_SALTED;
8298 dgst_pos0 = 3;
8299 dgst_pos1 = 4;
8300 dgst_pos2 = 2;
8301 dgst_pos3 = 1;
8302 break;
8303
8304 case 4700: hash_type = HASH_TYPE_SHA1;
8305 salt_type = SALT_TYPE_NONE;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_LE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS14;
8310 kern_type = KERN_TYPE_SHA1_MD5;
8311 dgst_size = DGST_SIZE_4_5;
8312 parse_func = sha1_parse_hash;
8313 sort_by_digest = sort_by_digest_4_5;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_PRECOMPUTE_INIT
8316 | OPTI_TYPE_PRECOMPUTE_MERKLE
8317 | OPTI_TYPE_EARLY_SKIP
8318 | OPTI_TYPE_NOT_ITERATED
8319 | OPTI_TYPE_NOT_SALTED
8320 | OPTI_TYPE_RAW_HASH;
8321 dgst_pos0 = 3;
8322 dgst_pos1 = 4;
8323 dgst_pos2 = 2;
8324 dgst_pos3 = 1;
8325 break;
8326
8327 case 4800: hash_type = HASH_TYPE_MD5;
8328 salt_type = SALT_TYPE_EMBEDDED;
8329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8330 opts_type = OPTS_TYPE_PT_GENERATE_LE
8331 | OPTS_TYPE_PT_ADDBITS14;
8332 kern_type = KERN_TYPE_MD5_CHAP;
8333 dgst_size = DGST_SIZE_4_4;
8334 parse_func = chap_parse_hash;
8335 sort_by_digest = sort_by_digest_4_4;
8336 opti_type = OPTI_TYPE_ZERO_BYTE
8337 | OPTI_TYPE_PRECOMPUTE_INIT
8338 | OPTI_TYPE_PRECOMPUTE_MERKLE
8339 | OPTI_TYPE_MEET_IN_MIDDLE
8340 | OPTI_TYPE_EARLY_SKIP
8341 | OPTI_TYPE_NOT_ITERATED
8342 | OPTI_TYPE_RAW_HASH;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 3;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 4900: hash_type = HASH_TYPE_SHA1;
8350 salt_type = SALT_TYPE_INTERN;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8353 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8354 dgst_size = DGST_SIZE_4_5;
8355 parse_func = sha1s_parse_hash;
8356 sort_by_digest = sort_by_digest_4_5;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_PRECOMPUTE_INIT
8359 | OPTI_TYPE_PRECOMPUTE_MERKLE
8360 | OPTI_TYPE_EARLY_SKIP;
8361 dgst_pos0 = 3;
8362 dgst_pos1 = 4;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 1;
8365 break;
8366
8367 case 5000: hash_type = HASH_TYPE_KECCAK;
8368 salt_type = SALT_TYPE_EMBEDDED;
8369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE
8371 | OPTS_TYPE_PT_ADD01;
8372 kern_type = KERN_TYPE_KECCAK;
8373 dgst_size = DGST_SIZE_8_25;
8374 parse_func = keccak_parse_hash;
8375 sort_by_digest = sort_by_digest_8_25;
8376 opti_type = OPTI_TYPE_ZERO_BYTE
8377 | OPTI_TYPE_RAW_HASH;
8378 dgst_pos0 = 2;
8379 dgst_pos1 = 3;
8380 dgst_pos2 = 4;
8381 dgst_pos3 = 5;
8382 break;
8383
8384 case 5100: hash_type = HASH_TYPE_MD5H;
8385 salt_type = SALT_TYPE_NONE;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_PT_ADD80
8389 | OPTS_TYPE_PT_ADDBITS14;
8390 kern_type = KERN_TYPE_MD5H;
8391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8392 parse_func = md5half_parse_hash;
8393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_RAW_HASH;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 1;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 3;
8400 break;
8401
8402 case 5200: hash_type = HASH_TYPE_SHA256;
8403 salt_type = SALT_TYPE_EMBEDDED;
8404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8406 kern_type = KERN_TYPE_PSAFE3;
8407 dgst_size = DGST_SIZE_4_8;
8408 parse_func = psafe3_parse_hash;
8409 sort_by_digest = sort_by_digest_4_8;
8410 opti_type = OPTI_TYPE_ZERO_BYTE;
8411 dgst_pos0 = 0;
8412 dgst_pos1 = 1;
8413 dgst_pos2 = 2;
8414 dgst_pos3 = 3;
8415 break;
8416
8417 case 5300: hash_type = HASH_TYPE_MD5;
8418 salt_type = SALT_TYPE_EMBEDDED;
8419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8420 opts_type = OPTS_TYPE_PT_GENERATE_LE
8421 | OPTS_TYPE_ST_ADD80;
8422 kern_type = KERN_TYPE_IKEPSK_MD5;
8423 dgst_size = DGST_SIZE_4_4;
8424 parse_func = ikepsk_md5_parse_hash;
8425 sort_by_digest = sort_by_digest_4_4;
8426 opti_type = OPTI_TYPE_ZERO_BYTE;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 5400: hash_type = HASH_TYPE_SHA1;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_BE
8437 | OPTS_TYPE_ST_ADD80;
8438 kern_type = KERN_TYPE_IKEPSK_SHA1;
8439 dgst_size = DGST_SIZE_4_5;
8440 parse_func = ikepsk_sha1_parse_hash;
8441 sort_by_digest = sort_by_digest_4_5;
8442 opti_type = OPTI_TYPE_ZERO_BYTE;
8443 dgst_pos0 = 3;
8444 dgst_pos1 = 4;
8445 dgst_pos2 = 2;
8446 dgst_pos3 = 1;
8447 break;
8448
8449 case 5500: hash_type = HASH_TYPE_NETNTLM;
8450 salt_type = SALT_TYPE_EMBEDDED;
8451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE
8453 | OPTS_TYPE_PT_ADD80
8454 | OPTS_TYPE_PT_ADDBITS14
8455 | OPTS_TYPE_PT_UNICODE
8456 | OPTS_TYPE_ST_HEX;
8457 kern_type = KERN_TYPE_NETNTLMv1;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = netntlmv1_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8463 dgst_pos0 = 0;
8464 dgst_pos1 = 1;
8465 dgst_pos2 = 2;
8466 dgst_pos3 = 3;
8467 break;
8468
8469 case 5600: hash_type = HASH_TYPE_MD5;
8470 salt_type = SALT_TYPE_EMBEDDED;
8471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8472 opts_type = OPTS_TYPE_PT_GENERATE_LE
8473 | OPTS_TYPE_PT_ADD80
8474 | OPTS_TYPE_PT_ADDBITS14
8475 | OPTS_TYPE_PT_UNICODE;
8476 kern_type = KERN_TYPE_NETNTLMv2;
8477 dgst_size = DGST_SIZE_4_4;
8478 parse_func = netntlmv2_parse_hash;
8479 sort_by_digest = sort_by_digest_4_4;
8480 opti_type = OPTI_TYPE_ZERO_BYTE;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 5700: hash_type = HASH_TYPE_SHA256;
8488 salt_type = SALT_TYPE_NONE;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_SHA256;
8494 dgst_size = DGST_SIZE_4_8;
8495 parse_func = cisco4_parse_hash;
8496 sort_by_digest = sort_by_digest_4_8;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_ITERATED
8502 | OPTI_TYPE_NOT_SALTED
8503 | OPTI_TYPE_RAW_HASH;
8504 dgst_pos0 = 3;
8505 dgst_pos1 = 7;
8506 dgst_pos2 = 2;
8507 dgst_pos3 = 6;
8508 break;
8509
8510 case 5800: hash_type = HASH_TYPE_SHA1;
8511 salt_type = SALT_TYPE_INTERN;
8512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8513 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8514 | OPTS_TYPE_ST_ADD80;
8515 kern_type = KERN_TYPE_ANDROIDPIN;
8516 dgst_size = DGST_SIZE_4_5;
8517 parse_func = androidpin_parse_hash;
8518 sort_by_digest = sort_by_digest_4_5;
8519 opti_type = OPTI_TYPE_ZERO_BYTE;
8520 dgst_pos0 = 0;
8521 dgst_pos1 = 1;
8522 dgst_pos2 = 2;
8523 dgst_pos3 = 3;
8524 break;
8525
8526 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8527 salt_type = SALT_TYPE_NONE;
8528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE
8530 | OPTS_TYPE_PT_ADD80;
8531 kern_type = KERN_TYPE_RIPEMD160;
8532 dgst_size = DGST_SIZE_4_5;
8533 parse_func = ripemd160_parse_hash;
8534 sort_by_digest = sort_by_digest_4_5;
8535 opti_type = OPTI_TYPE_ZERO_BYTE;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 1;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 3;
8540 break;
8541
8542 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8543 salt_type = SALT_TYPE_NONE;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_BE
8546 | OPTS_TYPE_PT_ADD80;
8547 kern_type = KERN_TYPE_WHIRLPOOL;
8548 dgst_size = DGST_SIZE_4_16;
8549 parse_func = whirlpool_parse_hash;
8550 sort_by_digest = sort_by_digest_4_16;
8551 opti_type = OPTI_TYPE_ZERO_BYTE;
8552 dgst_pos0 = 0;
8553 dgst_pos1 = 1;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 3;
8556 break;
8557
8558 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8559 salt_type = SALT_TYPE_EMBEDDED;
8560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8562 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8563 dgst_size = DGST_SIZE_4_5;
8564 parse_func = truecrypt_parse_hash_2k;
8565 sort_by_digest = sort_by_digest_4_5;
8566 opti_type = OPTI_TYPE_ZERO_BYTE;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 1;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 3;
8571 break;
8572
8573 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8574 salt_type = SALT_TYPE_EMBEDDED;
8575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8577 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8578 dgst_size = DGST_SIZE_4_5;
8579 parse_func = truecrypt_parse_hash_2k;
8580 sort_by_digest = sort_by_digest_4_5;
8581 opti_type = OPTI_TYPE_ZERO_BYTE;
8582 dgst_pos0 = 0;
8583 dgst_pos1 = 1;
8584 dgst_pos2 = 2;
8585 dgst_pos3 = 3;
8586 break;
8587
8588 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8589 salt_type = SALT_TYPE_EMBEDDED;
8590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8592 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8593 dgst_size = DGST_SIZE_4_5;
8594 parse_func = truecrypt_parse_hash_2k;
8595 sort_by_digest = sort_by_digest_4_5;
8596 opti_type = OPTI_TYPE_ZERO_BYTE;
8597 dgst_pos0 = 0;
8598 dgst_pos1 = 1;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 3;
8601 break;
8602
8603 case 6221: hash_type = HASH_TYPE_SHA512;
8604 salt_type = SALT_TYPE_EMBEDDED;
8605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8607 kern_type = KERN_TYPE_TCSHA512_XTS512;
8608 dgst_size = DGST_SIZE_8_8;
8609 parse_func = truecrypt_parse_hash_1k;
8610 sort_by_digest = sort_by_digest_8_8;
8611 opti_type = OPTI_TYPE_ZERO_BYTE;
8612 dgst_pos0 = 0;
8613 dgst_pos1 = 1;
8614 dgst_pos2 = 2;
8615 dgst_pos3 = 3;
8616 break;
8617
8618 case 6222: hash_type = HASH_TYPE_SHA512;
8619 salt_type = SALT_TYPE_EMBEDDED;
8620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8621 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8622 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8623 dgst_size = DGST_SIZE_8_8;
8624 parse_func = truecrypt_parse_hash_1k;
8625 sort_by_digest = sort_by_digest_8_8;
8626 opti_type = OPTI_TYPE_ZERO_BYTE;
8627 dgst_pos0 = 0;
8628 dgst_pos1 = 1;
8629 dgst_pos2 = 2;
8630 dgst_pos3 = 3;
8631 break;
8632
8633 case 6223: hash_type = HASH_TYPE_SHA512;
8634 salt_type = SALT_TYPE_EMBEDDED;
8635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8636 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8637 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8638 dgst_size = DGST_SIZE_8_8;
8639 parse_func = truecrypt_parse_hash_1k;
8640 sort_by_digest = sort_by_digest_8_8;
8641 opti_type = OPTI_TYPE_ZERO_BYTE;
8642 dgst_pos0 = 0;
8643 dgst_pos1 = 1;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 3;
8646 break;
8647
8648 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8649 salt_type = SALT_TYPE_EMBEDDED;
8650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8652 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8653 dgst_size = DGST_SIZE_4_8;
8654 parse_func = truecrypt_parse_hash_1k;
8655 sort_by_digest = sort_by_digest_4_8;
8656 opti_type = OPTI_TYPE_ZERO_BYTE;
8657 dgst_pos0 = 0;
8658 dgst_pos1 = 1;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 3;
8661 break;
8662
8663 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8664 salt_type = SALT_TYPE_EMBEDDED;
8665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8667 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8668 dgst_size = DGST_SIZE_4_8;
8669 parse_func = truecrypt_parse_hash_1k;
8670 sort_by_digest = sort_by_digest_4_8;
8671 opti_type = OPTI_TYPE_ZERO_BYTE;
8672 dgst_pos0 = 0;
8673 dgst_pos1 = 1;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 3;
8676 break;
8677
8678 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8679 salt_type = SALT_TYPE_EMBEDDED;
8680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8682 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8683 dgst_size = DGST_SIZE_4_8;
8684 parse_func = truecrypt_parse_hash_1k;
8685 sort_by_digest = sort_by_digest_4_8;
8686 opti_type = OPTI_TYPE_ZERO_BYTE;
8687 dgst_pos0 = 0;
8688 dgst_pos1 = 1;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 3;
8691 break;
8692
8693 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8694 salt_type = SALT_TYPE_EMBEDDED;
8695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8697 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8698 dgst_size = DGST_SIZE_4_5;
8699 parse_func = truecrypt_parse_hash_1k;
8700 sort_by_digest = sort_by_digest_4_5;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 1;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 3;
8706 break;
8707
8708 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8712 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8713 dgst_size = DGST_SIZE_4_5;
8714 parse_func = truecrypt_parse_hash_1k;
8715 sort_by_digest = sort_by_digest_4_5;
8716 opti_type = OPTI_TYPE_ZERO_BYTE;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 1;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 3;
8721 break;
8722
8723 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8724 salt_type = SALT_TYPE_EMBEDDED;
8725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8727 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8728 dgst_size = DGST_SIZE_4_5;
8729 parse_func = truecrypt_parse_hash_1k;
8730 sort_by_digest = sort_by_digest_4_5;
8731 opti_type = OPTI_TYPE_ZERO_BYTE;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 1;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 3;
8736 break;
8737
8738 case 6300: hash_type = HASH_TYPE_MD5;
8739 salt_type = SALT_TYPE_EMBEDDED;
8740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8742 kern_type = KERN_TYPE_MD5AIX;
8743 dgst_size = DGST_SIZE_4_4;
8744 parse_func = md5aix_parse_hash;
8745 sort_by_digest = sort_by_digest_4_4;
8746 opti_type = OPTI_TYPE_ZERO_BYTE;
8747 dgst_pos0 = 0;
8748 dgst_pos1 = 1;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 3;
8751 break;
8752
8753 case 6400: hash_type = HASH_TYPE_SHA256;
8754 salt_type = SALT_TYPE_EMBEDDED;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8757 kern_type = KERN_TYPE_SHA256AIX;
8758 dgst_size = DGST_SIZE_4_8;
8759 parse_func = sha256aix_parse_hash;
8760 sort_by_digest = sort_by_digest_4_8;
8761 opti_type = OPTI_TYPE_ZERO_BYTE;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 1;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 3;
8766 break;
8767
8768 case 6500: hash_type = HASH_TYPE_SHA512;
8769 salt_type = SALT_TYPE_EMBEDDED;
8770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8772 kern_type = KERN_TYPE_SHA512AIX;
8773 dgst_size = DGST_SIZE_8_8;
8774 parse_func = sha512aix_parse_hash;
8775 sort_by_digest = sort_by_digest_8_8;
8776 opti_type = OPTI_TYPE_ZERO_BYTE;
8777 dgst_pos0 = 0;
8778 dgst_pos1 = 1;
8779 dgst_pos2 = 2;
8780 dgst_pos3 = 3;
8781 break;
8782
8783 case 6600: hash_type = HASH_TYPE_AES;
8784 salt_type = SALT_TYPE_EMBEDDED;
8785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8787 kern_type = KERN_TYPE_AGILEKEY;
8788 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8789 parse_func = agilekey_parse_hash;
8790 sort_by_digest = sort_by_digest_4_5;
8791 opti_type = OPTI_TYPE_ZERO_BYTE;
8792 dgst_pos0 = 0;
8793 dgst_pos1 = 1;
8794 dgst_pos2 = 2;
8795 dgst_pos3 = 3;
8796 break;
8797
8798 case 6700: hash_type = HASH_TYPE_SHA1;
8799 salt_type = SALT_TYPE_EMBEDDED;
8800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8801 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8802 kern_type = KERN_TYPE_SHA1AIX;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = sha1aix_parse_hash;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6800: hash_type = HASH_TYPE_AES;
8814 salt_type = SALT_TYPE_EMBEDDED;
8815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8817 kern_type = KERN_TYPE_LASTPASS;
8818 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8819 parse_func = lastpass_parse_hash;
8820 sort_by_digest = sort_by_digest_4_8;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6900: hash_type = HASH_TYPE_GOST;
8829 salt_type = SALT_TYPE_NONE;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8832 kern_type = KERN_TYPE_GOST;
8833 dgst_size = DGST_SIZE_4_8;
8834 parse_func = gost_parse_hash;
8835 sort_by_digest = sort_by_digest_4_8;
8836 opti_type = OPTI_TYPE_ZERO_BYTE;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 7100: hash_type = HASH_TYPE_SHA512;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847 kern_type = KERN_TYPE_PBKDF2_SHA512;
8848 dgst_size = DGST_SIZE_8_16;
8849 parse_func = sha512osx_parse_hash;
8850 sort_by_digest = sort_by_digest_8_16;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 7200: hash_type = HASH_TYPE_SHA512;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_PBKDF2_SHA512;
8863 dgst_size = DGST_SIZE_8_16;
8864 parse_func = sha512grub_parse_hash;
8865 sort_by_digest = sort_by_digest_8_16;
8866 opti_type = OPTI_TYPE_ZERO_BYTE;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 1;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 3;
8871 break;
8872
8873 case 7300: hash_type = HASH_TYPE_SHA1;
8874 salt_type = SALT_TYPE_EMBEDDED;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_BE
8877 | OPTS_TYPE_ST_ADD80
8878 | OPTS_TYPE_ST_ADDBITS15;
8879 kern_type = KERN_TYPE_RAKP;
8880 dgst_size = DGST_SIZE_4_5;
8881 parse_func = rakp_parse_hash;
8882 sort_by_digest = sort_by_digest_4_5;
8883 opti_type = OPTI_TYPE_ZERO_BYTE
8884 | OPTI_TYPE_NOT_ITERATED;
8885 dgst_pos0 = 3;
8886 dgst_pos1 = 4;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 1;
8889 break;
8890
8891 case 7400: hash_type = HASH_TYPE_SHA256;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8895 kern_type = KERN_TYPE_SHA256CRYPT;
8896 dgst_size = DGST_SIZE_4_8;
8897 parse_func = sha256crypt_parse_hash;
8898 sort_by_digest = sort_by_digest_4_8;
8899 opti_type = OPTI_TYPE_ZERO_BYTE;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 7500: hash_type = HASH_TYPE_KRB5PA;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8910 kern_type = KERN_TYPE_KRB5PA;
8911 dgst_size = DGST_SIZE_4_4;
8912 parse_func = krb5pa_parse_hash;
8913 sort_by_digest = sort_by_digest_4_4;
8914 opti_type = OPTI_TYPE_ZERO_BYTE
8915 | OPTI_TYPE_NOT_ITERATED;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 7600: hash_type = HASH_TYPE_SHA1;
8923 salt_type = SALT_TYPE_INTERN;
8924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_BE
8926 | OPTS_TYPE_PT_ADD80
8927 | OPTS_TYPE_PT_ADDBITS15;
8928 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8929 dgst_size = DGST_SIZE_4_5;
8930 parse_func = redmine_parse_hash;
8931 sort_by_digest = sort_by_digest_4_5;
8932 opti_type = OPTI_TYPE_ZERO_BYTE
8933 | OPTI_TYPE_PRECOMPUTE_INIT
8934 | OPTI_TYPE_EARLY_SKIP
8935 | OPTI_TYPE_NOT_ITERATED
8936 | OPTI_TYPE_PREPENDED_SALT;
8937 dgst_pos0 = 3;
8938 dgst_pos1 = 4;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 1;
8941 break;
8942
8943 case 7700: hash_type = HASH_TYPE_SAPB;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_LE
8947 | OPTS_TYPE_PT_UPPER
8948 | OPTS_TYPE_ST_UPPER;
8949 kern_type = KERN_TYPE_SAPB;
8950 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8951 parse_func = sapb_parse_hash;
8952 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8953 opti_type = OPTI_TYPE_ZERO_BYTE
8954 | OPTI_TYPE_PRECOMPUTE_INIT
8955 | OPTI_TYPE_NOT_ITERATED;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 7800: hash_type = HASH_TYPE_SAPG;
8963 salt_type = SALT_TYPE_EMBEDDED;
8964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_BE
8966 | OPTS_TYPE_ST_ADD80
8967 | OPTS_TYPE_ST_UPPER;
8968 kern_type = KERN_TYPE_SAPG;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = sapg_parse_hash;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE
8973 | OPTI_TYPE_PRECOMPUTE_INIT
8974 | OPTI_TYPE_NOT_ITERATED;
8975 dgst_pos0 = 3;
8976 dgst_pos1 = 4;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 1;
8979 break;
8980
8981 case 7900: hash_type = HASH_TYPE_SHA512;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8985 kern_type = KERN_TYPE_DRUPAL7;
8986 dgst_size = DGST_SIZE_8_8;
8987 parse_func = drupal7_parse_hash;
8988 sort_by_digest = sort_by_digest_8_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 8000: hash_type = HASH_TYPE_SHA256;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_BE
9000 | OPTS_TYPE_PT_UNICODE
9001 | OPTS_TYPE_ST_ADD80
9002 | OPTS_TYPE_ST_HEX;
9003 kern_type = KERN_TYPE_SYBASEASE;
9004 dgst_size = DGST_SIZE_4_8;
9005 parse_func = sybasease_parse_hash;
9006 sort_by_digest = sort_by_digest_4_8;
9007 opti_type = OPTI_TYPE_ZERO_BYTE
9008 | OPTI_TYPE_PRECOMPUTE_INIT
9009 | OPTI_TYPE_EARLY_SKIP
9010 | OPTI_TYPE_NOT_ITERATED
9011 | OPTI_TYPE_RAW_HASH;
9012 dgst_pos0 = 3;
9013 dgst_pos1 = 7;
9014 dgst_pos2 = 2;
9015 dgst_pos3 = 6;
9016 break;
9017
9018 case 8100: hash_type = HASH_TYPE_SHA1;
9019 salt_type = SALT_TYPE_EMBEDDED;
9020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9021 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9022 kern_type = KERN_TYPE_NETSCALER;
9023 dgst_size = DGST_SIZE_4_5;
9024 parse_func = netscaler_parse_hash;
9025 sort_by_digest = sort_by_digest_4_5;
9026 opti_type = OPTI_TYPE_ZERO_BYTE
9027 | OPTI_TYPE_PRECOMPUTE_INIT
9028 | OPTI_TYPE_PRECOMPUTE_MERKLE
9029 | OPTI_TYPE_EARLY_SKIP
9030 | OPTI_TYPE_NOT_ITERATED
9031 | OPTI_TYPE_PREPENDED_SALT
9032 | OPTI_TYPE_RAW_HASH;
9033 dgst_pos0 = 3;
9034 dgst_pos1 = 4;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 1;
9037 break;
9038
9039 case 8200: hash_type = HASH_TYPE_SHA256;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_CLOUDKEY;
9044 dgst_size = DGST_SIZE_4_8;
9045 parse_func = cloudkey_parse_hash;
9046 sort_by_digest = sort_by_digest_4_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE;
9048 dgst_pos0 = 0;
9049 dgst_pos1 = 1;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 3;
9052 break;
9053
9054 case 8300: hash_type = HASH_TYPE_SHA1;
9055 salt_type = SALT_TYPE_EMBEDDED;
9056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE
9058 | OPTS_TYPE_ST_HEX
9059 | OPTS_TYPE_ST_ADD80;
9060 kern_type = KERN_TYPE_NSEC3;
9061 dgst_size = DGST_SIZE_4_5;
9062 parse_func = nsec3_parse_hash;
9063 sort_by_digest = sort_by_digest_4_5;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 3;
9066 dgst_pos1 = 4;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 1;
9069 break;
9070
9071 case 8400: hash_type = HASH_TYPE_SHA1;
9072 salt_type = SALT_TYPE_INTERN;
9073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_BE
9075 | OPTS_TYPE_PT_ADD80
9076 | OPTS_TYPE_PT_ADDBITS15;
9077 kern_type = KERN_TYPE_WBB3;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = wbb3_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_PRECOMPUTE_INIT
9083 | OPTI_TYPE_NOT_ITERATED;
9084 dgst_pos0 = 3;
9085 dgst_pos1 = 4;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 1;
9088 break;
9089
9090 case 8500: hash_type = HASH_TYPE_DESRACF;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE
9094 | OPTS_TYPE_ST_UPPER;
9095 kern_type = KERN_TYPE_RACF;
9096 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9097 parse_func = racf_parse_hash;
9098 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9099 opti_type = OPTI_TYPE_ZERO_BYTE
9100 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 8600: hash_type = HASH_TYPE_LOTUS5;
9108 salt_type = SALT_TYPE_NONE;
9109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_LOTUS5;
9112 dgst_size = DGST_SIZE_4_4;
9113 parse_func = lotus5_parse_hash;
9114 sort_by_digest = sort_by_digest_4_4;
9115 opti_type = OPTI_TYPE_EARLY_SKIP
9116 | OPTI_TYPE_NOT_ITERATED
9117 | OPTI_TYPE_NOT_SALTED
9118 | OPTI_TYPE_RAW_HASH;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 8700: hash_type = HASH_TYPE_LOTUS6;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9129 kern_type = KERN_TYPE_LOTUS6;
9130 dgst_size = DGST_SIZE_4_4;
9131 parse_func = lotus6_parse_hash;
9132 sort_by_digest = sort_by_digest_4_4;
9133 opti_type = OPTI_TYPE_EARLY_SKIP
9134 | OPTI_TYPE_NOT_ITERATED
9135 | OPTI_TYPE_RAW_HASH;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9146 kern_type = KERN_TYPE_ANDROIDFDE;
9147 dgst_size = DGST_SIZE_4_4;
9148 parse_func = androidfde_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 8900: hash_type = HASH_TYPE_SCRYPT;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9161 kern_type = KERN_TYPE_SCRYPT;
9162 dgst_size = DGST_SIZE_4_8;
9163 parse_func = scrypt_parse_hash;
9164 sort_by_digest = sort_by_digest_4_8;
9165 opti_type = OPTI_TYPE_ZERO_BYTE;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 9000: hash_type = HASH_TYPE_SHA1;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE
9176 | OPTS_TYPE_ST_GENERATE_LE;
9177 kern_type = KERN_TYPE_PSAFE2;
9178 dgst_size = DGST_SIZE_4_5;
9179 parse_func = psafe2_parse_hash;
9180 sort_by_digest = sort_by_digest_4_5;
9181 opti_type = OPTI_TYPE_ZERO_BYTE;
9182 dgst_pos0 = 0;
9183 dgst_pos1 = 1;
9184 dgst_pos2 = 2;
9185 dgst_pos3 = 3;
9186 break;
9187
9188 case 9100: hash_type = HASH_TYPE_LOTUS8;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9192 kern_type = KERN_TYPE_LOTUS8;
9193 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9194 parse_func = lotus8_parse_hash;
9195 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9196 opti_type = OPTI_TYPE_ZERO_BYTE;
9197 dgst_pos0 = 0;
9198 dgst_pos1 = 1;
9199 dgst_pos2 = 2;
9200 dgst_pos3 = 3;
9201 break;
9202
9203 case 9200: hash_type = HASH_TYPE_SHA256;
9204 salt_type = SALT_TYPE_EMBEDDED;
9205 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9206 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9207 kern_type = KERN_TYPE_PBKDF2_SHA256;
9208 dgst_size = DGST_SIZE_4_32;
9209 parse_func = cisco8_parse_hash;
9210 sort_by_digest = sort_by_digest_4_32;
9211 opti_type = OPTI_TYPE_ZERO_BYTE;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 9300: hash_type = HASH_TYPE_SCRYPT;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9222 kern_type = KERN_TYPE_SCRYPT;
9223 dgst_size = DGST_SIZE_4_8;
9224 parse_func = cisco9_parse_hash;
9225 sort_by_digest = sort_by_digest_4_8;
9226 opti_type = OPTI_TYPE_ZERO_BYTE;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9234 salt_type = SALT_TYPE_EMBEDDED;
9235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9237 kern_type = KERN_TYPE_OFFICE2007;
9238 dgst_size = DGST_SIZE_4_4;
9239 parse_func = office2007_parse_hash;
9240 sort_by_digest = sort_by_digest_4_4;
9241 opti_type = OPTI_TYPE_ZERO_BYTE;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9252 kern_type = KERN_TYPE_OFFICE2010;
9253 dgst_size = DGST_SIZE_4_4;
9254 parse_func = office2010_parse_hash;
9255 sort_by_digest = sort_by_digest_4_4;
9256 opti_type = OPTI_TYPE_ZERO_BYTE;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9267 kern_type = KERN_TYPE_OFFICE2013;
9268 dgst_size = DGST_SIZE_4_4;
9269 parse_func = office2013_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE
9282 | OPTS_TYPE_PT_ADD80
9283 | OPTS_TYPE_PT_UNICODE;
9284 kern_type = KERN_TYPE_OLDOFFICE01;
9285 dgst_size = DGST_SIZE_4_4;
9286 parse_func = oldoffice01_parse_hash;
9287 sort_by_digest = sort_by_digest_4_4;
9288 opti_type = OPTI_TYPE_ZERO_BYTE
9289 | OPTI_TYPE_PRECOMPUTE_INIT
9290 | OPTI_TYPE_NOT_ITERATED;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 1;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 3;
9295 break;
9296
9297 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE
9301 | OPTS_TYPE_PT_ADD80;
9302 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9303 dgst_size = DGST_SIZE_4_4;
9304 parse_func = oldoffice01cm1_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4;
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_PRECOMPUTE_INIT
9308 | OPTI_TYPE_NOT_ITERATED;
9309 dgst_pos0 = 0;
9310 dgst_pos1 = 1;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 3;
9313 break;
9314
9315 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9316 salt_type = SALT_TYPE_EMBEDDED;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_LE
9319 | OPTS_TYPE_PT_ADD80
9320 | OPTS_TYPE_PT_UNICODE
9321 | OPTS_TYPE_PT_NEVERCRACK;
9322 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9323 dgst_size = DGST_SIZE_4_4;
9324 parse_func = oldoffice01cm2_parse_hash;
9325 sort_by_digest = sort_by_digest_4_4;
9326 opti_type = OPTI_TYPE_ZERO_BYTE
9327 | OPTI_TYPE_PRECOMPUTE_INIT
9328 | OPTI_TYPE_NOT_ITERATED;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_BE
9339 | OPTS_TYPE_PT_ADD80
9340 | OPTS_TYPE_PT_UNICODE;
9341 kern_type = KERN_TYPE_OLDOFFICE34;
9342 dgst_size = DGST_SIZE_4_4;
9343 parse_func = oldoffice34_parse_hash;
9344 sort_by_digest = sort_by_digest_4_4;
9345 opti_type = OPTI_TYPE_ZERO_BYTE
9346 | OPTI_TYPE_PRECOMPUTE_INIT
9347 | OPTI_TYPE_NOT_ITERATED;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9355 salt_type = SALT_TYPE_EMBEDDED;
9356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9358 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9359 dgst_size = DGST_SIZE_4_4;
9360 parse_func = oldoffice34cm1_parse_hash;
9361 sort_by_digest = sort_by_digest_4_4;
9362 opti_type = OPTI_TYPE_ZERO_BYTE
9363 | OPTI_TYPE_PRECOMPUTE_INIT
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_BE
9375 | OPTS_TYPE_PT_ADD80
9376 | OPTS_TYPE_PT_UNICODE
9377 | OPTS_TYPE_PT_NEVERCRACK;
9378 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9379 dgst_size = DGST_SIZE_4_4;
9380 parse_func = oldoffice34cm2_parse_hash;
9381 sort_by_digest = sort_by_digest_4_4;
9382 opti_type = OPTI_TYPE_ZERO_BYTE
9383 | OPTI_TYPE_PRECOMPUTE_INIT
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 9900: hash_type = HASH_TYPE_MD5;
9392 salt_type = SALT_TYPE_NONE;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_RADMIN2;
9396 dgst_size = DGST_SIZE_4_4;
9397 parse_func = radmin2_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4;
9399 opti_type = OPTI_TYPE_ZERO_BYTE
9400 | OPTI_TYPE_PRECOMPUTE_INIT
9401 | OPTI_TYPE_EARLY_SKIP
9402 | OPTI_TYPE_NOT_ITERATED
9403 | OPTI_TYPE_NOT_SALTED;
9404 dgst_pos0 = 0;
9405 dgst_pos1 = 3;
9406 dgst_pos2 = 2;
9407 dgst_pos3 = 1;
9408 break;
9409
9410 case 10000: hash_type = HASH_TYPE_SHA256;
9411 salt_type = SALT_TYPE_EMBEDDED;
9412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9413 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9414 kern_type = KERN_TYPE_PBKDF2_SHA256;
9415 dgst_size = DGST_SIZE_4_32;
9416 parse_func = djangopbkdf2_parse_hash;
9417 sort_by_digest = sort_by_digest_4_32;
9418 opti_type = OPTI_TYPE_ZERO_BYTE;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 10100: hash_type = HASH_TYPE_SIPHASH;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9429 kern_type = KERN_TYPE_SIPHASH;
9430 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9431 parse_func = siphash_parse_hash;
9432 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9433 opti_type = OPTI_TYPE_ZERO_BYTE
9434 | OPTI_TYPE_NOT_ITERATED
9435 | OPTI_TYPE_RAW_HASH;
9436 dgst_pos0 = 0;
9437 dgst_pos1 = 1;
9438 dgst_pos2 = 2;
9439 dgst_pos3 = 3;
9440 break;
9441
9442 case 10200: hash_type = HASH_TYPE_MD5;
9443 salt_type = SALT_TYPE_EMBEDDED;
9444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9445 opts_type = OPTS_TYPE_PT_GENERATE_LE
9446 | OPTS_TYPE_ST_ADD80
9447 | OPTS_TYPE_ST_ADDBITS14;
9448 kern_type = KERN_TYPE_HMACMD5_PW;
9449 dgst_size = DGST_SIZE_4_4;
9450 parse_func = crammd5_parse_hash;
9451 sort_by_digest = sort_by_digest_4_4;
9452 opti_type = OPTI_TYPE_ZERO_BYTE
9453 | OPTI_TYPE_NOT_ITERATED;
9454 dgst_pos0 = 0;
9455 dgst_pos1 = 3;
9456 dgst_pos2 = 2;
9457 dgst_pos3 = 1;
9458 break;
9459
9460 case 10300: hash_type = HASH_TYPE_SHA1;
9461 salt_type = SALT_TYPE_EMBEDDED;
9462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9463 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9464 kern_type = KERN_TYPE_SAPH_SHA1;
9465 dgst_size = DGST_SIZE_4_5;
9466 parse_func = saph_sha1_parse_hash;
9467 sort_by_digest = sort_by_digest_4_5;
9468 opti_type = OPTI_TYPE_ZERO_BYTE;
9469 dgst_pos0 = 0;
9470 dgst_pos1 = 1;
9471 dgst_pos2 = 2;
9472 dgst_pos3 = 3;
9473 break;
9474
9475 case 10400: hash_type = HASH_TYPE_PDFU16;
9476 salt_type = SALT_TYPE_EMBEDDED;
9477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9478 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9479 kern_type = KERN_TYPE_PDF11;
9480 dgst_size = DGST_SIZE_4_4;
9481 parse_func = pdf11_parse_hash;
9482 sort_by_digest = sort_by_digest_4_4;
9483 opti_type = OPTI_TYPE_ZERO_BYTE
9484 | OPTI_TYPE_NOT_ITERATED;
9485 dgst_pos0 = 0;
9486 dgst_pos1 = 1;
9487 dgst_pos2 = 2;
9488 dgst_pos3 = 3;
9489 break;
9490
9491 case 10410: hash_type = HASH_TYPE_PDFU16;
9492 salt_type = SALT_TYPE_EMBEDDED;
9493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9494 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9495 kern_type = KERN_TYPE_PDF11CM1;
9496 dgst_size = DGST_SIZE_4_4;
9497 parse_func = pdf11cm1_parse_hash;
9498 sort_by_digest = sort_by_digest_4_4;
9499 opti_type = OPTI_TYPE_ZERO_BYTE
9500 | OPTI_TYPE_NOT_ITERATED;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 1;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 3;
9505 break;
9506
9507 case 10420: hash_type = HASH_TYPE_PDFU16;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9511 kern_type = KERN_TYPE_PDF11CM2;
9512 dgst_size = DGST_SIZE_4_4;
9513 parse_func = pdf11cm2_parse_hash;
9514 sort_by_digest = sort_by_digest_4_4;
9515 opti_type = OPTI_TYPE_ZERO_BYTE
9516 | OPTI_TYPE_NOT_ITERATED;
9517 dgst_pos0 = 0;
9518 dgst_pos1 = 1;
9519 dgst_pos2 = 2;
9520 dgst_pos3 = 3;
9521 break;
9522
9523 case 10500: hash_type = HASH_TYPE_PDFU16;
9524 salt_type = SALT_TYPE_EMBEDDED;
9525 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9526 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9527 kern_type = KERN_TYPE_PDF14;
9528 dgst_size = DGST_SIZE_4_4;
9529 parse_func = pdf14_parse_hash;
9530 sort_by_digest = sort_by_digest_4_4;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_NOT_ITERATED;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 10600: hash_type = HASH_TYPE_SHA256;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_BE
9543 | OPTS_TYPE_ST_ADD80
9544 | OPTS_TYPE_ST_ADDBITS15
9545 | OPTS_TYPE_HASH_COPY;
9546 kern_type = KERN_TYPE_SHA256_PWSLT;
9547 dgst_size = DGST_SIZE_4_8;
9548 parse_func = pdf17l3_parse_hash;
9549 sort_by_digest = sort_by_digest_4_8;
9550 opti_type = OPTI_TYPE_ZERO_BYTE
9551 | OPTI_TYPE_PRECOMPUTE_INIT
9552 | OPTI_TYPE_PRECOMPUTE_MERKLE
9553 | OPTI_TYPE_EARLY_SKIP
9554 | OPTI_TYPE_NOT_ITERATED
9555 | OPTI_TYPE_APPENDED_SALT
9556 | OPTI_TYPE_RAW_HASH;
9557 dgst_pos0 = 3;
9558 dgst_pos1 = 7;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 6;
9561 break;
9562
9563 case 10700: hash_type = HASH_TYPE_PDFU32;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_HASH_COPY;
9568 kern_type = KERN_TYPE_PDF17L8;
9569 dgst_size = DGST_SIZE_4_8;
9570 parse_func = pdf17l8_parse_hash;
9571 sort_by_digest = sort_by_digest_4_8;
9572 opti_type = OPTI_TYPE_ZERO_BYTE
9573 | OPTI_TYPE_NOT_ITERATED;
9574 dgst_pos0 = 0;
9575 dgst_pos1 = 1;
9576 dgst_pos2 = 2;
9577 dgst_pos3 = 3;
9578 break;
9579
9580 case 10800: hash_type = HASH_TYPE_SHA384;
9581 salt_type = SALT_TYPE_NONE;
9582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9583 opts_type = OPTS_TYPE_PT_GENERATE_BE
9584 | OPTS_TYPE_PT_ADD80
9585 | OPTS_TYPE_PT_ADDBITS15;
9586 kern_type = KERN_TYPE_SHA384;
9587 dgst_size = DGST_SIZE_8_8;
9588 parse_func = sha384_parse_hash;
9589 sort_by_digest = sort_by_digest_8_8;
9590 opti_type = OPTI_TYPE_ZERO_BYTE
9591 | OPTI_TYPE_PRECOMPUTE_INIT
9592 | OPTI_TYPE_PRECOMPUTE_MERKLE
9593 | OPTI_TYPE_EARLY_SKIP
9594 | OPTI_TYPE_NOT_ITERATED
9595 | OPTI_TYPE_NOT_SALTED
9596 | OPTI_TYPE_RAW_HASH;
9597 dgst_pos0 = 6;
9598 dgst_pos1 = 7;
9599 dgst_pos2 = 4;
9600 dgst_pos3 = 5;
9601 break;
9602
9603 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE
9607 | OPTS_TYPE_ST_BASE64
9608 | OPTS_TYPE_HASH_COPY;
9609 kern_type = KERN_TYPE_PBKDF2_SHA256;
9610 dgst_size = DGST_SIZE_4_32;
9611 parse_func = pbkdf2_sha256_parse_hash;
9612 sort_by_digest = sort_by_digest_4_32;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 11000: hash_type = HASH_TYPE_MD5;
9621 salt_type = SALT_TYPE_INTERN;
9622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE
9624 | OPTS_TYPE_PT_ADD80;
9625 kern_type = KERN_TYPE_PRESTASHOP;
9626 dgst_size = DGST_SIZE_4_4;
9627 parse_func = prestashop_parse_hash;
9628 sort_by_digest = sort_by_digest_4_4;
9629 opti_type = OPTI_TYPE_ZERO_BYTE
9630 | OPTI_TYPE_PRECOMPUTE_INIT
9631 | OPTI_TYPE_NOT_ITERATED
9632 | OPTI_TYPE_PREPENDED_SALT;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 3;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 1;
9637 break;
9638
9639 case 11100: hash_type = HASH_TYPE_MD5;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE
9643 | OPTS_TYPE_ST_ADD80;
9644 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9645 dgst_size = DGST_SIZE_4_4;
9646 parse_func = postgresql_auth_parse_hash;
9647 sort_by_digest = sort_by_digest_4_4;
9648 opti_type = OPTI_TYPE_ZERO_BYTE
9649 | OPTI_TYPE_PRECOMPUTE_INIT
9650 | OPTI_TYPE_PRECOMPUTE_MERKLE
9651 | OPTI_TYPE_EARLY_SKIP;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 3;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 1;
9656 break;
9657
9658 case 11200: hash_type = HASH_TYPE_SHA1;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_BE
9662 | OPTS_TYPE_PT_ADD80
9663 | OPTS_TYPE_ST_HEX;
9664 kern_type = KERN_TYPE_MYSQL_AUTH;
9665 dgst_size = DGST_SIZE_4_5;
9666 parse_func = mysql_auth_parse_hash;
9667 sort_by_digest = sort_by_digest_4_5;
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_EARLY_SKIP;
9670 dgst_pos0 = 3;
9671 dgst_pos1 = 4;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 1;
9674 break;
9675
9676 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9677 salt_type = SALT_TYPE_EMBEDDED;
9678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE
9680 | OPTS_TYPE_ST_HEX
9681 | OPTS_TYPE_ST_ADD80;
9682 kern_type = KERN_TYPE_BITCOIN_WALLET;
9683 dgst_size = DGST_SIZE_4_4;
9684 parse_func = bitcoin_wallet_parse_hash;
9685 sort_by_digest = sort_by_digest_4_4;
9686 opti_type = OPTI_TYPE_ZERO_BYTE;
9687 dgst_pos0 = 0;
9688 dgst_pos1 = 1;
9689 dgst_pos2 = 2;
9690 dgst_pos3 = 3;
9691 break;
9692
9693 case 11400: hash_type = HASH_TYPE_MD5;
9694 salt_type = SALT_TYPE_EMBEDDED;
9695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9696 opts_type = OPTS_TYPE_PT_GENERATE_LE
9697 | OPTS_TYPE_PT_ADD80
9698 | OPTS_TYPE_HASH_COPY;
9699 kern_type = KERN_TYPE_SIP_AUTH;
9700 dgst_size = DGST_SIZE_4_4;
9701 parse_func = sip_auth_parse_hash;
9702 sort_by_digest = sort_by_digest_4_4;
9703 opti_type = OPTI_TYPE_ZERO_BYTE;
9704 dgst_pos0 = 0;
9705 dgst_pos1 = 3;
9706 dgst_pos2 = 2;
9707 dgst_pos3 = 1;
9708 break;
9709
9710 case 11500: hash_type = HASH_TYPE_CRC32;
9711 salt_type = SALT_TYPE_INTERN;
9712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9713 opts_type = OPTS_TYPE_PT_GENERATE_LE
9714 | OPTS_TYPE_ST_GENERATE_LE
9715 | OPTS_TYPE_ST_HEX;
9716 kern_type = KERN_TYPE_CRC32;
9717 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9718 parse_func = crc32_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9720 opti_type = OPTI_TYPE_ZERO_BYTE;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 11600: hash_type = HASH_TYPE_AES;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE
9731 | OPTS_TYPE_PT_NEVERCRACK;
9732 kern_type = KERN_TYPE_SEVEN_ZIP;
9733 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9734 parse_func = seven_zip_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9736 opti_type = OPTI_TYPE_ZERO_BYTE;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9744 salt_type = SALT_TYPE_NONE;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_LE
9747 | OPTS_TYPE_PT_ADD01;
9748 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9749 dgst_size = DGST_SIZE_4_8;
9750 parse_func = gost2012sbog_256_parse_hash;
9751 sort_by_digest = sort_by_digest_4_8;
9752 opti_type = OPTI_TYPE_ZERO_BYTE;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9760 salt_type = SALT_TYPE_NONE;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE
9763 | OPTS_TYPE_PT_ADD01;
9764 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9765 dgst_size = DGST_SIZE_4_16;
9766 parse_func = gost2012sbog_512_parse_hash;
9767 sort_by_digest = sort_by_digest_4_16;
9768 opti_type = OPTI_TYPE_ZERO_BYTE;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9776 salt_type = SALT_TYPE_EMBEDDED;
9777 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_LE
9779 | OPTS_TYPE_ST_BASE64
9780 | OPTS_TYPE_HASH_COPY;
9781 kern_type = KERN_TYPE_PBKDF2_MD5;
9782 dgst_size = DGST_SIZE_4_32;
9783 parse_func = pbkdf2_md5_parse_hash;
9784 sort_by_digest = sort_by_digest_4_32;
9785 opti_type = OPTI_TYPE_ZERO_BYTE;
9786 dgst_pos0 = 0;
9787 dgst_pos1 = 1;
9788 dgst_pos2 = 2;
9789 dgst_pos3 = 3;
9790 break;
9791
9792 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9793 salt_type = SALT_TYPE_EMBEDDED;
9794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9795 opts_type = OPTS_TYPE_PT_GENERATE_LE
9796 | OPTS_TYPE_ST_BASE64
9797 | OPTS_TYPE_HASH_COPY;
9798 kern_type = KERN_TYPE_PBKDF2_SHA1;
9799 dgst_size = DGST_SIZE_4_32;
9800 parse_func = pbkdf2_sha1_parse_hash;
9801 sort_by_digest = sort_by_digest_4_32;
9802 opti_type = OPTI_TYPE_ZERO_BYTE;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE
9813 | OPTS_TYPE_ST_BASE64
9814 | OPTS_TYPE_HASH_COPY;
9815 kern_type = KERN_TYPE_PBKDF2_SHA512;
9816 dgst_size = DGST_SIZE_8_16;
9817 parse_func = pbkdf2_sha512_parse_hash;
9818 sort_by_digest = sort_by_digest_8_16;
9819 opti_type = OPTI_TYPE_ZERO_BYTE;
9820 dgst_pos0 = 0;
9821 dgst_pos1 = 1;
9822 dgst_pos2 = 2;
9823 dgst_pos3 = 3;
9824 break;
9825
9826 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9827 salt_type = SALT_TYPE_EMBEDDED;
9828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9830 kern_type = KERN_TYPE_ECRYPTFS;
9831 dgst_size = DGST_SIZE_8_8;
9832 parse_func = ecryptfs_parse_hash;
9833 sort_by_digest = sort_by_digest_8_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE;
9835 dgst_pos0 = 0;
9836 dgst_pos1 = 1;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 3;
9839 break;
9840
9841 case 12300: hash_type = HASH_TYPE_ORACLET;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9845 kern_type = KERN_TYPE_ORACLET;
9846 dgst_size = DGST_SIZE_8_16;
9847 parse_func = oraclet_parse_hash;
9848 sort_by_digest = sort_by_digest_8_16;
9849 opti_type = OPTI_TYPE_ZERO_BYTE;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 1;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 3;
9854 break;
9855
9856 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9860 kern_type = KERN_TYPE_BSDICRYPT;
9861 dgst_size = DGST_SIZE_4_4;
9862 parse_func = bsdicrypt_parse_hash;
9863 sort_by_digest = sort_by_digest_4_4;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 1;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 3;
9870 break;
9871
9872 case 12500: hash_type = HASH_TYPE_RAR3HP;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9876 kern_type = KERN_TYPE_RAR3;
9877 dgst_size = DGST_SIZE_4_4;
9878 parse_func = rar3hp_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4;
9880 opti_type = OPTI_TYPE_ZERO_BYTE;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 12600: hash_type = HASH_TYPE_SHA256;
9888 salt_type = SALT_TYPE_INTERN;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_BE
9891 | OPTS_TYPE_PT_ADD80;
9892 kern_type = KERN_TYPE_CF10;
9893 dgst_size = DGST_SIZE_4_8;
9894 parse_func = cf10_parse_hash;
9895 sort_by_digest = sort_by_digest_4_8;
9896 opti_type = OPTI_TYPE_ZERO_BYTE
9897 | OPTI_TYPE_PRECOMPUTE_INIT
9898 | OPTI_TYPE_EARLY_SKIP
9899 | OPTI_TYPE_NOT_ITERATED;
9900 dgst_pos0 = 3;
9901 dgst_pos1 = 7;
9902 dgst_pos2 = 2;
9903 dgst_pos3 = 6;
9904 break;
9905
9906 case 12700: hash_type = HASH_TYPE_AES;
9907 salt_type = SALT_TYPE_EMBEDDED;
9908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9909 opts_type = OPTS_TYPE_PT_GENERATE_LE
9910 | OPTS_TYPE_HASH_COPY;
9911 kern_type = KERN_TYPE_MYWALLET;
9912 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9913 parse_func = mywallet_parse_hash;
9914 sort_by_digest = sort_by_digest_4_5;
9915 opti_type = OPTI_TYPE_ZERO_BYTE;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_MS_DRSR;
9927 dgst_size = DGST_SIZE_4_8;
9928 parse_func = ms_drsr_parse_hash;
9929 sort_by_digest = sort_by_digest_4_8;
9930 opti_type = OPTI_TYPE_ZERO_BYTE;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 1;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 3;
9935 break;
9936
9937 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9941 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9942 dgst_size = DGST_SIZE_4_8;
9943 parse_func = androidfde_samsung_parse_hash;
9944 sort_by_digest = sort_by_digest_4_8;
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9956 kern_type = KERN_TYPE_RAR5;
9957 dgst_size = DGST_SIZE_4_4;
9958 parse_func = rar5_parse_hash;
9959 sort_by_digest = sort_by_digest_4_4;
9960 opti_type = OPTI_TYPE_ZERO_BYTE;
9961 dgst_pos0 = 0;
9962 dgst_pos1 = 1;
9963 dgst_pos2 = 2;
9964 dgst_pos3 = 3;
9965 break;
9966
9967 default: usage_mini_print (PROGNAME); return (-1);
9968 }
9969
9970 /**
9971 * transpose
9972 */
9973
9974 data.parse_func = parse_func;
9975
9976 /**
9977 * misc stuff
9978 */
9979
9980 if (hex_salt)
9981 {
9982 if (salt_type == SALT_TYPE_INTERN)
9983 {
9984 opts_type |= OPTS_TYPE_ST_HEX;
9985 }
9986 else
9987 {
9988 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9989
9990 return (-1);
9991 }
9992 }
9993
9994 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9995 | (salt_type == SALT_TYPE_EXTERN)
9996 | (salt_type == SALT_TYPE_EMBEDDED)
9997 | (salt_type == SALT_TYPE_VIRTUAL));
9998
9999 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10000
10001 data.hash_type = hash_type;
10002 data.attack_mode = attack_mode;
10003 data.attack_kern = attack_kern;
10004 data.attack_exec = attack_exec;
10005 data.kern_type = kern_type;
10006 data.opts_type = opts_type;
10007 data.dgst_size = dgst_size;
10008 data.salt_type = salt_type;
10009 data.isSalted = isSalted;
10010 data.sort_by_digest = sort_by_digest;
10011 data.dgst_pos0 = dgst_pos0;
10012 data.dgst_pos1 = dgst_pos1;
10013 data.dgst_pos2 = dgst_pos2;
10014 data.dgst_pos3 = dgst_pos3;
10015
10016 esalt_size = 0;
10017
10018 switch (hash_mode)
10019 {
10020 case 2500: esalt_size = sizeof (wpa_t); break;
10021 case 5300: esalt_size = sizeof (ikepsk_t); break;
10022 case 5400: esalt_size = sizeof (ikepsk_t); break;
10023 case 5500: esalt_size = sizeof (netntlm_t); break;
10024 case 5600: esalt_size = sizeof (netntlm_t); break;
10025 case 6211:
10026 case 6212:
10027 case 6213:
10028 case 6221:
10029 case 6222:
10030 case 6223:
10031 case 6231:
10032 case 6232:
10033 case 6233:
10034 case 6241:
10035 case 6242:
10036 case 6243: esalt_size = sizeof (tc_t); break;
10037 case 6600: esalt_size = sizeof (agilekey_t); break;
10038 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10039 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10040 case 7300: esalt_size = sizeof (rakp_t); break;
10041 case 7500: esalt_size = sizeof (krb5pa_t); break;
10042 case 8200: esalt_size = sizeof (cloudkey_t); break;
10043 case 8800: esalt_size = sizeof (androidfde_t); break;
10044 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10045 case 9400: esalt_size = sizeof (office2007_t); break;
10046 case 9500: esalt_size = sizeof (office2010_t); break;
10047 case 9600: esalt_size = sizeof (office2013_t); break;
10048 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10049 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10050 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10051 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10052 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10053 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10054 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10055 case 10200: esalt_size = sizeof (cram_md5_t); break;
10056 case 10400: esalt_size = sizeof (pdf_t); break;
10057 case 10410: esalt_size = sizeof (pdf_t); break;
10058 case 10420: esalt_size = sizeof (pdf_t); break;
10059 case 10500: esalt_size = sizeof (pdf_t); break;
10060 case 10600: esalt_size = sizeof (pdf_t); break;
10061 case 10700: esalt_size = sizeof (pdf_t); break;
10062 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10063 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10064 case 11400: esalt_size = sizeof (sip_t); break;
10065 case 11600: esalt_size = sizeof (seven_zip_t); break;
10066 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10067 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10068 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10069 case 13000: esalt_size = sizeof (rar5_t); break;
10070 }
10071
10072 data.esalt_size = esalt_size;
10073
10074 /**
10075 * choose dictionary parser
10076 */
10077
10078 if (hash_type == HASH_TYPE_LM)
10079 {
10080 get_next_word_func = get_next_word_lm;
10081 }
10082 else if (opts_type & OPTS_TYPE_PT_UPPER)
10083 {
10084 get_next_word_func = get_next_word_uc;
10085 }
10086 else
10087 {
10088 get_next_word_func = get_next_word_std;
10089 }
10090
10091 /**
10092 * dictstat
10093 */
10094
10095 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10096
10097 #ifdef _POSIX
10098 size_t dictstat_nmemb = 0;
10099 #endif
10100
10101 #ifdef _WIN
10102 uint dictstat_nmemb = 0;
10103 #endif
10104
10105 char dictstat[256];
10106
10107 FILE *dictstat_fp = NULL;
10108
10109 if (keyspace == 0)
10110 {
10111 memset (dictstat, 0, sizeof (dictstat));
10112
10113 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10114
10115 dictstat_fp = fopen (dictstat, "rb");
10116
10117 if (dictstat_fp)
10118 {
10119 #ifdef _POSIX
10120 struct stat tmpstat;
10121
10122 fstat (fileno (dictstat_fp), &tmpstat);
10123 #endif
10124
10125 #ifdef _WIN
10126 struct stat64 tmpstat;
10127
10128 _fstat64 (fileno (dictstat_fp), &tmpstat);
10129 #endif
10130
10131 if (tmpstat.st_mtime < COMPTIME)
10132 {
10133 /* with v0.15 the format changed so we have to ensure user is using a good version
10134 since there is no version-header in the dictstat file */
10135
10136 fclose (dictstat_fp);
10137
10138 unlink (dictstat);
10139 }
10140 else
10141 {
10142 while (!feof (dictstat_fp))
10143 {
10144 dictstat_t d;
10145
10146 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10147
10148 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10149
10150 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10151 {
10152 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10153
10154 return -1;
10155 }
10156 }
10157
10158 fclose (dictstat_fp);
10159 }
10160 }
10161 }
10162
10163 /**
10164 * potfile
10165 */
10166
10167 char potfile[256] = { 0 };
10168
10169 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10170
10171 data.pot_fp = NULL;
10172
10173 FILE *out_fp = NULL;
10174 FILE *pot_fp = NULL;
10175
10176 if (show == 1 || left == 1)
10177 {
10178 pot_fp = fopen (potfile, "rb");
10179
10180 if (pot_fp == NULL)
10181 {
10182 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10183
10184 return (-1);
10185 }
10186
10187 if (outfile != NULL)
10188 {
10189 if ((out_fp = fopen (outfile, "ab")) == NULL)
10190 {
10191 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10192
10193 fclose (pot_fp);
10194
10195 return (-1);
10196 }
10197 }
10198 else
10199 {
10200 out_fp = stdout;
10201 }
10202 }
10203 else
10204 {
10205 if (potfile_disable == 0)
10206 {
10207 pot_fp = fopen (potfile, "ab");
10208
10209 if (pot_fp == NULL)
10210 {
10211 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10212
10213 return (-1);
10214 }
10215
10216 data.pot_fp = pot_fp;
10217 }
10218 }
10219
10220 pot_t *pot = NULL;
10221
10222 uint pot_cnt = 0;
10223 uint pot_avail = 0;
10224
10225 if (show == 1 || left == 1)
10226 {
10227 SUPPRESS_OUTPUT = 1;
10228
10229 pot_avail = count_lines (pot_fp);
10230
10231 rewind (pot_fp);
10232
10233 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10234
10235 uint pot_hashes_avail = 0;
10236
10237 uint line_num = 0;
10238
10239 while (!feof (pot_fp))
10240 {
10241 line_num++;
10242
10243 char line_buf[BUFSIZ];
10244
10245 int line_len = fgetl (pot_fp, line_buf);
10246
10247 if (line_len == 0) continue;
10248
10249 char *plain_buf = line_buf + line_len;
10250
10251 pot_t *pot_ptr = &pot[pot_cnt];
10252
10253 hash_t *hashes_buf = &pot_ptr->hash;
10254
10255 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10256 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10257
10258 if (pot_cnt == pot_hashes_avail)
10259 {
10260 uint pos = 0;
10261
10262 for (pos = 0; pos < INCR_POT; pos++)
10263 {
10264 if ((pot_cnt + pos) >= pot_avail) break;
10265
10266 pot_t *tmp_pot = &pot[pot_cnt + pos];
10267
10268 hash_t *tmp_hash = &tmp_pot->hash;
10269
10270 tmp_hash->digest = mymalloc (dgst_size);
10271
10272 if (isSalted)
10273 {
10274 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10275 }
10276
10277 if (esalt_size)
10278 {
10279 tmp_hash->esalt = mymalloc (esalt_size);
10280 }
10281
10282 pot_hashes_avail++;
10283 }
10284 }
10285
10286 int plain_len = 0;
10287
10288 int parser_status;
10289
10290 int iter = MAX_CUT_TRIES;
10291
10292 do
10293 {
10294 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10295 {
10296 if (line_buf[i] == ':')
10297 {
10298 line_len--;
10299
10300 break;
10301 }
10302 }
10303
10304 if (data.hash_mode != 2500)
10305 {
10306 parser_status = parse_func (line_buf, line_len, hashes_buf);
10307 }
10308 else
10309 {
10310 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10311
10312 if (line_len > max_salt_size)
10313 {
10314 parser_status = PARSER_GLOBAL_LENGTH;
10315 }
10316 else
10317 {
10318 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10319
10320 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10321
10322 hashes_buf->salt->salt_len = line_len;
10323
10324 parser_status = PARSER_OK;
10325 }
10326 }
10327
10328 // if NOT parsed without error, we add the ":" to the plain
10329
10330 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10331 {
10332 plain_len++;
10333 plain_buf--;
10334 }
10335
10336 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10337
10338 if (parser_status < PARSER_GLOBAL_ZERO)
10339 {
10340 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10341
10342 continue;
10343 }
10344
10345 if (plain_len >= 255) continue;
10346
10347 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10348
10349 pot_ptr->plain_len = plain_len;
10350
10351 pot_cnt++;
10352 }
10353
10354 fclose (pot_fp);
10355
10356 SUPPRESS_OUTPUT = 0;
10357
10358 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10359 }
10360
10361 /**
10362 * kernel accel and loops auto adjustment
10363 */
10364
10365 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10366 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10367
10368 if (workload_profile == 1)
10369 {
10370 kernel_loops /= 8;
10371 kernel_accel /= 4;
10372
10373 if (kernel_loops == 0) kernel_loops = 8;
10374 if (kernel_accel == 0) kernel_accel = 2;
10375 }
10376 else if (workload_profile == 3)
10377 {
10378 kernel_loops *= 8;
10379 kernel_accel *= 4;
10380
10381 if (kernel_loops > 1024) kernel_loops = 1024;
10382 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10383 }
10384
10385 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10386
10387 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10388 {
10389 kernel_loops = 1024;
10390 }
10391
10392 if (hash_mode == 12500)
10393 {
10394 kernel_loops = ROUNDS_RAR3 / 16;
10395 }
10396
10397 data.kernel_accel = kernel_accel;
10398 data.kernel_loops = kernel_loops;
10399
10400 /**
10401 * word len
10402 */
10403
10404 uint pw_min = PW_MIN;
10405 uint pw_max = PW_MAX;
10406
10407 switch (hash_mode)
10408 {
10409 case 400: if (pw_max > 40) pw_max = 40;
10410 break;
10411 case 500: if (pw_max > 16) pw_max = 16;
10412 break;
10413 case 1500: if (pw_max > 8) pw_max = 8;
10414 break;
10415 case 1600: if (pw_max > 16) pw_max = 16;
10416 break;
10417 case 1800: if (pw_max > 16) pw_max = 16;
10418 break;
10419 case 2100: if (pw_max > 16) pw_max = 16;
10420 break;
10421 case 2500: if (pw_min < 8) pw_min = 8;
10422 break;
10423 case 3000: if (pw_max > 7) pw_max = 7;
10424 break;
10425 case 5200: if (pw_max > 24) pw_max = 24;
10426 break;
10427 case 5800: if (pw_max > 16) pw_max = 16;
10428 break;
10429 case 6300: if (pw_max > 16) pw_max = 16;
10430 break;
10431 case 7400: if (pw_max > 16) pw_max = 16;
10432 break;
10433 case 7900: if (pw_max > 48) pw_max = 48;
10434 break;
10435 case 8500: if (pw_max > 8) pw_max = 8;
10436 break;
10437 case 8600: if (pw_max > 16) pw_max = 16;
10438 break;
10439 case 9710: pw_min = 5;
10440 pw_max = 5;
10441 break;
10442 case 9810: pw_min = 5;
10443 pw_max = 5;
10444 break;
10445 case 10410: pw_min = 5;
10446 pw_max = 5;
10447 break;
10448 case 10300: if (pw_max < 3) pw_min = 3;
10449 if (pw_max > 40) pw_max = 40;
10450 break;
10451 case 10500: if (pw_max < 3) pw_min = 3;
10452 if (pw_max > 40) pw_max = 40;
10453 break;
10454 case 10700: if (pw_max > 16) pw_max = 16;
10455 break;
10456 case 11300: if (pw_max > 40) pw_max = 40;
10457 break;
10458 case 12500: if (pw_max > 20) pw_max = 20;
10459 break;
10460 case 12800: if (pw_max > 24) pw_max = 24;
10461 break;
10462 }
10463
10464 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10465 {
10466 switch (attack_kern)
10467 {
10468 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10469 break;
10470 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10471 break;
10472 }
10473 }
10474
10475 /**
10476 * charsets : keep them together for more easy maintainnce
10477 */
10478
10479 cs_t mp_sys[6] = { { { 0 }, 0 } };
10480 cs_t mp_usr[4] = { { { 0 }, 0 } };
10481
10482 mp_setup_sys (mp_sys);
10483
10484 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10485 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10486 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10487 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10488
10489 /**
10490 * load hashes, part I: find input mode, count hashes
10491 */
10492
10493 uint hashlist_mode = 0;
10494 uint hashlist_format = HLFMT_HASHCAT;
10495
10496 uint hashes_avail = 0;
10497
10498 if (benchmark == 0)
10499 {
10500 struct stat f;
10501
10502 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10503
10504 if ((hash_mode == 2500) ||
10505 (hash_mode == 5200) ||
10506 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10507 (hash_mode == 9000))
10508 {
10509 hashlist_mode = HL_MODE_ARG;
10510
10511 char *hashfile = myargv[optind];
10512
10513 data.hashfile = hashfile;
10514
10515 logfile_top_var_string ("target", hashfile);
10516 }
10517
10518 if (hashlist_mode == HL_MODE_ARG)
10519 {
10520 if (hash_mode == 2500)
10521 {
10522 struct stat st;
10523
10524 if (stat (data.hashfile, &st) == -1)
10525 {
10526 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10527
10528 return (-1);
10529 }
10530
10531 hashes_avail = st.st_size / sizeof (hccap_t);
10532 }
10533 else
10534 {
10535 hashes_avail = 1;
10536 }
10537 }
10538 else if (hashlist_mode == HL_MODE_FILE)
10539 {
10540 char *hashfile = myargv[optind];
10541
10542 data.hashfile = hashfile;
10543
10544 logfile_top_var_string ("target", hashfile);
10545
10546 FILE *fp = NULL;
10547
10548 if ((fp = fopen (hashfile, "rb")) == NULL)
10549 {
10550 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10551
10552 return (-1);
10553 }
10554
10555 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10556
10557 hashes_avail = count_lines (fp);
10558
10559 rewind (fp);
10560
10561 if (hashes_avail == 0)
10562 {
10563 log_error ("ERROR: hashfile is empty or corrupt");
10564
10565 fclose (fp);
10566
10567 return (-1);
10568 }
10569
10570 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10571
10572 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10573 {
10574 log_error ("ERROR: remove not supported in native hashfile-format mode");
10575
10576 fclose (fp);
10577
10578 return (-1);
10579 }
10580
10581 fclose (fp);
10582 }
10583 }
10584 else
10585 {
10586 hashlist_mode = HL_MODE_ARG;
10587
10588 hashes_avail = 1;
10589 }
10590
10591 if (hash_mode == 3000) hashes_avail *= 2;
10592
10593 data.hashlist_mode = hashlist_mode;
10594 data.hashlist_format = hashlist_format;
10595
10596 logfile_top_uint (hashlist_mode);
10597 logfile_top_uint (hashlist_format);
10598
10599 /**
10600 * load hashes, part II: allocate required memory, set pointers
10601 */
10602
10603 hash_t *hashes_buf = NULL;
10604 void *digests_buf = NULL;
10605 salt_t *salts_buf = NULL;
10606 void *esalts_buf = NULL;
10607
10608 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10609
10610 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10611
10612 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10613 {
10614 u32 hash_pos;
10615
10616 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10617 {
10618 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10619
10620 hashes_buf[hash_pos].hash_info = hash_info;
10621
10622 if (username && (remove || show || left))
10623 {
10624 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10625 }
10626
10627 if (benchmark)
10628 {
10629 hash_info->orighash = (char *) mymalloc (256);
10630 }
10631 }
10632 }
10633
10634 if (isSalted)
10635 {
10636 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10637
10638 if (esalt_size)
10639 {
10640 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10641 }
10642 }
10643 else
10644 {
10645 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10646 }
10647
10648 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10649 {
10650 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10651
10652 if (isSalted)
10653 {
10654 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10655
10656 if (esalt_size)
10657 {
10658 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10659 }
10660 }
10661 else
10662 {
10663 hashes_buf[hash_pos].salt = &salts_buf[0];
10664 }
10665 }
10666
10667 /**
10668 * load hashes, part III: parse hashes or generate them if benchmark
10669 */
10670
10671 uint hashes_cnt = 0;
10672
10673 if (benchmark == 0)
10674 {
10675 if (keyspace == 1)
10676 {
10677 // useless to read hash file for keyspace, cheat a little bit w/ optind
10678 }
10679 else if (hashes_avail == 0)
10680 {
10681 }
10682 else if (hashlist_mode == HL_MODE_ARG)
10683 {
10684 char *input_buf = myargv[optind];
10685
10686 uint input_len = strlen (input_buf);
10687
10688 logfile_top_var_string ("target", input_buf);
10689
10690 char *hash_buf = NULL;
10691 int hash_len = 0;
10692
10693 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10694
10695 if (hash_len)
10696 {
10697 if (opts_type & OPTS_TYPE_HASH_COPY)
10698 {
10699 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10700
10701 hash_info_tmp->orighash = mystrdup (hash_buf);
10702 }
10703
10704 if (isSalted)
10705 {
10706 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10707 }
10708
10709 int parser_status = PARSER_OK;
10710
10711 if (hash_mode == 2500)
10712 {
10713 if (hash_len == 0)
10714 {
10715 log_error ("ERROR: hccap file not specified");
10716
10717 return (-1);
10718 }
10719
10720 hashlist_mode = HL_MODE_FILE;
10721
10722 data.hashlist_mode = hashlist_mode;
10723
10724 FILE *fp = fopen (hash_buf, "rb");
10725
10726 if (fp == NULL)
10727 {
10728 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10729
10730 return (-1);
10731 }
10732
10733 if (hashes_avail < 1)
10734 {
10735 log_error ("ERROR: hccap file is empty or corrupt");
10736
10737 fclose (fp);
10738
10739 return (-1);
10740 }
10741
10742 uint hccap_size = sizeof (hccap_t);
10743
10744 char in[hccap_size];
10745
10746 while (!feof (fp))
10747 {
10748 int n = fread (&in, hccap_size, 1, fp);
10749
10750 if (n != 1)
10751 {
10752 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10753
10754 break;
10755 }
10756
10757 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10758
10759 if (parser_status != PARSER_OK)
10760 {
10761 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10762
10763 continue;
10764 }
10765
10766 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10767
10768 if ((show == 1) || (left == 1))
10769 {
10770 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10771
10772 char *salt_ptr = (char *) tmp_salt->salt_buf;
10773
10774 int cur_pos = tmp_salt->salt_len;
10775 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10776
10777 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10778
10779 u8 *pke_ptr = (u8 *) wpa->pke;
10780
10781 // do the appending task
10782
10783 snprintf (salt_ptr + cur_pos,
10784 rem_len,
10785 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10786 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10787 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10788
10789
10790 // memset () the remaining part of the salt
10791
10792 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10793 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10794
10795 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10796
10797 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10798 }
10799
10800 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);
10801 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);
10802
10803 hashes_cnt++;
10804 }
10805
10806 fclose (fp);
10807 }
10808 else if (hash_mode == 3000)
10809 {
10810 if (hash_len == 32)
10811 {
10812 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10813
10814 hash_t *lm_hash_left = NULL;
10815
10816 if (parser_status == PARSER_OK)
10817 {
10818 lm_hash_left = &hashes_buf[hashes_cnt];
10819
10820 hashes_cnt++;
10821 }
10822 else
10823 {
10824 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10825 }
10826
10827
10828 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10829
10830 hash_t *lm_hash_right = NULL;
10831
10832 if (parser_status == PARSER_OK)
10833 {
10834 lm_hash_right = &hashes_buf[hashes_cnt];
10835
10836 hashes_cnt++;
10837 }
10838 else
10839 {
10840 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10841 }
10842
10843 // show / left
10844
10845 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10846 {
10847 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);
10848 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);
10849 }
10850 }
10851 else
10852 {
10853 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10854
10855 if (parser_status == PARSER_OK)
10856 {
10857 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10858 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10859 }
10860
10861 if (parser_status == PARSER_OK)
10862 {
10863 hashes_cnt++;
10864 }
10865 else
10866 {
10867 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10868 }
10869 }
10870 }
10871 else
10872 {
10873 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10874
10875 if (parser_status == PARSER_OK)
10876 {
10877 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10878 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10879 }
10880
10881 if (parser_status == PARSER_OK)
10882 {
10883 hashes_cnt++;
10884 }
10885 else
10886 {
10887 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10888 }
10889 }
10890 }
10891 }
10892 else if (hashlist_mode == HL_MODE_FILE)
10893 {
10894 char *hashfile = data.hashfile;
10895
10896 FILE *fp;
10897
10898 if ((fp = fopen (hashfile, "rb")) == NULL)
10899 {
10900 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10901
10902 return (-1);
10903 }
10904
10905 uint line_num = 0;
10906
10907 while (!feof (fp))
10908 {
10909 line_num++;
10910
10911 char line_buf[BUFSIZ];
10912
10913 int line_len = fgetl (fp, line_buf);
10914
10915 if (line_len == 0) continue;
10916
10917 char *hash_buf = NULL;
10918 int hash_len = 0;
10919
10920 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10921
10922 if (username)
10923 {
10924 char *user_buf = NULL;
10925 int user_len = 0;
10926
10927 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10928
10929 if (remove || show)
10930 {
10931 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10932
10933 *user = (user_t *) malloc (sizeof (user_t));
10934
10935 user_t *user_ptr = *user;
10936
10937 if (user_buf != NULL)
10938 {
10939 user_ptr->user_name = mystrdup (user_buf);
10940 }
10941 else
10942 {
10943 user_ptr->user_name = mystrdup ("");
10944 }
10945
10946 user_ptr->user_len = user_len;
10947 }
10948 }
10949
10950 if (opts_type & OPTS_TYPE_HASH_COPY)
10951 {
10952 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10953
10954 hash_info_tmp->orighash = mystrdup (hash_buf);
10955 }
10956
10957 if (isSalted)
10958 {
10959 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10960 }
10961
10962 if (hash_mode == 3000)
10963 {
10964 if (hash_len == 32)
10965 {
10966 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10967
10968 if (parser_status < PARSER_GLOBAL_ZERO)
10969 {
10970 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10971
10972 continue;
10973 }
10974
10975 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10976
10977 hashes_cnt++;
10978
10979 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10980
10981 if (parser_status < PARSER_GLOBAL_ZERO)
10982 {
10983 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10984
10985 continue;
10986 }
10987
10988 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10989
10990 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);
10991
10992 hashes_cnt++;
10993
10994 // show / left
10995
10996 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);
10997 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);
10998 }
10999 else
11000 {
11001 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11002
11003 if (parser_status < PARSER_GLOBAL_ZERO)
11004 {
11005 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11006
11007 continue;
11008 }
11009
11010 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);
11011
11012 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11013 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11014
11015 hashes_cnt++;
11016 }
11017 }
11018 else
11019 {
11020 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11021
11022 if (parser_status < PARSER_GLOBAL_ZERO)
11023 {
11024 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11025
11026 continue;
11027 }
11028
11029 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);
11030
11031 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11032 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11033
11034 hashes_cnt++;
11035 }
11036 }
11037
11038 fclose (fp);
11039
11040 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11041
11042 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11043 }
11044 }
11045 else
11046 {
11047 if (isSalted)
11048 {
11049 hashes_buf[0].salt->salt_len = 8;
11050
11051 // special salt handling
11052
11053 switch (hash_mode)
11054 {
11055 case 1500: hashes_buf[0].salt->salt_len = 2;
11056 break;
11057 case 1731: hashes_buf[0].salt->salt_len = 4;
11058 break;
11059 case 2410: hashes_buf[0].salt->salt_len = 4;
11060 break;
11061 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11062 break;
11063 case 3100: hashes_buf[0].salt->salt_len = 1;
11064 break;
11065 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11066 break;
11067 case 5800: hashes_buf[0].salt->salt_len = 16;
11068 break;
11069 case 6800: hashes_buf[0].salt->salt_len = 32;
11070 break;
11071 case 8400: hashes_buf[0].salt->salt_len = 40;
11072 break;
11073 case 8800: hashes_buf[0].salt->salt_len = 16;
11074 break;
11075 case 8900: hashes_buf[0].salt->salt_len = 16;
11076 hashes_buf[0].salt->scrypt_N = 1024;
11077 hashes_buf[0].salt->scrypt_r = 1;
11078 hashes_buf[0].salt->scrypt_p = 1;
11079 break;
11080 case 9100: hashes_buf[0].salt->salt_len = 16;
11081 break;
11082 case 9300: hashes_buf[0].salt->salt_len = 14;
11083 hashes_buf[0].salt->scrypt_N = 16384;
11084 hashes_buf[0].salt->scrypt_r = 1;
11085 hashes_buf[0].salt->scrypt_p = 1;
11086 break;
11087 case 9400: hashes_buf[0].salt->salt_len = 16;
11088 break;
11089 case 9500: hashes_buf[0].salt->salt_len = 16;
11090 break;
11091 case 9600: hashes_buf[0].salt->salt_len = 16;
11092 break;
11093 case 9700: hashes_buf[0].salt->salt_len = 16;
11094 break;
11095 case 9710: hashes_buf[0].salt->salt_len = 16;
11096 break;
11097 case 9720: hashes_buf[0].salt->salt_len = 16;
11098 break;
11099 case 9800: hashes_buf[0].salt->salt_len = 16;
11100 break;
11101 case 9810: hashes_buf[0].salt->salt_len = 16;
11102 break;
11103 case 9820: hashes_buf[0].salt->salt_len = 16;
11104 break;
11105 case 10300: hashes_buf[0].salt->salt_len = 12;
11106 break;
11107 case 11500: hashes_buf[0].salt->salt_len = 4;
11108 break;
11109 case 11600: hashes_buf[0].salt->salt_len = 4;
11110 break;
11111 case 12400: hashes_buf[0].salt->salt_len = 4;
11112 break;
11113 case 12500: hashes_buf[0].salt->salt_len = 8;
11114 break;
11115 case 12600: hashes_buf[0].salt->salt_len = 64;
11116 break;
11117 }
11118
11119 // special esalt handling
11120
11121 switch (hash_mode)
11122 {
11123 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11124 break;
11125 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11126 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11127 break;
11128 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11129 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11130 break;
11131 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11132 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11133 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11134 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11135 break;
11136 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11137 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11138 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11139 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11140 break;
11141 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11142 break;
11143 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11144 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11145 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11146 break;
11147 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11148 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11149 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11150 break;
11151 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11152 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11153 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11154 break;
11155 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11156 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11157 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11158 break;
11159 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11160 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11161 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11162 break;
11163 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11164 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11165 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11166 break;
11167 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11168 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11169 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11170 break;
11171 }
11172 }
11173
11174 // set hashfile
11175
11176 switch (hash_mode)
11177 {
11178 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11179 break;
11180 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11181 break;
11182 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11183 break;
11184 case 6211:
11185 case 6212:
11186 case 6213:
11187 case 6221:
11188 case 6222:
11189 case 6223:
11190 case 6231:
11191 case 6232:
11192 case 6233:
11193 case 6241:
11194 case 6242:
11195 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11196 break;
11197 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11198 break;
11199 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11200 break;
11201 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11202 break;
11203 }
11204
11205 // set default iterations
11206
11207 switch (hash_mode)
11208 {
11209 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11210 break;
11211 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11212 break;
11213 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11214 break;
11215 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11216 break;
11217 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11218 break;
11219 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11220 break;
11221 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11222 break;
11223 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11224 break;
11225 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11226 break;
11227 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11228 break;
11229 case 6211:
11230 case 6212:
11231 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11232 break;
11233 case 6221:
11234 case 6222:
11235 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11236 break;
11237 case 6231:
11238 case 6232:
11239 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11240 break;
11241 case 6241:
11242 case 6242:
11243 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11244 break;
11245 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11246 break;
11247 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11248 break;
11249 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11250 break;
11251 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11252 break;
11253 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11254 break;
11255 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11256 break;
11257 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11258 break;
11259 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11260 break;
11261 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11262 break;
11263 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11264 break;
11265 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11266 break;
11267 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11268 break;
11269 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11270 break;
11271 case 8900: hashes_buf[0].salt->salt_iter = 1;
11272 break;
11273 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11274 break;
11275 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11276 break;
11277 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11278 break;
11279 case 9300: hashes_buf[0].salt->salt_iter = 1;
11280 break;
11281 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11282 break;
11283 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11284 break;
11285 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11286 break;
11287 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11288 break;
11289 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11290 break;
11291 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11292 break;
11293 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11294 break;
11295 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11296 break;
11297 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11298 break;
11299 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11300 break;
11301 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11302 break;
11303 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11304 break;
11305 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11306 break;
11307 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11308 break;
11309 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11310 break;
11311 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11312 break;
11313 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11314 break;
11315 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11316 break;
11317 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11318 break;
11319 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11320 break;
11321 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11322 break;
11323 }
11324
11325 // set special tuning for benchmark-mode 1
11326
11327 if (benchmark_mode == 1)
11328 {
11329 kernel_loops *= 8;
11330 kernel_accel *= 4;
11331
11332 switch (hash_mode)
11333 {
11334 case 400: kernel_loops = ROUNDS_PHPASS;
11335 kernel_accel = 32;
11336 break;
11337 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11338 kernel_accel = 32;
11339 break;
11340 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11341 kernel_accel = 32;
11342 break;
11343 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11344 kernel_accel = 32;
11345 break;
11346 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11347 kernel_accel = 16;
11348 break;
11349 case 2100: kernel_loops = ROUNDS_DCC2;
11350 kernel_accel = 16;
11351 break;
11352 case 2500: kernel_loops = ROUNDS_WPA2;
11353 kernel_accel = 32;
11354 break;
11355 case 3200: kernel_loops = ROUNDS_BCRYPT;
11356 kernel_accel = 8;
11357 break;
11358 case 5200: kernel_loops = ROUNDS_PSAFE3;
11359 kernel_accel = 16;
11360 break;
11361 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11362 kernel_accel = 16;
11363 break;
11364 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11365 kernel_accel = 64;
11366 break;
11367 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11368 kernel_accel = 32;
11369 break;
11370 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11371 kernel_accel = 32;
11372 break;
11373 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11374 kernel_accel = 8;
11375 break;
11376 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11377 kernel_accel = 8;
11378 break;
11379 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11380 kernel_accel = 8;
11381 break;
11382 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11383 kernel_accel = 8;
11384 break;
11385 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11386 kernel_accel = 8;
11387 break;
11388 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11389 kernel_accel = 8;
11390 break;
11391 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11392 kernel_accel = 128;
11393 break;
11394 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11395 kernel_accel = 64;
11396 break;
11397 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11398 kernel_accel = 64;
11399 break;
11400 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11401 kernel_accel = 32;
11402 break;
11403 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11404 kernel_accel = 128;
11405 break;
11406 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11407 kernel_accel = 128;
11408 break;
11409 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11410 kernel_accel = 32;
11411 break;
11412 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11413 kernel_accel = 64;
11414 break;
11415 case 6800: kernel_loops = ROUNDS_LASTPASS;
11416 kernel_accel = 64;
11417 break;
11418 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11419 kernel_accel = 8;
11420 break;
11421 case 7200: kernel_loops = ROUNDS_GRUB;
11422 kernel_accel = 16;
11423 break;
11424 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11425 kernel_accel = 8;
11426 break;
11427 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11428 kernel_accel = 8;
11429 break;
11430 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11431 kernel_accel = 8;
11432 break;
11433 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11434 kernel_accel = 32;
11435 break;
11436 case 8900: kernel_loops = 1;
11437 kernel_accel = 64;
11438 break;
11439 case 9000: kernel_loops = ROUNDS_PSAFE2;
11440 kernel_accel = 16;
11441 break;
11442 case 9100: kernel_loops = ROUNDS_LOTUS8;
11443 kernel_accel = 64;
11444 break;
11445 case 9200: kernel_loops = ROUNDS_CISCO8;
11446 kernel_accel = 8;
11447 break;
11448 case 9300: kernel_loops = 1;
11449 kernel_accel = 4;
11450 break;
11451 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11452 kernel_accel = 32;
11453 break;
11454 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11455 kernel_accel = 32;
11456 break;
11457 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11458 kernel_accel = 8;
11459 break;
11460 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11461 kernel_accel = 8;
11462 break;
11463 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11464 kernel_accel = 16;
11465 break;
11466 case 10500: kernel_loops = ROUNDS_PDF14;
11467 kernel_accel = 256;
11468 break;
11469 case 10700: kernel_loops = ROUNDS_PDF17L8;
11470 kernel_accel = 8;
11471 break;
11472 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11473 kernel_accel = 8;
11474 break;
11475 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11476 kernel_accel = 8;
11477 break;
11478 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11479 kernel_accel = 8;
11480 break;
11481 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11482 kernel_accel = 8;
11483 break;
11484 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11485 kernel_accel = 8;
11486 break;
11487 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11488 kernel_accel = 8;
11489 break;
11490 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11491 kernel_accel = 8;
11492 break;
11493 case 12300: kernel_loops = ROUNDS_ORACLET;
11494 kernel_accel = 8;
11495 break;
11496 case 12500: kernel_loops = ROUNDS_RAR3;
11497 kernel_accel = 32;
11498 break;
11499 case 12700: kernel_loops = ROUNDS_MYWALLET;
11500 kernel_accel = 512;
11501 break;
11502 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11503 kernel_accel = 512;
11504 break;
11505 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11506 kernel_accel = 8;
11507 break;
11508 case 13000: kernel_loops = ROUNDS_RAR5;
11509 kernel_accel = 8;
11510 break;
11511 }
11512
11513 // some algorithm collide too fast, make that impossible
11514
11515 switch (hash_mode)
11516 {
11517 case 11500: ((uint *) digests_buf)[1] = 1;
11518 break;
11519 }
11520
11521 if (kernel_loops > 1024) kernel_loops = 1024;
11522 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11523 }
11524
11525 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11526 {
11527 kernel_loops = 1024;
11528 }
11529
11530 if (hash_mode == 12500)
11531 {
11532 kernel_loops = ROUNDS_RAR3 / 16;
11533 }
11534
11535 data.kernel_accel = kernel_accel;
11536 data.kernel_loops = kernel_loops;
11537
11538 hashes_cnt = 1;
11539 }
11540
11541 if (show == 1 || left == 1)
11542 {
11543 for (uint i = 0; i < pot_cnt; i++)
11544 {
11545 pot_t *pot_ptr = &pot[i];
11546
11547 hash_t *hashes_buf = &pot_ptr->hash;
11548
11549 local_free (hashes_buf->digest);
11550
11551 if (isSalted)
11552 {
11553 local_free (hashes_buf->salt);
11554 }
11555 }
11556
11557 local_free (pot);
11558
11559 if (data.quiet == 0) log_info_nn ("");
11560
11561 return (0);
11562 }
11563
11564 if (keyspace == 0)
11565 {
11566 if (hashes_cnt == 0)
11567 {
11568 log_error ("ERROR: No hashes loaded");
11569
11570 return (-1);
11571 }
11572 }
11573
11574 /**
11575 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11576 */
11577
11578 if (data.outfile != NULL)
11579 {
11580 if (data.hashfile != NULL)
11581 {
11582 #ifdef _POSIX
11583 struct stat tmpstat_outfile;
11584 struct stat tmpstat_hashfile;
11585 #endif
11586
11587 #ifdef _WIN
11588 struct stat64 tmpstat_outfile;
11589 struct stat64 tmpstat_hashfile;
11590 #endif
11591
11592 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11593
11594 if (tmp_outfile_fp)
11595 {
11596 #ifdef _POSIX
11597 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11598 #endif
11599
11600 #ifdef _WIN
11601 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11602 #endif
11603
11604 fclose (tmp_outfile_fp);
11605 }
11606
11607 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11608
11609 if (tmp_hashfile_fp)
11610 {
11611 #ifdef _POSIX
11612 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11613 #endif
11614
11615 #ifdef _WIN
11616 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11617 #endif
11618
11619 fclose (tmp_hashfile_fp);
11620 }
11621
11622 if (tmp_outfile_fp && tmp_outfile_fp)
11623 {
11624 tmpstat_outfile.st_mode = 0;
11625 tmpstat_outfile.st_nlink = 0;
11626 tmpstat_outfile.st_uid = 0;
11627 tmpstat_outfile.st_gid = 0;
11628 tmpstat_outfile.st_rdev = 0;
11629 tmpstat_outfile.st_atime = 0;
11630
11631 tmpstat_hashfile.st_mode = 0;
11632 tmpstat_hashfile.st_nlink = 0;
11633 tmpstat_hashfile.st_uid = 0;
11634 tmpstat_hashfile.st_gid = 0;
11635 tmpstat_hashfile.st_rdev = 0;
11636 tmpstat_hashfile.st_atime = 0;
11637
11638 #ifdef _POSIX
11639 tmpstat_outfile.st_blksize = 0;
11640 tmpstat_outfile.st_blocks = 0;
11641
11642 tmpstat_hashfile.st_blksize = 0;
11643 tmpstat_hashfile.st_blocks = 0;
11644 #endif
11645
11646 #ifdef _POSIX
11647 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11648 {
11649 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11650
11651 return (-1);
11652 }
11653 #endif
11654
11655 #ifdef _WIN
11656 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11657 {
11658 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11659
11660 return (-1);
11661 }
11662 #endif
11663 }
11664 }
11665 }
11666
11667 /**
11668 * Remove duplicates
11669 */
11670
11671 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11672
11673 if (isSalted)
11674 {
11675 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11676 }
11677 else
11678 {
11679 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11680 }
11681
11682 uint hashes_cnt_orig = hashes_cnt;
11683
11684 hashes_cnt = 1;
11685
11686 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11687 {
11688 if (isSalted)
11689 {
11690 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11691 {
11692 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11693 }
11694 }
11695 else
11696 {
11697 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11698 }
11699
11700 if (hashes_pos > hashes_cnt)
11701 {
11702 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11703 }
11704
11705 hashes_cnt++;
11706 }
11707
11708 /**
11709 * Potfile removes
11710 */
11711
11712 uint potfile_remove_cracks = 0;
11713
11714 if (potfile_disable == 0)
11715 {
11716 hash_t hash_buf;
11717
11718 hash_buf.digest = mymalloc (dgst_size);
11719 hash_buf.salt = NULL;
11720 hash_buf.esalt = NULL;
11721 hash_buf.hash_info = NULL;
11722 hash_buf.cracked = 0;
11723
11724 if (isSalted)
11725 {
11726 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11727 }
11728
11729 if (esalt_size)
11730 {
11731 hash_buf.esalt = mymalloc (esalt_size);
11732 }
11733
11734 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11735
11736 // no solution for these special hash types (for instane because they use hashfile in output etc)
11737 if ((hash_mode != 5200) &&
11738 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11739 (hash_mode != 9000))
11740 {
11741 FILE *fp = fopen (potfile, "rb");
11742
11743 if (fp != NULL)
11744 {
11745 while (!feof (fp))
11746 {
11747 char line_buf[BUFSIZ];
11748
11749 memset (line_buf, 0, BUFSIZ);
11750
11751 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11752
11753 if (ptr == NULL) break;
11754
11755 int line_len = strlen (line_buf);
11756
11757 if (line_len == 0) continue;
11758
11759 int iter = MAX_CUT_TRIES;
11760
11761 for (int i = line_len - 1; i && iter; i--, line_len--)
11762 {
11763 if (line_buf[i] != ':') continue;
11764
11765 if (isSalted)
11766 {
11767 memset (hash_buf.salt, 0, sizeof (salt_t));
11768 }
11769
11770 hash_t *found = NULL;
11771
11772 if (hash_mode == 6800)
11773 {
11774 if (i < 48) // 48 = 12 * uint in salt_buf[]
11775 {
11776 // manipulate salt_buf
11777 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11778
11779 hash_buf.salt->salt_len = i;
11780
11781 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11782 }
11783 }
11784 else if (hash_mode == 2500)
11785 {
11786 if (i < 48) // 48 = 12 * uint in salt_buf[]
11787 {
11788 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11789 // manipulate salt_buf
11790
11791 // to be safe work with a copy (because of line_len loop, i etc)
11792
11793 char line_buf_cpy[BUFSIZ];
11794 memset (line_buf_cpy, 0, BUFSIZ);
11795
11796 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11797
11798 memcpy (line_buf_cpy, line_buf, i);
11799
11800 char *mac2_pos = strrchr (line_buf_cpy, ':');
11801
11802 if (mac2_pos == NULL) continue;
11803
11804 mac2_pos[0] = 0;
11805 mac2_pos++;
11806
11807 if (strlen (mac2_pos) != 12) continue;
11808
11809 char *mac1_pos = strrchr (line_buf_cpy, ':');
11810
11811 if (mac1_pos == NULL) continue;
11812
11813 mac1_pos[0] = 0;
11814 mac1_pos++;
11815
11816 if (strlen (mac1_pos) != 12) continue;
11817
11818 uint essid_length = mac1_pos - line_buf_cpy - 1;
11819
11820 // here we need the ESSID
11821 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11822
11823 hash_buf.salt->salt_len = essid_length;
11824
11825 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11826
11827 if (found)
11828 {
11829 wpa_t *wpa = (wpa_t *) found->esalt;
11830
11831 uint pke[25];
11832
11833 char *pke_ptr = (char *) pke;
11834
11835 for (uint i = 0; i < 25; i++)
11836 {
11837 pke[i] = byte_swap_32 (wpa->pke[i]);
11838 }
11839
11840 u8 mac1[6];
11841 u8 mac2[6];
11842
11843 memcpy (mac1, pke_ptr + 23, 6);
11844 memcpy (mac2, pke_ptr + 29, 6);
11845
11846 // compare hex string(s) vs binary MAC address(es)
11847
11848 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11849 {
11850 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11851 {
11852 found = NULL;
11853 break;
11854 }
11855 }
11856
11857 // early skip ;)
11858 if (!found) continue;
11859
11860 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11861 {
11862 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11863 {
11864 found = NULL;
11865 break;
11866 }
11867 }
11868 }
11869 }
11870 }
11871 else
11872 {
11873 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11874
11875 if (parser_status == PARSER_OK)
11876 {
11877 if (isSalted)
11878 {
11879 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11880 }
11881 else
11882 {
11883 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11884 }
11885 }
11886 }
11887
11888 if (found == NULL) continue;
11889
11890 if (!found->cracked) potfile_remove_cracks++;
11891
11892 found->cracked = 1;
11893
11894 if (found) break;
11895
11896 iter--;
11897 }
11898 }
11899
11900 fclose (fp);
11901 }
11902 }
11903
11904 if (esalt_size)
11905 {
11906 local_free (hash_buf.esalt);
11907 }
11908
11909 if (isSalted)
11910 {
11911 local_free (hash_buf.salt);
11912 }
11913
11914 local_free (hash_buf.digest);
11915 }
11916
11917 /**
11918 * Now generate all the buffers required for later
11919 */
11920
11921 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11922
11923 salt_t *salts_buf_new = NULL;
11924 void *esalts_buf_new = NULL;
11925
11926 if (isSalted)
11927 {
11928 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11929
11930 if (esalt_size)
11931 {
11932 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11933 }
11934 }
11935 else
11936 {
11937 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11938 }
11939
11940 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11941
11942 uint digests_cnt = hashes_cnt;
11943 uint digests_done = 0;
11944
11945 uint size_digests = digests_cnt * dgst_size;
11946 uint size_shown = digests_cnt * sizeof (uint);
11947
11948 uint *digests_shown = (uint *) mymalloc (size_shown);
11949 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11950
11951 uint salts_cnt = 0;
11952 uint salts_done = 0;
11953
11954 hashinfo_t **hash_info = NULL;
11955
11956 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11957 {
11958 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11959
11960 if (username && (remove || show))
11961 {
11962 uint user_pos;
11963
11964 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11965 {
11966 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11967
11968 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11969 }
11970 }
11971 }
11972
11973 uint *salts_shown = (uint *) mymalloc (size_shown);
11974
11975 salt_t *salt_buf;
11976
11977 {
11978 // copied from inner loop
11979
11980 salt_buf = &salts_buf_new[salts_cnt];
11981
11982 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11983
11984 if (esalt_size)
11985 {
11986 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11987 }
11988
11989 salt_buf->digests_cnt = 0;
11990 salt_buf->digests_done = 0;
11991 salt_buf->digests_offset = 0;
11992
11993 salts_cnt++;
11994 }
11995
11996 if (hashes_buf[0].cracked == 1)
11997 {
11998 digests_shown[0] = 1;
11999
12000 digests_done++;
12001
12002 salt_buf->digests_done++;
12003 }
12004
12005 salt_buf->digests_cnt++;
12006
12007 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12008
12009 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12010 {
12011 hash_info[0] = hashes_buf[0].hash_info;
12012 }
12013
12014 // copy from inner loop
12015
12016 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12017 {
12018 if (isSalted)
12019 {
12020 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12021 {
12022 salt_buf = &salts_buf_new[salts_cnt];
12023
12024 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12025
12026 if (esalt_size)
12027 {
12028 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12029 }
12030
12031 salt_buf->digests_cnt = 0;
12032 salt_buf->digests_done = 0;
12033 salt_buf->digests_offset = hashes_pos;
12034
12035 salts_cnt++;
12036 }
12037 }
12038
12039 if (hashes_buf[hashes_pos].cracked == 1)
12040 {
12041 digests_shown[hashes_pos] = 1;
12042
12043 digests_done++;
12044
12045 salt_buf->digests_done++;
12046 }
12047
12048 salt_buf->digests_cnt++;
12049
12050 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12051
12052 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12053 {
12054 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12055 }
12056 }
12057
12058 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12059 {
12060 salt_t *salt_buf = &salts_buf_new[salt_pos];
12061
12062 if (salt_buf->digests_done == salt_buf->digests_cnt)
12063 {
12064 salts_shown[salt_pos] = 1;
12065
12066 salts_done++;
12067 }
12068
12069 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12070 }
12071
12072 local_free (digests_buf);
12073 local_free (salts_buf);
12074 local_free (esalts_buf);
12075
12076 digests_buf = digests_buf_new;
12077 salts_buf = salts_buf_new;
12078 esalts_buf = esalts_buf_new;
12079
12080 local_free (hashes_buf);
12081
12082 /**
12083 * special modification not set from parser
12084 */
12085
12086 switch (hash_mode)
12087 {
12088 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12089 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12090 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12091 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12092 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12093 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12094 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12095 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12096 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12097 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12098 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12099 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12100 }
12101
12102 if (truecrypt_keyfiles)
12103 {
12104 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12105
12106 char *keyfiles = strdup (truecrypt_keyfiles);
12107
12108 char *keyfile = strtok (keyfiles, ",");
12109
12110 do
12111 {
12112 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12113
12114 } while ((keyfile = strtok (NULL, ",")) != NULL);
12115
12116 free (keyfiles);
12117 }
12118
12119 data.digests_cnt = digests_cnt;
12120 data.digests_done = digests_done;
12121 data.digests_buf = digests_buf;
12122 data.digests_shown = digests_shown;
12123 data.digests_shown_tmp = digests_shown_tmp;
12124
12125 data.salts_cnt = salts_cnt;
12126 data.salts_done = salts_done;
12127 data.salts_buf = salts_buf;
12128 data.salts_shown = salts_shown;
12129
12130 data.esalts_buf = esalts_buf;
12131 data.hash_info = hash_info;
12132
12133 /**
12134 * Automatic Optimizers
12135 */
12136
12137 if (salts_cnt == 1)
12138 opti_type |= OPTI_TYPE_SINGLE_SALT;
12139
12140 if (digests_cnt == 1)
12141 opti_type |= OPTI_TYPE_SINGLE_HASH;
12142
12143 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12144 opti_type |= OPTI_TYPE_NOT_ITERATED;
12145
12146 if (attack_mode == ATTACK_MODE_BF)
12147 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12148
12149 data.opti_type = opti_type;
12150
12151 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12152 {
12153 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12154 {
12155 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12156 {
12157 if (opts_type & OPTS_TYPE_ST_ADD80)
12158 {
12159 opts_type &= ~OPTS_TYPE_ST_ADD80;
12160 opts_type |= OPTS_TYPE_PT_ADD80;
12161 }
12162
12163 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12164 {
12165 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12166 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12167 }
12168
12169 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12170 {
12171 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12172 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12173 }
12174 }
12175 }
12176 }
12177
12178 /**
12179 * Some algorithm, like descrypt, can benefit from JIT compilation
12180 */
12181
12182 int force_jit_compilation = -1;
12183
12184 if (hash_mode == 8900)
12185 {
12186 force_jit_compilation = 8900;
12187 }
12188 else if (hash_mode == 9300)
12189 {
12190 force_jit_compilation = 8900;
12191 }
12192 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12193 {
12194 force_jit_compilation = 1500;
12195 }
12196
12197 /**
12198 * generate bitmap tables
12199 */
12200
12201 const uint bitmap_shift1 = 5;
12202 const uint bitmap_shift2 = 13;
12203
12204 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12205
12206 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12207 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12208 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12209 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12210 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12211 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12212 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12213 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12214
12215 uint bitmap_bits;
12216 uint bitmap_nums;
12217 uint bitmap_mask;
12218 uint bitmap_size;
12219
12220 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12221 {
12222 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12223
12224 bitmap_nums = 1 << bitmap_bits;
12225
12226 bitmap_mask = bitmap_nums - 1;
12227
12228 bitmap_size = bitmap_nums * sizeof (uint);
12229
12230 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12231
12232 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;
12233 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;
12234
12235 break;
12236 }
12237
12238 bitmap_nums = 1 << bitmap_bits;
12239
12240 bitmap_mask = bitmap_nums - 1;
12241
12242 bitmap_size = bitmap_nums * sizeof (uint);
12243
12244 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);
12245 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);
12246
12247 /**
12248 * prepare quick rule
12249 */
12250
12251 data.rule_buf_l = rule_buf_l;
12252 data.rule_buf_r = rule_buf_r;
12253
12254 int rule_len_l = (int) strlen (rule_buf_l);
12255 int rule_len_r = (int) strlen (rule_buf_r);
12256
12257 data.rule_len_l = rule_len_l;
12258 data.rule_len_r = rule_len_r;
12259
12260 /**
12261 * load rules
12262 */
12263
12264 uint *all_kernel_rules_cnt = NULL;
12265
12266 kernel_rule_t **all_kernel_rules_buf = NULL;
12267
12268 if (rp_files_cnt)
12269 {
12270 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12271
12272 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12273 }
12274
12275 char rule_buf[BUFSIZ];
12276
12277 int rule_len = 0;
12278
12279 for (uint i = 0; i < rp_files_cnt; i++)
12280 {
12281 uint kernel_rules_avail = 0;
12282
12283 uint kernel_rules_cnt = 0;
12284
12285 kernel_rule_t *kernel_rules_buf = NULL;
12286
12287 char *rp_file = rp_files[i];
12288
12289 char in[BLOCK_SIZE];
12290 char out[BLOCK_SIZE];
12291
12292 FILE *fp = NULL;
12293
12294 uint rule_line = 0;
12295
12296 if ((fp = fopen (rp_file, "rb")) == NULL)
12297 {
12298 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12299
12300 return (-1);
12301 }
12302
12303 while (!feof (fp))
12304 {
12305 memset (rule_buf, 0, BUFSIZ);
12306
12307 rule_len = fgetl (fp, rule_buf);
12308
12309 rule_line++;
12310
12311 if (rule_len == 0) continue;
12312
12313 if (rule_buf[0] == '#') continue;
12314
12315 if (kernel_rules_avail == kernel_rules_cnt)
12316 {
12317 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12318
12319 kernel_rules_avail += INCR_RULES;
12320 }
12321
12322 memset (in, 0, BLOCK_SIZE);
12323 memset (out, 0, BLOCK_SIZE);
12324
12325 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12326
12327 if (result == -1)
12328 {
12329 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12330
12331 continue;
12332 }
12333
12334 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12335 {
12336 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12337
12338 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12339
12340 continue;
12341 }
12342
12343 /* its so slow
12344 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12345 {
12346 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12347
12348 continue;
12349 }
12350 */
12351
12352 kernel_rules_cnt++;
12353 }
12354
12355 fclose (fp);
12356
12357 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12358
12359 all_kernel_rules_buf[i] = kernel_rules_buf;
12360 }
12361
12362 /**
12363 * merge rules or automatic rule generator
12364 */
12365
12366 uint kernel_rules_cnt = 0;
12367
12368 kernel_rule_t *kernel_rules_buf = NULL;
12369
12370 if (attack_mode == ATTACK_MODE_STRAIGHT)
12371 {
12372 if (rp_files_cnt)
12373 {
12374 kernel_rules_cnt = 1;
12375
12376 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12377
12378 repeats[0] = kernel_rules_cnt;
12379
12380 for (uint i = 0; i < rp_files_cnt; i++)
12381 {
12382 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12383
12384 repeats[i + 1] = kernel_rules_cnt;
12385 }
12386
12387 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12388
12389 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12390
12391 for (uint i = 0; i < kernel_rules_cnt; i++)
12392 {
12393 uint out_pos = 0;
12394
12395 kernel_rule_t *out = &kernel_rules_buf[i];
12396
12397 for (uint j = 0; j < rp_files_cnt; j++)
12398 {
12399 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12400 uint in_pos;
12401
12402 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12403
12404 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12405 {
12406 if (out_pos == RULES_MAX - 1)
12407 {
12408 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12409
12410 break;
12411 }
12412
12413 out->cmds[out_pos] = in->cmds[in_pos];
12414 }
12415 }
12416 }
12417
12418 local_free (repeats);
12419 }
12420 else if (rp_gen)
12421 {
12422 uint kernel_rules_avail = 0;
12423
12424 while (kernel_rules_cnt < rp_gen)
12425 {
12426 if (kernel_rules_avail == kernel_rules_cnt)
12427 {
12428 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12429
12430 kernel_rules_avail += INCR_RULES;
12431 }
12432
12433 memset (rule_buf, 0, BLOCK_SIZE);
12434
12435 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12436
12437 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12438
12439 kernel_rules_cnt++;
12440 }
12441 }
12442 }
12443
12444 /**
12445 * generate NOP rules
12446 */
12447
12448 if (kernel_rules_cnt == 0)
12449 {
12450 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12451
12452 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12453
12454 kernel_rules_cnt++;
12455 }
12456
12457 data.kernel_rules_cnt = kernel_rules_cnt;
12458 data.kernel_rules_buf = kernel_rules_buf;
12459
12460 /**
12461 * OpenCL platforms: detect
12462 */
12463
12464 cl_platform_id platforms[CL_PLATFORMS_MAX];
12465
12466 cl_uint platforms_cnt = 0;
12467
12468 cl_device_id platform_devices[DEVICES_MAX];
12469
12470 cl_uint platform_devices_cnt;
12471
12472 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12473
12474 if (platforms_cnt == 0)
12475 {
12476 log_error ("ERROR: No OpenCL compatible platform found");
12477
12478 return (-1);
12479 }
12480
12481 /**
12482 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12483 */
12484
12485 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12486 {
12487 cl_platform_id platform = platforms[platform_id];
12488
12489 char platform_vendor[INFOSZ] = { 0 };
12490
12491 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12492
12493 #ifdef HAVE_HWMON
12494 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12495 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12496 {
12497 // make sure that we do not directly control the fan for NVidia
12498
12499 gpu_temp_retain = 0;
12500
12501 data.gpu_temp_retain = gpu_temp_retain;
12502 }
12503 #endif // HAVE_NVML || HAVE_NVAPI
12504 #endif
12505 }
12506
12507 /**
12508 * OpenCL devices: simply push all devices from all platforms into the same device array
12509 */
12510
12511 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12512
12513 data.devices_param = devices_param;
12514
12515 uint devices_cnt = 0;
12516
12517 uint devices_active = 0;
12518
12519 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12520 {
12521 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12522
12523 cl_platform_id platform = platforms[platform_id];
12524
12525 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12526
12527 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12528 {
12529 const uint device_id = devices_cnt;
12530
12531 hc_device_param_t *device_param = &data.devices_param[device_id];
12532
12533 device_param->device = platform_devices[platform_devices_id];
12534
12535 device_param->device_id = device_id;
12536
12537 device_param->platform_devices_id = platform_devices_id;
12538
12539 // vendor_id
12540
12541 cl_uint vendor_id = 0;
12542
12543 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12544
12545 device_param->vendor_id = vendor_id;
12546
12547 // device_type
12548
12549 cl_device_type device_type;
12550
12551 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12552
12553 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12554
12555 device_param->device_type = device_type;
12556
12557 // device_name
12558
12559 char *device_name = (char *) mymalloc (INFOSZ);
12560
12561 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12562
12563 device_param->device_name = device_name;
12564
12565 // device_version
12566
12567 char *device_version = (char *) mymalloc (INFOSZ);
12568
12569 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12570
12571 device_param->device_version = device_version;
12572
12573 if (strstr (device_version, "pocl"))
12574 {
12575 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12576 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12577
12578 cl_uint vendor_id = 0xffff;
12579
12580 device_param->vendor_id = vendor_id;
12581 }
12582
12583 // max_compute_units
12584
12585 cl_uint vector_width;
12586
12587 if (attack_mode == ATTACK_MODE_BF)
12588 {
12589 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12590 {
12591 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12592 }
12593 else
12594 {
12595 vector_width = opencl_vector_width;
12596 }
12597 }
12598 else
12599 {
12600 vector_width = 1;
12601 }
12602
12603 if (vector_width > 8) vector_width = 8;
12604
12605 device_param->vector_width = vector_width;
12606
12607 // max_compute_units
12608
12609 cl_uint device_processors;
12610
12611 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12612
12613 device_param->device_processors = device_processors;
12614
12615 // max_mem_alloc_size
12616
12617 cl_ulong device_maxmem_alloc;
12618
12619 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12620
12621 device_param->device_maxmem_alloc = device_maxmem_alloc;
12622
12623 // max_mem_alloc_size
12624
12625 cl_ulong device_global_mem;
12626
12627 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12628
12629 device_param->device_global_mem = device_global_mem;
12630
12631 // max_clock_frequency
12632
12633 cl_uint device_maxclock_frequency;
12634
12635 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12636
12637 device_param->device_maxclock_frequency = device_maxclock_frequency;
12638
12639 // skipped
12640
12641 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12642 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12643
12644 device_param->skipped = (skipped1 || skipped2);
12645
12646 // driver_version
12647
12648 char *driver_version = (char *) mymalloc (INFOSZ);
12649
12650 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12651
12652 device_param->driver_version = driver_version;
12653
12654 // device_name_chksum
12655
12656 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12657
12658 #if __x86_64__
12659 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);
12660 #else
12661 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);
12662 #endif
12663
12664 uint device_name_digest[4];
12665
12666 device_name_digest[0] = 0;
12667 device_name_digest[1] = 0;
12668 device_name_digest[2] = 0;
12669 device_name_digest[3] = 0;
12670
12671 md5_64 ((uint *) device_name_chksum, device_name_digest);
12672
12673 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12674
12675 device_param->device_name_chksum = device_name_chksum;
12676
12677 // device_processor_cores
12678
12679 if (device_type & CL_DEVICE_TYPE_CPU)
12680 {
12681 cl_uint device_processor_cores = 1;
12682
12683 device_param->device_processor_cores = device_processor_cores;
12684 }
12685
12686 if (device_type & CL_DEVICE_TYPE_GPU)
12687 {
12688 if (vendor_id == VENDOR_ID_AMD)
12689 {
12690 cl_uint device_processor_cores = 0;
12691
12692 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12693
12694 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12695
12696 device_param->device_processor_cores = device_processor_cores;
12697 }
12698 else if (vendor_id == VENDOR_ID_NV)
12699 {
12700 cl_uint kernel_exec_timeout = 0;
12701
12702 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12703
12704 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12705
12706 device_param->kernel_exec_timeout = kernel_exec_timeout;
12707
12708 cl_uint device_processor_cores = 0;
12709
12710 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12711
12712 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12713
12714 device_param->device_processor_cores = device_processor_cores;
12715
12716 cl_uint sm_minor = 0;
12717 cl_uint sm_major = 0;
12718
12719 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12720 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12721
12722 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12723 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12724
12725 device_param->sm_minor = sm_minor;
12726 device_param->sm_major = sm_major;
12727 }
12728 else
12729 {
12730 cl_uint device_processor_cores = 1;
12731
12732 device_param->device_processor_cores = device_processor_cores;
12733 }
12734 }
12735
12736 // display results
12737
12738 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12739 {
12740 if (device_param->skipped == 0)
12741 {
12742 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12743 device_id + 1,
12744 device_name,
12745 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12746 (unsigned int) (device_global_mem / 1024 / 1024),
12747 (unsigned int) (device_maxclock_frequency),
12748 (unsigned int) device_processors);
12749 }
12750 else
12751 {
12752 log_info ("Device #%u: %s, skipped",
12753 device_id + 1,
12754 device_name);
12755 }
12756 }
12757
12758 // common driver check
12759
12760 if (device_param->skipped == 0)
12761 {
12762 if (strstr (device_version, "pocl"))
12763 {
12764 if (force == 0)
12765 {
12766 log_info ("");
12767 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12768 log_info ("You are STRONGLY encouraged not to use it");
12769 log_info ("You can use --force to override this but do not post error reports if you do so");
12770 log_info ("");
12771
12772 return (-1);
12773 }
12774 }
12775
12776 if (device_type & CL_DEVICE_TYPE_GPU)
12777 {
12778 if (vendor_id == VENDOR_ID_NV)
12779 {
12780 if (device_param->kernel_exec_timeout != 0)
12781 {
12782 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);
12783 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12784 }
12785 }
12786 else if (vendor_id == VENDOR_ID_AMD)
12787 {
12788 int catalyst_check = (force == 1) ? 0 : 1;
12789
12790 int catalyst_warn = 0;
12791
12792 int catalyst_broken = 0;
12793
12794 if (catalyst_check == 1)
12795 {
12796 catalyst_warn = 1;
12797
12798 // v14.9 and higher
12799 if (atoi (device_param->driver_version) >= 1573)
12800 {
12801 catalyst_warn = 0;
12802 }
12803
12804 catalyst_check = 0;
12805 }
12806
12807 if (catalyst_broken == 1)
12808 {
12809 log_info ("");
12810 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12811 log_info ("It will pass over cracked hashes and does not report them as cracked");
12812 log_info ("You are STRONGLY encouraged not to use it");
12813 log_info ("You can use --force to override this but do not post error reports if you do so");
12814 log_info ("");
12815
12816 return (-1);
12817 }
12818
12819 if (catalyst_warn == 1)
12820 {
12821 log_info ("");
12822 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12823 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12824 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12825 #ifdef _WIN
12826 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12827 #endif
12828 log_info ("You can use --force to override this but do not post error reports if you do so");
12829 log_info ("");
12830
12831 return (-1);
12832 }
12833 }
12834 }
12835
12836 devices_active++;
12837 }
12838
12839 // next please
12840
12841 devices_cnt++;
12842 }
12843 }
12844
12845 if (devices_active == 0)
12846 {
12847 log_error ("ERROR: No devices found/left");
12848
12849 return (-1);
12850 }
12851
12852 data.devices_cnt = devices_cnt;
12853
12854 data.devices_active = devices_active;
12855
12856 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12857 {
12858 log_info ("");
12859 }
12860
12861 /**
12862 * OpenCL devices: allocate buffer for device specific information
12863 */
12864
12865 #ifdef HAVE_HWMON
12866 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12867
12868 #ifdef HAVE_ADL
12869 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12870
12871 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12872 #endif // ADL
12873 #endif
12874
12875 /**
12876 * enable custom signal handler(s)
12877 */
12878
12879 if (benchmark == 0)
12880 {
12881 hc_signal (sigHandler_default);
12882 }
12883 else
12884 {
12885 hc_signal (sigHandler_benchmark);
12886 }
12887
12888 /**
12889 * User-defined GPU temp handling
12890 */
12891
12892 #ifdef HAVE_HWMON
12893 if (gpu_temp_disable == 1)
12894 {
12895 gpu_temp_abort = 0;
12896 gpu_temp_retain = 0;
12897 }
12898
12899 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12900 {
12901 if (gpu_temp_abort < gpu_temp_retain)
12902 {
12903 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12904
12905 return (-1);
12906 }
12907 }
12908
12909 data.gpu_temp_disable = gpu_temp_disable;
12910 data.gpu_temp_abort = gpu_temp_abort;
12911 data.gpu_temp_retain = gpu_temp_retain;
12912 #endif
12913
12914 /**
12915 * inform the user
12916 */
12917
12918 if (data.quiet == 0)
12919 {
12920 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12921
12922 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);
12923
12924 if (attack_mode == ATTACK_MODE_STRAIGHT)
12925 {
12926 log_info ("Rules: %u", kernel_rules_cnt);
12927 }
12928
12929 if (opti_type)
12930 {
12931 log_info ("Applicable Optimizers:");
12932
12933 for (uint i = 0; i < 32; i++)
12934 {
12935 const uint opti_bit = 1u << i;
12936
12937 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12938 }
12939 }
12940
12941 /**
12942 * Watchdog and Temperature balance
12943 */
12944
12945 #ifdef HAVE_HWMON
12946 if (gpu_temp_abort == 0)
12947 {
12948 log_info ("Watchdog: Temperature abort trigger disabled");
12949 }
12950 else
12951 {
12952 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12953 }
12954
12955 if (gpu_temp_retain == 0)
12956 {
12957 log_info ("Watchdog: Temperature retain trigger disabled");
12958 }
12959 else
12960 {
12961 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12962 }
12963 #endif
12964 }
12965
12966 if (data.quiet == 0) log_info ("");
12967
12968 /**
12969 * HM devices: init
12970 */
12971
12972 #ifdef HAVE_HWMON
12973 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
12974 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12975 #endif
12976
12977 #ifdef HAVE_ADL
12978 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12979 #endif
12980
12981 if (gpu_temp_disable == 0)
12982 {
12983 #if defined(WIN) && defined(HAVE_NVAPI)
12984 if (NvAPI_Initialize () == NVAPI_OK)
12985 {
12986 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12987
12988 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12989
12990 int tmp_out = 0;
12991
12992 for (int i = 0; i < tmp_in; i++)
12993 {
12994 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12995 }
12996
12997 for (int i = 0; i < tmp_out; i++)
12998 {
12999 NvU32 speed;
13000
13001 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13002 }
13003 }
13004 #endif // WIN && HAVE_NVAPI
13005
13006 #if defined(LINUX) && defined(HAVE_NVML)
13007 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
13008
13009 data.hm_dll_nv = hm_dll_nv;
13010
13011 if (hm_dll_nv)
13012 {
13013 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
13014 {
13015 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
13016
13017 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13018
13019 int tmp_out = 0;
13020
13021 for (int i = 0; i < tmp_in; i++)
13022 {
13023 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13024 }
13025
13026 for (int i = 0; i < tmp_out; i++)
13027 {
13028 unsigned int speed;
13029
13030 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;
13031 }
13032 }
13033 }
13034 #endif // LINUX && HAVE_NVML
13035
13036 #ifdef HAVE_ADL
13037 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
13038
13039 data.hm_dll_amd = hm_dll_amd;
13040
13041 if (hm_dll_amd)
13042 {
13043 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13044 {
13045 // total number of adapters
13046
13047 int hm_adapters_num;
13048
13049 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
13050
13051 // adapter info
13052
13053 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
13054
13055 if (lpAdapterInfo == NULL) return (-1);
13056
13057 // get a list (of ids of) valid/usable adapters
13058
13059 int num_adl_adapters = 0;
13060
13061 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13062
13063 if (num_adl_adapters > 0)
13064 {
13065 hc_thread_mutex_lock (mux_adl);
13066
13067 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13068
13069 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13070
13071 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13072 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13073
13074 hc_thread_mutex_unlock (mux_adl);
13075 }
13076
13077 myfree (valid_adl_device_list);
13078 myfree (lpAdapterInfo);
13079 }
13080 }
13081 #endif // HAVE_ADL
13082 }
13083
13084 /**
13085 * HM devices: copy
13086 */
13087
13088 if (gpu_temp_disable == 0)
13089 {
13090 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13091 {
13092 hc_device_param_t *device_param = &data.devices_param[device_id];
13093
13094 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13095
13096 if (device_param->skipped) continue;
13097
13098 const uint platform_devices_id = device_param->platform_devices_id;
13099
13100 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13101 if (device_param->vendor_id == VENDOR_ID_NV)
13102 {
13103 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13104 }
13105 #endif
13106
13107 #ifdef HAVE_ADL
13108 if (device_param->vendor_id == VENDOR_ID_AMD)
13109 {
13110 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13111 }
13112 #endif
13113 }
13114 }
13115
13116 /*
13117 * Temporary fix:
13118 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13119 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13120 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13121 * Driver / ADL bug?
13122 */
13123
13124 #ifdef HAVE_ADL
13125 if (powertune_enable == 1)
13126 {
13127 hc_thread_mutex_lock (mux_adl);
13128
13129 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13130 {
13131 hc_device_param_t *device_param = &data.devices_param[device_id];
13132
13133 if (device_param->skipped) continue;
13134
13135 if (data.hm_device[device_id].od_version == 6)
13136 {
13137 // set powertune value only
13138
13139 int powertune_supported = 0;
13140
13141 int ADL_rc = 0;
13142
13143 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13144 {
13145 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13146
13147 return (-1);
13148 }
13149
13150 if (powertune_supported != 0)
13151 {
13152 // powertune set
13153 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13154
13155 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13156 {
13157 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13158
13159 return (-1);
13160 }
13161
13162 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13163 {
13164 log_error ("ERROR: Failed to set new ADL PowerControl values");
13165
13166 return (-1);
13167 }
13168 }
13169 }
13170 }
13171
13172 hc_thread_mutex_unlock (mux_adl);
13173 }
13174 #endif // HAVE_ADK
13175 #endif // HAVE_HWMON
13176
13177 uint kernel_blocks_all = 0;
13178
13179 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13180 {
13181 /**
13182 * host buffer
13183 */
13184
13185 hc_device_param_t *device_param = &data.devices_param[device_id];
13186
13187 if (device_param->skipped) continue;
13188
13189 /**
13190 * device properties
13191 */
13192
13193 char *device_name_chksum = device_param->device_name_chksum;
13194
13195 uint device_processors = device_param->device_processors;
13196
13197 uint device_processor_cores = device_param->device_processor_cores;
13198
13199 cl_device_type device_type = device_param->device_type;
13200
13201 /**
13202 * create context for each device
13203 */
13204
13205 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13206
13207 /**
13208 * create command-queue
13209 */
13210
13211 // not support with NV
13212 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13213
13214 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13215
13216 /**
13217 * create input buffers on device
13218 */
13219
13220 uint kernel_threads = KERNEL_THREADS;
13221
13222 // bcrypt
13223 if (hash_mode == 3200) kernel_threads = 8;
13224 if (hash_mode == 9000) kernel_threads = 8;
13225
13226 if (device_type & CL_DEVICE_TYPE_CPU)
13227 {
13228 // CPU still need lots of workitems, don't know why...
13229 // for testing phase, lets start with this
13230
13231 // kernel_accel = 1;
13232 }
13233
13234 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13235 uint kernel_blocks = kernel_power;
13236
13237 device_param->kernel_threads = kernel_threads;
13238 device_param->kernel_power_user = kernel_power;
13239 device_param->kernel_blocks_user = kernel_blocks;
13240
13241 kernel_blocks_all += kernel_blocks;
13242
13243 uint size_pws = kernel_power * sizeof (pw_t);
13244
13245 uint size_tmps = 4;
13246
13247 switch (hash_mode)
13248 {
13249 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13250 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13251 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13252 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13253 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13254 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13255 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13256 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13257 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13258 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13259 case 6211:
13260 case 6212:
13261 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13262 case 6221:
13263 case 6222:
13264 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13265 case 6231:
13266 case 6232:
13267 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13268 case 6241:
13269 case 6242:
13270 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13271 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13272 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13273 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13274 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13275 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13276 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13277 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13278 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13279 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13280 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13281 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13282 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13283 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13284 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13285 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13286 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13287 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13288 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13289 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13290 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13291 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13292 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13293 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13294 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13295 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13296 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13297 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13298 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13299 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13300 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13301 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13302 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13303 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13304 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13305 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13306 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13307 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13308 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13309 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13310 };
13311
13312 uint size_hooks = 4;
13313
13314 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13315 {
13316 // insert correct hook size
13317 }
13318
13319 // we can optimize some stuff here...
13320
13321 device_param->size_pws = size_pws;
13322 device_param->size_tmps = size_tmps;
13323 device_param->size_hooks = size_hooks;
13324
13325 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13326 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13327
13328 device_param->size_root_css = size_root_css;
13329 device_param->size_markov_css = size_markov_css;
13330
13331 uint size_results = KERNEL_THREADS * sizeof (uint);
13332
13333 device_param->size_results = size_results;
13334
13335 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13336 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13337
13338 uint size_plains = digests_cnt * sizeof (plain_t);
13339 uint size_salts = salts_cnt * sizeof (salt_t);
13340 uint size_esalts = salts_cnt * esalt_size;
13341
13342 device_param->size_plains = size_plains;
13343 device_param->size_digests = size_digests;
13344 device_param->size_shown = size_shown;
13345 device_param->size_salts = size_salts;
13346
13347 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13348 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13349 uint size_tm = 32 * sizeof (bs_word_t);
13350
13351 u64 size_scryptV = 1;
13352
13353 if ((hash_mode == 8900) || (hash_mode == 9300))
13354 {
13355 uint tmto_start = 0;
13356 uint tmto_stop = 10;
13357
13358 if (scrypt_tmto)
13359 {
13360 tmto_start = scrypt_tmto;
13361 }
13362 else
13363 {
13364 // in case the user did not specify the tmto manually
13365 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13366 // but set the lower end only in case the user has a device with too less memory
13367
13368 if (hash_mode == 8900)
13369 {
13370 if (device_param->vendor_id == VENDOR_ID_AMD)
13371 {
13372 tmto_start = 1;
13373 }
13374 else if (device_param->vendor_id == VENDOR_ID_NV)
13375 {
13376 tmto_start = 3;
13377 }
13378 }
13379 else if (hash_mode == 9300)
13380 {
13381 if (device_param->vendor_id == VENDOR_ID_AMD)
13382 {
13383 tmto_start = 3;
13384 }
13385 else if (device_param->vendor_id == VENDOR_ID_NV)
13386 {
13387 tmto_start = 5;
13388 }
13389 }
13390 }
13391
13392 if (quiet == 0) log_info ("");
13393
13394 uint shader_per_mp = 1;
13395
13396 if (device_param->vendor_id == VENDOR_ID_AMD)
13397 {
13398 shader_per_mp = 8;
13399 }
13400 else if (device_param->vendor_id == VENDOR_ID_NV)
13401 {
13402 shader_per_mp = 32;
13403 }
13404
13405 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13406 {
13407 // TODO: in theory the following calculation needs to be done per salt, not global
13408 // we assume all hashes have the same scrypt settings
13409
13410 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13411
13412 size_scryptV /= 1 << tmto;
13413
13414 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13415
13416 if (size_scryptV > device_param->device_maxmem_alloc)
13417 {
13418 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13419
13420 continue;
13421 }
13422
13423 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13424 {
13425 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13426 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13427 }
13428
13429 break;
13430 }
13431
13432 if (data.salts_buf[0].scrypt_phy == 0)
13433 {
13434 log_error ("ERROR: can't allocate enough device memory");
13435
13436 return -1;
13437 }
13438
13439 if (quiet == 0) log_info ("");
13440 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13441 }
13442
13443 /**
13444 * default building options
13445 */
13446
13447 char build_opts[1024];
13448
13449 // we don't have sm_* on vendors not NV but it doesn't matter
13450
13451 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);
13452
13453 /**
13454 * main kernel
13455 */
13456
13457 {
13458 /**
13459 * kernel source filename
13460 */
13461
13462 char source_file[256] = { 0 };
13463
13464 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13465
13466 struct stat sst;
13467
13468 if (stat (source_file, &sst) == -1)
13469 {
13470 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13471
13472 return -1;
13473 }
13474
13475 /**
13476 * kernel cached filename
13477 */
13478
13479 char cached_file[256] = { 0 };
13480
13481 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13482
13483 int cached = 1;
13484
13485 struct stat cst;
13486
13487 if (stat (cached_file, &cst) == -1)
13488 {
13489 cached = 0;
13490 }
13491
13492 /**
13493 * kernel compile or load
13494 */
13495
13496 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13497
13498 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13499
13500 if (force_jit_compilation == -1)
13501 {
13502 if (cached == 0)
13503 {
13504 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13505
13506 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13507
13508 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13509
13510 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13511
13512 size_t binary_size;
13513
13514 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13515
13516 u8 *binary = (u8 *) mymalloc (binary_size);
13517
13518 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13519
13520 writeProgramBin (cached_file, binary, binary_size);
13521
13522 local_free (binary);
13523 }
13524 else
13525 {
13526 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13527
13528 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13529
13530 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13531
13532 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13533 }
13534 }
13535 else
13536 {
13537 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13538
13539 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13540
13541 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13542
13543 if (force_jit_compilation == 1500)
13544 {
13545 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13546 }
13547 else if (force_jit_compilation == 8900)
13548 {
13549 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);
13550 }
13551
13552 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13553 }
13554
13555 local_free (kernel_lengths);
13556 local_free (kernel_sources[0]);
13557 local_free (kernel_sources);
13558
13559 // this is mostly for debug
13560
13561 size_t ret_val_size = 0;
13562
13563 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13564
13565 if (ret_val_size > 2)
13566 {
13567 char *build_log = (char *) mymalloc (ret_val_size + 1);
13568
13569 memset (build_log, 0, ret_val_size + 1);
13570
13571 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13572
13573 puts (build_log);
13574
13575 myfree (build_log);
13576 }
13577 }
13578
13579 /**
13580 * word generator kernel
13581 */
13582
13583 if (attack_mode != ATTACK_MODE_STRAIGHT)
13584 {
13585 /**
13586 * kernel mp source filename
13587 */
13588
13589 char source_file[256] = { 0 };
13590
13591 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13592
13593 struct stat sst;
13594
13595 if (stat (source_file, &sst) == -1)
13596 {
13597 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13598
13599 return -1;
13600 }
13601
13602 /**
13603 * kernel mp cached filename
13604 */
13605
13606 char cached_file[256] = { 0 };
13607
13608 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13609
13610 int cached = 1;
13611
13612 struct stat cst;
13613
13614 if (stat (cached_file, &cst) == -1)
13615 {
13616 cached = 0;
13617 }
13618
13619 /**
13620 * kernel compile or load
13621 */
13622
13623 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13624
13625 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13626
13627 if (cached == 0)
13628 {
13629 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13630
13631 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13632
13633 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13634
13635 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13636
13637 size_t binary_size;
13638
13639 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13640
13641 u8 *binary = (u8 *) mymalloc (binary_size);
13642
13643 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13644
13645 writeProgramBin (cached_file, binary, binary_size);
13646
13647 local_free (binary);
13648 }
13649 else
13650 {
13651 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13652
13653 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13654
13655 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13656
13657 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13658 }
13659
13660 local_free (kernel_lengths);
13661 local_free (kernel_sources[0]);
13662 local_free (kernel_sources);
13663
13664 // this is mostly for debug
13665
13666 size_t ret_val_size = 0;
13667
13668 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13669
13670 if (ret_val_size > 2)
13671 {
13672 char *build_log = (char *) mymalloc (ret_val_size + 1);
13673
13674 memset (build_log, 0, ret_val_size + 1);
13675
13676 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13677
13678 puts (build_log);
13679
13680 myfree (build_log);
13681 }
13682 }
13683
13684 /**
13685 * amplifier kernel
13686 */
13687
13688 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13689 {
13690
13691 }
13692 else
13693 {
13694 /**
13695 * kernel amp source filename
13696 */
13697
13698 char source_file[256] = { 0 };
13699
13700 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13701
13702 struct stat sst;
13703
13704 if (stat (source_file, &sst) == -1)
13705 {
13706 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13707
13708 return -1;
13709 }
13710
13711 /**
13712 * kernel amp cached filename
13713 */
13714
13715 char cached_file[256] = { 0 };
13716
13717 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13718
13719 int cached = 1;
13720
13721 struct stat cst;
13722
13723 if (stat (cached_file, &cst) == -1)
13724 {
13725 cached = 0;
13726 }
13727
13728 /**
13729 * kernel compile or load
13730 */
13731
13732 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13733
13734 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13735
13736 if (cached == 0)
13737 {
13738 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13739
13740 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13741
13742 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13743
13744 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13745
13746 size_t binary_size;
13747
13748 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13749
13750 u8 *binary = (u8 *) mymalloc (binary_size);
13751
13752 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13753
13754 writeProgramBin (cached_file, binary, binary_size);
13755
13756 local_free (binary);
13757 }
13758 else
13759 {
13760 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13761
13762 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13763
13764 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13765
13766 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13767 }
13768
13769 local_free (kernel_lengths);
13770 local_free (kernel_sources[0]);
13771 local_free (kernel_sources);
13772
13773 // this is mostly for debug
13774
13775 size_t ret_val_size = 0;
13776
13777 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13778
13779 if (ret_val_size > 2)
13780 {
13781 char *build_log = (char *) mymalloc (ret_val_size + 1);
13782
13783 memset (build_log, 0, ret_val_size + 1);
13784
13785 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13786
13787 puts (build_log);
13788
13789 myfree (build_log);
13790 }
13791 }
13792
13793 /**
13794 * global buffers
13795 */
13796
13797 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13798 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13799 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13800 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13801 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13802 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13803 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13804 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13805 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13806 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13807 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13808 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13809 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13810 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13811 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13812 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13813 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13814 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13815
13816 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13817 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13818 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13819 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13820 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13821 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13822 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13823 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13824 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13825 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13826 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13827
13828 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13829 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13830 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13831 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13832 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13833 run_kernel_bzero (device_param, device_param->d_result, size_results);
13834
13835 /**
13836 * special buffers
13837 */
13838
13839 if (attack_kern == ATTACK_KERN_STRAIGHT)
13840 {
13841 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13842 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13843
13844 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13845
13846 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13847 }
13848 else if (attack_kern == ATTACK_KERN_COMBI)
13849 {
13850 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13851 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13852 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13853 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13854
13855 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13856 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13857 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13858 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13859 }
13860 else if (attack_kern == ATTACK_KERN_BF)
13861 {
13862 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13863 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13864 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13865 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13866 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13867
13868 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13869 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13870 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13871 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13872 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13873 }
13874
13875 if (size_esalts)
13876 {
13877 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13878
13879 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13880 }
13881
13882 /**
13883 * main host data
13884 */
13885
13886 uint *result = (uint *) mymalloc (size_results);
13887
13888 memset (result, 0, size_results);
13889
13890 device_param->result = result;
13891
13892 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13893
13894 memset (pws_buf, 0, size_pws);
13895
13896 device_param->pws_buf = pws_buf;
13897
13898 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13899
13900 for (int i = 0; i < 64; i++)
13901 {
13902 pw_caches[i].pw_buf.pw_len = i;
13903 pw_caches[i].cnt = 0;
13904 }
13905
13906 device_param->pw_caches = pw_caches;
13907
13908 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13909
13910 device_param->combs_buf = combs_buf;
13911
13912 void *hooks_buf = mymalloc (size_hooks);
13913
13914 device_param->hooks_buf = hooks_buf;
13915
13916 device_param->pw_transpose = pw_transpose_to_hi1;
13917 device_param->pw_add = pw_add_to_hc1;
13918
13919 /**
13920 * kernel args
13921 */
13922
13923 device_param->kernel_params_buf32[21] = bitmap_mask;
13924 device_param->kernel_params_buf32[22] = bitmap_shift1;
13925 device_param->kernel_params_buf32[23] = bitmap_shift2;
13926 device_param->kernel_params_buf32[24] = 0; // salt_pos
13927 device_param->kernel_params_buf32[25] = 0; // loop_pos
13928 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13929 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13930 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13931 device_param->kernel_params_buf32[29] = 0; // digests_offset
13932 device_param->kernel_params_buf32[30] = 0; // combs_mode
13933 device_param->kernel_params_buf32[31] = 0; // gid_max
13934
13935 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13936 ? &device_param->d_pws_buf
13937 : &device_param->d_pws_amp_buf;
13938 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13939 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13940 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13941 device_param->kernel_params[ 4] = &device_param->d_tmps;
13942 device_param->kernel_params[ 5] = &device_param->d_hooks;
13943 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13944 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13945 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13946 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13947 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13948 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13949 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13950 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13951 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13952 device_param->kernel_params[15] = &device_param->d_digests_buf;
13953 device_param->kernel_params[16] = &device_param->d_digests_shown;
13954 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13955 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13956 device_param->kernel_params[19] = &device_param->d_result;
13957 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13958 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13959 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13960 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13961 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13962 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13963 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13964 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13965 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13966 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13967 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13968 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13969
13970 device_param->kernel_params_mp_buf64[3] = 0;
13971 device_param->kernel_params_mp_buf32[4] = 0;
13972 device_param->kernel_params_mp_buf32[5] = 0;
13973 device_param->kernel_params_mp_buf32[6] = 0;
13974 device_param->kernel_params_mp_buf32[7] = 0;
13975 device_param->kernel_params_mp_buf32[8] = 0;
13976
13977 device_param->kernel_params_mp[0] = NULL;
13978 device_param->kernel_params_mp[1] = NULL;
13979 device_param->kernel_params_mp[2] = NULL;
13980 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13981 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13982 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13983 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13984 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13985 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13986
13987 device_param->kernel_params_mp_l_buf64[3] = 0;
13988 device_param->kernel_params_mp_l_buf32[4] = 0;
13989 device_param->kernel_params_mp_l_buf32[5] = 0;
13990 device_param->kernel_params_mp_l_buf32[6] = 0;
13991 device_param->kernel_params_mp_l_buf32[7] = 0;
13992 device_param->kernel_params_mp_l_buf32[8] = 0;
13993 device_param->kernel_params_mp_l_buf32[9] = 0;
13994
13995 device_param->kernel_params_mp_l[0] = NULL;
13996 device_param->kernel_params_mp_l[1] = NULL;
13997 device_param->kernel_params_mp_l[2] = NULL;
13998 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13999 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
14000 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
14001 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
14002 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
14003 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
14004 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
14005
14006 device_param->kernel_params_mp_r_buf64[3] = 0;
14007 device_param->kernel_params_mp_r_buf32[4] = 0;
14008 device_param->kernel_params_mp_r_buf32[5] = 0;
14009 device_param->kernel_params_mp_r_buf32[6] = 0;
14010 device_param->kernel_params_mp_r_buf32[7] = 0;
14011 device_param->kernel_params_mp_r_buf32[8] = 0;
14012
14013 device_param->kernel_params_mp_r[0] = NULL;
14014 device_param->kernel_params_mp_r[1] = NULL;
14015 device_param->kernel_params_mp_r[2] = NULL;
14016 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
14017 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
14018 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
14019 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
14020 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
14021 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
14022
14023 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
14024 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
14025
14026 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
14027 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
14028 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
14029 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
14030 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
14031 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
14032 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
14033
14034 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
14035
14036 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
14037 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
14038
14039 /**
14040 * kernel name
14041 */
14042
14043 char kernel_name[64] = { 0 };
14044
14045 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14046 {
14047 if (opti_type & OPTI_TYPE_SINGLE_HASH)
14048 {
14049 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
14050
14051 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14052
14053 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
14054
14055 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14056
14057 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
14058
14059 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14060 }
14061 else
14062 {
14063 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
14064
14065 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14066
14067 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
14068
14069 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14070
14071 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
14072
14073 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14074 }
14075
14076 if (data.attack_mode == ATTACK_MODE_BF)
14077 {
14078 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14079 {
14080 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
14081
14082 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
14083
14084 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
14085
14086 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
14087 }
14088 }
14089 }
14090 else
14091 {
14092 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14093
14094 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14095
14096 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14097
14098 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14099
14100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14101
14102 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14103
14104 if (opts_type & OPTS_TYPE_HOOK12)
14105 {
14106 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14107
14108 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14109 }
14110
14111 if (opts_type & OPTS_TYPE_HOOK23)
14112 {
14113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14114
14115 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14116 }
14117 }
14118
14119 for (uint i = 0; i <= 20; i++)
14120 {
14121 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14122 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14123 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14124
14125 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14126 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14127 }
14128
14129 for (uint i = 21; i <= 31; i++)
14130 {
14131 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14132 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14133 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14134
14135 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14136 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14137 }
14138
14139 if (attack_mode == ATTACK_MODE_BF)
14140 {
14141 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14142 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14143
14144 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14145 {
14146 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14147
14148 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14149 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14150 }
14151 }
14152 else if (attack_mode == ATTACK_MODE_HYBRID1)
14153 {
14154 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14155 }
14156 else if (attack_mode == ATTACK_MODE_HYBRID2)
14157 {
14158 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14159 }
14160
14161 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14162 {
14163 // nothing to do
14164 }
14165 else
14166 {
14167 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14168 }
14169
14170 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14171 {
14172 // nothing to do
14173 }
14174 else
14175 {
14176 for (uint i = 0; i < 5; i++)
14177 {
14178 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14179 }
14180
14181 for (uint i = 5; i < 7; i++)
14182 {
14183 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14184 }
14185 }
14186
14187 /**
14188 * Store initial fanspeed if gpu_temp_retain is enabled
14189 */
14190
14191 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
14192 int gpu_temp_retain_set = 0;
14193
14194 if (gpu_temp_disable == 0)
14195 {
14196 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14197 {
14198 hc_thread_mutex_lock (mux_adl);
14199
14200 if (data.hm_device[device_id].fan_supported == 1)
14201 {
14202 if (gpu_temp_retain_chgd == 0)
14203 {
14204 uint cur_temp = 0;
14205 uint default_temp = 0;
14206
14207 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
14208
14209 if (ADL_rc == ADL_OK)
14210 {
14211 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14212
14213 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14214
14215 // special case with multi gpu setups: always use minimum retain
14216
14217 if (gpu_temp_retain_set == 0)
14218 {
14219 gpu_temp_retain = gpu_temp_retain_target;
14220 gpu_temp_retain_set = 1;
14221 }
14222 else
14223 {
14224 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14225 }
14226
14227 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14228 }
14229 }
14230
14231 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14232
14233 temp_retain_fanspeed_value[device_id] = fan_speed;
14234
14235 if (fan_speed == -1)
14236 {
14237 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14238
14239 temp_retain_fanspeed_value[device_id] = 0;
14240 }
14241 }
14242
14243 hc_thread_mutex_unlock (mux_adl);
14244 }
14245 }
14246
14247 /**
14248 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14249 */
14250
14251 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14252 {
14253 hc_thread_mutex_lock (mux_adl);
14254
14255 if (data.hm_device[device_id].od_version == 6)
14256 {
14257 int ADL_rc;
14258
14259 // check powertune capabilities first, if not available then skip device
14260
14261 int powertune_supported = 0;
14262
14263 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14264 {
14265 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14266
14267 return (-1);
14268 }
14269
14270 if (powertune_supported != 0)
14271 {
14272 // powercontrol settings
14273
14274 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14275
14276 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14277 {
14278 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]);
14279 }
14280
14281 if (ADL_rc != ADL_OK)
14282 {
14283 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14284
14285 return (-1);
14286 }
14287
14288 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14289 {
14290 log_error ("ERROR: Failed to set new ADL PowerControl values");
14291
14292 return (-1);
14293 }
14294
14295 // clocks
14296
14297 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14298
14299 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14300
14301 if ((ADL_rc = 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)
14302 {
14303 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14304
14305 return (-1);
14306 }
14307
14308 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14309
14310 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14311
14312 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14313 {
14314 log_error ("ERROR: Failed to get ADL device capabilities");
14315
14316 return (-1);
14317 }
14318
14319 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14320 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14321
14322 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14323 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14324
14325 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14326 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14327
14328 // warning if profile has too low max values
14329
14330 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14331 {
14332 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14333 }
14334
14335 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14336 {
14337 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14338 }
14339
14340 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14341
14342 performance_state->iNumberOfPerformanceLevels = 2;
14343
14344 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14345 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14346 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14347 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14348
14349 if ((ADL_rc = 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)
14350 {
14351 log_info ("ERROR: Failed to set ADL performance state");
14352
14353 return (-1);
14354 }
14355
14356 local_free (performance_state);
14357 }
14358 }
14359
14360 hc_thread_mutex_unlock (mux_adl);
14361 }
14362 #endif // HAVE_HWMON && HAVE_ADL
14363 }
14364
14365 data.kernel_blocks_all = kernel_blocks_all;
14366
14367 if (data.quiet == 0) log_info ("");
14368
14369 /**
14370 * Inform user which algorithm is checked and at which workload setting
14371 */
14372
14373 if (benchmark == 1)
14374 {
14375 quiet = 0;
14376
14377 data.quiet = quiet;
14378
14379 char *hash_type = strhashtype (data.hash_mode); // not a bug
14380
14381 log_info ("Hashtype: %s", hash_type);
14382 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14383 log_info ("");
14384 }
14385
14386 /**
14387 * keep track of the progress
14388 */
14389
14390 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14391 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14392 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14393
14394 /**
14395 * open filehandles
14396 */
14397
14398 #if _WIN
14399 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14400 {
14401 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14402
14403 return (-1);
14404 }
14405
14406 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14407 {
14408 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14409
14410 return (-1);
14411 }
14412
14413 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14414 {
14415 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14416
14417 return (-1);
14418 }
14419 #endif
14420
14421 /**
14422 * dictionary pad
14423 */
14424
14425 segment_size *= (1024 * 1024);
14426
14427 data.segment_size = segment_size;
14428
14429 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14430
14431 wl_data->buf = (char *) mymalloc (segment_size);
14432 wl_data->avail = segment_size;
14433 wl_data->incr = segment_size;
14434 wl_data->cnt = 0;
14435 wl_data->pos = 0;
14436
14437 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14438
14439 data.wordlist_mode = wordlist_mode;
14440
14441 cs_t *css_buf = NULL;
14442 uint css_cnt = 0;
14443 uint dictcnt = 0;
14444 uint maskcnt = 1;
14445 char **masks = NULL;
14446 char **dictfiles = NULL;
14447
14448 uint mask_from_file = 0;
14449
14450 if (attack_mode == ATTACK_MODE_STRAIGHT)
14451 {
14452 if (wordlist_mode == WL_MODE_FILE)
14453 {
14454 int wls_left = myargc - (optind + 1);
14455
14456 for (int i = 0; i < wls_left; i++)
14457 {
14458 char *l0_filename = myargv[optind + 1 + i];
14459
14460 struct stat l0_stat;
14461
14462 if (stat (l0_filename, &l0_stat) == -1)
14463 {
14464 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14465
14466 return (-1);
14467 }
14468
14469 uint is_dir = S_ISDIR (l0_stat.st_mode);
14470
14471 if (is_dir == 0)
14472 {
14473 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14474
14475 dictcnt++;
14476
14477 dictfiles[dictcnt - 1] = l0_filename;
14478 }
14479 else
14480 {
14481 // do not allow --keyspace w/ a directory
14482
14483 if (keyspace == 1)
14484 {
14485 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14486
14487 return (-1);
14488 }
14489
14490 char **dictionary_files = NULL;
14491
14492 dictionary_files = scan_directory (l0_filename);
14493
14494 if (dictionary_files != NULL)
14495 {
14496 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14497
14498 for (int d = 0; dictionary_files[d] != NULL; d++)
14499 {
14500 char *l1_filename = dictionary_files[d];
14501
14502 struct stat l1_stat;
14503
14504 if (stat (l1_filename, &l1_stat) == -1)
14505 {
14506 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14507
14508 return (-1);
14509 }
14510
14511 if (S_ISREG (l1_stat.st_mode))
14512 {
14513 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14514
14515 dictcnt++;
14516
14517 dictfiles[dictcnt - 1] = strdup (l1_filename);
14518 }
14519 }
14520 }
14521
14522 local_free (dictionary_files);
14523 }
14524 }
14525
14526 if (dictcnt < 1)
14527 {
14528 log_error ("ERROR: No usable dictionary file found.");
14529
14530 return (-1);
14531 }
14532 }
14533 else if (wordlist_mode == WL_MODE_STDIN)
14534 {
14535 dictcnt = 1;
14536 }
14537 }
14538 else if (attack_mode == ATTACK_MODE_COMBI)
14539 {
14540 // display
14541
14542 char *dictfile1 = myargv[optind + 1 + 0];
14543 char *dictfile2 = myargv[optind + 1 + 1];
14544
14545 // find the bigger dictionary and use as base
14546
14547 FILE *fp1;
14548 FILE *fp2;
14549
14550 struct stat tmp_stat;
14551
14552 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14553 {
14554 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14555
14556 return (-1);
14557 }
14558
14559 if (stat (dictfile1, &tmp_stat) == -1)
14560 {
14561 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14562
14563 fclose (fp1);
14564
14565 return (-1);
14566 }
14567
14568 if (S_ISDIR (tmp_stat.st_mode))
14569 {
14570 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14571
14572 fclose (fp1);
14573
14574 return (-1);
14575 }
14576
14577 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14578 {
14579 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14580
14581 fclose (fp1);
14582
14583 return (-1);
14584 }
14585
14586 if (stat (dictfile2, &tmp_stat) == -1)
14587 {
14588 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14589
14590 fclose (fp1);
14591 fclose (fp2);
14592
14593 return (-1);
14594 }
14595
14596 if (S_ISDIR (tmp_stat.st_mode))
14597 {
14598 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14599
14600 fclose (fp1);
14601 fclose (fp2);
14602
14603 return (-1);
14604 }
14605
14606 data.combs_cnt = 1;
14607
14608 data.quiet = 1;
14609
14610 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14611
14612 data.quiet = quiet;
14613
14614 if (words1_cnt == 0)
14615 {
14616 log_error ("ERROR: %s: empty file", dictfile1);
14617
14618 fclose (fp1);
14619 fclose (fp2);
14620
14621 return (-1);
14622 }
14623
14624 data.combs_cnt = 1;
14625
14626 data.quiet = 1;
14627
14628 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14629
14630 data.quiet = quiet;
14631
14632 if (words2_cnt == 0)
14633 {
14634 log_error ("ERROR: %s: empty file", dictfile2);
14635
14636 fclose (fp1);
14637 fclose (fp2);
14638
14639 return (-1);
14640 }
14641
14642 fclose (fp1);
14643 fclose (fp2);
14644
14645 data.dictfile = dictfile1;
14646 data.dictfile2 = dictfile2;
14647
14648 if (words1_cnt >= words2_cnt)
14649 {
14650 data.combs_cnt = words2_cnt;
14651 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14652
14653 dictfiles = &data.dictfile;
14654
14655 dictcnt = 1;
14656 }
14657 else
14658 {
14659 data.combs_cnt = words1_cnt;
14660 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14661
14662 dictfiles = &data.dictfile2;
14663
14664 dictcnt = 1;
14665
14666 // we also have to switch wordlist related rules!
14667
14668 char *tmpc = data.rule_buf_l;
14669
14670 data.rule_buf_l = data.rule_buf_r;
14671 data.rule_buf_r = tmpc;
14672
14673 int tmpi = data.rule_len_l;
14674
14675 data.rule_len_l = data.rule_len_r;
14676 data.rule_len_r = tmpi;
14677 }
14678 }
14679 else if (attack_mode == ATTACK_MODE_BF)
14680 {
14681 char *mask = NULL;
14682
14683 maskcnt = 0;
14684
14685 if (benchmark == 0)
14686 {
14687 mask = myargv[optind + 1];
14688
14689 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14690
14691 if ((optind + 2) <= myargc)
14692 {
14693 struct stat file_stat;
14694
14695 if (stat (mask, &file_stat) == -1)
14696 {
14697 maskcnt = 1;
14698
14699 masks[maskcnt - 1] = mystrdup (mask);
14700 }
14701 else
14702 {
14703 int wls_left = myargc - (optind + 1);
14704
14705 uint masks_avail = INCR_MASKS;
14706
14707 for (int i = 0; i < wls_left; i++)
14708 {
14709 if (i != 0)
14710 {
14711 mask = myargv[optind + 1 + i];
14712
14713 if (stat (mask, &file_stat) == -1)
14714 {
14715 log_error ("ERROR: %s: %s", mask, strerror (errno));
14716
14717 return (-1);
14718 }
14719 }
14720
14721 uint is_file = S_ISREG (file_stat.st_mode);
14722
14723 if (is_file == 1)
14724 {
14725 FILE *mask_fp;
14726
14727 if ((mask_fp = fopen (mask, "r")) == NULL)
14728 {
14729 log_error ("ERROR: %s: %s", mask, strerror (errno));
14730
14731 return (-1);
14732 }
14733
14734 char line_buf[BUFSIZ];
14735
14736 while (!feof (mask_fp))
14737 {
14738 memset (line_buf, 0, BUFSIZ);
14739
14740 int line_len = fgetl (mask_fp, line_buf);
14741
14742 if (line_len == 0) continue;
14743
14744 if (line_buf[0] == '#') continue;
14745
14746 if (masks_avail == maskcnt)
14747 {
14748 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14749
14750 masks_avail += INCR_MASKS;
14751 }
14752
14753 masks[maskcnt] = mystrdup (line_buf);
14754
14755 maskcnt++;
14756 }
14757
14758 fclose (mask_fp);
14759 }
14760 else
14761 {
14762 log_error ("ERROR: %s: unsupported file-type", mask);
14763
14764 return (-1);
14765 }
14766 }
14767
14768 mask_from_file = 1;
14769 }
14770 }
14771 else
14772 {
14773 custom_charset_1 = (char *) "?l?d?u";
14774 custom_charset_2 = (char *) "?l?d";
14775 custom_charset_3 = (char *) "?l?d*!$@_";
14776
14777 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14778 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14779 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14780
14781 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14782
14783 wordlist_mode = WL_MODE_MASK;
14784
14785 data.wordlist_mode = wordlist_mode;
14786
14787 increment = 1;
14788
14789 maskcnt = 1;
14790 }
14791 }
14792 else
14793 {
14794 /**
14795 * generate full masks and charsets
14796 */
14797
14798 masks = (char **) mymalloc (sizeof (char *));
14799
14800 switch (hash_mode)
14801 {
14802 case 1731: pw_min = 5;
14803 pw_max = 5;
14804 mask = mystrdup ("?b?b?b?b?b");
14805 break;
14806 case 12500: pw_min = 5;
14807 pw_max = 5;
14808 mask = mystrdup ("?b?b?b?b?b");
14809 break;
14810 default: pw_min = 7;
14811 pw_max = 7;
14812 mask = mystrdup ("?b?b?b?b?b?b?b");
14813 break;
14814 }
14815
14816 maskcnt = 1;
14817
14818 masks[maskcnt - 1] = mystrdup (mask);
14819
14820 wordlist_mode = WL_MODE_MASK;
14821
14822 data.wordlist_mode = wordlist_mode;
14823
14824 increment = 1;
14825 }
14826
14827 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14828
14829 if (increment)
14830 {
14831 if (increment_min > pw_min) pw_min = increment_min;
14832
14833 if (increment_max < pw_max) pw_max = increment_max;
14834 }
14835 }
14836 else if (attack_mode == ATTACK_MODE_HYBRID1)
14837 {
14838 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14839
14840 // display
14841
14842 char *mask = myargv[myargc - 1];
14843
14844 maskcnt = 0;
14845
14846 masks = (char **) mymalloc (1 * sizeof (char *));
14847
14848 // mod
14849
14850 struct stat file_stat;
14851
14852 if (stat (mask, &file_stat) == -1)
14853 {
14854 maskcnt = 1;
14855
14856 masks[maskcnt - 1] = mystrdup (mask);
14857 }
14858 else
14859 {
14860 uint is_file = S_ISREG (file_stat.st_mode);
14861
14862 if (is_file == 1)
14863 {
14864 FILE *mask_fp;
14865
14866 if ((mask_fp = fopen (mask, "r")) == NULL)
14867 {
14868 log_error ("ERROR: %s: %s", mask, strerror (errno));
14869
14870 return (-1);
14871 }
14872
14873 char line_buf[BUFSIZ];
14874
14875 uint masks_avail = 1;
14876
14877 while (!feof (mask_fp))
14878 {
14879 memset (line_buf, 0, BUFSIZ);
14880
14881 int line_len = fgetl (mask_fp, line_buf);
14882
14883 if (line_len == 0) continue;
14884
14885 if (line_buf[0] == '#') continue;
14886
14887 if (masks_avail == maskcnt)
14888 {
14889 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14890
14891 masks_avail += INCR_MASKS;
14892 }
14893
14894 masks[maskcnt] = mystrdup (line_buf);
14895
14896 maskcnt++;
14897 }
14898
14899 fclose (mask_fp);
14900
14901 mask_from_file = 1;
14902 }
14903 else
14904 {
14905 maskcnt = 1;
14906
14907 masks[maskcnt - 1] = mystrdup (mask);
14908 }
14909 }
14910
14911 // base
14912
14913 int wls_left = myargc - (optind + 2);
14914
14915 for (int i = 0; i < wls_left; i++)
14916 {
14917 char *filename = myargv[optind + 1 + i];
14918
14919 struct stat file_stat;
14920
14921 if (stat (filename, &file_stat) == -1)
14922 {
14923 log_error ("ERROR: %s: %s", filename, strerror (errno));
14924
14925 return (-1);
14926 }
14927
14928 uint is_dir = S_ISDIR (file_stat.st_mode);
14929
14930 if (is_dir == 0)
14931 {
14932 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14933
14934 dictcnt++;
14935
14936 dictfiles[dictcnt - 1] = filename;
14937 }
14938 else
14939 {
14940 // do not allow --keyspace w/ a directory
14941
14942 if (keyspace == 1)
14943 {
14944 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14945
14946 return (-1);
14947 }
14948
14949 char **dictionary_files = NULL;
14950
14951 dictionary_files = scan_directory (filename);
14952
14953 if (dictionary_files != NULL)
14954 {
14955 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14956
14957 for (int d = 0; dictionary_files[d] != NULL; d++)
14958 {
14959 char *l1_filename = dictionary_files[d];
14960
14961 struct stat l1_stat;
14962
14963 if (stat (l1_filename, &l1_stat) == -1)
14964 {
14965 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14966
14967 return (-1);
14968 }
14969
14970 if (S_ISREG (l1_stat.st_mode))
14971 {
14972 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14973
14974 dictcnt++;
14975
14976 dictfiles[dictcnt - 1] = strdup (l1_filename);
14977 }
14978 }
14979 }
14980
14981 local_free (dictionary_files);
14982 }
14983 }
14984
14985 if (dictcnt < 1)
14986 {
14987 log_error ("ERROR: No usable dictionary file found.");
14988
14989 return (-1);
14990 }
14991
14992 if (increment)
14993 {
14994 maskcnt = 0;
14995
14996 uint mask_min = increment_min; // we can't reject smaller masks here
14997 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14998
14999 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15000 {
15001 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15002
15003 if (cur_mask == NULL) break;
15004
15005 masks[maskcnt] = cur_mask;
15006
15007 maskcnt++;
15008
15009 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15010 }
15011 }
15012 }
15013 else if (attack_mode == ATTACK_MODE_HYBRID2)
15014 {
15015 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15016
15017 // display
15018
15019 char *mask = myargv[optind + 1 + 0];
15020
15021 maskcnt = 0;
15022
15023 masks = (char **) mymalloc (1 * sizeof (char *));
15024
15025 // mod
15026
15027 struct stat file_stat;
15028
15029 if (stat (mask, &file_stat) == -1)
15030 {
15031 maskcnt = 1;
15032
15033 masks[maskcnt - 1] = mystrdup (mask);
15034 }
15035 else
15036 {
15037 uint is_file = S_ISREG (file_stat.st_mode);
15038
15039 if (is_file == 1)
15040 {
15041 FILE *mask_fp;
15042
15043 if ((mask_fp = fopen (mask, "r")) == NULL)
15044 {
15045 log_error ("ERROR: %s: %s", mask, strerror (errno));
15046
15047 return (-1);
15048 }
15049
15050 char line_buf[BUFSIZ];
15051
15052 uint masks_avail = 1;
15053
15054 while (!feof (mask_fp))
15055 {
15056 memset (line_buf, 0, BUFSIZ);
15057
15058 int line_len = fgetl (mask_fp, line_buf);
15059
15060 if (line_len == 0) continue;
15061
15062 if (line_buf[0] == '#') continue;
15063
15064 if (masks_avail == maskcnt)
15065 {
15066 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15067
15068 masks_avail += INCR_MASKS;
15069 }
15070
15071 masks[maskcnt] = mystrdup (line_buf);
15072
15073 maskcnt++;
15074 }
15075
15076 fclose (mask_fp);
15077
15078 mask_from_file = 1;
15079 }
15080 else
15081 {
15082 maskcnt = 1;
15083
15084 masks[maskcnt - 1] = mystrdup (mask);
15085 }
15086 }
15087
15088 // base
15089
15090 int wls_left = myargc - (optind + 2);
15091
15092 for (int i = 0; i < wls_left; i++)
15093 {
15094 char *filename = myargv[optind + 2 + i];
15095
15096 struct stat file_stat;
15097
15098 if (stat (filename, &file_stat) == -1)
15099 {
15100 log_error ("ERROR: %s: %s", filename, strerror (errno));
15101
15102 return (-1);
15103 }
15104
15105 uint is_dir = S_ISDIR (file_stat.st_mode);
15106
15107 if (is_dir == 0)
15108 {
15109 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15110
15111 dictcnt++;
15112
15113 dictfiles[dictcnt - 1] = filename;
15114 }
15115 else
15116 {
15117 // do not allow --keyspace w/ a directory
15118
15119 if (keyspace == 1)
15120 {
15121 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15122
15123 return (-1);
15124 }
15125
15126 char **dictionary_files = NULL;
15127
15128 dictionary_files = scan_directory (filename);
15129
15130 if (dictionary_files != NULL)
15131 {
15132 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15133
15134 for (int d = 0; dictionary_files[d] != NULL; d++)
15135 {
15136 char *l1_filename = dictionary_files[d];
15137
15138 struct stat l1_stat;
15139
15140 if (stat (l1_filename, &l1_stat) == -1)
15141 {
15142 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15143
15144 return (-1);
15145 }
15146
15147 if (S_ISREG (l1_stat.st_mode))
15148 {
15149 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15150
15151 dictcnt++;
15152
15153 dictfiles[dictcnt - 1] = strdup (l1_filename);
15154 }
15155 }
15156 }
15157
15158 local_free (dictionary_files);
15159 }
15160 }
15161
15162 if (dictcnt < 1)
15163 {
15164 log_error ("ERROR: No usable dictionary file found.");
15165
15166 return (-1);
15167 }
15168
15169 if (increment)
15170 {
15171 maskcnt = 0;
15172
15173 uint mask_min = increment_min; // we can't reject smaller masks here
15174 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15175
15176 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15177 {
15178 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15179
15180 if (cur_mask == NULL) break;
15181
15182 masks[maskcnt] = cur_mask;
15183
15184 maskcnt++;
15185
15186 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15187 }
15188 }
15189 }
15190
15191 data.pw_min = pw_min;
15192 data.pw_max = pw_max;
15193
15194 /**
15195 * weak hash check
15196 */
15197
15198 if (weak_hash_threshold >= salts_cnt)
15199 {
15200 uint first_device_id = 0;
15201
15202 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15203 {
15204 hc_device_param_t *device_param = &data.devices_param[device_id];
15205
15206 if (device_param->skipped) continue;
15207
15208 first_device_id = device_id;
15209
15210 break;
15211 }
15212
15213 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15214
15215 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15216 {
15217 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15218 }
15219 }
15220
15221 // Display hack, guarantee that there is at least one \r before real start
15222
15223 if (data.quiet == 0) log_info_nn ("");
15224
15225 /**
15226 * status and monitor threads
15227 */
15228
15229 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15230
15231 hc_thread_t i_thread = 0;
15232
15233 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15234 {
15235 hc_thread_create (i_thread, thread_keypress, &benchmark);
15236 }
15237
15238 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15239
15240 uint ni_threads_cnt = 0;
15241
15242 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15243
15244 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15245
15246 ni_threads_cnt++;
15247
15248 /**
15249 * Outfile remove
15250 */
15251
15252 if (keyspace == 0)
15253 {
15254 if (outfile_check_timer != 0)
15255 {
15256 if (data.outfile_check_directory != NULL)
15257 {
15258 if ((hash_mode != 5200) &&
15259 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15260 (hash_mode != 9000))
15261 {
15262 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15263
15264 ni_threads_cnt++;
15265 }
15266 else
15267 {
15268 outfile_check_timer = 0;
15269 }
15270 }
15271 else
15272 {
15273 outfile_check_timer = 0;
15274 }
15275 }
15276 }
15277
15278 /**
15279 * Inform the user if we got some hashes remove because of the pot file remove feature
15280 */
15281
15282 if (data.quiet == 0)
15283 {
15284 if (potfile_remove_cracks > 0)
15285 {
15286 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15287 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15288 }
15289 }
15290
15291 data.outfile_check_timer = outfile_check_timer;
15292
15293 /**
15294 * main loop
15295 */
15296
15297 char **induction_dictionaries = NULL;
15298
15299 int induction_dictionaries_cnt = 0;
15300
15301 hcstat_table_t *root_table_buf = NULL;
15302 hcstat_table_t *markov_table_buf = NULL;
15303
15304 uint initial_restore_done = 0;
15305
15306 data.maskcnt = maskcnt;
15307
15308 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15309 {
15310 if (data.devices_status == STATUS_CRACKED) break;
15311
15312 data.devices_status = STATUS_INIT;
15313
15314 if (maskpos > rd->maskpos)
15315 {
15316 rd->dictpos = 0;
15317 }
15318
15319 rd->maskpos = maskpos;
15320 data.maskpos = maskpos;
15321
15322 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15323 {
15324 char *mask = masks[maskpos];
15325
15326 if (mask_from_file == 1)
15327 {
15328 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15329
15330 char *str_ptr;
15331 uint str_pos;
15332
15333 uint mask_offset = 0;
15334
15335 uint separator_cnt;
15336
15337 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15338 {
15339 str_ptr = strstr (mask + mask_offset, ",");
15340
15341 if (str_ptr == NULL) break;
15342
15343 str_pos = str_ptr - mask;
15344
15345 // escaped separator, i.e. "\,"
15346
15347 if (str_pos > 0)
15348 {
15349 if (mask[str_pos - 1] == '\\')
15350 {
15351 separator_cnt --;
15352
15353 mask_offset = str_pos + 1;
15354
15355 continue;
15356 }
15357 }
15358
15359 // reset the offset
15360
15361 mask_offset = 0;
15362
15363 mask[str_pos] = '\0';
15364
15365 switch (separator_cnt)
15366 {
15367 case 0:
15368 mp_reset_usr (mp_usr, 0);
15369
15370 custom_charset_1 = mask;
15371 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15372 break;
15373
15374 case 1:
15375 mp_reset_usr (mp_usr, 1);
15376
15377 custom_charset_2 = mask;
15378 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15379 break;
15380
15381 case 2:
15382 mp_reset_usr (mp_usr, 2);
15383
15384 custom_charset_3 = mask;
15385 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15386 break;
15387
15388 case 3:
15389 mp_reset_usr (mp_usr, 3);
15390
15391 custom_charset_4 = mask;
15392 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15393 break;
15394 }
15395
15396 mask = mask + str_pos + 1;
15397 }
15398 }
15399
15400 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15401 {
15402 if (maskpos > 0)
15403 {
15404 local_free (css_buf);
15405 local_free (data.root_css_buf);
15406 local_free (data.markov_css_buf);
15407
15408 local_free (masks[maskpos - 1]);
15409 }
15410
15411 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15412
15413 data.mask = mask;
15414 data.css_cnt = css_cnt;
15415 data.css_buf = css_buf;
15416
15417 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15418
15419 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15420
15421 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15422 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15423
15424 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15425
15426 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15427
15428 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15429 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15430
15431 data.root_css_buf = root_css_buf;
15432 data.markov_css_buf = markov_css_buf;
15433
15434 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15435
15436 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15437
15438 local_free (root_table_buf);
15439 local_free (markov_table_buf);
15440
15441 // args
15442
15443 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15444 {
15445 hc_device_param_t *device_param = &data.devices_param[device_id];
15446
15447 if (device_param->skipped) continue;
15448
15449 device_param->kernel_params_mp[0] = &device_param->d_combs;
15450 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15451 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15452
15453 device_param->kernel_params_mp_buf64[3] = 0;
15454 device_param->kernel_params_mp_buf32[4] = css_cnt;
15455 device_param->kernel_params_mp_buf32[5] = 0;
15456 device_param->kernel_params_mp_buf32[6] = 0;
15457 device_param->kernel_params_mp_buf32[7] = 0;
15458
15459 if (attack_mode == ATTACK_MODE_HYBRID1)
15460 {
15461 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15462 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15463 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15464 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15465 }
15466 else if (attack_mode == ATTACK_MODE_HYBRID2)
15467 {
15468 device_param->kernel_params_mp_buf32[5] = 0;
15469 device_param->kernel_params_mp_buf32[6] = 0;
15470 device_param->kernel_params_mp_buf32[7] = 0;
15471 }
15472
15473 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15474 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15475 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15476
15477 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);
15478 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);
15479 }
15480 }
15481 else if (attack_mode == ATTACK_MODE_BF)
15482 {
15483 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15484
15485 if (increment)
15486 {
15487 for (uint i = 0; i < dictcnt; i++)
15488 {
15489 local_free (dictfiles[i]);
15490 }
15491
15492 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15493 {
15494 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15495
15496 if (l1_filename == NULL) break;
15497
15498 dictcnt++;
15499
15500 dictfiles[dictcnt - 1] = l1_filename;
15501 }
15502 }
15503 else
15504 {
15505 dictcnt++;
15506
15507 dictfiles[dictcnt - 1] = mask;
15508 }
15509
15510 if (dictcnt == 0)
15511 {
15512 log_error ("ERROR: Mask is too small");
15513
15514 return (-1);
15515 }
15516 }
15517 }
15518
15519 free (induction_dictionaries);
15520
15521 // induction_dictionaries_cnt = 0; // implied
15522
15523 if (attack_mode != ATTACK_MODE_BF)
15524 {
15525 if (keyspace == 0)
15526 {
15527 induction_dictionaries = scan_directory (induction_directory);
15528
15529 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15530 }
15531 }
15532
15533 if (induction_dictionaries_cnt)
15534 {
15535 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15536 }
15537
15538 /**
15539 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15540 */
15541 if (keyspace == 1)
15542 {
15543 if ((maskcnt > 1) || (dictcnt > 1))
15544 {
15545 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15546
15547 return (-1);
15548 }
15549 }
15550
15551 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15552 {
15553 char *subid = logfile_generate_subid ();
15554
15555 data.subid = subid;
15556
15557 logfile_sub_msg ("START");
15558
15559 data.devices_status = STATUS_INIT;
15560
15561 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15562 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15563 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15564
15565 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15566
15567 data.cpt_pos = 0;
15568
15569 data.cpt_start = time (NULL);
15570
15571 data.cpt_total = 0;
15572
15573 if (data.restore == 0)
15574 {
15575 rd->words_cur = skip;
15576
15577 skip = 0;
15578
15579 data.skip = 0;
15580 }
15581
15582 data.ms_paused = 0;
15583
15584 data.words_cur = rd->words_cur;
15585
15586 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15587 {
15588 hc_device_param_t *device_param = &data.devices_param[device_id];
15589
15590 if (device_param->skipped) continue;
15591
15592 device_param->speed_pos = 0;
15593
15594 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15595 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15596 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15597
15598 device_param->kernel_power = device_param->kernel_power_user;
15599 device_param->kernel_blocks = device_param->kernel_blocks_user;
15600
15601 device_param->outerloop_pos = 0;
15602 device_param->outerloop_left = 0;
15603 device_param->innerloop_pos = 0;
15604 device_param->innerloop_left = 0;
15605
15606 // some more resets:
15607
15608 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15609
15610 memset (device_param->pws_buf, 0, device_param->size_pws);
15611
15612 device_param->pw_cnt = 0;
15613 device_param->pws_cnt = 0;
15614
15615 device_param->words_off = 0;
15616 device_param->words_done = 0;
15617 }
15618
15619 data.kernel_blocks_div = 0;
15620
15621 // figure out some workload
15622
15623 if (attack_mode == ATTACK_MODE_STRAIGHT)
15624 {
15625 if (data.wordlist_mode == WL_MODE_FILE)
15626 {
15627 char *dictfile = NULL;
15628
15629 if (induction_dictionaries_cnt)
15630 {
15631 dictfile = induction_dictionaries[0];
15632 }
15633 else
15634 {
15635 dictfile = dictfiles[dictpos];
15636 }
15637
15638 data.dictfile = dictfile;
15639
15640 logfile_sub_string (dictfile);
15641
15642 for (uint i = 0; i < rp_files_cnt; i++)
15643 {
15644 logfile_sub_var_string ("rulefile", rp_files[i]);
15645 }
15646
15647 FILE *fd2 = fopen (dictfile, "rb");
15648
15649 if (fd2 == NULL)
15650 {
15651 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15652
15653 return (-1);
15654 }
15655
15656 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15657
15658 fclose (fd2);
15659
15660 if (data.words_cnt == 0)
15661 {
15662 if (data.devices_status == STATUS_CRACKED) break;
15663 if (data.devices_status == STATUS_ABORTED) break;
15664
15665 dictpos++;
15666
15667 continue;
15668 }
15669 }
15670 }
15671 else if (attack_mode == ATTACK_MODE_COMBI)
15672 {
15673 char *dictfile = data.dictfile;
15674 char *dictfile2 = data.dictfile2;
15675
15676 logfile_sub_string (dictfile);
15677 logfile_sub_string (dictfile2);
15678
15679 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15680 {
15681 FILE *fd2 = fopen (dictfile, "rb");
15682
15683 if (fd2 == NULL)
15684 {
15685 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15686
15687 return (-1);
15688 }
15689
15690 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15691
15692 fclose (fd2);
15693 }
15694 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15695 {
15696 FILE *fd2 = fopen (dictfile2, "rb");
15697
15698 if (fd2 == NULL)
15699 {
15700 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15701
15702 return (-1);
15703 }
15704
15705 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15706
15707 fclose (fd2);
15708 }
15709
15710 if (data.words_cnt == 0)
15711 {
15712 if (data.devices_status == STATUS_CRACKED) break;
15713 if (data.devices_status == STATUS_ABORTED) break;
15714
15715 dictpos++;
15716
15717 continue;
15718 }
15719 }
15720 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15721 {
15722 char *dictfile = NULL;
15723
15724 if (induction_dictionaries_cnt)
15725 {
15726 dictfile = induction_dictionaries[0];
15727 }
15728 else
15729 {
15730 dictfile = dictfiles[dictpos];
15731 }
15732
15733 data.dictfile = dictfile;
15734
15735 char *mask = data.mask;
15736
15737 logfile_sub_string (dictfile);
15738 logfile_sub_string (mask);
15739
15740 FILE *fd2 = fopen (dictfile, "rb");
15741
15742 if (fd2 == NULL)
15743 {
15744 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15745
15746 return (-1);
15747 }
15748
15749 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15750
15751 fclose (fd2);
15752
15753 if (data.words_cnt == 0)
15754 {
15755 if (data.devices_status == STATUS_CRACKED) break;
15756 if (data.devices_status == STATUS_ABORTED) break;
15757
15758 dictpos++;
15759
15760 continue;
15761 }
15762 }
15763 else if (attack_mode == ATTACK_MODE_BF)
15764 {
15765 local_free (css_buf);
15766 local_free (data.root_css_buf);
15767 local_free (data.markov_css_buf);
15768
15769 char *mask = dictfiles[dictpos];
15770
15771 logfile_sub_string (mask);
15772
15773 // base
15774
15775 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15776
15777 if (opts_type & OPTS_TYPE_PT_UNICODE)
15778 {
15779 uint css_cnt_unicode = css_cnt * 2;
15780
15781 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15782
15783 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15784 {
15785 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15786
15787 css_buf_unicode[j + 1].cs_buf[0] = 0;
15788 css_buf_unicode[j + 1].cs_len = 1;
15789 }
15790
15791 free (css_buf);
15792
15793 css_buf = css_buf_unicode;
15794 css_cnt = css_cnt_unicode;
15795 }
15796
15797 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15798
15799 uint mask_min = pw_min;
15800 uint mask_max = pw_max;
15801
15802 if (opts_type & OPTS_TYPE_PT_UNICODE)
15803 {
15804 mask_min *= 2;
15805 mask_max *= 2;
15806 }
15807
15808 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15809 {
15810 if (css_cnt < mask_min)
15811 {
15812 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15813 }
15814
15815 if (css_cnt > mask_max)
15816 {
15817 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15818 }
15819
15820 // skip to next mask
15821
15822 dictpos++;
15823
15824 rd->dictpos = dictpos;
15825
15826 logfile_sub_msg ("STOP");
15827
15828 continue;
15829 }
15830
15831 uint save_css_cnt = css_cnt;
15832
15833 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15834 {
15835 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15836 {
15837 uint salt_len = (uint) data.salts_buf[0].salt_len;
15838 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15839
15840 uint css_cnt_salt = css_cnt + salt_len;
15841
15842 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15843
15844 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15845
15846 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15847 {
15848 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15849 css_buf_salt[j].cs_len = 1;
15850 }
15851
15852 free (css_buf);
15853
15854 css_buf = css_buf_salt;
15855 css_cnt = css_cnt_salt;
15856 }
15857 }
15858
15859 data.mask = mask;
15860 data.css_cnt = css_cnt;
15861 data.css_buf = css_buf;
15862
15863 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15864
15865 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15866
15867 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15868
15869 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15870 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15871
15872 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15873
15874 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15875
15876 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15877 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15878
15879 data.root_css_buf = root_css_buf;
15880 data.markov_css_buf = markov_css_buf;
15881
15882 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15883
15884 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15885
15886 local_free (root_table_buf);
15887 local_free (markov_table_buf);
15888
15889 // copy + args
15890
15891 uint css_cnt_l = css_cnt;
15892 uint css_cnt_r;
15893
15894 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15895 {
15896 if (save_css_cnt < 6)
15897 {
15898 css_cnt_r = 1;
15899 }
15900 else if (save_css_cnt == 6)
15901 {
15902 css_cnt_r = 2;
15903 }
15904 else
15905 {
15906 if (opts_type & OPTS_TYPE_PT_UNICODE)
15907 {
15908 if (save_css_cnt == 8 || save_css_cnt == 10)
15909 {
15910 css_cnt_r = 2;
15911 }
15912 else
15913 {
15914 css_cnt_r = 4;
15915 }
15916 }
15917 else
15918 {
15919 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15920 {
15921 css_cnt_r = 3;
15922 }
15923 else
15924 {
15925 css_cnt_r = 4;
15926 }
15927 }
15928 }
15929 }
15930 else
15931 {
15932 css_cnt_r = 1;
15933
15934 /* unfinished code?
15935 int sum = css_buf[css_cnt_r - 1].cs_len;
15936
15937 for (uint i = 1; i < 4 && i < css_cnt; i++)
15938 {
15939 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15940
15941 css_cnt_r++;
15942
15943 sum *= css_buf[css_cnt_r - 1].cs_len;
15944 }
15945 */
15946 }
15947
15948 css_cnt_l -= css_cnt_r;
15949
15950 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15951
15952 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15953 {
15954 hc_device_param_t *device_param = &data.devices_param[device_id];
15955
15956 if (device_param->skipped) continue;
15957
15958 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15959 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15960 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15961
15962 device_param->kernel_params_mp_l_buf64[3] = 0;
15963 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15964 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15965 device_param->kernel_params_mp_l_buf32[6] = 0;
15966 device_param->kernel_params_mp_l_buf32[7] = 0;
15967 device_param->kernel_params_mp_l_buf32[8] = 0;
15968
15969 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15970 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15971 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15972 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15973
15974 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15975 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15976 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15977
15978 device_param->kernel_params_mp_r_buf64[3] = 0;
15979 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15980 device_param->kernel_params_mp_r_buf32[5] = 0;
15981 device_param->kernel_params_mp_r_buf32[6] = 0;
15982 device_param->kernel_params_mp_r_buf32[7] = 0;
15983
15984 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]);
15985 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]);
15986 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]);
15987
15988 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]);
15989 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]);
15990 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]);
15991
15992 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);
15993 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);
15994 }
15995 }
15996
15997 u64 words_base = data.words_cnt;
15998
15999 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16000 {
16001 if (data.kernel_rules_cnt)
16002 {
16003 words_base /= data.kernel_rules_cnt;
16004 }
16005 }
16006 else if (data.attack_kern == ATTACK_KERN_COMBI)
16007 {
16008 if (data.combs_cnt)
16009 {
16010 words_base /= data.combs_cnt;
16011 }
16012 }
16013 else if (data.attack_kern == ATTACK_KERN_BF)
16014 {
16015 if (data.bfs_cnt)
16016 {
16017 words_base /= data.bfs_cnt;
16018 }
16019 }
16020
16021 data.words_base = words_base;
16022
16023 if (keyspace == 1)
16024 {
16025 log_info ("%llu", (unsigned long long int) words_base);
16026
16027 return (0);
16028 }
16029
16030 if (data.words_cur > data.words_base)
16031 {
16032 log_error ("ERROR: restore value greater keyspace");
16033
16034 return (-1);
16035 }
16036
16037 if (data.words_cur)
16038 {
16039 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
16040 {
16041 for (uint i = 0; i < data.salts_cnt; i++)
16042 {
16043 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
16044 }
16045 }
16046 else if (data.attack_kern == ATTACK_KERN_COMBI)
16047 {
16048 for (uint i = 0; i < data.salts_cnt; i++)
16049 {
16050 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
16051 }
16052 }
16053 else if (data.attack_kern == ATTACK_KERN_BF)
16054 {
16055 for (uint i = 0; i < data.salts_cnt; i++)
16056 {
16057 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
16058 }
16059 }
16060 }
16061
16062 /*
16063 * Inform user about possible slow speeds
16064 */
16065
16066 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16067 {
16068 if (data.words_base < kernel_blocks_all)
16069 {
16070 if (quiet == 0)
16071 {
16072 log_info ("");
16073 log_info ("ATTENTION!");
16074 log_info (" The wordlist or mask you are using is too small.");
16075 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
16076 log_info (" The cracking speed will drop.");
16077 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
16078 log_info ("");
16079 }
16080 }
16081 }
16082
16083 /*
16084 * Update loopback file
16085 */
16086
16087 if (loopback == 1)
16088 {
16089 time_t now;
16090
16091 time (&now);
16092
16093 uint random_num = get_random_num (0, 9999);
16094
16095 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
16096
16097 data.loopback_file = loopback_file;
16098 }
16099
16100 /*
16101 * Update dictionary statistic
16102 */
16103
16104 if (keyspace == 0)
16105 {
16106 dictstat_fp = fopen (dictstat, "wb");
16107
16108 if (dictstat_fp)
16109 {
16110 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16111
16112 fclose (dictstat_fp);
16113 }
16114 }
16115
16116 data.devices_status = STATUS_RUNNING;
16117
16118 if (initial_restore_done == 0)
16119 {
16120 if (data.restore_disable == 0) cycle_restore ();
16121
16122 initial_restore_done = 1;
16123 }
16124
16125 hc_timer_set (&data.timer_running);
16126
16127 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16128 {
16129 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16130 {
16131 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16132 if (quiet == 0) fflush (stdout);
16133 }
16134 }
16135 else if (wordlist_mode == WL_MODE_STDIN)
16136 {
16137 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16138 if (data.quiet == 0) log_info ("");
16139 }
16140
16141 time_t runtime_start;
16142
16143 time (&runtime_start);
16144
16145 data.runtime_start = runtime_start;
16146
16147 /**
16148 * create cracker threads
16149 */
16150
16151 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16152
16153 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16154 {
16155 hc_device_param_t *device_param = &devices_param[device_id];
16156
16157 if (wordlist_mode == WL_MODE_STDIN)
16158 {
16159 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16160 }
16161 else
16162 {
16163 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16164 }
16165 }
16166
16167 // wait for crack threads to exit
16168
16169 hc_thread_wait (devices_cnt, c_threads);
16170
16171 local_free (c_threads);
16172
16173 data.restore = 0;
16174
16175 // finalize task
16176
16177 logfile_sub_var_uint ("status-after-work", data.devices_status);
16178
16179 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16180
16181 if (data.devices_status == STATUS_CRACKED) break;
16182 if (data.devices_status == STATUS_ABORTED) break;
16183
16184 if (data.devices_status == STATUS_BYPASS)
16185 {
16186 data.devices_status = STATUS_RUNNING;
16187 }
16188
16189 if (induction_dictionaries_cnt)
16190 {
16191 unlink (induction_dictionaries[0]);
16192 }
16193
16194 free (induction_dictionaries);
16195
16196 if (attack_mode != ATTACK_MODE_BF)
16197 {
16198 induction_dictionaries = scan_directory (induction_directory);
16199
16200 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16201 }
16202
16203 if (benchmark == 0)
16204 {
16205 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16206 {
16207 if (quiet == 0) clear_prompt ();
16208
16209 if (quiet == 0) log_info ("");
16210
16211 if (status == 1)
16212 {
16213 status_display ();
16214 }
16215 else
16216 {
16217 if (quiet == 0) status_display ();
16218 }
16219
16220 if (quiet == 0) log_info ("");
16221 }
16222 }
16223
16224 if (attack_mode == ATTACK_MODE_BF)
16225 {
16226 dictpos++;
16227
16228 rd->dictpos = dictpos;
16229 }
16230 else
16231 {
16232 if (induction_dictionaries_cnt)
16233 {
16234 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16235 }
16236 else
16237 {
16238 dictpos++;
16239
16240 rd->dictpos = dictpos;
16241 }
16242 }
16243
16244 time_t runtime_stop;
16245
16246 time (&runtime_stop);
16247
16248 data.runtime_stop = runtime_stop;
16249
16250 logfile_sub_uint (runtime_start);
16251 logfile_sub_uint (runtime_stop);
16252
16253 logfile_sub_msg ("STOP");
16254
16255 global_free (subid);
16256 }
16257
16258 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16259
16260 if (data.devices_status == STATUS_CRACKED) break;
16261 if (data.devices_status == STATUS_ABORTED) break;
16262 if (data.devices_status == STATUS_QUIT) break;
16263
16264 if (data.devices_status == STATUS_BYPASS)
16265 {
16266 data.devices_status = STATUS_RUNNING;
16267 }
16268 }
16269
16270 // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers
16271
16272 if (attack_mode == ATTACK_MODE_STRAIGHT)
16273 {
16274 if (data.wordlist_mode == WL_MODE_FILE)
16275 {
16276 if (data.dictfile == NULL)
16277 {
16278 if (dictfiles != NULL)
16279 {
16280 data.dictfile = dictfiles[0];
16281
16282 hc_timer_set (&data.timer_running);
16283 }
16284 }
16285 }
16286 }
16287 // NOTE: combi is okay because it is already set beforehand
16288 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16289 {
16290 if (data.dictfile == NULL)
16291 {
16292 if (dictfiles != NULL)
16293 {
16294 hc_timer_set (&data.timer_running);
16295
16296 data.dictfile = dictfiles[0];
16297 }
16298 }
16299 }
16300 else if (attack_mode == ATTACK_MODE_BF)
16301 {
16302 if (data.mask == NULL)
16303 {
16304 hc_timer_set (&data.timer_running);
16305
16306 data.mask = masks[0];
16307 }
16308 }
16309
16310 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16311 {
16312 data.devices_status = STATUS_EXHAUSTED;
16313 }
16314
16315 // if cracked / aborted remove last induction dictionary
16316
16317 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16318 {
16319 struct stat induct_stat;
16320
16321 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16322 {
16323 unlink (induction_dictionaries[file_pos]);
16324 }
16325 }
16326
16327 // wait for non-interactive threads
16328
16329 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16330 {
16331 hc_thread_wait (1, &ni_threads[thread_idx]);
16332 }
16333
16334 local_free (ni_threads);
16335
16336 // wait for interactive threads
16337
16338 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16339 {
16340 hc_thread_wait (1, &i_thread);
16341 }
16342
16343 // we dont need restore file anymore
16344 if (data.restore_disable == 0)
16345 {
16346 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16347 {
16348 unlink (eff_restore_file);
16349 unlink (new_restore_file);
16350 }
16351 else
16352 {
16353 cycle_restore ();
16354 }
16355 }
16356
16357 // finally save left hashes
16358
16359 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16360 {
16361 save_hash ();
16362 }
16363
16364 /**
16365 * Clean up
16366 */
16367
16368 if (benchmark == 1)
16369 {
16370 status_benchmark ();
16371
16372 log_info ("");
16373 }
16374 else
16375 {
16376 if (quiet == 0) clear_prompt ();
16377
16378 if (quiet == 0) log_info ("");
16379
16380 if (status == 1)
16381 {
16382 status_display ();
16383 }
16384 else
16385 {
16386 if (quiet == 0) status_display ();
16387 }
16388
16389 if (quiet == 0) log_info ("");
16390 }
16391
16392 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16393 {
16394 hc_device_param_t *device_param = &data.devices_param[device_id];
16395
16396 if (device_param->skipped) continue;
16397
16398 local_free (device_param->result);
16399
16400 local_free (device_param->pw_caches);
16401
16402 local_free (device_param->combs_buf);
16403
16404 local_free (device_param->hooks_buf);
16405
16406 local_free (device_param->device_name);
16407
16408 local_free (device_param->device_name_chksum);
16409
16410 local_free (device_param->device_version);
16411
16412 local_free (device_param->driver_version);
16413
16414 if (device_param->pws_buf) myfree (device_param->pws_buf);
16415 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16416 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16417 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16418 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16419 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16420 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16421 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16422 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16423 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16424 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16425 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16426 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16427 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16428 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16429 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16430 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16431 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16432 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16433 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16434 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16435 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16436 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16437 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16438 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16439 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16440 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16441 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16442 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16443
16444 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16445 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16446 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16447 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16448 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16449 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16450 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16451 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16452 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16453 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16454 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16455
16456 if (device_param->program) hc_clReleaseProgram (device_param->program);
16457 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16458 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16459
16460 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16461 if (device_param->context) hc_clReleaseContext (device_param->context);
16462 }
16463
16464 // reset default fan speed
16465
16466 #ifdef HAVE_HWMON
16467 if (gpu_temp_disable == 0)
16468 {
16469 #ifdef HAVE_ADL
16470 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16471 {
16472 hc_thread_mutex_lock (mux_adl);
16473
16474 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16475 {
16476 hc_device_param_t *device_param = &data.devices_param[device_id];
16477
16478 if (device_param->skipped) continue;
16479
16480 if (data.hm_device[device_id].fan_supported == 1)
16481 {
16482 int fanspeed = temp_retain_fanspeed_value[device_id];
16483
16484 if (fanspeed == -1) continue;
16485
16486 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16487
16488 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16489 }
16490 }
16491
16492 hc_thread_mutex_unlock (mux_adl);
16493 }
16494 #endif // HAVE_ADL
16495 }
16496
16497 // reset power tuning
16498
16499 #ifdef HAVE_ADL
16500 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16501 {
16502 hc_thread_mutex_lock (mux_adl);
16503
16504 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16505 {
16506 hc_device_param_t *device_param = &data.devices_param[device_id];
16507
16508 if (device_param->skipped) continue;
16509
16510 if (data.hm_device[device_id].od_version == 6)
16511 {
16512 // check powertune capabilities first, if not available then skip device
16513
16514 int powertune_supported = 0;
16515
16516 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16517 {
16518 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16519
16520 return (-1);
16521 }
16522
16523 if (powertune_supported != 0)
16524 {
16525 // powercontrol settings
16526
16527 if ((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)
16528 {
16529 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16530
16531 return (-1);
16532 }
16533
16534 // clocks
16535
16536 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16537
16538 performance_state->iNumberOfPerformanceLevels = 2;
16539
16540 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16541 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16542 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16543 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16544
16545 if ((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)
16546 {
16547 log_info ("ERROR: Failed to restore ADL performance state");
16548
16549 return (-1);
16550 }
16551
16552 local_free (performance_state);
16553 }
16554 }
16555 }
16556
16557 hc_thread_mutex_unlock (mux_adl);
16558 }
16559 #endif // HAVE_ADL
16560
16561 if (gpu_temp_disable == 0)
16562 {
16563 #if defined(LINUX) && defined(HAVE_NVML)
16564 if (data.hm_dll_nv)
16565 {
16566 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16567
16568 hm_close (data.hm_dll_nv);
16569 }
16570 #endif
16571
16572 #if defined(WIN) && (HAVE_NVAPI)
16573 NvAPI_Unload ();
16574 #endif
16575
16576 #ifdef HAVE_ADL
16577 if (data.hm_dll_amd)
16578 {
16579 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16580
16581 hm_close (data.hm_dll_amd);
16582 }
16583 #endif
16584 }
16585 #endif // HAVE_HWMON
16586
16587 // free memory
16588
16589 local_free (masks);
16590
16591 local_free (dictstat_base);
16592
16593 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16594 {
16595 pot_t *pot_ptr = &pot[pot_pos];
16596
16597 hash_t *hash = &pot_ptr->hash;
16598
16599 local_free (hash->digest);
16600
16601 if (isSalted)
16602 {
16603 local_free (hash->salt);
16604 }
16605 }
16606
16607 local_free (pot);
16608
16609 local_free (all_kernel_rules_cnt);
16610 local_free (all_kernel_rules_buf);
16611
16612 local_free (wl_data->buf);
16613 local_free (wl_data);
16614
16615 local_free (bitmap_s1_a);
16616 local_free (bitmap_s1_b);
16617 local_free (bitmap_s1_c);
16618 local_free (bitmap_s1_d);
16619 local_free (bitmap_s2_a);
16620 local_free (bitmap_s2_b);
16621 local_free (bitmap_s2_c);
16622 local_free (bitmap_s2_d);
16623
16624 #ifdef HAVE_HWMON
16625 local_free (temp_retain_fanspeed_value);
16626 #ifdef HAVE_ADL
16627 local_free (od_clock_mem_status);
16628 local_free (od_power_control_status);
16629 #endif // ADL
16630 #endif
16631
16632 global_free (devices_param);
16633
16634 global_free (kernel_rules_buf);
16635
16636 global_free (root_css_buf);
16637 global_free (markov_css_buf);
16638
16639 global_free (digests_buf);
16640 global_free (digests_shown);
16641 global_free (digests_shown_tmp);
16642
16643 global_free (salts_buf);
16644 global_free (salts_shown);
16645
16646 global_free (esalts_buf);
16647
16648 global_free (words_progress_done);
16649 global_free (words_progress_rejected);
16650 global_free (words_progress_restored);
16651
16652 if (pot_fp) fclose (pot_fp);
16653
16654 if (data.devices_status == STATUS_QUIT) break;
16655 }
16656
16657 // destroy others mutex
16658
16659 hc_thread_mutex_delete (mux_dispatcher);
16660 hc_thread_mutex_delete (mux_counter);
16661 hc_thread_mutex_delete (mux_display);
16662 hc_thread_mutex_delete (mux_adl);
16663
16664 // free memory
16665
16666 local_free (eff_restore_file);
16667 local_free (new_restore_file);
16668
16669 local_free (rd);
16670
16671 // loopback
16672
16673 local_free (loopback_file);
16674
16675 if (loopback == 1) unlink (loopback_file);
16676
16677 // induction directory
16678
16679 if (induction_dir == NULL)
16680 {
16681 if (attack_mode != ATTACK_MODE_BF)
16682 {
16683 if (rmdir (induction_directory) == -1)
16684 {
16685 if (errno == ENOENT)
16686 {
16687 // good, we can ignore
16688 }
16689 else if (errno == ENOTEMPTY)
16690 {
16691 // good, we can ignore
16692 }
16693 else
16694 {
16695 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16696
16697 return (-1);
16698 }
16699 }
16700
16701 local_free (induction_directory);
16702 }
16703 }
16704
16705 // outfile-check directory
16706
16707 if (outfile_check_dir == NULL)
16708 {
16709 if (rmdir (outfile_check_directory) == -1)
16710 {
16711 if (errno == ENOENT)
16712 {
16713 // good, we can ignore
16714 }
16715 else if (errno == ENOTEMPTY)
16716 {
16717 // good, we can ignore
16718 }
16719 else
16720 {
16721 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16722
16723 return (-1);
16724 }
16725 }
16726
16727 local_free (outfile_check_directory);
16728 }
16729
16730 time_t proc_stop;
16731
16732 time (&proc_stop);
16733
16734 logfile_top_uint (proc_start);
16735 logfile_top_uint (proc_stop);
16736
16737 logfile_top_msg ("STOP");
16738
16739 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16740 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16741
16742 if (data.devices_status == STATUS_ABORTED) return 2;
16743 if (data.devices_status == STATUS_QUIT) return 2;
16744 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16745 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16746 if (data.devices_status == STATUS_CRACKED) return 0;
16747
16748 return -1;
16749 }
Hashcat additions to support pwdhash