projects / hashcat.git / blob
? search:


d225ddc7c82e9b2d2e06210066e1d678edead028
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
389 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
390 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* OpenCL device-types:",
445 "",
446 " 1 = CPU devices",
447 " 2 = GPU devices",
448 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
449 "",
450 "* Outfile Formats:",
451 "",
452 " 1 = hash[:salt]",
453 " 2 = plain",
454 " 3 = hash[:salt]:plain",
455 " 4 = hex_plain",
456 " 5 = hash[:salt]:hex_plain",
457 " 6 = plain:hex_plain",
458 " 7 = hash[:salt]:plain:hex_plain",
459 " 8 = crackpos",
460 " 9 = hash[:salt]:crackpos",
461 " 10 = plain:crackpos",
462 " 11 = hash[:salt]:plain:crackpos",
463 " 12 = hex_plain:crackpos",
464 " 13 = hash[:salt]:hex_plain:crackpos",
465 " 14 = plain:hex_plain:crackpos",
466 " 15 = hash[:salt]:plain:hex_plain:crackpos",
467 "",
468 "* Debug mode output formats (for hybrid mode only, by using rules):",
469 "",
470 " 1 = save finding rule",
471 " 2 = save original word",
472 " 3 = save original word and finding rule",
473 " 4 = save original word, finding rule and modified plain",
474 "",
475 "* Built-in charsets:",
476 "",
477 " ?l = abcdefghijklmnopqrstuvwxyz",
478 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
479 " ?d = 0123456789",
480 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
481 " ?a = ?l?u?d?s",
482 " ?b = 0x00 - 0xff",
483 "",
484 "* Attack modes:",
485 "",
486 " 0 = Straight",
487 " 1 = Combination",
488 " 3 = Brute-force",
489 " 6 = Hybrid dict + mask",
490 " 7 = Hybrid mask + dict",
491 "",
492 "* Hash types:",
493 "",
494 "[[ Roll-your-own: Raw Hashes ]]",
495 "",
496 " 900 = MD4",
497 " 0 = MD5",
498 " 5100 = Half MD5",
499 " 100 = SHA1",
500 " 10800 = SHA-384",
501 " 1400 = SHA-256",
502 " 1700 = SHA-512",
503 " 5000 = SHA-3(Keccak)",
504 " 10100 = SipHash",
505 " 6000 = RipeMD160",
506 " 6100 = Whirlpool",
507 " 6900 = GOST R 34.11-94",
508 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
509 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
510 "",
511 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
512 "",
513 " 10 = md5($pass.$salt)",
514 " 20 = md5($salt.$pass)",
515 " 30 = md5(unicode($pass).$salt)",
516 " 40 = md5($salt.unicode($pass))",
517 " 3800 = md5($salt.$pass.$salt)",
518 " 3710 = md5($salt.md5($pass))",
519 " 2600 = md5(md5($pass)",
520 " 4300 = md5(strtoupper(md5($pass)))",
521 " 4400 = md5(sha1($pass))",
522 " 110 = sha1($pass.$salt)",
523 " 120 = sha1($salt.$pass)",
524 " 130 = sha1(unicode($pass).$salt)",
525 " 140 = sha1($salt.unicode($pass))",
526 " 4500 = sha1(sha1($pass)",
527 " 4700 = sha1(md5($pass))",
528 " 4900 = sha1($salt.$pass.$salt)",
529 " 1410 = sha256($pass.$salt)",
530 " 1420 = sha256($salt.$pass)",
531 " 1430 = sha256(unicode($pass).$salt)",
532 " 1440 = sha256($salt.unicode($pass))",
533 " 1710 = sha512($pass.$salt)",
534 " 1720 = sha512($salt.$pass)",
535 " 1730 = sha512(unicode($pass).$salt)",
536 " 1740 = sha512($salt.unicode($pass))",
537 "",
538 "[[ Roll-your-own: Authenticated Hashes ]]",
539 "",
540 " 50 = HMAC-MD5 (key = $pass)",
541 " 60 = HMAC-MD5 (key = $salt)",
542 " 150 = HMAC-SHA1 (key = $pass)",
543 " 160 = HMAC-SHA1 (key = $salt)",
544 " 1450 = HMAC-SHA256 (key = $pass)",
545 " 1460 = HMAC-SHA256 (key = $salt)",
546 " 1750 = HMAC-SHA512 (key = $pass)",
547 " 1760 = HMAC-SHA512 (key = $salt)",
548 "",
549 "[[ Generic KDF ]]",
550 "",
551 " 400 = phpass",
552 " 8900 = scrypt",
553 " 11900 = PBKDF2-HMAC-MD5",
554 " 12000 = PBKDF2-HMAC-SHA1",
555 " 10900 = PBKDF2-HMAC-SHA256",
556 " 12100 = PBKDF2-HMAC-SHA512",
557 "",
558 "[[ Network protocols, Challenge-Response ]]",
559 "",
560 " 23 = Skype",
561 " 2500 = WPA/WPA2",
562 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
563 " 5300 = IKE-PSK MD5",
564 " 5400 = IKE-PSK SHA1",
565 " 5500 = NetNTLMv1",
566 " 5500 = NetNTLMv1 + ESS",
567 " 5600 = NetNTLMv2",
568 " 7300 = IPMI2 RAKP HMAC-SHA1",
569 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
570 " 8300 = DNSSEC (NSEC3)",
571 " 10200 = Cram MD5",
572 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
573 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
574 " 11400 = SIP digest authentication (MD5)",
575 "",
576 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
577 "",
578 " 121 = SMF (Simple Machines Forum)",
579 " 400 = phpBB3",
580 " 2611 = vBulletin < v3.8.5",
581 " 2711 = vBulletin > v3.8.5",
582 " 2811 = MyBB",
583 " 2811 = IPB (Invison Power Board)",
584 " 8400 = WBB3 (Woltlab Burning Board)",
585 " 11 = Joomla < 2.5.18",
586 " 400 = Joomla > 2.5.18",
587 " 400 = Wordpress",
588 " 2612 = PHPS",
589 " 7900 = Drupal7",
590 " 21 = osCommerce",
591 " 21 = xt:Commerce",
592 " 11000 = PrestaShop",
593 " 124 = Django (SHA-1)",
594 " 10000 = Django (PBKDF2-SHA256)",
595 " 3711 = Mediawiki B type",
596 " 7600 = Redmine",
597 "",
598 "[[ Database Server ]]",
599 "",
600 " 12 = PostgreSQL",
601 " 131 = MSSQL(2000)",
602 " 132 = MSSQL(2005)",
603 " 1731 = MSSQL(2012)",
604 " 1731 = MSSQL(2014)",
605 " 200 = MySQL323",
606 " 300 = MySQL4.1/MySQL5",
607 " 3100 = Oracle H: Type (Oracle 7+)",
608 " 112 = Oracle S: Type (Oracle 11+)",
609 " 12300 = Oracle T: Type (Oracle 12+)",
610 " 8000 = Sybase ASE",
611 "",
612 "[[ HTTP, SMTP, LDAP Server ]]",
613 "",
614 " 141 = EPiServer 6.x < v4",
615 " 1441 = EPiServer 6.x > v4",
616 " 1600 = Apache $apr1$",
617 " 12600 = ColdFusion 10+",
618 " 1421 = hMailServer",
619 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
620 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
621 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
622 "",
623 "[[ Checksums ]]",
624 "",
625 " 11500 = CRC32",
626 "",
627 "[[ Operating-Systems ]]",
628 "",
629 " 3000 = LM",
630 " 1000 = NTLM",
631 " 1100 = Domain Cached Credentials (DCC), MS Cache",
632 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
633 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
634 " 1500 = descrypt, DES(Unix), Traditional DES",
635 " 12400 = BSDiCrypt, Extended DES",
636 " 500 = md5crypt $1$, MD5(Unix)",
637 " 3200 = bcrypt $2*$, Blowfish(Unix)",
638 " 7400 = sha256crypt $5$, SHA256(Unix)",
639 " 1800 = sha512crypt $6$, SHA512(Unix)",
640 " 122 = OSX v10.4",
641 " 122 = OSX v10.5",
642 " 122 = OSX v10.6",
643 " 1722 = OSX v10.7",
644 " 7100 = OSX v10.8",
645 " 7100 = OSX v10.9",
646 " 7100 = OSX v10.10",
647 " 6300 = AIX {smd5}",
648 " 6700 = AIX {ssha1}",
649 " 6400 = AIX {ssha256}",
650 " 6500 = AIX {ssha512}",
651 " 2400 = Cisco-PIX",
652 " 2410 = Cisco-ASA",
653 " 500 = Cisco-IOS $1$",
654 " 5700 = Cisco-IOS $4$",
655 " 9200 = Cisco-IOS $8$",
656 " 9300 = Cisco-IOS $9$",
657 " 22 = Juniper Netscreen/SSG (ScreenOS)",
658 " 501 = Juniper IVE",
659 " 5800 = Android PIN",
660 " 8100 = Citrix Netscaler",
661 " 8500 = RACF",
662 " 7200 = GRUB 2",
663 " 9900 = Radmin2",
664 "",
665 "[[ Enterprise Application Software (EAS) ]]",
666 "",
667 " 7700 = SAP CODVN B (BCODE)",
668 " 7800 = SAP CODVN F/G (PASSCODE)",
669 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
670 " 8600 = Lotus Notes/Domino 5",
671 " 8700 = Lotus Notes/Domino 6",
672 " 9100 = Lotus Notes/Domino 8",
673 " 133 = PeopleSoft",
674 "",
675 "[[ Archives ]]",
676 "",
677 " 11600 = 7-Zip",
678 " 12500 = RAR3-hp",
679 " 13000 = RAR5",
680 "",
681 "[[ Full-Disk encryptions (FDE) ]]",
682 "",
683 " 62XY = TrueCrypt 5.0+",
684 " X = 1 = PBKDF2-HMAC-RipeMD160",
685 " X = 2 = PBKDF2-HMAC-SHA512",
686 " X = 3 = PBKDF2-HMAC-Whirlpool",
687 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
688 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
689 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
690 " Y = 3 = XTS 1536 bit (Ciphers: All)",
691 " 8800 = Android FDE < v4.3",
692 " 12900 = Android FDE (Samsung DEK)",
693 " 12200 = eCryptfs",
694 "",
695 "[[ Documents ]]",
696 "",
697 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
698 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
699 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
700 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
701 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
702 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
703 " 9400 = MS Office 2007",
704 " 9500 = MS Office 2010",
705 " 9600 = MS Office 2013",
706 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
707 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
708 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
709 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
710 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
711 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
712 "",
713 "[[ Password Managers ]]",
714 "",
715 " 9000 = Password Safe v2",
716 " 5200 = Password Safe v3",
717 " 6800 = Lastpass",
718 " 6600 = 1Password, agilekeychain",
719 " 8200 = 1Password, cloudkeychain",
720 " 11300 = Bitcoin/Litecoin wallet.dat",
721 " 12700 = Blockchain, My Wallet",
722 "",
723 NULL
724 };
725
726 /**
727 * oclHashcat specific functions
728 */
729
730 void status_display_automat ()
731 {
732 FILE *out = stdout;
733
734 fprintf (out, "STATUS\t%u\t", data.devices_status);
735
736 /**
737 * speed new
738 */
739
740 fprintf (out, "SPEED\t");
741
742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
743 {
744 hc_device_param_t *device_param = &data.devices_param[device_id];
745
746 if (device_param->skipped) continue;
747
748 u64 speed_cnt = 0;
749 float speed_ms = 0;
750
751 for (int i = 0; i < SPEED_CACHE; i++)
752 {
753 float rec_ms;
754
755 hc_timer_get (device_param->speed_rec[i], rec_ms);
756
757 if (rec_ms > SPEED_MAXAGE) continue;
758
759 speed_cnt += device_param->speed_cnt[i];
760 speed_ms += device_param->speed_ms[i];
761 }
762
763 speed_cnt /= SPEED_CACHE;
764 speed_ms /= SPEED_CACHE;
765
766 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
767 }
768
769 /**
770 * words_cur
771 */
772
773 u64 words_cur = get_lowest_words_done ();
774
775 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
776
777 /**
778 * counter
779 */
780
781 uint salts_left = data.salts_cnt - data.salts_done;
782
783 if (salts_left == 0) salts_left = 1;
784
785 u64 progress_total = data.words_cnt * salts_left;
786
787 u64 all_done = 0;
788 u64 all_rejected = 0;
789 u64 all_restored = 0;
790
791 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
792 {
793 if (salts_left > 1)
794 {
795 // otherwise the final cracked status shows 0/XXX progress
796
797 if (data.salts_shown[salt_pos] == 1) continue;
798 }
799
800 all_done += data.words_progress_done[salt_pos];
801 all_rejected += data.words_progress_rejected[salt_pos];
802 all_restored += data.words_progress_restored[salt_pos];
803 }
804
805 u64 progress_cur = all_restored + all_done + all_rejected;
806 u64 progress_end = progress_total;
807
808 u64 progress_skip = 0;
809
810 if (data.skip)
811 {
812 progress_skip = MIN (data.skip, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
817 }
818
819 if (data.limit)
820 {
821 progress_end = MIN (data.limit, data.words_base) * salts_left;
822
823 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
824 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
825 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
826 }
827
828 u64 progress_cur_relative_skip = progress_cur - progress_skip;
829 u64 progress_end_relative_skip = progress_end - progress_skip;
830
831 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
832
833 /**
834 * cracks
835 */
836
837 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
838 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
839
840 /**
841 * temperature
842 */
843
844 if (data.gpu_temp_disable == 0)
845 {
846 fprintf (out, "TEMP\t");
847
848 hc_thread_mutex_lock (mux_adl);
849
850 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
851 {
852 hc_device_param_t *device_param = &data.devices_param[device_id];
853
854 if (device_param->skipped) continue;
855
856 int temp = hm_get_temperature_with_device_id (device_id);
857
858 fprintf (out, "%d\t", temp);
859 }
860
861 hc_thread_mutex_unlock (mux_adl);
862 }
863
864 #ifdef _WIN
865 fputc ('\r', out);
866 fputc ('\n', out);
867 #endif
868
869 #ifdef _POSIX
870 fputc ('\n', out);
871 #endif
872
873 fflush (out);
874 }
875
876 void status_display ()
877 {
878 if (data.devices_status == STATUS_INIT) return;
879 if (data.devices_status == STATUS_STARTING) return;
880 if (data.devices_status == STATUS_BYPASS) return;
881
882 if (data.status_automat == 1)
883 {
884 status_display_automat ();
885
886 return;
887 }
888
889 char tmp_buf[1000];
890
891 uint tmp_len = 0;
892
893 log_info ("Session.Name...: %s", data.session);
894
895 char *status_type = strstatus (data.devices_status);
896
897 uint hash_mode = data.hash_mode;
898
899 char *hash_type = strhashtype (hash_mode); // not a bug
900
901 log_info ("Status.........: %s", status_type);
902
903 /**
904 * show rules
905 */
906
907 if (data.rp_files_cnt)
908 {
909 uint i;
910
911 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
912 {
913 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
914 }
915
916 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
917
918 log_info ("Rules.Type.....: %s", tmp_buf);
919
920 tmp_len = 0;
921 }
922
923 if (data.rp_gen)
924 {
925 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
926
927 if (data.rp_gen_seed)
928 {
929 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
930 }
931 }
932
933 /**
934 * show input
935 */
936
937 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
938 {
939 if (data.wordlist_mode == WL_MODE_FILE)
940 {
941 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
942 }
943 else if (data.wordlist_mode == WL_MODE_STDIN)
944 {
945 log_info ("Input.Mode.....: Pipe");
946 }
947 }
948 else if (data.attack_mode == ATTACK_MODE_COMBI)
949 {
950 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
951 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
952 }
953 else if (data.attack_mode == ATTACK_MODE_BF)
954 {
955 char *mask = data.mask;
956
957 if (mask != NULL)
958 {
959 uint mask_len = data.css_cnt;
960
961 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
962
963 if (mask_len > 0)
964 {
965 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
966 {
967 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
968 {
969 mask_len -= data.salts_buf[0].salt_len;
970 }
971 }
972
973 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
974
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
976 }
977
978 if (data.maskcnt > 1)
979 {
980 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
981
982 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
983 }
984
985 log_info ("Input.Mode.....: %s", tmp_buf);
986 }
987
988 tmp_len = 0;
989 }
990 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
994 }
995 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
996 {
997 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
998 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
999 }
1000
1001 if (data.digests_cnt == 1)
1002 {
1003 if (data.hash_mode == 2500)
1004 {
1005 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1006
1007 uint pke[25];
1008
1009 char *pke_ptr = (char *) pke;
1010
1011 for (uint i = 0; i < 25; i++)
1012 {
1013 pke[i] = byte_swap_32 (wpa->pke[i]);
1014 }
1015
1016 char mac1[6];
1017 char mac2[6];
1018
1019 memcpy (mac1, pke_ptr + 23, 6);
1020 memcpy (mac2, pke_ptr + 29, 6);
1021
1022 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1023 (char *) data.salts_buf[0].salt_buf,
1024 mac1[0] & 0xff,
1025 mac1[1] & 0xff,
1026 mac1[2] & 0xff,
1027 mac1[3] & 0xff,
1028 mac1[4] & 0xff,
1029 mac1[5] & 0xff,
1030 mac2[0] & 0xff,
1031 mac2[1] & 0xff,
1032 mac2[2] & 0xff,
1033 mac2[3] & 0xff,
1034 mac2[4] & 0xff,
1035 mac2[5] & 0xff);
1036 }
1037 else if (data.hash_mode == 5200)
1038 {
1039 log_info ("Hash.Target....: File (%s)", data.hashfile);
1040 }
1041 else if (data.hash_mode == 9000)
1042 {
1043 log_info ("Hash.Target....: File (%s)", data.hashfile);
1044 }
1045 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1046 {
1047 log_info ("Hash.Target....: File (%s)", data.hashfile);
1048 }
1049 else
1050 {
1051 char out_buf[4096];
1052
1053 ascii_digest (out_buf, 0, 0);
1054
1055 // limit length
1056 if (strlen (out_buf) > 40)
1057 {
1058 out_buf[41] = '.';
1059 out_buf[42] = '.';
1060 out_buf[43] = '.';
1061 out_buf[44] = 0;
1062 }
1063
1064 log_info ("Hash.Target....: %s", out_buf);
1065 }
1066 }
1067 else
1068 {
1069 if (data.hash_mode == 3000)
1070 {
1071 char out_buf1[4096];
1072 char out_buf2[4096];
1073
1074 ascii_digest (out_buf1, 0, 0);
1075 ascii_digest (out_buf2, 0, 1);
1076
1077 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1078 }
1079 else
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 }
1084
1085 log_info ("Hash.Type......: %s", hash_type);
1086
1087 /**
1088 * speed new
1089 */
1090
1091 u64 speed_cnt[DEVICES_MAX];
1092 float speed_ms[DEVICES_MAX];
1093
1094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1095 {
1096 hc_device_param_t *device_param = &data.devices_param[device_id];
1097
1098 if (device_param->skipped) continue;
1099
1100 // we need to clear values (set to 0) because in case the device does
1101 // not get new candidates it idles around but speed display would
1102 // show it as working.
1103 // if we instantly set it to 0 after reading it happens that the
1104 // speed can be shown as zero if the users refreshs to fast.
1105 // therefore, we add a timestamp when a stat was recorded and if its
1106 // to old we will not use it
1107
1108 speed_cnt[device_id] = 0;
1109 speed_ms[device_id] = 0;
1110
1111 for (int i = 0; i < SPEED_CACHE; i++)
1112 {
1113 float rec_ms;
1114
1115 hc_timer_get (device_param->speed_rec[i], rec_ms);
1116
1117 if (rec_ms > SPEED_MAXAGE) continue;
1118
1119 speed_cnt[device_id] += device_param->speed_cnt[i];
1120 speed_ms[device_id] += device_param->speed_ms[i];
1121 }
1122
1123 speed_cnt[device_id] /= SPEED_CACHE;
1124 speed_ms[device_id] /= SPEED_CACHE;
1125 }
1126
1127 float hashes_all_ms = 0;
1128
1129 float hashes_dev_ms[DEVICES_MAX];
1130
1131 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1132 {
1133 hc_device_param_t *device_param = &data.devices_param[device_id];
1134
1135 if (device_param->skipped) continue;
1136
1137 hashes_dev_ms[device_id] = 0;
1138
1139 if (speed_ms[device_id])
1140 {
1141 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1142
1143 hashes_all_ms += hashes_dev_ms[device_id];
1144 }
1145 }
1146
1147 /**
1148 * timers
1149 */
1150
1151 float ms_running = 0;
1152
1153 hc_timer_get (data.timer_running, ms_running);
1154
1155 float ms_paused = data.ms_paused;
1156
1157 if (data.devices_status == STATUS_PAUSED)
1158 {
1159 float ms_paused_tmp = 0;
1160
1161 hc_timer_get (data.timer_paused, ms_paused_tmp);
1162
1163 ms_paused += ms_paused_tmp;
1164 }
1165
1166 #ifdef WIN
1167
1168 __time64_t sec_run = ms_running / 1000;
1169
1170 #else
1171
1172 time_t sec_run = ms_running / 1000;
1173
1174 #endif
1175
1176 if (sec_run)
1177 {
1178 char display_run[32];
1179
1180 struct tm tm_run;
1181
1182 struct tm *tmp;
1183
1184 #ifdef WIN
1185
1186 tmp = _gmtime64 (&sec_run);
1187
1188 #else
1189
1190 tmp = gmtime (&sec_run);
1191
1192 #endif
1193
1194 if (tmp != NULL)
1195 {
1196 memcpy (&tm_run, tmp, sizeof (struct tm));
1197
1198 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1199
1200 char *start = ctime (&data.proc_start);
1201
1202 size_t start_len = strlen (start);
1203
1204 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1205 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1206
1207 log_info ("Time.Started...: %s (%s)", start, display_run);
1208 }
1209 }
1210 else
1211 {
1212 log_info ("Time.Started...: 0 secs");
1213 }
1214
1215 /**
1216 * counters
1217 */
1218
1219 uint salts_left = data.salts_cnt - data.salts_done;
1220
1221 if (salts_left == 0) salts_left = 1;
1222
1223 u64 progress_total = data.words_cnt * salts_left;
1224
1225 u64 all_done = 0;
1226 u64 all_rejected = 0;
1227 u64 all_restored = 0;
1228
1229 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1230 {
1231 if (salts_left > 1)
1232 {
1233 // otherwise the final cracked status shows 0/XXX progress
1234
1235 if (data.salts_shown[salt_pos] == 1) continue;
1236 }
1237
1238 all_done += data.words_progress_done[salt_pos];
1239 all_rejected += data.words_progress_rejected[salt_pos];
1240 all_restored += data.words_progress_restored[salt_pos];
1241 }
1242
1243 u64 progress_cur = all_restored + all_done + all_rejected;
1244 u64 progress_end = progress_total;
1245
1246 u64 progress_skip = 0;
1247
1248 if (data.skip)
1249 {
1250 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1251
1252 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1253 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1254 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1255 }
1256
1257 if (data.limit)
1258 {
1259 progress_end = MIN (data.limit, data.words_base) * salts_left;
1260
1261 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1262 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1263 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1264 }
1265
1266 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1267 u64 progress_end_relative_skip = progress_end - progress_skip;
1268
1269 float speed_ms_real = ms_running - ms_paused;
1270 u64 speed_plains_real = all_done;
1271
1272 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1273 {
1274 if (data.devices_status != STATUS_CRACKED)
1275 {
1276 u64 words_per_ms = 0;
1277
1278 if (speed_plains_real && speed_ms_real)
1279 {
1280 words_per_ms = speed_plains_real / speed_ms_real;
1281 }
1282
1283 #ifdef WIN
1284 __time64_t sec_etc = 0;
1285 #else
1286 time_t sec_etc = 0;
1287 #endif
1288
1289 if (words_per_ms)
1290 {
1291 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1292
1293 u64 ms_left = progress_left_relative_skip / words_per_ms;
1294
1295 sec_etc = ms_left / 1000;
1296 }
1297
1298 if (sec_etc == 0)
1299 {
1300 log_info ("Time.Estimated.: 0 secs");
1301 }
1302 else if ((u64) sec_etc > ETC_MAX)
1303 {
1304 log_info ("Time.Estimated.: > 10 Years");
1305 }
1306 else
1307 {
1308 char display_etc[32];
1309
1310 struct tm tm_etc;
1311
1312 struct tm *tmp;
1313
1314 #ifdef WIN
1315
1316 tmp = _gmtime64 (&sec_etc);
1317
1318 #else
1319
1320 tmp = gmtime (&sec_etc);
1321
1322 #endif
1323
1324 if (tmp != NULL)
1325 {
1326 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1327
1328 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1329
1330 time_t now;
1331
1332 time (&now);
1333
1334 now += sec_etc;
1335
1336 char *etc = ctime (&now);
1337
1338 size_t etc_len = strlen (etc);
1339
1340 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1341 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1342
1343 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1344 }
1345 }
1346 }
1347 }
1348
1349 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1350 {
1351 hc_device_param_t *device_param = &data.devices_param[device_id];
1352
1353 if (device_param->skipped) continue;
1354
1355 char display_dev_cur[16];
1356
1357 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1358
1359 strncpy (display_dev_cur, "0.00", 4);
1360
1361 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1362
1363 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1364 }
1365
1366 char display_all_cur[16];
1367
1368 memset (display_all_cur, 0, sizeof (display_all_cur));
1369
1370 strncpy (display_all_cur, "0.00", 4);
1371
1372 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1373
1374 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1375
1376 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1377 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1378
1379 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);
1380
1381 // crack-per-time
1382
1383 if (data.digests_cnt > 100)
1384 {
1385 time_t now = time (NULL);
1386
1387 int cpt_cur_min = 0;
1388 int cpt_cur_hour = 0;
1389 int cpt_cur_day = 0;
1390
1391 for (int i = 0; i < CPT_BUF; i++)
1392 {
1393 const uint cracked = data.cpt_buf[i].cracked;
1394 const time_t timestamp = data.cpt_buf[i].timestamp;
1395
1396 if ((timestamp + 60) > now)
1397 {
1398 cpt_cur_min += cracked;
1399 }
1400
1401 if ((timestamp + 3600) > now)
1402 {
1403 cpt_cur_hour += cracked;
1404 }
1405
1406 if ((timestamp + 86400) > now)
1407 {
1408 cpt_cur_day += cracked;
1409 }
1410 }
1411
1412 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1413 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1414 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1415
1416 if ((data.cpt_start + 86400) < now)
1417 {
1418 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1419 cpt_cur_min,
1420 cpt_cur_hour,
1421 cpt_cur_day,
1422 cpt_avg_min,
1423 cpt_avg_hour,
1424 cpt_avg_day);
1425 }
1426 else if ((data.cpt_start + 3600) < now)
1427 {
1428 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1429 cpt_cur_min,
1430 cpt_cur_hour,
1431 cpt_avg_min,
1432 cpt_avg_hour,
1433 cpt_avg_day);
1434 }
1435 else if ((data.cpt_start + 60) < now)
1436 {
1437 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1438 cpt_cur_min,
1439 cpt_avg_min,
1440 cpt_avg_hour,
1441 cpt_avg_day);
1442 }
1443 else
1444 {
1445 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_avg_min,
1447 cpt_avg_hour,
1448 cpt_avg_day);
1449 }
1450 }
1451
1452 // Restore point
1453
1454 u64 restore_point = get_lowest_words_done ();
1455
1456 u64 restore_total = data.words_base;
1457
1458 float percent_restore = 0;
1459
1460 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1461
1462 if (progress_end_relative_skip)
1463 {
1464 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1465 {
1466 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1467 float percent_rejected = 0.0;
1468
1469 if (progress_cur)
1470 {
1471 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1472 }
1473
1474 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);
1475 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1476
1477 if (data.restore_disable == 0)
1478 {
1479 if (percent_finished != 1)
1480 {
1481 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1482 }
1483 }
1484 }
1485 }
1486 else
1487 {
1488 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1489 {
1490 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1491 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1492
1493 if (data.restore_disable == 0)
1494 {
1495 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1496 }
1497 }
1498 else
1499 {
1500 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1501 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1502
1503 // --restore not allowed if stdin is used -- really? why?
1504
1505 //if (data.restore_disable == 0)
1506 //{
1507 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1508 //}
1509 }
1510 }
1511
1512 if (data.gpu_temp_disable == 0)
1513 {
1514 hc_thread_mutex_lock (mux_adl);
1515
1516 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1517 {
1518 hc_device_param_t *device_param = &data.devices_param[device_id];
1519
1520 if (device_param->skipped) continue;
1521
1522 #define HM_STR_BUF_SIZE 255
1523
1524 if (data.hm_device[device_id].fan_supported == 1)
1525 {
1526 char utilization[HM_STR_BUF_SIZE];
1527 char temperature[HM_STR_BUF_SIZE];
1528 char fanspeed[HM_STR_BUF_SIZE];
1529
1530 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1531 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1532
1533 if (device_param->vendor_id == VENDOR_ID_AMD)
1534 {
1535 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1536 }
1537 else if (device_param->vendor_id == VENDOR_ID_NV)
1538 {
1539 #ifdef LINUX
1540 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1541 #else
1542 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1543 #endif
1544 }
1545
1546 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1547 }
1548 else
1549 {
1550 char utilization[HM_STR_BUF_SIZE];
1551 char temperature[HM_STR_BUF_SIZE];
1552
1553 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1554 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1555
1556 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1557 }
1558 }
1559
1560 hc_thread_mutex_unlock (mux_adl);
1561 }
1562 }
1563
1564 static void status_benchmark ()
1565 {
1566 if (data.devices_status == STATUS_INIT) return;
1567 if (data.devices_status == STATUS_STARTING) return;
1568
1569 if (data.words_cnt == 0) return;
1570
1571 u64 speed_cnt[DEVICES_MAX];
1572 float speed_ms[DEVICES_MAX];
1573
1574 uint device_id;
1575
1576 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1577 {
1578 hc_device_param_t *device_param = &data.devices_param[device_id];
1579
1580 if (device_param->skipped) continue;
1581
1582 speed_cnt[device_id] = 0;
1583 speed_ms[device_id] = 0;
1584
1585 for (int i = 0; i < SPEED_CACHE; i++)
1586 {
1587 speed_cnt[device_id] += device_param->speed_cnt[i];
1588 speed_ms[device_id] += device_param->speed_ms[i];
1589 }
1590
1591 speed_cnt[device_id] /= SPEED_CACHE;
1592 speed_ms[device_id] /= SPEED_CACHE;
1593 }
1594
1595 float hashes_all_ms = 0;
1596
1597 float hashes_dev_ms[DEVICES_MAX];
1598
1599 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1600 {
1601 hc_device_param_t *device_param = &data.devices_param[device_id];
1602
1603 if (device_param->skipped) continue;
1604
1605 hashes_dev_ms[device_id] = 0;
1606
1607 if (speed_ms[device_id])
1608 {
1609 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1610
1611 hashes_all_ms += hashes_dev_ms[device_id];
1612 }
1613 }
1614
1615 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1616 {
1617 hc_device_param_t *device_param = &data.devices_param[device_id];
1618
1619 if (device_param->skipped) continue;
1620
1621 char display_dev_cur[16];
1622
1623 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1624
1625 strncpy (display_dev_cur, "0.00", 4);
1626
1627 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1628
1629 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1630 }
1631
1632 char display_all_cur[16];
1633
1634 memset (display_all_cur, 0, sizeof (display_all_cur));
1635
1636 strncpy (display_all_cur, "0.00", 4);
1637
1638 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1639
1640 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1641 }
1642
1643 /**
1644 * oclHashcat -only- functions
1645 */
1646
1647 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1648 {
1649 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1650 {
1651 if (attack_kern == ATTACK_KERN_STRAIGHT)
1652 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1653 else if (attack_kern == ATTACK_KERN_COMBI)
1654 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1655 else if (attack_kern == ATTACK_KERN_BF)
1656 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1657 }
1658 else
1659 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1660 }
1661
1662 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)
1663 {
1664 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1665 {
1666 if (attack_kern == ATTACK_KERN_STRAIGHT)
1667 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1668 else if (attack_kern == ATTACK_KERN_COMBI)
1669 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1670 else if (attack_kern == ATTACK_KERN_BF)
1671 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1672 }
1673 else
1674 {
1675 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1676 }
1677 }
1678
1679 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1680 {
1681 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1682 {
1683 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1684 }
1685 else
1686 {
1687 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1688 }
1689 }
1690
1691 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)
1692 {
1693 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1694 {
1695 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1696 }
1697 else
1698 {
1699 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1700 }
1701 }
1702
1703 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1704 {
1705 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1706 }
1707
1708 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1709 {
1710 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1711 }
1712
1713 static uint convert_from_hex (char *line_buf, const uint line_len)
1714 {
1715 if (line_len & 1) return (line_len); // not in hex
1716
1717 if (data.hex_wordlist == 1)
1718 {
1719 uint i;
1720 uint j;
1721
1722 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1723 {
1724 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1725 }
1726
1727 memset (line_buf + i, 0, line_len - i);
1728
1729 return (i);
1730 }
1731 else if (line_len >= 6) // $HEX[] = 6
1732 {
1733 if (line_buf[0] != '$') return (line_len);
1734 if (line_buf[1] != 'H') return (line_len);
1735 if (line_buf[2] != 'E') return (line_len);
1736 if (line_buf[3] != 'X') return (line_len);
1737 if (line_buf[4] != '[') return (line_len);
1738 if (line_buf[line_len - 1] != ']') return (line_len);
1739
1740 uint i;
1741 uint j;
1742
1743 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1744 {
1745 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1746 }
1747
1748 memset (line_buf + i, 0, line_len - i);
1749
1750 return (i);
1751 }
1752
1753 return (line_len);
1754 }
1755
1756 static uint count_lines (FILE *fd)
1757 {
1758 uint cnt = 0;
1759
1760 char *buf = (char *) mymalloc (BUFSIZ + 1);
1761
1762 size_t nread_tmp = 0;
1763
1764 char *ptr = buf;
1765
1766 while (!feof (fd))
1767 {
1768 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1769 nread_tmp = nread;
1770
1771 if (nread < 1) continue;
1772
1773 ptr = buf;
1774
1775 do
1776 {
1777 if (*ptr++ == '\n') cnt++;
1778
1779 } while (nread--);
1780 }
1781
1782 // special case (if last line did not contain a newline char ... at the very end of the file)
1783
1784 if (nread_tmp > 3)
1785 {
1786 ptr -= 2;
1787
1788 if (*ptr != '\n')
1789 {
1790 ptr--;
1791
1792 if (*ptr != '\n') // needed ? different on windows systems?
1793 {
1794 cnt++;
1795 }
1796 }
1797 }
1798
1799 myfree (buf);
1800
1801 return cnt;
1802 }
1803
1804 static void clear_prompt ()
1805 {
1806 fputc ('\r', stdout);
1807
1808 for (size_t i = 0; i < strlen (PROMPT); i++)
1809 {
1810 fputc (' ', stdout);
1811 }
1812
1813 fputc ('\r', stdout);
1814
1815 fflush (stdout);
1816 }
1817
1818 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1819 {
1820 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1821 }
1822
1823 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1824 {
1825 char *outfile = data.outfile;
1826 uint quiet = data.quiet;
1827 FILE *pot_fp = data.pot_fp;
1828 uint loopback = data.loopback;
1829 uint debug_mode = data.debug_mode;
1830 char *debug_file = data.debug_file;
1831
1832 char debug_rule_buf[BLOCK_SIZE];
1833 int debug_rule_len = 0; // -1 error
1834 uint debug_plain_len = 0;
1835
1836 u8 debug_plain_ptr[BLOCK_SIZE];
1837
1838 // hash
1839
1840 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1841
1842 ascii_digest (out_buf, salt_pos, digest_pos);
1843
1844 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1845
1846 // plain
1847
1848 plain_t plain;
1849
1850 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1851
1852 uint gidvid = plain.gidvid;
1853 uint il_pos = plain.il_pos;
1854
1855 u64 crackpos = device_param->words_off;
1856
1857 uint plain_buf[16];
1858
1859 u8 *plain_ptr = (u8 *) plain_buf;
1860 unsigned int plain_len = 0;
1861
1862 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1863 {
1864 u64 gidd = gidvid;
1865 u64 gidm = 0;
1866
1867 pw_t pw;
1868
1869 gidd_to_pw_t (device_param, gidd, &pw);
1870
1871 for (int i = 0, j = gidm; i < 16; i++, j++)
1872 {
1873 plain_buf[i] = pw.hi1[0][j];
1874 }
1875
1876 plain_len = pw.pw_len;
1877
1878 const uint off = device_param->innerloop_pos + il_pos;
1879
1880 if (debug_mode > 0)
1881 {
1882 debug_rule_len = 0;
1883
1884 // save rule
1885 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1886 {
1887 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1888
1889 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1890 }
1891
1892 // save plain
1893 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1894 {
1895 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1896
1897 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1898
1899 debug_plain_len = plain_len;
1900 }
1901 }
1902
1903 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1904
1905 crackpos += gidvid;
1906 crackpos *= data.kernel_rules_cnt;
1907 crackpos += device_param->innerloop_pos + il_pos;
1908
1909 if (plain_len > data.pw_max) plain_len = data.pw_max;
1910 }
1911 else if (data.attack_mode == ATTACK_MODE_COMBI)
1912 {
1913 u64 gidd = gidvid;
1914 u64 gidm = 0;
1915
1916 pw_t pw;
1917
1918 gidd_to_pw_t (device_param, gidd, &pw);
1919
1920 for (int i = 0, j = gidm; i < 16; i++, j++)
1921 {
1922 plain_buf[i] = pw.hi1[0][j];
1923 }
1924
1925 plain_len = pw.pw_len;
1926
1927 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1928 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1929
1930 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1931 {
1932 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1933 }
1934 else
1935 {
1936 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1937
1938 memcpy (plain_ptr, comb_buf, comb_len);
1939 }
1940
1941 plain_len += comb_len;
1942
1943 crackpos += gidvid;
1944 crackpos *= data.combs_cnt;
1945 crackpos += device_param->innerloop_pos + il_pos;
1946
1947 if (data.pw_max != PW_DICTMAX1)
1948 {
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 }
1952 else if (data.attack_mode == ATTACK_MODE_BF)
1953 {
1954 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1955 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1956
1957 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1958 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1959
1960 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1961 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1962
1963 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1964 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1965
1966 plain_len = data.css_cnt;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.bfs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971 }
1972 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1973 {
1974 u64 gidd = gidvid;
1975 u64 gidm = 0;
1976
1977 pw_t pw;
1978
1979 gidd_to_pw_t (device_param, gidd, &pw);
1980
1981 for (int i = 0, j = gidm; i < 16; i++, j++)
1982 {
1983 plain_buf[i] = pw.hi1[0][j];
1984 }
1985
1986 plain_len = pw.pw_len;
1987
1988 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1989
1990 uint start = 0;
1991 uint stop = device_param->kernel_params_mp_buf32[4];
1992
1993 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1994
1995 plain_len += start + stop;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.combs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000
2001 if (data.pw_max != PW_DICTMAX1)
2002 {
2003 if (plain_len > data.pw_max) plain_len = data.pw_max;
2004 }
2005 }
2006 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2007 {
2008 u64 gidd = gidvid;
2009 u64 gidm = 0;
2010
2011 pw_t pw;
2012
2013 gidd_to_pw_t (device_param, gidd, &pw);
2014
2015 for (int i = 0, j = gidm; i < 16; i++, j++)
2016 {
2017 plain_buf[i] = pw.hi1[0][j];
2018 }
2019
2020 plain_len = pw.pw_len;
2021
2022 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2023
2024 uint start = 0;
2025 uint stop = device_param->kernel_params_mp_buf32[4];
2026
2027 memmove (plain_ptr + stop, plain_ptr, plain_len);
2028
2029 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2030
2031 plain_len += start + stop;
2032
2033 crackpos += gidvid;
2034 crackpos *= data.combs_cnt;
2035 crackpos += device_param->innerloop_pos + il_pos;
2036
2037 if (data.pw_max != PW_DICTMAX1)
2038 {
2039 if (plain_len > data.pw_max) plain_len = data.pw_max;
2040 }
2041 }
2042
2043 if (data.attack_mode == ATTACK_MODE_BF)
2044 {
2045 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2046 {
2047 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2048 {
2049 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2050 {
2051 plain_len = plain_len - data.salts_buf[0].salt_len;
2052 }
2053 }
2054
2055 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2056 {
2057 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2058 {
2059 plain_ptr[j] = plain_ptr[i];
2060 }
2061
2062 plain_len = plain_len / 2;
2063 }
2064 }
2065 }
2066
2067 // if enabled, update also the potfile
2068
2069 if (pot_fp)
2070 {
2071 fprintf (pot_fp, "%s:", out_buf);
2072
2073 format_plain (pot_fp, plain_ptr, plain_len, 1);
2074
2075 fputc ('\n', pot_fp);
2076
2077 fflush (pot_fp);
2078 }
2079
2080 // outfile
2081
2082 FILE *out_fp = NULL;
2083
2084 if (outfile != NULL)
2085 {
2086 if ((out_fp = fopen (outfile, "ab")) == NULL)
2087 {
2088 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2089
2090 out_fp = stdout;
2091 }
2092 }
2093 else
2094 {
2095 out_fp = stdout;
2096
2097 if (quiet == 0) clear_prompt ();
2098 }
2099
2100 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2101
2102 if (outfile != NULL)
2103 {
2104 if (out_fp != stdout)
2105 {
2106 fclose (out_fp);
2107 }
2108 }
2109 else
2110 {
2111 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2112 {
2113 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2114 {
2115 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2116 if (quiet == 0) fflush (stdout);
2117 }
2118 }
2119 }
2120
2121 // loopback
2122
2123 if (loopback)
2124 {
2125 char *loopback_file = data.loopback_file;
2126
2127 FILE *fb_fp = NULL;
2128
2129 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2130 {
2131 format_plain (fb_fp, plain_ptr, plain_len, 1);
2132
2133 fputc ('\n', fb_fp);
2134
2135 fclose (fb_fp);
2136 }
2137 }
2138
2139 // (rule) debug mode
2140
2141 // the next check implies that:
2142 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2143 // - debug_mode > 0
2144
2145 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2146 {
2147 if (debug_rule_len < 0) debug_rule_len = 0;
2148
2149 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2150
2151 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2152
2153 if ((quiet == 0) && (debug_file == NULL))
2154 {
2155 fprintf (stdout, "%s", PROMPT);
2156 fflush (stdout);
2157 }
2158 }
2159 }
2160
2161 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2162 {
2163 salt_t *salt_buf = &data.salts_buf[salt_pos];
2164
2165 int found = 0;
2166
2167 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2168
2169 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2170
2171 if (found == 1)
2172 {
2173 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2174
2175 log_info_nn ("");
2176
2177 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);
2178
2179 uint cpt_cracked = 0;
2180
2181 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2182 {
2183 uint idx = salt_buf->digests_offset + digest_pos;
2184
2185 if (data.digests_shown_tmp[idx] == 0) continue;
2186
2187 if (data.digests_shown[idx] == 1) continue;
2188
2189 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2190 {
2191 data.digests_shown[idx] = 1;
2192
2193 data.digests_done++;
2194
2195 cpt_cracked++;
2196
2197 salt_buf->digests_done++;
2198
2199 if (salt_buf->digests_done == salt_buf->digests_cnt)
2200 {
2201 data.salts_shown[salt_pos] = 1;
2202
2203 data.salts_done++;
2204 }
2205 }
2206
2207 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2208
2209 check_hash (device_param, salt_pos, digest_pos);
2210 }
2211
2212 if (cpt_cracked > 0)
2213 {
2214 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2215 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2216
2217 data.cpt_pos++;
2218
2219 data.cpt_total += cpt_cracked;
2220
2221 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2222 }
2223
2224 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2225 {
2226 // we need to reset cracked state on the device
2227 // otherwise host thinks again and again the hash was cracked
2228 // and returns invalid password each time
2229
2230 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2231
2232 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);
2233 }
2234
2235 memset (device_param->result, 0, device_param->size_results);
2236
2237 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2238 }
2239 }
2240
2241 static void save_hash ()
2242 {
2243 char *hashfile = data.hashfile;
2244
2245 char new_hashfile[256];
2246 char old_hashfile[256];
2247
2248 memset (new_hashfile, 0, sizeof (new_hashfile));
2249 memset (old_hashfile, 0, sizeof (old_hashfile));
2250
2251 snprintf (new_hashfile, 255, "%s.new", hashfile);
2252 snprintf (old_hashfile, 255, "%s.old", hashfile);
2253
2254 unlink (new_hashfile);
2255
2256 char separator = data.separator;
2257
2258 FILE *fp = fopen (new_hashfile, "wb");
2259
2260 if (fp == NULL)
2261 {
2262 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2263
2264 exit (-1);
2265 }
2266
2267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2268 {
2269 if (data.salts_shown[salt_pos] == 1) continue;
2270
2271 salt_t *salt_buf = &data.salts_buf[salt_pos];
2272
2273 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2274 {
2275 uint idx = salt_buf->digests_offset + digest_pos;
2276
2277 if (data.digests_shown[idx] == 1) continue;
2278
2279 if (data.hash_mode != 2500)
2280 {
2281 char out_buf[4096];
2282
2283 memset (out_buf, 0, sizeof (out_buf));
2284
2285 if (data.username == 1)
2286 {
2287 user_t *user = data.hash_info[idx]->user;
2288
2289 uint i;
2290
2291 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2292
2293 fputc (separator, fp);
2294 }
2295
2296 ascii_digest (out_buf, salt_pos, digest_pos);
2297
2298 fputs (out_buf, fp);
2299
2300 log_out (fp, "");
2301 }
2302 else
2303 {
2304 hccap_t hccap;
2305
2306 to_hccap_t (&hccap, salt_pos, digest_pos);
2307
2308 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2309 }
2310 }
2311 }
2312
2313 fflush (fp);
2314
2315 fclose (fp);
2316
2317 unlink (old_hashfile);
2318
2319 if (rename (hashfile, old_hashfile) != 0)
2320 {
2321 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2322
2323 exit (-1);
2324 }
2325
2326 unlink (hashfile);
2327
2328 if (rename (new_hashfile, hashfile) != 0)
2329 {
2330 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2331
2332 exit (-1);
2333 }
2334
2335 unlink (old_hashfile);
2336 }
2337
2338 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2339 {
2340 // function called only in case kernel_blocks_all > words_left)
2341
2342 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2343
2344 kernel_blocks_div += kernel_blocks_div / 100;
2345
2346 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2347
2348 while (kernel_blocks_new < total_left)
2349 {
2350 kernel_blocks_div += kernel_blocks_div / 100;
2351
2352 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2353 }
2354
2355 if (data.quiet == 0)
2356 {
2357 clear_prompt ();
2358
2359 log_info ("");
2360
2361 log_info ("INFO: approaching final keyspace, workload adjusted");
2362
2363 log_info ("");
2364
2365 fprintf (stdout, "%s", PROMPT);
2366
2367 fflush (stdout);
2368 }
2369
2370 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2371
2372 return kernel_blocks_div;
2373 }
2374
2375 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2376 {
2377 uint num_elements = num;
2378
2379 device_param->kernel_params_buf32[30] = data.combs_mode;
2380 device_param->kernel_params_buf32[31] = num;
2381
2382 uint kernel_threads = device_param->kernel_threads;
2383
2384 while (num_elements % kernel_threads) num_elements++;
2385
2386 cl_kernel kernel = NULL;
2387
2388 switch (kern_run)
2389 {
2390 case KERN_RUN_1: kernel = device_param->kernel1; break;
2391 case KERN_RUN_12: kernel = device_param->kernel12; break;
2392 case KERN_RUN_2: kernel = device_param->kernel2; break;
2393 case KERN_RUN_23: kernel = device_param->kernel23; break;
2394 case KERN_RUN_3: kernel = device_param->kernel3; break;
2395 }
2396
2397 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2398 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2399 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2400 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2401 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2402 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2403 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2404 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2405 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2406 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2407 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2408
2409 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2410 {
2411 const size_t global_work_size[3] = { num_elements, 32, 1 };
2412 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2413
2414 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2415 }
2416 else
2417 {
2418 const size_t global_work_size[3] = { num_elements, 1, 1 };
2419 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2420
2421 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2422 }
2423
2424 hc_clFlush (device_param->command_queue);
2425
2426 hc_clFinish (device_param->command_queue);
2427 }
2428
2429 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2430 {
2431 uint num_elements = num;
2432
2433 switch (kern_run)
2434 {
2435 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2436 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2437 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2438 }
2439
2440 // causes problems with special threads like in bcrypt
2441 // const uint kernel_threads = device_param->kernel_threads;
2442
2443 const uint kernel_threads = KERNEL_THREADS;
2444
2445 while (num_elements % kernel_threads) num_elements++;
2446
2447 cl_kernel kernel = NULL;
2448
2449 switch (kern_run)
2450 {
2451 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2452 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2453 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2454 }
2455
2456 switch (kern_run)
2457 {
2458 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2459 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2460 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2461 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2462 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2463 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2464 break;
2465 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2466 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2467 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2468 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2469 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2470 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2471 break;
2472 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2473 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2474 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2475 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2476 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2477 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2478 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2479 break;
2480 }
2481
2482 const size_t global_work_size[3] = { num_elements, 1, 1 };
2483 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2484
2485 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2486
2487 hc_clFlush (device_param->command_queue);
2488
2489 hc_clFinish (device_param->command_queue);
2490 }
2491
2492 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2493 {
2494 uint num_elements = num;
2495
2496 uint kernel_threads = device_param->kernel_threads;
2497
2498 while (num_elements % kernel_threads) num_elements++;
2499
2500 cl_kernel kernel = device_param->kernel_tb;
2501
2502 const size_t global_work_size[3] = { num_elements, 1, 1 };
2503 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2504
2505 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2506
2507 hc_clFlush (device_param->command_queue);
2508
2509 hc_clFinish (device_param->command_queue);
2510 }
2511
2512 static void run_kernel_tm (hc_device_param_t *device_param)
2513 {
2514 const uint num_elements = 1024; // fixed
2515
2516 const uint kernel_threads = 32;
2517
2518 cl_kernel kernel = device_param->kernel_tm;
2519
2520 const size_t global_work_size[3] = { num_elements, 1, 1 };
2521 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2522
2523 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2524
2525 hc_clFlush (device_param->command_queue);
2526
2527 hc_clFinish (device_param->command_queue);
2528 }
2529
2530 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2531 {
2532 uint num_elements = num;
2533
2534 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2535 device_param->kernel_params_amp_buf32[6] = num_elements;
2536
2537 // causes problems with special threads like in bcrypt
2538 // const uint kernel_threads = device_param->kernel_threads;
2539
2540 const uint kernel_threads = KERNEL_THREADS;
2541
2542 while (num_elements % kernel_threads) num_elements++;
2543
2544 cl_kernel kernel = device_param->kernel_amp;
2545
2546 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2547 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2548
2549 const size_t global_work_size[3] = { num_elements, 1, 1 };
2550 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2551
2552 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2553
2554 hc_clFlush (device_param->command_queue);
2555
2556 hc_clFinish (device_param->command_queue);
2557 }
2558
2559 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2560 {
2561 if (device_param->vendor_id == VENDOR_ID_AMD)
2562 {
2563 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2564
2565 const cl_uchar zero = 0;
2566
2567 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2568 }
2569 else
2570 {
2571 // NOTE: clEnqueueFillBuffer () always fails with -59
2572 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2573 // How's that possible, OpenCL 1.2 support is advertised??
2574 // We need to workaround...
2575
2576 #define FILLSZ 0x100000
2577
2578 char *tmp = (char *) mymalloc (FILLSZ);
2579
2580 memset (tmp, 0, FILLSZ);
2581
2582 for (uint i = 0; i < size; i += FILLSZ)
2583 {
2584 const int left = size - i;
2585
2586 const int fillsz = MIN (FILLSZ, left);
2587
2588 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2589 }
2590
2591 myfree (tmp);
2592 }
2593 }
2594
2595 static int run_rule_engine (const int rule_len, const char *rule_buf)
2596 {
2597 if (rule_len == 0)
2598 {
2599 return 0;
2600 }
2601 else if (rule_len == 1)
2602 {
2603 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2604 }
2605
2606 return 1;
2607 }
2608
2609 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2610 {
2611 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2612 {
2613 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);
2614 }
2615 else if (data.attack_kern == ATTACK_KERN_COMBI)
2616 {
2617 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);
2618 }
2619 else if (data.attack_kern == ATTACK_KERN_BF)
2620 {
2621 const u64 off = device_param->words_off;
2622
2623 device_param->kernel_params_mp_l_buf64[3] = off;
2624
2625 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2626 }
2627 }
2628
2629 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2630 {
2631 const uint kernel_loops = data.kernel_loops;
2632
2633 // init speed timer
2634
2635 uint speed_pos = device_param->speed_pos;
2636
2637 #ifdef _POSIX
2638 if (device_param->timer_speed.tv_sec == 0)
2639 {
2640 hc_timer_set (&device_param->timer_speed);
2641 }
2642 #endif
2643
2644 #ifdef _WIN
2645 if (device_param->timer_speed.QuadPart == 0)
2646 {
2647 hc_timer_set (&device_param->timer_speed);
2648 }
2649 #endif
2650
2651 // find higest password length, this is for optimization stuff
2652
2653 uint highest_pw_len = 0;
2654
2655 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2656 {
2657 }
2658 else if (data.attack_kern == ATTACK_KERN_COMBI)
2659 {
2660 }
2661 else if (data.attack_kern == ATTACK_KERN_BF)
2662 {
2663 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2664 + device_param->kernel_params_mp_l_buf32[5];
2665 }
2666
2667 // bitslice optimization stuff
2668
2669 if (data.attack_mode == ATTACK_MODE_BF)
2670 {
2671 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2672 {
2673 run_kernel_tb (device_param, pws_cnt);
2674 }
2675 }
2676
2677 // iteration type
2678
2679 uint innerloop_step = 0;
2680 uint innerloop_cnt = 0;
2681
2682 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2683 else innerloop_step = 1;
2684
2685 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2686 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2687 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2688
2689 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2690
2691 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2692 {
2693 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2694
2695 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2696
2697 if (data.devices_status == STATUS_CRACKED) break;
2698 if (data.devices_status == STATUS_ABORTED) break;
2699 if (data.devices_status == STATUS_QUIT) break;
2700 if (data.devices_status == STATUS_BYPASS) break;
2701
2702 if (data.salts_shown[salt_pos] == 1) continue;
2703
2704 salt_t *salt_buf = &data.salts_buf[salt_pos];
2705
2706 device_param->kernel_params_buf32[24] = salt_pos;
2707 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2708 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2709
2710 FILE *combs_fp = device_param->combs_fp;
2711
2712 if (data.attack_mode == ATTACK_MODE_COMBI)
2713 {
2714 rewind (combs_fp);
2715 }
2716
2717 // innerloops
2718
2719 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2720 {
2721 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2722
2723 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2724
2725 if (data.devices_status == STATUS_CRACKED) break;
2726 if (data.devices_status == STATUS_ABORTED) break;
2727 if (data.devices_status == STATUS_QUIT) break;
2728 if (data.devices_status == STATUS_BYPASS) break;
2729
2730 uint innerloop_left = innerloop_cnt - innerloop_pos;
2731
2732 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2733
2734 device_param->innerloop_pos = innerloop_pos;
2735 device_param->innerloop_left = innerloop_left;
2736
2737 device_param->kernel_params_buf32[27] = innerloop_left;
2738
2739 if (innerloop_left == 0) continue;
2740
2741 // initialize amplifiers
2742
2743 if (data.attack_mode == ATTACK_MODE_COMBI)
2744 {
2745 char line_buf[BUFSIZ];
2746
2747 uint i = 0;
2748
2749 while (i < innerloop_left)
2750 {
2751 if (feof (combs_fp)) break;
2752
2753 int line_len = fgetl (combs_fp, line_buf);
2754
2755 if (line_len >= PW_MAX1) continue;
2756
2757 line_len = convert_from_hex (line_buf, line_len);
2758
2759 char *line_buf_new = line_buf;
2760
2761 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2762 {
2763 char rule_buf_out[BLOCK_SIZE];
2764
2765 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2766
2767 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2768
2769 if (rule_len_out < 0)
2770 {
2771 data.words_progress_rejected[salt_pos] += pw_cnt;
2772
2773 continue;
2774 }
2775
2776 line_len = rule_len_out;
2777
2778 line_buf_new = rule_buf_out;
2779 }
2780
2781 line_len = MIN (line_len, PW_DICTMAX);
2782
2783 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2784
2785 memcpy (ptr, line_buf_new, line_len);
2786
2787 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2788
2789 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2790 {
2791 uppercase (ptr, line_len);
2792 }
2793
2794 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2795 {
2796 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2797 {
2798 ptr[line_len] = 0x80;
2799 }
2800
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 ptr[line_len] = 0x01;
2804 }
2805 }
2806
2807 device_param->combs_buf[i].pw_len = line_len;
2808
2809 i++;
2810 }
2811
2812 for (uint j = i; j < innerloop_left; j++)
2813 {
2814 device_param->combs_buf[j].i[0] = 0;
2815 device_param->combs_buf[j].i[1] = 0;
2816 device_param->combs_buf[j].i[2] = 0;
2817 device_param->combs_buf[j].i[3] = 0;
2818 device_param->combs_buf[j].i[4] = 0;
2819 device_param->combs_buf[j].i[5] = 0;
2820 device_param->combs_buf[j].i[6] = 0;
2821 device_param->combs_buf[j].i[7] = 0;
2822
2823 device_param->combs_buf[j].pw_len = 0;
2824 }
2825
2826 innerloop_left = i;
2827 }
2828 else if (data.attack_mode == ATTACK_MODE_BF)
2829 {
2830 u64 off = innerloop_pos;
2831
2832 device_param->kernel_params_mp_r_buf64[3] = off;
2833
2834 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2835 }
2836 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2837 {
2838 u64 off = innerloop_pos;
2839
2840 device_param->kernel_params_mp_buf64[3] = off;
2841
2842 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2843 }
2844 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2845 {
2846 u64 off = innerloop_pos;
2847
2848 device_param->kernel_params_mp_buf64[3] = off;
2849
2850 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2851 }
2852
2853 // copy amplifiers
2854
2855 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2856 {
2857 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2858 }
2859 else if (data.attack_mode == ATTACK_MODE_COMBI)
2860 {
2861 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2862 }
2863 else if (data.attack_mode == ATTACK_MODE_BF)
2864 {
2865 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2866 }
2867 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2868 {
2869 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2874 }
2875
2876 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2877 {
2878 if (data.attack_mode == ATTACK_MODE_BF)
2879 {
2880 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2881 {
2882 const uint size_tm = 32 * sizeof (bs_word_t);
2883
2884 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2885
2886 run_kernel_tm (device_param);
2887
2888 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2889 }
2890 }
2891
2892 if (highest_pw_len < 16)
2893 {
2894 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2895 }
2896 else if (highest_pw_len < 32)
2897 {
2898 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2899 }
2900 else
2901 {
2902 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2903 }
2904 }
2905 else
2906 {
2907 run_kernel_amp (device_param, pws_cnt);
2908
2909 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2910
2911 if (data.opts_type & OPTS_TYPE_HOOK12)
2912 {
2913 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2914 }
2915
2916 uint iter = salt_buf->salt_iter;
2917
2918 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2919 {
2920 uint loop_left = iter - loop_pos;
2921
2922 loop_left = MIN (loop_left, kernel_loops);
2923
2924 device_param->kernel_params_buf32[25] = loop_pos;
2925 device_param->kernel_params_buf32[26] = loop_left;
2926
2927 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2928
2929 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2930
2931 if (data.devices_status == STATUS_CRACKED) break;
2932 if (data.devices_status == STATUS_ABORTED) break;
2933 if (data.devices_status == STATUS_QUIT) break;
2934 }
2935
2936 if (data.opts_type & OPTS_TYPE_HOOK23)
2937 {
2938 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2939
2940 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2941
2942 // do something with data
2943
2944 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2945 }
2946
2947 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2948 }
2949
2950 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2951
2952 if (data.devices_status == STATUS_CRACKED) break;
2953 if (data.devices_status == STATUS_ABORTED) break;
2954 if (data.devices_status == STATUS_QUIT) break;
2955
2956 /**
2957 * result
2958 */
2959
2960 hc_thread_mutex_lock (mux_display);
2961
2962 check_cracked (device_param, salt_pos);
2963
2964 hc_thread_mutex_unlock (mux_display);
2965
2966 /**
2967 * progress
2968 */
2969
2970 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2971
2972 hc_thread_mutex_lock (mux_counter);
2973
2974 data.words_progress_done[salt_pos] += perf_sum_all;
2975
2976 hc_thread_mutex_unlock (mux_counter);
2977
2978 /**
2979 * speed
2980 */
2981
2982 float speed_ms;
2983
2984 hc_timer_get (device_param->timer_speed, speed_ms);
2985
2986 hc_timer_set (&device_param->timer_speed);
2987
2988 hc_thread_mutex_lock (mux_display);
2989
2990 device_param->speed_cnt[speed_pos] = perf_sum_all;
2991
2992 device_param->speed_ms[speed_pos] = speed_ms;
2993
2994 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2995
2996 hc_thread_mutex_unlock (mux_display);
2997
2998 speed_pos++;
2999
3000 if (speed_pos == SPEED_CACHE)
3001 {
3002 speed_pos = 0;
3003 }
3004 }
3005 }
3006
3007 device_param->speed_pos = speed_pos;
3008 }
3009
3010 static void load_segment (wl_data_t *wl_data, FILE *fd)
3011 {
3012 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3013
3014 wl_data->pos = 0;
3015
3016 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3017
3018 wl_data->buf[wl_data->cnt] = 0;
3019
3020 if (wl_data->cnt == 0) return;
3021
3022 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3023
3024 while (!feof (fd))
3025 {
3026 if (wl_data->cnt == wl_data->avail)
3027 {
3028 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3029
3030 wl_data->avail += wl_data->incr;
3031 }
3032
3033 const int c = fgetc (fd);
3034
3035 if (c == EOF) break;
3036
3037 wl_data->buf[wl_data->cnt] = (char) c;
3038
3039 wl_data->cnt++;
3040
3041 if (c == '\n') break;
3042 }
3043
3044 // ensure stream ends with a newline
3045
3046 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3047 {
3048 wl_data->cnt++;
3049
3050 wl_data->buf[wl_data->cnt - 1] = '\n';
3051 }
3052
3053 return;
3054 }
3055
3056 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3057 {
3058 char *ptr = buf;
3059
3060 for (u32 i = 0; i < sz; i++, ptr++)
3061 {
3062 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3063
3064 if (i == 7)
3065 {
3066 *off = i;
3067 *len = i;
3068
3069 return;
3070 }
3071
3072 if (*ptr != '\n') continue;
3073
3074 *off = i + 1;
3075
3076 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3077
3078 *len = i;
3079
3080 return;
3081 }
3082
3083 *off = sz;
3084 *len = sz;
3085 }
3086
3087 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3088 {
3089 char *ptr = buf;
3090
3091 for (u32 i = 0; i < sz; i++, ptr++)
3092 {
3093 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3094
3095 if (*ptr != '\n') continue;
3096
3097 *off = i + 1;
3098
3099 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3100
3101 *len = i;
3102
3103 return;
3104 }
3105
3106 *off = sz;
3107 *len = sz;
3108 }
3109
3110 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3111 {
3112 char *ptr = buf;
3113
3114 for (u32 i = 0; i < sz; i++, ptr++)
3115 {
3116 if (*ptr != '\n') continue;
3117
3118 *off = i + 1;
3119
3120 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3121
3122 *len = i;
3123
3124 return;
3125 }
3126
3127 *off = sz;
3128 *len = sz;
3129 }
3130
3131 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3132 {
3133 while (wl_data->pos < wl_data->cnt)
3134 {
3135 uint off;
3136 uint len;
3137
3138 char *ptr = wl_data->buf + wl_data->pos;
3139
3140 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3141
3142 wl_data->pos += off;
3143
3144 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3145 {
3146 char rule_buf_out[BLOCK_SIZE];
3147
3148 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3149
3150 int rule_len_out = -1;
3151
3152 if (len < BLOCK_SIZE)
3153 {
3154 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3155 }
3156
3157 if (rule_len_out < 0)
3158 {
3159 continue;
3160 }
3161
3162 if (rule_len_out > PW_MAX)
3163 {
3164 continue;
3165 }
3166 }
3167 else
3168 {
3169 if (len > PW_MAX)
3170 {
3171 continue;
3172 }
3173 }
3174
3175 *out_buf = ptr;
3176 *out_len = len;
3177
3178 return;
3179 }
3180
3181 if (feof (fd))
3182 {
3183 fprintf (stderr, "bug!!\n");
3184
3185 return;
3186 }
3187
3188 load_segment (wl_data, fd);
3189
3190 get_next_word (wl_data, fd, out_buf, out_len);
3191 }
3192
3193 #ifdef _POSIX
3194 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3195 #endif
3196
3197 #ifdef _WIN
3198 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3199 #endif
3200 {
3201 hc_signal (NULL);
3202
3203 dictstat_t d;
3204
3205 d.cnt = 0;
3206
3207 #ifdef _POSIX
3208 fstat (fileno (fd), &d.stat);
3209 #endif
3210
3211 #ifdef _WIN
3212 _fstat64 (fileno (fd), &d.stat);
3213 #endif
3214
3215 d.stat.st_mode = 0;
3216 d.stat.st_nlink = 0;
3217 d.stat.st_uid = 0;
3218 d.stat.st_gid = 0;
3219 d.stat.st_rdev = 0;
3220 d.stat.st_atime = 0;
3221
3222 #ifdef _POSIX
3223 d.stat.st_blksize = 0;
3224 d.stat.st_blocks = 0;
3225 #endif
3226
3227 if (d.stat.st_size == 0) return 0;
3228
3229 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3230
3231 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3232 {
3233 if (d_cache)
3234 {
3235 u64 cnt = d_cache->cnt;
3236
3237 u64 keyspace = cnt;
3238
3239 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3240 {
3241 keyspace *= data.kernel_rules_cnt;
3242 }
3243 else if (data.attack_kern == ATTACK_KERN_COMBI)
3244 {
3245 keyspace *= data.combs_cnt;
3246 }
3247
3248 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);
3249 if (data.quiet == 0) log_info ("");
3250
3251 hc_signal (sigHandler_default);
3252
3253 return (keyspace);
3254 }
3255 }
3256
3257 time_t now = 0;
3258 time_t prev = 0;
3259
3260 u64 comp = 0;
3261 u64 cnt = 0;
3262 u64 cnt2 = 0;
3263
3264 while (!feof (fd))
3265 {
3266 load_segment (wl_data, fd);
3267
3268 comp += wl_data->cnt;
3269
3270 u32 i = 0;
3271
3272 while (i < wl_data->cnt)
3273 {
3274 u32 len;
3275 u32 off;
3276
3277 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3278
3279 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3280 {
3281 char rule_buf_out[BLOCK_SIZE];
3282
3283 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3284
3285 int rule_len_out = -1;
3286
3287 if (len < BLOCK_SIZE)
3288 {
3289 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3290 }
3291
3292 if (rule_len_out < 0)
3293 {
3294 len = PW_MAX1;
3295 }
3296 else
3297 {
3298 len = rule_len_out;
3299 }
3300 }
3301
3302 if (len < PW_MAX1)
3303 {
3304 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3305 {
3306 cnt += data.kernel_rules_cnt;
3307 }
3308 else if (data.attack_kern == ATTACK_KERN_COMBI)
3309 {
3310 cnt += data.combs_cnt;
3311 }
3312
3313 d.cnt++;
3314 }
3315
3316 i += off;
3317
3318 cnt2++;
3319 }
3320
3321 time (&now);
3322
3323 if ((now - prev) == 0) continue;
3324
3325 float percent = (float) comp / (float) d.stat.st_size;
3326
3327 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);
3328
3329 time (&prev);
3330 }
3331
3332 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);
3333 if (data.quiet == 0) log_info ("");
3334
3335 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3336
3337 hc_signal (sigHandler_default);
3338
3339 return (cnt);
3340 }
3341
3342 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3343 {
3344 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3345 }
3346
3347 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3348 {
3349 if (data.devices_status == STATUS_BYPASS) return 0;
3350
3351 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3352
3353 uint cache_cnt = pw_cache->cnt;
3354
3355 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3356
3357 memcpy (pw_hc1, pw_buf, pw_len);
3358
3359 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3360
3361 uint pws_cnt = device_param->pws_cnt;
3362
3363 cache_cnt++;
3364
3365 pw_t *pw = device_param->pws_buf + pws_cnt;
3366
3367 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3368
3369 pw->pw_len = pw_len;
3370
3371 pws_cnt++;
3372
3373 device_param->pws_cnt = pws_cnt;
3374 device_param->pw_cnt = pws_cnt * 1;
3375
3376 cache_cnt = 0;
3377
3378 pw_cache->cnt = cache_cnt;
3379
3380 return pws_cnt;
3381 }
3382
3383 static void *thread_monitor (void *p)
3384 {
3385 uint runtime_check = 0;
3386 uint remove_check = 0;
3387 uint status_check = 0;
3388 uint hwmon_check = 0;
3389 uint restore_check = 0;
3390
3391 uint restore_left = data.restore_timer;
3392 uint remove_left = data.remove_timer;
3393 uint status_left = data.status_timer;
3394
3395 // these variables are mainly used for fan control (AMD only)
3396
3397 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3398
3399 // temperature controller "loopback" values
3400
3401 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3402 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3403
3404 int temp_threshold = 1; // degrees celcius
3405
3406 int fan_speed_min = 15; // in percentage
3407 int fan_speed_max = 100;
3408
3409 time_t last_temp_check_time;
3410
3411 uint sleep_time = 1;
3412
3413 if (data.runtime)
3414 {
3415 runtime_check = 1;
3416 }
3417
3418 if (data.restore_timer)
3419 {
3420 restore_check = 1;
3421 }
3422
3423 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3424 {
3425 remove_check = 1;
3426 }
3427
3428 if (data.status == 1)
3429 {
3430 status_check = 1;
3431 }
3432
3433 if (data.gpu_temp_disable == 0)
3434 {
3435 time (&last_temp_check_time);
3436
3437 hwmon_check = 1;
3438 }
3439
3440 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3441 {
3442 return (p);
3443 }
3444
3445 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3446 {
3447 hc_sleep (sleep_time);
3448
3449 if (data.devices_status != STATUS_RUNNING) continue;
3450
3451 if (hwmon_check == 1)
3452 {
3453 hc_thread_mutex_lock (mux_adl);
3454
3455 time_t temp_check_time;
3456
3457 time (&temp_check_time);
3458
3459 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3460
3461 if (Ta == 0) Ta = 1;
3462
3463 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3464 {
3465 hc_device_param_t *device_param = &data.devices_param[device_id];
3466
3467 if (device_param->skipped) continue;
3468
3469 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3470
3471 const int temperature = hm_get_temperature_with_device_id (device_id);
3472
3473 if (temperature > (int) data.gpu_temp_abort)
3474 {
3475 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3476
3477 if (data.devices_status != STATUS_QUIT) myabort ();
3478
3479 break;
3480 }
3481
3482 const int gpu_temp_retain = data.gpu_temp_retain;
3483
3484 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3485 {
3486 if (data.hm_device[device_id].fan_supported == 1)
3487 {
3488 int temp_cur = temperature;
3489
3490 int temp_diff_new = gpu_temp_retain - temp_cur;
3491
3492 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3493
3494 // calculate Ta value (time difference in seconds between the last check and this check)
3495
3496 last_temp_check_time = temp_check_time;
3497
3498 float Kp = 1.8;
3499 float Ki = 0.005;
3500 float Kd = 6;
3501
3502 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3503
3504 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);
3505
3506 if (abs (fan_diff_required) >= temp_threshold)
3507 {
3508 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3509
3510 int fan_speed_level = fan_speed_cur;
3511
3512 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3513
3514 int fan_speed_new = fan_speed_level - fan_diff_required;
3515
3516 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3517 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3518
3519 if (fan_speed_new != fan_speed_cur)
3520 {
3521 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3522 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3523
3524 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3525 {
3526 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3527
3528 fan_speed_chgd[device_id] = 1;
3529 }
3530
3531 temp_diff_old[device_id] = temp_diff_new;
3532 }
3533 }
3534 }
3535 }
3536 }
3537
3538 hc_thread_mutex_unlock (mux_adl);
3539 }
3540
3541 if (restore_check == 1)
3542 {
3543 restore_left--;
3544
3545 if (restore_left == 0)
3546 {
3547 if (data.restore_disable == 0) cycle_restore ();
3548
3549 restore_left = data.restore_timer;
3550 }
3551 }
3552
3553 if ((runtime_check == 1) && (data.runtime_start > 0))
3554 {
3555 time_t runtime_cur;
3556
3557 time (&runtime_cur);
3558
3559 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3560
3561 if (runtime_left <= 0)
3562 {
3563 if (data.benchmark == 0)
3564 {
3565 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3566 }
3567
3568 if (data.devices_status != STATUS_QUIT) myabort ();
3569 }
3570 }
3571
3572 if (remove_check == 1)
3573 {
3574 remove_left--;
3575
3576 if (remove_left == 0)
3577 {
3578 if (data.digests_saved != data.digests_done)
3579 {
3580 data.digests_saved = data.digests_done;
3581
3582 save_hash ();
3583 }
3584
3585 remove_left = data.remove_timer;
3586 }
3587 }
3588
3589 if (status_check == 1)
3590 {
3591 status_left--;
3592
3593 if (status_left == 0)
3594 {
3595 hc_thread_mutex_lock (mux_display);
3596
3597 if (data.quiet == 0) clear_prompt ();
3598
3599 if (data.quiet == 0) log_info ("");
3600
3601 status_display ();
3602
3603 if (data.quiet == 0) log_info ("");
3604
3605 hc_thread_mutex_unlock (mux_display);
3606
3607 status_left = data.status_timer;
3608 }
3609 }
3610 }
3611
3612 myfree (fan_speed_chgd);
3613
3614 myfree (temp_diff_old);
3615 myfree (temp_diff_sum);
3616
3617 p = NULL;
3618
3619 return (p);
3620 }
3621
3622 static void *thread_outfile_remove (void *p)
3623 {
3624 // some hash-dependent constants
3625 char *outfile_dir = data.outfile_check_directory;
3626 uint dgst_size = data.dgst_size;
3627 uint isSalted = data.isSalted;
3628 uint esalt_size = data.esalt_size;
3629 uint hash_mode = data.hash_mode;
3630
3631 uint outfile_check_timer = data.outfile_check_timer;
3632
3633 char separator = data.separator;
3634
3635 // some hash-dependent functions
3636 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3637 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3638
3639 // buffers
3640 hash_t hash_buf;
3641
3642 memset (&hash_buf, 0, sizeof (hash_buf));
3643
3644 hash_buf.digest = mymalloc (dgst_size);
3645
3646 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3647
3648 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3649
3650 uint digest_buf[64];
3651
3652 outfile_data_t *out_info = NULL;
3653
3654 char **out_files = NULL;
3655
3656 time_t folder_mtime = 0;
3657
3658 int out_cnt = 0;
3659
3660 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3661
3662 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3663 {
3664 hc_sleep (1);
3665
3666 if (data.devices_status != STATUS_RUNNING) continue;
3667
3668 check_left--;
3669
3670 if (check_left == 0)
3671 {
3672 struct stat outfile_check_stat;
3673
3674 if (stat (outfile_dir, &outfile_check_stat) == 0)
3675 {
3676 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3677
3678 if (is_dir == 1)
3679 {
3680 if (outfile_check_stat.st_mtime > folder_mtime)
3681 {
3682 char **out_files_new = scan_directory (outfile_dir);
3683
3684 int out_cnt_new = count_dictionaries (out_files_new);
3685
3686 outfile_data_t *out_info_new = NULL;
3687
3688 if (out_cnt_new > 0)
3689 {
3690 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3691
3692 for (int i = 0; i < out_cnt_new; i++)
3693 {
3694 out_info_new[i].file_name = out_files_new[i];
3695
3696 // check if there are files that we have seen/checked before (and not changed)
3697
3698 for (int j = 0; j < out_cnt; j++)
3699 {
3700 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3701 {
3702 struct stat outfile_stat;
3703
3704 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3705 {
3706 if (outfile_stat.st_ctime == out_info[j].ctime)
3707 {
3708 out_info_new[i].ctime = out_info[j].ctime;
3709 out_info_new[i].seek = out_info[j].seek;
3710 }
3711 }
3712 }
3713 }
3714 }
3715 }
3716
3717 local_free (out_info);
3718 local_free (out_files);
3719
3720 out_files = out_files_new;
3721 out_cnt = out_cnt_new;
3722 out_info = out_info_new;
3723
3724 folder_mtime = outfile_check_stat.st_mtime;
3725 }
3726
3727 for (int j = 0; j < out_cnt; j++)
3728 {
3729 FILE *fp = fopen (out_info[j].file_name, "rb");
3730
3731 if (fp != NULL)
3732 {
3733 //hc_thread_mutex_lock (mux_display);
3734
3735 #ifdef _POSIX
3736 struct stat outfile_stat;
3737
3738 fstat (fileno (fp), &outfile_stat);
3739 #endif
3740
3741 #ifdef _WIN
3742 struct stat64 outfile_stat;
3743
3744 _fstat64 (fileno (fp), &outfile_stat);
3745 #endif
3746
3747 if (outfile_stat.st_ctime > out_info[j].ctime)
3748 {
3749 out_info[j].ctime = outfile_stat.st_ctime;
3750 out_info[j].seek = 0;
3751 }
3752
3753 fseek (fp, out_info[j].seek, SEEK_SET);
3754
3755 while (!feof (fp))
3756 {
3757 char line_buf[BUFSIZ];
3758
3759 memset (line_buf, 0, BUFSIZ);
3760
3761 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3762
3763 if (ptr == NULL) break;
3764
3765 int line_len = strlen (line_buf);
3766
3767 if (line_len <= 0) continue;
3768
3769 int iter = MAX_CUT_TRIES;
3770
3771 for (uint i = line_len - 1; i && iter; i--, line_len--)
3772 {
3773 if (line_buf[i] != separator) continue;
3774
3775 int parser_status = PARSER_OK;
3776
3777 if ((hash_mode != 2500) && (hash_mode != 6800))
3778 {
3779 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3780 }
3781
3782 uint found = 0;
3783
3784 if (parser_status == PARSER_OK)
3785 {
3786 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3787 {
3788 if (data.salts_shown[salt_pos] == 1) continue;
3789
3790 salt_t *salt_buf = &data.salts_buf[salt_pos];
3791
3792 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3793 {
3794 uint idx = salt_buf->digests_offset + digest_pos;
3795
3796 if (data.digests_shown[idx] == 1) continue;
3797
3798 uint cracked = 0;
3799
3800 if (hash_mode == 6800)
3801 {
3802 if (i == salt_buf->salt_len)
3803 {
3804 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3805 }
3806 }
3807 else if (hash_mode == 2500)
3808 {
3809 // BSSID : MAC1 : MAC2 (:plain)
3810 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3811 {
3812 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3813
3814 if (!cracked) continue;
3815
3816 // now compare MAC1 and MAC2 too, since we have this additional info
3817 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3818 char *mac2_pos = mac1_pos + 12 + 1;
3819
3820 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3821 wpa_t *wpa = &wpas[salt_pos];
3822
3823 uint pke[25];
3824
3825 char *pke_ptr = (char *) pke;
3826
3827 for (uint i = 0; i < 25; i++)
3828 {
3829 pke[i] = byte_swap_32 (wpa->pke[i]);
3830 }
3831
3832 u8 mac1[6];
3833 u8 mac2[6];
3834
3835 memcpy (mac1, pke_ptr + 23, 6);
3836 memcpy (mac2, pke_ptr + 29, 6);
3837
3838 // compare hex string(s) vs binary MAC address(es)
3839
3840 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3841 {
3842 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3843 {
3844 cracked = 0;
3845 break;
3846 }
3847 }
3848
3849 // early skip ;)
3850 if (!cracked) continue;
3851
3852 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3853 {
3854 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3855 {
3856 cracked = 0;
3857 break;
3858 }
3859 }
3860 }
3861 }
3862 else
3863 {
3864 char *digests_buf_ptr = (char *) data.digests_buf;
3865
3866 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3867
3868 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3869 }
3870
3871 if (cracked == 1)
3872 {
3873 found = 1;
3874
3875 data.digests_shown[idx] = 1;
3876
3877 data.digests_done++;
3878
3879 salt_buf->digests_done++;
3880
3881 if (salt_buf->digests_done == salt_buf->digests_cnt)
3882 {
3883 data.salts_shown[salt_pos] = 1;
3884
3885 data.salts_done++;
3886
3887 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3888 }
3889 }
3890 }
3891
3892 if (data.devices_status == STATUS_CRACKED) break;
3893 }
3894 }
3895
3896 if (found) break;
3897
3898 if (data.devices_status == STATUS_CRACKED) break;
3899
3900 iter--;
3901 }
3902
3903 if (data.devices_status == STATUS_CRACKED) break;
3904 }
3905
3906 out_info[j].seek = ftell (fp);
3907
3908 //hc_thread_mutex_unlock (mux_display);
3909
3910 fclose (fp);
3911 }
3912 }
3913 }
3914 }
3915
3916 check_left = outfile_check_timer;
3917 }
3918 }
3919
3920 if (esalt_size) local_free (hash_buf.esalt);
3921
3922 if (isSalted) local_free (hash_buf.salt);
3923
3924 local_free (hash_buf.digest);
3925
3926 local_free (out_info);
3927
3928 local_free (out_files);
3929
3930 p = NULL;
3931
3932 return (p);
3933 }
3934
3935 static uint get_work (hc_device_param_t *device_param, const u64 max)
3936 {
3937 hc_thread_mutex_lock (mux_dispatcher);
3938
3939 const u64 words_cur = data.words_cur;
3940 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3941
3942 device_param->words_off = words_cur;
3943
3944 const u64 words_left = words_base - words_cur;
3945
3946 if (data.kernel_blocks_all > words_left)
3947 {
3948 if (data.kernel_blocks_div == 0)
3949 {
3950 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3951 }
3952 }
3953
3954 if (data.kernel_blocks_div)
3955 {
3956 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3957 {
3958 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3959 const u32 kernel_power_new = kernel_blocks_new;
3960
3961 if (kernel_blocks_new < device_param->kernel_blocks)
3962 {
3963 device_param->kernel_blocks = kernel_blocks_new;
3964 device_param->kernel_power = kernel_power_new;
3965 }
3966 }
3967 }
3968
3969 const uint kernel_blocks = device_param->kernel_blocks;
3970
3971 uint work = MIN (words_left, kernel_blocks);
3972
3973 work = MIN (work, max);
3974
3975 data.words_cur += work;
3976
3977 hc_thread_mutex_unlock (mux_dispatcher);
3978
3979 return work;
3980 }
3981
3982 static void *thread_calc_stdin (void *p)
3983 {
3984 hc_device_param_t *device_param = (hc_device_param_t *) p;
3985
3986 const uint attack_kern = data.attack_kern;
3987
3988 const uint kernel_blocks = device_param->kernel_blocks;
3989
3990 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3991 {
3992 hc_thread_mutex_lock (mux_dispatcher);
3993
3994 if (feof (stdin) != 0)
3995 {
3996 hc_thread_mutex_unlock (mux_dispatcher);
3997
3998 break;
3999 }
4000
4001 uint words_cur = 0;
4002
4003 while (words_cur < kernel_blocks)
4004 {
4005 char buf[BUFSIZ];
4006
4007 char *line_buf = fgets (buf, sizeof (buf), stdin);
4008
4009 if (line_buf == NULL) break;
4010
4011 uint line_len = in_superchop (line_buf);
4012
4013 line_len = convert_from_hex (line_buf, line_len);
4014
4015 // post-process rule engine
4016
4017 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4018 {
4019 char rule_buf_out[BLOCK_SIZE];
4020
4021 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4022
4023 int rule_len_out = -1;
4024
4025 if (line_len < BLOCK_SIZE)
4026 {
4027 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4028 }
4029
4030 if (rule_len_out < 0) continue;
4031
4032 line_buf = rule_buf_out;
4033 line_len = rule_len_out;
4034 }
4035
4036 if (line_len > PW_MAX)
4037 {
4038 continue;
4039 }
4040
4041 if (attack_kern == ATTACK_KERN_STRAIGHT)
4042 {
4043 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4044 {
4045 hc_thread_mutex_lock (mux_counter);
4046
4047 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4048 {
4049 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4050 }
4051
4052 hc_thread_mutex_unlock (mux_counter);
4053
4054 continue;
4055 }
4056 }
4057 else if (attack_kern == ATTACK_KERN_COMBI)
4058 {
4059 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4060 // since we still need to combine the plains
4061
4062 if (line_len > data.pw_max)
4063 {
4064 hc_thread_mutex_lock (mux_counter);
4065
4066 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4067 {
4068 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4069 }
4070
4071 hc_thread_mutex_unlock (mux_counter);
4072
4073 continue;
4074 }
4075 }
4076
4077 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4078
4079 words_cur++;
4080
4081 if (data.devices_status == STATUS_CRACKED) break;
4082 if (data.devices_status == STATUS_ABORTED) break;
4083 if (data.devices_status == STATUS_QUIT) break;
4084 if (data.devices_status == STATUS_BYPASS) break;
4085 }
4086
4087 hc_thread_mutex_unlock (mux_dispatcher);
4088
4089 if (data.devices_status == STATUS_CRACKED) break;
4090 if (data.devices_status == STATUS_ABORTED) break;
4091 if (data.devices_status == STATUS_QUIT) break;
4092 if (data.devices_status == STATUS_BYPASS) break;
4093
4094 // we need 2 flushing because we have two independant caches and it can occur
4095 // that one buffer is already at threshold plus for that length also exists
4096 // more data in the 2nd buffer so it would overflow
4097
4098 // flush session 1
4099
4100 {
4101 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4102 {
4103 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4104
4105 const uint pw_cache_cnt = pw_cache->cnt;
4106
4107 if (pw_cache_cnt == 0) continue;
4108
4109 pw_cache->cnt = 0;
4110
4111 uint pws_cnt = device_param->pws_cnt;
4112
4113 pw_t *pw = device_param->pws_buf + pws_cnt;
4114
4115 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4116
4117 pw->pw_len = pw_len;
4118
4119 uint pw_cnt = device_param->pw_cnt;
4120
4121 pw_cnt += pw_cache_cnt;
4122
4123 device_param->pw_cnt = pw_cnt;
4124
4125 pws_cnt++;
4126
4127 device_param->pws_cnt = pws_cnt;
4128
4129 if (pws_cnt == device_param->kernel_power_user) break;
4130 }
4131
4132 const uint pw_cnt = device_param->pw_cnt;
4133 const uint pws_cnt = device_param->pws_cnt;
4134
4135 if (pws_cnt)
4136 {
4137 run_copy (device_param, pws_cnt);
4138
4139 run_cracker (device_param, pw_cnt, pws_cnt);
4140
4141 device_param->pw_cnt = 0;
4142 device_param->pws_cnt = 0;
4143 }
4144 }
4145
4146 // flush session 2
4147
4148 {
4149 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4150 {
4151 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4152
4153 const uint pw_cache_cnt = pw_cache->cnt;
4154
4155 if (pw_cache_cnt == 0) continue;
4156
4157 pw_cache->cnt = 0;
4158
4159 uint pws_cnt = device_param->pws_cnt;
4160
4161 pw_t *pw = device_param->pws_buf + pws_cnt;
4162
4163 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4164
4165 pw->pw_len = pw_len;
4166
4167 uint pw_cnt = device_param->pw_cnt;
4168
4169 pw_cnt += pw_cache_cnt;
4170
4171 device_param->pw_cnt = pw_cnt;
4172
4173 pws_cnt++;
4174
4175 device_param->pws_cnt = pws_cnt;
4176 }
4177
4178 const uint pw_cnt = device_param->pw_cnt;
4179 const uint pws_cnt = device_param->pws_cnt;
4180
4181 if (pws_cnt)
4182 {
4183 run_copy (device_param, pws_cnt);
4184
4185 run_cracker (device_param, pw_cnt, pws_cnt);
4186
4187 device_param->pw_cnt = 0;
4188 device_param->pws_cnt = 0;
4189 }
4190 }
4191 }
4192
4193 return NULL;
4194 }
4195
4196 static void *thread_calc (void *p)
4197 {
4198 hc_device_param_t *device_param = (hc_device_param_t *) p;
4199
4200 const uint attack_mode = data.attack_mode;
4201 const uint attack_kern = data.attack_kern;
4202
4203 if (attack_mode == ATTACK_MODE_BF)
4204 {
4205 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4206 {
4207 const uint work = get_work (device_param, -1);
4208
4209 if (work == 0) break;
4210
4211 const u64 words_off = device_param->words_off;
4212 const u64 words_fin = words_off + work;
4213
4214 const uint pw_cnt = work;
4215 const uint pws_cnt = work;
4216
4217 device_param->pw_cnt = pw_cnt;
4218 device_param->pws_cnt = pws_cnt;
4219
4220 if (pws_cnt)
4221 {
4222 run_copy (device_param, pws_cnt);
4223
4224 run_cracker (device_param, pw_cnt, pws_cnt);
4225
4226 device_param->pw_cnt = 0;
4227 device_param->pws_cnt = 0;
4228 }
4229
4230 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4231
4232 if (data.devices_status == STATUS_CRACKED) break;
4233 if (data.devices_status == STATUS_ABORTED) break;
4234 if (data.devices_status == STATUS_QUIT) break;
4235 if (data.devices_status == STATUS_BYPASS) break;
4236
4237 device_param->words_done = words_fin;
4238 }
4239 }
4240 else
4241 {
4242 const uint segment_size = data.segment_size;
4243
4244 char *dictfile = data.dictfile;
4245
4246 if (attack_mode == ATTACK_MODE_COMBI)
4247 {
4248 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4249 {
4250 dictfile = data.dictfile2;
4251 }
4252 }
4253
4254 FILE *fd = fopen (dictfile, "rb");
4255
4256 if (fd == NULL)
4257 {
4258 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4259
4260 return NULL;
4261 }
4262
4263 if (attack_mode == ATTACK_MODE_COMBI)
4264 {
4265 const uint combs_mode = data.combs_mode;
4266
4267 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4268 {
4269 const char *dictfilec = data.dictfile2;
4270
4271 FILE *combs_fp = fopen (dictfilec, "rb");
4272
4273 if (combs_fp == NULL)
4274 {
4275 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4276
4277 fclose (fd);
4278
4279 return NULL;
4280 }
4281
4282 device_param->combs_fp = combs_fp;
4283 }
4284 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4285 {
4286 const char *dictfilec = data.dictfile;
4287
4288 FILE *combs_fp = fopen (dictfilec, "rb");
4289
4290 if (combs_fp == NULL)
4291 {
4292 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4293
4294 fclose (fd);
4295
4296 return NULL;
4297 }
4298
4299 device_param->combs_fp = combs_fp;
4300 }
4301 }
4302
4303 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4304
4305 wl_data->buf = (char *) mymalloc (segment_size);
4306 wl_data->avail = segment_size;
4307 wl_data->incr = segment_size;
4308 wl_data->cnt = 0;
4309 wl_data->pos = 0;
4310
4311 u64 words_cur = 0;
4312
4313 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4314 {
4315 u64 words_off = 0;
4316 u64 words_fin = 0;
4317
4318 u64 max = -1;
4319
4320 while (max)
4321 {
4322 const uint work = get_work (device_param, max);
4323
4324 if (work == 0) break;
4325
4326 words_off = device_param->words_off;
4327 words_fin = words_off + work;
4328
4329 char *line_buf;
4330 uint line_len;
4331
4332 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4333
4334 max = 0;
4335
4336 for ( ; words_cur < words_fin; words_cur++)
4337 {
4338 get_next_word (wl_data, fd, &line_buf, &line_len);
4339
4340 line_len = convert_from_hex (line_buf, line_len);
4341
4342 // post-process rule engine
4343
4344 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4345 {
4346 char rule_buf_out[BLOCK_SIZE];
4347
4348 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4349
4350 int rule_len_out = -1;
4351
4352 if (line_len < BLOCK_SIZE)
4353 {
4354 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4355 }
4356
4357 if (rule_len_out < 0) continue;
4358
4359 line_buf = rule_buf_out;
4360 line_len = rule_len_out;
4361 }
4362
4363 if (attack_kern == ATTACK_KERN_STRAIGHT)
4364 {
4365 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4366 {
4367 max++;
4368
4369 hc_thread_mutex_lock (mux_counter);
4370
4371 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4372 {
4373 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4374 }
4375
4376 hc_thread_mutex_unlock (mux_counter);
4377
4378 continue;
4379 }
4380 }
4381 else if (attack_kern == ATTACK_KERN_COMBI)
4382 {
4383 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4384 // since we still need to combine the plains
4385
4386 if (line_len > data.pw_max)
4387 {
4388 max++;
4389
4390 hc_thread_mutex_lock (mux_counter);
4391
4392 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4393 {
4394 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4395 }
4396
4397 hc_thread_mutex_unlock (mux_counter);
4398
4399 continue;
4400 }
4401 }
4402
4403 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4404
4405 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4406
4407 if (data.devices_status == STATUS_CRACKED) break;
4408 if (data.devices_status == STATUS_ABORTED) break;
4409 if (data.devices_status == STATUS_QUIT) break;
4410 if (data.devices_status == STATUS_BYPASS) break;
4411 }
4412
4413 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4414
4415 if (data.devices_status == STATUS_CRACKED) break;
4416 if (data.devices_status == STATUS_ABORTED) break;
4417 if (data.devices_status == STATUS_QUIT) break;
4418 if (data.devices_status == STATUS_BYPASS) break;
4419 }
4420
4421 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4422
4423 if (data.devices_status == STATUS_CRACKED) break;
4424 if (data.devices_status == STATUS_ABORTED) break;
4425 if (data.devices_status == STATUS_QUIT) break;
4426 if (data.devices_status == STATUS_BYPASS) break;
4427
4428 // we need 2 flushing because we have two independant caches and it can occur
4429 // that one buffer is already at threshold plus for that length also exists
4430 // more data in the 2nd buffer so it would overflow
4431
4432 //
4433 // flush session 1
4434 //
4435
4436 {
4437 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4438 {
4439 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4440
4441 const uint pw_cache_cnt = pw_cache->cnt;
4442
4443 if (pw_cache_cnt == 0) continue;
4444
4445 pw_cache->cnt = 0;
4446
4447 uint pws_cnt = device_param->pws_cnt;
4448
4449 pw_t *pw = device_param->pws_buf + pws_cnt;
4450
4451 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4452
4453 pw->pw_len = pw_len;
4454
4455 uint pw_cnt = device_param->pw_cnt;
4456
4457 pw_cnt += pw_cache_cnt;
4458
4459 device_param->pw_cnt = pw_cnt;
4460
4461 pws_cnt++;
4462
4463 device_param->pws_cnt = pws_cnt;
4464
4465 if (pws_cnt == device_param->kernel_power_user) break;
4466 }
4467
4468 const uint pw_cnt = device_param->pw_cnt;
4469 const uint pws_cnt = device_param->pws_cnt;
4470
4471 if (pws_cnt)
4472 {
4473 run_copy (device_param, pws_cnt);
4474
4475 run_cracker (device_param, pw_cnt, pws_cnt);
4476
4477 device_param->pw_cnt = 0;
4478 device_param->pws_cnt = 0;
4479 }
4480
4481 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4482
4483 if (data.devices_status == STATUS_CRACKED) break;
4484 if (data.devices_status == STATUS_ABORTED) break;
4485 if (data.devices_status == STATUS_QUIT) break;
4486 if (data.devices_status == STATUS_BYPASS) break;
4487 }
4488
4489 //
4490 // flush session 2
4491 //
4492
4493 {
4494 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4495 {
4496 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4497
4498 const uint pw_cache_cnt = pw_cache->cnt;
4499
4500 if (pw_cache_cnt == 0) continue;
4501
4502 pw_cache->cnt = 0;
4503
4504 uint pws_cnt = device_param->pws_cnt;
4505
4506 pw_t *pw = device_param->pws_buf + pws_cnt;
4507
4508 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4509
4510 pw->pw_len = pw_len;
4511
4512 uint pw_cnt = device_param->pw_cnt;
4513
4514 pw_cnt += pw_cache_cnt;
4515
4516 device_param->pw_cnt = pw_cnt;
4517
4518 pws_cnt++;
4519
4520 device_param->pws_cnt = pws_cnt;
4521 }
4522
4523 const uint pw_cnt = device_param->pw_cnt;
4524 const uint pws_cnt = device_param->pws_cnt;
4525
4526 if (pws_cnt)
4527 {
4528 run_copy (device_param, pws_cnt);
4529
4530 run_cracker (device_param, pw_cnt, pws_cnt);
4531
4532 device_param->pw_cnt = 0;
4533 device_param->pws_cnt = 0;
4534 }
4535
4536 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4537
4538 if (data.devices_status == STATUS_CRACKED) break;
4539 if (data.devices_status == STATUS_ABORTED) break;
4540 if (data.devices_status == STATUS_QUIT) break;
4541 if (data.devices_status == STATUS_BYPASS) break;
4542 }
4543
4544 if (words_fin == 0) break;
4545
4546 device_param->words_done = words_fin;
4547 }
4548
4549 if (attack_mode == ATTACK_MODE_COMBI)
4550 {
4551 fclose (device_param->combs_fp);
4552 }
4553
4554 free (wl_data->buf);
4555 free (wl_data);
4556
4557 fclose (fd);
4558 }
4559
4560 return NULL;
4561 }
4562
4563 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4564 {
4565 salt_t *salt_buf = &data.salts_buf[salt_pos];
4566
4567 device_param->kernel_params_buf32[24] = salt_pos;
4568 device_param->kernel_params_buf32[27] = 1;
4569 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4570 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4571 device_param->kernel_params_buf32[30] = 0;
4572 device_param->kernel_params_buf32[31] = 1;
4573
4574 char *dictfile_old = data.dictfile;
4575
4576 const char *weak_hash_check = "weak-hash-check";
4577
4578 data.dictfile = (char *) weak_hash_check;
4579
4580 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4581
4582 data.kernel_rules_buf[0].cmds[0] = 0;
4583
4584 /**
4585 * run the kernel
4586 */
4587
4588 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4589 {
4590 run_kernel (KERN_RUN_1, device_param, 1);
4591 }
4592 else
4593 {
4594 run_kernel (KERN_RUN_1, device_param, 1);
4595
4596 const uint iter = salt_buf->salt_iter;
4597
4598 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4599 {
4600 uint loop_left = iter - loop_pos;
4601
4602 loop_left = MIN (loop_left, kernel_loops);
4603
4604 device_param->kernel_params_buf32[25] = loop_pos;
4605 device_param->kernel_params_buf32[26] = loop_left;
4606
4607 run_kernel (KERN_RUN_2, device_param, 1);
4608 }
4609
4610 run_kernel (KERN_RUN_3, device_param, 1);
4611 }
4612
4613 /**
4614 * result
4615 */
4616
4617 check_cracked (device_param, salt_pos);
4618
4619 /**
4620 * cleanup
4621 */
4622
4623 device_param->kernel_params_buf32[24] = 0;
4624 device_param->kernel_params_buf32[25] = 0;
4625 device_param->kernel_params_buf32[26] = 0;
4626 device_param->kernel_params_buf32[27] = 0;
4627 device_param->kernel_params_buf32[28] = 0;
4628 device_param->kernel_params_buf32[29] = 0;
4629 device_param->kernel_params_buf32[30] = 0;
4630 device_param->kernel_params_buf32[31] = 0;
4631
4632 data.dictfile = dictfile_old;
4633
4634 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4635 }
4636
4637 // hlfmt hashcat
4638
4639 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4640 {
4641 if (data.username == 0)
4642 {
4643 *hashbuf_pos = line_buf;
4644 *hashbuf_len = line_len;
4645 }
4646 else
4647 {
4648 char *pos = line_buf;
4649 int len = line_len;
4650
4651 for (int i = 0; i < line_len; i++, pos++, len--)
4652 {
4653 if (line_buf[i] == data.separator)
4654 {
4655 pos++;
4656
4657 len--;
4658
4659 break;
4660 }
4661 }
4662
4663 *hashbuf_pos = pos;
4664 *hashbuf_len = len;
4665 }
4666 }
4667
4668 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4669 {
4670 char *pos = NULL;
4671 int len = 0;
4672
4673 int sep_cnt = 0;
4674
4675 for (int i = 0; i < line_len; i++)
4676 {
4677 if (line_buf[i] == data.separator)
4678 {
4679 sep_cnt++;
4680
4681 continue;
4682 }
4683
4684 if (sep_cnt == 0)
4685 {
4686 if (pos == NULL) pos = line_buf + i;
4687
4688 len++;
4689 }
4690 }
4691
4692 *userbuf_pos = pos;
4693 *userbuf_len = len;
4694 }
4695
4696 // hlfmt pwdump
4697
4698 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4699 {
4700 int sep_cnt = 0;
4701
4702 int sep2_len = 0;
4703 int sep3_len = 0;
4704
4705 for (int i = 0; i < line_len; i++)
4706 {
4707 if (line_buf[i] == ':')
4708 {
4709 sep_cnt++;
4710
4711 continue;
4712 }
4713
4714 if (sep_cnt == 2) sep2_len++;
4715 if (sep_cnt == 3) sep3_len++;
4716 }
4717
4718 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4719
4720 return 0;
4721 }
4722
4723 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4724 {
4725 char *pos = NULL;
4726 int len = 0;
4727
4728 int sep_cnt = 0;
4729
4730 for (int i = 0; i < line_len; i++)
4731 {
4732 if (line_buf[i] == ':')
4733 {
4734 sep_cnt++;
4735
4736 continue;
4737 }
4738
4739 if (data.hash_mode == 1000)
4740 {
4741 if (sep_cnt == 3)
4742 {
4743 if (pos == NULL) pos = line_buf + i;
4744
4745 len++;
4746 }
4747 }
4748 else if (data.hash_mode == 3000)
4749 {
4750 if (sep_cnt == 2)
4751 {
4752 if (pos == NULL) pos = line_buf + i;
4753
4754 len++;
4755 }
4756 }
4757 }
4758
4759 *hashbuf_pos = pos;
4760 *hashbuf_len = len;
4761 }
4762
4763 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4764 {
4765 char *pos = NULL;
4766 int len = 0;
4767
4768 int sep_cnt = 0;
4769
4770 for (int i = 0; i < line_len; i++)
4771 {
4772 if (line_buf[i] == ':')
4773 {
4774 sep_cnt++;
4775
4776 continue;
4777 }
4778
4779 if (sep_cnt == 0)
4780 {
4781 if (pos == NULL) pos = line_buf + i;
4782
4783 len++;
4784 }
4785 }
4786
4787 *userbuf_pos = pos;
4788 *userbuf_len = len;
4789 }
4790
4791 // hlfmt passwd
4792
4793 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4794 {
4795 int sep_cnt = 0;
4796
4797 char sep5_first = 0;
4798 char sep6_first = 0;
4799
4800 for (int i = 0; i < line_len; i++)
4801 {
4802 if (line_buf[i] == ':')
4803 {
4804 sep_cnt++;
4805
4806 continue;
4807 }
4808
4809 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4810 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4811 }
4812
4813 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4814
4815 return 0;
4816 }
4817
4818 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4819 {
4820 char *pos = NULL;
4821 int len = 0;
4822
4823 int sep_cnt = 0;
4824
4825 for (int i = 0; i < line_len; i++)
4826 {
4827 if (line_buf[i] == ':')
4828 {
4829 sep_cnt++;
4830
4831 continue;
4832 }
4833
4834 if (sep_cnt == 1)
4835 {
4836 if (pos == NULL) pos = line_buf + i;
4837
4838 len++;
4839 }
4840 }
4841
4842 *hashbuf_pos = pos;
4843 *hashbuf_len = len;
4844 }
4845
4846 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4847 {
4848 char *pos = NULL;
4849 int len = 0;
4850
4851 int sep_cnt = 0;
4852
4853 for (int i = 0; i < line_len; i++)
4854 {
4855 if (line_buf[i] == ':')
4856 {
4857 sep_cnt++;
4858
4859 continue;
4860 }
4861
4862 if (sep_cnt == 0)
4863 {
4864 if (pos == NULL) pos = line_buf + i;
4865
4866 len++;
4867 }
4868 }
4869
4870 *userbuf_pos = pos;
4871 *userbuf_len = len;
4872 }
4873
4874 // hlfmt shadow
4875
4876 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4877 {
4878 int sep_cnt = 0;
4879
4880 for (int i = 0; i < line_len; i++)
4881 {
4882 if (line_buf[i] == ':') sep_cnt++;
4883 }
4884
4885 if (sep_cnt == 8) return 1;
4886
4887 return 0;
4888 }
4889
4890 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4891 {
4892 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4893 }
4894
4895 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4896 {
4897 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4898 }
4899
4900 // hlfmt main
4901
4902 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4903 {
4904 switch (hashfile_format)
4905 {
4906 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4907 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4908 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4909 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4910 }
4911 }
4912
4913 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4914 {
4915 switch (hashfile_format)
4916 {
4917 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4918 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4919 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4920 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4921 }
4922 }
4923
4924 static uint hlfmt_detect (FILE *fp, uint max_check)
4925 {
4926 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4927
4928 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4929 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4930
4931 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4932
4933 uint num_check = 0;
4934
4935 while (!feof (fp))
4936 {
4937 char line_buf[BUFSIZ];
4938
4939 int line_len = fgetl (fp, line_buf);
4940
4941 if (line_len == 0) continue;
4942
4943 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4944 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4945 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4946
4947 if (num_check == max_check) break;
4948
4949 num_check++;
4950 }
4951
4952 uint hashlist_format = HLFMT_HASHCAT;
4953
4954 for (int i = 1; i < HLFMTS_CNT; i++)
4955 {
4956 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4957
4958 hashlist_format = i;
4959 }
4960
4961 free (formats_cnt);
4962
4963 return hashlist_format;
4964 }
4965
4966 /**
4967 * some further helper function
4968 */
4969
4970 // wrapper around mymalloc for ADL
4971
4972 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4973 {
4974 return mymalloc (iSize);
4975 }
4976
4977 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)
4978 {
4979 u64 collisions = 0;
4980
4981 const uint dgst_pos0 = data.dgst_pos0;
4982 const uint dgst_pos1 = data.dgst_pos1;
4983 const uint dgst_pos2 = data.dgst_pos2;
4984 const uint dgst_pos3 = data.dgst_pos3;
4985
4986 memset (bitmap_a, 0, bitmap_size);
4987 memset (bitmap_b, 0, bitmap_size);
4988 memset (bitmap_c, 0, bitmap_size);
4989 memset (bitmap_d, 0, bitmap_size);
4990
4991 for (uint i = 0; i < digests_cnt; i++)
4992 {
4993 uint *digest_ptr = (uint *) digests_buf_ptr;
4994
4995 digests_buf_ptr += dgst_size;
4996
4997 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
4998 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
4999 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5000 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5001
5002 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5003 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5004 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5005 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5006
5007 if (bitmap_a[idx0] & val0) collisions++;
5008 if (bitmap_b[idx1] & val1) collisions++;
5009 if (bitmap_c[idx2] & val2) collisions++;
5010 if (bitmap_d[idx3] & val3) collisions++;
5011
5012 bitmap_a[idx0] |= val0;
5013 bitmap_b[idx1] |= val1;
5014 bitmap_c[idx2] |= val2;
5015 bitmap_d[idx3] |= val3;
5016
5017 if (collisions >= collisions_max) return 0x7fffffff;
5018 }
5019
5020 return collisions;
5021 }
5022
5023 /**
5024 * main
5025 */
5026
5027 int main (int argc, char **argv)
5028 {
5029 /**
5030 * To help users a bit
5031 */
5032
5033 char *compute = getenv ("COMPUTE");
5034
5035 if (compute)
5036 {
5037 char display[100];
5038
5039 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5040
5041 putenv (display);
5042 }
5043 else
5044 {
5045 if (getenv ("DISPLAY") == NULL)
5046 putenv ((char *) "DISPLAY=:0");
5047 }
5048
5049 /*
5050 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5051 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5052
5053 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5054 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5055 */
5056
5057 /**
5058 * Real init
5059 */
5060
5061 memset (&data, 0, sizeof (hc_global_data_t));
5062
5063 time_t proc_start;
5064
5065 time (&proc_start);
5066
5067 data.proc_start = proc_start;
5068
5069 int myargc = argc;
5070 char **myargv = argv;
5071
5072 hc_thread_mutex_init (mux_dispatcher);
5073 hc_thread_mutex_init (mux_counter);
5074 hc_thread_mutex_init (mux_display);
5075 hc_thread_mutex_init (mux_adl);
5076
5077 /**
5078 * commandline parameters
5079 */
5080
5081 uint usage = USAGE;
5082 uint version = VERSION;
5083 uint quiet = QUIET;
5084 uint benchmark = BENCHMARK;
5085 uint benchmark_mode = BENCHMARK_MODE;
5086 uint show = SHOW;
5087 uint left = LEFT;
5088 uint username = USERNAME;
5089 uint remove = REMOVE;
5090 uint remove_timer = REMOVE_TIMER;
5091 u64 skip = SKIP;
5092 u64 limit = LIMIT;
5093 uint keyspace = KEYSPACE;
5094 uint potfile_disable = POTFILE_DISABLE;
5095 uint debug_mode = DEBUG_MODE;
5096 char *debug_file = NULL;
5097 char *induction_dir = NULL;
5098 char *outfile_check_dir = NULL;
5099 uint force = FORCE;
5100 uint runtime = RUNTIME;
5101 uint hash_mode = HASH_MODE;
5102 uint attack_mode = ATTACK_MODE;
5103 uint markov_disable = MARKOV_DISABLE;
5104 uint markov_classic = MARKOV_CLASSIC;
5105 uint markov_threshold = MARKOV_THRESHOLD;
5106 char *markov_hcstat = NULL;
5107 char *outfile = NULL;
5108 uint outfile_format = OUTFILE_FORMAT;
5109 uint outfile_autohex = OUTFILE_AUTOHEX;
5110 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5111 uint restore = RESTORE;
5112 uint restore_timer = RESTORE_TIMER;
5113 uint restore_disable = RESTORE_DISABLE;
5114 uint status = STATUS;
5115 uint status_timer = STATUS_TIMER;
5116 uint status_automat = STATUS_AUTOMAT;
5117 uint loopback = LOOPBACK;
5118 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5119 char *session = NULL;
5120 uint hex_charset = HEX_CHARSET;
5121 uint hex_salt = HEX_SALT;
5122 uint hex_wordlist = HEX_WORDLIST;
5123 uint rp_gen = RP_GEN;
5124 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5125 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5126 uint rp_gen_seed = RP_GEN_SEED;
5127 char *rule_buf_l = (char *) RULE_BUF_L;
5128 char *rule_buf_r = (char *) RULE_BUF_R;
5129 uint increment = INCREMENT;
5130 uint increment_min = INCREMENT_MIN;
5131 uint increment_max = INCREMENT_MAX;
5132 char *cpu_affinity = NULL;
5133 char *opencl_devices = NULL;
5134 char *opencl_platforms = NULL;
5135 char *opencl_device_types = NULL;
5136 char *truecrypt_keyfiles = NULL;
5137 uint workload_profile = WORKLOAD_PROFILE;
5138 uint kernel_accel = KERNEL_ACCEL;
5139 uint kernel_loops = KERNEL_LOOPS;
5140 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5141 uint gpu_temp_abort = GPU_TEMP_ABORT;
5142 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5143 uint powertune_enable = POWERTUNE_ENABLE;
5144 uint logfile_disable = LOGFILE_DISABLE;
5145 uint segment_size = SEGMENT_SIZE;
5146 uint scrypt_tmto = SCRYPT_TMTO;
5147 char separator = SEPARATOR;
5148 uint bitmap_min = BITMAP_MIN;
5149 uint bitmap_max = BITMAP_MAX;
5150 char *custom_charset_1 = NULL;
5151 char *custom_charset_2 = NULL;
5152 char *custom_charset_3 = NULL;
5153 char *custom_charset_4 = NULL;
5154
5155 #define IDX_HELP 'h'
5156 #define IDX_VERSION 'V'
5157 #define IDX_VERSION_LOWER 'v'
5158 #define IDX_QUIET 0xff02
5159 #define IDX_SHOW 0xff03
5160 #define IDX_LEFT 0xff04
5161 #define IDX_REMOVE 0xff05
5162 #define IDX_REMOVE_TIMER 0xff37
5163 #define IDX_SKIP 's'
5164 #define IDX_LIMIT 'l'
5165 #define IDX_KEYSPACE 0xff35
5166 #define IDX_POTFILE_DISABLE 0xff06
5167 #define IDX_DEBUG_MODE 0xff43
5168 #define IDX_DEBUG_FILE 0xff44
5169 #define IDX_INDUCTION_DIR 0xff46
5170 #define IDX_OUTFILE_CHECK_DIR 0xff47
5171 #define IDX_USERNAME 0xff07
5172 #define IDX_FORCE 0xff08
5173 #define IDX_RUNTIME 0xff09
5174 #define IDX_BENCHMARK 'b'
5175 #define IDX_BENCHMARK_MODE 0xff32
5176 #define IDX_HASH_MODE 'm'
5177 #define IDX_ATTACK_MODE 'a'
5178 #define IDX_RP_FILE 'r'
5179 #define IDX_RP_GEN 'g'
5180 #define IDX_RP_GEN_FUNC_MIN 0xff10
5181 #define IDX_RP_GEN_FUNC_MAX 0xff11
5182 #define IDX_RP_GEN_SEED 0xff34
5183 #define IDX_RULE_BUF_L 'j'
5184 #define IDX_RULE_BUF_R 'k'
5185 #define IDX_INCREMENT 'i'
5186 #define IDX_INCREMENT_MIN 0xff12
5187 #define IDX_INCREMENT_MAX 0xff13
5188 #define IDX_OUTFILE 'o'
5189 #define IDX_OUTFILE_FORMAT 0xff14
5190 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5191 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5192 #define IDX_RESTORE 0xff15
5193 #define IDX_RESTORE_DISABLE 0xff27
5194 #define IDX_STATUS 0xff17
5195 #define IDX_STATUS_TIMER 0xff18
5196 #define IDX_STATUS_AUTOMAT 0xff50
5197 #define IDX_LOOPBACK 0xff38
5198 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5199 #define IDX_SESSION 0xff19
5200 #define IDX_HEX_CHARSET 0xff20
5201 #define IDX_HEX_SALT 0xff21
5202 #define IDX_HEX_WORDLIST 0xff40
5203 #define IDX_MARKOV_DISABLE 0xff22
5204 #define IDX_MARKOV_CLASSIC 0xff23
5205 #define IDX_MARKOV_THRESHOLD 't'
5206 #define IDX_MARKOV_HCSTAT 0xff24
5207 #define IDX_CPU_AFFINITY 0xff25
5208 #define IDX_OPENCL_DEVICES 'd'
5209 #define IDX_OPENCL_PLATFORMS 0xff72
5210 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5211 #define IDX_WORKLOAD_PROFILE 'w'
5212 #define IDX_KERNEL_ACCEL 'n'
5213 #define IDX_KERNEL_LOOPS 'u'
5214 #define IDX_GPU_TEMP_DISABLE 0xff29
5215 #define IDX_GPU_TEMP_ABORT 0xff30
5216 #define IDX_GPU_TEMP_RETAIN 0xff31
5217 #define IDX_POWERTUNE_ENABLE 0xff41
5218 #define IDX_LOGFILE_DISABLE 0xff51
5219 #define IDX_TRUECRYPT_KEYFILES 0xff52
5220 #define IDX_SCRYPT_TMTO 0xff61
5221 #define IDX_SEGMENT_SIZE 'c'
5222 #define IDX_SEPARATOR 'p'
5223 #define IDX_BITMAP_MIN 0xff70
5224 #define IDX_BITMAP_MAX 0xff71
5225 #define IDX_CUSTOM_CHARSET_1 '1'
5226 #define IDX_CUSTOM_CHARSET_2 '2'
5227 #define IDX_CUSTOM_CHARSET_3 '3'
5228 #define IDX_CUSTOM_CHARSET_4 '4'
5229
5230 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5231
5232 struct option long_options[] =
5233 {
5234 {"help", no_argument, 0, IDX_HELP},
5235 {"version", no_argument, 0, IDX_VERSION},
5236 {"quiet", no_argument, 0, IDX_QUIET},
5237 {"show", no_argument, 0, IDX_SHOW},
5238 {"left", no_argument, 0, IDX_LEFT},
5239 {"username", no_argument, 0, IDX_USERNAME},
5240 {"remove", no_argument, 0, IDX_REMOVE},
5241 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5242 {"skip", required_argument, 0, IDX_SKIP},
5243 {"limit", required_argument, 0, IDX_LIMIT},
5244 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5245 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5246 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5247 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5248 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5249 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5250 {"force", no_argument, 0, IDX_FORCE},
5251 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5252 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5253 {"restore", no_argument, 0, IDX_RESTORE},
5254 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5255 {"status", no_argument, 0, IDX_STATUS},
5256 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5257 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5258 {"loopback", no_argument, 0, IDX_LOOPBACK},
5259 {"weak-hash-threshold",
5260 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5261 {"session", required_argument, 0, IDX_SESSION},
5262 {"runtime", required_argument, 0, IDX_RUNTIME},
5263 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5264 {"generate-rules-func-min",
5265 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5266 {"generate-rules-func-max",
5267 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5268 {"generate-rules-seed",
5269 required_argument, 0, IDX_RP_GEN_SEED},
5270 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5271 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5272 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5273 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5274 {"rules-file", required_argument, 0, IDX_RP_FILE},
5275 {"outfile", required_argument, 0, IDX_OUTFILE},
5276 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5277 {"outfile-autohex-disable",
5278 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5279 {"outfile-check-timer",
5280 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5281 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5282 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5283 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5284 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5285 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5286 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5287 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5288 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5289 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5290 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5291 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5292 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5293 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5294 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5295 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5296 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5297 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5298 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5299 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5300 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5301 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5302 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5303 // deprecated
5304 {"seperator", required_argument, 0, IDX_SEPARATOR},
5305 {"separator", required_argument, 0, IDX_SEPARATOR},
5306 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5307 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5308 {"increment", no_argument, 0, IDX_INCREMENT},
5309 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5310 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5311 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5312 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5313 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5314 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5315
5316 {0, 0, 0, 0}
5317 };
5318
5319 uint rp_files_cnt = 0;
5320
5321 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5322
5323 int option_index;
5324 int c;
5325
5326 optind = 1;
5327 optopt = 0;
5328 option_index = 0;
5329
5330 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5331 {
5332 switch (c)
5333 {
5334 case IDX_HELP: usage = 1; break;
5335 case IDX_VERSION:
5336 case IDX_VERSION_LOWER: version = 1; break;
5337 case IDX_RESTORE: restore = 1; break;
5338 case IDX_SESSION: session = optarg; break;
5339 case IDX_SHOW: show = 1; break;
5340 case IDX_LEFT: left = 1; break;
5341 case '?': return (-1);
5342 }
5343 }
5344
5345 if (optopt != 0)
5346 {
5347 log_error ("ERROR: Invalid argument specified");
5348
5349 return (-1);
5350 }
5351
5352 /**
5353 * exit functions
5354 */
5355
5356 if (version)
5357 {
5358 log_info (VERSION_TXT);
5359
5360 return (0);
5361 }
5362
5363 if (usage)
5364 {
5365 usage_big_print (PROGNAME);
5366
5367 return (0);
5368 }
5369
5370 /**
5371 * session needs to be set, always!
5372 */
5373
5374 if (session == NULL) session = (char *) PROGNAME;
5375
5376 /**
5377 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5378 */
5379
5380 char *exec_path = get_exec_path ();
5381
5382 #ifdef LINUX
5383
5384 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5385 char *resolved_exec_path = realpath (exec_path, NULL);
5386
5387 char *install_dir = get_install_dir (resolved_exec_path);
5388 char *profile_dir = NULL;
5389 char *session_dir = NULL;
5390 char *shared_dir = NULL;
5391
5392 if (strcmp (install_dir, resolved_install_folder) == 0)
5393 {
5394 struct passwd *pw = getpwuid (getuid ());
5395
5396 const char *homedir = pw->pw_dir;
5397
5398 profile_dir = get_profile_dir (homedir);
5399 session_dir = get_session_dir (profile_dir);
5400 shared_dir = strdup (SHARED_FOLDER);
5401
5402 mkdir (profile_dir, 0700);
5403 mkdir (session_dir, 0700);
5404 }
5405 else
5406 {
5407 profile_dir = install_dir;
5408 session_dir = install_dir;
5409 shared_dir = install_dir;
5410 }
5411
5412 myfree (resolved_install_folder);
5413 myfree (resolved_exec_path);
5414
5415 #else
5416
5417 char *install_dir = get_install_dir (exec_path);
5418 char *profile_dir = install_dir;
5419 char *session_dir = install_dir;
5420 char *shared_dir = install_dir;
5421
5422 #endif
5423
5424 data.install_dir = install_dir;
5425 data.profile_dir = profile_dir;
5426 data.session_dir = session_dir;
5427 data.shared_dir = shared_dir;
5428
5429 myfree (exec_path);
5430
5431 /**
5432 * kernel cache, we need to make sure folder exist
5433 */
5434
5435 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5436
5437 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5438
5439 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5440
5441 mkdir (kernels_folder, 0700);
5442
5443 myfree (kernels_folder);
5444
5445 /**
5446 * session
5447 */
5448
5449 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5450
5451 data.session = session;
5452
5453 char *eff_restore_file = (char *) mymalloc (session_size);
5454 char *new_restore_file = (char *) mymalloc (session_size);
5455
5456 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5457 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5458
5459 data.eff_restore_file = eff_restore_file;
5460 data.new_restore_file = new_restore_file;
5461
5462 if (((show == 1) || (left == 1)) && (restore == 1))
5463 {
5464 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5465 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5466
5467 return (-1);
5468 }
5469
5470 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5471 if ((show == 1) || (left == 1))
5472 {
5473 restore_disable = 1;
5474
5475 restore = 0;
5476 }
5477
5478 data.restore_disable = restore_disable;
5479
5480 restore_data_t *rd = init_restore (argc, argv);
5481
5482 data.rd = rd;
5483
5484 /**
5485 * restore file
5486 */
5487
5488 if (restore == 1)
5489 {
5490 read_restore (eff_restore_file, rd);
5491
5492 if (rd->version_bin < RESTORE_MIN)
5493 {
5494 log_error ("ERROR: Incompatible restore-file version");
5495
5496 return (-1);
5497 }
5498
5499 myargc = rd->argc;
5500 myargv = rd->argv;
5501
5502 #ifdef _POSIX
5503 rd->pid = getpid ();
5504 #elif _WIN
5505 rd->pid = GetCurrentProcessId ();
5506 #endif
5507 }
5508
5509 uint hash_mode_chgd = 0;
5510 uint runtime_chgd = 0;
5511 uint kernel_loops_chgd = 0;
5512 uint kernel_accel_chgd = 0;
5513 uint attack_mode_chgd = 0;
5514 uint outfile_format_chgd = 0;
5515 uint rp_gen_seed_chgd = 0;
5516 uint remove_timer_chgd = 0;
5517 uint increment_min_chgd = 0;
5518 uint increment_max_chgd = 0;
5519 uint gpu_temp_abort_chgd = 0;
5520 uint gpu_temp_retain_chgd = 0;
5521
5522 optind = 1;
5523 optopt = 0;
5524 option_index = 0;
5525
5526 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5527 {
5528 switch (c)
5529 {
5530 //case IDX_HELP: usage = 1; break;
5531 //case IDX_VERSION: version = 1; break;
5532 //case IDX_RESTORE: restore = 1; break;
5533 case IDX_QUIET: quiet = 1; break;
5534 //case IDX_SHOW: show = 1; break;
5535 case IDX_SHOW: break;
5536 //case IDX_LEFT: left = 1; break;
5537 case IDX_LEFT: break;
5538 case IDX_USERNAME: username = 1; break;
5539 case IDX_REMOVE: remove = 1; break;
5540 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5541 remove_timer_chgd = 1; break;
5542 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5543 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5544 case IDX_DEBUG_FILE: debug_file = optarg; break;
5545 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5546 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5547 case IDX_FORCE: force = 1; break;
5548 case IDX_SKIP: skip = atoll (optarg); break;
5549 case IDX_LIMIT: limit = atoll (optarg); break;
5550 case IDX_KEYSPACE: keyspace = 1; break;
5551 case IDX_BENCHMARK: benchmark = 1; break;
5552 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5553 case IDX_RESTORE: break;
5554 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5555 case IDX_STATUS: status = 1; break;
5556 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5557 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5558 case IDX_LOOPBACK: loopback = 1; break;
5559 case IDX_WEAK_HASH_THRESHOLD:
5560 weak_hash_threshold = atoi (optarg); break;
5561 //case IDX_SESSION: session = optarg; break;
5562 case IDX_SESSION: break;
5563 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5564 hash_mode_chgd = 1; break;
5565 case IDX_RUNTIME: runtime = atoi (optarg);
5566 runtime_chgd = 1; break;
5567 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5568 attack_mode_chgd = 1; break;
5569 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5570 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5571 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5572 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5573 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5574 rp_gen_seed_chgd = 1; break;
5575 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5576 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5577 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5578 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5579 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5580 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5581 case IDX_OUTFILE: outfile = optarg; break;
5582 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5583 outfile_format_chgd = 1; break;
5584 case IDX_OUTFILE_AUTOHEX_DISABLE:
5585 outfile_autohex = 0; break;
5586 case IDX_OUTFILE_CHECK_TIMER:
5587 outfile_check_timer = atoi (optarg); break;
5588 case IDX_HEX_CHARSET: hex_charset = 1; break;
5589 case IDX_HEX_SALT: hex_salt = 1; break;
5590 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5591 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5592 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5593 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5594 case IDX_OPENCL_DEVICE_TYPES:
5595 opencl_device_types = optarg; break;
5596 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5597 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5598 kernel_accel_chgd = 1; break;
5599 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5600 kernel_loops_chgd = 1; break;
5601 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5602 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5603 gpu_temp_abort = atoi (optarg); break;
5604 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5605 gpu_temp_retain = atoi (optarg); break;
5606 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5607 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5608 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5609 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5610 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5611 case IDX_SEPARATOR: separator = optarg[0]; break;
5612 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5613 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5614 case IDX_INCREMENT: increment = 1; break;
5615 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5616 increment_min_chgd = 1; break;
5617 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5618 increment_max_chgd = 1; break;
5619 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5620 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5621 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5622 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5623
5624 default:
5625 log_error ("ERROR: Invalid argument specified");
5626 return (-1);
5627 }
5628 }
5629
5630 if (optopt != 0)
5631 {
5632 log_error ("ERROR: Invalid argument specified");
5633
5634 return (-1);
5635 }
5636
5637 /**
5638 * Inform user things getting started,
5639 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5640 * - we do not need to check algorithm_pos
5641 */
5642
5643 if (quiet == 0)
5644 {
5645 if (benchmark == 1)
5646 {
5647 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5648
5649 log_info ("");
5650 }
5651 else if (restore == 1)
5652 {
5653 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5654
5655 log_info ("");
5656 }
5657 else
5658 {
5659 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5660
5661 log_info ("");
5662 }
5663 }
5664
5665 /**
5666 * sanity check
5667 */
5668
5669 if (attack_mode > 7)
5670 {
5671 log_error ("ERROR: Invalid attack-mode specified");
5672
5673 return (-1);
5674 }
5675
5676 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5677 {
5678 log_error ("ERROR: Invalid runtime specified");
5679
5680 return (-1);
5681 }
5682
5683 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5684 {
5685 log_error ("ERROR: Invalid hash-type specified");
5686
5687 return (-1);
5688 }
5689
5690 // renamed hash modes
5691
5692 if (hash_mode_chgd)
5693 {
5694 int n = -1;
5695
5696 switch (hash_mode)
5697 {
5698 case 123: n = 124;
5699 break;
5700 }
5701
5702 if (n >= 0)
5703 {
5704 log_error ("Old -m specified, use -m %d instead", n);
5705
5706 return (-1);
5707 }
5708 }
5709
5710 if (username == 1)
5711 {
5712 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5713 {
5714 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5715
5716 return (-1);
5717 }
5718 }
5719
5720 if (outfile_format > 16)
5721 {
5722 log_error ("ERROR: Invalid outfile-format specified");
5723
5724 return (-1);
5725 }
5726
5727 if (left == 1)
5728 {
5729 if (outfile_format_chgd == 1)
5730 {
5731 if (outfile_format > 1)
5732 {
5733 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5734
5735 return (-1);
5736 }
5737 }
5738 else
5739 {
5740 outfile_format = OUTFILE_FMT_HASH;
5741 }
5742 }
5743
5744 if (show == 1)
5745 {
5746 if (outfile_format_chgd == 1)
5747 {
5748 if ((outfile_format > 7) && (outfile_format < 16))
5749 {
5750 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5751
5752 return (-1);
5753 }
5754 }
5755 }
5756
5757 if (increment_min < INCREMENT_MIN)
5758 {
5759 log_error ("ERROR: Invalid increment-min specified");
5760
5761 return (-1);
5762 }
5763
5764 if (increment_max > INCREMENT_MAX)
5765 {
5766 log_error ("ERROR: Invalid increment-max specified");
5767
5768 return (-1);
5769 }
5770
5771 if (increment_min > increment_max)
5772 {
5773 log_error ("ERROR: Invalid increment-min specified");
5774
5775 return (-1);
5776 }
5777
5778 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5779 {
5780 log_error ("ERROR: increment is not allowed in attack-mode 0");
5781
5782 return (-1);
5783 }
5784
5785 if ((increment == 0) && (increment_min_chgd == 1))
5786 {
5787 log_error ("ERROR: increment-min is only supported together with increment switch");
5788
5789 return (-1);
5790 }
5791
5792 if ((increment == 0) && (increment_max_chgd == 1))
5793 {
5794 log_error ("ERROR: increment-max is only supported together with increment switch");
5795
5796 return (-1);
5797 }
5798
5799 if (rp_files_cnt && rp_gen)
5800 {
5801 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5802
5803 return (-1);
5804 }
5805
5806 if (rp_files_cnt || rp_gen)
5807 {
5808 if (attack_mode != ATTACK_MODE_STRAIGHT)
5809 {
5810 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5811
5812 return (-1);
5813 }
5814 }
5815
5816 if (rp_gen_func_min > rp_gen_func_max)
5817 {
5818 log_error ("ERROR: Invalid rp-gen-func-min specified");
5819
5820 return (-1);
5821 }
5822
5823 if (kernel_accel_chgd == 1)
5824 {
5825 if (workload_profile != WORKLOAD_PROFILE)
5826 {
5827 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5828
5829 return (-1);
5830 }
5831
5832 if (kernel_accel < 1)
5833 {
5834 log_error ("ERROR: Invalid kernel-accel specified");
5835
5836 return (-1);
5837 }
5838
5839 if (kernel_accel > 800)
5840 {
5841 log_error ("ERROR: Invalid kernel-accel specified");
5842
5843 return (-1);
5844 }
5845 }
5846
5847 if (kernel_loops_chgd == 1)
5848 {
5849 if (workload_profile != WORKLOAD_PROFILE)
5850 {
5851 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5852
5853 return (-1);
5854 }
5855
5856 if (kernel_loops < 1)
5857 {
5858 log_error ("ERROR: Invalid kernel-loops specified");
5859
5860 return (-1);
5861 }
5862
5863 if (kernel_loops > 1024)
5864 {
5865 log_error ("ERROR: Invalid kernel-loops specified");
5866
5867 return (-1);
5868 }
5869 }
5870
5871 if (benchmark == 1)
5872 {
5873 if (workload_profile != WORKLOAD_PROFILE)
5874 {
5875 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5876
5877 return (-1);
5878 }
5879 }
5880
5881 if ((workload_profile < 1) || (workload_profile > 3))
5882 {
5883 log_error ("ERROR: workload-profile %i not available", workload_profile);
5884
5885 return (-1);
5886 }
5887
5888 if (show == 1 || left == 1)
5889 {
5890 attack_mode = ATTACK_MODE_NONE;
5891
5892 if (remove == 1)
5893 {
5894 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5895
5896 return (-1);
5897 }
5898
5899 if (potfile_disable == 1)
5900 {
5901 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5902
5903 return (-1);
5904 }
5905 }
5906
5907 uint attack_kern = ATTACK_KERN_NONE;
5908
5909 switch (attack_mode)
5910 {
5911 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5912 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5913 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5914 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5915 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5916 }
5917
5918 if (benchmark == 0)
5919 {
5920 if (keyspace == 1)
5921 {
5922 int num_additional_params = 1;
5923
5924 if (attack_kern == ATTACK_KERN_COMBI)
5925 {
5926 num_additional_params = 2;
5927 }
5928
5929 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5930
5931 if (keyspace_wordlist_specified == 0) optind--;
5932 }
5933
5934 if (attack_kern == ATTACK_KERN_NONE)
5935 {
5936 if ((optind + 1) != myargc)
5937 {
5938 usage_mini_print (myargv[0]);
5939
5940 return (-1);
5941 }
5942 }
5943 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5944 {
5945 if ((optind + 1) > myargc)
5946 {
5947 usage_mini_print (myargv[0]);
5948
5949 return (-1);
5950 }
5951 }
5952 else if (attack_kern == ATTACK_KERN_COMBI)
5953 {
5954 if ((optind + 3) != myargc)
5955 {
5956 usage_mini_print (myargv[0]);
5957
5958 return (-1);
5959 }
5960 }
5961 else if (attack_kern == ATTACK_KERN_BF)
5962 {
5963 if ((optind + 1) > myargc)
5964 {
5965 usage_mini_print (myargv[0]);
5966
5967 return (-1);
5968 }
5969 }
5970 else
5971 {
5972 usage_mini_print (myargv[0]);
5973
5974 return (-1);
5975 }
5976 }
5977 else
5978 {
5979 if (myargv[optind] != 0)
5980 {
5981 log_error ("ERROR: Invalid argument for benchmark mode specified");
5982
5983 return (-1);
5984 }
5985
5986 if (attack_mode_chgd == 1)
5987 {
5988 if (attack_mode != ATTACK_MODE_BF)
5989 {
5990 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5991
5992 return (-1);
5993 }
5994 }
5995
5996 if (benchmark_mode == 0)
5997 {
5998 // nothing to do
5999 }
6000 else if (benchmark_mode == 1)
6001 {
6002 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
6003 {
6004 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
6005
6006 return (-1);
6007 }
6008 }
6009 else
6010 {
6011 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6012
6013 return (-1);
6014 }
6015 }
6016
6017 if (skip != 0 && limit != 0)
6018 {
6019 limit += skip;
6020 }
6021
6022 if (keyspace == 1)
6023 {
6024 if (show == 1)
6025 {
6026 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6027
6028 return (-1);
6029 }
6030 else if (left == 1)
6031 {
6032 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6033
6034 return (-1);
6035 }
6036
6037 potfile_disable = 1;
6038
6039 restore_disable = 1;
6040
6041 restore = 0;
6042
6043 weak_hash_threshold = 0;
6044
6045 quiet = 1;
6046 }
6047
6048 if (remove_timer_chgd == 1)
6049 {
6050 if (remove == 0)
6051 {
6052 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6053
6054 return (-1);
6055 }
6056
6057 if (remove_timer < 1)
6058 {
6059 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6060
6061 return (-1);
6062 }
6063 }
6064
6065 if (loopback == 1)
6066 {
6067 if (attack_mode == ATTACK_MODE_BF)
6068 {
6069 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6070
6071 return (-1);
6072 }
6073 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6074 {
6075 if ((rp_files_cnt == 0) && (rp_gen == 0))
6076 {
6077 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6078
6079 return (-1);
6080 }
6081 }
6082 }
6083
6084 if (debug_mode > 0)
6085 {
6086 if (attack_mode != ATTACK_MODE_STRAIGHT)
6087 {
6088 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6089
6090 return (-1);
6091 }
6092
6093 if ((rp_files_cnt == 0) && (rp_gen == 0))
6094 {
6095 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6096
6097 return (-1);
6098 }
6099 }
6100
6101 if (debug_mode > 4)
6102 {
6103 log_error ("ERROR: Invalid debug-mode specified");
6104
6105 return (-1);
6106 }
6107
6108 if (debug_file != NULL)
6109 {
6110 if (debug_mode < 1)
6111 {
6112 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6113
6114 return (-1);
6115 }
6116 }
6117
6118 if (induction_dir != NULL)
6119 {
6120 if (attack_mode == ATTACK_MODE_BF)
6121 {
6122 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6123
6124 return (-1);
6125 }
6126 }
6127
6128 if (attack_mode != ATTACK_MODE_STRAIGHT)
6129 {
6130 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6131 {
6132 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6133
6134 return (-1);
6135 }
6136
6137 weak_hash_threshold = 0;
6138 }
6139
6140 /**
6141 * induction directory
6142 */
6143
6144 char *induction_directory = NULL;
6145
6146 if (attack_mode != ATTACK_MODE_BF)
6147 {
6148 if (induction_dir == NULL)
6149 {
6150 induction_directory = (char *) mymalloc (session_size);
6151
6152 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6153
6154 // create induction folder if it does not already exist
6155
6156 if (keyspace == 0)
6157 {
6158 if (rmdir (induction_directory) == -1)
6159 {
6160 if (errno == ENOENT)
6161 {
6162 // good, we can ignore
6163 }
6164 else if (errno == ENOTEMPTY)
6165 {
6166 char *induction_directory_mv = (char *) mymalloc (session_size);
6167
6168 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6169
6170 if (rename (induction_directory, induction_directory_mv) != 0)
6171 {
6172 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6173
6174 return (-1);
6175 }
6176 }
6177 else
6178 {
6179 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6180
6181 return (-1);
6182 }
6183 }
6184
6185 if (mkdir (induction_directory, 0700) == -1)
6186 {
6187 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6188
6189 return (-1);
6190 }
6191 }
6192 }
6193 else
6194 {
6195 induction_directory = induction_dir;
6196 }
6197 }
6198
6199 data.induction_directory = induction_directory;
6200
6201 /**
6202 * loopback
6203 */
6204
6205 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6206
6207 char *loopback_file = (char *) mymalloc (loopback_size);
6208
6209 /**
6210 * outfile-check directory
6211 */
6212
6213 char *outfile_check_directory = NULL;
6214
6215 if (outfile_check_dir == NULL)
6216 {
6217 outfile_check_directory = (char *) mymalloc (session_size);
6218
6219 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6220 }
6221 else
6222 {
6223 outfile_check_directory = outfile_check_dir;
6224 }
6225
6226 data.outfile_check_directory = outfile_check_directory;
6227
6228 if (keyspace == 0)
6229 {
6230 struct stat outfile_check_stat;
6231
6232 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6233 {
6234 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6235
6236 if (is_dir == 0)
6237 {
6238 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6239
6240 return (-1);
6241 }
6242 }
6243 else if (outfile_check_dir == NULL)
6244 {
6245 if (mkdir (outfile_check_directory, 0700) == -1)
6246 {
6247 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6248
6249 return (-1);
6250 }
6251 }
6252 }
6253
6254 /**
6255 * special other stuff
6256 */
6257
6258 if (hash_mode == 9710)
6259 {
6260 outfile_format = 5;
6261 outfile_format_chgd = 1;
6262 }
6263
6264 if (hash_mode == 9810)
6265 {
6266 outfile_format = 5;
6267 outfile_format_chgd = 1;
6268 }
6269
6270 if (hash_mode == 10410)
6271 {
6272 outfile_format = 5;
6273 outfile_format_chgd = 1;
6274 }
6275
6276 /**
6277 * store stuff
6278 */
6279
6280 data.hash_mode = hash_mode;
6281 data.restore = restore;
6282 data.restore_timer = restore_timer;
6283 data.restore_disable = restore_disable;
6284 data.status = status;
6285 data.status_timer = status_timer;
6286 data.status_automat = status_automat;
6287 data.loopback = loopback;
6288 data.runtime = runtime;
6289 data.remove = remove;
6290 data.remove_timer = remove_timer;
6291 data.debug_mode = debug_mode;
6292 data.debug_file = debug_file;
6293 data.username = username;
6294 data.quiet = quiet;
6295 data.outfile = outfile;
6296 data.outfile_format = outfile_format;
6297 data.outfile_autohex = outfile_autohex;
6298 data.hex_charset = hex_charset;
6299 data.hex_salt = hex_salt;
6300 data.hex_wordlist = hex_wordlist;
6301 data.separator = separator;
6302 data.rp_files = rp_files;
6303 data.rp_files_cnt = rp_files_cnt;
6304 data.rp_gen = rp_gen;
6305 data.rp_gen_seed = rp_gen_seed;
6306 data.force = force;
6307 data.benchmark = benchmark;
6308 data.skip = skip;
6309 data.limit = limit;
6310 data.powertune_enable = powertune_enable;
6311 data.logfile_disable = logfile_disable;
6312 data.truecrypt_keyfiles = truecrypt_keyfiles;
6313 data.scrypt_tmto = scrypt_tmto;
6314
6315 /**
6316 * cpu affinity
6317 */
6318
6319 if (cpu_affinity)
6320 {
6321 set_cpu_affinity (cpu_affinity);
6322 }
6323
6324 if (rp_gen_seed_chgd == 0)
6325 {
6326 srand (proc_start);
6327 }
6328 else
6329 {
6330 srand (rp_gen_seed);
6331 }
6332
6333 /**
6334 * logfile init
6335 */
6336
6337 if (logfile_disable == 0)
6338 {
6339 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6340
6341 char *logfile = (char *) mymalloc (logfile_size);
6342
6343 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6344
6345 data.logfile = logfile;
6346
6347 char *topid = logfile_generate_topid ();
6348
6349 data.topid = topid;
6350 }
6351
6352 // logfile_append() checks for logfile_disable internally to make it easier from here
6353
6354 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6355 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6356 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6357 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6358 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6359 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6360 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6361 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6362 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6363 #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));
6364
6365 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6366 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6367 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6368 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6369 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6370 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6371 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6372 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6373
6374 logfile_top_msg ("START");
6375
6376 logfile_top_uint (attack_mode);
6377 logfile_top_uint (attack_kern);
6378 logfile_top_uint (benchmark);
6379 logfile_top_uint (benchmark_mode);
6380 logfile_top_uint (bitmap_min);
6381 logfile_top_uint (bitmap_max);
6382 logfile_top_uint (debug_mode);
6383 logfile_top_uint (force);
6384 logfile_top_uint (kernel_accel);
6385 logfile_top_uint (kernel_loops);
6386 logfile_top_uint (gpu_temp_abort);
6387 logfile_top_uint (gpu_temp_disable);
6388 logfile_top_uint (gpu_temp_retain);
6389 logfile_top_uint (hash_mode);
6390 logfile_top_uint (hex_charset);
6391 logfile_top_uint (hex_salt);
6392 logfile_top_uint (hex_wordlist);
6393 logfile_top_uint (increment);
6394 logfile_top_uint (increment_max);
6395 logfile_top_uint (increment_min);
6396 logfile_top_uint (keyspace);
6397 logfile_top_uint (left);
6398 logfile_top_uint (logfile_disable);
6399 logfile_top_uint (loopback);
6400 logfile_top_uint (markov_classic);
6401 logfile_top_uint (markov_disable);
6402 logfile_top_uint (markov_threshold);
6403 logfile_top_uint (outfile_autohex);
6404 logfile_top_uint (outfile_check_timer);
6405 logfile_top_uint (outfile_format);
6406 logfile_top_uint (potfile_disable);
6407 logfile_top_uint (powertune_enable);
6408 logfile_top_uint (scrypt_tmto);
6409 logfile_top_uint (quiet);
6410 logfile_top_uint (remove);
6411 logfile_top_uint (remove_timer);
6412 logfile_top_uint (restore);
6413 logfile_top_uint (restore_disable);
6414 logfile_top_uint (restore_timer);
6415 logfile_top_uint (rp_gen);
6416 logfile_top_uint (rp_gen_func_max);
6417 logfile_top_uint (rp_gen_func_min);
6418 logfile_top_uint (rp_gen_seed);
6419 logfile_top_uint (runtime);
6420 logfile_top_uint (segment_size);
6421 logfile_top_uint (show);
6422 logfile_top_uint (status);
6423 logfile_top_uint (status_automat);
6424 logfile_top_uint (status_timer);
6425 logfile_top_uint (usage);
6426 logfile_top_uint (username);
6427 logfile_top_uint (version);
6428 logfile_top_uint (weak_hash_threshold);
6429 logfile_top_uint (workload_profile);
6430 logfile_top_uint64 (limit);
6431 logfile_top_uint64 (skip);
6432 logfile_top_char (separator);
6433 logfile_top_string (cpu_affinity);
6434 logfile_top_string (custom_charset_1);
6435 logfile_top_string (custom_charset_2);
6436 logfile_top_string (custom_charset_3);
6437 logfile_top_string (custom_charset_4);
6438 logfile_top_string (debug_file);
6439 logfile_top_string (opencl_devices);
6440 logfile_top_string (opencl_platforms);
6441 logfile_top_string (opencl_device_types);
6442 logfile_top_string (induction_dir);
6443 logfile_top_string (markov_hcstat);
6444 logfile_top_string (outfile);
6445 logfile_top_string (outfile_check_dir);
6446 logfile_top_string (rule_buf_l);
6447 logfile_top_string (rule_buf_r);
6448 logfile_top_string (session);
6449 logfile_top_string (truecrypt_keyfiles);
6450
6451 /**
6452 * OpenCL platform selection
6453 */
6454
6455 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6456
6457 /**
6458 * OpenCL device selection
6459 */
6460
6461 u32 devices_filter = setup_devices_filter (opencl_devices);
6462
6463 /**
6464 * OpenCL device type selection
6465 */
6466
6467 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6468
6469 /**
6470 * benchmark
6471 */
6472
6473 if (benchmark == 1)
6474 {
6475 /**
6476 * disable useless stuff for benchmark
6477 */
6478
6479 restore_timer = 0;
6480 status_timer = 0;
6481 restore_disable = 1;
6482 potfile_disable = 1;
6483 weak_hash_threshold = 0;
6484
6485 data.restore_timer = restore_timer;
6486 data.status_timer = status_timer;
6487 data.restore_disable = restore_disable;
6488
6489 if (benchmark_mode == 1)
6490 {
6491 markov_disable = 1;
6492 }
6493
6494 /**
6495 * force attack mode to be bruteforce
6496 */
6497
6498 attack_mode = ATTACK_MODE_BF;
6499 attack_kern = ATTACK_KERN_BF;
6500
6501 if (runtime_chgd == 0)
6502 {
6503 runtime = 4;
6504
6505 if (benchmark_mode == 1) runtime = 17;
6506
6507 data.runtime = runtime;
6508 }
6509 }
6510
6511 /**
6512 * config
6513 */
6514
6515 uint hash_type = 0;
6516 uint salt_type = 0;
6517 uint attack_exec = 0;
6518 uint opts_type = 0;
6519 uint kern_type = 0;
6520 uint dgst_size = 0;
6521 uint esalt_size = 0;
6522 uint opti_type = 0;
6523 uint dgst_pos0 = -1;
6524 uint dgst_pos1 = -1;
6525 uint dgst_pos2 = -1;
6526 uint dgst_pos3 = -1;
6527
6528 int (*parse_func) (char *, uint, hash_t *);
6529 int (*sort_by_digest) (const void *, const void *);
6530
6531 uint algorithm_pos = 0;
6532 uint algorithm_max = 1;
6533
6534 uint *algorithms = default_benchmark_algorithms;
6535
6536 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6537
6538 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6539 {
6540 /*
6541 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6542 * the following algos are skipped entirely
6543 */
6544
6545 if (algorithm_pos > 0)
6546 {
6547 local_free (rd);
6548
6549 rd = init_restore (argc, argv);
6550
6551 data.rd = rd;
6552 }
6553
6554 /**
6555 * update hash_mode in case of multihash benchmark
6556 */
6557
6558 if (benchmark == 1)
6559 {
6560 if (hash_mode_chgd == 0)
6561 {
6562 hash_mode = algorithms[algorithm_pos];
6563
6564 data.hash_mode = hash_mode;
6565 }
6566
6567 quiet = 1;
6568
6569 data.quiet = quiet;
6570 }
6571
6572 switch (hash_mode)
6573 {
6574 case 0: hash_type = HASH_TYPE_MD5;
6575 salt_type = SALT_TYPE_NONE;
6576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6577 opts_type = OPTS_TYPE_PT_GENERATE_LE
6578 | OPTS_TYPE_PT_ADD80
6579 | OPTS_TYPE_PT_ADDBITS14;
6580 kern_type = KERN_TYPE_MD5;
6581 dgst_size = DGST_SIZE_4_4;
6582 parse_func = md5_parse_hash;
6583 sort_by_digest = sort_by_digest_4_4;
6584 opti_type = OPTI_TYPE_ZERO_BYTE
6585 | OPTI_TYPE_PRECOMPUTE_INIT
6586 | OPTI_TYPE_PRECOMPUTE_MERKLE
6587 | OPTI_TYPE_MEET_IN_MIDDLE
6588 | OPTI_TYPE_EARLY_SKIP
6589 | OPTI_TYPE_NOT_ITERATED
6590 | OPTI_TYPE_NOT_SALTED
6591 | OPTI_TYPE_RAW_HASH;
6592 dgst_pos0 = 0;
6593 dgst_pos1 = 3;
6594 dgst_pos2 = 2;
6595 dgst_pos3 = 1;
6596 break;
6597
6598 case 10: hash_type = HASH_TYPE_MD5;
6599 salt_type = SALT_TYPE_INTERN;
6600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6601 opts_type = OPTS_TYPE_PT_GENERATE_LE
6602 | OPTS_TYPE_ST_ADD80
6603 | OPTS_TYPE_ST_ADDBITS14;
6604 kern_type = KERN_TYPE_MD5_PWSLT;
6605 dgst_size = DGST_SIZE_4_4;
6606 parse_func = md5s_parse_hash;
6607 sort_by_digest = sort_by_digest_4_4;
6608 opti_type = OPTI_TYPE_ZERO_BYTE
6609 | OPTI_TYPE_PRECOMPUTE_INIT
6610 | OPTI_TYPE_PRECOMPUTE_MERKLE
6611 | OPTI_TYPE_MEET_IN_MIDDLE
6612 | OPTI_TYPE_EARLY_SKIP
6613 | OPTI_TYPE_NOT_ITERATED
6614 | OPTI_TYPE_APPENDED_SALT
6615 | OPTI_TYPE_RAW_HASH;
6616 dgst_pos0 = 0;
6617 dgst_pos1 = 3;
6618 dgst_pos2 = 2;
6619 dgst_pos3 = 1;
6620 break;
6621
6622 case 11: hash_type = HASH_TYPE_MD5;
6623 salt_type = SALT_TYPE_INTERN;
6624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6625 opts_type = OPTS_TYPE_PT_GENERATE_LE
6626 | OPTS_TYPE_ST_ADD80
6627 | OPTS_TYPE_ST_ADDBITS14;
6628 kern_type = KERN_TYPE_MD5_PWSLT;
6629 dgst_size = DGST_SIZE_4_4;
6630 parse_func = joomla_parse_hash;
6631 sort_by_digest = sort_by_digest_4_4;
6632 opti_type = OPTI_TYPE_ZERO_BYTE
6633 | OPTI_TYPE_PRECOMPUTE_INIT
6634 | OPTI_TYPE_PRECOMPUTE_MERKLE
6635 | OPTI_TYPE_MEET_IN_MIDDLE
6636 | OPTI_TYPE_EARLY_SKIP
6637 | OPTI_TYPE_NOT_ITERATED
6638 | OPTI_TYPE_APPENDED_SALT
6639 | OPTI_TYPE_RAW_HASH;
6640 dgst_pos0 = 0;
6641 dgst_pos1 = 3;
6642 dgst_pos2 = 2;
6643 dgst_pos3 = 1;
6644 break;
6645
6646 case 12: hash_type = HASH_TYPE_MD5;
6647 salt_type = SALT_TYPE_INTERN;
6648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6649 opts_type = OPTS_TYPE_PT_GENERATE_LE
6650 | OPTS_TYPE_ST_ADD80
6651 | OPTS_TYPE_ST_ADDBITS14;
6652 kern_type = KERN_TYPE_MD5_PWSLT;
6653 dgst_size = DGST_SIZE_4_4;
6654 parse_func = postgresql_parse_hash;
6655 sort_by_digest = sort_by_digest_4_4;
6656 opti_type = OPTI_TYPE_ZERO_BYTE
6657 | OPTI_TYPE_PRECOMPUTE_INIT
6658 | OPTI_TYPE_PRECOMPUTE_MERKLE
6659 | OPTI_TYPE_MEET_IN_MIDDLE
6660 | OPTI_TYPE_EARLY_SKIP
6661 | OPTI_TYPE_NOT_ITERATED
6662 | OPTI_TYPE_APPENDED_SALT
6663 | OPTI_TYPE_RAW_HASH;
6664 dgst_pos0 = 0;
6665 dgst_pos1 = 3;
6666 dgst_pos2 = 2;
6667 dgst_pos3 = 1;
6668 break;
6669
6670 case 20: hash_type = HASH_TYPE_MD5;
6671 salt_type = SALT_TYPE_INTERN;
6672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6673 opts_type = OPTS_TYPE_PT_GENERATE_LE
6674 | OPTS_TYPE_PT_ADD80
6675 | OPTS_TYPE_PT_ADDBITS14;
6676 kern_type = KERN_TYPE_MD5_SLTPW;
6677 dgst_size = DGST_SIZE_4_4;
6678 parse_func = md5s_parse_hash;
6679 sort_by_digest = sort_by_digest_4_4;
6680 opti_type = OPTI_TYPE_ZERO_BYTE
6681 | OPTI_TYPE_PRECOMPUTE_INIT
6682 | OPTI_TYPE_PRECOMPUTE_MERKLE
6683 | OPTI_TYPE_EARLY_SKIP
6684 | OPTI_TYPE_NOT_ITERATED
6685 | OPTI_TYPE_PREPENDED_SALT
6686 | OPTI_TYPE_RAW_HASH;
6687 dgst_pos0 = 0;
6688 dgst_pos1 = 3;
6689 dgst_pos2 = 2;
6690 dgst_pos3 = 1;
6691 break;
6692
6693 case 21: hash_type = HASH_TYPE_MD5;
6694 salt_type = SALT_TYPE_INTERN;
6695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6696 opts_type = OPTS_TYPE_PT_GENERATE_LE
6697 | OPTS_TYPE_PT_ADD80
6698 | OPTS_TYPE_PT_ADDBITS14;
6699 kern_type = KERN_TYPE_MD5_SLTPW;
6700 dgst_size = DGST_SIZE_4_4;
6701 parse_func = osc_parse_hash;
6702 sort_by_digest = sort_by_digest_4_4;
6703 opti_type = OPTI_TYPE_ZERO_BYTE
6704 | OPTI_TYPE_PRECOMPUTE_INIT
6705 | OPTI_TYPE_PRECOMPUTE_MERKLE
6706 | OPTI_TYPE_EARLY_SKIP
6707 | OPTI_TYPE_NOT_ITERATED
6708 | OPTI_TYPE_PREPENDED_SALT
6709 | OPTI_TYPE_RAW_HASH;
6710 dgst_pos0 = 0;
6711 dgst_pos1 = 3;
6712 dgst_pos2 = 2;
6713 dgst_pos3 = 1;
6714 break;
6715
6716 case 22: hash_type = HASH_TYPE_MD5;
6717 salt_type = SALT_TYPE_EMBEDDED;
6718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6719 opts_type = OPTS_TYPE_PT_GENERATE_LE
6720 | OPTS_TYPE_PT_ADD80
6721 | OPTS_TYPE_PT_ADDBITS14;
6722 kern_type = KERN_TYPE_MD5_SLTPW;
6723 dgst_size = DGST_SIZE_4_4;
6724 parse_func = netscreen_parse_hash;
6725 sort_by_digest = sort_by_digest_4_4;
6726 opti_type = OPTI_TYPE_ZERO_BYTE
6727 | OPTI_TYPE_PRECOMPUTE_INIT
6728 | OPTI_TYPE_PRECOMPUTE_MERKLE
6729 | OPTI_TYPE_EARLY_SKIP
6730 | OPTI_TYPE_NOT_ITERATED
6731 | OPTI_TYPE_PREPENDED_SALT
6732 | OPTI_TYPE_RAW_HASH;
6733 dgst_pos0 = 0;
6734 dgst_pos1 = 3;
6735 dgst_pos2 = 2;
6736 dgst_pos3 = 1;
6737 break;
6738
6739 case 23: hash_type = HASH_TYPE_MD5;
6740 salt_type = SALT_TYPE_EMBEDDED;
6741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6742 opts_type = OPTS_TYPE_PT_GENERATE_LE
6743 | OPTS_TYPE_PT_ADD80
6744 | OPTS_TYPE_PT_ADDBITS14;
6745 kern_type = KERN_TYPE_MD5_SLTPW;
6746 dgst_size = DGST_SIZE_4_4;
6747 parse_func = skype_parse_hash;
6748 sort_by_digest = sort_by_digest_4_4;
6749 opti_type = OPTI_TYPE_ZERO_BYTE
6750 | OPTI_TYPE_PRECOMPUTE_INIT
6751 | OPTI_TYPE_PRECOMPUTE_MERKLE
6752 | OPTI_TYPE_EARLY_SKIP
6753 | OPTI_TYPE_NOT_ITERATED
6754 | OPTI_TYPE_PREPENDED_SALT
6755 | OPTI_TYPE_RAW_HASH;
6756 dgst_pos0 = 0;
6757 dgst_pos1 = 3;
6758 dgst_pos2 = 2;
6759 dgst_pos3 = 1;
6760 break;
6761
6762 case 30: hash_type = HASH_TYPE_MD5;
6763 salt_type = SALT_TYPE_INTERN;
6764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6765 opts_type = OPTS_TYPE_PT_GENERATE_LE
6766 | OPTS_TYPE_PT_UNICODE
6767 | OPTS_TYPE_ST_ADD80
6768 | OPTS_TYPE_ST_ADDBITS14;
6769 kern_type = KERN_TYPE_MD5_PWUSLT;
6770 dgst_size = DGST_SIZE_4_4;
6771 parse_func = md5s_parse_hash;
6772 sort_by_digest = sort_by_digest_4_4;
6773 opti_type = OPTI_TYPE_ZERO_BYTE
6774 | OPTI_TYPE_PRECOMPUTE_INIT
6775 | OPTI_TYPE_PRECOMPUTE_MERKLE
6776 | OPTI_TYPE_MEET_IN_MIDDLE
6777 | OPTI_TYPE_EARLY_SKIP
6778 | OPTI_TYPE_NOT_ITERATED
6779 | OPTI_TYPE_APPENDED_SALT
6780 | OPTI_TYPE_RAW_HASH;
6781 dgst_pos0 = 0;
6782 dgst_pos1 = 3;
6783 dgst_pos2 = 2;
6784 dgst_pos3 = 1;
6785 break;
6786
6787 case 40: hash_type = HASH_TYPE_MD5;
6788 salt_type = SALT_TYPE_INTERN;
6789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6790 opts_type = OPTS_TYPE_PT_GENERATE_LE
6791 | OPTS_TYPE_PT_ADD80
6792 | OPTS_TYPE_PT_ADDBITS14
6793 | OPTS_TYPE_PT_UNICODE;
6794 kern_type = KERN_TYPE_MD5_SLTPWU;
6795 dgst_size = DGST_SIZE_4_4;
6796 parse_func = md5s_parse_hash;
6797 sort_by_digest = sort_by_digest_4_4;
6798 opti_type = OPTI_TYPE_ZERO_BYTE
6799 | OPTI_TYPE_PRECOMPUTE_INIT
6800 | OPTI_TYPE_PRECOMPUTE_MERKLE
6801 | OPTI_TYPE_EARLY_SKIP
6802 | OPTI_TYPE_NOT_ITERATED
6803 | OPTI_TYPE_PREPENDED_SALT
6804 | OPTI_TYPE_RAW_HASH;
6805 dgst_pos0 = 0;
6806 dgst_pos1 = 3;
6807 dgst_pos2 = 2;
6808 dgst_pos3 = 1;
6809 break;
6810
6811 case 50: hash_type = HASH_TYPE_MD5;
6812 salt_type = SALT_TYPE_INTERN;
6813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6814 opts_type = OPTS_TYPE_PT_GENERATE_LE
6815 | OPTS_TYPE_ST_ADD80
6816 | OPTS_TYPE_ST_ADDBITS14;
6817 kern_type = KERN_TYPE_HMACMD5_PW;
6818 dgst_size = DGST_SIZE_4_4;
6819 parse_func = hmacmd5_parse_hash;
6820 sort_by_digest = sort_by_digest_4_4;
6821 opti_type = OPTI_TYPE_ZERO_BYTE
6822 | OPTI_TYPE_NOT_ITERATED;
6823 dgst_pos0 = 0;
6824 dgst_pos1 = 3;
6825 dgst_pos2 = 2;
6826 dgst_pos3 = 1;
6827 break;
6828
6829 case 60: hash_type = HASH_TYPE_MD5;
6830 salt_type = SALT_TYPE_INTERN;
6831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6832 opts_type = OPTS_TYPE_PT_GENERATE_LE
6833 | OPTS_TYPE_PT_ADD80
6834 | OPTS_TYPE_PT_ADDBITS14;
6835 kern_type = KERN_TYPE_HMACMD5_SLT;
6836 dgst_size = DGST_SIZE_4_4;
6837 parse_func = hmacmd5_parse_hash;
6838 sort_by_digest = sort_by_digest_4_4;
6839 opti_type = OPTI_TYPE_ZERO_BYTE
6840 | OPTI_TYPE_NOT_ITERATED;
6841 dgst_pos0 = 0;
6842 dgst_pos1 = 3;
6843 dgst_pos2 = 2;
6844 dgst_pos3 = 1;
6845 break;
6846
6847 case 100: hash_type = HASH_TYPE_SHA1;
6848 salt_type = SALT_TYPE_NONE;
6849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6850 opts_type = OPTS_TYPE_PT_GENERATE_BE
6851 | OPTS_TYPE_PT_ADD80
6852 | OPTS_TYPE_PT_ADDBITS15;
6853 kern_type = KERN_TYPE_SHA1;
6854 dgst_size = DGST_SIZE_4_5;
6855 parse_func = sha1_parse_hash;
6856 sort_by_digest = sort_by_digest_4_5;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_NOT_SALTED
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 3;
6865 dgst_pos1 = 4;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 101: hash_type = HASH_TYPE_SHA1;
6871 salt_type = SALT_TYPE_NONE;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_BE
6874 | OPTS_TYPE_PT_ADD80
6875 | OPTS_TYPE_PT_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1b64_parse_hash;
6879 sort_by_digest = sort_by_digest_4_5;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_NOT_SALTED
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 3;
6888 dgst_pos1 = 4;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 110: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_INTERN;
6895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6896 opts_type = OPTS_TYPE_PT_GENERATE_BE
6897 | OPTS_TYPE_ST_ADD80
6898 | OPTS_TYPE_ST_ADDBITS15;
6899 kern_type = KERN_TYPE_SHA1_PWSLT;
6900 dgst_size = DGST_SIZE_4_5;
6901 parse_func = sha1s_parse_hash;
6902 sort_by_digest = sort_by_digest_4_5;
6903 opti_type = OPTI_TYPE_ZERO_BYTE
6904 | OPTI_TYPE_PRECOMPUTE_INIT
6905 | OPTI_TYPE_PRECOMPUTE_MERKLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_APPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 3;
6911 dgst_pos1 = 4;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 111: hash_type = HASH_TYPE_SHA1;
6917 salt_type = SALT_TYPE_EMBEDDED;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_BE
6920 | OPTS_TYPE_ST_ADD80
6921 | OPTS_TYPE_ST_ADDBITS15;
6922 kern_type = KERN_TYPE_SHA1_PWSLT;
6923 dgst_size = DGST_SIZE_4_5;
6924 parse_func = sha1b64s_parse_hash;
6925 sort_by_digest = sort_by_digest_4_5;
6926 opti_type = OPTI_TYPE_ZERO_BYTE
6927 | OPTI_TYPE_PRECOMPUTE_INIT
6928 | OPTI_TYPE_PRECOMPUTE_MERKLE
6929 | OPTI_TYPE_EARLY_SKIP
6930 | OPTI_TYPE_NOT_ITERATED
6931 | OPTI_TYPE_APPENDED_SALT
6932 | OPTI_TYPE_RAW_HASH;
6933 dgst_pos0 = 3;
6934 dgst_pos1 = 4;
6935 dgst_pos2 = 2;
6936 dgst_pos3 = 1;
6937 break;
6938
6939 case 112: hash_type = HASH_TYPE_SHA1;
6940 salt_type = SALT_TYPE_INTERN;
6941 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6942 opts_type = OPTS_TYPE_PT_GENERATE_BE
6943 | OPTS_TYPE_ST_ADD80
6944 | OPTS_TYPE_ST_ADDBITS15
6945 | OPTS_TYPE_ST_HEX;
6946 kern_type = KERN_TYPE_SHA1_PWSLT;
6947 dgst_size = DGST_SIZE_4_5;
6948 parse_func = oracles_parse_hash;
6949 sort_by_digest = sort_by_digest_4_5;
6950 opti_type = OPTI_TYPE_ZERO_BYTE
6951 | OPTI_TYPE_PRECOMPUTE_INIT
6952 | OPTI_TYPE_PRECOMPUTE_MERKLE
6953 | OPTI_TYPE_EARLY_SKIP
6954 | OPTI_TYPE_NOT_ITERATED
6955 | OPTI_TYPE_APPENDED_SALT
6956 | OPTI_TYPE_RAW_HASH;
6957 dgst_pos0 = 3;
6958 dgst_pos1 = 4;
6959 dgst_pos2 = 2;
6960 dgst_pos3 = 1;
6961 break;
6962
6963 case 120: hash_type = HASH_TYPE_SHA1;
6964 salt_type = SALT_TYPE_INTERN;
6965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6966 opts_type = OPTS_TYPE_PT_GENERATE_BE
6967 | OPTS_TYPE_PT_ADD80
6968 | OPTS_TYPE_PT_ADDBITS15;
6969 kern_type = KERN_TYPE_SHA1_SLTPW;
6970 dgst_size = DGST_SIZE_4_5;
6971 parse_func = sha1s_parse_hash;
6972 sort_by_digest = sort_by_digest_4_5;
6973 opti_type = OPTI_TYPE_ZERO_BYTE
6974 | OPTI_TYPE_PRECOMPUTE_INIT
6975 | OPTI_TYPE_PRECOMPUTE_MERKLE
6976 | OPTI_TYPE_EARLY_SKIP
6977 | OPTI_TYPE_NOT_ITERATED
6978 | OPTI_TYPE_PREPENDED_SALT
6979 | OPTI_TYPE_RAW_HASH;
6980 dgst_pos0 = 3;
6981 dgst_pos1 = 4;
6982 dgst_pos2 = 2;
6983 dgst_pos3 = 1;
6984 break;
6985
6986 case 121: hash_type = HASH_TYPE_SHA1;
6987 salt_type = SALT_TYPE_INTERN;
6988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6989 opts_type = OPTS_TYPE_PT_GENERATE_BE
6990 | OPTS_TYPE_PT_ADD80
6991 | OPTS_TYPE_PT_ADDBITS15
6992 | OPTS_TYPE_ST_LOWER;
6993 kern_type = KERN_TYPE_SHA1_SLTPW;
6994 dgst_size = DGST_SIZE_4_5;
6995 parse_func = smf_parse_hash;
6996 sort_by_digest = sort_by_digest_4_5;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_EARLY_SKIP
7001 | OPTI_TYPE_NOT_ITERATED
7002 | OPTI_TYPE_PREPENDED_SALT
7003 | OPTI_TYPE_RAW_HASH;
7004 dgst_pos0 = 3;
7005 dgst_pos1 = 4;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 122: hash_type = HASH_TYPE_SHA1;
7011 salt_type = SALT_TYPE_EMBEDDED;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_BE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS15
7016 | OPTS_TYPE_ST_HEX;
7017 kern_type = KERN_TYPE_SHA1_SLTPW;
7018 dgst_size = DGST_SIZE_4_5;
7019 parse_func = osx1_parse_hash;
7020 sort_by_digest = sort_by_digest_4_5;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_EARLY_SKIP
7025 | OPTI_TYPE_NOT_ITERATED
7026 | OPTI_TYPE_PREPENDED_SALT
7027 | OPTI_TYPE_RAW_HASH;
7028 dgst_pos0 = 3;
7029 dgst_pos1 = 4;
7030 dgst_pos2 = 2;
7031 dgst_pos3 = 1;
7032 break;
7033
7034 case 124: hash_type = HASH_TYPE_SHA1;
7035 salt_type = SALT_TYPE_EMBEDDED;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_BE
7038 | OPTS_TYPE_PT_ADD80
7039 | OPTS_TYPE_PT_ADDBITS15;
7040 kern_type = KERN_TYPE_SHA1_SLTPW;
7041 dgst_size = DGST_SIZE_4_5;
7042 parse_func = djangosha1_parse_hash;
7043 sort_by_digest = sort_by_digest_4_5;
7044 opti_type = OPTI_TYPE_ZERO_BYTE
7045 | OPTI_TYPE_PRECOMPUTE_INIT
7046 | OPTI_TYPE_PRECOMPUTE_MERKLE
7047 | OPTI_TYPE_EARLY_SKIP
7048 | OPTI_TYPE_NOT_ITERATED
7049 | OPTI_TYPE_PREPENDED_SALT
7050 | OPTI_TYPE_RAW_HASH;
7051 dgst_pos0 = 3;
7052 dgst_pos1 = 4;
7053 dgst_pos2 = 2;
7054 dgst_pos3 = 1;
7055 break;
7056
7057 case 130: hash_type = HASH_TYPE_SHA1;
7058 salt_type = SALT_TYPE_INTERN;
7059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7060 opts_type = OPTS_TYPE_PT_GENERATE_BE
7061 | OPTS_TYPE_PT_UNICODE
7062 | OPTS_TYPE_ST_ADD80
7063 | OPTS_TYPE_ST_ADDBITS15;
7064 kern_type = KERN_TYPE_SHA1_PWUSLT;
7065 dgst_size = DGST_SIZE_4_5;
7066 parse_func = sha1s_parse_hash;
7067 sort_by_digest = sort_by_digest_4_5;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 3;
7076 dgst_pos1 = 4;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 131: hash_type = HASH_TYPE_SHA1;
7082 salt_type = SALT_TYPE_EMBEDDED;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_BE
7085 | OPTS_TYPE_PT_UNICODE
7086 | OPTS_TYPE_PT_UPPER
7087 | OPTS_TYPE_ST_ADD80
7088 | OPTS_TYPE_ST_ADDBITS15
7089 | OPTS_TYPE_ST_HEX;
7090 kern_type = KERN_TYPE_SHA1_PWUSLT;
7091 dgst_size = DGST_SIZE_4_5;
7092 parse_func = mssql2000_parse_hash;
7093 sort_by_digest = sort_by_digest_4_5;
7094 opti_type = OPTI_TYPE_ZERO_BYTE
7095 | OPTI_TYPE_PRECOMPUTE_INIT
7096 | OPTI_TYPE_PRECOMPUTE_MERKLE
7097 | OPTI_TYPE_EARLY_SKIP
7098 | OPTI_TYPE_NOT_ITERATED
7099 | OPTI_TYPE_APPENDED_SALT
7100 | OPTI_TYPE_RAW_HASH;
7101 dgst_pos0 = 3;
7102 dgst_pos1 = 4;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 132: hash_type = HASH_TYPE_SHA1;
7108 salt_type = SALT_TYPE_EMBEDDED;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_BE
7111 | OPTS_TYPE_PT_UNICODE
7112 | OPTS_TYPE_ST_ADD80
7113 | OPTS_TYPE_ST_ADDBITS15
7114 | OPTS_TYPE_ST_HEX;
7115 kern_type = KERN_TYPE_SHA1_PWUSLT;
7116 dgst_size = DGST_SIZE_4_5;
7117 parse_func = mssql2005_parse_hash;
7118 sort_by_digest = sort_by_digest_4_5;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_PRECOMPUTE_INIT
7121 | OPTI_TYPE_PRECOMPUTE_MERKLE
7122 | OPTI_TYPE_EARLY_SKIP
7123 | OPTI_TYPE_NOT_ITERATED
7124 | OPTI_TYPE_APPENDED_SALT
7125 | OPTI_TYPE_RAW_HASH;
7126 dgst_pos0 = 3;
7127 dgst_pos1 = 4;
7128 dgst_pos2 = 2;
7129 dgst_pos3 = 1;
7130 break;
7131
7132 case 133: hash_type = HASH_TYPE_SHA1;
7133 salt_type = SALT_TYPE_EMBEDDED;
7134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7135 opts_type = OPTS_TYPE_PT_GENERATE_BE
7136 | OPTS_TYPE_PT_UNICODE
7137 | OPTS_TYPE_ST_ADD80
7138 | OPTS_TYPE_ST_ADDBITS15;
7139 kern_type = KERN_TYPE_SHA1_PWUSLT;
7140 dgst_size = DGST_SIZE_4_5;
7141 parse_func = peoplesoft_parse_hash;
7142 sort_by_digest = sort_by_digest_4_5;
7143 opti_type = OPTI_TYPE_ZERO_BYTE
7144 | OPTI_TYPE_PRECOMPUTE_INIT
7145 | OPTI_TYPE_PRECOMPUTE_MERKLE
7146 | OPTI_TYPE_EARLY_SKIP
7147 | OPTI_TYPE_NOT_ITERATED
7148 | OPTI_TYPE_APPENDED_SALT
7149 | OPTI_TYPE_RAW_HASH;
7150 dgst_pos0 = 3;
7151 dgst_pos1 = 4;
7152 dgst_pos2 = 2;
7153 dgst_pos3 = 1;
7154 break;
7155
7156 case 140: hash_type = HASH_TYPE_SHA1;
7157 salt_type = SALT_TYPE_INTERN;
7158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7159 opts_type = OPTS_TYPE_PT_GENERATE_BE
7160 | OPTS_TYPE_PT_ADD80
7161 | OPTS_TYPE_PT_ADDBITS15
7162 | OPTS_TYPE_PT_UNICODE;
7163 kern_type = KERN_TYPE_SHA1_SLTPWU;
7164 dgst_size = DGST_SIZE_4_5;
7165 parse_func = sha1s_parse_hash;
7166 sort_by_digest = sort_by_digest_4_5;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_PREPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 3;
7175 dgst_pos1 = 4;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 141: hash_type = HASH_TYPE_SHA1;
7181 salt_type = SALT_TYPE_EMBEDDED;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_BE
7184 | OPTS_TYPE_PT_ADD80
7185 | OPTS_TYPE_PT_ADDBITS15
7186 | OPTS_TYPE_PT_UNICODE
7187 | OPTS_TYPE_ST_BASE64;
7188 kern_type = KERN_TYPE_SHA1_SLTPWU;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = episerver_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_PREPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 150: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_ST_ADD80
7210 | OPTS_TYPE_ST_ADDBITS15;
7211 kern_type = KERN_TYPE_HMACSHA1_PW;
7212 dgst_size = DGST_SIZE_4_5;
7213 parse_func = hmacsha1_parse_hash;
7214 sort_by_digest = sort_by_digest_4_5;
7215 opti_type = OPTI_TYPE_ZERO_BYTE
7216 | OPTI_TYPE_NOT_ITERATED;
7217 dgst_pos0 = 3;
7218 dgst_pos1 = 4;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 160: hash_type = HASH_TYPE_SHA1;
7224 salt_type = SALT_TYPE_INTERN;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_BE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS15;
7229 kern_type = KERN_TYPE_HMACSHA1_SLT;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = hmacsha1_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_NOT_ITERATED;
7235 dgst_pos0 = 3;
7236 dgst_pos1 = 4;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 190: hash_type = HASH_TYPE_SHA1;
7242 salt_type = SALT_TYPE_NONE;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_BE
7245 | OPTS_TYPE_PT_ADD80
7246 | OPTS_TYPE_PT_ADDBITS15;
7247 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7248 dgst_size = DGST_SIZE_4_5;
7249 parse_func = sha1linkedin_parse_hash;
7250 sort_by_digest = sort_by_digest_4_5;
7251 opti_type = OPTI_TYPE_ZERO_BYTE
7252 | OPTI_TYPE_PRECOMPUTE_INIT
7253 | OPTI_TYPE_EARLY_SKIP
7254 | OPTI_TYPE_NOT_ITERATED
7255 | OPTI_TYPE_NOT_SALTED;
7256 dgst_pos0 = 0;
7257 dgst_pos1 = 4;
7258 dgst_pos2 = 3;
7259 dgst_pos3 = 2;
7260 break;
7261
7262 case 200: hash_type = HASH_TYPE_MYSQL;
7263 salt_type = SALT_TYPE_NONE;
7264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7265 opts_type = 0;
7266 kern_type = KERN_TYPE_MYSQL;
7267 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7268 parse_func = mysql323_parse_hash;
7269 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7270 opti_type = OPTI_TYPE_ZERO_BYTE;
7271 dgst_pos0 = 0;
7272 dgst_pos1 = 1;
7273 dgst_pos2 = 2;
7274 dgst_pos3 = 3;
7275 break;
7276
7277 case 300: hash_type = HASH_TYPE_SHA1;
7278 salt_type = SALT_TYPE_NONE;
7279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7280 opts_type = OPTS_TYPE_PT_GENERATE_BE
7281 | OPTS_TYPE_PT_ADD80
7282 | OPTS_TYPE_PT_ADDBITS15;
7283 kern_type = KERN_TYPE_MYSQL41;
7284 dgst_size = DGST_SIZE_4_5;
7285 parse_func = sha1_parse_hash;
7286 sort_by_digest = sort_by_digest_4_5;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_NOT_SALTED;
7293 dgst_pos0 = 3;
7294 dgst_pos1 = 4;
7295 dgst_pos2 = 2;
7296 dgst_pos3 = 1;
7297 break;
7298
7299 case 400: hash_type = HASH_TYPE_MD5;
7300 salt_type = SALT_TYPE_EMBEDDED;
7301 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7302 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7303 kern_type = KERN_TYPE_PHPASS;
7304 dgst_size = DGST_SIZE_4_4;
7305 parse_func = phpass_parse_hash;
7306 sort_by_digest = sort_by_digest_4_4;
7307 opti_type = OPTI_TYPE_ZERO_BYTE;
7308 dgst_pos0 = 0;
7309 dgst_pos1 = 1;
7310 dgst_pos2 = 2;
7311 dgst_pos3 = 3;
7312 break;
7313
7314 case 500: hash_type = HASH_TYPE_MD5;
7315 salt_type = SALT_TYPE_EMBEDDED;
7316 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7317 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7318 kern_type = KERN_TYPE_MD5CRYPT;
7319 dgst_size = DGST_SIZE_4_4;
7320 parse_func = md5crypt_parse_hash;
7321 sort_by_digest = sort_by_digest_4_4;
7322 opti_type = OPTI_TYPE_ZERO_BYTE;
7323 dgst_pos0 = 0;
7324 dgst_pos1 = 1;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 3;
7327 break;
7328
7329 case 501: hash_type = HASH_TYPE_MD5;
7330 salt_type = SALT_TYPE_EMBEDDED;
7331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_LE
7333 | OPTS_TYPE_HASH_COPY;
7334 kern_type = KERN_TYPE_MD5CRYPT;
7335 dgst_size = DGST_SIZE_4_4;
7336 parse_func = juniper_parse_hash;
7337 sort_by_digest = sort_by_digest_4_4;
7338 opti_type = OPTI_TYPE_ZERO_BYTE;
7339 dgst_pos0 = 0;
7340 dgst_pos1 = 1;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 3;
7343 break;
7344
7345 case 900: hash_type = HASH_TYPE_MD4;
7346 salt_type = SALT_TYPE_NONE;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_LE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS14;
7351 kern_type = KERN_TYPE_MD4;
7352 dgst_size = DGST_SIZE_4_4;
7353 parse_func = md4_parse_hash;
7354 sort_by_digest = sort_by_digest_4_4;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_MEET_IN_MIDDLE
7359 | OPTI_TYPE_EARLY_SKIP
7360 | OPTI_TYPE_NOT_ITERATED
7361 | OPTI_TYPE_NOT_SALTED
7362 | OPTI_TYPE_RAW_HASH;
7363 dgst_pos0 = 0;
7364 dgst_pos1 = 3;
7365 dgst_pos2 = 2;
7366 dgst_pos3 = 1;
7367 break;
7368
7369 case 1000: hash_type = HASH_TYPE_MD4;
7370 salt_type = SALT_TYPE_NONE;
7371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7372 opts_type = OPTS_TYPE_PT_GENERATE_LE
7373 | OPTS_TYPE_PT_ADD80
7374 | OPTS_TYPE_PT_ADDBITS14
7375 | OPTS_TYPE_PT_UNICODE;
7376 kern_type = KERN_TYPE_MD4_PWU;
7377 dgst_size = DGST_SIZE_4_4;
7378 parse_func = md4_parse_hash;
7379 sort_by_digest = sort_by_digest_4_4;
7380 opti_type = OPTI_TYPE_ZERO_BYTE
7381 | OPTI_TYPE_PRECOMPUTE_INIT
7382 | OPTI_TYPE_PRECOMPUTE_MERKLE
7383 | OPTI_TYPE_MEET_IN_MIDDLE
7384 | OPTI_TYPE_EARLY_SKIP
7385 | OPTI_TYPE_NOT_ITERATED
7386 | OPTI_TYPE_NOT_SALTED
7387 | OPTI_TYPE_RAW_HASH;
7388 dgst_pos0 = 0;
7389 dgst_pos1 = 3;
7390 dgst_pos2 = 2;
7391 dgst_pos3 = 1;
7392 break;
7393
7394 case 1100: hash_type = HASH_TYPE_MD4;
7395 salt_type = SALT_TYPE_INTERN;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_LE
7398 | OPTS_TYPE_PT_ADD80
7399 | OPTS_TYPE_PT_ADDBITS14
7400 | OPTS_TYPE_PT_UNICODE
7401 | OPTS_TYPE_ST_ADD80
7402 | OPTS_TYPE_ST_UNICODE
7403 | OPTS_TYPE_ST_LOWER;
7404 kern_type = KERN_TYPE_MD44_PWUSLT;
7405 dgst_size = DGST_SIZE_4_4;
7406 parse_func = dcc_parse_hash;
7407 sort_by_digest = sort_by_digest_4_4;
7408 opti_type = OPTI_TYPE_ZERO_BYTE
7409 | OPTI_TYPE_PRECOMPUTE_INIT
7410 | OPTI_TYPE_PRECOMPUTE_MERKLE
7411 | OPTI_TYPE_EARLY_SKIP
7412 | OPTI_TYPE_NOT_ITERATED;
7413 dgst_pos0 = 0;
7414 dgst_pos1 = 3;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 1;
7417 break;
7418
7419 case 1400: hash_type = HASH_TYPE_SHA256;
7420 salt_type = SALT_TYPE_NONE;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_PT_ADD80
7424 | OPTS_TYPE_PT_ADDBITS15;
7425 kern_type = KERN_TYPE_SHA256;
7426 dgst_size = DGST_SIZE_4_8;
7427 parse_func = sha256_parse_hash;
7428 sort_by_digest = sort_by_digest_4_8;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_NOT_SALTED
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 7;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 6;
7440 break;
7441
7442 case 1410: hash_type = HASH_TYPE_SHA256;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_ST_ADD80
7447 | OPTS_TYPE_ST_ADDBITS15;
7448 kern_type = KERN_TYPE_SHA256_PWSLT;
7449 dgst_size = DGST_SIZE_4_8;
7450 parse_func = sha256s_parse_hash;
7451 sort_by_digest = sort_by_digest_4_8;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_EARLY_SKIP
7456 | OPTI_TYPE_NOT_ITERATED
7457 | OPTI_TYPE_APPENDED_SALT
7458 | OPTI_TYPE_RAW_HASH;
7459 dgst_pos0 = 3;
7460 dgst_pos1 = 7;
7461 dgst_pos2 = 2;
7462 dgst_pos3 = 6;
7463 break;
7464
7465 case 1420: hash_type = HASH_TYPE_SHA256;
7466 salt_type = SALT_TYPE_INTERN;
7467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7468 opts_type = OPTS_TYPE_PT_GENERATE_BE
7469 | OPTS_TYPE_PT_ADD80
7470 | OPTS_TYPE_PT_ADDBITS15;
7471 kern_type = KERN_TYPE_SHA256_SLTPW;
7472 dgst_size = DGST_SIZE_4_8;
7473 parse_func = sha256s_parse_hash;
7474 sort_by_digest = sort_by_digest_4_8;
7475 opti_type = OPTI_TYPE_ZERO_BYTE
7476 | OPTI_TYPE_PRECOMPUTE_INIT
7477 | OPTI_TYPE_PRECOMPUTE_MERKLE
7478 | OPTI_TYPE_EARLY_SKIP
7479 | OPTI_TYPE_NOT_ITERATED
7480 | OPTI_TYPE_PREPENDED_SALT
7481 | OPTI_TYPE_RAW_HASH;
7482 dgst_pos0 = 3;
7483 dgst_pos1 = 7;
7484 dgst_pos2 = 2;
7485 dgst_pos3 = 6;
7486 break;
7487
7488 case 1421: hash_type = HASH_TYPE_SHA256;
7489 salt_type = SALT_TYPE_EMBEDDED;
7490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7491 opts_type = OPTS_TYPE_PT_GENERATE_BE
7492 | OPTS_TYPE_PT_ADD80
7493 | OPTS_TYPE_PT_ADDBITS15;
7494 kern_type = KERN_TYPE_SHA256_SLTPW;
7495 dgst_size = DGST_SIZE_4_8;
7496 parse_func = hmailserver_parse_hash;
7497 sort_by_digest = sort_by_digest_4_8;
7498 opti_type = OPTI_TYPE_ZERO_BYTE
7499 | OPTI_TYPE_PRECOMPUTE_INIT
7500 | OPTI_TYPE_PRECOMPUTE_MERKLE
7501 | OPTI_TYPE_EARLY_SKIP
7502 | OPTI_TYPE_NOT_ITERATED
7503 | OPTI_TYPE_PREPENDED_SALT
7504 | OPTI_TYPE_RAW_HASH;
7505 dgst_pos0 = 3;
7506 dgst_pos1 = 7;
7507 dgst_pos2 = 2;
7508 dgst_pos3 = 6;
7509 break;
7510
7511 case 1430: hash_type = HASH_TYPE_SHA256;
7512 salt_type = SALT_TYPE_INTERN;
7513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7514 opts_type = OPTS_TYPE_PT_GENERATE_BE
7515 | OPTS_TYPE_PT_UNICODE
7516 | OPTS_TYPE_ST_ADD80
7517 | OPTS_TYPE_ST_ADDBITS15;
7518 kern_type = KERN_TYPE_SHA256_PWUSLT;
7519 dgst_size = DGST_SIZE_4_8;
7520 parse_func = sha256s_parse_hash;
7521 sort_by_digest = sort_by_digest_4_8;
7522 opti_type = OPTI_TYPE_ZERO_BYTE
7523 | OPTI_TYPE_PRECOMPUTE_INIT
7524 | OPTI_TYPE_PRECOMPUTE_MERKLE
7525 | OPTI_TYPE_EARLY_SKIP
7526 | OPTI_TYPE_NOT_ITERATED
7527 | OPTI_TYPE_APPENDED_SALT
7528 | OPTI_TYPE_RAW_HASH;
7529 dgst_pos0 = 3;
7530 dgst_pos1 = 7;
7531 dgst_pos2 = 2;
7532 dgst_pos3 = 6;
7533 break;
7534
7535 case 1440: hash_type = HASH_TYPE_SHA256;
7536 salt_type = SALT_TYPE_INTERN;
7537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7538 opts_type = OPTS_TYPE_PT_GENERATE_BE
7539 | OPTS_TYPE_PT_ADD80
7540 | OPTS_TYPE_PT_ADDBITS15
7541 | OPTS_TYPE_PT_UNICODE;
7542 kern_type = KERN_TYPE_SHA256_SLTPWU;
7543 dgst_size = DGST_SIZE_4_8;
7544 parse_func = sha256s_parse_hash;
7545 sort_by_digest = sort_by_digest_4_8;
7546 opti_type = OPTI_TYPE_ZERO_BYTE
7547 | OPTI_TYPE_PRECOMPUTE_INIT
7548 | OPTI_TYPE_PRECOMPUTE_MERKLE
7549 | OPTI_TYPE_EARLY_SKIP
7550 | OPTI_TYPE_NOT_ITERATED
7551 | OPTI_TYPE_PREPENDED_SALT
7552 | OPTI_TYPE_RAW_HASH;
7553 dgst_pos0 = 3;
7554 dgst_pos1 = 7;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 6;
7557 break;
7558
7559 case 1441: hash_type = HASH_TYPE_SHA256;
7560 salt_type = SALT_TYPE_EMBEDDED;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS15
7565 | OPTS_TYPE_PT_UNICODE
7566 | OPTS_TYPE_ST_BASE64;
7567 kern_type = KERN_TYPE_SHA256_SLTPWU;
7568 dgst_size = DGST_SIZE_4_8;
7569 parse_func = episerver4_parse_hash;
7570 sort_by_digest = sort_by_digest_4_8;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_PREPENDED_SALT
7577 | OPTI_TYPE_RAW_HASH;
7578 dgst_pos0 = 3;
7579 dgst_pos1 = 7;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 6;
7582 break;
7583
7584 case 1450: hash_type = HASH_TYPE_SHA256;
7585 salt_type = SALT_TYPE_INTERN;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_BE
7588 | OPTS_TYPE_ST_ADD80;
7589 kern_type = KERN_TYPE_HMACSHA256_PW;
7590 dgst_size = DGST_SIZE_4_8;
7591 parse_func = hmacsha256_parse_hash;
7592 sort_by_digest = sort_by_digest_4_8;
7593 opti_type = OPTI_TYPE_ZERO_BYTE
7594 | OPTI_TYPE_NOT_ITERATED;
7595 dgst_pos0 = 3;
7596 dgst_pos1 = 7;
7597 dgst_pos2 = 2;
7598 dgst_pos3 = 6;
7599 break;
7600
7601 case 1460: hash_type = HASH_TYPE_SHA256;
7602 salt_type = SALT_TYPE_INTERN;
7603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7604 opts_type = OPTS_TYPE_PT_GENERATE_BE
7605 | OPTS_TYPE_PT_ADD80
7606 | OPTS_TYPE_PT_ADDBITS15;
7607 kern_type = KERN_TYPE_HMACSHA256_SLT;
7608 dgst_size = DGST_SIZE_4_8;
7609 parse_func = hmacsha256_parse_hash;
7610 sort_by_digest = sort_by_digest_4_8;
7611 opti_type = OPTI_TYPE_ZERO_BYTE
7612 | OPTI_TYPE_NOT_ITERATED;
7613 dgst_pos0 = 3;
7614 dgst_pos1 = 7;
7615 dgst_pos2 = 2;
7616 dgst_pos3 = 6;
7617 break;
7618
7619 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7620 salt_type = SALT_TYPE_EMBEDDED;
7621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7622 opts_type = OPTS_TYPE_PT_GENERATE_LE
7623 | OPTS_TYPE_PT_BITSLICE;
7624 kern_type = KERN_TYPE_DESCRYPT;
7625 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7626 parse_func = descrypt_parse_hash;
7627 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7628 opti_type = OPTI_TYPE_ZERO_BYTE
7629 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7630 dgst_pos0 = 0;
7631 dgst_pos1 = 1;
7632 dgst_pos2 = 2;
7633 dgst_pos3 = 3;
7634 break;
7635
7636 case 1600: hash_type = HASH_TYPE_MD5;
7637 salt_type = SALT_TYPE_EMBEDDED;
7638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7640 kern_type = KERN_TYPE_APR1CRYPT;
7641 dgst_size = DGST_SIZE_4_4;
7642 parse_func = md5apr1_parse_hash;
7643 sort_by_digest = sort_by_digest_4_4;
7644 opti_type = OPTI_TYPE_ZERO_BYTE;
7645 dgst_pos0 = 0;
7646 dgst_pos1 = 1;
7647 dgst_pos2 = 2;
7648 dgst_pos3 = 3;
7649 break;
7650
7651 case 1700: hash_type = HASH_TYPE_SHA512;
7652 salt_type = SALT_TYPE_NONE;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_PT_ADD80
7656 | OPTS_TYPE_PT_ADDBITS15;
7657 kern_type = KERN_TYPE_SHA512;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = sha512_parse_hash;
7660 sort_by_digest = sort_by_digest_8_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_NOT_SALTED
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 14;
7669 dgst_pos1 = 15;
7670 dgst_pos2 = 6;
7671 dgst_pos3 = 7;
7672 break;
7673
7674 case 1710: hash_type = HASH_TYPE_SHA512;
7675 salt_type = SALT_TYPE_INTERN;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_ST_ADD80
7679 | OPTS_TYPE_ST_ADDBITS15;
7680 kern_type = KERN_TYPE_SHA512_PWSLT;
7681 dgst_size = DGST_SIZE_8_8;
7682 parse_func = sha512s_parse_hash;
7683 sort_by_digest = sort_by_digest_8_8;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED
7689 | OPTI_TYPE_APPENDED_SALT
7690 | OPTI_TYPE_RAW_HASH;
7691 dgst_pos0 = 14;
7692 dgst_pos1 = 15;
7693 dgst_pos2 = 6;
7694 dgst_pos3 = 7;
7695 break;
7696
7697 case 1711: hash_type = HASH_TYPE_SHA512;
7698 salt_type = SALT_TYPE_EMBEDDED;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_ST_ADD80
7702 | OPTS_TYPE_ST_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA512_PWSLT;
7704 dgst_size = DGST_SIZE_8_8;
7705 parse_func = sha512b64s_parse_hash;
7706 sort_by_digest = sort_by_digest_8_8;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_APPENDED_SALT
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 14;
7715 dgst_pos1 = 15;
7716 dgst_pos2 = 6;
7717 dgst_pos3 = 7;
7718 break;
7719
7720 case 1720: hash_type = HASH_TYPE_SHA512;
7721 salt_type = SALT_TYPE_INTERN;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_PT_ADD80
7725 | OPTS_TYPE_PT_ADDBITS15;
7726 kern_type = KERN_TYPE_SHA512_SLTPW;
7727 dgst_size = DGST_SIZE_8_8;
7728 parse_func = sha512s_parse_hash;
7729 sort_by_digest = sort_by_digest_8_8;
7730 opti_type = OPTI_TYPE_ZERO_BYTE
7731 | OPTI_TYPE_PRECOMPUTE_INIT
7732 | OPTI_TYPE_PRECOMPUTE_MERKLE
7733 | OPTI_TYPE_EARLY_SKIP
7734 | OPTI_TYPE_NOT_ITERATED
7735 | OPTI_TYPE_PREPENDED_SALT
7736 | OPTI_TYPE_RAW_HASH;
7737 dgst_pos0 = 14;
7738 dgst_pos1 = 15;
7739 dgst_pos2 = 6;
7740 dgst_pos3 = 7;
7741 break;
7742
7743 case 1722: hash_type = HASH_TYPE_SHA512;
7744 salt_type = SALT_TYPE_EMBEDDED;
7745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7746 opts_type = OPTS_TYPE_PT_GENERATE_BE
7747 | OPTS_TYPE_PT_ADD80
7748 | OPTS_TYPE_PT_ADDBITS15
7749 | OPTS_TYPE_ST_HEX;
7750 kern_type = KERN_TYPE_SHA512_SLTPW;
7751 dgst_size = DGST_SIZE_8_8;
7752 parse_func = osx512_parse_hash;
7753 sort_by_digest = sort_by_digest_8_8;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_PRECOMPUTE_INIT
7756 | OPTI_TYPE_PRECOMPUTE_MERKLE
7757 | OPTI_TYPE_EARLY_SKIP
7758 | OPTI_TYPE_NOT_ITERATED
7759 | OPTI_TYPE_PREPENDED_SALT
7760 | OPTI_TYPE_RAW_HASH;
7761 dgst_pos0 = 14;
7762 dgst_pos1 = 15;
7763 dgst_pos2 = 6;
7764 dgst_pos3 = 7;
7765 break;
7766
7767 case 1730: hash_type = HASH_TYPE_SHA512;
7768 salt_type = SALT_TYPE_INTERN;
7769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7770 opts_type = OPTS_TYPE_PT_GENERATE_BE
7771 | OPTS_TYPE_PT_UNICODE
7772 | OPTS_TYPE_ST_ADD80
7773 | OPTS_TYPE_ST_ADDBITS15;
7774 kern_type = KERN_TYPE_SHA512_PWSLTU;
7775 dgst_size = DGST_SIZE_8_8;
7776 parse_func = sha512s_parse_hash;
7777 sort_by_digest = sort_by_digest_8_8;
7778 opti_type = OPTI_TYPE_ZERO_BYTE
7779 | OPTI_TYPE_PRECOMPUTE_INIT
7780 | OPTI_TYPE_PRECOMPUTE_MERKLE
7781 | OPTI_TYPE_EARLY_SKIP
7782 | OPTI_TYPE_NOT_ITERATED
7783 | OPTI_TYPE_APPENDED_SALT
7784 | OPTI_TYPE_RAW_HASH;
7785 dgst_pos0 = 14;
7786 dgst_pos1 = 15;
7787 dgst_pos2 = 6;
7788 dgst_pos3 = 7;
7789 break;
7790
7791 case 1731: hash_type = HASH_TYPE_SHA512;
7792 salt_type = SALT_TYPE_EMBEDDED;
7793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7794 opts_type = OPTS_TYPE_PT_GENERATE_BE
7795 | OPTS_TYPE_PT_UNICODE
7796 | OPTS_TYPE_ST_ADD80
7797 | OPTS_TYPE_ST_ADDBITS15
7798 | OPTS_TYPE_ST_HEX;
7799 kern_type = KERN_TYPE_SHA512_PWSLTU;
7800 dgst_size = DGST_SIZE_8_8;
7801 parse_func = mssql2012_parse_hash;
7802 sort_by_digest = sort_by_digest_8_8;
7803 opti_type = OPTI_TYPE_ZERO_BYTE
7804 | OPTI_TYPE_PRECOMPUTE_INIT
7805 | OPTI_TYPE_PRECOMPUTE_MERKLE
7806 | OPTI_TYPE_EARLY_SKIP
7807 | OPTI_TYPE_NOT_ITERATED
7808 | OPTI_TYPE_APPENDED_SALT
7809 | OPTI_TYPE_RAW_HASH;
7810 dgst_pos0 = 14;
7811 dgst_pos1 = 15;
7812 dgst_pos2 = 6;
7813 dgst_pos3 = 7;
7814 break;
7815
7816 case 1740: hash_type = HASH_TYPE_SHA512;
7817 salt_type = SALT_TYPE_INTERN;
7818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_PT_ADD80
7821 | OPTS_TYPE_PT_ADDBITS15
7822 | OPTS_TYPE_PT_UNICODE;
7823 kern_type = KERN_TYPE_SHA512_SLTPWU;
7824 dgst_size = DGST_SIZE_8_8;
7825 parse_func = sha512s_parse_hash;
7826 sort_by_digest = sort_by_digest_8_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_PREPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 14;
7835 dgst_pos1 = 15;
7836 dgst_pos2 = 6;
7837 dgst_pos3 = 7;
7838 break;
7839
7840 case 1750: hash_type = HASH_TYPE_SHA512;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_ST_ADD80;
7845 kern_type = KERN_TYPE_HMACSHA512_PW;
7846 dgst_size = DGST_SIZE_8_8;
7847 parse_func = hmacsha512_parse_hash;
7848 sort_by_digest = sort_by_digest_8_8;
7849 opti_type = OPTI_TYPE_ZERO_BYTE
7850 | OPTI_TYPE_NOT_ITERATED;
7851 dgst_pos0 = 14;
7852 dgst_pos1 = 15;
7853 dgst_pos2 = 6;
7854 dgst_pos3 = 7;
7855 break;
7856
7857 case 1760: hash_type = HASH_TYPE_SHA512;
7858 salt_type = SALT_TYPE_INTERN;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_BE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS15;
7863 kern_type = KERN_TYPE_HMACSHA512_SLT;
7864 dgst_size = DGST_SIZE_8_8;
7865 parse_func = hmacsha512_parse_hash;
7866 sort_by_digest = sort_by_digest_8_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_NOT_ITERATED;
7869 dgst_pos0 = 14;
7870 dgst_pos1 = 15;
7871 dgst_pos2 = 6;
7872 dgst_pos3 = 7;
7873 break;
7874
7875 case 1800: hash_type = HASH_TYPE_SHA512;
7876 salt_type = SALT_TYPE_EMBEDDED;
7877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7879 kern_type = KERN_TYPE_SHA512CRYPT;
7880 dgst_size = DGST_SIZE_8_8;
7881 parse_func = sha512crypt_parse_hash;
7882 sort_by_digest = sort_by_digest_8_8;
7883 opti_type = OPTI_TYPE_ZERO_BYTE;
7884 dgst_pos0 = 0;
7885 dgst_pos1 = 1;
7886 dgst_pos2 = 2;
7887 dgst_pos3 = 3;
7888 break;
7889
7890 case 2100: hash_type = HASH_TYPE_DCC2;
7891 salt_type = SALT_TYPE_EMBEDDED;
7892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7893 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7894 | OPTS_TYPE_ST_LOWER
7895 | OPTS_TYPE_ST_UNICODE;
7896 kern_type = KERN_TYPE_DCC2;
7897 dgst_size = DGST_SIZE_4_4;
7898 parse_func = dcc2_parse_hash;
7899 sort_by_digest = sort_by_digest_4_4;
7900 opti_type = OPTI_TYPE_ZERO_BYTE;
7901 dgst_pos0 = 0;
7902 dgst_pos1 = 1;
7903 dgst_pos2 = 2;
7904 dgst_pos3 = 3;
7905 break;
7906
7907 case 2400: hash_type = HASH_TYPE_MD5;
7908 salt_type = SALT_TYPE_NONE;
7909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7911 kern_type = KERN_TYPE_MD5PIX;
7912 dgst_size = DGST_SIZE_4_4;
7913 parse_func = md5pix_parse_hash;
7914 sort_by_digest = sort_by_digest_4_4;
7915 opti_type = OPTI_TYPE_ZERO_BYTE
7916 | OPTI_TYPE_PRECOMPUTE_INIT
7917 | OPTI_TYPE_PRECOMPUTE_MERKLE
7918 | OPTI_TYPE_EARLY_SKIP
7919 | OPTI_TYPE_NOT_ITERATED
7920 | OPTI_TYPE_NOT_SALTED;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 3;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 1;
7925 break;
7926
7927 case 2410: hash_type = HASH_TYPE_MD5;
7928 salt_type = SALT_TYPE_INTERN;
7929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7931 kern_type = KERN_TYPE_MD5ASA;
7932 dgst_size = DGST_SIZE_4_4;
7933 parse_func = md5asa_parse_hash;
7934 sort_by_digest = sort_by_digest_4_4;
7935 opti_type = OPTI_TYPE_ZERO_BYTE
7936 | OPTI_TYPE_PRECOMPUTE_INIT
7937 | OPTI_TYPE_PRECOMPUTE_MERKLE
7938 | OPTI_TYPE_EARLY_SKIP
7939 | OPTI_TYPE_NOT_ITERATED;
7940 dgst_pos0 = 0;
7941 dgst_pos1 = 3;
7942 dgst_pos2 = 2;
7943 dgst_pos3 = 1;
7944 break;
7945
7946 case 2500: hash_type = HASH_TYPE_WPA;
7947 salt_type = SALT_TYPE_EMBEDDED;
7948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7950 kern_type = KERN_TYPE_WPA;
7951 dgst_size = DGST_SIZE_4_4;
7952 parse_func = wpa_parse_hash;
7953 sort_by_digest = sort_by_digest_4_4;
7954 opti_type = OPTI_TYPE_ZERO_BYTE;
7955 dgst_pos0 = 0;
7956 dgst_pos1 = 1;
7957 dgst_pos2 = 2;
7958 dgst_pos3 = 3;
7959 break;
7960
7961 case 2600: hash_type = HASH_TYPE_MD5;
7962 salt_type = SALT_TYPE_VIRTUAL;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_LE
7965 | OPTS_TYPE_PT_ADD80
7966 | OPTS_TYPE_PT_ADDBITS14
7967 | OPTS_TYPE_ST_ADD80;
7968 kern_type = KERN_TYPE_MD55_PWSLT1;
7969 dgst_size = DGST_SIZE_4_4;
7970 parse_func = md5md5_parse_hash;
7971 sort_by_digest = sort_by_digest_4_4;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP;
7976 dgst_pos0 = 0;
7977 dgst_pos1 = 3;
7978 dgst_pos2 = 2;
7979 dgst_pos3 = 1;
7980 break;
7981
7982 case 2611: hash_type = HASH_TYPE_MD5;
7983 salt_type = SALT_TYPE_INTERN;
7984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7985 opts_type = OPTS_TYPE_PT_GENERATE_LE
7986 | OPTS_TYPE_PT_ADD80
7987 | OPTS_TYPE_PT_ADDBITS14
7988 | OPTS_TYPE_ST_ADD80;
7989 kern_type = KERN_TYPE_MD55_PWSLT1;
7990 dgst_size = DGST_SIZE_4_4;
7991 parse_func = vb3_parse_hash;
7992 sort_by_digest = sort_by_digest_4_4;
7993 opti_type = OPTI_TYPE_ZERO_BYTE
7994 | OPTI_TYPE_PRECOMPUTE_INIT
7995 | OPTI_TYPE_PRECOMPUTE_MERKLE
7996 | OPTI_TYPE_EARLY_SKIP;
7997 dgst_pos0 = 0;
7998 dgst_pos1 = 3;
7999 dgst_pos2 = 2;
8000 dgst_pos3 = 1;
8001 break;
8002
8003 case 2612: hash_type = HASH_TYPE_MD5;
8004 salt_type = SALT_TYPE_EMBEDDED;
8005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8006 opts_type = OPTS_TYPE_PT_GENERATE_LE
8007 | OPTS_TYPE_PT_ADD80
8008 | OPTS_TYPE_PT_ADDBITS14
8009 | OPTS_TYPE_ST_ADD80
8010 | OPTS_TYPE_ST_HEX;
8011 kern_type = KERN_TYPE_MD55_PWSLT1;
8012 dgst_size = DGST_SIZE_4_4;
8013 parse_func = phps_parse_hash;
8014 sort_by_digest = sort_by_digest_4_4;
8015 opti_type = OPTI_TYPE_ZERO_BYTE
8016 | OPTI_TYPE_PRECOMPUTE_INIT
8017 | OPTI_TYPE_PRECOMPUTE_MERKLE
8018 | OPTI_TYPE_EARLY_SKIP;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 3;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 1;
8023 break;
8024
8025 case 2711: hash_type = HASH_TYPE_MD5;
8026 salt_type = SALT_TYPE_INTERN;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_LE
8029 | OPTS_TYPE_PT_ADD80
8030 | OPTS_TYPE_PT_ADDBITS14
8031 | OPTS_TYPE_ST_ADD80;
8032 kern_type = KERN_TYPE_MD55_PWSLT2;
8033 dgst_size = DGST_SIZE_4_4;
8034 parse_func = vb30_parse_hash;
8035 sort_by_digest = sort_by_digest_4_4;
8036 opti_type = OPTI_TYPE_ZERO_BYTE
8037 | OPTI_TYPE_PRECOMPUTE_INIT
8038 | OPTI_TYPE_EARLY_SKIP;
8039 dgst_pos0 = 0;
8040 dgst_pos1 = 3;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 1;
8043 break;
8044
8045 case 2811: hash_type = HASH_TYPE_MD5;
8046 salt_type = SALT_TYPE_INTERN;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_LE
8049 | OPTS_TYPE_PT_ADD80
8050 | OPTS_TYPE_PT_ADDBITS14;
8051 kern_type = KERN_TYPE_MD55_SLTPW;
8052 dgst_size = DGST_SIZE_4_4;
8053 parse_func = ipb2_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_EARLY_SKIP;
8058 dgst_pos0 = 0;
8059 dgst_pos1 = 3;
8060 dgst_pos2 = 2;
8061 dgst_pos3 = 1;
8062 break;
8063
8064 case 3000: hash_type = HASH_TYPE_LM;
8065 salt_type = SALT_TYPE_NONE;
8066 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8067 opts_type = OPTS_TYPE_PT_GENERATE_LE
8068 | OPTS_TYPE_PT_UPPER
8069 | OPTS_TYPE_PT_BITSLICE;
8070 kern_type = KERN_TYPE_LM;
8071 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8072 parse_func = lm_parse_hash;
8073 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8076 dgst_pos0 = 0;
8077 dgst_pos1 = 1;
8078 dgst_pos2 = 2;
8079 dgst_pos3 = 3;
8080 break;
8081
8082 case 3100: hash_type = HASH_TYPE_ORACLEH;
8083 salt_type = SALT_TYPE_INTERN;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_LE
8086 | OPTS_TYPE_PT_UPPER
8087 | OPTS_TYPE_ST_UPPER;
8088 kern_type = KERN_TYPE_ORACLEH;
8089 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8090 parse_func = oracleh_parse_hash;
8091 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8092 opti_type = OPTI_TYPE_ZERO_BYTE;
8093 dgst_pos0 = 0;
8094 dgst_pos1 = 1;
8095 dgst_pos2 = 2;
8096 dgst_pos3 = 3;
8097 break;
8098
8099 case 3200: hash_type = HASH_TYPE_BCRYPT;
8100 salt_type = SALT_TYPE_EMBEDDED;
8101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_LE
8103 | OPTS_TYPE_ST_GENERATE_LE;
8104 kern_type = KERN_TYPE_BCRYPT;
8105 dgst_size = DGST_SIZE_4_6;
8106 parse_func = bcrypt_parse_hash;
8107 sort_by_digest = sort_by_digest_4_6;
8108 opti_type = OPTI_TYPE_ZERO_BYTE;
8109 dgst_pos0 = 0;
8110 dgst_pos1 = 1;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 3;
8113 break;
8114
8115 case 3710: hash_type = HASH_TYPE_MD5;
8116 salt_type = SALT_TYPE_INTERN;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_LE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS14;
8121 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8122 dgst_size = DGST_SIZE_4_4;
8123 parse_func = md5s_parse_hash;
8124 sort_by_digest = sort_by_digest_4_4;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_PRECOMPUTE_INIT
8127 | OPTI_TYPE_PRECOMPUTE_MERKLE
8128 | OPTI_TYPE_EARLY_SKIP;
8129 dgst_pos0 = 0;
8130 dgst_pos1 = 3;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 1;
8133 break;
8134
8135 case 3711: hash_type = HASH_TYPE_MD5;
8136 salt_type = SALT_TYPE_EMBEDDED;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_LE
8139 | OPTS_TYPE_PT_ADD80
8140 | OPTS_TYPE_PT_ADDBITS14;
8141 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8142 dgst_size = DGST_SIZE_4_4;
8143 parse_func = mediawiki_b_parse_hash;
8144 sort_by_digest = sort_by_digest_4_4;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP;
8149 dgst_pos0 = 0;
8150 dgst_pos1 = 3;
8151 dgst_pos2 = 2;
8152 dgst_pos3 = 1;
8153 break;
8154
8155 case 3800: hash_type = HASH_TYPE_MD5;
8156 salt_type = SALT_TYPE_INTERN;
8157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_LE
8159 | OPTS_TYPE_ST_ADDBITS14;
8160 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md5s_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_EARLY_SKIP
8168 | OPTI_TYPE_NOT_ITERATED
8169 | OPTI_TYPE_RAW_HASH;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 3;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 4300: hash_type = HASH_TYPE_MD5;
8177 salt_type = SALT_TYPE_VIRTUAL;
8178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE
8180 | OPTS_TYPE_PT_ADD80
8181 | OPTS_TYPE_PT_ADDBITS14
8182 | OPTS_TYPE_ST_ADD80;
8183 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8184 dgst_size = DGST_SIZE_4_4;
8185 parse_func = md5md5_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
8198 case 4400: hash_type = HASH_TYPE_MD5;
8199 salt_type = SALT_TYPE_NONE;
8200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_BE
8202 | OPTS_TYPE_PT_ADD80
8203 | OPTS_TYPE_PT_ADDBITS15;
8204 kern_type = KERN_TYPE_MD5_SHA1;
8205 dgst_size = DGST_SIZE_4_4;
8206 parse_func = md5_parse_hash;
8207 sort_by_digest = sort_by_digest_4_4;
8208 opti_type = OPTI_TYPE_ZERO_BYTE
8209 | OPTI_TYPE_PRECOMPUTE_INIT
8210 | OPTI_TYPE_PRECOMPUTE_MERKLE
8211 | OPTI_TYPE_EARLY_SKIP
8212 | OPTI_TYPE_NOT_ITERATED
8213 | OPTI_TYPE_NOT_SALTED
8214 | OPTI_TYPE_RAW_HASH;
8215 dgst_pos0 = 0;
8216 dgst_pos1 = 3;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 1;
8219 break;
8220
8221 case 4500: hash_type = HASH_TYPE_SHA1;
8222 salt_type = SALT_TYPE_NONE;
8223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_BE
8225 | OPTS_TYPE_PT_ADD80
8226 | OPTS_TYPE_PT_ADDBITS15;
8227 kern_type = KERN_TYPE_SHA11;
8228 dgst_size = DGST_SIZE_4_5;
8229 parse_func = sha1_parse_hash;
8230 sort_by_digest = sort_by_digest_4_5;
8231 opti_type = OPTI_TYPE_ZERO_BYTE
8232 | OPTI_TYPE_PRECOMPUTE_INIT
8233 | OPTI_TYPE_PRECOMPUTE_MERKLE
8234 | OPTI_TYPE_EARLY_SKIP
8235 | OPTI_TYPE_NOT_SALTED;
8236 dgst_pos0 = 3;
8237 dgst_pos1 = 4;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 1;
8240 break;
8241
8242 case 4700: hash_type = HASH_TYPE_SHA1;
8243 salt_type = SALT_TYPE_NONE;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE
8246 | OPTS_TYPE_PT_ADD80
8247 | OPTS_TYPE_PT_ADDBITS14;
8248 kern_type = KERN_TYPE_SHA1_MD5;
8249 dgst_size = DGST_SIZE_4_5;
8250 parse_func = sha1_parse_hash;
8251 sort_by_digest = sort_by_digest_4_5;
8252 opti_type = OPTI_TYPE_ZERO_BYTE
8253 | OPTI_TYPE_PRECOMPUTE_INIT
8254 | OPTI_TYPE_PRECOMPUTE_MERKLE
8255 | OPTI_TYPE_EARLY_SKIP
8256 | OPTI_TYPE_NOT_ITERATED
8257 | OPTI_TYPE_NOT_SALTED
8258 | OPTI_TYPE_RAW_HASH;
8259 dgst_pos0 = 3;
8260 dgst_pos1 = 4;
8261 dgst_pos2 = 2;
8262 dgst_pos3 = 1;
8263 break;
8264
8265 case 4800: hash_type = HASH_TYPE_MD5;
8266 salt_type = SALT_TYPE_EMBEDDED;
8267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8268 opts_type = OPTS_TYPE_PT_GENERATE_LE
8269 | OPTS_TYPE_PT_ADDBITS14;
8270 kern_type = KERN_TYPE_MD5_CHAP;
8271 dgst_size = DGST_SIZE_4_4;
8272 parse_func = chap_parse_hash;
8273 sort_by_digest = sort_by_digest_4_4;
8274 opti_type = OPTI_TYPE_ZERO_BYTE
8275 | OPTI_TYPE_PRECOMPUTE_INIT
8276 | OPTI_TYPE_PRECOMPUTE_MERKLE
8277 | OPTI_TYPE_MEET_IN_MIDDLE
8278 | OPTI_TYPE_EARLY_SKIP
8279 | OPTI_TYPE_NOT_ITERATED
8280 | OPTI_TYPE_RAW_HASH;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 3;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 1;
8285 break;
8286
8287 case 4900: hash_type = HASH_TYPE_SHA1;
8288 salt_type = SALT_TYPE_INTERN;
8289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8291 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8292 dgst_size = DGST_SIZE_4_5;
8293 parse_func = sha1s_parse_hash;
8294 sort_by_digest = sort_by_digest_4_5;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_EARLY_SKIP;
8299 dgst_pos0 = 3;
8300 dgst_pos1 = 4;
8301 dgst_pos2 = 2;
8302 dgst_pos3 = 1;
8303 break;
8304
8305 case 5000: hash_type = HASH_TYPE_KECCAK;
8306 salt_type = SALT_TYPE_EMBEDDED;
8307 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8308 opts_type = OPTS_TYPE_PT_GENERATE_LE
8309 | OPTS_TYPE_PT_ADD01;
8310 kern_type = KERN_TYPE_KECCAK;
8311 dgst_size = DGST_SIZE_8_25;
8312 parse_func = keccak_parse_hash;
8313 sort_by_digest = sort_by_digest_8_25;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_RAW_HASH;
8316 dgst_pos0 = 2;
8317 dgst_pos1 = 3;
8318 dgst_pos2 = 4;
8319 dgst_pos3 = 5;
8320 break;
8321
8322 case 5100: hash_type = HASH_TYPE_MD5H;
8323 salt_type = SALT_TYPE_NONE;
8324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8325 opts_type = OPTS_TYPE_PT_GENERATE_LE
8326 | OPTS_TYPE_PT_ADD80
8327 | OPTS_TYPE_PT_ADDBITS14;
8328 kern_type = KERN_TYPE_MD5H;
8329 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8330 parse_func = md5half_parse_hash;
8331 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_RAW_HASH;
8334 dgst_pos0 = 0;
8335 dgst_pos1 = 1;
8336 dgst_pos2 = 2;
8337 dgst_pos3 = 3;
8338 break;
8339
8340 case 5200: hash_type = HASH_TYPE_SHA256;
8341 salt_type = SALT_TYPE_EMBEDDED;
8342 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8343 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8344 kern_type = KERN_TYPE_PSAFE3;
8345 dgst_size = DGST_SIZE_4_8;
8346 parse_func = psafe3_parse_hash;
8347 sort_by_digest = sort_by_digest_4_8;
8348 opti_type = OPTI_TYPE_ZERO_BYTE;
8349 dgst_pos0 = 0;
8350 dgst_pos1 = 1;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 3;
8353 break;
8354
8355 case 5300: hash_type = HASH_TYPE_MD5;
8356 salt_type = SALT_TYPE_EMBEDDED;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE
8359 | OPTS_TYPE_ST_ADD80;
8360 kern_type = KERN_TYPE_IKEPSK_MD5;
8361 dgst_size = DGST_SIZE_4_4;
8362 parse_func = ikepsk_md5_parse_hash;
8363 sort_by_digest = sort_by_digest_4_4;
8364 opti_type = OPTI_TYPE_ZERO_BYTE;
8365 dgst_pos0 = 0;
8366 dgst_pos1 = 3;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 1;
8369 break;
8370
8371 case 5400: hash_type = HASH_TYPE_SHA1;
8372 salt_type = SALT_TYPE_EMBEDDED;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_BE
8375 | OPTS_TYPE_ST_ADD80;
8376 kern_type = KERN_TYPE_IKEPSK_SHA1;
8377 dgst_size = DGST_SIZE_4_5;
8378 parse_func = ikepsk_sha1_parse_hash;
8379 sort_by_digest = sort_by_digest_4_5;
8380 opti_type = OPTI_TYPE_ZERO_BYTE;
8381 dgst_pos0 = 3;
8382 dgst_pos1 = 4;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 1;
8385 break;
8386
8387 case 5500: hash_type = HASH_TYPE_NETNTLM;
8388 salt_type = SALT_TYPE_EMBEDDED;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_LE
8391 | OPTS_TYPE_PT_ADD80
8392 | OPTS_TYPE_PT_ADDBITS14
8393 | OPTS_TYPE_PT_UNICODE
8394 | OPTS_TYPE_ST_HEX;
8395 kern_type = KERN_TYPE_NETNTLMv1;
8396 dgst_size = DGST_SIZE_4_4;
8397 parse_func = netntlmv1_parse_hash;
8398 sort_by_digest = sort_by_digest_4_4;
8399 opti_type = OPTI_TYPE_ZERO_BYTE
8400 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8401 dgst_pos0 = 0;
8402 dgst_pos1 = 1;
8403 dgst_pos2 = 2;
8404 dgst_pos3 = 3;
8405 break;
8406
8407 case 5600: hash_type = HASH_TYPE_MD5;
8408 salt_type = SALT_TYPE_EMBEDDED;
8409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8410 opts_type = OPTS_TYPE_PT_GENERATE_LE
8411 | OPTS_TYPE_PT_ADD80
8412 | OPTS_TYPE_PT_ADDBITS14
8413 | OPTS_TYPE_PT_UNICODE;
8414 kern_type = KERN_TYPE_NETNTLMv2;
8415 dgst_size = DGST_SIZE_4_4;
8416 parse_func = netntlmv2_parse_hash;
8417 sort_by_digest = sort_by_digest_4_4;
8418 opti_type = OPTI_TYPE_ZERO_BYTE;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 3;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 1;
8423 break;
8424
8425 case 5700: hash_type = HASH_TYPE_SHA256;
8426 salt_type = SALT_TYPE_NONE;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_BE
8429 | OPTS_TYPE_PT_ADD80
8430 | OPTS_TYPE_PT_ADDBITS15;
8431 kern_type = KERN_TYPE_SHA256;
8432 dgst_size = DGST_SIZE_4_8;
8433 parse_func = cisco4_parse_hash;
8434 sort_by_digest = sort_by_digest_4_8;
8435 opti_type = OPTI_TYPE_ZERO_BYTE
8436 | OPTI_TYPE_PRECOMPUTE_INIT
8437 | OPTI_TYPE_PRECOMPUTE_MERKLE
8438 | OPTI_TYPE_EARLY_SKIP
8439 | OPTI_TYPE_NOT_ITERATED
8440 | OPTI_TYPE_NOT_SALTED
8441 | OPTI_TYPE_RAW_HASH;
8442 dgst_pos0 = 3;
8443 dgst_pos1 = 7;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 6;
8446 break;
8447
8448 case 5800: hash_type = HASH_TYPE_SHA1;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8452 | OPTS_TYPE_ST_ADD80;
8453 kern_type = KERN_TYPE_ANDROIDPIN;
8454 dgst_size = DGST_SIZE_4_5;
8455 parse_func = androidpin_parse_hash;
8456 sort_by_digest = sort_by_digest_4_5;
8457 opti_type = OPTI_TYPE_ZERO_BYTE;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 1;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 3;
8462 break;
8463
8464 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8465 salt_type = SALT_TYPE_NONE;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80;
8469 kern_type = KERN_TYPE_RIPEMD160;
8470 dgst_size = DGST_SIZE_4_5;
8471 parse_func = ripemd160_parse_hash;
8472 sort_by_digest = sort_by_digest_4_5;
8473 opti_type = OPTI_TYPE_ZERO_BYTE;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 1;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 3;
8478 break;
8479
8480 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8481 salt_type = SALT_TYPE_NONE;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_BE
8484 | OPTS_TYPE_PT_ADD80;
8485 kern_type = KERN_TYPE_WHIRLPOOL;
8486 dgst_size = DGST_SIZE_4_16;
8487 parse_func = whirlpool_parse_hash;
8488 sort_by_digest = sort_by_digest_4_16;
8489 opti_type = OPTI_TYPE_ZERO_BYTE;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 1;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 3;
8494 break;
8495
8496 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8497 salt_type = SALT_TYPE_EMBEDDED;
8498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8500 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8501 dgst_size = DGST_SIZE_4_5;
8502 parse_func = truecrypt_parse_hash_2k;
8503 sort_by_digest = sort_by_digest_4_5;
8504 opti_type = OPTI_TYPE_ZERO_BYTE;
8505 dgst_pos0 = 0;
8506 dgst_pos1 = 1;
8507 dgst_pos2 = 2;
8508 dgst_pos3 = 3;
8509 break;
8510
8511 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8512 salt_type = SALT_TYPE_EMBEDDED;
8513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8515 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8516 dgst_size = DGST_SIZE_4_5;
8517 parse_func = truecrypt_parse_hash_2k;
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 6213: hash_type = HASH_TYPE_RIPEMD160;
8527 salt_type = SALT_TYPE_EMBEDDED;
8528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8530 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8531 dgst_size = DGST_SIZE_4_5;
8532 parse_func = truecrypt_parse_hash_2k;
8533 sort_by_digest = sort_by_digest_4_5;
8534 opti_type = OPTI_TYPE_ZERO_BYTE;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 1;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 3;
8539 break;
8540
8541 case 6221: hash_type = HASH_TYPE_SHA512;
8542 salt_type = SALT_TYPE_EMBEDDED;
8543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8545 kern_type = KERN_TYPE_TCSHA512_XTS512;
8546 dgst_size = DGST_SIZE_8_8;
8547 parse_func = truecrypt_parse_hash_1k;
8548 sort_by_digest = sort_by_digest_8_8;
8549 opti_type = OPTI_TYPE_ZERO_BYTE;
8550 dgst_pos0 = 0;
8551 dgst_pos1 = 1;
8552 dgst_pos2 = 2;
8553 dgst_pos3 = 3;
8554 break;
8555
8556 case 6222: hash_type = HASH_TYPE_SHA512;
8557 salt_type = SALT_TYPE_EMBEDDED;
8558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8559 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8560 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8561 dgst_size = DGST_SIZE_8_8;
8562 parse_func = truecrypt_parse_hash_1k;
8563 sort_by_digest = sort_by_digest_8_8;
8564 opti_type = OPTI_TYPE_ZERO_BYTE;
8565 dgst_pos0 = 0;
8566 dgst_pos1 = 1;
8567 dgst_pos2 = 2;
8568 dgst_pos3 = 3;
8569 break;
8570
8571 case 6223: hash_type = HASH_TYPE_SHA512;
8572 salt_type = SALT_TYPE_EMBEDDED;
8573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8575 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8576 dgst_size = DGST_SIZE_8_8;
8577 parse_func = truecrypt_parse_hash_1k;
8578 sort_by_digest = sort_by_digest_8_8;
8579 opti_type = OPTI_TYPE_ZERO_BYTE;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 1;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 3;
8584 break;
8585
8586 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8587 salt_type = SALT_TYPE_EMBEDDED;
8588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8590 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8591 dgst_size = DGST_SIZE_4_8;
8592 parse_func = truecrypt_parse_hash_1k;
8593 sort_by_digest = sort_by_digest_4_8;
8594 opti_type = OPTI_TYPE_ZERO_BYTE;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 1;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 3;
8599 break;
8600
8601 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8605 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8606 dgst_size = DGST_SIZE_4_8;
8607 parse_func = truecrypt_parse_hash_1k;
8608 sort_by_digest = sort_by_digest_4_8;
8609 opti_type = OPTI_TYPE_ZERO_BYTE;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 1;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 3;
8614 break;
8615
8616 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8620 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8621 dgst_size = DGST_SIZE_4_8;
8622 parse_func = truecrypt_parse_hash_1k;
8623 sort_by_digest = sort_by_digest_4_8;
8624 opti_type = OPTI_TYPE_ZERO_BYTE;
8625 dgst_pos0 = 0;
8626 dgst_pos1 = 1;
8627 dgst_pos2 = 2;
8628 dgst_pos3 = 3;
8629 break;
8630
8631 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8632 salt_type = SALT_TYPE_EMBEDDED;
8633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8635 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8636 dgst_size = DGST_SIZE_4_5;
8637 parse_func = truecrypt_parse_hash_1k;
8638 sort_by_digest = sort_by_digest_4_5;
8639 opti_type = OPTI_TYPE_ZERO_BYTE;
8640 dgst_pos0 = 0;
8641 dgst_pos1 = 1;
8642 dgst_pos2 = 2;
8643 dgst_pos3 = 3;
8644 break;
8645
8646 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8647 salt_type = SALT_TYPE_EMBEDDED;
8648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8650 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8651 dgst_size = DGST_SIZE_4_5;
8652 parse_func = truecrypt_parse_hash_1k;
8653 sort_by_digest = sort_by_digest_4_5;
8654 opti_type = OPTI_TYPE_ZERO_BYTE;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 1;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 3;
8659 break;
8660
8661 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8665 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8666 dgst_size = DGST_SIZE_4_5;
8667 parse_func = truecrypt_parse_hash_1k;
8668 sort_by_digest = sort_by_digest_4_5;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 6300: hash_type = HASH_TYPE_MD5;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8680 kern_type = KERN_TYPE_MD5AIX;
8681 dgst_size = DGST_SIZE_4_4;
8682 parse_func = md5aix_parse_hash;
8683 sort_by_digest = sort_by_digest_4_4;
8684 opti_type = OPTI_TYPE_ZERO_BYTE;
8685 dgst_pos0 = 0;
8686 dgst_pos1 = 1;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 3;
8689 break;
8690
8691 case 6400: hash_type = HASH_TYPE_SHA256;
8692 salt_type = SALT_TYPE_EMBEDDED;
8693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8695 kern_type = KERN_TYPE_SHA256AIX;
8696 dgst_size = DGST_SIZE_4_8;
8697 parse_func = sha256aix_parse_hash;
8698 sort_by_digest = sort_by_digest_4_8;
8699 opti_type = OPTI_TYPE_ZERO_BYTE;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 1;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 3;
8704 break;
8705
8706 case 6500: hash_type = HASH_TYPE_SHA512;
8707 salt_type = SALT_TYPE_EMBEDDED;
8708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8710 kern_type = KERN_TYPE_SHA512AIX;
8711 dgst_size = DGST_SIZE_8_8;
8712 parse_func = sha512aix_parse_hash;
8713 sort_by_digest = sort_by_digest_8_8;
8714 opti_type = OPTI_TYPE_ZERO_BYTE;
8715 dgst_pos0 = 0;
8716 dgst_pos1 = 1;
8717 dgst_pos2 = 2;
8718 dgst_pos3 = 3;
8719 break;
8720
8721 case 6600: hash_type = HASH_TYPE_AES;
8722 salt_type = SALT_TYPE_EMBEDDED;
8723 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8724 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8725 kern_type = KERN_TYPE_AGILEKEY;
8726 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8727 parse_func = agilekey_parse_hash;
8728 sort_by_digest = sort_by_digest_4_5;
8729 opti_type = OPTI_TYPE_ZERO_BYTE;
8730 dgst_pos0 = 0;
8731 dgst_pos1 = 1;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 3;
8734 break;
8735
8736 case 6700: hash_type = HASH_TYPE_SHA1;
8737 salt_type = SALT_TYPE_EMBEDDED;
8738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8740 kern_type = KERN_TYPE_SHA1AIX;
8741 dgst_size = DGST_SIZE_4_5;
8742 parse_func = sha1aix_parse_hash;
8743 sort_by_digest = sort_by_digest_4_5;
8744 opti_type = OPTI_TYPE_ZERO_BYTE;
8745 dgst_pos0 = 0;
8746 dgst_pos1 = 1;
8747 dgst_pos2 = 2;
8748 dgst_pos3 = 3;
8749 break;
8750
8751 case 6800: hash_type = HASH_TYPE_AES;
8752 salt_type = SALT_TYPE_EMBEDDED;
8753 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8754 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8755 kern_type = KERN_TYPE_LASTPASS;
8756 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8757 parse_func = lastpass_parse_hash;
8758 sort_by_digest = sort_by_digest_4_8;
8759 opti_type = OPTI_TYPE_ZERO_BYTE;
8760 dgst_pos0 = 0;
8761 dgst_pos1 = 1;
8762 dgst_pos2 = 2;
8763 dgst_pos3 = 3;
8764 break;
8765
8766 case 6900: hash_type = HASH_TYPE_GOST;
8767 salt_type = SALT_TYPE_NONE;
8768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8769 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8770 kern_type = KERN_TYPE_GOST;
8771 dgst_size = DGST_SIZE_4_8;
8772 parse_func = gost_parse_hash;
8773 sort_by_digest = sort_by_digest_4_8;
8774 opti_type = OPTI_TYPE_ZERO_BYTE;
8775 dgst_pos0 = 0;
8776 dgst_pos1 = 1;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 3;
8779 break;
8780
8781 case 7100: hash_type = HASH_TYPE_SHA512;
8782 salt_type = SALT_TYPE_EMBEDDED;
8783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8785 kern_type = KERN_TYPE_PBKDF2_SHA512;
8786 dgst_size = DGST_SIZE_8_16;
8787 parse_func = sha512osx_parse_hash;
8788 sort_by_digest = sort_by_digest_8_16;
8789 opti_type = OPTI_TYPE_ZERO_BYTE;
8790 dgst_pos0 = 0;
8791 dgst_pos1 = 1;
8792 dgst_pos2 = 2;
8793 dgst_pos3 = 3;
8794 break;
8795
8796 case 7200: hash_type = HASH_TYPE_SHA512;
8797 salt_type = SALT_TYPE_EMBEDDED;
8798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8799 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8800 kern_type = KERN_TYPE_PBKDF2_SHA512;
8801 dgst_size = DGST_SIZE_8_16;
8802 parse_func = sha512grub_parse_hash;
8803 sort_by_digest = sort_by_digest_8_16;
8804 opti_type = OPTI_TYPE_ZERO_BYTE;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 1;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 3;
8809 break;
8810
8811 case 7300: hash_type = HASH_TYPE_SHA1;
8812 salt_type = SALT_TYPE_EMBEDDED;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_BE
8815 | OPTS_TYPE_ST_ADD80
8816 | OPTS_TYPE_ST_ADDBITS15;
8817 kern_type = KERN_TYPE_RAKP;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = rakp_parse_hash;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_NOT_ITERATED;
8823 dgst_pos0 = 3;
8824 dgst_pos1 = 4;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 1;
8827 break;
8828
8829 case 7400: hash_type = HASH_TYPE_SHA256;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8833 kern_type = KERN_TYPE_SHA256CRYPT;
8834 dgst_size = DGST_SIZE_4_8;
8835 parse_func = sha256crypt_parse_hash;
8836 sort_by_digest = sort_by_digest_4_8;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 7500: hash_type = HASH_TYPE_KRB5PA;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_KRB5PA;
8849 dgst_size = DGST_SIZE_4_4;
8850 parse_func = krb5pa_parse_hash;
8851 sort_by_digest = sort_by_digest_4_4;
8852 opti_type = OPTI_TYPE_ZERO_BYTE
8853 | OPTI_TYPE_NOT_ITERATED;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 7600: hash_type = HASH_TYPE_SHA1;
8861 salt_type = SALT_TYPE_INTERN;
8862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_BE
8864 | OPTS_TYPE_PT_ADD80
8865 | OPTS_TYPE_PT_ADDBITS15;
8866 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8867 dgst_size = DGST_SIZE_4_5;
8868 parse_func = redmine_parse_hash;
8869 sort_by_digest = sort_by_digest_4_5;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_PRECOMPUTE_INIT
8872 | OPTI_TYPE_EARLY_SKIP
8873 | OPTI_TYPE_NOT_ITERATED
8874 | OPTI_TYPE_PREPENDED_SALT;
8875 dgst_pos0 = 3;
8876 dgst_pos1 = 4;
8877 dgst_pos2 = 2;
8878 dgst_pos3 = 1;
8879 break;
8880
8881 case 7700: hash_type = HASH_TYPE_SAPB;
8882 salt_type = SALT_TYPE_EMBEDDED;
8883 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8884 opts_type = OPTS_TYPE_PT_GENERATE_LE
8885 | OPTS_TYPE_PT_UPPER
8886 | OPTS_TYPE_ST_UPPER;
8887 kern_type = KERN_TYPE_SAPB;
8888 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8889 parse_func = sapb_parse_hash;
8890 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8891 opti_type = OPTI_TYPE_ZERO_BYTE
8892 | OPTI_TYPE_PRECOMPUTE_INIT
8893 | OPTI_TYPE_NOT_ITERATED;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 7800: hash_type = HASH_TYPE_SAPG;
8901 salt_type = SALT_TYPE_EMBEDDED;
8902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_BE
8904 | OPTS_TYPE_ST_ADD80
8905 | OPTS_TYPE_ST_UPPER;
8906 kern_type = KERN_TYPE_SAPG;
8907 dgst_size = DGST_SIZE_4_5;
8908 parse_func = sapg_parse_hash;
8909 sort_by_digest = sort_by_digest_4_5;
8910 opti_type = OPTI_TYPE_ZERO_BYTE
8911 | OPTI_TYPE_PRECOMPUTE_INIT
8912 | OPTI_TYPE_NOT_ITERATED;
8913 dgst_pos0 = 3;
8914 dgst_pos1 = 4;
8915 dgst_pos2 = 2;
8916 dgst_pos3 = 1;
8917 break;
8918
8919 case 7900: hash_type = HASH_TYPE_SHA512;
8920 salt_type = SALT_TYPE_EMBEDDED;
8921 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8923 kern_type = KERN_TYPE_DRUPAL7;
8924 dgst_size = DGST_SIZE_8_8;
8925 parse_func = drupal7_parse_hash;
8926 sort_by_digest = sort_by_digest_8_8;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 8000: hash_type = HASH_TYPE_SHA256;
8935 salt_type = SALT_TYPE_EMBEDDED;
8936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_BE
8938 | OPTS_TYPE_PT_UNICODE
8939 | OPTS_TYPE_ST_ADD80
8940 | OPTS_TYPE_ST_HEX;
8941 kern_type = KERN_TYPE_SYBASEASE;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = sybasease_parse_hash;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_INIT
8947 | OPTI_TYPE_EARLY_SKIP
8948 | OPTI_TYPE_NOT_ITERATED
8949 | OPTI_TYPE_RAW_HASH;
8950 dgst_pos0 = 3;
8951 dgst_pos1 = 7;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 6;
8954 break;
8955
8956 case 8100: hash_type = HASH_TYPE_SHA1;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8960 kern_type = KERN_TYPE_NETSCALER;
8961 dgst_size = DGST_SIZE_4_5;
8962 parse_func = netscaler_parse_hash;
8963 sort_by_digest = sort_by_digest_4_5;
8964 opti_type = OPTI_TYPE_ZERO_BYTE
8965 | OPTI_TYPE_PRECOMPUTE_INIT
8966 | OPTI_TYPE_PRECOMPUTE_MERKLE
8967 | OPTI_TYPE_EARLY_SKIP
8968 | OPTI_TYPE_NOT_ITERATED
8969 | OPTI_TYPE_PREPENDED_SALT
8970 | OPTI_TYPE_RAW_HASH;
8971 dgst_pos0 = 3;
8972 dgst_pos1 = 4;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 1;
8975 break;
8976
8977 case 8200: hash_type = HASH_TYPE_SHA256;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8981 kern_type = KERN_TYPE_CLOUDKEY;
8982 dgst_size = DGST_SIZE_4_8;
8983 parse_func = cloudkey_parse_hash;
8984 sort_by_digest = sort_by_digest_4_8;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 8300: hash_type = HASH_TYPE_SHA1;
8993 salt_type = SALT_TYPE_EMBEDDED;
8994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE
8996 | OPTS_TYPE_ST_HEX
8997 | OPTS_TYPE_ST_ADD80;
8998 kern_type = KERN_TYPE_NSEC3;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = nsec3_parse_hash;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 3;
9004 dgst_pos1 = 4;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 1;
9007 break;
9008
9009 case 8400: hash_type = HASH_TYPE_SHA1;
9010 salt_type = SALT_TYPE_INTERN;
9011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_BE
9013 | OPTS_TYPE_PT_ADD80
9014 | OPTS_TYPE_PT_ADDBITS15;
9015 kern_type = KERN_TYPE_WBB3;
9016 dgst_size = DGST_SIZE_4_5;
9017 parse_func = wbb3_parse_hash;
9018 sort_by_digest = sort_by_digest_4_5;
9019 opti_type = OPTI_TYPE_ZERO_BYTE
9020 | OPTI_TYPE_PRECOMPUTE_INIT
9021 | OPTI_TYPE_NOT_ITERATED;
9022 dgst_pos0 = 3;
9023 dgst_pos1 = 4;
9024 dgst_pos2 = 2;
9025 dgst_pos3 = 1;
9026 break;
9027
9028 case 8500: hash_type = HASH_TYPE_DESRACF;
9029 salt_type = SALT_TYPE_EMBEDDED;
9030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9031 opts_type = OPTS_TYPE_PT_GENERATE_LE
9032 | OPTS_TYPE_ST_UPPER;
9033 kern_type = KERN_TYPE_RACF;
9034 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9035 parse_func = racf_parse_hash;
9036 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9037 opti_type = OPTI_TYPE_ZERO_BYTE
9038 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 8600: hash_type = HASH_TYPE_LOTUS5;
9046 salt_type = SALT_TYPE_NONE;
9047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9049 kern_type = KERN_TYPE_LOTUS5;
9050 dgst_size = DGST_SIZE_4_4;
9051 parse_func = lotus5_parse_hash;
9052 sort_by_digest = sort_by_digest_4_4;
9053 opti_type = OPTI_TYPE_EARLY_SKIP
9054 | OPTI_TYPE_NOT_ITERATED
9055 | OPTI_TYPE_NOT_SALTED
9056 | OPTI_TYPE_RAW_HASH;
9057 dgst_pos0 = 0;
9058 dgst_pos1 = 1;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 3;
9061 break;
9062
9063 case 8700: hash_type = HASH_TYPE_LOTUS6;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9067 kern_type = KERN_TYPE_LOTUS6;
9068 dgst_size = DGST_SIZE_4_4;
9069 parse_func = lotus6_parse_hash;
9070 sort_by_digest = sort_by_digest_4_4;
9071 opti_type = OPTI_TYPE_EARLY_SKIP
9072 | OPTI_TYPE_NOT_ITERATED
9073 | OPTI_TYPE_RAW_HASH;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9084 kern_type = KERN_TYPE_ANDROIDFDE;
9085 dgst_size = DGST_SIZE_4_4;
9086 parse_func = androidfde_parse_hash;
9087 sort_by_digest = sort_by_digest_4_4;
9088 opti_type = OPTI_TYPE_ZERO_BYTE;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 8900: hash_type = HASH_TYPE_SCRYPT;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9099 kern_type = KERN_TYPE_SCRYPT;
9100 dgst_size = DGST_SIZE_4_8;
9101 parse_func = scrypt_parse_hash;
9102 sort_by_digest = sort_by_digest_4_8;
9103 opti_type = OPTI_TYPE_ZERO_BYTE;
9104 dgst_pos0 = 0;
9105 dgst_pos1 = 1;
9106 dgst_pos2 = 2;
9107 dgst_pos3 = 3;
9108 break;
9109
9110 case 9000: hash_type = HASH_TYPE_SHA1;
9111 salt_type = SALT_TYPE_EMBEDDED;
9112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_LE
9114 | OPTS_TYPE_ST_GENERATE_LE;
9115 kern_type = KERN_TYPE_PSAFE2;
9116 dgst_size = DGST_SIZE_4_5;
9117 parse_func = psafe2_parse_hash;
9118 sort_by_digest = sort_by_digest_4_5;
9119 opti_type = OPTI_TYPE_ZERO_BYTE;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 9100: hash_type = HASH_TYPE_LOTUS8;
9127 salt_type = SALT_TYPE_EMBEDDED;
9128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9130 kern_type = KERN_TYPE_LOTUS8;
9131 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9132 parse_func = lotus8_parse_hash;
9133 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9134 opti_type = OPTI_TYPE_ZERO_BYTE;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 1;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 3;
9139 break;
9140
9141 case 9200: hash_type = HASH_TYPE_SHA256;
9142 salt_type = SALT_TYPE_EMBEDDED;
9143 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9144 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9145 kern_type = KERN_TYPE_PBKDF2_SHA256;
9146 dgst_size = DGST_SIZE_4_32;
9147 parse_func = cisco8_parse_hash;
9148 sort_by_digest = sort_by_digest_4_32;
9149 opti_type = OPTI_TYPE_ZERO_BYTE;
9150 dgst_pos0 = 0;
9151 dgst_pos1 = 1;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 3;
9154 break;
9155
9156 case 9300: hash_type = HASH_TYPE_SCRYPT;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9160 kern_type = KERN_TYPE_SCRYPT;
9161 dgst_size = DGST_SIZE_4_8;
9162 parse_func = cisco9_parse_hash;
9163 sort_by_digest = sort_by_digest_4_8;
9164 opti_type = OPTI_TYPE_ZERO_BYTE;
9165 dgst_pos0 = 0;
9166 dgst_pos1 = 1;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 3;
9169 break;
9170
9171 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9175 kern_type = KERN_TYPE_OFFICE2007;
9176 dgst_size = DGST_SIZE_4_4;
9177 parse_func = office2007_parse_hash;
9178 sort_by_digest = sort_by_digest_4_4;
9179 opti_type = OPTI_TYPE_ZERO_BYTE;
9180 dgst_pos0 = 0;
9181 dgst_pos1 = 1;
9182 dgst_pos2 = 2;
9183 dgst_pos3 = 3;
9184 break;
9185
9186 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9187 salt_type = SALT_TYPE_EMBEDDED;
9188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9189 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9190 kern_type = KERN_TYPE_OFFICE2010;
9191 dgst_size = DGST_SIZE_4_4;
9192 parse_func = office2010_parse_hash;
9193 sort_by_digest = sort_by_digest_4_4;
9194 opti_type = OPTI_TYPE_ZERO_BYTE;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 1;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 3;
9199 break;
9200
9201 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9202 salt_type = SALT_TYPE_EMBEDDED;
9203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9205 kern_type = KERN_TYPE_OFFICE2013;
9206 dgst_size = DGST_SIZE_4_4;
9207 parse_func = office2013_parse_hash;
9208 sort_by_digest = sort_by_digest_4_4;
9209 opti_type = OPTI_TYPE_ZERO_BYTE;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_UNICODE;
9222 kern_type = KERN_TYPE_OLDOFFICE01;
9223 dgst_size = DGST_SIZE_4_4;
9224 parse_func = oldoffice01_parse_hash;
9225 sort_by_digest = sort_by_digest_4_4;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_LE
9239 | OPTS_TYPE_PT_ADD80;
9240 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9241 dgst_size = DGST_SIZE_4_4;
9242 parse_func = oldoffice01cm1_parse_hash;
9243 sort_by_digest = sort_by_digest_4_4;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_NOT_ITERATED;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE
9257 | OPTS_TYPE_PT_ADD80
9258 | OPTS_TYPE_PT_UNICODE
9259 | OPTS_TYPE_PT_NEVERCRACK;
9260 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9261 dgst_size = DGST_SIZE_4_4;
9262 parse_func = oldoffice01cm2_parse_hash;
9263 sort_by_digest = sort_by_digest_4_4;
9264 opti_type = OPTI_TYPE_ZERO_BYTE
9265 | OPTI_TYPE_PRECOMPUTE_INIT
9266 | OPTI_TYPE_NOT_ITERATED;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_BE
9277 | OPTS_TYPE_PT_ADD80
9278 | OPTS_TYPE_PT_UNICODE;
9279 kern_type = KERN_TYPE_OLDOFFICE34;
9280 dgst_size = DGST_SIZE_4_4;
9281 parse_func = oldoffice34_parse_hash;
9282 sort_by_digest = sort_by_digest_4_4;
9283 opti_type = OPTI_TYPE_ZERO_BYTE
9284 | OPTI_TYPE_PRECOMPUTE_INIT
9285 | OPTI_TYPE_NOT_ITERATED;
9286 dgst_pos0 = 0;
9287 dgst_pos1 = 1;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 3;
9290 break;
9291
9292 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9293 salt_type = SALT_TYPE_EMBEDDED;
9294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9296 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9297 dgst_size = DGST_SIZE_4_4;
9298 parse_func = oldoffice34cm1_parse_hash;
9299 sort_by_digest = sort_by_digest_4_4;
9300 opti_type = OPTI_TYPE_ZERO_BYTE
9301 | OPTI_TYPE_PRECOMPUTE_INIT
9302 | OPTI_TYPE_NOT_ITERATED;
9303 dgst_pos0 = 0;
9304 dgst_pos1 = 1;
9305 dgst_pos2 = 2;
9306 dgst_pos3 = 3;
9307 break;
9308
9309 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9310 salt_type = SALT_TYPE_EMBEDDED;
9311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9312 opts_type = OPTS_TYPE_PT_GENERATE_BE
9313 | OPTS_TYPE_PT_ADD80
9314 | OPTS_TYPE_PT_UNICODE
9315 | OPTS_TYPE_PT_NEVERCRACK;
9316 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9317 dgst_size = DGST_SIZE_4_4;
9318 parse_func = oldoffice34cm2_parse_hash;
9319 sort_by_digest = sort_by_digest_4_4;
9320 opti_type = OPTI_TYPE_ZERO_BYTE
9321 | OPTI_TYPE_PRECOMPUTE_INIT
9322 | OPTI_TYPE_NOT_ITERATED;
9323 dgst_pos0 = 0;
9324 dgst_pos1 = 1;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 3;
9327 break;
9328
9329 case 9900: hash_type = HASH_TYPE_MD5;
9330 salt_type = SALT_TYPE_NONE;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9333 kern_type = KERN_TYPE_RADMIN2;
9334 dgst_size = DGST_SIZE_4_4;
9335 parse_func = radmin2_parse_hash;
9336 sort_by_digest = sort_by_digest_4_4;
9337 opti_type = OPTI_TYPE_ZERO_BYTE
9338 | OPTI_TYPE_PRECOMPUTE_INIT
9339 | OPTI_TYPE_EARLY_SKIP
9340 | OPTI_TYPE_NOT_ITERATED
9341 | OPTI_TYPE_NOT_SALTED;
9342 dgst_pos0 = 0;
9343 dgst_pos1 = 3;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 1;
9346 break;
9347
9348 case 10000: hash_type = HASH_TYPE_SHA256;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9352 kern_type = KERN_TYPE_PBKDF2_SHA256;
9353 dgst_size = DGST_SIZE_4_32;
9354 parse_func = djangopbkdf2_parse_hash;
9355 sort_by_digest = sort_by_digest_4_32;
9356 opti_type = OPTI_TYPE_ZERO_BYTE;
9357 dgst_pos0 = 0;
9358 dgst_pos1 = 1;
9359 dgst_pos2 = 2;
9360 dgst_pos3 = 3;
9361 break;
9362
9363 case 10100: hash_type = HASH_TYPE_SIPHASH;
9364 salt_type = SALT_TYPE_EMBEDDED;
9365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9367 kern_type = KERN_TYPE_SIPHASH;
9368 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9369 parse_func = siphash_parse_hash;
9370 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9371 opti_type = OPTI_TYPE_ZERO_BYTE
9372 | OPTI_TYPE_NOT_ITERATED
9373 | OPTI_TYPE_RAW_HASH;
9374 dgst_pos0 = 0;
9375 dgst_pos1 = 1;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 3;
9378 break;
9379
9380 case 10200: hash_type = HASH_TYPE_MD5;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE
9384 | OPTS_TYPE_ST_ADD80
9385 | OPTS_TYPE_ST_ADDBITS14;
9386 kern_type = KERN_TYPE_HMACMD5_PW;
9387 dgst_size = DGST_SIZE_4_4;
9388 parse_func = crammd5_parse_hash;
9389 sort_by_digest = sort_by_digest_4_4;
9390 opti_type = OPTI_TYPE_ZERO_BYTE
9391 | OPTI_TYPE_NOT_ITERATED;
9392 dgst_pos0 = 0;
9393 dgst_pos1 = 3;
9394 dgst_pos2 = 2;
9395 dgst_pos3 = 1;
9396 break;
9397
9398 case 10300: hash_type = HASH_TYPE_SHA1;
9399 salt_type = SALT_TYPE_EMBEDDED;
9400 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9401 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9402 kern_type = KERN_TYPE_SAPH_SHA1;
9403 dgst_size = DGST_SIZE_4_5;
9404 parse_func = saph_sha1_parse_hash;
9405 sort_by_digest = sort_by_digest_4_5;
9406 opti_type = OPTI_TYPE_ZERO_BYTE;
9407 dgst_pos0 = 0;
9408 dgst_pos1 = 1;
9409 dgst_pos2 = 2;
9410 dgst_pos3 = 3;
9411 break;
9412
9413 case 10400: hash_type = HASH_TYPE_PDFU16;
9414 salt_type = SALT_TYPE_EMBEDDED;
9415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9416 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9417 kern_type = KERN_TYPE_PDF11;
9418 dgst_size = DGST_SIZE_4_4;
9419 parse_func = pdf11_parse_hash;
9420 sort_by_digest = sort_by_digest_4_4;
9421 opti_type = OPTI_TYPE_ZERO_BYTE
9422 | OPTI_TYPE_NOT_ITERATED;
9423 dgst_pos0 = 0;
9424 dgst_pos1 = 1;
9425 dgst_pos2 = 2;
9426 dgst_pos3 = 3;
9427 break;
9428
9429 case 10410: hash_type = HASH_TYPE_PDFU16;
9430 salt_type = SALT_TYPE_EMBEDDED;
9431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9432 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9433 kern_type = KERN_TYPE_PDF11CM1;
9434 dgst_size = DGST_SIZE_4_4;
9435 parse_func = pdf11cm1_parse_hash;
9436 sort_by_digest = sort_by_digest_4_4;
9437 opti_type = OPTI_TYPE_ZERO_BYTE
9438 | OPTI_TYPE_NOT_ITERATED;
9439 dgst_pos0 = 0;
9440 dgst_pos1 = 1;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 3;
9443 break;
9444
9445 case 10420: hash_type = HASH_TYPE_PDFU16;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9449 kern_type = KERN_TYPE_PDF11CM2;
9450 dgst_size = DGST_SIZE_4_4;
9451 parse_func = pdf11cm2_parse_hash;
9452 sort_by_digest = sort_by_digest_4_4;
9453 opti_type = OPTI_TYPE_ZERO_BYTE
9454 | OPTI_TYPE_NOT_ITERATED;
9455 dgst_pos0 = 0;
9456 dgst_pos1 = 1;
9457 dgst_pos2 = 2;
9458 dgst_pos3 = 3;
9459 break;
9460
9461 case 10500: hash_type = HASH_TYPE_PDFU16;
9462 salt_type = SALT_TYPE_EMBEDDED;
9463 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9464 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9465 kern_type = KERN_TYPE_PDF14;
9466 dgst_size = DGST_SIZE_4_4;
9467 parse_func = pdf14_parse_hash;
9468 sort_by_digest = sort_by_digest_4_4;
9469 opti_type = OPTI_TYPE_ZERO_BYTE
9470 | OPTI_TYPE_NOT_ITERATED;
9471 dgst_pos0 = 0;
9472 dgst_pos1 = 1;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 3;
9475 break;
9476
9477 case 10600: hash_type = HASH_TYPE_SHA256;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_BE
9481 | OPTS_TYPE_ST_ADD80
9482 | OPTS_TYPE_ST_ADDBITS15
9483 | OPTS_TYPE_HASH_COPY;
9484 kern_type = KERN_TYPE_SHA256_PWSLT;
9485 dgst_size = DGST_SIZE_4_8;
9486 parse_func = pdf17l3_parse_hash;
9487 sort_by_digest = sort_by_digest_4_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_PRECOMPUTE_INIT
9490 | OPTI_TYPE_PRECOMPUTE_MERKLE
9491 | OPTI_TYPE_EARLY_SKIP
9492 | OPTI_TYPE_NOT_ITERATED
9493 | OPTI_TYPE_APPENDED_SALT
9494 | OPTI_TYPE_RAW_HASH;
9495 dgst_pos0 = 3;
9496 dgst_pos1 = 7;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 6;
9499 break;
9500
9501 case 10700: hash_type = HASH_TYPE_PDFU32;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE
9505 | OPTS_TYPE_HASH_COPY;
9506 kern_type = KERN_TYPE_PDF17L8;
9507 dgst_size = DGST_SIZE_4_8;
9508 parse_func = pdf17l8_parse_hash;
9509 sort_by_digest = sort_by_digest_4_8;
9510 opti_type = OPTI_TYPE_ZERO_BYTE
9511 | OPTI_TYPE_NOT_ITERATED;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 10800: hash_type = HASH_TYPE_SHA384;
9519 salt_type = SALT_TYPE_NONE;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_BE
9522 | OPTS_TYPE_PT_ADD80
9523 | OPTS_TYPE_PT_ADDBITS15;
9524 kern_type = KERN_TYPE_SHA384;
9525 dgst_size = DGST_SIZE_8_8;
9526 parse_func = sha384_parse_hash;
9527 sort_by_digest = sort_by_digest_8_8;
9528 opti_type = OPTI_TYPE_ZERO_BYTE
9529 | OPTI_TYPE_PRECOMPUTE_INIT
9530 | OPTI_TYPE_PRECOMPUTE_MERKLE
9531 | OPTI_TYPE_EARLY_SKIP
9532 | OPTI_TYPE_NOT_ITERATED
9533 | OPTI_TYPE_NOT_SALTED
9534 | OPTI_TYPE_RAW_HASH;
9535 dgst_pos0 = 6;
9536 dgst_pos1 = 7;
9537 dgst_pos2 = 4;
9538 dgst_pos3 = 5;
9539 break;
9540
9541 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE
9545 | OPTS_TYPE_ST_BASE64
9546 | OPTS_TYPE_HASH_COPY;
9547 kern_type = KERN_TYPE_PBKDF2_SHA256;
9548 dgst_size = DGST_SIZE_4_32;
9549 parse_func = pbkdf2_sha256_parse_hash;
9550 sort_by_digest = sort_by_digest_4_32;
9551 opti_type = OPTI_TYPE_ZERO_BYTE;
9552 dgst_pos0 = 0;
9553 dgst_pos1 = 1;
9554 dgst_pos2 = 2;
9555 dgst_pos3 = 3;
9556 break;
9557
9558 case 11000: hash_type = HASH_TYPE_MD5;
9559 salt_type = SALT_TYPE_INTERN;
9560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9561 opts_type = OPTS_TYPE_PT_GENERATE_LE
9562 | OPTS_TYPE_PT_ADD80;
9563 kern_type = KERN_TYPE_PRESTASHOP;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = prestashop_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE
9568 | OPTI_TYPE_PRECOMPUTE_INIT
9569 | OPTI_TYPE_NOT_ITERATED
9570 | OPTI_TYPE_PREPENDED_SALT;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 3;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 1;
9575 break;
9576
9577 case 11100: hash_type = HASH_TYPE_MD5;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_ST_ADD80;
9582 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = postgresql_auth_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_PRECOMPUTE_INIT
9588 | OPTI_TYPE_PRECOMPUTE_MERKLE
9589 | OPTI_TYPE_EARLY_SKIP;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 3;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 1;
9594 break;
9595
9596 case 11200: hash_type = HASH_TYPE_SHA1;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_BE
9600 | OPTS_TYPE_PT_ADD80
9601 | OPTS_TYPE_ST_HEX;
9602 kern_type = KERN_TYPE_MYSQL_AUTH;
9603 dgst_size = DGST_SIZE_4_5;
9604 parse_func = mysql_auth_parse_hash;
9605 sort_by_digest = sort_by_digest_4_5;
9606 opti_type = OPTI_TYPE_ZERO_BYTE
9607 | OPTI_TYPE_EARLY_SKIP;
9608 dgst_pos0 = 3;
9609 dgst_pos1 = 4;
9610 dgst_pos2 = 2;
9611 dgst_pos3 = 1;
9612 break;
9613
9614 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9615 salt_type = SALT_TYPE_EMBEDDED;
9616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9617 opts_type = OPTS_TYPE_PT_GENERATE_LE
9618 | OPTS_TYPE_ST_HEX
9619 | OPTS_TYPE_ST_ADD80;
9620 kern_type = KERN_TYPE_BITCOIN_WALLET;
9621 dgst_size = DGST_SIZE_4_4;
9622 parse_func = bitcoin_wallet_parse_hash;
9623 sort_by_digest = sort_by_digest_4_4;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 11400: hash_type = HASH_TYPE_MD5;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE
9635 | OPTS_TYPE_PT_ADD80
9636 | OPTS_TYPE_HASH_COPY;
9637 kern_type = KERN_TYPE_SIP_AUTH;
9638 dgst_size = DGST_SIZE_4_4;
9639 parse_func = sip_auth_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 3;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 1;
9646 break;
9647
9648 case 11500: hash_type = HASH_TYPE_CRC32;
9649 salt_type = SALT_TYPE_INTERN;
9650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE
9652 | OPTS_TYPE_ST_GENERATE_LE
9653 | OPTS_TYPE_ST_HEX;
9654 kern_type = KERN_TYPE_CRC32;
9655 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9656 parse_func = crc32_parse_hash;
9657 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9658 opti_type = OPTI_TYPE_ZERO_BYTE;
9659 dgst_pos0 = 0;
9660 dgst_pos1 = 1;
9661 dgst_pos2 = 2;
9662 dgst_pos3 = 3;
9663 break;
9664
9665 case 11600: hash_type = HASH_TYPE_AES;
9666 salt_type = SALT_TYPE_EMBEDDED;
9667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9668 opts_type = OPTS_TYPE_PT_GENERATE_LE
9669 | OPTS_TYPE_PT_NEVERCRACK;
9670 kern_type = KERN_TYPE_SEVEN_ZIP;
9671 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9672 parse_func = seven_zip_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9674 opti_type = OPTI_TYPE_ZERO_BYTE;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9682 salt_type = SALT_TYPE_NONE;
9683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE
9685 | OPTS_TYPE_PT_ADD01;
9686 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9687 dgst_size = DGST_SIZE_4_8;
9688 parse_func = gost2012sbog_256_parse_hash;
9689 sort_by_digest = sort_by_digest_4_8;
9690 opti_type = OPTI_TYPE_ZERO_BYTE;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9698 salt_type = SALT_TYPE_NONE;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE
9701 | OPTS_TYPE_PT_ADD01;
9702 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9703 dgst_size = DGST_SIZE_4_16;
9704 parse_func = gost2012sbog_512_parse_hash;
9705 sort_by_digest = sort_by_digest_4_16;
9706 opti_type = OPTI_TYPE_ZERO_BYTE;
9707 dgst_pos0 = 0;
9708 dgst_pos1 = 1;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 3;
9711 break;
9712
9713 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE
9717 | OPTS_TYPE_ST_BASE64
9718 | OPTS_TYPE_HASH_COPY;
9719 kern_type = KERN_TYPE_PBKDF2_MD5;
9720 dgst_size = DGST_SIZE_4_32;
9721 parse_func = pbkdf2_md5_parse_hash;
9722 sort_by_digest = sort_by_digest_4_32;
9723 opti_type = OPTI_TYPE_ZERO_BYTE;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 1;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 3;
9728 break;
9729
9730 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE
9734 | OPTS_TYPE_ST_BASE64
9735 | OPTS_TYPE_HASH_COPY;
9736 kern_type = KERN_TYPE_PBKDF2_SHA1;
9737 dgst_size = DGST_SIZE_4_32;
9738 parse_func = pbkdf2_sha1_parse_hash;
9739 sort_by_digest = sort_by_digest_4_32;
9740 opti_type = OPTI_TYPE_ZERO_BYTE;
9741 dgst_pos0 = 0;
9742 dgst_pos1 = 1;
9743 dgst_pos2 = 2;
9744 dgst_pos3 = 3;
9745 break;
9746
9747 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9748 salt_type = SALT_TYPE_EMBEDDED;
9749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9750 opts_type = OPTS_TYPE_PT_GENERATE_LE
9751 | OPTS_TYPE_ST_BASE64
9752 | OPTS_TYPE_HASH_COPY;
9753 kern_type = KERN_TYPE_PBKDF2_SHA512;
9754 dgst_size = DGST_SIZE_8_16;
9755 parse_func = pbkdf2_sha512_parse_hash;
9756 sort_by_digest = sort_by_digest_8_16;
9757 opti_type = OPTI_TYPE_ZERO_BYTE;
9758 dgst_pos0 = 0;
9759 dgst_pos1 = 1;
9760 dgst_pos2 = 2;
9761 dgst_pos3 = 3;
9762 break;
9763
9764 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9765 salt_type = SALT_TYPE_EMBEDDED;
9766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9767 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9768 kern_type = KERN_TYPE_ECRYPTFS;
9769 dgst_size = DGST_SIZE_8_8;
9770 parse_func = ecryptfs_parse_hash;
9771 sort_by_digest = sort_by_digest_8_8;
9772 opti_type = OPTI_TYPE_ZERO_BYTE;
9773 dgst_pos0 = 0;
9774 dgst_pos1 = 1;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 3;
9777 break;
9778
9779 case 12300: hash_type = HASH_TYPE_ORACLET;
9780 salt_type = SALT_TYPE_EMBEDDED;
9781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9783 kern_type = KERN_TYPE_ORACLET;
9784 dgst_size = DGST_SIZE_8_16;
9785 parse_func = oraclet_parse_hash;
9786 sort_by_digest = sort_by_digest_8_16;
9787 opti_type = OPTI_TYPE_ZERO_BYTE;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9798 kern_type = KERN_TYPE_BSDICRYPT;
9799 dgst_size = DGST_SIZE_4_4;
9800 parse_func = bsdicrypt_parse_hash;
9801 sort_by_digest = sort_by_digest_4_4;
9802 opti_type = OPTI_TYPE_ZERO_BYTE
9803 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9804 dgst_pos0 = 0;
9805 dgst_pos1 = 1;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 3;
9808 break;
9809
9810 case 12500: hash_type = HASH_TYPE_RAR3HP;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9814 kern_type = KERN_TYPE_RAR3;
9815 dgst_size = DGST_SIZE_4_4;
9816 parse_func = rar3hp_parse_hash;
9817 sort_by_digest = sort_by_digest_4_4;
9818 opti_type = OPTI_TYPE_ZERO_BYTE;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 12600: hash_type = HASH_TYPE_SHA256;
9826 salt_type = SALT_TYPE_INTERN;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_BE
9829 | OPTS_TYPE_PT_ADD80;
9830 kern_type = KERN_TYPE_CF10;
9831 dgst_size = DGST_SIZE_4_8;
9832 parse_func = cf10_parse_hash;
9833 sort_by_digest = sort_by_digest_4_8;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_PRECOMPUTE_INIT
9836 | OPTI_TYPE_EARLY_SKIP
9837 | OPTI_TYPE_NOT_ITERATED;
9838 dgst_pos0 = 3;
9839 dgst_pos1 = 7;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 6;
9842 break;
9843
9844 case 12700: hash_type = HASH_TYPE_AES;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_LE
9848 | OPTS_TYPE_HASH_COPY;
9849 kern_type = KERN_TYPE_MYWALLET;
9850 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9851 parse_func = mywallet_parse_hash;
9852 sort_by_digest = sort_by_digest_4_5;
9853 opti_type = OPTI_TYPE_ZERO_BYTE;
9854 dgst_pos0 = 0;
9855 dgst_pos1 = 1;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 3;
9858 break;
9859
9860 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9864 kern_type = KERN_TYPE_MS_DRSR;
9865 dgst_size = DGST_SIZE_4_8;
9866 parse_func = ms_drsr_parse_hash;
9867 sort_by_digest = sort_by_digest_4_8;
9868 opti_type = OPTI_TYPE_ZERO_BYTE;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9879 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9880 dgst_size = DGST_SIZE_4_8;
9881 parse_func = androidfde_samsung_parse_hash;
9882 sort_by_digest = sort_by_digest_4_8;
9883 opti_type = OPTI_TYPE_ZERO_BYTE;
9884 dgst_pos0 = 0;
9885 dgst_pos1 = 1;
9886 dgst_pos2 = 2;
9887 dgst_pos3 = 3;
9888 break;
9889
9890 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9894 kern_type = KERN_TYPE_RAR5;
9895 dgst_size = DGST_SIZE_4_4;
9896 parse_func = rar5_parse_hash;
9897 sort_by_digest = sort_by_digest_4_4;
9898 opti_type = OPTI_TYPE_ZERO_BYTE;
9899 dgst_pos0 = 0;
9900 dgst_pos1 = 1;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 3;
9903 break;
9904
9905 default: usage_mini_print (PROGNAME); return (-1);
9906 }
9907
9908 /**
9909 * transpose
9910 */
9911
9912 data.parse_func = parse_func;
9913
9914 /**
9915 * misc stuff
9916 */
9917
9918 if (hex_salt)
9919 {
9920 if (salt_type == SALT_TYPE_INTERN)
9921 {
9922 opts_type |= OPTS_TYPE_ST_HEX;
9923 }
9924 else
9925 {
9926 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9927
9928 return (-1);
9929 }
9930 }
9931
9932 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9933 | (salt_type == SALT_TYPE_EXTERN)
9934 | (salt_type == SALT_TYPE_EMBEDDED)
9935 | (salt_type == SALT_TYPE_VIRTUAL));
9936
9937 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9938
9939 data.hash_type = hash_type;
9940 data.attack_mode = attack_mode;
9941 data.attack_kern = attack_kern;
9942 data.attack_exec = attack_exec;
9943 data.kern_type = kern_type;
9944 data.opts_type = opts_type;
9945 data.dgst_size = dgst_size;
9946 data.salt_type = salt_type;
9947 data.isSalted = isSalted;
9948 data.sort_by_digest = sort_by_digest;
9949 data.dgst_pos0 = dgst_pos0;
9950 data.dgst_pos1 = dgst_pos1;
9951 data.dgst_pos2 = dgst_pos2;
9952 data.dgst_pos3 = dgst_pos3;
9953
9954 esalt_size = 0;
9955
9956 switch (hash_mode)
9957 {
9958 case 2500: esalt_size = sizeof (wpa_t); break;
9959 case 5300: esalt_size = sizeof (ikepsk_t); break;
9960 case 5400: esalt_size = sizeof (ikepsk_t); break;
9961 case 5500: esalt_size = sizeof (netntlm_t); break;
9962 case 5600: esalt_size = sizeof (netntlm_t); break;
9963 case 6211:
9964 case 6212:
9965 case 6213:
9966 case 6221:
9967 case 6222:
9968 case 6223:
9969 case 6231:
9970 case 6232:
9971 case 6233:
9972 case 6241:
9973 case 6242:
9974 case 6243: esalt_size = sizeof (tc_t); break;
9975 case 6600: esalt_size = sizeof (agilekey_t); break;
9976 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9977 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9978 case 7300: esalt_size = sizeof (rakp_t); break;
9979 case 7500: esalt_size = sizeof (krb5pa_t); break;
9980 case 8200: esalt_size = sizeof (cloudkey_t); break;
9981 case 8800: esalt_size = sizeof (androidfde_t); break;
9982 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9983 case 9400: esalt_size = sizeof (office2007_t); break;
9984 case 9500: esalt_size = sizeof (office2010_t); break;
9985 case 9600: esalt_size = sizeof (office2013_t); break;
9986 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9987 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9988 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9989 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9990 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9991 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9992 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9993 case 10200: esalt_size = sizeof (cram_md5_t); break;
9994 case 10400: esalt_size = sizeof (pdf_t); break;
9995 case 10410: esalt_size = sizeof (pdf_t); break;
9996 case 10420: esalt_size = sizeof (pdf_t); break;
9997 case 10500: esalt_size = sizeof (pdf_t); break;
9998 case 10600: esalt_size = sizeof (pdf_t); break;
9999 case 10700: esalt_size = sizeof (pdf_t); break;
10000 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10001 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10002 case 11400: esalt_size = sizeof (sip_t); break;
10003 case 11600: esalt_size = sizeof (seven_zip_t); break;
10004 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10005 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10006 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10007 case 13000: esalt_size = sizeof (rar5_t); break;
10008 }
10009
10010 data.esalt_size = esalt_size;
10011
10012 /**
10013 * choose dictionary parser
10014 */
10015
10016 if (hash_type == HASH_TYPE_LM)
10017 {
10018 get_next_word_func = get_next_word_lm;
10019 }
10020 else if (opts_type & OPTS_TYPE_PT_UPPER)
10021 {
10022 get_next_word_func = get_next_word_uc;
10023 }
10024 else
10025 {
10026 get_next_word_func = get_next_word_std;
10027 }
10028
10029 /**
10030 * dictstat
10031 */
10032
10033 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10034
10035 #ifdef _POSIX
10036 size_t dictstat_nmemb = 0;
10037 #endif
10038
10039 #ifdef _WIN
10040 uint dictstat_nmemb = 0;
10041 #endif
10042
10043 char dictstat[256];
10044
10045 FILE *dictstat_fp = NULL;
10046
10047 if (keyspace == 0)
10048 {
10049 memset (dictstat, 0, sizeof (dictstat));
10050
10051 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10052
10053 dictstat_fp = fopen (dictstat, "rb");
10054
10055 if (dictstat_fp)
10056 {
10057 #ifdef _POSIX
10058 struct stat tmpstat;
10059
10060 fstat (fileno (dictstat_fp), &tmpstat);
10061 #endif
10062
10063 #ifdef _WIN
10064 struct stat64 tmpstat;
10065
10066 _fstat64 (fileno (dictstat_fp), &tmpstat);
10067 #endif
10068
10069 if (tmpstat.st_mtime < COMPTIME)
10070 {
10071 /* with v0.15 the format changed so we have to ensure user is using a good version
10072 since there is no version-header in the dictstat file */
10073
10074 fclose (dictstat_fp);
10075
10076 unlink (dictstat);
10077 }
10078 else
10079 {
10080 while (!feof (dictstat_fp))
10081 {
10082 dictstat_t d;
10083
10084 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10085
10086 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10087
10088 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10089 {
10090 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10091
10092 return -1;
10093 }
10094 }
10095
10096 fclose (dictstat_fp);
10097 }
10098 }
10099 }
10100
10101 /**
10102 * potfile
10103 */
10104
10105 char potfile[256];
10106
10107 memset (potfile, 0, sizeof (potfile));
10108
10109 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10110
10111 data.pot_fp = NULL;
10112
10113 FILE *out_fp = NULL;
10114 FILE *pot_fp = NULL;
10115
10116 if (show == 1 || left == 1)
10117 {
10118 pot_fp = fopen (potfile, "rb");
10119
10120 if (pot_fp == NULL)
10121 {
10122 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10123
10124 return (-1);
10125 }
10126
10127 if (outfile != NULL)
10128 {
10129 if ((out_fp = fopen (outfile, "ab")) == NULL)
10130 {
10131 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10132
10133 fclose (pot_fp);
10134
10135 return (-1);
10136 }
10137 }
10138 else
10139 {
10140 out_fp = stdout;
10141 }
10142 }
10143 else
10144 {
10145 if (potfile_disable == 0)
10146 {
10147 pot_fp = fopen (potfile, "ab");
10148
10149 if (pot_fp == NULL)
10150 {
10151 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10152
10153 return (-1);
10154 }
10155
10156 data.pot_fp = pot_fp;
10157 }
10158 }
10159
10160 pot_t *pot = NULL;
10161
10162 uint pot_cnt = 0;
10163 uint pot_avail = 0;
10164
10165 if (show == 1 || left == 1)
10166 {
10167 SUPPRESS_OUTPUT = 1;
10168
10169 pot_avail = count_lines (pot_fp);
10170
10171 rewind (pot_fp);
10172
10173 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10174
10175 uint pot_hashes_avail = 0;
10176
10177 uint line_num = 0;
10178
10179 while (!feof (pot_fp))
10180 {
10181 line_num++;
10182
10183 char line_buf[BUFSIZ];
10184
10185 int line_len = fgetl (pot_fp, line_buf);
10186
10187 if (line_len == 0) continue;
10188
10189 char *plain_buf = line_buf + line_len;
10190
10191 pot_t *pot_ptr = &pot[pot_cnt];
10192
10193 hash_t *hashes_buf = &pot_ptr->hash;
10194
10195 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10196 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10197
10198 if (pot_cnt == pot_hashes_avail)
10199 {
10200 uint pos = 0;
10201
10202 for (pos = 0; pos < INCR_POT; pos++)
10203 {
10204 if ((pot_cnt + pos) >= pot_avail) break;
10205
10206 pot_t *tmp_pot = &pot[pot_cnt + pos];
10207
10208 hash_t *tmp_hash = &tmp_pot->hash;
10209
10210 tmp_hash->digest = mymalloc (dgst_size);
10211
10212 if (isSalted)
10213 {
10214 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10215 }
10216
10217 if (esalt_size)
10218 {
10219 tmp_hash->esalt = mymalloc (esalt_size);
10220 }
10221
10222 pot_hashes_avail++;
10223 }
10224 }
10225
10226 int plain_len = 0;
10227
10228 int parser_status;
10229
10230 int iter = MAX_CUT_TRIES;
10231
10232 do
10233 {
10234 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10235 {
10236 if (line_buf[i] == ':')
10237 {
10238 line_len--;
10239
10240 break;
10241 }
10242 }
10243
10244 if (data.hash_mode != 2500)
10245 {
10246 parser_status = parse_func (line_buf, line_len, hashes_buf);
10247 }
10248 else
10249 {
10250 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10251
10252 if (line_len > max_salt_size)
10253 {
10254 parser_status = PARSER_GLOBAL_LENGTH;
10255 }
10256 else
10257 {
10258 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10259
10260 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10261
10262 hashes_buf->salt->salt_len = line_len;
10263
10264 parser_status = PARSER_OK;
10265 }
10266 }
10267
10268 // if NOT parsed without error, we add the ":" to the plain
10269
10270 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10271 {
10272 plain_len++;
10273 plain_buf--;
10274 }
10275
10276 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10277
10278 if (parser_status < PARSER_GLOBAL_ZERO)
10279 {
10280 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10281
10282 continue;
10283 }
10284
10285 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10286
10287 pot_ptr->plain_len = plain_len;
10288
10289 pot_cnt++;
10290 }
10291
10292 fclose (pot_fp);
10293
10294 SUPPRESS_OUTPUT = 0;
10295
10296 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10297 }
10298
10299 /**
10300 * kernel accel and loops auto adjustment
10301 */
10302
10303 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10304 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10305
10306 if (workload_profile == 1)
10307 {
10308 kernel_loops /= 8;
10309 kernel_accel /= 4;
10310
10311 if (kernel_loops == 0) kernel_loops = 8;
10312 if (kernel_accel == 0) kernel_accel = 2;
10313 }
10314 else if (workload_profile == 3)
10315 {
10316 kernel_loops *= 8;
10317 kernel_accel *= 4;
10318
10319 if (kernel_loops > 1024) kernel_loops = 1024;
10320 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10321 }
10322
10323 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10324
10325 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10326 {
10327 kernel_loops = 1024;
10328 }
10329
10330 if (hash_mode == 12500)
10331 {
10332 kernel_loops = ROUNDS_RAR3 / 16;
10333 }
10334
10335 data.kernel_accel = kernel_accel;
10336 data.kernel_loops = kernel_loops;
10337
10338 /**
10339 * word len
10340 */
10341
10342 uint pw_min = PW_MIN;
10343 uint pw_max = PW_MAX;
10344
10345 switch (hash_mode)
10346 {
10347 case 400: if (pw_max > 40) pw_max = 40;
10348 break;
10349 case 500: if (pw_max > 16) pw_max = 16;
10350 break;
10351 case 1500: if (pw_max > 8) pw_max = 8;
10352 break;
10353 case 1600: if (pw_max > 16) pw_max = 16;
10354 break;
10355 case 1800: if (pw_max > 16) pw_max = 16;
10356 break;
10357 case 2100: if (pw_max > 16) pw_max = 16;
10358 break;
10359 case 2500: if (pw_min < 8) pw_min = 8;
10360 break;
10361 case 3000: if (pw_max > 7) pw_max = 7;
10362 break;
10363 case 5200: if (pw_max > 24) pw_max = 24;
10364 break;
10365 case 5800: if (pw_max > 16) pw_max = 16;
10366 break;
10367 case 6300: if (pw_max > 16) pw_max = 16;
10368 break;
10369 case 7400: if (pw_max > 16) pw_max = 16;
10370 break;
10371 case 7900: if (pw_max > 48) pw_max = 48;
10372 break;
10373 case 8500: if (pw_max > 8) pw_max = 8;
10374 break;
10375 case 8600: if (pw_max > 16) pw_max = 16;
10376 break;
10377 case 9710: pw_min = 5;
10378 pw_max = 5;
10379 break;
10380 case 9810: pw_min = 5;
10381 pw_max = 5;
10382 break;
10383 case 10410: pw_min = 5;
10384 pw_max = 5;
10385 break;
10386 case 10300: if (pw_max < 3) pw_min = 3;
10387 if (pw_max > 40) pw_max = 40;
10388 break;
10389 case 10500: if (pw_max < 3) pw_min = 3;
10390 if (pw_max > 40) pw_max = 40;
10391 break;
10392 case 10700: if (pw_max > 16) pw_max = 16;
10393 break;
10394 case 11300: if (pw_max > 40) pw_max = 40;
10395 break;
10396 case 12500: if (pw_max > 20) pw_max = 20;
10397 break;
10398 case 12800: if (pw_max > 24) pw_max = 24;
10399 break;
10400 }
10401
10402 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10403 {
10404 switch (attack_kern)
10405 {
10406 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10407 break;
10408 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10409 break;
10410 }
10411 }
10412
10413 /**
10414 * charsets : keep them together for more easy maintainnce
10415 */
10416
10417 cs_t mp_sys[6];
10418 cs_t mp_usr[4];
10419
10420 memset (mp_sys, 0, sizeof (mp_sys));
10421 memset (mp_usr, 0, sizeof (mp_usr));
10422
10423 mp_setup_sys (mp_sys);
10424
10425 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10426 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10427 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10428 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10429
10430 /**
10431 * load hashes, part I: find input mode, count hashes
10432 */
10433
10434 uint hashlist_mode = 0;
10435 uint hashlist_format = HLFMT_HASHCAT;
10436
10437 uint hashes_avail = 0;
10438
10439 if (benchmark == 0)
10440 {
10441 struct stat f;
10442
10443 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10444
10445 if ((hash_mode == 2500) ||
10446 (hash_mode == 5200) ||
10447 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10448 (hash_mode == 9000))
10449 {
10450 hashlist_mode = HL_MODE_ARG;
10451
10452 char *hashfile = myargv[optind];
10453
10454 data.hashfile = hashfile;
10455
10456 logfile_top_var_string ("target", hashfile);
10457 }
10458
10459 if (hashlist_mode == HL_MODE_ARG)
10460 {
10461 if (hash_mode == 2500)
10462 {
10463 struct stat st;
10464
10465 if (stat (data.hashfile, &st) == -1)
10466 {
10467 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10468
10469 return (-1);
10470 }
10471
10472 hashes_avail = st.st_size / sizeof (hccap_t);
10473 }
10474 else
10475 {
10476 hashes_avail = 1;
10477 }
10478 }
10479 else if (hashlist_mode == HL_MODE_FILE)
10480 {
10481 char *hashfile = myargv[optind];
10482
10483 data.hashfile = hashfile;
10484
10485 logfile_top_var_string ("target", hashfile);
10486
10487 FILE *fp = NULL;
10488
10489 if ((fp = fopen (hashfile, "rb")) == NULL)
10490 {
10491 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10492
10493 return (-1);
10494 }
10495
10496 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10497
10498 hashes_avail = count_lines (fp);
10499
10500 rewind (fp);
10501
10502 if (hashes_avail == 0)
10503 {
10504 log_error ("ERROR: hashfile is empty or corrupt");
10505
10506 fclose (fp);
10507
10508 return (-1);
10509 }
10510
10511 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10512
10513 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10514 {
10515 log_error ("ERROR: remove not supported in native hashfile-format mode");
10516
10517 fclose (fp);
10518
10519 return (-1);
10520 }
10521
10522 fclose (fp);
10523 }
10524 }
10525 else
10526 {
10527 hashlist_mode = HL_MODE_ARG;
10528
10529 hashes_avail = 1;
10530 }
10531
10532 if (hash_mode == 3000) hashes_avail *= 2;
10533
10534 data.hashlist_mode = hashlist_mode;
10535 data.hashlist_format = hashlist_format;
10536
10537 logfile_top_uint (hashlist_mode);
10538 logfile_top_uint (hashlist_format);
10539
10540 /**
10541 * load hashes, part II: allocate required memory, set pointers
10542 */
10543
10544 hash_t *hashes_buf = NULL;
10545 void *digests_buf = NULL;
10546 salt_t *salts_buf = NULL;
10547 void *esalts_buf = NULL;
10548
10549 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10550
10551 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10552
10553 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10554 {
10555 u32 hash_pos;
10556
10557 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10558 {
10559 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10560
10561 hashes_buf[hash_pos].hash_info = hash_info;
10562
10563 if (username && (remove || show || left))
10564 {
10565 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10566 }
10567
10568 if (benchmark)
10569 {
10570 hash_info->orighash = (char *) mymalloc (256);
10571 }
10572 }
10573 }
10574
10575 if (isSalted)
10576 {
10577 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10578
10579 if (esalt_size)
10580 {
10581 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10582 }
10583 }
10584 else
10585 {
10586 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10587 }
10588
10589 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10590 {
10591 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10592
10593 if (isSalted)
10594 {
10595 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10596
10597 if (esalt_size)
10598 {
10599 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10600 }
10601 }
10602 else
10603 {
10604 hashes_buf[hash_pos].salt = &salts_buf[0];
10605 }
10606 }
10607
10608 /**
10609 * load hashes, part III: parse hashes or generate them if benchmark
10610 */
10611
10612 uint hashes_cnt = 0;
10613
10614 if (benchmark == 0)
10615 {
10616 if (keyspace == 1)
10617 {
10618 // useless to read hash file for keyspace, cheat a little bit w/ optind
10619 }
10620 else if (hashes_avail == 0)
10621 {
10622 }
10623 else if (hashlist_mode == HL_MODE_ARG)
10624 {
10625 char *input_buf = myargv[optind];
10626
10627 uint input_len = strlen (input_buf);
10628
10629 logfile_top_var_string ("target", input_buf);
10630
10631 char *hash_buf = NULL;
10632 int hash_len = 0;
10633
10634 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10635
10636 if (hash_len)
10637 {
10638 if (opts_type & OPTS_TYPE_HASH_COPY)
10639 {
10640 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10641
10642 hash_info_tmp->orighash = mystrdup (hash_buf);
10643 }
10644
10645 if (isSalted)
10646 {
10647 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10648 }
10649
10650 int parser_status = PARSER_OK;
10651
10652 if (hash_mode == 2500)
10653 {
10654 if (hash_len == 0)
10655 {
10656 log_error ("ERROR: hccap file not specified");
10657
10658 return (-1);
10659 }
10660
10661 hashlist_mode = HL_MODE_FILE;
10662
10663 data.hashlist_mode = hashlist_mode;
10664
10665 FILE *fp = fopen (hash_buf, "rb");
10666
10667 if (fp == NULL)
10668 {
10669 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10670
10671 return (-1);
10672 }
10673
10674 if (hashes_avail < 1)
10675 {
10676 log_error ("ERROR: hccap file is empty or corrupt");
10677
10678 fclose (fp);
10679
10680 return (-1);
10681 }
10682
10683 uint hccap_size = sizeof (hccap_t);
10684
10685 char in[hccap_size];
10686
10687 while (!feof (fp))
10688 {
10689 int n = fread (&in, hccap_size, 1, fp);
10690
10691 if (n != 1)
10692 {
10693 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10694
10695 break;
10696 }
10697
10698 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10699
10700 if (parser_status != PARSER_OK)
10701 {
10702 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10703
10704 continue;
10705 }
10706
10707 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10708
10709 if ((show == 1) || (left == 1))
10710 {
10711 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10712
10713 char *salt_ptr = (char *) tmp_salt->salt_buf;
10714
10715 int cur_pos = tmp_salt->salt_len;
10716 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10717
10718 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10719
10720 u8 *pke_ptr = (u8 *) wpa->pke;
10721
10722 // do the appending task
10723
10724 snprintf (salt_ptr + cur_pos,
10725 rem_len,
10726 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10727 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10728 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10729
10730
10731 // memset () the remaining part of the salt
10732
10733 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10734 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10735
10736 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10737
10738 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10739 }
10740
10741 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);
10742 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);
10743
10744 hashes_cnt++;
10745 }
10746
10747 fclose (fp);
10748 }
10749 else if (hash_mode == 3000)
10750 {
10751 if (hash_len == 32)
10752 {
10753 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10754
10755 hash_t *lm_hash_left = NULL;
10756
10757 if (parser_status == PARSER_OK)
10758 {
10759 lm_hash_left = &hashes_buf[hashes_cnt];
10760
10761 hashes_cnt++;
10762 }
10763 else
10764 {
10765 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10766 }
10767
10768
10769 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10770
10771 hash_t *lm_hash_right = NULL;
10772
10773 if (parser_status == PARSER_OK)
10774 {
10775 lm_hash_right = &hashes_buf[hashes_cnt];
10776
10777 hashes_cnt++;
10778 }
10779 else
10780 {
10781 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10782 }
10783
10784 // show / left
10785
10786 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10787 {
10788 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);
10789 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);
10790 }
10791 }
10792 else
10793 {
10794 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10795
10796 if (parser_status == PARSER_OK)
10797 {
10798 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10799 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10800 }
10801
10802 if (parser_status == PARSER_OK)
10803 {
10804 hashes_cnt++;
10805 }
10806 else
10807 {
10808 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10809 }
10810 }
10811 }
10812 else
10813 {
10814 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10815
10816 if (parser_status == PARSER_OK)
10817 {
10818 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10819 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10820 }
10821
10822 if (parser_status == PARSER_OK)
10823 {
10824 hashes_cnt++;
10825 }
10826 else
10827 {
10828 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10829 }
10830 }
10831 }
10832 }
10833 else if (hashlist_mode == HL_MODE_FILE)
10834 {
10835 char *hashfile = data.hashfile;
10836
10837 FILE *fp;
10838
10839 if ((fp = fopen (hashfile, "rb")) == NULL)
10840 {
10841 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10842
10843 return (-1);
10844 }
10845
10846 uint line_num = 0;
10847
10848 while (!feof (fp))
10849 {
10850 line_num++;
10851
10852 char line_buf[BUFSIZ];
10853
10854 int line_len = fgetl (fp, line_buf);
10855
10856 if (line_len == 0) continue;
10857
10858 char *hash_buf = NULL;
10859 int hash_len = 0;
10860
10861 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10862
10863 if (username)
10864 {
10865 char *user_buf = NULL;
10866 int user_len = 0;
10867
10868 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10869
10870 if (remove || show)
10871 {
10872 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10873
10874 *user = (user_t *) malloc (sizeof (user_t));
10875
10876 user_t *user_ptr = *user;
10877
10878 if (user_buf != NULL)
10879 {
10880 user_ptr->user_name = mystrdup (user_buf);
10881 }
10882 else
10883 {
10884 user_ptr->user_name = mystrdup ("");
10885 }
10886
10887 user_ptr->user_len = user_len;
10888 }
10889 }
10890
10891 if (opts_type & OPTS_TYPE_HASH_COPY)
10892 {
10893 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10894
10895 hash_info_tmp->orighash = mystrdup (hash_buf);
10896 }
10897
10898 if (isSalted)
10899 {
10900 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10901 }
10902
10903 if (hash_mode == 3000)
10904 {
10905 if (hash_len == 32)
10906 {
10907 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10908
10909 if (parser_status < PARSER_GLOBAL_ZERO)
10910 {
10911 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10912
10913 continue;
10914 }
10915
10916 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10917
10918 hashes_cnt++;
10919
10920 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10921
10922 if (parser_status < PARSER_GLOBAL_ZERO)
10923 {
10924 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10925
10926 continue;
10927 }
10928
10929 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10930
10931 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);
10932
10933 hashes_cnt++;
10934
10935 // show / left
10936
10937 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);
10938 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);
10939 }
10940 else
10941 {
10942 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10943
10944 if (parser_status < PARSER_GLOBAL_ZERO)
10945 {
10946 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10947
10948 continue;
10949 }
10950
10951 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);
10952
10953 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10954 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10955
10956 hashes_cnt++;
10957 }
10958 }
10959 else
10960 {
10961 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10962
10963 if (parser_status < PARSER_GLOBAL_ZERO)
10964 {
10965 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10966
10967 continue;
10968 }
10969
10970 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);
10971
10972 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10973 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10974
10975 hashes_cnt++;
10976 }
10977 }
10978
10979 fclose (fp);
10980
10981 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10982
10983 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10984 }
10985 }
10986 else
10987 {
10988 if (isSalted)
10989 {
10990 hashes_buf[0].salt->salt_len = 8;
10991
10992 // special salt handling
10993
10994 switch (hash_mode)
10995 {
10996 case 1500: hashes_buf[0].salt->salt_len = 2;
10997 break;
10998 case 1731: hashes_buf[0].salt->salt_len = 4;
10999 break;
11000 case 2410: hashes_buf[0].salt->salt_len = 4;
11001 break;
11002 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11003 break;
11004 case 3100: hashes_buf[0].salt->salt_len = 1;
11005 break;
11006 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11007 break;
11008 case 5800: hashes_buf[0].salt->salt_len = 16;
11009 break;
11010 case 6800: hashes_buf[0].salt->salt_len = 32;
11011 break;
11012 case 8400: hashes_buf[0].salt->salt_len = 40;
11013 break;
11014 case 8800: hashes_buf[0].salt->salt_len = 16;
11015 break;
11016 case 8900: hashes_buf[0].salt->salt_len = 16;
11017 hashes_buf[0].salt->scrypt_N = 1024;
11018 hashes_buf[0].salt->scrypt_r = 1;
11019 hashes_buf[0].salt->scrypt_p = 1;
11020 break;
11021 case 9100: hashes_buf[0].salt->salt_len = 16;
11022 break;
11023 case 9300: hashes_buf[0].salt->salt_len = 14;
11024 hashes_buf[0].salt->scrypt_N = 16384;
11025 hashes_buf[0].salt->scrypt_r = 1;
11026 hashes_buf[0].salt->scrypt_p = 1;
11027 break;
11028 case 9400: hashes_buf[0].salt->salt_len = 16;
11029 break;
11030 case 9500: hashes_buf[0].salt->salt_len = 16;
11031 break;
11032 case 9600: hashes_buf[0].salt->salt_len = 16;
11033 break;
11034 case 9700: hashes_buf[0].salt->salt_len = 16;
11035 break;
11036 case 9710: hashes_buf[0].salt->salt_len = 16;
11037 break;
11038 case 9720: hashes_buf[0].salt->salt_len = 16;
11039 break;
11040 case 9800: hashes_buf[0].salt->salt_len = 16;
11041 break;
11042 case 9810: hashes_buf[0].salt->salt_len = 16;
11043 break;
11044 case 9820: hashes_buf[0].salt->salt_len = 16;
11045 break;
11046 case 10300: hashes_buf[0].salt->salt_len = 12;
11047 break;
11048 case 11500: hashes_buf[0].salt->salt_len = 4;
11049 break;
11050 case 11600: hashes_buf[0].salt->salt_len = 4;
11051 break;
11052 case 12400: hashes_buf[0].salt->salt_len = 4;
11053 break;
11054 case 12500: hashes_buf[0].salt->salt_len = 8;
11055 break;
11056 case 12600: hashes_buf[0].salt->salt_len = 64;
11057 break;
11058 }
11059
11060 // special esalt handling
11061
11062 switch (hash_mode)
11063 {
11064 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11065 break;
11066 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11067 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11068 break;
11069 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11070 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11071 break;
11072 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11073 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11074 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11075 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11076 break;
11077 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11078 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11079 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11080 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11081 break;
11082 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11083 break;
11084 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11085 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11086 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11087 break;
11088 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11089 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11090 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11091 break;
11092 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11093 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11094 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11095 break;
11096 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11097 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11098 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11099 break;
11100 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11101 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11102 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11103 break;
11104 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11105 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11106 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11107 break;
11108 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11109 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11110 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11111 break;
11112 }
11113 }
11114
11115 // set hashfile
11116
11117 switch (hash_mode)
11118 {
11119 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11120 break;
11121 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11122 break;
11123 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11124 break;
11125 case 6211:
11126 case 6212:
11127 case 6213:
11128 case 6221:
11129 case 6222:
11130 case 6223:
11131 case 6231:
11132 case 6232:
11133 case 6233:
11134 case 6241:
11135 case 6242:
11136 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11137 break;
11138 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11139 break;
11140 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11141 break;
11142 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11143 break;
11144 }
11145
11146 // set default iterations
11147
11148 switch (hash_mode)
11149 {
11150 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11151 break;
11152 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11153 break;
11154 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11155 break;
11156 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11157 break;
11158 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11159 break;
11160 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11161 break;
11162 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11163 break;
11164 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11165 break;
11166 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11167 break;
11168 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11169 break;
11170 case 6211:
11171 case 6212:
11172 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11173 break;
11174 case 6221:
11175 case 6222:
11176 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11177 break;
11178 case 6231:
11179 case 6232:
11180 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11181 break;
11182 case 6241:
11183 case 6242:
11184 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11185 break;
11186 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11187 break;
11188 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11189 break;
11190 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11191 break;
11192 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11193 break;
11194 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11195 break;
11196 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11197 break;
11198 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11199 break;
11200 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11201 break;
11202 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11203 break;
11204 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11205 break;
11206 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11207 break;
11208 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11209 break;
11210 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11211 break;
11212 case 8900: hashes_buf[0].salt->salt_iter = 1;
11213 break;
11214 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11215 break;
11216 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11217 break;
11218 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11219 break;
11220 case 9300: hashes_buf[0].salt->salt_iter = 1;
11221 break;
11222 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11223 break;
11224 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11225 break;
11226 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11227 break;
11228 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11229 break;
11230 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11231 break;
11232 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11233 break;
11234 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11235 break;
11236 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11237 break;
11238 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11239 break;
11240 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11241 break;
11242 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11243 break;
11244 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11245 break;
11246 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11247 break;
11248 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11249 break;
11250 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11251 break;
11252 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11253 break;
11254 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11255 break;
11256 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11257 break;
11258 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11259 break;
11260 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11261 break;
11262 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11263 break;
11264 }
11265
11266 // set special tuning for benchmark-mode 1
11267
11268 if (benchmark_mode == 1)
11269 {
11270 kernel_loops *= 8;
11271 kernel_accel *= 4;
11272
11273 switch (hash_mode)
11274 {
11275 case 400: kernel_loops = ROUNDS_PHPASS;
11276 kernel_accel = 32;
11277 break;
11278 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11279 kernel_accel = 32;
11280 break;
11281 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11282 kernel_accel = 32;
11283 break;
11284 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11285 kernel_accel = 32;
11286 break;
11287 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11288 kernel_accel = 16;
11289 break;
11290 case 2100: kernel_loops = ROUNDS_DCC2;
11291 kernel_accel = 16;
11292 break;
11293 case 2500: kernel_loops = ROUNDS_WPA2;
11294 kernel_accel = 32;
11295 break;
11296 case 3200: kernel_loops = ROUNDS_BCRYPT;
11297 kernel_accel = 8;
11298 break;
11299 case 5200: kernel_loops = ROUNDS_PSAFE3;
11300 kernel_accel = 16;
11301 break;
11302 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11303 kernel_accel = 16;
11304 break;
11305 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11306 kernel_accel = 64;
11307 break;
11308 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11309 kernel_accel = 32;
11310 break;
11311 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11312 kernel_accel = 32;
11313 break;
11314 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11315 kernel_accel = 8;
11316 break;
11317 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11318 kernel_accel = 8;
11319 break;
11320 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11321 kernel_accel = 8;
11322 break;
11323 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11324 kernel_accel = 8;
11325 break;
11326 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11327 kernel_accel = 8;
11328 break;
11329 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11330 kernel_accel = 8;
11331 break;
11332 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11333 kernel_accel = 128;
11334 break;
11335 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11336 kernel_accel = 64;
11337 break;
11338 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11339 kernel_accel = 64;
11340 break;
11341 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11342 kernel_accel = 32;
11343 break;
11344 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11345 kernel_accel = 128;
11346 break;
11347 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11348 kernel_accel = 128;
11349 break;
11350 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11351 kernel_accel = 32;
11352 break;
11353 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11354 kernel_accel = 64;
11355 break;
11356 case 6800: kernel_loops = ROUNDS_LASTPASS;
11357 kernel_accel = 64;
11358 break;
11359 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11360 kernel_accel = 8;
11361 break;
11362 case 7200: kernel_loops = ROUNDS_GRUB;
11363 kernel_accel = 16;
11364 break;
11365 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11366 kernel_accel = 8;
11367 break;
11368 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11369 kernel_accel = 8;
11370 break;
11371 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11372 kernel_accel = 8;
11373 break;
11374 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11375 kernel_accel = 32;
11376 break;
11377 case 8900: kernel_loops = 1;
11378 kernel_accel = 64;
11379 break;
11380 case 9000: kernel_loops = ROUNDS_PSAFE2;
11381 kernel_accel = 16;
11382 break;
11383 case 9100: kernel_loops = ROUNDS_LOTUS8;
11384 kernel_accel = 64;
11385 break;
11386 case 9200: kernel_loops = ROUNDS_CISCO8;
11387 kernel_accel = 8;
11388 break;
11389 case 9300: kernel_loops = 1;
11390 kernel_accel = 4;
11391 break;
11392 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11393 kernel_accel = 32;
11394 break;
11395 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11396 kernel_accel = 32;
11397 break;
11398 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11399 kernel_accel = 8;
11400 break;
11401 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11402 kernel_accel = 8;
11403 break;
11404 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11405 kernel_accel = 16;
11406 break;
11407 case 10500: kernel_loops = ROUNDS_PDF14;
11408 kernel_accel = 256;
11409 break;
11410 case 10700: kernel_loops = ROUNDS_PDF17L8;
11411 kernel_accel = 8;
11412 break;
11413 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11414 kernel_accel = 8;
11415 break;
11416 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11417 kernel_accel = 8;
11418 break;
11419 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11420 kernel_accel = 8;
11421 break;
11422 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11423 kernel_accel = 8;
11424 break;
11425 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11426 kernel_accel = 8;
11427 break;
11428 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11429 kernel_accel = 8;
11430 break;
11431 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11432 kernel_accel = 8;
11433 break;
11434 case 12300: kernel_loops = ROUNDS_ORACLET;
11435 kernel_accel = 8;
11436 break;
11437 case 12500: kernel_loops = ROUNDS_RAR3;
11438 kernel_accel = 32;
11439 break;
11440 case 12700: kernel_loops = ROUNDS_MYWALLET;
11441 kernel_accel = 512;
11442 break;
11443 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11444 kernel_accel = 512;
11445 break;
11446 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11447 kernel_accel = 8;
11448 break;
11449 case 13000: kernel_loops = ROUNDS_RAR5;
11450 kernel_accel = 8;
11451 break;
11452 }
11453
11454 // some algorithm collide too fast, make that impossible
11455
11456 switch (hash_mode)
11457 {
11458 case 11500: ((uint *) digests_buf)[1] = 1;
11459 break;
11460 }
11461
11462 if (kernel_loops > 1024) kernel_loops = 1024;
11463 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11464 }
11465
11466 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11467 {
11468 kernel_loops = 1024;
11469 }
11470
11471 if (hash_mode == 12500)
11472 {
11473 kernel_loops = ROUNDS_RAR3 / 16;
11474 }
11475
11476 data.kernel_accel = kernel_accel;
11477 data.kernel_loops = kernel_loops;
11478
11479 hashes_cnt = 1;
11480 }
11481
11482 if (show == 1 || left == 1)
11483 {
11484 for (uint i = 0; i < pot_cnt; i++)
11485 {
11486 pot_t *pot_ptr = &pot[i];
11487
11488 hash_t *hashes_buf = &pot_ptr->hash;
11489
11490 local_free (hashes_buf->digest);
11491
11492 if (isSalted)
11493 {
11494 local_free (hashes_buf->salt);
11495 }
11496 }
11497
11498 local_free (pot);
11499
11500 if (data.quiet == 0) log_info_nn ("");
11501
11502 return (0);
11503 }
11504
11505 if (keyspace == 0)
11506 {
11507 if (hashes_cnt == 0)
11508 {
11509 log_error ("ERROR: No hashes loaded");
11510
11511 return (-1);
11512 }
11513 }
11514
11515 /**
11516 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11517 */
11518
11519 if (data.outfile != NULL)
11520 {
11521 if (data.hashfile != NULL)
11522 {
11523 #ifdef _POSIX
11524 struct stat tmpstat_outfile;
11525 struct stat tmpstat_hashfile;
11526 #endif
11527
11528 #ifdef _WIN
11529 struct stat64 tmpstat_outfile;
11530 struct stat64 tmpstat_hashfile;
11531 #endif
11532
11533 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11534
11535 if (tmp_outfile_fp)
11536 {
11537 #ifdef _POSIX
11538 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11539 #endif
11540
11541 #ifdef _WIN
11542 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11543 #endif
11544
11545 fclose (tmp_outfile_fp);
11546 }
11547
11548 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11549
11550 if (tmp_hashfile_fp)
11551 {
11552 #ifdef _POSIX
11553 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11554 #endif
11555
11556 #ifdef _WIN
11557 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11558 #endif
11559
11560 fclose (tmp_hashfile_fp);
11561 }
11562
11563 if (tmp_outfile_fp && tmp_outfile_fp)
11564 {
11565 tmpstat_outfile.st_mode = 0;
11566 tmpstat_outfile.st_nlink = 0;
11567 tmpstat_outfile.st_uid = 0;
11568 tmpstat_outfile.st_gid = 0;
11569 tmpstat_outfile.st_rdev = 0;
11570 tmpstat_outfile.st_atime = 0;
11571
11572 tmpstat_hashfile.st_mode = 0;
11573 tmpstat_hashfile.st_nlink = 0;
11574 tmpstat_hashfile.st_uid = 0;
11575 tmpstat_hashfile.st_gid = 0;
11576 tmpstat_hashfile.st_rdev = 0;
11577 tmpstat_hashfile.st_atime = 0;
11578
11579 #ifdef _POSIX
11580 tmpstat_outfile.st_blksize = 0;
11581 tmpstat_outfile.st_blocks = 0;
11582
11583 tmpstat_hashfile.st_blksize = 0;
11584 tmpstat_hashfile.st_blocks = 0;
11585 #endif
11586
11587 #ifdef _POSIX
11588 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11589 {
11590 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11591
11592 return (-1);
11593 }
11594 #endif
11595
11596 #ifdef _WIN
11597 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11598 {
11599 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11600
11601 return (-1);
11602 }
11603 #endif
11604 }
11605 }
11606 }
11607
11608 /**
11609 * Remove duplicates
11610 */
11611
11612 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11613
11614 if (isSalted)
11615 {
11616 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11617 }
11618 else
11619 {
11620 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11621 }
11622
11623 uint hashes_cnt_orig = hashes_cnt;
11624
11625 hashes_cnt = 1;
11626
11627 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11628 {
11629 if (isSalted)
11630 {
11631 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11632 {
11633 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11634 }
11635 }
11636 else
11637 {
11638 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11639 }
11640
11641 if (hashes_pos > hashes_cnt)
11642 {
11643 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11644 }
11645
11646 hashes_cnt++;
11647 }
11648
11649 /**
11650 * Potfile removes
11651 */
11652
11653 uint potfile_remove_cracks = 0;
11654
11655 if (potfile_disable == 0)
11656 {
11657 hash_t hash_buf;
11658
11659 hash_buf.digest = mymalloc (dgst_size);
11660 hash_buf.salt = NULL;
11661 hash_buf.esalt = NULL;
11662 hash_buf.hash_info = NULL;
11663 hash_buf.cracked = 0;
11664
11665 if (isSalted)
11666 {
11667 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11668 }
11669
11670 if (esalt_size)
11671 {
11672 hash_buf.esalt = mymalloc (esalt_size);
11673 }
11674
11675 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11676
11677 // no solution for these special hash types (for instane because they use hashfile in output etc)
11678 if ((hash_mode != 5200) &&
11679 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11680 (hash_mode != 9000))
11681 {
11682 FILE *fp = fopen (potfile, "rb");
11683
11684 if (fp != NULL)
11685 {
11686 while (!feof (fp))
11687 {
11688 char line_buf[BUFSIZ];
11689
11690 memset (line_buf, 0, BUFSIZ);
11691
11692 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11693
11694 if (ptr == NULL) break;
11695
11696 int line_len = strlen (line_buf);
11697
11698 if (line_len == 0) continue;
11699
11700 int iter = MAX_CUT_TRIES;
11701
11702 for (int i = line_len - 1; i && iter; i--, line_len--)
11703 {
11704 if (line_buf[i] != ':') continue;
11705
11706 if (isSalted)
11707 {
11708 memset (hash_buf.salt, 0, sizeof (salt_t));
11709 }
11710
11711 hash_t *found = NULL;
11712
11713 if (hash_mode == 6800)
11714 {
11715 if (i < 48) // 48 = 12 * uint in salt_buf[]
11716 {
11717 // manipulate salt_buf
11718 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11719
11720 hash_buf.salt->salt_len = i;
11721
11722 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11723 }
11724 }
11725 else if (hash_mode == 2500)
11726 {
11727 if (i < 48) // 48 = 12 * uint in salt_buf[]
11728 {
11729 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11730 // manipulate salt_buf
11731
11732 // to be safe work with a copy (because of line_len loop, i etc)
11733
11734 char line_buf_cpy[BUFSIZ];
11735 memset (line_buf_cpy, 0, BUFSIZ);
11736
11737 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11738
11739 memcpy (line_buf_cpy, line_buf, i);
11740
11741 char *mac2_pos = strrchr (line_buf_cpy, ':');
11742
11743 if (mac2_pos == NULL) continue;
11744
11745 mac2_pos[0] = 0;
11746 mac2_pos++;
11747
11748 if (strlen (mac2_pos) != 12) continue;
11749
11750 char *mac1_pos = strrchr (line_buf_cpy, ':');
11751
11752 if (mac1_pos == NULL) continue;
11753
11754 mac1_pos[0] = 0;
11755 mac1_pos++;
11756
11757 if (strlen (mac1_pos) != 12) continue;
11758
11759 uint essid_length = mac1_pos - line_buf_cpy - 1;
11760
11761 // here we need the ESSID
11762 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11763
11764 hash_buf.salt->salt_len = essid_length;
11765
11766 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11767
11768 if (found)
11769 {
11770 wpa_t *wpa = (wpa_t *) found->esalt;
11771
11772 uint pke[25];
11773
11774 char *pke_ptr = (char *) pke;
11775
11776 for (uint i = 0; i < 25; i++)
11777 {
11778 pke[i] = byte_swap_32 (wpa->pke[i]);
11779 }
11780
11781 u8 mac1[6];
11782 u8 mac2[6];
11783
11784 memcpy (mac1, pke_ptr + 23, 6);
11785 memcpy (mac2, pke_ptr + 29, 6);
11786
11787 // compare hex string(s) vs binary MAC address(es)
11788
11789 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11790 {
11791 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11792 {
11793 found = NULL;
11794 break;
11795 }
11796 }
11797
11798 // early skip ;)
11799 if (!found) continue;
11800
11801 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11802 {
11803 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11804 {
11805 found = NULL;
11806 break;
11807 }
11808 }
11809 }
11810 }
11811 }
11812 else
11813 {
11814 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11815
11816 if (parser_status == PARSER_OK)
11817 {
11818 if (isSalted)
11819 {
11820 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11821 }
11822 else
11823 {
11824 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11825 }
11826 }
11827 }
11828
11829 if (found == NULL) continue;
11830
11831 if (!found->cracked) potfile_remove_cracks++;
11832
11833 found->cracked = 1;
11834
11835 if (found) break;
11836
11837 iter--;
11838 }
11839 }
11840
11841 fclose (fp);
11842 }
11843 }
11844
11845 if (esalt_size)
11846 {
11847 local_free (hash_buf.esalt);
11848 }
11849
11850 if (isSalted)
11851 {
11852 local_free (hash_buf.salt);
11853 }
11854
11855 local_free (hash_buf.digest);
11856 }
11857
11858 /**
11859 * Now generate all the buffers required for later
11860 */
11861
11862 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11863
11864 salt_t *salts_buf_new = NULL;
11865 void *esalts_buf_new = NULL;
11866
11867 if (isSalted)
11868 {
11869 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11870
11871 if (esalt_size)
11872 {
11873 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11874 }
11875 }
11876 else
11877 {
11878 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11879 }
11880
11881 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11882
11883 uint digests_cnt = hashes_cnt;
11884 uint digests_done = 0;
11885
11886 uint size_digests = digests_cnt * dgst_size;
11887 uint size_shown = digests_cnt * sizeof (uint);
11888
11889 uint *digests_shown = (uint *) mymalloc (size_shown);
11890 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11891
11892 uint salts_cnt = 0;
11893 uint salts_done = 0;
11894
11895 hashinfo_t **hash_info = NULL;
11896
11897 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11898 {
11899 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11900
11901 if (username && (remove || show))
11902 {
11903 uint user_pos;
11904
11905 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11906 {
11907 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11908
11909 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11910 }
11911 }
11912 }
11913
11914 uint *salts_shown = (uint *) mymalloc (size_shown);
11915
11916 salt_t *salt_buf;
11917
11918 {
11919 // copied from inner loop
11920
11921 salt_buf = &salts_buf_new[salts_cnt];
11922
11923 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11924
11925 if (esalt_size)
11926 {
11927 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11928 }
11929
11930 salt_buf->digests_cnt = 0;
11931 salt_buf->digests_done = 0;
11932 salt_buf->digests_offset = 0;
11933
11934 salts_cnt++;
11935 }
11936
11937 if (hashes_buf[0].cracked == 1)
11938 {
11939 digests_shown[0] = 1;
11940
11941 digests_done++;
11942
11943 salt_buf->digests_done++;
11944 }
11945
11946 salt_buf->digests_cnt++;
11947
11948 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11949
11950 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11951 {
11952 hash_info[0] = hashes_buf[0].hash_info;
11953 }
11954
11955 // copy from inner loop
11956
11957 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11958 {
11959 if (isSalted)
11960 {
11961 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11962 {
11963 salt_buf = &salts_buf_new[salts_cnt];
11964
11965 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11966
11967 if (esalt_size)
11968 {
11969 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11970 }
11971
11972 salt_buf->digests_cnt = 0;
11973 salt_buf->digests_done = 0;
11974 salt_buf->digests_offset = hashes_pos;
11975
11976 salts_cnt++;
11977 }
11978 }
11979
11980 if (hashes_buf[hashes_pos].cracked == 1)
11981 {
11982 digests_shown[hashes_pos] = 1;
11983
11984 digests_done++;
11985
11986 salt_buf->digests_done++;
11987 }
11988
11989 salt_buf->digests_cnt++;
11990
11991 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11992
11993 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11994 {
11995 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11996 }
11997 }
11998
11999 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12000 {
12001 salt_t *salt_buf = &salts_buf_new[salt_pos];
12002
12003 if (salt_buf->digests_done == salt_buf->digests_cnt)
12004 {
12005 salts_shown[salt_pos] = 1;
12006
12007 salts_done++;
12008 }
12009
12010 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12011 }
12012
12013 local_free (digests_buf);
12014 local_free (salts_buf);
12015 local_free (esalts_buf);
12016
12017 digests_buf = digests_buf_new;
12018 salts_buf = salts_buf_new;
12019 esalts_buf = esalts_buf_new;
12020
12021 local_free (hashes_buf);
12022
12023 /**
12024 * special modification not set from parser
12025 */
12026
12027 switch (hash_mode)
12028 {
12029 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12030 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12031 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12032 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12033 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12034 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12035 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12036 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12037 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12038 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12039 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12040 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12041 }
12042
12043 if (truecrypt_keyfiles)
12044 {
12045 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12046
12047 char *keyfiles = strdup (truecrypt_keyfiles);
12048
12049 char *keyfile = strtok (keyfiles, ",");
12050
12051 do
12052 {
12053 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12054
12055 } while ((keyfile = strtok (NULL, ",")) != NULL);
12056
12057 free (keyfiles);
12058 }
12059
12060 data.digests_cnt = digests_cnt;
12061 data.digests_done = digests_done;
12062 data.digests_buf = digests_buf;
12063 data.digests_shown = digests_shown;
12064 data.digests_shown_tmp = digests_shown_tmp;
12065
12066 data.salts_cnt = salts_cnt;
12067 data.salts_done = salts_done;
12068 data.salts_buf = salts_buf;
12069 data.salts_shown = salts_shown;
12070
12071 data.esalts_buf = esalts_buf;
12072 data.hash_info = hash_info;
12073
12074 /**
12075 * Automatic Optimizers
12076 */
12077
12078 if (salts_cnt == 1)
12079 opti_type |= OPTI_TYPE_SINGLE_SALT;
12080
12081 if (digests_cnt == 1)
12082 opti_type |= OPTI_TYPE_SINGLE_HASH;
12083
12084 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12085 opti_type |= OPTI_TYPE_NOT_ITERATED;
12086
12087 if (attack_mode == ATTACK_MODE_BF)
12088 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12089
12090 data.opti_type = opti_type;
12091
12092 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12093 {
12094 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12095 {
12096 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12097 {
12098 if (opts_type & OPTS_TYPE_ST_ADD80)
12099 {
12100 opts_type &= ~OPTS_TYPE_ST_ADD80;
12101 opts_type |= OPTS_TYPE_PT_ADD80;
12102 }
12103
12104 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12105 {
12106 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12107 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12108 }
12109
12110 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12111 {
12112 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12113 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12114 }
12115 }
12116 }
12117 }
12118
12119 /**
12120 * Some algorithm, like descrypt, can benefit from JIT compilation
12121 */
12122
12123 uint force_jit_compilation = 0;
12124
12125 if (hash_mode == 8900)
12126 {
12127 force_jit_compilation = 8900;
12128 }
12129 else if (hash_mode == 9300)
12130 {
12131 force_jit_compilation = 8900;
12132 }
12133 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12134 {
12135 force_jit_compilation = 1500;
12136 }
12137
12138 /**
12139 * generate bitmap tables
12140 */
12141
12142 const uint bitmap_shift1 = 5;
12143 const uint bitmap_shift2 = 13;
12144
12145 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12146
12147 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12148 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12149 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12150 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12151 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12152 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12153 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12154 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12155
12156 uint bitmap_bits;
12157 uint bitmap_nums;
12158 uint bitmap_mask;
12159 uint bitmap_size;
12160
12161 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12162 {
12163 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12164
12165 bitmap_nums = 1 << bitmap_bits;
12166
12167 bitmap_mask = bitmap_nums - 1;
12168
12169 bitmap_size = bitmap_nums * sizeof (uint);
12170
12171 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12172
12173 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;
12174 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;
12175
12176 break;
12177 }
12178
12179 bitmap_nums = 1 << bitmap_bits;
12180
12181 bitmap_mask = bitmap_nums - 1;
12182
12183 bitmap_size = bitmap_nums * sizeof (uint);
12184
12185 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);
12186 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);
12187
12188 /**
12189 * prepare quick rule
12190 */
12191
12192 data.rule_buf_l = rule_buf_l;
12193 data.rule_buf_r = rule_buf_r;
12194
12195 int rule_len_l = (int) strlen (rule_buf_l);
12196 int rule_len_r = (int) strlen (rule_buf_r);
12197
12198 data.rule_len_l = rule_len_l;
12199 data.rule_len_r = rule_len_r;
12200
12201 /**
12202 * load rules
12203 */
12204
12205 uint *all_kernel_rules_cnt = NULL;
12206
12207 kernel_rule_t **all_kernel_rules_buf = NULL;
12208
12209 if (rp_files_cnt)
12210 {
12211 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12212
12213 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12214 }
12215
12216 char rule_buf[BUFSIZ];
12217
12218 int rule_len = 0;
12219
12220 for (uint i = 0; i < rp_files_cnt; i++)
12221 {
12222 uint kernel_rules_avail = 0;
12223
12224 uint kernel_rules_cnt = 0;
12225
12226 kernel_rule_t *kernel_rules_buf = NULL;
12227
12228 char *rp_file = rp_files[i];
12229
12230 char in[BLOCK_SIZE];
12231 char out[BLOCK_SIZE];
12232
12233 FILE *fp = NULL;
12234
12235 uint rule_line = 0;
12236
12237 if ((fp = fopen (rp_file, "rb")) == NULL)
12238 {
12239 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12240
12241 return (-1);
12242 }
12243
12244 while (!feof (fp))
12245 {
12246 memset (rule_buf, 0, BUFSIZ);
12247
12248 rule_len = fgetl (fp, rule_buf);
12249
12250 rule_line++;
12251
12252 if (rule_len == 0) continue;
12253
12254 if (rule_buf[0] == '#') continue;
12255
12256 if (kernel_rules_avail == kernel_rules_cnt)
12257 {
12258 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12259
12260 kernel_rules_avail += INCR_RULES;
12261 }
12262
12263 memset (in, 0, BLOCK_SIZE);
12264 memset (out, 0, BLOCK_SIZE);
12265
12266 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12267
12268 if (result == -1)
12269 {
12270 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12271
12272 continue;
12273 }
12274
12275 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12276 {
12277 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12278
12279 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12280
12281 continue;
12282 }
12283
12284 /* its so slow
12285 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12286 {
12287 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12288
12289 continue;
12290 }
12291 */
12292
12293 kernel_rules_cnt++;
12294 }
12295
12296 fclose (fp);
12297
12298 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12299
12300 all_kernel_rules_buf[i] = kernel_rules_buf;
12301 }
12302
12303 /**
12304 * merge rules or automatic rule generator
12305 */
12306
12307 uint kernel_rules_cnt = 0;
12308
12309 kernel_rule_t *kernel_rules_buf = NULL;
12310
12311 if (attack_mode == ATTACK_MODE_STRAIGHT)
12312 {
12313 if (rp_files_cnt)
12314 {
12315 kernel_rules_cnt = 1;
12316
12317 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12318
12319 repeats[0] = kernel_rules_cnt;
12320
12321 for (uint i = 0; i < rp_files_cnt; i++)
12322 {
12323 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12324
12325 repeats[i + 1] = kernel_rules_cnt;
12326 }
12327
12328 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12329
12330 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12331
12332 for (uint i = 0; i < kernel_rules_cnt; i++)
12333 {
12334 uint out_pos = 0;
12335
12336 kernel_rule_t *out = &kernel_rules_buf[i];
12337
12338 for (uint j = 0; j < rp_files_cnt; j++)
12339 {
12340 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12341 uint in_pos;
12342
12343 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12344
12345 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12346 {
12347 if (out_pos == RULES_MAX - 1)
12348 {
12349 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12350
12351 break;
12352 }
12353
12354 out->cmds[out_pos] = in->cmds[in_pos];
12355 }
12356 }
12357 }
12358
12359 local_free (repeats);
12360 }
12361 else if (rp_gen)
12362 {
12363 uint kernel_rules_avail = 0;
12364
12365 while (kernel_rules_cnt < rp_gen)
12366 {
12367 if (kernel_rules_avail == kernel_rules_cnt)
12368 {
12369 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12370
12371 kernel_rules_avail += INCR_RULES;
12372 }
12373
12374 memset (rule_buf, 0, BLOCK_SIZE);
12375
12376 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12377
12378 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12379
12380 kernel_rules_cnt++;
12381 }
12382 }
12383 }
12384
12385 /**
12386 * generate NOP rules
12387 */
12388
12389 if (kernel_rules_cnt == 0)
12390 {
12391 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12392
12393 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12394
12395 kernel_rules_cnt++;
12396 }
12397
12398 data.kernel_rules_cnt = kernel_rules_cnt;
12399 data.kernel_rules_buf = kernel_rules_buf;
12400
12401 /**
12402 * OpenCL platforms: detect
12403 */
12404
12405 cl_platform_id platforms[CL_PLATFORMS_MAX];
12406
12407 cl_uint platforms_cnt = 0;
12408
12409 cl_device_id platform_devices[DEVICES_MAX];
12410
12411 cl_uint platform_devices_cnt;
12412
12413 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12414
12415 if (platforms_cnt == 0)
12416 {
12417 log_error ("ERROR: No OpenCL compatible platform found");
12418
12419 return (-1);
12420 }
12421
12422 /**
12423 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12424 */
12425
12426 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12427 {
12428 cl_platform_id platform = platforms[platform_id];
12429
12430 char platform_vendor[INFOSZ];
12431
12432 memset (platform_vendor, 0, sizeof (platform_vendor));
12433
12434 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12435
12436 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12437 {
12438 // make sure that we do not directly control the fan for NVidia
12439
12440 gpu_temp_retain = 0;
12441
12442 data.gpu_temp_retain = gpu_temp_retain;
12443 }
12444 }
12445
12446 /**
12447 * OpenCL devices: simply push all devices from all platforms into the same device array
12448 */
12449
12450 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12451
12452 data.devices_param = devices_param;
12453
12454 uint devices_cnt = 0;
12455
12456 uint devices_active = 0;
12457
12458 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12459 {
12460 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12461
12462 cl_platform_id platform = platforms[platform_id];
12463
12464 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12465
12466 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12467 {
12468 const uint device_id = devices_cnt;
12469
12470 hc_device_param_t *device_param = &data.devices_param[device_id];
12471
12472 device_param->device = platform_devices[platform_devices_id];
12473
12474 device_param->device_id = device_id;
12475
12476 device_param->platform_devices_id = platform_devices_id;
12477
12478 // vendor_id
12479
12480 cl_uint vendor_id = 0;
12481
12482 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12483
12484 device_param->vendor_id = vendor_id;
12485
12486 // device_type
12487
12488 cl_device_type device_type;
12489
12490 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12491
12492 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12493
12494 device_param->device_type = device_type;
12495
12496 // device_name
12497
12498 char *device_name = (char *) mymalloc (INFOSZ);
12499
12500 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12501
12502 device_param->device_name = device_name;
12503
12504 // device_version
12505
12506 char *device_version = (char *) mymalloc (INFOSZ);
12507
12508 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12509
12510 device_param->device_version = device_version;
12511
12512 if (strstr (device_version, "pocl"))
12513 {
12514 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12515 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12516
12517 cl_uint vendor_id = 0xffff;
12518
12519 device_param->vendor_id = vendor_id;
12520 }
12521
12522 // max_compute_units
12523
12524 cl_uint device_processors;
12525
12526 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12527
12528 device_param->device_processors = device_processors;
12529
12530 // max_mem_alloc_size
12531
12532 cl_ulong device_maxmem_alloc;
12533
12534 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12535
12536 device_param->device_maxmem_alloc = device_maxmem_alloc;
12537
12538 // max_mem_alloc_size
12539
12540 cl_ulong device_global_mem;
12541
12542 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12543
12544 device_param->device_global_mem = device_global_mem;
12545
12546 // max_clock_frequency
12547
12548 cl_uint device_maxclock_frequency;
12549
12550 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12551
12552 device_param->device_maxclock_frequency = device_maxclock_frequency;
12553
12554 // skipped
12555
12556 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12557 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12558
12559 device_param->skipped = (skipped1 || skipped2);
12560
12561 // driver_version
12562
12563 char *driver_version = (char *) mymalloc (INFOSZ);
12564
12565 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12566
12567 device_param->driver_version = driver_version;
12568
12569 // device_name_chksum
12570
12571 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12572
12573 #if __x86_64__
12574 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12575 #else
12576 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12577 #endif
12578
12579 uint device_name_digest[4];
12580
12581 device_name_digest[0] = 0;
12582 device_name_digest[1] = 0;
12583 device_name_digest[2] = 0;
12584 device_name_digest[3] = 0;
12585
12586 md5_64 ((uint *) device_name_chksum, device_name_digest);
12587
12588 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12589
12590 device_param->device_name_chksum = device_name_chksum;
12591
12592 // device_processor_cores
12593
12594 if (device_type & CL_DEVICE_TYPE_CPU)
12595 {
12596 cl_uint device_processor_cores = 1;
12597
12598 device_param->device_processor_cores = device_processor_cores;
12599 }
12600
12601 if (device_type & CL_DEVICE_TYPE_GPU)
12602 {
12603 if (vendor_id == VENDOR_ID_AMD)
12604 {
12605 cl_uint device_processor_cores = 0;
12606
12607 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12608
12609 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12610
12611 device_param->device_processor_cores = device_processor_cores;
12612 }
12613 else if (vendor_id == VENDOR_ID_NV)
12614 {
12615 cl_uint kernel_exec_timeout = 0;
12616
12617 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12618
12619 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12620
12621 device_param->kernel_exec_timeout = kernel_exec_timeout;
12622
12623 cl_uint device_processor_cores = 0;
12624
12625 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12626
12627 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12628
12629 device_param->device_processor_cores = device_processor_cores;
12630
12631 cl_uint sm_minor = 0;
12632 cl_uint sm_major = 0;
12633
12634 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12635 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12636
12637 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12638 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12639
12640 device_param->sm_minor = sm_minor;
12641 device_param->sm_major = sm_major;
12642 }
12643 else
12644 {
12645 cl_uint device_processor_cores = 1;
12646
12647 device_param->device_processor_cores = device_processor_cores;
12648 }
12649 }
12650
12651 // display results
12652
12653 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12654 {
12655 if (device_param->skipped == 0)
12656 {
12657 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12658 device_id + 1,
12659 device_name,
12660 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12661 (unsigned int) (device_global_mem / 1024 / 1024),
12662 (unsigned int) (device_maxclock_frequency),
12663 (unsigned int) device_processors);
12664 }
12665 else
12666 {
12667 log_info ("Device #%u: %s, skipped",
12668 device_id + 1,
12669 device_name);
12670 }
12671 }
12672
12673 // common driver check
12674
12675 if (device_param->skipped == 0)
12676 {
12677 if (strstr (device_version, "pocl"))
12678 {
12679 if (force == 0)
12680 {
12681 log_info ("");
12682 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12683 log_info ("You are STRONGLY encouraged not to use it");
12684 log_info ("You can use --force to override this but do not post error reports if you do so");
12685 log_info ("");
12686
12687 return (-1);
12688 }
12689 }
12690
12691 if (device_type & CL_DEVICE_TYPE_GPU)
12692 {
12693 if (vendor_id == VENDOR_ID_NV)
12694 {
12695 if (device_param->kernel_exec_timeout != 0)
12696 {
12697 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);
12698 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12699 }
12700 }
12701 else if (vendor_id == VENDOR_ID_AMD)
12702 {
12703 int catalyst_check = (force == 1) ? 0 : 1;
12704
12705 int catalyst_warn = 0;
12706
12707 int catalyst_broken = 0;
12708
12709 if (catalyst_check == 1)
12710 {
12711 catalyst_warn = 1;
12712
12713 // v14.9 and higher
12714 if (atoi (device_param->driver_version) >= 1573)
12715 {
12716 catalyst_warn = 0;
12717 }
12718
12719 catalyst_check = 0;
12720 }
12721
12722 if (catalyst_broken == 1)
12723 {
12724 log_info ("");
12725 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12726 log_info ("It will pass over cracked hashes and does not report them as cracked");
12727 log_info ("You are STRONGLY encouraged not to use it");
12728 log_info ("You can use --force to override this but do not post error reports if you do so");
12729 log_info ("");
12730
12731 return (-1);
12732 }
12733
12734 if (catalyst_warn == 1)
12735 {
12736 log_info ("");
12737 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12738 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12739 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12740 #ifdef _WIN
12741 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12742 #endif
12743 log_info ("You can use --force to override this but do not post error reports if you do so");
12744 log_info ("");
12745
12746 return (-1);
12747 }
12748 }
12749 }
12750
12751 devices_active++;
12752 }
12753
12754 // next please
12755
12756 devices_cnt++;
12757 }
12758 }
12759
12760 if (devices_active == 0)
12761 {
12762 log_error ("ERROR: No devices found/left");
12763
12764 return (-1);
12765 }
12766
12767 data.devices_cnt = devices_cnt;
12768
12769 data.devices_active = devices_active;
12770
12771 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12772 {
12773 log_info ("");
12774 }
12775
12776 /**
12777 * OpenCL devices: allocate buffer for device specific information
12778 */
12779
12780 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12781
12782 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12783
12784 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12785
12786 /**
12787 * enable custom signal handler(s)
12788 */
12789
12790 if (benchmark == 0)
12791 {
12792 hc_signal (sigHandler_default);
12793 }
12794 else
12795 {
12796 hc_signal (sigHandler_benchmark);
12797 }
12798
12799 /**
12800 * User-defined GPU temp handling
12801 */
12802
12803 if (gpu_temp_disable == 1)
12804 {
12805 gpu_temp_abort = 0;
12806 gpu_temp_retain = 0;
12807 }
12808
12809 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12810 {
12811 if (gpu_temp_abort < gpu_temp_retain)
12812 {
12813 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12814
12815 return (-1);
12816 }
12817 }
12818
12819 data.gpu_temp_disable = gpu_temp_disable;
12820 data.gpu_temp_abort = gpu_temp_abort;
12821 data.gpu_temp_retain = gpu_temp_retain;
12822
12823 /**
12824 * inform the user
12825 */
12826
12827 if (data.quiet == 0)
12828 {
12829 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12830
12831 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);
12832
12833 if (attack_mode == ATTACK_MODE_STRAIGHT)
12834 {
12835 log_info ("Rules: %u", kernel_rules_cnt);
12836 }
12837
12838 if (opti_type)
12839 {
12840 log_info ("Applicable Optimizers:");
12841
12842 for (uint i = 0; i < 32; i++)
12843 {
12844 const uint opti_bit = 1u << i;
12845
12846 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12847 }
12848 }
12849
12850 /**
12851 * Watchdog and Temperature balance
12852 */
12853
12854 if (gpu_temp_abort == 0)
12855 {
12856 log_info ("Watchdog: Temperature abort trigger disabled");
12857 }
12858 else
12859 {
12860 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12861 }
12862
12863 if (gpu_temp_retain == 0)
12864 {
12865 log_info ("Watchdog: Temperature retain trigger disabled");
12866 }
12867 else
12868 {
12869 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12870 }
12871 }
12872
12873 if (data.quiet == 0) log_info ("");
12874
12875 /**
12876 * HM devices: init
12877 */
12878
12879 hm_attrs_t hm_adapters_nv[DEVICES_MAX];
12880 hm_attrs_t hm_adapters_amd[DEVICES_MAX];
12881
12882 memset (hm_adapters_nv, 0, sizeof (hm_adapters_nv));
12883 memset (hm_adapters_amd, 0, sizeof (hm_adapters_amd));
12884
12885 if (gpu_temp_disable == 0)
12886 {
12887 #ifdef WIN
12888 if (NvAPI_Initialize () == NVAPI_OK)
12889 {
12890 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12891
12892 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12893
12894 int tmp_out = 0;
12895
12896 for (int i = 0; i < tmp_in; i++)
12897 {
12898 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12899 }
12900
12901 for (int i = 0; i < tmp_out; i++)
12902 {
12903 NvU32 speed;
12904
12905 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12906 }
12907 }
12908 #endif
12909
12910 #ifdef LINUX
12911 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12912
12913 data.hm_dll_nv = hm_dll_nv;
12914
12915 if (hm_dll_nv)
12916 {
12917 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12918 {
12919 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12920
12921 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12922
12923 int tmp_out = 0;
12924
12925 for (int i = 0; i < tmp_in; i++)
12926 {
12927 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12928 }
12929
12930 for (int i = 0; i < tmp_out; i++)
12931 {
12932 unsigned int speed;
12933
12934 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;
12935 }
12936 }
12937 }
12938 #endif
12939
12940 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12941
12942 data.hm_dll_amd = hm_dll_amd;
12943
12944 if (hm_dll_amd)
12945 {
12946 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12947 {
12948 // total number of adapters
12949
12950 int hm_adapters_num;
12951
12952 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12953
12954 // adapter info
12955
12956 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12957
12958 if (lpAdapterInfo == NULL) return (-1);
12959
12960 // get a list (of ids of) valid/usable adapters
12961
12962 int num_adl_adapters = 0;
12963
12964 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12965
12966 if (num_adl_adapters > 0)
12967 {
12968 hc_thread_mutex_lock (mux_adl);
12969
12970 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12971
12972 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12973
12974 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12975 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12976
12977 hc_thread_mutex_unlock (mux_adl);
12978 }
12979
12980 myfree (valid_adl_device_list);
12981 myfree (lpAdapterInfo);
12982 }
12983 }
12984 }
12985
12986 /**
12987 * HM devices: copy
12988 */
12989
12990 if (gpu_temp_disable == 0)
12991 {
12992 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12993 {
12994 hc_device_param_t *device_param = &data.devices_param[device_id];
12995
12996 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12997
12998 if (device_param->skipped) continue;
12999
13000 const uint platform_devices_id = device_param->platform_devices_id;
13001
13002 if (device_param->vendor_id == VENDOR_ID_NV)
13003 {
13004 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13005 }
13006
13007 if (device_param->vendor_id == VENDOR_ID_AMD)
13008 {
13009 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13010 }
13011 }
13012 }
13013
13014 /*
13015 * Temporary fix:
13016 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13017 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13018 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13019 * Driver / ADL bug?
13020 */
13021
13022 if (powertune_enable == 1)
13023 {
13024 hc_thread_mutex_lock (mux_adl);
13025
13026 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13027 {
13028 hc_device_param_t *device_param = &data.devices_param[device_id];
13029
13030 if (device_param->skipped) continue;
13031
13032 if (data.hm_device[device_id].od_version == 6)
13033 {
13034 // set powertune value only
13035
13036 int powertune_supported = 0;
13037
13038 int ADL_rc = 0;
13039
13040 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13041 {
13042 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13043
13044 return (-1);
13045 }
13046
13047 if (powertune_supported != 0)
13048 {
13049 // powertune set
13050 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13051
13052 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13053 {
13054 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13055
13056 return (-1);
13057 }
13058
13059 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13060 {
13061 log_error ("ERROR: Failed to set new ADL PowerControl values");
13062
13063 return (-1);
13064 }
13065 }
13066 }
13067 }
13068
13069 hc_thread_mutex_unlock (mux_adl);
13070 }
13071
13072 uint kernel_blocks_all = 0;
13073
13074 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13075 {
13076 /**
13077 * host buffer
13078 */
13079
13080 hc_device_param_t *device_param = &data.devices_param[device_id];
13081
13082 if (device_param->skipped) continue;
13083
13084 /**
13085 * device properties
13086 */
13087
13088 char *device_name_chksum = device_param->device_name_chksum;
13089
13090 uint device_processors = device_param->device_processors;
13091
13092 uint device_processor_cores = device_param->device_processor_cores;
13093
13094 cl_device_type device_type = device_param->device_type;
13095
13096 /**
13097 * create context for each device
13098 */
13099
13100 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13101
13102 /**
13103 * create command-queue
13104 */
13105
13106 // not support with NV
13107 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13108
13109 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13110
13111 /**
13112 * create input buffers on device
13113 */
13114
13115 uint kernel_threads = KERNEL_THREADS;
13116
13117 // bcrypt
13118 if (hash_mode == 3200) kernel_threads = 8;
13119 if (hash_mode == 9000) kernel_threads = 8;
13120
13121 if (device_type & CL_DEVICE_TYPE_CPU)
13122 {
13123 // CPU still need lots of workitems, don't know why...
13124 // for testing phase, lets start with this
13125
13126 kernel_accel = 1;
13127 }
13128
13129 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13130 uint kernel_blocks = kernel_power;
13131
13132 device_param->kernel_threads = kernel_threads;
13133 device_param->kernel_power_user = kernel_power;
13134 device_param->kernel_blocks_user = kernel_blocks;
13135
13136 kernel_blocks_all += kernel_blocks;
13137
13138 uint size_pws = kernel_power * sizeof (pw_t);
13139
13140 uint size_tmps = 4;
13141
13142 switch (hash_mode)
13143 {
13144 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13145 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13146 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13147 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13148 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13149 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13150 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13151 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13152 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13153 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13154 case 6211:
13155 case 6212:
13156 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13157 case 6221:
13158 case 6222:
13159 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13160 case 6231:
13161 case 6232:
13162 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13163 case 6241:
13164 case 6242:
13165 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13166 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13167 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13168 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13169 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13170 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13171 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13172 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13173 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13174 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13175 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13176 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13177 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13178 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13179 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13180 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13181 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13182 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13183 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13184 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13185 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13186 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13187 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13188 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13189 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13190 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13191 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13192 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13193 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13194 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13195 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13196 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13197 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13198 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13199 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13200 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13201 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13202 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13203 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13204 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13205 };
13206
13207 uint size_hooks = 4;
13208
13209 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13210 {
13211 // insert correct hook size
13212 }
13213
13214 // we can optimize some stuff here...
13215
13216 device_param->size_pws = size_pws;
13217 device_param->size_tmps = size_tmps;
13218 device_param->size_hooks = size_hooks;
13219
13220 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13221 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13222
13223 device_param->size_root_css = size_root_css;
13224 device_param->size_markov_css = size_markov_css;
13225
13226 uint size_results = KERNEL_THREADS * sizeof (uint);
13227
13228 device_param->size_results = size_results;
13229
13230 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13231 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13232
13233 uint size_plains = digests_cnt * sizeof (plain_t);
13234 uint size_salts = salts_cnt * sizeof (salt_t);
13235 uint size_esalts = salts_cnt * esalt_size;
13236
13237 device_param->size_plains = size_plains;
13238 device_param->size_digests = size_digests;
13239 device_param->size_shown = size_shown;
13240 device_param->size_salts = size_salts;
13241
13242 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13243 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13244 uint size_tm = 32 * sizeof (bs_word_t);
13245
13246 u64 size_scryptV = 1;
13247
13248 if ((hash_mode == 8900) || (hash_mode == 9300))
13249 {
13250 uint tmto_start = 0;
13251 uint tmto_stop = 10;
13252
13253 if (scrypt_tmto)
13254 {
13255 tmto_start = scrypt_tmto;
13256 }
13257 else
13258 {
13259 // in case the user did not specify the tmto manually
13260 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13261 // but set the lower end only in case the user has a device with too less memory
13262
13263 if (hash_mode == 8900)
13264 {
13265 if (device_param->vendor_id == VENDOR_ID_AMD)
13266 {
13267 tmto_start = 1;
13268 }
13269 else if (device_param->vendor_id == VENDOR_ID_NV)
13270 {
13271 tmto_start = 3;
13272 }
13273 }
13274 else if (hash_mode == 9300)
13275 {
13276 if (device_param->vendor_id == VENDOR_ID_AMD)
13277 {
13278 tmto_start = 3;
13279 }
13280 else if (device_param->vendor_id == VENDOR_ID_NV)
13281 {
13282 tmto_start = 5;
13283 }
13284 }
13285 }
13286
13287 if (quiet == 0) log_info ("");
13288
13289 uint shader_per_mp = 1;
13290
13291 if (device_param->vendor_id == VENDOR_ID_AMD)
13292 {
13293 shader_per_mp = 8;
13294 }
13295 else if (device_param->vendor_id == VENDOR_ID_NV)
13296 {
13297 shader_per_mp = 32;
13298 }
13299
13300 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13301 {
13302 // TODO: in theory the following calculation needs to be done per salt, not global
13303 // we assume all hashes have the same scrypt settings
13304
13305 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13306
13307 size_scryptV /= 1 << tmto;
13308
13309 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13310
13311 if (size_scryptV > device_param->device_maxmem_alloc)
13312 {
13313 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13314
13315 continue;
13316 }
13317
13318 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13319 {
13320 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13321 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13322 }
13323
13324 break;
13325 }
13326
13327 if (data.salts_buf[0].scrypt_phy == 0)
13328 {
13329 log_error ("ERROR: can't allocate enough device memory");
13330
13331 return -1;
13332 }
13333
13334 if (quiet == 0) log_info ("");
13335 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13336 }
13337
13338 /**
13339 * default building options
13340 */
13341
13342 char build_opts[1024];
13343
13344 // we don't have sm_* on vendors not NV but it doesn't matter
13345
13346 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13347
13348 /**
13349 * main kernel
13350 */
13351
13352 {
13353 /**
13354 * kernel source filename
13355 */
13356
13357 char source_file[256];
13358
13359 memset (source_file, 0, sizeof (source_file));
13360
13361 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13362
13363 struct stat sst;
13364
13365 if (stat (source_file, &sst) == -1)
13366 {
13367 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13368
13369 return -1;
13370 }
13371
13372 /**
13373 * kernel cached filename
13374 */
13375
13376 char cached_file[256];
13377
13378 memset (cached_file, 0, sizeof (cached_file));
13379
13380 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13381
13382 int cached = 1;
13383
13384 struct stat cst;
13385
13386 if (stat (cached_file, &cst) == -1)
13387 {
13388 cached = 0;
13389 }
13390
13391 /**
13392 * kernel compile or load
13393 */
13394
13395 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13396
13397 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13398
13399 if (force_jit_compilation == 0)
13400 {
13401 if (cached == 0)
13402 {
13403 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13404
13405 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13406
13407 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13408
13409 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13410
13411 size_t binary_size;
13412
13413 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13414
13415 u8 *binary = (u8 *) mymalloc (binary_size);
13416
13417 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13418
13419 writeProgramBin (cached_file, binary, binary_size);
13420
13421 local_free (binary);
13422 }
13423 else
13424 {
13425 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13426
13427 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13428
13429 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13430
13431 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13432 }
13433 }
13434 else
13435 {
13436 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13437
13438 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13439
13440 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13441
13442 if (force_jit_compilation == 1500)
13443 {
13444 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13445 }
13446 else if (force_jit_compilation == 8900)
13447 {
13448 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);
13449 }
13450
13451 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13452 }
13453
13454 local_free (kernel_lengths);
13455 local_free (kernel_sources[0]);
13456 local_free (kernel_sources);
13457
13458 // this is mostly for debug
13459
13460 size_t ret_val_size = 0;
13461
13462 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13463
13464 if (ret_val_size > 2)
13465 {
13466 char *build_log = (char *) mymalloc (ret_val_size + 1);
13467
13468 memset (build_log, 0, ret_val_size + 1);
13469
13470 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13471
13472 puts (build_log);
13473
13474 myfree (build_log);
13475 }
13476 }
13477
13478 /**
13479 * word generator kernel
13480 */
13481
13482 if (attack_mode != ATTACK_MODE_STRAIGHT)
13483 {
13484 /**
13485 * kernel mp source filename
13486 */
13487
13488 char source_file[256];
13489
13490 memset (source_file, 0, sizeof (source_file));
13491
13492 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13493
13494 struct stat sst;
13495
13496 if (stat (source_file, &sst) == -1)
13497 {
13498 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13499
13500 return -1;
13501 }
13502
13503 /**
13504 * kernel mp cached filename
13505 */
13506
13507 char cached_file[256];
13508
13509 memset (cached_file, 0, sizeof (cached_file));
13510
13511 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13512
13513 int cached = 1;
13514
13515 struct stat cst;
13516
13517 if (stat (cached_file, &cst) == -1)
13518 {
13519 cached = 0;
13520 }
13521
13522 /**
13523 * kernel compile or load
13524 */
13525
13526 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13527
13528 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13529
13530 if (cached == 0)
13531 {
13532 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13533
13534 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13535
13536 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13537
13538 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13539
13540 size_t binary_size;
13541
13542 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13543
13544 u8 *binary = (u8 *) mymalloc (binary_size);
13545
13546 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13547
13548 writeProgramBin (cached_file, binary, binary_size);
13549
13550 local_free (binary);
13551 }
13552 else
13553 {
13554 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13555
13556 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13557
13558 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13559
13560 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13561 }
13562
13563 local_free (kernel_lengths);
13564 local_free (kernel_sources[0]);
13565 local_free (kernel_sources);
13566
13567 // this is mostly for debug
13568
13569 size_t ret_val_size = 0;
13570
13571 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13572
13573 if (ret_val_size > 2)
13574 {
13575 char *build_log = (char *) mymalloc (ret_val_size + 1);
13576
13577 memset (build_log, 0, ret_val_size + 1);
13578
13579 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13580
13581 puts (build_log);
13582
13583 myfree (build_log);
13584 }
13585 }
13586
13587 /**
13588 * amplifier kernel
13589 */
13590
13591 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13592 {
13593
13594 }
13595 else
13596 {
13597 /**
13598 * kernel amp source filename
13599 */
13600
13601 char source_file[256];
13602
13603 memset (source_file, 0, sizeof (source_file));
13604
13605 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13606
13607 struct stat sst;
13608
13609 if (stat (source_file, &sst) == -1)
13610 {
13611 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13612
13613 return -1;
13614 }
13615
13616 /**
13617 * kernel amp cached filename
13618 */
13619
13620 char cached_file[256];
13621
13622 memset (cached_file, 0, sizeof (cached_file));
13623
13624 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13625
13626 int cached = 1;
13627
13628 struct stat cst;
13629
13630 if (stat (cached_file, &cst) == -1)
13631 {
13632 cached = 0;
13633 }
13634
13635 /**
13636 * kernel compile or load
13637 */
13638
13639 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13640
13641 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13642
13643 if (cached == 0)
13644 {
13645 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13646
13647 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13648
13649 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13650
13651 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13652
13653 size_t binary_size;
13654
13655 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13656
13657 u8 *binary = (u8 *) mymalloc (binary_size);
13658
13659 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13660
13661 writeProgramBin (cached_file, binary, binary_size);
13662
13663 local_free (binary);
13664 }
13665 else
13666 {
13667 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13668
13669 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13670
13671 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13672
13673 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13674 }
13675
13676 local_free (kernel_lengths);
13677 local_free (kernel_sources[0]);
13678 local_free (kernel_sources);
13679
13680 // this is mostly for debug
13681
13682 size_t ret_val_size = 0;
13683
13684 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13685
13686 if (ret_val_size > 2)
13687 {
13688 char *build_log = (char *) mymalloc (ret_val_size + 1);
13689
13690 memset (build_log, 0, ret_val_size + 1);
13691
13692 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13693
13694 puts (build_log);
13695
13696 myfree (build_log);
13697 }
13698 }
13699
13700 /**
13701 * global buffers
13702 */
13703
13704 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13705 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13706 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13707 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13708 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13709 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13710 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13711 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13712 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13713 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13714 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13715 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13716 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13717 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13718 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13719 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13720 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13721 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13722
13723 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13724 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13725 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13726 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13727 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13728 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13729 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13730 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13731 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13732 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13733 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13734
13735 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13736 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13737 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13738 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13739 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13740 run_kernel_bzero (device_param, device_param->d_result, size_results);
13741
13742 /**
13743 * special buffers
13744 */
13745
13746 if (attack_kern == ATTACK_KERN_STRAIGHT)
13747 {
13748 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13749 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13750
13751 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13752
13753 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13754 }
13755 else if (attack_kern == ATTACK_KERN_COMBI)
13756 {
13757 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13758 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13759 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13760 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13761
13762 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13763 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13764 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13765 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13766 }
13767 else if (attack_kern == ATTACK_KERN_BF)
13768 {
13769 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13770 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13771 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13772 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13773 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13774
13775 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13776 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13777 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13778 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13779 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13780 }
13781
13782 if (size_esalts)
13783 {
13784 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13785
13786 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13787 }
13788
13789 /**
13790 * main host data
13791 */
13792
13793 uint *result = (uint *) mymalloc (size_results);
13794
13795 memset (result, 0, size_results);
13796
13797 device_param->result = result;
13798
13799 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13800
13801 memset (pws_buf, 0, size_pws);
13802
13803 device_param->pws_buf = pws_buf;
13804
13805 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13806
13807 for (int i = 0; i < 64; i++)
13808 {
13809 pw_caches[i].pw_buf.pw_len = i;
13810 pw_caches[i].cnt = 0;
13811 }
13812
13813 device_param->pw_caches = pw_caches;
13814
13815 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13816
13817 device_param->combs_buf = combs_buf;
13818
13819 void *hooks_buf = mymalloc (size_hooks);
13820
13821 device_param->hooks_buf = hooks_buf;
13822
13823 device_param->pw_transpose = pw_transpose_to_hi1;
13824 device_param->pw_add = pw_add_to_hc1;
13825
13826 /**
13827 * kernel args
13828 */
13829
13830 device_param->kernel_params_buf32[21] = bitmap_mask;
13831 device_param->kernel_params_buf32[22] = bitmap_shift1;
13832 device_param->kernel_params_buf32[23] = bitmap_shift2;
13833 device_param->kernel_params_buf32[24] = 0; // salt_pos
13834 device_param->kernel_params_buf32[25] = 0; // loop_pos
13835 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13836 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13837 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13838 device_param->kernel_params_buf32[29] = 0; // digests_offset
13839 device_param->kernel_params_buf32[30] = 0; // combs_mode
13840 device_param->kernel_params_buf32[31] = 0; // gid_max
13841
13842 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13843 ? &device_param->d_pws_buf
13844 : &device_param->d_pws_amp_buf;
13845 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13846 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13847 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13848 device_param->kernel_params[ 4] = &device_param->d_tmps;
13849 device_param->kernel_params[ 5] = &device_param->d_hooks;
13850 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13851 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13852 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13853 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13854 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13855 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13856 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13857 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13858 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13859 device_param->kernel_params[15] = &device_param->d_digests_buf;
13860 device_param->kernel_params[16] = &device_param->d_digests_shown;
13861 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13862 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13863 device_param->kernel_params[19] = &device_param->d_result;
13864 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13865 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13866 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13867 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13868 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13869 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13870 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13871 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13872 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13873 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13874 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13875 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13876
13877 device_param->kernel_params_mp_buf64[3] = 0;
13878 device_param->kernel_params_mp_buf32[4] = 0;
13879 device_param->kernel_params_mp_buf32[5] = 0;
13880 device_param->kernel_params_mp_buf32[6] = 0;
13881 device_param->kernel_params_mp_buf32[7] = 0;
13882 device_param->kernel_params_mp_buf32[8] = 0;
13883
13884 device_param->kernel_params_mp[0] = NULL;
13885 device_param->kernel_params_mp[1] = NULL;
13886 device_param->kernel_params_mp[2] = NULL;
13887 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13888 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13889 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13890 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13891 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13892 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13893
13894 device_param->kernel_params_mp_l_buf64[3] = 0;
13895 device_param->kernel_params_mp_l_buf32[4] = 0;
13896 device_param->kernel_params_mp_l_buf32[5] = 0;
13897 device_param->kernel_params_mp_l_buf32[6] = 0;
13898 device_param->kernel_params_mp_l_buf32[7] = 0;
13899 device_param->kernel_params_mp_l_buf32[8] = 0;
13900 device_param->kernel_params_mp_l_buf32[9] = 0;
13901
13902 device_param->kernel_params_mp_l[0] = NULL;
13903 device_param->kernel_params_mp_l[1] = NULL;
13904 device_param->kernel_params_mp_l[2] = NULL;
13905 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13906 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13907 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13908 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13909 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13910 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13911 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13912
13913 device_param->kernel_params_mp_r_buf64[3] = 0;
13914 device_param->kernel_params_mp_r_buf32[4] = 0;
13915 device_param->kernel_params_mp_r_buf32[5] = 0;
13916 device_param->kernel_params_mp_r_buf32[6] = 0;
13917 device_param->kernel_params_mp_r_buf32[7] = 0;
13918 device_param->kernel_params_mp_r_buf32[8] = 0;
13919
13920 device_param->kernel_params_mp_r[0] = NULL;
13921 device_param->kernel_params_mp_r[1] = NULL;
13922 device_param->kernel_params_mp_r[2] = NULL;
13923 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13924 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13925 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13926 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13927 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13928 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13929
13930 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13931 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13932
13933 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13934 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13935 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13936 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13937 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13938 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13939 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13940
13941 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13942
13943 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13944 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13945
13946 /**
13947 * kernel name
13948 */
13949
13950 char kernel_name[64];
13951
13952 memset (kernel_name, 0, sizeof (kernel_name));
13953
13954 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13955 {
13956 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13957 {
13958 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13959
13960 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13961
13962 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13963
13964 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13965
13966 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13967
13968 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13969 }
13970 else
13971 {
13972 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13973
13974 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13975
13976 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13977
13978 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13979
13980 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13981
13982 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13983 }
13984
13985 if (data.attack_mode == ATTACK_MODE_BF)
13986 {
13987 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13988 {
13989 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13990
13991 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13992
13993 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13994
13995 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13996 }
13997 }
13998 }
13999 else
14000 {
14001 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
14002
14003 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
14004
14005 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14006
14007 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14008
14009 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14010
14011 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14012
14013 if (opts_type & OPTS_TYPE_HOOK12)
14014 {
14015 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14016
14017 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14018 }
14019
14020 if (opts_type & OPTS_TYPE_HOOK23)
14021 {
14022 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14023
14024 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14025 }
14026 }
14027
14028 for (uint i = 0; i <= 20; i++)
14029 {
14030 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14031 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14032 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14033
14034 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14035 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14036 }
14037
14038 for (uint i = 21; i <= 31; i++)
14039 {
14040 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14041 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14042 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14043
14044 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14045 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14046 }
14047
14048 if (attack_mode == ATTACK_MODE_BF)
14049 {
14050 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14051 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14052
14053 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14054 {
14055 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14056
14057 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14058 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14059 }
14060 }
14061 else if (attack_mode == ATTACK_MODE_HYBRID1)
14062 {
14063 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14064 }
14065 else if (attack_mode == ATTACK_MODE_HYBRID2)
14066 {
14067 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14068 }
14069
14070 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14071 {
14072 // nothing to do
14073 }
14074 else
14075 {
14076 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14077 }
14078
14079 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14080 {
14081 // nothing to do
14082 }
14083 else
14084 {
14085 for (uint i = 0; i < 5; i++)
14086 {
14087 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14088 }
14089
14090 for (uint i = 5; i < 7; i++)
14091 {
14092 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14093 }
14094 }
14095
14096 /**
14097 * Store initial fanspeed if gpu_temp_retain is enabled
14098 */
14099
14100 int gpu_temp_retain_set = 0;
14101
14102 if (gpu_temp_disable == 0)
14103 {
14104 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14105 {
14106 hc_thread_mutex_lock (mux_adl);
14107
14108 if (data.hm_device[device_id].fan_supported == 1)
14109 {
14110 if (gpu_temp_retain_chgd == 0)
14111 {
14112 uint cur_temp = 0;
14113 uint default_temp = 0;
14114
14115 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);
14116
14117 if (ADL_rc == ADL_OK)
14118 {
14119 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14120
14121 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14122
14123 // special case with multi gpu setups: always use minimum retain
14124
14125 if (gpu_temp_retain_set == 0)
14126 {
14127 gpu_temp_retain = gpu_temp_retain_target;
14128 gpu_temp_retain_set = 1;
14129 }
14130 else
14131 {
14132 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14133 }
14134
14135 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14136 }
14137 }
14138
14139 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14140
14141 temp_retain_fanspeed_value[device_id] = fan_speed;
14142
14143 if (fan_speed == -1)
14144 {
14145 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14146
14147 temp_retain_fanspeed_value[device_id] = 0;
14148 }
14149 }
14150
14151 hc_thread_mutex_unlock (mux_adl);
14152 }
14153 }
14154
14155 /**
14156 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14157 */
14158
14159 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14160 {
14161 hc_thread_mutex_lock (mux_adl);
14162
14163 if (data.hm_device[device_id].od_version == 6)
14164 {
14165 int ADL_rc;
14166
14167 // check powertune capabilities first, if not available then skip device
14168
14169 int powertune_supported = 0;
14170
14171 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14172 {
14173 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14174
14175 return (-1);
14176 }
14177
14178 if (powertune_supported != 0)
14179 {
14180 // powercontrol settings
14181
14182 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14183
14184 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14185 {
14186 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]);
14187 }
14188
14189 if (ADL_rc != ADL_OK)
14190 {
14191 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14192
14193 return (-1);
14194 }
14195
14196 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14197 {
14198 log_error ("ERROR: Failed to set new ADL PowerControl values");
14199
14200 return (-1);
14201 }
14202
14203 // clocks
14204
14205 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14206
14207 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14208
14209 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)
14210 {
14211 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14212
14213 return (-1);
14214 }
14215
14216 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14217
14218 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14219
14220 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14221 {
14222 log_error ("ERROR: Failed to get ADL device capabilities");
14223
14224 return (-1);
14225 }
14226
14227 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14228 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14229
14230 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14231 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14232
14233 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14234 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14235
14236 // warning if profile has to low max values
14237
14238 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14239 {
14240 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14241 }
14242
14243 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14244 {
14245 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14246 }
14247
14248 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14249
14250 performance_state->iNumberOfPerformanceLevels = 2;
14251
14252 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14253 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14254 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14255 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14256
14257 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)
14258 {
14259 log_info ("ERROR: Failed to set ADL performance state");
14260
14261 return (-1);
14262 }
14263
14264 local_free (performance_state);
14265 }
14266 }
14267
14268 hc_thread_mutex_unlock (mux_adl);
14269 }
14270 }
14271
14272 data.kernel_blocks_all = kernel_blocks_all;
14273
14274 if (data.quiet == 0) log_info ("");
14275
14276 /**
14277 * Inform user which algorithm is checked and at which workload setting
14278 */
14279
14280 if (benchmark == 1)
14281 {
14282 quiet = 0;
14283
14284 data.quiet = quiet;
14285
14286 char *hash_type = strhashtype (data.hash_mode); // not a bug
14287
14288 log_info ("Hashtype: %s", hash_type);
14289 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14290 log_info ("");
14291 }
14292
14293 /**
14294 * keep track of the progress
14295 */
14296
14297 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14298 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14299 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14300
14301 /**
14302 * open filehandles
14303 */
14304
14305 #if _WIN
14306 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14307 {
14308 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14309
14310 return (-1);
14311 }
14312
14313 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14314 {
14315 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14316
14317 return (-1);
14318 }
14319
14320 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14321 {
14322 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14323
14324 return (-1);
14325 }
14326 #endif
14327
14328 /**
14329 * dictionary pad
14330 */
14331
14332 segment_size *= (1024 * 1024);
14333
14334 data.segment_size = segment_size;
14335
14336 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14337
14338 wl_data->buf = (char *) mymalloc (segment_size);
14339 wl_data->avail = segment_size;
14340 wl_data->incr = segment_size;
14341 wl_data->cnt = 0;
14342 wl_data->pos = 0;
14343
14344 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14345
14346 data.wordlist_mode = wordlist_mode;
14347
14348 cs_t *css_buf = NULL;
14349 uint css_cnt = 0;
14350 uint dictcnt = 0;
14351 uint maskcnt = 1;
14352 char **masks = NULL;
14353 char **dictfiles = NULL;
14354
14355 uint mask_from_file = 0;
14356
14357 if (attack_mode == ATTACK_MODE_STRAIGHT)
14358 {
14359 if (wordlist_mode == WL_MODE_FILE)
14360 {
14361 int wls_left = myargc - (optind + 1);
14362
14363 for (int i = 0; i < wls_left; i++)
14364 {
14365 char *l0_filename = myargv[optind + 1 + i];
14366
14367 struct stat l0_stat;
14368
14369 if (stat (l0_filename, &l0_stat) == -1)
14370 {
14371 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14372
14373 return (-1);
14374 }
14375
14376 uint is_dir = S_ISDIR (l0_stat.st_mode);
14377
14378 if (is_dir == 0)
14379 {
14380 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14381
14382 dictcnt++;
14383
14384 dictfiles[dictcnt - 1] = l0_filename;
14385 }
14386 else
14387 {
14388 // do not allow --keyspace w/ a directory
14389
14390 if (keyspace == 1)
14391 {
14392 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14393
14394 return (-1);
14395 }
14396
14397 char **dictionary_files = NULL;
14398
14399 dictionary_files = scan_directory (l0_filename);
14400
14401 if (dictionary_files != NULL)
14402 {
14403 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14404
14405 for (int d = 0; dictionary_files[d] != NULL; d++)
14406 {
14407 char *l1_filename = dictionary_files[d];
14408
14409 struct stat l1_stat;
14410
14411 if (stat (l1_filename, &l1_stat) == -1)
14412 {
14413 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14414
14415 return (-1);
14416 }
14417
14418 if (S_ISREG (l1_stat.st_mode))
14419 {
14420 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14421
14422 dictcnt++;
14423
14424 dictfiles[dictcnt - 1] = strdup (l1_filename);
14425 }
14426 }
14427 }
14428
14429 local_free (dictionary_files);
14430 }
14431 }
14432
14433 if (dictcnt < 1)
14434 {
14435 log_error ("ERROR: No usable dictionary file found.");
14436
14437 return (-1);
14438 }
14439 }
14440 else if (wordlist_mode == WL_MODE_STDIN)
14441 {
14442 dictcnt = 1;
14443 }
14444 }
14445 else if (attack_mode == ATTACK_MODE_COMBI)
14446 {
14447 // display
14448
14449 char *dictfile1 = myargv[optind + 1 + 0];
14450 char *dictfile2 = myargv[optind + 1 + 1];
14451
14452 // find the bigger dictionary and use as base
14453
14454 FILE *fp1;
14455 FILE *fp2;
14456
14457 struct stat tmp_stat;
14458
14459 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14460 {
14461 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14462
14463 return (-1);
14464 }
14465
14466 if (stat (dictfile1, &tmp_stat) == -1)
14467 {
14468 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14469
14470 fclose (fp1);
14471
14472 return (-1);
14473 }
14474
14475 if (S_ISDIR (tmp_stat.st_mode))
14476 {
14477 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14478
14479 fclose (fp1);
14480
14481 return (-1);
14482 }
14483
14484 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14485 {
14486 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14487
14488 fclose (fp1);
14489
14490 return (-1);
14491 }
14492
14493 if (stat (dictfile2, &tmp_stat) == -1)
14494 {
14495 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14496
14497 fclose (fp1);
14498 fclose (fp2);
14499
14500 return (-1);
14501 }
14502
14503 if (S_ISDIR (tmp_stat.st_mode))
14504 {
14505 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14506
14507 fclose (fp1);
14508 fclose (fp2);
14509
14510 return (-1);
14511 }
14512
14513 data.combs_cnt = 1;
14514
14515 data.quiet = 1;
14516
14517 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14518
14519 data.quiet = quiet;
14520
14521 if (words1_cnt == 0)
14522 {
14523 log_error ("ERROR: %s: empty file", dictfile1);
14524
14525 fclose (fp1);
14526 fclose (fp2);
14527
14528 return (-1);
14529 }
14530
14531 data.combs_cnt = 1;
14532
14533 data.quiet = 1;
14534
14535 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14536
14537 data.quiet = quiet;
14538
14539 if (words2_cnt == 0)
14540 {
14541 log_error ("ERROR: %s: empty file", dictfile2);
14542
14543 fclose (fp1);
14544 fclose (fp2);
14545
14546 return (-1);
14547 }
14548
14549 fclose (fp1);
14550 fclose (fp2);
14551
14552 data.dictfile = dictfile1;
14553 data.dictfile2 = dictfile2;
14554
14555 if (words1_cnt >= words2_cnt)
14556 {
14557 data.combs_cnt = words2_cnt;
14558 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14559
14560 dictfiles = &data.dictfile;
14561
14562 dictcnt = 1;
14563 }
14564 else
14565 {
14566 data.combs_cnt = words1_cnt;
14567 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14568
14569 dictfiles = &data.dictfile2;
14570
14571 dictcnt = 1;
14572
14573 // we also have to switch wordlist related rules!
14574
14575 char *tmpc = data.rule_buf_l;
14576
14577 data.rule_buf_l = data.rule_buf_r;
14578 data.rule_buf_r = tmpc;
14579
14580 int tmpi = data.rule_len_l;
14581
14582 data.rule_len_l = data.rule_len_r;
14583 data.rule_len_r = tmpi;
14584 }
14585 }
14586 else if (attack_mode == ATTACK_MODE_BF)
14587 {
14588 char *mask = NULL;
14589
14590 maskcnt = 0;
14591
14592 if (benchmark == 0)
14593 {
14594 mask = myargv[optind + 1];
14595
14596 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14597
14598 if ((optind + 2) <= myargc)
14599 {
14600 struct stat file_stat;
14601
14602 if (stat (mask, &file_stat) == -1)
14603 {
14604 maskcnt = 1;
14605
14606 masks[maskcnt - 1] = mystrdup (mask);
14607 }
14608 else
14609 {
14610 int wls_left = myargc - (optind + 1);
14611
14612 uint masks_avail = INCR_MASKS;
14613
14614 for (int i = 0; i < wls_left; i++)
14615 {
14616 if (i != 0)
14617 {
14618 mask = myargv[optind + 1 + i];
14619
14620 if (stat (mask, &file_stat) == -1)
14621 {
14622 log_error ("ERROR: %s: %s", mask, strerror (errno));
14623
14624 return (-1);
14625 }
14626 }
14627
14628 uint is_file = S_ISREG (file_stat.st_mode);
14629
14630 if (is_file == 1)
14631 {
14632 FILE *mask_fp;
14633
14634 if ((mask_fp = fopen (mask, "r")) == NULL)
14635 {
14636 log_error ("ERROR: %s: %s", mask, strerror (errno));
14637
14638 return (-1);
14639 }
14640
14641 char line_buf[BUFSIZ];
14642
14643 while (!feof (mask_fp))
14644 {
14645 memset (line_buf, 0, BUFSIZ);
14646
14647 int line_len = fgetl (mask_fp, line_buf);
14648
14649 if (line_len == 0) continue;
14650
14651 if (line_buf[0] == '#') continue;
14652
14653 if (masks_avail == maskcnt)
14654 {
14655 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14656
14657 masks_avail += INCR_MASKS;
14658 }
14659
14660 masks[maskcnt] = mystrdup (line_buf);
14661
14662 maskcnt++;
14663 }
14664
14665 fclose (mask_fp);
14666 }
14667 else
14668 {
14669 log_error ("ERROR: %s: unsupported file-type", mask);
14670
14671 return (-1);
14672 }
14673 }
14674
14675 mask_from_file = 1;
14676 }
14677 }
14678 else
14679 {
14680 custom_charset_1 = (char *) "?l?d?u";
14681 custom_charset_2 = (char *) "?l?d";
14682 custom_charset_3 = (char *) "?l?d*!$@_";
14683
14684 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14685 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14686 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14687
14688 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14689
14690 wordlist_mode = WL_MODE_MASK;
14691
14692 data.wordlist_mode = wordlist_mode;
14693
14694 increment = 1;
14695
14696 maskcnt = 1;
14697 }
14698 }
14699 else
14700 {
14701 /**
14702 * generate full masks and charsets
14703 */
14704
14705 masks = (char **) mymalloc (sizeof (char *));
14706
14707 switch (hash_mode)
14708 {
14709 case 1731: pw_min = 5;
14710 pw_max = 5;
14711 mask = mystrdup ("?b?b?b?b?b");
14712 break;
14713 case 12500: pw_min = 5;
14714 pw_max = 5;
14715 mask = mystrdup ("?b?b?b?b?b");
14716 break;
14717 default: pw_min = 7;
14718 pw_max = 7;
14719 mask = mystrdup ("?b?b?b?b?b?b?b");
14720 break;
14721 }
14722
14723 maskcnt = 1;
14724
14725 masks[maskcnt - 1] = mystrdup (mask);
14726
14727 wordlist_mode = WL_MODE_MASK;
14728
14729 data.wordlist_mode = wordlist_mode;
14730
14731 increment = 1;
14732 }
14733
14734 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14735
14736 if (increment)
14737 {
14738 if (increment_min > pw_min) pw_min = increment_min;
14739
14740 if (increment_max < pw_max) pw_max = increment_max;
14741 }
14742 }
14743 else if (attack_mode == ATTACK_MODE_HYBRID1)
14744 {
14745 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14746
14747 // display
14748
14749 char *mask = myargv[myargc - 1];
14750
14751 maskcnt = 0;
14752
14753 masks = (char **) mymalloc (1 * sizeof (char *));
14754
14755 // mod
14756
14757 struct stat file_stat;
14758
14759 if (stat (mask, &file_stat) == -1)
14760 {
14761 maskcnt = 1;
14762
14763 masks[maskcnt - 1] = mystrdup (mask);
14764 }
14765 else
14766 {
14767 uint is_file = S_ISREG (file_stat.st_mode);
14768
14769 if (is_file == 1)
14770 {
14771 FILE *mask_fp;
14772
14773 if ((mask_fp = fopen (mask, "r")) == NULL)
14774 {
14775 log_error ("ERROR: %s: %s", mask, strerror (errno));
14776
14777 return (-1);
14778 }
14779
14780 char line_buf[BUFSIZ];
14781
14782 uint masks_avail = 1;
14783
14784 while (!feof (mask_fp))
14785 {
14786 memset (line_buf, 0, BUFSIZ);
14787
14788 int line_len = fgetl (mask_fp, line_buf);
14789
14790 if (line_len == 0) continue;
14791
14792 if (line_buf[0] == '#') continue;
14793
14794 if (masks_avail == maskcnt)
14795 {
14796 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14797
14798 masks_avail += INCR_MASKS;
14799 }
14800
14801 masks[maskcnt] = mystrdup (line_buf);
14802
14803 maskcnt++;
14804 }
14805
14806 fclose (mask_fp);
14807
14808 mask_from_file = 1;
14809 }
14810 else
14811 {
14812 maskcnt = 1;
14813
14814 masks[maskcnt - 1] = mystrdup (mask);
14815 }
14816 }
14817
14818 // base
14819
14820 int wls_left = myargc - (optind + 2);
14821
14822 for (int i = 0; i < wls_left; i++)
14823 {
14824 char *filename = myargv[optind + 1 + i];
14825
14826 struct stat file_stat;
14827
14828 if (stat (filename, &file_stat) == -1)
14829 {
14830 log_error ("ERROR: %s: %s", filename, strerror (errno));
14831
14832 return (-1);
14833 }
14834
14835 uint is_dir = S_ISDIR (file_stat.st_mode);
14836
14837 if (is_dir == 0)
14838 {
14839 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14840
14841 dictcnt++;
14842
14843 dictfiles[dictcnt - 1] = filename;
14844 }
14845 else
14846 {
14847 // do not allow --keyspace w/ a directory
14848
14849 if (keyspace == 1)
14850 {
14851 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14852
14853 return (-1);
14854 }
14855
14856 char **dictionary_files = NULL;
14857
14858 dictionary_files = scan_directory (filename);
14859
14860 if (dictionary_files != NULL)
14861 {
14862 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14863
14864 for (int d = 0; dictionary_files[d] != NULL; d++)
14865 {
14866 char *l1_filename = dictionary_files[d];
14867
14868 struct stat l1_stat;
14869
14870 if (stat (l1_filename, &l1_stat) == -1)
14871 {
14872 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14873
14874 return (-1);
14875 }
14876
14877 if (S_ISREG (l1_stat.st_mode))
14878 {
14879 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14880
14881 dictcnt++;
14882
14883 dictfiles[dictcnt - 1] = strdup (l1_filename);
14884 }
14885 }
14886 }
14887
14888 local_free (dictionary_files);
14889 }
14890 }
14891
14892 if (dictcnt < 1)
14893 {
14894 log_error ("ERROR: No usable dictionary file found.");
14895
14896 return (-1);
14897 }
14898
14899 if (increment)
14900 {
14901 maskcnt = 0;
14902
14903 uint mask_min = increment_min; // we can't reject smaller masks here
14904 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14905
14906 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14907 {
14908 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14909
14910 if (cur_mask == NULL) break;
14911
14912 masks[maskcnt] = cur_mask;
14913
14914 maskcnt++;
14915
14916 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14917 }
14918 }
14919 }
14920 else if (attack_mode == ATTACK_MODE_HYBRID2)
14921 {
14922 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14923
14924 // display
14925
14926 char *mask = myargv[optind + 1 + 0];
14927
14928 maskcnt = 0;
14929
14930 masks = (char **) mymalloc (1 * sizeof (char *));
14931
14932 // mod
14933
14934 struct stat file_stat;
14935
14936 if (stat (mask, &file_stat) == -1)
14937 {
14938 maskcnt = 1;
14939
14940 masks[maskcnt - 1] = mystrdup (mask);
14941 }
14942 else
14943 {
14944 uint is_file = S_ISREG (file_stat.st_mode);
14945
14946 if (is_file == 1)
14947 {
14948 FILE *mask_fp;
14949
14950 if ((mask_fp = fopen (mask, "r")) == NULL)
14951 {
14952 log_error ("ERROR: %s: %s", mask, strerror (errno));
14953
14954 return (-1);
14955 }
14956
14957 char line_buf[BUFSIZ];
14958
14959 uint masks_avail = 1;
14960
14961 while (!feof (mask_fp))
14962 {
14963 memset (line_buf, 0, BUFSIZ);
14964
14965 int line_len = fgetl (mask_fp, line_buf);
14966
14967 if (line_len == 0) continue;
14968
14969 if (line_buf[0] == '#') continue;
14970
14971 if (masks_avail == maskcnt)
14972 {
14973 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14974
14975 masks_avail += INCR_MASKS;
14976 }
14977
14978 masks[maskcnt] = mystrdup (line_buf);
14979
14980 maskcnt++;
14981 }
14982
14983 fclose (mask_fp);
14984
14985 mask_from_file = 1;
14986 }
14987 else
14988 {
14989 maskcnt = 1;
14990
14991 masks[maskcnt - 1] = mystrdup (mask);
14992 }
14993 }
14994
14995 // base
14996
14997 int wls_left = myargc - (optind + 2);
14998
14999 for (int i = 0; i < wls_left; i++)
15000 {
15001 char *filename = myargv[optind + 2 + i];
15002
15003 struct stat file_stat;
15004
15005 if (stat (filename, &file_stat) == -1)
15006 {
15007 log_error ("ERROR: %s: %s", filename, strerror (errno));
15008
15009 return (-1);
15010 }
15011
15012 uint is_dir = S_ISDIR (file_stat.st_mode);
15013
15014 if (is_dir == 0)
15015 {
15016 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15017
15018 dictcnt++;
15019
15020 dictfiles[dictcnt - 1] = filename;
15021 }
15022 else
15023 {
15024 // do not allow --keyspace w/ a directory
15025
15026 if (keyspace == 1)
15027 {
15028 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15029
15030 return (-1);
15031 }
15032
15033 char **dictionary_files = NULL;
15034
15035 dictionary_files = scan_directory (filename);
15036
15037 if (dictionary_files != NULL)
15038 {
15039 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15040
15041 for (int d = 0; dictionary_files[d] != NULL; d++)
15042 {
15043 char *l1_filename = dictionary_files[d];
15044
15045 struct stat l1_stat;
15046
15047 if (stat (l1_filename, &l1_stat) == -1)
15048 {
15049 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15050
15051 return (-1);
15052 }
15053
15054 if (S_ISREG (l1_stat.st_mode))
15055 {
15056 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15057
15058 dictcnt++;
15059
15060 dictfiles[dictcnt - 1] = strdup (l1_filename);
15061 }
15062 }
15063 }
15064
15065 local_free (dictionary_files);
15066 }
15067 }
15068
15069 if (dictcnt < 1)
15070 {
15071 log_error ("ERROR: No usable dictionary file found.");
15072
15073 return (-1);
15074 }
15075
15076 if (increment)
15077 {
15078 maskcnt = 0;
15079
15080 uint mask_min = increment_min; // we can't reject smaller masks here
15081 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15082
15083 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15084 {
15085 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15086
15087 if (cur_mask == NULL) break;
15088
15089 masks[maskcnt] = cur_mask;
15090
15091 maskcnt++;
15092
15093 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15094 }
15095 }
15096 }
15097
15098 data.pw_min = pw_min;
15099 data.pw_max = pw_max;
15100
15101 /**
15102 * weak hash check
15103 */
15104
15105 if (weak_hash_threshold >= salts_cnt)
15106 {
15107 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15108
15109 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15110 {
15111 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
15112 }
15113 }
15114
15115 // Display hack, guarantee that there is at least one \r before real start
15116
15117 if (data.quiet == 0) log_info_nn ("");
15118
15119 /**
15120 * status and monitor threads
15121 */
15122
15123 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15124
15125 hc_thread_t i_thread = 0;
15126
15127 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15128 {
15129 hc_thread_create (i_thread, thread_keypress, &benchmark);
15130 }
15131
15132 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15133
15134 uint ni_threads_cnt = 0;
15135
15136 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15137
15138 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15139
15140 ni_threads_cnt++;
15141
15142 /**
15143 * Outfile remove
15144 */
15145
15146 if (keyspace == 0)
15147 {
15148 if (outfile_check_timer != 0)
15149 {
15150 if (data.outfile_check_directory != NULL)
15151 {
15152 if ((hash_mode != 5200) &&
15153 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15154 (hash_mode != 9000))
15155 {
15156 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15157
15158 ni_threads_cnt++;
15159 }
15160 else
15161 {
15162 outfile_check_timer = 0;
15163 }
15164 }
15165 else
15166 {
15167 outfile_check_timer = 0;
15168 }
15169 }
15170 }
15171
15172 /**
15173 * Inform the user if we got some hashes remove because of the pot file remove feature
15174 */
15175
15176 if (data.quiet == 0)
15177 {
15178 if (potfile_remove_cracks > 0)
15179 {
15180 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15181 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15182 }
15183 }
15184
15185 data.outfile_check_timer = outfile_check_timer;
15186
15187 /**
15188 * main loop
15189 */
15190
15191 char **induction_dictionaries = NULL;
15192
15193 int induction_dictionaries_cnt = 0;
15194
15195 hcstat_table_t *root_table_buf = NULL;
15196 hcstat_table_t *markov_table_buf = NULL;
15197
15198 uint initial_restore_done = 0;
15199
15200 data.maskcnt = maskcnt;
15201
15202 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15203 {
15204 if (data.devices_status == STATUS_CRACKED) break;
15205
15206 data.devices_status = STATUS_INIT;
15207
15208 if (maskpos > rd->maskpos)
15209 {
15210 rd->dictpos = 0;
15211 }
15212
15213 rd->maskpos = maskpos;
15214 data.maskpos = maskpos;
15215
15216 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15217 {
15218 char *mask = masks[maskpos];
15219
15220 if (mask_from_file == 1)
15221 {
15222 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15223
15224 char *str_ptr;
15225 uint str_pos;
15226
15227 uint mask_offset = 0;
15228
15229 uint separator_cnt;
15230
15231 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15232 {
15233 str_ptr = strstr (mask + mask_offset, ",");
15234
15235 if (str_ptr == NULL) break;
15236
15237 str_pos = str_ptr - mask;
15238
15239 // escaped separator, i.e. "\,"
15240
15241 if (str_pos > 0)
15242 {
15243 if (mask[str_pos - 1] == '\\')
15244 {
15245 separator_cnt --;
15246
15247 mask_offset = str_pos + 1;
15248
15249 continue;
15250 }
15251 }
15252
15253 // reset the offset
15254
15255 mask_offset = 0;
15256
15257 mask[str_pos] = '\0';
15258
15259 switch (separator_cnt)
15260 {
15261 case 0:
15262 mp_reset_usr (mp_usr, 0);
15263
15264 custom_charset_1 = mask;
15265 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15266 break;
15267
15268 case 1:
15269 mp_reset_usr (mp_usr, 1);
15270
15271 custom_charset_2 = mask;
15272 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15273 break;
15274
15275 case 2:
15276 mp_reset_usr (mp_usr, 2);
15277
15278 custom_charset_3 = mask;
15279 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15280 break;
15281
15282 case 3:
15283 mp_reset_usr (mp_usr, 3);
15284
15285 custom_charset_4 = mask;
15286 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15287 break;
15288 }
15289
15290 mask = mask + str_pos + 1;
15291 }
15292 }
15293
15294 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15295 {
15296 if (maskpos > 0)
15297 {
15298 local_free (css_buf);
15299 local_free (data.root_css_buf);
15300 local_free (data.markov_css_buf);
15301
15302 local_free (masks[maskpos - 1]);
15303 }
15304
15305 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15306
15307 data.mask = mask;
15308 data.css_cnt = css_cnt;
15309 data.css_buf = css_buf;
15310
15311 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15312
15313 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15314
15315 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15316
15317 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15318 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15319
15320 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15321
15322 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15323
15324 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15325 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15326
15327 data.root_css_buf = root_css_buf;
15328 data.markov_css_buf = markov_css_buf;
15329
15330 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15331
15332 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15333
15334 local_free (root_table_buf);
15335 local_free (markov_table_buf);
15336
15337 // args
15338
15339 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15340 {
15341 hc_device_param_t *device_param = &data.devices_param[device_id];
15342
15343 if (device_param->skipped) continue;
15344
15345 device_param->kernel_params_mp[0] = &device_param->d_combs;
15346 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15347 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15348
15349 device_param->kernel_params_mp_buf64[3] = 0;
15350 device_param->kernel_params_mp_buf32[4] = css_cnt;
15351 device_param->kernel_params_mp_buf32[5] = 0;
15352 device_param->kernel_params_mp_buf32[6] = 0;
15353 device_param->kernel_params_mp_buf32[7] = 0;
15354
15355 if (attack_mode == ATTACK_MODE_HYBRID1)
15356 {
15357 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15358 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15359 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15360 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15361 }
15362 else if (attack_mode == ATTACK_MODE_HYBRID2)
15363 {
15364 device_param->kernel_params_mp_buf32[5] = 0;
15365 device_param->kernel_params_mp_buf32[6] = 0;
15366 device_param->kernel_params_mp_buf32[7] = 0;
15367 }
15368
15369 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15370 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15371 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15372
15373 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);
15374 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);
15375 }
15376 }
15377 else if (attack_mode == ATTACK_MODE_BF)
15378 {
15379 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15380
15381 if (increment)
15382 {
15383 for (uint i = 0; i < dictcnt; i++)
15384 {
15385 local_free (dictfiles[i]);
15386 }
15387
15388 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15389 {
15390 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15391
15392 if (l1_filename == NULL) break;
15393
15394 dictcnt++;
15395
15396 dictfiles[dictcnt - 1] = l1_filename;
15397 }
15398 }
15399 else
15400 {
15401 dictcnt++;
15402
15403 dictfiles[dictcnt - 1] = mask;
15404 }
15405
15406 if (dictcnt == 0)
15407 {
15408 log_error ("ERROR: Mask is too small");
15409
15410 return (-1);
15411 }
15412 }
15413 }
15414
15415 free (induction_dictionaries);
15416
15417 // induction_dictionaries_cnt = 0; // implied
15418
15419 if (attack_mode != ATTACK_MODE_BF)
15420 {
15421 if (keyspace == 0)
15422 {
15423 induction_dictionaries = scan_directory (induction_directory);
15424
15425 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15426 }
15427 }
15428
15429 if (induction_dictionaries_cnt)
15430 {
15431 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15432 }
15433
15434 /**
15435 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15436 */
15437 if (keyspace == 1)
15438 {
15439 if ((maskcnt > 1) || (dictcnt > 1))
15440 {
15441 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15442
15443 return (-1);
15444 }
15445 }
15446
15447 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15448 {
15449 char *subid = logfile_generate_subid ();
15450
15451 data.subid = subid;
15452
15453 logfile_sub_msg ("START");
15454
15455 data.devices_status = STATUS_INIT;
15456
15457 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15458 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15459 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15460
15461 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15462
15463 data.cpt_pos = 0;
15464
15465 data.cpt_start = time (NULL);
15466
15467 data.cpt_total = 0;
15468
15469 if (data.restore == 0)
15470 {
15471 rd->words_cur = skip;
15472
15473 skip = 0;
15474
15475 data.skip = 0;
15476 }
15477
15478 data.ms_paused = 0;
15479
15480 data.words_cur = rd->words_cur;
15481
15482 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15483 {
15484 hc_device_param_t *device_param = &data.devices_param[device_id];
15485
15486 if (device_param->skipped) continue;
15487
15488 device_param->speed_pos = 0;
15489
15490 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15491 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15492 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15493
15494 device_param->kernel_power = device_param->kernel_power_user;
15495 device_param->kernel_blocks = device_param->kernel_blocks_user;
15496
15497 device_param->outerloop_pos = 0;
15498 device_param->outerloop_left = 0;
15499 device_param->innerloop_pos = 0;
15500 device_param->innerloop_left = 0;
15501
15502 // some more resets:
15503
15504 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15505
15506 memset (device_param->pws_buf, 0, device_param->size_pws);
15507
15508 device_param->pw_cnt = 0;
15509 device_param->pws_cnt = 0;
15510
15511 device_param->words_off = 0;
15512 device_param->words_done = 0;
15513 }
15514
15515 data.kernel_blocks_div = 0;
15516
15517 // figure out some workload
15518
15519 if (attack_mode == ATTACK_MODE_STRAIGHT)
15520 {
15521 if (data.wordlist_mode == WL_MODE_FILE)
15522 {
15523 char *dictfile = NULL;
15524
15525 if (induction_dictionaries_cnt)
15526 {
15527 dictfile = induction_dictionaries[0];
15528 }
15529 else
15530 {
15531 dictfile = dictfiles[dictpos];
15532 }
15533
15534 data.dictfile = dictfile;
15535
15536 logfile_sub_string (dictfile);
15537
15538 for (uint i = 0; i < rp_files_cnt; i++)
15539 {
15540 logfile_sub_var_string ("rulefile", rp_files[i]);
15541 }
15542
15543 FILE *fd2 = fopen (dictfile, "rb");
15544
15545 if (fd2 == NULL)
15546 {
15547 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15548
15549 return (-1);
15550 }
15551
15552 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15553
15554 fclose (fd2);
15555
15556 if (data.words_cnt == 0)
15557 {
15558 if (data.devices_status == STATUS_CRACKED) break;
15559 if (data.devices_status == STATUS_ABORTED) break;
15560
15561 dictpos++;
15562
15563 continue;
15564 }
15565 }
15566 }
15567 else if (attack_mode == ATTACK_MODE_COMBI)
15568 {
15569 char *dictfile = data.dictfile;
15570 char *dictfile2 = data.dictfile2;
15571
15572 logfile_sub_string (dictfile);
15573 logfile_sub_string (dictfile2);
15574
15575 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15576 {
15577 FILE *fd2 = fopen (dictfile, "rb");
15578
15579 if (fd2 == NULL)
15580 {
15581 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15582
15583 return (-1);
15584 }
15585
15586 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15587
15588 fclose (fd2);
15589 }
15590 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15591 {
15592 FILE *fd2 = fopen (dictfile2, "rb");
15593
15594 if (fd2 == NULL)
15595 {
15596 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15597
15598 return (-1);
15599 }
15600
15601 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15602
15603 fclose (fd2);
15604 }
15605
15606 if (data.words_cnt == 0)
15607 {
15608 if (data.devices_status == STATUS_CRACKED) break;
15609 if (data.devices_status == STATUS_ABORTED) break;
15610
15611 dictpos++;
15612
15613 continue;
15614 }
15615 }
15616 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15617 {
15618 char *dictfile = NULL;
15619
15620 if (induction_dictionaries_cnt)
15621 {
15622 dictfile = induction_dictionaries[0];
15623 }
15624 else
15625 {
15626 dictfile = dictfiles[dictpos];
15627 }
15628
15629 data.dictfile = dictfile;
15630
15631 char *mask = data.mask;
15632
15633 logfile_sub_string (dictfile);
15634 logfile_sub_string (mask);
15635
15636 FILE *fd2 = fopen (dictfile, "rb");
15637
15638 if (fd2 == NULL)
15639 {
15640 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15641
15642 return (-1);
15643 }
15644
15645 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15646
15647 fclose (fd2);
15648
15649 if (data.words_cnt == 0)
15650 {
15651 if (data.devices_status == STATUS_CRACKED) break;
15652 if (data.devices_status == STATUS_ABORTED) break;
15653
15654 dictpos++;
15655
15656 continue;
15657 }
15658 }
15659 else if (attack_mode == ATTACK_MODE_BF)
15660 {
15661 local_free (css_buf);
15662 local_free (data.root_css_buf);
15663 local_free (data.markov_css_buf);
15664
15665 char *mask = dictfiles[dictpos];
15666
15667 logfile_sub_string (mask);
15668
15669 // base
15670
15671 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15672
15673 if (opts_type & OPTS_TYPE_PT_UNICODE)
15674 {
15675 uint css_cnt_unicode = css_cnt * 2;
15676
15677 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15678
15679 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15680 {
15681 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15682
15683 css_buf_unicode[j + 1].cs_buf[0] = 0;
15684 css_buf_unicode[j + 1].cs_len = 1;
15685 }
15686
15687 free (css_buf);
15688
15689 css_buf = css_buf_unicode;
15690 css_cnt = css_cnt_unicode;
15691 }
15692
15693 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15694
15695 uint mask_min = pw_min;
15696 uint mask_max = pw_max;
15697
15698 if (opts_type & OPTS_TYPE_PT_UNICODE)
15699 {
15700 mask_min *= 2;
15701 mask_max *= 2;
15702 }
15703
15704 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15705 {
15706 if (css_cnt < mask_min)
15707 {
15708 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15709 }
15710
15711 if (css_cnt > mask_max)
15712 {
15713 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15714 }
15715
15716 // skip to next mask
15717
15718 dictpos++;
15719
15720 rd->dictpos = dictpos;
15721
15722 logfile_sub_msg ("STOP");
15723
15724 continue;
15725 }
15726
15727 uint save_css_cnt = css_cnt;
15728
15729 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15730 {
15731 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15732 {
15733 uint salt_len = (uint) data.salts_buf[0].salt_len;
15734 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15735
15736 uint css_cnt_salt = css_cnt + salt_len;
15737
15738 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15739
15740 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15741
15742 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15743 {
15744 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15745 css_buf_salt[j].cs_len = 1;
15746 }
15747
15748 free (css_buf);
15749
15750 css_buf = css_buf_salt;
15751 css_cnt = css_cnt_salt;
15752 }
15753 }
15754
15755 data.mask = mask;
15756 data.css_cnt = css_cnt;
15757 data.css_buf = css_buf;
15758
15759 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15760
15761 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15762
15763 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15764
15765 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15766
15767 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15768 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15769
15770 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15771
15772 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15773
15774 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15775 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15776
15777 data.root_css_buf = root_css_buf;
15778 data.markov_css_buf = markov_css_buf;
15779
15780 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15781
15782 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15783
15784 local_free (root_table_buf);
15785 local_free (markov_table_buf);
15786
15787 // copy + args
15788
15789 uint css_cnt_l = css_cnt;
15790 uint css_cnt_r;
15791
15792 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15793 {
15794 if (save_css_cnt < 6)
15795 {
15796 css_cnt_r = 1;
15797 }
15798 else if (save_css_cnt == 6)
15799 {
15800 css_cnt_r = 2;
15801 }
15802 else
15803 {
15804 if (opts_type & OPTS_TYPE_PT_UNICODE)
15805 {
15806 if (save_css_cnt == 8 || save_css_cnt == 10)
15807 {
15808 css_cnt_r = 2;
15809 }
15810 else
15811 {
15812 css_cnt_r = 4;
15813 }
15814 }
15815 else
15816 {
15817 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15818 {
15819 css_cnt_r = 3;
15820 }
15821 else
15822 {
15823 css_cnt_r = 4;
15824 }
15825 }
15826 }
15827 }
15828 else
15829 {
15830 css_cnt_r = 1;
15831
15832 /* unfinished code?
15833 int sum = css_buf[css_cnt_r - 1].cs_len;
15834
15835 for (uint i = 1; i < 4 && i < css_cnt; i++)
15836 {
15837 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15838
15839 css_cnt_r++;
15840
15841 sum *= css_buf[css_cnt_r - 1].cs_len;
15842 }
15843 */
15844 }
15845
15846 css_cnt_l -= css_cnt_r;
15847
15848 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15849
15850 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15851 {
15852 hc_device_param_t *device_param = &data.devices_param[device_id];
15853
15854 if (device_param->skipped) continue;
15855
15856 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15857 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15858 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15859
15860 device_param->kernel_params_mp_l_buf64[3] = 0;
15861 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15862 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15863 device_param->kernel_params_mp_l_buf32[6] = 0;
15864 device_param->kernel_params_mp_l_buf32[7] = 0;
15865 device_param->kernel_params_mp_l_buf32[8] = 0;
15866
15867 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15868 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15869 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15870 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15871
15872 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15873 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15874 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15875
15876 device_param->kernel_params_mp_r_buf64[3] = 0;
15877 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15878 device_param->kernel_params_mp_r_buf32[5] = 0;
15879 device_param->kernel_params_mp_r_buf32[6] = 0;
15880 device_param->kernel_params_mp_r_buf32[7] = 0;
15881
15882 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]);
15883 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]);
15884 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]);
15885
15886 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]);
15887 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]);
15888 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]);
15889
15890 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);
15891 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);
15892 }
15893 }
15894
15895 u64 words_base = data.words_cnt;
15896
15897 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15898 {
15899 if (data.kernel_rules_cnt)
15900 {
15901 words_base /= data.kernel_rules_cnt;
15902 }
15903 }
15904 else if (data.attack_kern == ATTACK_KERN_COMBI)
15905 {
15906 if (data.combs_cnt)
15907 {
15908 words_base /= data.combs_cnt;
15909 }
15910 }
15911 else if (data.attack_kern == ATTACK_KERN_BF)
15912 {
15913 if (data.bfs_cnt)
15914 {
15915 words_base /= data.bfs_cnt;
15916 }
15917 }
15918
15919 data.words_base = words_base;
15920
15921 if (keyspace == 1)
15922 {
15923 log_info ("%llu", (unsigned long long int) words_base);
15924
15925 return (0);
15926 }
15927
15928 if (data.words_cur > data.words_base)
15929 {
15930 log_error ("ERROR: restore value greater keyspace");
15931
15932 return (-1);
15933 }
15934
15935 if (data.words_cur)
15936 {
15937 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15938 {
15939 for (uint i = 0; i < data.salts_cnt; i++)
15940 {
15941 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15942 }
15943 }
15944 else if (data.attack_kern == ATTACK_KERN_COMBI)
15945 {
15946 for (uint i = 0; i < data.salts_cnt; i++)
15947 {
15948 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15949 }
15950 }
15951 else if (data.attack_kern == ATTACK_KERN_BF)
15952 {
15953 for (uint i = 0; i < data.salts_cnt; i++)
15954 {
15955 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15956 }
15957 }
15958 }
15959
15960 /*
15961 * Inform user about possible slow speeds
15962 */
15963
15964 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15965 {
15966 if (data.words_base < kernel_blocks_all)
15967 {
15968 if (quiet == 0)
15969 {
15970 log_info ("");
15971 log_info ("ATTENTION!");
15972 log_info (" The wordlist or mask you are using is too small.");
15973 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15974 log_info (" The cracking speed will drop.");
15975 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15976 log_info ("");
15977 }
15978 }
15979 }
15980
15981 /*
15982 * Update loopback file
15983 */
15984
15985 if (loopback == 1)
15986 {
15987 time_t now;
15988
15989 time (&now);
15990
15991 uint random_num = get_random_num (0, 9999);
15992
15993 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15994
15995 data.loopback_file = loopback_file;
15996 }
15997
15998 /*
15999 * Update dictionary statistic
16000 */
16001
16002 if (keyspace == 0)
16003 {
16004 dictstat_fp = fopen (dictstat, "wb");
16005
16006 if (dictstat_fp)
16007 {
16008 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16009
16010 fclose (dictstat_fp);
16011 }
16012 }
16013
16014 data.devices_status = STATUS_RUNNING;
16015
16016 if (initial_restore_done == 0)
16017 {
16018 if (data.restore_disable == 0) cycle_restore ();
16019
16020 initial_restore_done = 1;
16021 }
16022
16023 hc_timer_set (&data.timer_running);
16024
16025 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16026 {
16027 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16028 {
16029 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16030 if (quiet == 0) fflush (stdout);
16031 }
16032 }
16033 else if (wordlist_mode == WL_MODE_STDIN)
16034 {
16035 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16036 if (data.quiet == 0) log_info ("");
16037 }
16038
16039 time_t runtime_start;
16040
16041 time (&runtime_start);
16042
16043 data.runtime_start = runtime_start;
16044
16045 /**
16046 * create cracker threads
16047 */
16048
16049 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16050
16051 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16052 {
16053 hc_device_param_t *device_param = &devices_param[device_id];
16054
16055 if (device_param->skipped) continue;
16056
16057 if (wordlist_mode == WL_MODE_STDIN)
16058 {
16059 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16060 }
16061 else
16062 {
16063 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16064 }
16065 }
16066
16067 // wait for crack threads to exit
16068
16069 hc_thread_wait (devices_cnt, c_threads);
16070
16071 local_free (c_threads);
16072
16073 data.restore = 0;
16074
16075 // finalize task
16076
16077 logfile_sub_var_uint ("status-after-work", data.devices_status);
16078
16079 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16080
16081 if (data.devices_status == STATUS_CRACKED) break;
16082 if (data.devices_status == STATUS_ABORTED) break;
16083
16084 if (data.devices_status == STATUS_BYPASS)
16085 {
16086 data.devices_status = STATUS_RUNNING;
16087 }
16088
16089 if (induction_dictionaries_cnt)
16090 {
16091 unlink (induction_dictionaries[0]);
16092 }
16093
16094 free (induction_dictionaries);
16095
16096 if (attack_mode != ATTACK_MODE_BF)
16097 {
16098 induction_dictionaries = scan_directory (induction_directory);
16099
16100 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16101 }
16102
16103 if (benchmark == 0)
16104 {
16105 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16106 {
16107 if (quiet == 0) clear_prompt ();
16108
16109 if (quiet == 0) log_info ("");
16110
16111 if (status == 1)
16112 {
16113 status_display ();
16114 }
16115 else
16116 {
16117 if (quiet == 0) status_display ();
16118 }
16119
16120 if (quiet == 0) log_info ("");
16121 }
16122 }
16123
16124 if (attack_mode == ATTACK_MODE_BF)
16125 {
16126 dictpos++;
16127
16128 rd->dictpos = dictpos;
16129 }
16130 else
16131 {
16132 if (induction_dictionaries_cnt)
16133 {
16134 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16135 }
16136 else
16137 {
16138 dictpos++;
16139
16140 rd->dictpos = dictpos;
16141 }
16142 }
16143
16144 time_t runtime_stop;
16145
16146 time (&runtime_stop);
16147
16148 data.runtime_stop = runtime_stop;
16149
16150 logfile_sub_uint (runtime_start);
16151 logfile_sub_uint (runtime_stop);
16152
16153 logfile_sub_msg ("STOP");
16154
16155 global_free (subid);
16156 }
16157
16158 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16159
16160 if (data.devices_status == STATUS_CRACKED) break;
16161 if (data.devices_status == STATUS_ABORTED) break;
16162 if (data.devices_status == STATUS_QUIT) break;
16163
16164 if (data.devices_status == STATUS_BYPASS)
16165 {
16166 data.devices_status = STATUS_RUNNING;
16167 }
16168 }
16169
16170 // 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
16171
16172 if (attack_mode == ATTACK_MODE_STRAIGHT)
16173 {
16174 if (data.wordlist_mode == WL_MODE_FILE)
16175 {
16176 if (data.dictfile == NULL)
16177 {
16178 if (dictfiles != NULL)
16179 {
16180 data.dictfile = dictfiles[0];
16181
16182 hc_timer_set (&data.timer_running);
16183 }
16184 }
16185 }
16186 }
16187 // NOTE: combi is okay because it is already set beforehand
16188 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16189 {
16190 if (data.dictfile == NULL)
16191 {
16192 if (dictfiles != NULL)
16193 {
16194 hc_timer_set (&data.timer_running);
16195
16196 data.dictfile = dictfiles[0];
16197 }
16198 }
16199 }
16200 else if (attack_mode == ATTACK_MODE_BF)
16201 {
16202 if (data.mask == NULL)
16203 {
16204 hc_timer_set (&data.timer_running);
16205
16206 data.mask = masks[0];
16207 }
16208 }
16209
16210 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16211 {
16212 data.devices_status = STATUS_EXHAUSTED;
16213 }
16214
16215 // if cracked / aborted remove last induction dictionary
16216
16217 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16218 {
16219 struct stat induct_stat;
16220
16221 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16222 {
16223 unlink (induction_dictionaries[file_pos]);
16224 }
16225 }
16226
16227 // wait for non-interactive threads
16228
16229 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16230 {
16231 hc_thread_wait (1, &ni_threads[thread_idx]);
16232 }
16233
16234 local_free (ni_threads);
16235
16236 // wait for interactive threads
16237
16238 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16239 {
16240 hc_thread_wait (1, &i_thread);
16241 }
16242
16243 // we dont need restore file anymore
16244 if (data.restore_disable == 0)
16245 {
16246 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16247 {
16248 unlink (eff_restore_file);
16249 unlink (new_restore_file);
16250 }
16251 else
16252 {
16253 cycle_restore ();
16254 }
16255 }
16256
16257 // finally save left hashes
16258
16259 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16260 {
16261 save_hash ();
16262 }
16263
16264 /**
16265 * Clean up
16266 */
16267
16268 if (benchmark == 1)
16269 {
16270 status_benchmark ();
16271
16272 log_info ("");
16273 }
16274 else
16275 {
16276 if (quiet == 0) clear_prompt ();
16277
16278 if (quiet == 0) log_info ("");
16279
16280 if (status == 1)
16281 {
16282 status_display ();
16283 }
16284 else
16285 {
16286 if (quiet == 0) status_display ();
16287 }
16288
16289 if (quiet == 0) log_info ("");
16290 }
16291
16292 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16293 {
16294 hc_device_param_t *device_param = &data.devices_param[device_id];
16295
16296 if (device_param->skipped) continue;
16297
16298 local_free (device_param->result);
16299
16300 local_free (device_param->pw_caches);
16301
16302 local_free (device_param->combs_buf);
16303
16304 local_free (device_param->hooks_buf);
16305
16306 local_free (device_param->device_name);
16307
16308 local_free (device_param->device_name_chksum);
16309
16310 local_free (device_param->device_version);
16311
16312 local_free (device_param->driver_version);
16313
16314 if (device_param->pws_buf) myfree (device_param->pws_buf);
16315 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16316 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16317 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16318 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16319 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16320 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16321 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16322 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16323 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16324 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16325 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16326 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16327 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16328 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16329 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16330 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16331 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16332 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16333 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16334 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16335 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16336 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16337 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16338 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16339 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16340 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16341 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16342 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16343
16344 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16345 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16346 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16347 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16348 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16349 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16350 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16351 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16352 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16353 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16354 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16355
16356 if (device_param->program) hc_clReleaseProgram (device_param->program);
16357 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16358 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16359
16360 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16361 if (device_param->context) hc_clReleaseContext (device_param->context);
16362 }
16363
16364 // reset default fan speed
16365
16366 if (gpu_temp_disable == 0)
16367 {
16368 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16369 {
16370 hc_thread_mutex_lock (mux_adl);
16371
16372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16373 {
16374 hc_device_param_t *device_param = &data.devices_param[device_id];
16375
16376 if (device_param->skipped) continue;
16377
16378 if (data.hm_device[device_id].fan_supported == 1)
16379 {
16380 int fanspeed = temp_retain_fanspeed_value[device_id];
16381
16382 if (fanspeed == -1) continue;
16383
16384 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16385
16386 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16387 }
16388 }
16389
16390 hc_thread_mutex_unlock (mux_adl);
16391 }
16392 }
16393
16394 // reset power tuning
16395
16396 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16397 {
16398 hc_thread_mutex_lock (mux_adl);
16399
16400 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16401 {
16402 hc_device_param_t *device_param = &data.devices_param[device_id];
16403
16404 if (device_param->skipped) continue;
16405
16406 if (data.hm_device[device_id].od_version == 6)
16407 {
16408 // check powertune capabilities first, if not available then skip device
16409
16410 int powertune_supported = 0;
16411
16412 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16413 {
16414 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16415
16416 return (-1);
16417 }
16418
16419 if (powertune_supported != 0)
16420 {
16421 // powercontrol settings
16422
16423 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)
16424 {
16425 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16426
16427 return (-1);
16428 }
16429
16430 // clocks
16431
16432 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16433
16434 performance_state->iNumberOfPerformanceLevels = 2;
16435
16436 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16437 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16438 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16439 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16440
16441 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)
16442 {
16443 log_info ("ERROR: Failed to restore ADL performance state");
16444
16445 return (-1);
16446 }
16447
16448 local_free (performance_state);
16449 }
16450 }
16451 }
16452
16453 hc_thread_mutex_unlock (mux_adl);
16454 }
16455
16456 if (gpu_temp_disable == 0)
16457 {
16458 #ifdef LINUX
16459 if (data.hm_dll_nv)
16460 {
16461 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16462
16463 hm_close (data.hm_dll_nv);
16464 }
16465 #endif
16466
16467 #ifdef WIN
16468 NvAPI_Unload ();
16469 #endif
16470
16471 if (data.hm_dll_amd)
16472 {
16473 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16474
16475 hm_close (data.hm_dll_amd);
16476 }
16477 }
16478
16479 // free memory
16480
16481 local_free (masks);
16482
16483 local_free (dictstat_base);
16484
16485 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16486 {
16487 pot_t *pot_ptr = &pot[pot_pos];
16488
16489 hash_t *hash = &pot_ptr->hash;
16490
16491 local_free (hash->digest);
16492
16493 if (isSalted)
16494 {
16495 local_free (hash->salt);
16496 }
16497 }
16498
16499 local_free (pot);
16500
16501 local_free (all_kernel_rules_cnt);
16502 local_free (all_kernel_rules_buf);
16503
16504 local_free (wl_data->buf);
16505 local_free (wl_data);
16506
16507 local_free (bitmap_s1_a);
16508 local_free (bitmap_s1_b);
16509 local_free (bitmap_s1_c);
16510 local_free (bitmap_s1_d);
16511 local_free (bitmap_s2_a);
16512 local_free (bitmap_s2_b);
16513 local_free (bitmap_s2_c);
16514 local_free (bitmap_s2_d);
16515
16516 local_free (temp_retain_fanspeed_value);
16517 local_free (od_clock_mem_status);
16518 local_free (od_power_control_status);
16519
16520 global_free (devices_param);
16521
16522 global_free (kernel_rules_buf);
16523
16524 global_free (root_css_buf);
16525 global_free (markov_css_buf);
16526
16527 global_free (digests_buf);
16528 global_free (digests_shown);
16529 global_free (digests_shown_tmp);
16530
16531 global_free (salts_buf);
16532 global_free (salts_shown);
16533
16534 global_free (esalts_buf);
16535
16536 global_free (words_progress_done);
16537 global_free (words_progress_rejected);
16538 global_free (words_progress_restored);
16539
16540 if (pot_fp) fclose (pot_fp);
16541
16542 if (data.devices_status == STATUS_QUIT) break;
16543 }
16544
16545 // destroy others mutex
16546
16547 hc_thread_mutex_delete (mux_dispatcher);
16548 hc_thread_mutex_delete (mux_counter);
16549 hc_thread_mutex_delete (mux_display);
16550 hc_thread_mutex_delete (mux_adl);
16551
16552 // free memory
16553
16554 local_free (eff_restore_file);
16555 local_free (new_restore_file);
16556
16557 local_free (rd);
16558
16559 // loopback
16560
16561 local_free (loopback_file);
16562
16563 if (loopback == 1) unlink (loopback_file);
16564
16565 // induction directory
16566
16567 if (induction_dir == NULL)
16568 {
16569 if (attack_mode != ATTACK_MODE_BF)
16570 {
16571 if (rmdir (induction_directory) == -1)
16572 {
16573 if (errno == ENOENT)
16574 {
16575 // good, we can ignore
16576 }
16577 else if (errno == ENOTEMPTY)
16578 {
16579 // good, we can ignore
16580 }
16581 else
16582 {
16583 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16584
16585 return (-1);
16586 }
16587 }
16588
16589 local_free (induction_directory);
16590 }
16591 }
16592
16593 // outfile-check directory
16594
16595 if (outfile_check_dir == NULL)
16596 {
16597 if (rmdir (outfile_check_directory) == -1)
16598 {
16599 if (errno == ENOENT)
16600 {
16601 // good, we can ignore
16602 }
16603 else if (errno == ENOTEMPTY)
16604 {
16605 // good, we can ignore
16606 }
16607 else
16608 {
16609 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16610
16611 return (-1);
16612 }
16613 }
16614
16615 local_free (outfile_check_directory);
16616 }
16617
16618 time_t proc_stop;
16619
16620 time (&proc_stop);
16621
16622 logfile_top_uint (proc_start);
16623 logfile_top_uint (proc_stop);
16624
16625 logfile_top_msg ("STOP");
16626
16627 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16628 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16629
16630 if (data.devices_status == STATUS_ABORTED) return 2;
16631 if (data.devices_status == STATUS_QUIT) return 2;
16632 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16633 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16634 if (data.devices_status == STATUS_CRACKED) return 0;
16635
16636 return -1;
16637 }
Hashcat additions to support pwdhash