projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed a buffer overflow in potfile handling
[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] = { 0 };
1356
1357 strncpy (display_dev_cur, "0.00", 4);
1358
1359 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1360
1361 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1362 }
1363
1364 char display_all_cur[16] = { 0 };
1365
1366 strncpy (display_all_cur, "0.00", 4);
1367
1368 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1369
1370 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1371
1372 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1373 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1374
1375 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);
1376
1377 // crack-per-time
1378
1379 if (data.digests_cnt > 100)
1380 {
1381 time_t now = time (NULL);
1382
1383 int cpt_cur_min = 0;
1384 int cpt_cur_hour = 0;
1385 int cpt_cur_day = 0;
1386
1387 for (int i = 0; i < CPT_BUF; i++)
1388 {
1389 const uint cracked = data.cpt_buf[i].cracked;
1390 const time_t timestamp = data.cpt_buf[i].timestamp;
1391
1392 if ((timestamp + 60) > now)
1393 {
1394 cpt_cur_min += cracked;
1395 }
1396
1397 if ((timestamp + 3600) > now)
1398 {
1399 cpt_cur_hour += cracked;
1400 }
1401
1402 if ((timestamp + 86400) > now)
1403 {
1404 cpt_cur_day += cracked;
1405 }
1406 }
1407
1408 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1409 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1410 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1411
1412 if ((data.cpt_start + 86400) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_cur_hour,
1417 cpt_cur_day,
1418 cpt_avg_min,
1419 cpt_avg_hour,
1420 cpt_avg_day);
1421 }
1422 else if ((data.cpt_start + 3600) < now)
1423 {
1424 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1425 cpt_cur_min,
1426 cpt_cur_hour,
1427 cpt_avg_min,
1428 cpt_avg_hour,
1429 cpt_avg_day);
1430 }
1431 else if ((data.cpt_start + 60) < now)
1432 {
1433 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1434 cpt_cur_min,
1435 cpt_avg_min,
1436 cpt_avg_hour,
1437 cpt_avg_day);
1438 }
1439 else
1440 {
1441 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_avg_min,
1443 cpt_avg_hour,
1444 cpt_avg_day);
1445 }
1446 }
1447
1448 // Restore point
1449
1450 u64 restore_point = get_lowest_words_done ();
1451
1452 u64 restore_total = data.words_base;
1453
1454 float percent_restore = 0;
1455
1456 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1457
1458 if (progress_end_relative_skip)
1459 {
1460 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1461 {
1462 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1463 float percent_rejected = 0.0;
1464
1465 if (progress_cur)
1466 {
1467 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1468 }
1469
1470 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);
1471 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1472
1473 if (data.restore_disable == 0)
1474 {
1475 if (percent_finished != 1)
1476 {
1477 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1478 }
1479 }
1480 }
1481 }
1482 else
1483 {
1484 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1485 {
1486 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1487 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1488
1489 if (data.restore_disable == 0)
1490 {
1491 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1492 }
1493 }
1494 else
1495 {
1496 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1497 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1498
1499 // --restore not allowed if stdin is used -- really? why?
1500
1501 //if (data.restore_disable == 0)
1502 //{
1503 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1504 //}
1505 }
1506 }
1507
1508 if (data.gpu_temp_disable == 0)
1509 {
1510 hc_thread_mutex_lock (mux_adl);
1511
1512 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1513 {
1514 hc_device_param_t *device_param = &data.devices_param[device_id];
1515
1516 if (device_param->skipped) continue;
1517
1518 #define HM_STR_BUF_SIZE 255
1519
1520 if (data.hm_device[device_id].fan_supported == 1)
1521 {
1522 char utilization[HM_STR_BUF_SIZE];
1523 char temperature[HM_STR_BUF_SIZE];
1524 char fanspeed[HM_STR_BUF_SIZE];
1525
1526 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1527 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1528
1529 if (device_param->vendor_id == VENDOR_ID_AMD)
1530 {
1531 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1532 }
1533 else if (device_param->vendor_id == VENDOR_ID_NV)
1534 {
1535 #ifdef LINUX
1536 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1537 #else
1538 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1539 #endif
1540 }
1541
1542 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1543 }
1544 else
1545 {
1546 char utilization[HM_STR_BUF_SIZE];
1547 char temperature[HM_STR_BUF_SIZE];
1548
1549 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1550 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1551
1552 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1553 }
1554 }
1555
1556 hc_thread_mutex_unlock (mux_adl);
1557 }
1558 }
1559
1560 static void status_benchmark ()
1561 {
1562 if (data.devices_status == STATUS_INIT) return;
1563 if (data.devices_status == STATUS_STARTING) return;
1564
1565 if (data.words_cnt == 0) return;
1566
1567 u64 speed_cnt[DEVICES_MAX];
1568 float speed_ms[DEVICES_MAX];
1569
1570 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1571 {
1572 hc_device_param_t *device_param = &data.devices_param[device_id];
1573
1574 if (device_param->skipped) continue;
1575
1576 speed_cnt[device_id] = 0;
1577 speed_ms[device_id] = 0;
1578
1579 for (int i = 0; i < SPEED_CACHE; i++)
1580 {
1581 speed_cnt[device_id] += device_param->speed_cnt[i];
1582 speed_ms[device_id] += device_param->speed_ms[i];
1583 }
1584
1585 speed_cnt[device_id] /= SPEED_CACHE;
1586 speed_ms[device_id] /= SPEED_CACHE;
1587 }
1588
1589 float hashes_all_ms = 0;
1590
1591 float hashes_dev_ms[DEVICES_MAX];
1592
1593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1594 {
1595 hc_device_param_t *device_param = &data.devices_param[device_id];
1596
1597 if (device_param->skipped) continue;
1598
1599 hashes_dev_ms[device_id] = 0;
1600
1601 if (speed_ms[device_id])
1602 {
1603 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1604
1605 hashes_all_ms += hashes_dev_ms[device_id];
1606 }
1607 }
1608
1609 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1610 {
1611 hc_device_param_t *device_param = &data.devices_param[device_id];
1612
1613 if (device_param->skipped) continue;
1614
1615 char display_dev_cur[16] = { 0 };
1616
1617 strncpy (display_dev_cur, "0.00", 4);
1618
1619 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1620
1621 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1622 }
1623
1624 char display_all_cur[16] = { 0 };
1625
1626 strncpy (display_all_cur, "0.00", 4);
1627
1628 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1629
1630 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1631 }
1632
1633 /**
1634 * oclHashcat -only- functions
1635 */
1636
1637 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1638 {
1639 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1640 {
1641 if (attack_kern == ATTACK_KERN_STRAIGHT)
1642 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1643 else if (attack_kern == ATTACK_KERN_COMBI)
1644 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1645 else if (attack_kern == ATTACK_KERN_BF)
1646 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1647 }
1648 else
1649 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1650 }
1651
1652 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)
1653 {
1654 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1655 {
1656 if (attack_kern == ATTACK_KERN_STRAIGHT)
1657 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1658 else if (attack_kern == ATTACK_KERN_COMBI)
1659 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1660 else if (attack_kern == ATTACK_KERN_BF)
1661 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1662 }
1663 else
1664 {
1665 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1666 }
1667 }
1668
1669 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1670 {
1671 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1672 {
1673 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1674 }
1675 else
1676 {
1677 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1678 }
1679 }
1680
1681 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)
1682 {
1683 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1684 {
1685 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1686 }
1687 else
1688 {
1689 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1690 }
1691 }
1692
1693 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1694 {
1695 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1696 }
1697
1698 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1699 {
1700 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1701 }
1702
1703 static uint convert_from_hex (char *line_buf, const uint line_len)
1704 {
1705 if (line_len & 1) return (line_len); // not in hex
1706
1707 if (data.hex_wordlist == 1)
1708 {
1709 uint i;
1710 uint j;
1711
1712 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1713 {
1714 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1715 }
1716
1717 memset (line_buf + i, 0, line_len - i);
1718
1719 return (i);
1720 }
1721 else if (line_len >= 6) // $HEX[] = 6
1722 {
1723 if (line_buf[0] != '$') return (line_len);
1724 if (line_buf[1] != 'H') return (line_len);
1725 if (line_buf[2] != 'E') return (line_len);
1726 if (line_buf[3] != 'X') return (line_len);
1727 if (line_buf[4] != '[') return (line_len);
1728 if (line_buf[line_len - 1] != ']') return (line_len);
1729
1730 uint i;
1731 uint j;
1732
1733 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1734 {
1735 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1736 }
1737
1738 memset (line_buf + i, 0, line_len - i);
1739
1740 return (i);
1741 }
1742
1743 return (line_len);
1744 }
1745
1746 static uint count_lines (FILE *fd)
1747 {
1748 uint cnt = 0;
1749
1750 char *buf = (char *) mymalloc (BUFSIZ + 1);
1751
1752 size_t nread_tmp = 0;
1753
1754 char *ptr = buf;
1755
1756 while (!feof (fd))
1757 {
1758 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1759 nread_tmp = nread;
1760
1761 if (nread < 1) continue;
1762
1763 ptr = buf;
1764
1765 do
1766 {
1767 if (*ptr++ == '\n') cnt++;
1768
1769 } while (nread--);
1770 }
1771
1772 // special case (if last line did not contain a newline char ... at the very end of the file)
1773
1774 if (nread_tmp > 3)
1775 {
1776 ptr -= 2;
1777
1778 if (*ptr != '\n')
1779 {
1780 ptr--;
1781
1782 if (*ptr != '\n') // needed ? different on windows systems?
1783 {
1784 cnt++;
1785 }
1786 }
1787 }
1788
1789 myfree (buf);
1790
1791 return cnt;
1792 }
1793
1794 static void clear_prompt ()
1795 {
1796 fputc ('\r', stdout);
1797
1798 for (size_t i = 0; i < strlen (PROMPT); i++)
1799 {
1800 fputc (' ', stdout);
1801 }
1802
1803 fputc ('\r', stdout);
1804
1805 fflush (stdout);
1806 }
1807
1808 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1809 {
1810 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1811 }
1812
1813 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1814 {
1815 char *outfile = data.outfile;
1816 uint quiet = data.quiet;
1817 FILE *pot_fp = data.pot_fp;
1818 uint loopback = data.loopback;
1819 uint debug_mode = data.debug_mode;
1820 char *debug_file = data.debug_file;
1821
1822 char debug_rule_buf[BLOCK_SIZE];
1823 int debug_rule_len = 0; // -1 error
1824 uint debug_plain_len = 0;
1825
1826 u8 debug_plain_ptr[BLOCK_SIZE];
1827
1828 // hash
1829
1830 char out_buf[4096] = { 0 };
1831
1832 ascii_digest (out_buf, salt_pos, digest_pos);
1833
1834 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1835
1836 // plain
1837
1838 plain_t plain;
1839
1840 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1841
1842 uint gidvid = plain.gidvid;
1843 uint il_pos = plain.il_pos;
1844
1845 u64 crackpos = device_param->words_off;
1846
1847 uint plain_buf[16];
1848
1849 u8 *plain_ptr = (u8 *) plain_buf;
1850 unsigned int plain_len = 0;
1851
1852 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1853 {
1854 u64 gidd = gidvid;
1855 u64 gidm = 0;
1856
1857 pw_t pw;
1858
1859 gidd_to_pw_t (device_param, gidd, &pw);
1860
1861 for (int i = 0, j = gidm; i < 16; i++, j++)
1862 {
1863 plain_buf[i] = pw.hi1[0][j];
1864 }
1865
1866 plain_len = pw.pw_len;
1867
1868 const uint off = device_param->innerloop_pos + il_pos;
1869
1870 if (debug_mode > 0)
1871 {
1872 debug_rule_len = 0;
1873
1874 // save rule
1875 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1876 {
1877 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1878
1879 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1880 }
1881
1882 // save plain
1883 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1884 {
1885 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1886
1887 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1888
1889 debug_plain_len = plain_len;
1890 }
1891 }
1892
1893 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1894
1895 crackpos += gidvid;
1896 crackpos *= data.kernel_rules_cnt;
1897 crackpos += device_param->innerloop_pos + il_pos;
1898
1899 if (plain_len > data.pw_max) plain_len = data.pw_max;
1900 }
1901 else if (data.attack_mode == ATTACK_MODE_COMBI)
1902 {
1903 u64 gidd = gidvid;
1904 u64 gidm = 0;
1905
1906 pw_t pw;
1907
1908 gidd_to_pw_t (device_param, gidd, &pw);
1909
1910 for (int i = 0, j = gidm; i < 16; i++, j++)
1911 {
1912 plain_buf[i] = pw.hi1[0][j];
1913 }
1914
1915 plain_len = pw.pw_len;
1916
1917 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1918 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1919
1920 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1921 {
1922 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1923 }
1924 else
1925 {
1926 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1927
1928 memcpy (plain_ptr, comb_buf, comb_len);
1929 }
1930
1931 plain_len += comb_len;
1932
1933 crackpos += gidvid;
1934 crackpos *= data.combs_cnt;
1935 crackpos += device_param->innerloop_pos + il_pos;
1936
1937 if (data.pw_max != PW_DICTMAX1)
1938 {
1939 if (plain_len > data.pw_max) plain_len = data.pw_max;
1940 }
1941 }
1942 else if (data.attack_mode == ATTACK_MODE_BF)
1943 {
1944 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1945 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1946
1947 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1948 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1949
1950 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1951 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1952
1953 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1954 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1955
1956 plain_len = data.css_cnt;
1957
1958 crackpos += gidvid;
1959 crackpos *= data.bfs_cnt;
1960 crackpos += device_param->innerloop_pos + il_pos;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1963 {
1964 u64 gidd = gidvid;
1965 u64 gidm = 0;
1966
1967 pw_t pw;
1968
1969 gidd_to_pw_t (device_param, gidd, &pw);
1970
1971 for (int i = 0, j = gidm; i < 16; i++, j++)
1972 {
1973 plain_buf[i] = pw.hi1[0][j];
1974 }
1975
1976 plain_len = pw.pw_len;
1977
1978 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1979
1980 uint start = 0;
1981 uint stop = device_param->kernel_params_mp_buf32[4];
1982
1983 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1984
1985 plain_len += start + stop;
1986
1987 crackpos += gidvid;
1988 crackpos *= data.combs_cnt;
1989 crackpos += device_param->innerloop_pos + il_pos;
1990
1991 if (data.pw_max != PW_DICTMAX1)
1992 {
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 }
1996 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1997 {
1998 u64 gidd = gidvid;
1999 u64 gidm = 0;
2000
2001 pw_t pw;
2002
2003 gidd_to_pw_t (device_param, gidd, &pw);
2004
2005 for (int i = 0, j = gidm; i < 16; i++, j++)
2006 {
2007 plain_buf[i] = pw.hi1[0][j];
2008 }
2009
2010 plain_len = pw.pw_len;
2011
2012 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2013
2014 uint start = 0;
2015 uint stop = device_param->kernel_params_mp_buf32[4];
2016
2017 memmove (plain_ptr + stop, plain_ptr, plain_len);
2018
2019 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032
2033 if (data.attack_mode == ATTACK_MODE_BF)
2034 {
2035 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2036 {
2037 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2038 {
2039 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2040 {
2041 plain_len = plain_len - data.salts_buf[0].salt_len;
2042 }
2043 }
2044
2045 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2046 {
2047 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2048 {
2049 plain_ptr[j] = plain_ptr[i];
2050 }
2051
2052 plain_len = plain_len / 2;
2053 }
2054 }
2055 }
2056
2057 // if enabled, update also the potfile
2058
2059 if (pot_fp)
2060 {
2061 fprintf (pot_fp, "%s:", out_buf);
2062
2063 format_plain (pot_fp, plain_ptr, plain_len, 1);
2064
2065 fputc ('\n', pot_fp);
2066
2067 fflush (pot_fp);
2068 }
2069
2070 // outfile
2071
2072 FILE *out_fp = NULL;
2073
2074 if (outfile != NULL)
2075 {
2076 if ((out_fp = fopen (outfile, "ab")) == NULL)
2077 {
2078 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2079
2080 out_fp = stdout;
2081 }
2082 }
2083 else
2084 {
2085 out_fp = stdout;
2086
2087 if (quiet == 0) clear_prompt ();
2088 }
2089
2090 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2091
2092 if (outfile != NULL)
2093 {
2094 if (out_fp != stdout)
2095 {
2096 fclose (out_fp);
2097 }
2098 }
2099 else
2100 {
2101 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2102 {
2103 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2104 {
2105 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2106 if (quiet == 0) fflush (stdout);
2107 }
2108 }
2109 }
2110
2111 // loopback
2112
2113 if (loopback)
2114 {
2115 char *loopback_file = data.loopback_file;
2116
2117 FILE *fb_fp = NULL;
2118
2119 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2120 {
2121 format_plain (fb_fp, plain_ptr, plain_len, 1);
2122
2123 fputc ('\n', fb_fp);
2124
2125 fclose (fb_fp);
2126 }
2127 }
2128
2129 // (rule) debug mode
2130
2131 // the next check implies that:
2132 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2133 // - debug_mode > 0
2134
2135 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2136 {
2137 if (debug_rule_len < 0) debug_rule_len = 0;
2138
2139 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2140
2141 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2142
2143 if ((quiet == 0) && (debug_file == NULL))
2144 {
2145 fprintf (stdout, "%s", PROMPT);
2146 fflush (stdout);
2147 }
2148 }
2149 }
2150
2151 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2152 {
2153 salt_t *salt_buf = &data.salts_buf[salt_pos];
2154
2155 int found = 0;
2156
2157 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2158
2159 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2160
2161 if (found == 1)
2162 {
2163 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2164
2165 log_info_nn ("");
2166
2167 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);
2168
2169 uint cpt_cracked = 0;
2170
2171 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2172 {
2173 uint idx = salt_buf->digests_offset + digest_pos;
2174
2175 if (data.digests_shown_tmp[idx] == 0) continue;
2176
2177 if (data.digests_shown[idx] == 1) continue;
2178
2179 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2180 {
2181 data.digests_shown[idx] = 1;
2182
2183 data.digests_done++;
2184
2185 cpt_cracked++;
2186
2187 salt_buf->digests_done++;
2188
2189 if (salt_buf->digests_done == salt_buf->digests_cnt)
2190 {
2191 data.salts_shown[salt_pos] = 1;
2192
2193 data.salts_done++;
2194 }
2195 }
2196
2197 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2198
2199 check_hash (device_param, salt_pos, digest_pos);
2200 }
2201
2202 if (cpt_cracked > 0)
2203 {
2204 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2205 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2206
2207 data.cpt_pos++;
2208
2209 data.cpt_total += cpt_cracked;
2210
2211 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2212 }
2213
2214 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2215 {
2216 // we need to reset cracked state on the device
2217 // otherwise host thinks again and again the hash was cracked
2218 // and returns invalid password each time
2219
2220 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2221
2222 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);
2223 }
2224
2225 memset (device_param->result, 0, device_param->size_results);
2226
2227 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2228 }
2229 }
2230
2231 static void save_hash ()
2232 {
2233 char *hashfile = data.hashfile;
2234
2235 char new_hashfile[256] = { 0 };
2236 char old_hashfile[256] = { 0 };
2237
2238 snprintf (new_hashfile, 255, "%s.new", hashfile);
2239 snprintf (old_hashfile, 255, "%s.old", hashfile);
2240
2241 unlink (new_hashfile);
2242
2243 char separator = data.separator;
2244
2245 FILE *fp = fopen (new_hashfile, "wb");
2246
2247 if (fp == NULL)
2248 {
2249 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2250
2251 exit (-1);
2252 }
2253
2254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2255 {
2256 if (data.salts_shown[salt_pos] == 1) continue;
2257
2258 salt_t *salt_buf = &data.salts_buf[salt_pos];
2259
2260 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2261 {
2262 uint idx = salt_buf->digests_offset + digest_pos;
2263
2264 if (data.digests_shown[idx] == 1) continue;
2265
2266 if (data.hash_mode != 2500)
2267 {
2268 char out_buf[4096] = { 0 };
2269
2270 if (data.username == 1)
2271 {
2272 user_t *user = data.hash_info[idx]->user;
2273
2274 uint i;
2275
2276 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2277
2278 fputc (separator, fp);
2279 }
2280
2281 ascii_digest (out_buf, salt_pos, digest_pos);
2282
2283 fputs (out_buf, fp);
2284
2285 log_out (fp, "");
2286 }
2287 else
2288 {
2289 hccap_t hccap;
2290
2291 to_hccap_t (&hccap, salt_pos, digest_pos);
2292
2293 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2294 }
2295 }
2296 }
2297
2298 fflush (fp);
2299
2300 fclose (fp);
2301
2302 unlink (old_hashfile);
2303
2304 if (rename (hashfile, old_hashfile) != 0)
2305 {
2306 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2307
2308 exit (-1);
2309 }
2310
2311 unlink (hashfile);
2312
2313 if (rename (new_hashfile, hashfile) != 0)
2314 {
2315 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 unlink (old_hashfile);
2321 }
2322
2323 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2324 {
2325 // function called only in case kernel_blocks_all > words_left)
2326
2327 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2328
2329 kernel_blocks_div += kernel_blocks_div / 100;
2330
2331 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2332
2333 while (kernel_blocks_new < total_left)
2334 {
2335 kernel_blocks_div += kernel_blocks_div / 100;
2336
2337 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2338 }
2339
2340 if (data.quiet == 0)
2341 {
2342 clear_prompt ();
2343
2344 log_info ("");
2345
2346 log_info ("INFO: approaching final keyspace, workload adjusted");
2347
2348 log_info ("");
2349
2350 fprintf (stdout, "%s", PROMPT);
2351
2352 fflush (stdout);
2353 }
2354
2355 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2356
2357 return kernel_blocks_div;
2358 }
2359
2360 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2361 {
2362 uint num_elements = num;
2363
2364 device_param->kernel_params_buf32[30] = data.combs_mode;
2365 device_param->kernel_params_buf32[31] = num;
2366
2367 uint kernel_threads = device_param->kernel_threads;
2368
2369 while (num_elements % kernel_threads) num_elements++;
2370
2371 cl_kernel kernel = NULL;
2372
2373 switch (kern_run)
2374 {
2375 case KERN_RUN_1: kernel = device_param->kernel1; break;
2376 case KERN_RUN_12: kernel = device_param->kernel12; break;
2377 case KERN_RUN_2: kernel = device_param->kernel2; break;
2378 case KERN_RUN_23: kernel = device_param->kernel23; break;
2379 case KERN_RUN_3: kernel = device_param->kernel3; break;
2380 }
2381
2382 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2383 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2384 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2385 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2386 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2387 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2388 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2389 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2390 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2391 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2392 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2393
2394 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2395 {
2396 const size_t global_work_size[3] = { num_elements, 32, 1 };
2397 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2398
2399 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2400 }
2401 else
2402 {
2403 const size_t global_work_size[3] = { num_elements, 1, 1 };
2404 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2405
2406 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2407 }
2408
2409 hc_clFlush (device_param->command_queue);
2410
2411 hc_clFinish (device_param->command_queue);
2412 }
2413
2414 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2415 {
2416 uint num_elements = num;
2417
2418 switch (kern_run)
2419 {
2420 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2421 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2422 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2423 }
2424
2425 // causes problems with special threads like in bcrypt
2426 // const uint kernel_threads = device_param->kernel_threads;
2427
2428 const uint kernel_threads = KERNEL_THREADS;
2429
2430 while (num_elements % kernel_threads) num_elements++;
2431
2432 cl_kernel kernel = NULL;
2433
2434 switch (kern_run)
2435 {
2436 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2437 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2438 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2439 }
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2444 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2445 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2446 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2447 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2448 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2449 break;
2450 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2451 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2452 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2453 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2454 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2455 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2456 break;
2457 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2458 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2459 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2460 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2461 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2462 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2463 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2464 break;
2465 }
2466
2467 const size_t global_work_size[3] = { num_elements, 1, 1 };
2468 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2469
2470 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2471
2472 hc_clFlush (device_param->command_queue);
2473
2474 hc_clFinish (device_param->command_queue);
2475 }
2476
2477 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2478 {
2479 uint num_elements = num;
2480
2481 uint kernel_threads = device_param->kernel_threads;
2482
2483 while (num_elements % kernel_threads) num_elements++;
2484
2485 cl_kernel kernel = device_param->kernel_tb;
2486
2487 const size_t global_work_size[3] = { num_elements, 1, 1 };
2488 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2489
2490 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2491
2492 hc_clFlush (device_param->command_queue);
2493
2494 hc_clFinish (device_param->command_queue);
2495 }
2496
2497 static void run_kernel_tm (hc_device_param_t *device_param)
2498 {
2499 const uint num_elements = 1024; // fixed
2500
2501 const uint kernel_threads = 32;
2502
2503 cl_kernel kernel = device_param->kernel_tm;
2504
2505 const size_t global_work_size[3] = { num_elements, 1, 1 };
2506 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2507
2508 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2509
2510 hc_clFlush (device_param->command_queue);
2511
2512 hc_clFinish (device_param->command_queue);
2513 }
2514
2515 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2516 {
2517 uint num_elements = num;
2518
2519 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2520 device_param->kernel_params_amp_buf32[6] = num_elements;
2521
2522 // causes problems with special threads like in bcrypt
2523 // const uint kernel_threads = device_param->kernel_threads;
2524
2525 const uint kernel_threads = KERNEL_THREADS;
2526
2527 while (num_elements % kernel_threads) num_elements++;
2528
2529 cl_kernel kernel = device_param->kernel_amp;
2530
2531 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2532 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2533
2534 const size_t global_work_size[3] = { num_elements, 1, 1 };
2535 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2536
2537 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2538
2539 hc_clFlush (device_param->command_queue);
2540
2541 hc_clFinish (device_param->command_queue);
2542 }
2543
2544 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2545 {
2546 if (device_param->vendor_id == VENDOR_ID_AMD)
2547 {
2548 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2549
2550 const cl_uchar zero = 0;
2551
2552 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2553 }
2554 else
2555 {
2556 // NOTE: clEnqueueFillBuffer () always fails with -59
2557 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2558 // How's that possible, OpenCL 1.2 support is advertised??
2559 // We need to workaround...
2560
2561 #define FILLSZ 0x100000
2562
2563 char *tmp = (char *) mymalloc (FILLSZ);
2564
2565 memset (tmp, 0, FILLSZ);
2566
2567 for (uint i = 0; i < size; i += FILLSZ)
2568 {
2569 const int left = size - i;
2570
2571 const int fillsz = MIN (FILLSZ, left);
2572
2573 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2574 }
2575
2576 myfree (tmp);
2577 }
2578 }
2579
2580 static int run_rule_engine (const int rule_len, const char *rule_buf)
2581 {
2582 if (rule_len == 0)
2583 {
2584 return 0;
2585 }
2586 else if (rule_len == 1)
2587 {
2588 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2589 }
2590
2591 return 1;
2592 }
2593
2594 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2595 {
2596 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2597 {
2598 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);
2599 }
2600 else if (data.attack_kern == ATTACK_KERN_COMBI)
2601 {
2602 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);
2603 }
2604 else if (data.attack_kern == ATTACK_KERN_BF)
2605 {
2606 const u64 off = device_param->words_off;
2607
2608 device_param->kernel_params_mp_l_buf64[3] = off;
2609
2610 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2611 }
2612 }
2613
2614 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2615 {
2616 const uint kernel_loops = data.kernel_loops;
2617
2618 // init speed timer
2619
2620 uint speed_pos = device_param->speed_pos;
2621
2622 #ifdef _POSIX
2623 if (device_param->timer_speed.tv_sec == 0)
2624 {
2625 hc_timer_set (&device_param->timer_speed);
2626 }
2627 #endif
2628
2629 #ifdef _WIN
2630 if (device_param->timer_speed.QuadPart == 0)
2631 {
2632 hc_timer_set (&device_param->timer_speed);
2633 }
2634 #endif
2635
2636 // find higest password length, this is for optimization stuff
2637
2638 uint highest_pw_len = 0;
2639
2640 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2641 {
2642 }
2643 else if (data.attack_kern == ATTACK_KERN_COMBI)
2644 {
2645 }
2646 else if (data.attack_kern == ATTACK_KERN_BF)
2647 {
2648 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2649 + device_param->kernel_params_mp_l_buf32[5];
2650 }
2651
2652 // bitslice optimization stuff
2653
2654 if (data.attack_mode == ATTACK_MODE_BF)
2655 {
2656 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2657 {
2658 run_kernel_tb (device_param, pws_cnt);
2659 }
2660 }
2661
2662 // iteration type
2663
2664 uint innerloop_step = 0;
2665 uint innerloop_cnt = 0;
2666
2667 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2668 else innerloop_step = 1;
2669
2670 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2671 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2672 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2673
2674 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2675
2676 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2677 {
2678 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2679
2680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2681
2682 if (data.devices_status == STATUS_CRACKED) break;
2683 if (data.devices_status == STATUS_ABORTED) break;
2684 if (data.devices_status == STATUS_QUIT) break;
2685 if (data.devices_status == STATUS_BYPASS) break;
2686
2687 if (data.salts_shown[salt_pos] == 1) continue;
2688
2689 salt_t *salt_buf = &data.salts_buf[salt_pos];
2690
2691 device_param->kernel_params_buf32[24] = salt_pos;
2692 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2693 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2694
2695 FILE *combs_fp = device_param->combs_fp;
2696
2697 if (data.attack_mode == ATTACK_MODE_COMBI)
2698 {
2699 rewind (combs_fp);
2700 }
2701
2702 // innerloops
2703
2704 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2705 {
2706 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2707
2708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2709
2710 if (data.devices_status == STATUS_CRACKED) break;
2711 if (data.devices_status == STATUS_ABORTED) break;
2712 if (data.devices_status == STATUS_QUIT) break;
2713 if (data.devices_status == STATUS_BYPASS) break;
2714
2715 uint innerloop_left = innerloop_cnt - innerloop_pos;
2716
2717 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2718
2719 device_param->innerloop_pos = innerloop_pos;
2720 device_param->innerloop_left = innerloop_left;
2721
2722 device_param->kernel_params_buf32[27] = innerloop_left;
2723
2724 if (innerloop_left == 0) continue;
2725
2726 // initialize amplifiers
2727
2728 if (data.attack_mode == ATTACK_MODE_COMBI)
2729 {
2730 char line_buf[BUFSIZ];
2731
2732 uint i = 0;
2733
2734 while (i < innerloop_left)
2735 {
2736 if (feof (combs_fp)) break;
2737
2738 int line_len = fgetl (combs_fp, line_buf);
2739
2740 if (line_len >= PW_MAX1) continue;
2741
2742 line_len = convert_from_hex (line_buf, line_len);
2743
2744 char *line_buf_new = line_buf;
2745
2746 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2747 {
2748 char rule_buf_out[BLOCK_SIZE] = { 0 };
2749
2750 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2751
2752 if (rule_len_out < 0)
2753 {
2754 data.words_progress_rejected[salt_pos] += pw_cnt;
2755
2756 continue;
2757 }
2758
2759 line_len = rule_len_out;
2760
2761 line_buf_new = rule_buf_out;
2762 }
2763
2764 line_len = MIN (line_len, PW_DICTMAX);
2765
2766 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2767
2768 memcpy (ptr, line_buf_new, line_len);
2769
2770 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2771
2772 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2773 {
2774 uppercase (ptr, line_len);
2775 }
2776
2777 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2778 {
2779 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2780 {
2781 ptr[line_len] = 0x80;
2782 }
2783
2784 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2785 {
2786 ptr[line_len] = 0x01;
2787 }
2788 }
2789
2790 device_param->combs_buf[i].pw_len = line_len;
2791
2792 i++;
2793 }
2794
2795 for (uint j = i; j < innerloop_left; j++)
2796 {
2797 device_param->combs_buf[j].i[0] = 0;
2798 device_param->combs_buf[j].i[1] = 0;
2799 device_param->combs_buf[j].i[2] = 0;
2800 device_param->combs_buf[j].i[3] = 0;
2801 device_param->combs_buf[j].i[4] = 0;
2802 device_param->combs_buf[j].i[5] = 0;
2803 device_param->combs_buf[j].i[6] = 0;
2804 device_param->combs_buf[j].i[7] = 0;
2805
2806 device_param->combs_buf[j].pw_len = 0;
2807 }
2808
2809 innerloop_left = i;
2810 }
2811 else if (data.attack_mode == ATTACK_MODE_BF)
2812 {
2813 u64 off = innerloop_pos;
2814
2815 device_param->kernel_params_mp_r_buf64[3] = off;
2816
2817 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2818 }
2819 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2820 {
2821 u64 off = innerloop_pos;
2822
2823 device_param->kernel_params_mp_buf64[3] = off;
2824
2825 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2826 }
2827 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2828 {
2829 u64 off = innerloop_pos;
2830
2831 device_param->kernel_params_mp_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2834 }
2835
2836 // copy amplifiers
2837
2838 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2839 {
2840 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);
2841 }
2842 else if (data.attack_mode == ATTACK_MODE_COMBI)
2843 {
2844 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);
2845 }
2846 else if (data.attack_mode == ATTACK_MODE_BF)
2847 {
2848 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);
2849 }
2850 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2851 {
2852 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);
2853 }
2854 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2855 {
2856 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);
2857 }
2858
2859 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2860 {
2861 if (data.attack_mode == ATTACK_MODE_BF)
2862 {
2863 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2864 {
2865 const uint size_tm = 32 * sizeof (bs_word_t);
2866
2867 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2868
2869 run_kernel_tm (device_param);
2870
2871 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2872 }
2873 }
2874
2875 if (highest_pw_len < 16)
2876 {
2877 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2878 }
2879 else if (highest_pw_len < 32)
2880 {
2881 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2882 }
2883 else
2884 {
2885 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2886 }
2887 }
2888 else
2889 {
2890 run_kernel_amp (device_param, pws_cnt);
2891
2892 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2893
2894 if (data.opts_type & OPTS_TYPE_HOOK12)
2895 {
2896 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2897 }
2898
2899 uint iter = salt_buf->salt_iter;
2900
2901 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2902 {
2903 uint loop_left = iter - loop_pos;
2904
2905 loop_left = MIN (loop_left, kernel_loops);
2906
2907 device_param->kernel_params_buf32[25] = loop_pos;
2908 device_param->kernel_params_buf32[26] = loop_left;
2909
2910 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2911
2912 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2913
2914 if (data.devices_status == STATUS_CRACKED) break;
2915 if (data.devices_status == STATUS_ABORTED) break;
2916 if (data.devices_status == STATUS_QUIT) break;
2917 }
2918
2919 if (data.opts_type & OPTS_TYPE_HOOK23)
2920 {
2921 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2922
2923 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2924
2925 // do something with data
2926
2927 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2928 }
2929
2930 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2931 }
2932
2933 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2934
2935 if (data.devices_status == STATUS_CRACKED) break;
2936 if (data.devices_status == STATUS_ABORTED) break;
2937 if (data.devices_status == STATUS_QUIT) break;
2938
2939 /**
2940 * result
2941 */
2942
2943 hc_thread_mutex_lock (mux_display);
2944
2945 check_cracked (device_param, salt_pos);
2946
2947 hc_thread_mutex_unlock (mux_display);
2948
2949 /**
2950 * progress
2951 */
2952
2953 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2954
2955 hc_thread_mutex_lock (mux_counter);
2956
2957 data.words_progress_done[salt_pos] += perf_sum_all;
2958
2959 hc_thread_mutex_unlock (mux_counter);
2960
2961 /**
2962 * speed
2963 */
2964
2965 float speed_ms;
2966
2967 hc_timer_get (device_param->timer_speed, speed_ms);
2968
2969 hc_timer_set (&device_param->timer_speed);
2970
2971 hc_thread_mutex_lock (mux_display);
2972
2973 device_param->speed_cnt[speed_pos] = perf_sum_all;
2974
2975 device_param->speed_ms[speed_pos] = speed_ms;
2976
2977 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2978
2979 hc_thread_mutex_unlock (mux_display);
2980
2981 speed_pos++;
2982
2983 if (speed_pos == SPEED_CACHE)
2984 {
2985 speed_pos = 0;
2986 }
2987 }
2988 }
2989
2990 device_param->speed_pos = speed_pos;
2991 }
2992
2993 static void load_segment (wl_data_t *wl_data, FILE *fd)
2994 {
2995 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2996
2997 wl_data->pos = 0;
2998
2999 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3000
3001 wl_data->buf[wl_data->cnt] = 0;
3002
3003 if (wl_data->cnt == 0) return;
3004
3005 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3006
3007 while (!feof (fd))
3008 {
3009 if (wl_data->cnt == wl_data->avail)
3010 {
3011 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3012
3013 wl_data->avail += wl_data->incr;
3014 }
3015
3016 const int c = fgetc (fd);
3017
3018 if (c == EOF) break;
3019
3020 wl_data->buf[wl_data->cnt] = (char) c;
3021
3022 wl_data->cnt++;
3023
3024 if (c == '\n') break;
3025 }
3026
3027 // ensure stream ends with a newline
3028
3029 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3030 {
3031 wl_data->cnt++;
3032
3033 wl_data->buf[wl_data->cnt - 1] = '\n';
3034 }
3035
3036 return;
3037 }
3038
3039 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3040 {
3041 char *ptr = buf;
3042
3043 for (u32 i = 0; i < sz; i++, ptr++)
3044 {
3045 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3046
3047 if (i == 7)
3048 {
3049 *off = i;
3050 *len = i;
3051
3052 return;
3053 }
3054
3055 if (*ptr != '\n') continue;
3056
3057 *off = i + 1;
3058
3059 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3060
3061 *len = i;
3062
3063 return;
3064 }
3065
3066 *off = sz;
3067 *len = sz;
3068 }
3069
3070 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3071 {
3072 char *ptr = buf;
3073
3074 for (u32 i = 0; i < sz; i++, ptr++)
3075 {
3076 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3077
3078 if (*ptr != '\n') continue;
3079
3080 *off = i + 1;
3081
3082 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3083
3084 *len = i;
3085
3086 return;
3087 }
3088
3089 *off = sz;
3090 *len = sz;
3091 }
3092
3093 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3094 {
3095 char *ptr = buf;
3096
3097 for (u32 i = 0; i < sz; i++, ptr++)
3098 {
3099 if (*ptr != '\n') continue;
3100
3101 *off = i + 1;
3102
3103 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3104
3105 *len = i;
3106
3107 return;
3108 }
3109
3110 *off = sz;
3111 *len = sz;
3112 }
3113
3114 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3115 {
3116 while (wl_data->pos < wl_data->cnt)
3117 {
3118 uint off;
3119 uint len;
3120
3121 char *ptr = wl_data->buf + wl_data->pos;
3122
3123 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3124
3125 wl_data->pos += off;
3126
3127 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3128 {
3129 char rule_buf_out[BLOCK_SIZE] = { 0 };
3130
3131 int rule_len_out = -1;
3132
3133 if (len < BLOCK_SIZE)
3134 {
3135 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3136 }
3137
3138 if (rule_len_out < 0)
3139 {
3140 continue;
3141 }
3142
3143 if (rule_len_out > PW_MAX)
3144 {
3145 continue;
3146 }
3147 }
3148 else
3149 {
3150 if (len > PW_MAX)
3151 {
3152 continue;
3153 }
3154 }
3155
3156 *out_buf = ptr;
3157 *out_len = len;
3158
3159 return;
3160 }
3161
3162 if (feof (fd))
3163 {
3164 fprintf (stderr, "bug!!\n");
3165
3166 return;
3167 }
3168
3169 load_segment (wl_data, fd);
3170
3171 get_next_word (wl_data, fd, out_buf, out_len);
3172 }
3173
3174 #ifdef _POSIX
3175 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3176 #endif
3177
3178 #ifdef _WIN
3179 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3180 #endif
3181 {
3182 hc_signal (NULL);
3183
3184 dictstat_t d;
3185
3186 d.cnt = 0;
3187
3188 #ifdef _POSIX
3189 fstat (fileno (fd), &d.stat);
3190 #endif
3191
3192 #ifdef _WIN
3193 _fstat64 (fileno (fd), &d.stat);
3194 #endif
3195
3196 d.stat.st_mode = 0;
3197 d.stat.st_nlink = 0;
3198 d.stat.st_uid = 0;
3199 d.stat.st_gid = 0;
3200 d.stat.st_rdev = 0;
3201 d.stat.st_atime = 0;
3202
3203 #ifdef _POSIX
3204 d.stat.st_blksize = 0;
3205 d.stat.st_blocks = 0;
3206 #endif
3207
3208 if (d.stat.st_size == 0) return 0;
3209
3210 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3211
3212 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3213 {
3214 if (d_cache)
3215 {
3216 u64 cnt = d_cache->cnt;
3217
3218 u64 keyspace = cnt;
3219
3220 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3221 {
3222 keyspace *= data.kernel_rules_cnt;
3223 }
3224 else if (data.attack_kern == ATTACK_KERN_COMBI)
3225 {
3226 keyspace *= data.combs_cnt;
3227 }
3228
3229 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);
3230 if (data.quiet == 0) log_info ("");
3231
3232 hc_signal (sigHandler_default);
3233
3234 return (keyspace);
3235 }
3236 }
3237
3238 time_t now = 0;
3239 time_t prev = 0;
3240
3241 u64 comp = 0;
3242 u64 cnt = 0;
3243 u64 cnt2 = 0;
3244
3245 while (!feof (fd))
3246 {
3247 load_segment (wl_data, fd);
3248
3249 comp += wl_data->cnt;
3250
3251 u32 i = 0;
3252
3253 while (i < wl_data->cnt)
3254 {
3255 u32 len;
3256 u32 off;
3257
3258 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3259
3260 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3261 {
3262 char rule_buf_out[BLOCK_SIZE] = { 0 };
3263
3264 int rule_len_out = -1;
3265
3266 if (len < BLOCK_SIZE)
3267 {
3268 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3269 }
3270
3271 if (rule_len_out < 0)
3272 {
3273 len = PW_MAX1;
3274 }
3275 else
3276 {
3277 len = rule_len_out;
3278 }
3279 }
3280
3281 if (len < PW_MAX1)
3282 {
3283 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3284 {
3285 cnt += data.kernel_rules_cnt;
3286 }
3287 else if (data.attack_kern == ATTACK_KERN_COMBI)
3288 {
3289 cnt += data.combs_cnt;
3290 }
3291
3292 d.cnt++;
3293 }
3294
3295 i += off;
3296
3297 cnt2++;
3298 }
3299
3300 time (&now);
3301
3302 if ((now - prev) == 0) continue;
3303
3304 float percent = (float) comp / (float) d.stat.st_size;
3305
3306 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);
3307
3308 time (&prev);
3309 }
3310
3311 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);
3312 if (data.quiet == 0) log_info ("");
3313
3314 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3315
3316 hc_signal (sigHandler_default);
3317
3318 return (cnt);
3319 }
3320
3321 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3322 {
3323 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3324 }
3325
3326 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3327 {
3328 if (data.devices_status == STATUS_BYPASS) return 0;
3329
3330 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3331
3332 uint cache_cnt = pw_cache->cnt;
3333
3334 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3335
3336 memcpy (pw_hc1, pw_buf, pw_len);
3337
3338 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3339
3340 uint pws_cnt = device_param->pws_cnt;
3341
3342 cache_cnt++;
3343
3344 pw_t *pw = device_param->pws_buf + pws_cnt;
3345
3346 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3347
3348 pw->pw_len = pw_len;
3349
3350 pws_cnt++;
3351
3352 device_param->pws_cnt = pws_cnt;
3353 device_param->pw_cnt = pws_cnt * 1;
3354
3355 cache_cnt = 0;
3356
3357 pw_cache->cnt = cache_cnt;
3358
3359 return pws_cnt;
3360 }
3361
3362 static void *thread_monitor (void *p)
3363 {
3364 uint runtime_check = 0;
3365 uint remove_check = 0;
3366 uint status_check = 0;
3367 uint hwmon_check = 0;
3368 uint restore_check = 0;
3369
3370 uint restore_left = data.restore_timer;
3371 uint remove_left = data.remove_timer;
3372 uint status_left = data.status_timer;
3373
3374 // these variables are mainly used for fan control (AMD only)
3375
3376 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3377
3378 // temperature controller "loopback" values
3379
3380 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3381 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3382
3383 int temp_threshold = 1; // degrees celcius
3384
3385 int fan_speed_min = 15; // in percentage
3386 int fan_speed_max = 100;
3387
3388 time_t last_temp_check_time;
3389
3390 uint sleep_time = 1;
3391
3392 if (data.runtime)
3393 {
3394 runtime_check = 1;
3395 }
3396
3397 if (data.restore_timer)
3398 {
3399 restore_check = 1;
3400 }
3401
3402 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3403 {
3404 remove_check = 1;
3405 }
3406
3407 if (data.status == 1)
3408 {
3409 status_check = 1;
3410 }
3411
3412 if (data.gpu_temp_disable == 0)
3413 {
3414 time (&last_temp_check_time);
3415
3416 hwmon_check = 1;
3417 }
3418
3419 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3420 {
3421 return (p);
3422 }
3423
3424 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3425 {
3426 hc_sleep (sleep_time);
3427
3428 if (data.devices_status != STATUS_RUNNING) continue;
3429
3430 if (hwmon_check == 1)
3431 {
3432 hc_thread_mutex_lock (mux_adl);
3433
3434 time_t temp_check_time;
3435
3436 time (&temp_check_time);
3437
3438 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3439
3440 if (Ta == 0) Ta = 1;
3441
3442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3443 {
3444 hc_device_param_t *device_param = &data.devices_param[device_id];
3445
3446 if (device_param->skipped) continue;
3447
3448 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3449
3450 const int temperature = hm_get_temperature_with_device_id (device_id);
3451
3452 if (temperature > (int) data.gpu_temp_abort)
3453 {
3454 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3455
3456 if (data.devices_status != STATUS_QUIT) myabort ();
3457
3458 break;
3459 }
3460
3461 const int gpu_temp_retain = data.gpu_temp_retain;
3462
3463 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3464 {
3465 if (data.hm_device[device_id].fan_supported == 1)
3466 {
3467 int temp_cur = temperature;
3468
3469 int temp_diff_new = gpu_temp_retain - temp_cur;
3470
3471 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3472
3473 // calculate Ta value (time difference in seconds between the last check and this check)
3474
3475 last_temp_check_time = temp_check_time;
3476
3477 float Kp = 1.8;
3478 float Ki = 0.005;
3479 float Kd = 6;
3480
3481 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3482
3483 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);
3484
3485 if (abs (fan_diff_required) >= temp_threshold)
3486 {
3487 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3488
3489 int fan_speed_level = fan_speed_cur;
3490
3491 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3492
3493 int fan_speed_new = fan_speed_level - fan_diff_required;
3494
3495 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3496 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3497
3498 if (fan_speed_new != fan_speed_cur)
3499 {
3500 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3501 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3502
3503 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3504 {
3505 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3506
3507 fan_speed_chgd[device_id] = 1;
3508 }
3509
3510 temp_diff_old[device_id] = temp_diff_new;
3511 }
3512 }
3513 }
3514 }
3515 }
3516
3517 hc_thread_mutex_unlock (mux_adl);
3518 }
3519
3520 if (restore_check == 1)
3521 {
3522 restore_left--;
3523
3524 if (restore_left == 0)
3525 {
3526 if (data.restore_disable == 0) cycle_restore ();
3527
3528 restore_left = data.restore_timer;
3529 }
3530 }
3531
3532 if ((runtime_check == 1) && (data.runtime_start > 0))
3533 {
3534 time_t runtime_cur;
3535
3536 time (&runtime_cur);
3537
3538 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3539
3540 if (runtime_left <= 0)
3541 {
3542 if (data.benchmark == 0)
3543 {
3544 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3545 }
3546
3547 if (data.devices_status != STATUS_QUIT) myabort ();
3548 }
3549 }
3550
3551 if (remove_check == 1)
3552 {
3553 remove_left--;
3554
3555 if (remove_left == 0)
3556 {
3557 if (data.digests_saved != data.digests_done)
3558 {
3559 data.digests_saved = data.digests_done;
3560
3561 save_hash ();
3562 }
3563
3564 remove_left = data.remove_timer;
3565 }
3566 }
3567
3568 if (status_check == 1)
3569 {
3570 status_left--;
3571
3572 if (status_left == 0)
3573 {
3574 hc_thread_mutex_lock (mux_display);
3575
3576 if (data.quiet == 0) clear_prompt ();
3577
3578 if (data.quiet == 0) log_info ("");
3579
3580 status_display ();
3581
3582 if (data.quiet == 0) log_info ("");
3583
3584 hc_thread_mutex_unlock (mux_display);
3585
3586 status_left = data.status_timer;
3587 }
3588 }
3589 }
3590
3591 myfree (fan_speed_chgd);
3592
3593 myfree (temp_diff_old);
3594 myfree (temp_diff_sum);
3595
3596 p = NULL;
3597
3598 return (p);
3599 }
3600
3601 static void *thread_outfile_remove (void *p)
3602 {
3603 // some hash-dependent constants
3604 char *outfile_dir = data.outfile_check_directory;
3605 uint dgst_size = data.dgst_size;
3606 uint isSalted = data.isSalted;
3607 uint esalt_size = data.esalt_size;
3608 uint hash_mode = data.hash_mode;
3609
3610 uint outfile_check_timer = data.outfile_check_timer;
3611
3612 char separator = data.separator;
3613
3614 // some hash-dependent functions
3615 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3616 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3617
3618 // buffers
3619 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3620
3621 hash_buf.digest = mymalloc (dgst_size);
3622
3623 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3624
3625 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3626
3627 uint digest_buf[64];
3628
3629 outfile_data_t *out_info = NULL;
3630
3631 char **out_files = NULL;
3632
3633 time_t folder_mtime = 0;
3634
3635 int out_cnt = 0;
3636
3637 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3638
3639 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3640 {
3641 hc_sleep (1);
3642
3643 if (data.devices_status != STATUS_RUNNING) continue;
3644
3645 check_left--;
3646
3647 if (check_left == 0)
3648 {
3649 struct stat outfile_check_stat;
3650
3651 if (stat (outfile_dir, &outfile_check_stat) == 0)
3652 {
3653 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3654
3655 if (is_dir == 1)
3656 {
3657 if (outfile_check_stat.st_mtime > folder_mtime)
3658 {
3659 char **out_files_new = scan_directory (outfile_dir);
3660
3661 int out_cnt_new = count_dictionaries (out_files_new);
3662
3663 outfile_data_t *out_info_new = NULL;
3664
3665 if (out_cnt_new > 0)
3666 {
3667 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3668
3669 for (int i = 0; i < out_cnt_new; i++)
3670 {
3671 out_info_new[i].file_name = out_files_new[i];
3672
3673 // check if there are files that we have seen/checked before (and not changed)
3674
3675 for (int j = 0; j < out_cnt; j++)
3676 {
3677 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3678 {
3679 struct stat outfile_stat;
3680
3681 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3682 {
3683 if (outfile_stat.st_ctime == out_info[j].ctime)
3684 {
3685 out_info_new[i].ctime = out_info[j].ctime;
3686 out_info_new[i].seek = out_info[j].seek;
3687 }
3688 }
3689 }
3690 }
3691 }
3692 }
3693
3694 local_free (out_info);
3695 local_free (out_files);
3696
3697 out_files = out_files_new;
3698 out_cnt = out_cnt_new;
3699 out_info = out_info_new;
3700
3701 folder_mtime = outfile_check_stat.st_mtime;
3702 }
3703
3704 for (int j = 0; j < out_cnt; j++)
3705 {
3706 FILE *fp = fopen (out_info[j].file_name, "rb");
3707
3708 if (fp != NULL)
3709 {
3710 //hc_thread_mutex_lock (mux_display);
3711
3712 #ifdef _POSIX
3713 struct stat outfile_stat;
3714
3715 fstat (fileno (fp), &outfile_stat);
3716 #endif
3717
3718 #ifdef _WIN
3719 struct stat64 outfile_stat;
3720
3721 _fstat64 (fileno (fp), &outfile_stat);
3722 #endif
3723
3724 if (outfile_stat.st_ctime > out_info[j].ctime)
3725 {
3726 out_info[j].ctime = outfile_stat.st_ctime;
3727 out_info[j].seek = 0;
3728 }
3729
3730 fseek (fp, out_info[j].seek, SEEK_SET);
3731
3732 while (!feof (fp))
3733 {
3734 char line_buf[BUFSIZ];
3735
3736 memset (line_buf, 0, BUFSIZ);
3737
3738 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3739
3740 if (ptr == NULL) break;
3741
3742 int line_len = strlen (line_buf);
3743
3744 if (line_len <= 0) continue;
3745
3746 int iter = MAX_CUT_TRIES;
3747
3748 for (uint i = line_len - 1; i && iter; i--, line_len--)
3749 {
3750 if (line_buf[i] != separator) continue;
3751
3752 int parser_status = PARSER_OK;
3753
3754 if ((hash_mode != 2500) && (hash_mode != 6800))
3755 {
3756 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3757 }
3758
3759 uint found = 0;
3760
3761 if (parser_status == PARSER_OK)
3762 {
3763 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3764 {
3765 if (data.salts_shown[salt_pos] == 1) continue;
3766
3767 salt_t *salt_buf = &data.salts_buf[salt_pos];
3768
3769 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3770 {
3771 uint idx = salt_buf->digests_offset + digest_pos;
3772
3773 if (data.digests_shown[idx] == 1) continue;
3774
3775 uint cracked = 0;
3776
3777 if (hash_mode == 6800)
3778 {
3779 if (i == salt_buf->salt_len)
3780 {
3781 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3782 }
3783 }
3784 else if (hash_mode == 2500)
3785 {
3786 // BSSID : MAC1 : MAC2 (:plain)
3787 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3788 {
3789 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3790
3791 if (!cracked) continue;
3792
3793 // now compare MAC1 and MAC2 too, since we have this additional info
3794 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3795 char *mac2_pos = mac1_pos + 12 + 1;
3796
3797 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3798 wpa_t *wpa = &wpas[salt_pos];
3799
3800 uint pke[25];
3801
3802 char *pke_ptr = (char *) pke;
3803
3804 for (uint i = 0; i < 25; i++)
3805 {
3806 pke[i] = byte_swap_32 (wpa->pke[i]);
3807 }
3808
3809 u8 mac1[6];
3810 u8 mac2[6];
3811
3812 memcpy (mac1, pke_ptr + 23, 6);
3813 memcpy (mac2, pke_ptr + 29, 6);
3814
3815 // compare hex string(s) vs binary MAC address(es)
3816
3817 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3818 {
3819 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3820 {
3821 cracked = 0;
3822 break;
3823 }
3824 }
3825
3826 // early skip ;)
3827 if (!cracked) continue;
3828
3829 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3830 {
3831 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3832 {
3833 cracked = 0;
3834 break;
3835 }
3836 }
3837 }
3838 }
3839 else
3840 {
3841 char *digests_buf_ptr = (char *) data.digests_buf;
3842
3843 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3844
3845 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3846 }
3847
3848 if (cracked == 1)
3849 {
3850 found = 1;
3851
3852 data.digests_shown[idx] = 1;
3853
3854 data.digests_done++;
3855
3856 salt_buf->digests_done++;
3857
3858 if (salt_buf->digests_done == salt_buf->digests_cnt)
3859 {
3860 data.salts_shown[salt_pos] = 1;
3861
3862 data.salts_done++;
3863
3864 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3865 }
3866 }
3867 }
3868
3869 if (data.devices_status == STATUS_CRACKED) break;
3870 }
3871 }
3872
3873 if (found) break;
3874
3875 if (data.devices_status == STATUS_CRACKED) break;
3876
3877 iter--;
3878 }
3879
3880 if (data.devices_status == STATUS_CRACKED) break;
3881 }
3882
3883 out_info[j].seek = ftell (fp);
3884
3885 //hc_thread_mutex_unlock (mux_display);
3886
3887 fclose (fp);
3888 }
3889 }
3890 }
3891 }
3892
3893 check_left = outfile_check_timer;
3894 }
3895 }
3896
3897 if (esalt_size) local_free (hash_buf.esalt);
3898
3899 if (isSalted) local_free (hash_buf.salt);
3900
3901 local_free (hash_buf.digest);
3902
3903 local_free (out_info);
3904
3905 local_free (out_files);
3906
3907 p = NULL;
3908
3909 return (p);
3910 }
3911
3912 static uint get_work (hc_device_param_t *device_param, const u64 max)
3913 {
3914 hc_thread_mutex_lock (mux_dispatcher);
3915
3916 const u64 words_cur = data.words_cur;
3917 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3918
3919 device_param->words_off = words_cur;
3920
3921 const u64 words_left = words_base - words_cur;
3922
3923 if (data.kernel_blocks_all > words_left)
3924 {
3925 if (data.kernel_blocks_div == 0)
3926 {
3927 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3928 }
3929 }
3930
3931 if (data.kernel_blocks_div)
3932 {
3933 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3934 {
3935 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3936 const u32 kernel_power_new = kernel_blocks_new;
3937
3938 if (kernel_blocks_new < device_param->kernel_blocks)
3939 {
3940 device_param->kernel_blocks = kernel_blocks_new;
3941 device_param->kernel_power = kernel_power_new;
3942 }
3943 }
3944 }
3945
3946 const uint kernel_blocks = device_param->kernel_blocks;
3947
3948 uint work = MIN (words_left, kernel_blocks);
3949
3950 work = MIN (work, max);
3951
3952 data.words_cur += work;
3953
3954 hc_thread_mutex_unlock (mux_dispatcher);
3955
3956 return work;
3957 }
3958
3959 static void *thread_calc_stdin (void *p)
3960 {
3961 hc_device_param_t *device_param = (hc_device_param_t *) p;
3962
3963 if (device_param->skipped) return NULL;
3964
3965 const uint attack_kern = data.attack_kern;
3966
3967 const uint kernel_blocks = device_param->kernel_blocks;
3968
3969 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3970 {
3971 hc_thread_mutex_lock (mux_dispatcher);
3972
3973 if (feof (stdin) != 0)
3974 {
3975 hc_thread_mutex_unlock (mux_dispatcher);
3976
3977 break;
3978 }
3979
3980 uint words_cur = 0;
3981
3982 while (words_cur < kernel_blocks)
3983 {
3984 char buf[BUFSIZ];
3985
3986 char *line_buf = fgets (buf, sizeof (buf), stdin);
3987
3988 if (line_buf == NULL) break;
3989
3990 uint line_len = in_superchop (line_buf);
3991
3992 line_len = convert_from_hex (line_buf, line_len);
3993
3994 // post-process rule engine
3995
3996 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3997 {
3998 char rule_buf_out[BLOCK_SIZE] = { 0 };
3999
4000 int rule_len_out = -1;
4001
4002 if (line_len < BLOCK_SIZE)
4003 {
4004 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4005 }
4006
4007 if (rule_len_out < 0) continue;
4008
4009 line_buf = rule_buf_out;
4010 line_len = rule_len_out;
4011 }
4012
4013 if (line_len > PW_MAX)
4014 {
4015 continue;
4016 }
4017
4018 if (attack_kern == ATTACK_KERN_STRAIGHT)
4019 {
4020 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4021 {
4022 hc_thread_mutex_lock (mux_counter);
4023
4024 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4025 {
4026 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4027 }
4028
4029 hc_thread_mutex_unlock (mux_counter);
4030
4031 continue;
4032 }
4033 }
4034 else if (attack_kern == ATTACK_KERN_COMBI)
4035 {
4036 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4037 // since we still need to combine the plains
4038
4039 if (line_len > data.pw_max)
4040 {
4041 hc_thread_mutex_lock (mux_counter);
4042
4043 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4044 {
4045 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4046 }
4047
4048 hc_thread_mutex_unlock (mux_counter);
4049
4050 continue;
4051 }
4052 }
4053
4054 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4055
4056 words_cur++;
4057
4058 if (data.devices_status == STATUS_CRACKED) break;
4059 if (data.devices_status == STATUS_ABORTED) break;
4060 if (data.devices_status == STATUS_QUIT) break;
4061 if (data.devices_status == STATUS_BYPASS) break;
4062 }
4063
4064 hc_thread_mutex_unlock (mux_dispatcher);
4065
4066 if (data.devices_status == STATUS_CRACKED) break;
4067 if (data.devices_status == STATUS_ABORTED) break;
4068 if (data.devices_status == STATUS_QUIT) break;
4069 if (data.devices_status == STATUS_BYPASS) break;
4070
4071 // we need 2 flushing because we have two independant caches and it can occur
4072 // that one buffer is already at threshold plus for that length also exists
4073 // more data in the 2nd buffer so it would overflow
4074
4075 // flush session 1
4076
4077 {
4078 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4079 {
4080 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4081
4082 const uint pw_cache_cnt = pw_cache->cnt;
4083
4084 if (pw_cache_cnt == 0) continue;
4085
4086 pw_cache->cnt = 0;
4087
4088 uint pws_cnt = device_param->pws_cnt;
4089
4090 pw_t *pw = device_param->pws_buf + pws_cnt;
4091
4092 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4093
4094 pw->pw_len = pw_len;
4095
4096 uint pw_cnt = device_param->pw_cnt;
4097
4098 pw_cnt += pw_cache_cnt;
4099
4100 device_param->pw_cnt = pw_cnt;
4101
4102 pws_cnt++;
4103
4104 device_param->pws_cnt = pws_cnt;
4105
4106 if (pws_cnt == device_param->kernel_power_user) break;
4107 }
4108
4109 const uint pw_cnt = device_param->pw_cnt;
4110 const uint pws_cnt = device_param->pws_cnt;
4111
4112 if (pws_cnt)
4113 {
4114 run_copy (device_param, pws_cnt);
4115
4116 run_cracker (device_param, pw_cnt, pws_cnt);
4117
4118 device_param->pw_cnt = 0;
4119 device_param->pws_cnt = 0;
4120 }
4121 }
4122
4123 // flush session 2
4124
4125 {
4126 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4127 {
4128 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4129
4130 const uint pw_cache_cnt = pw_cache->cnt;
4131
4132 if (pw_cache_cnt == 0) continue;
4133
4134 pw_cache->cnt = 0;
4135
4136 uint pws_cnt = device_param->pws_cnt;
4137
4138 pw_t *pw = device_param->pws_buf + pws_cnt;
4139
4140 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4141
4142 pw->pw_len = pw_len;
4143
4144 uint pw_cnt = device_param->pw_cnt;
4145
4146 pw_cnt += pw_cache_cnt;
4147
4148 device_param->pw_cnt = pw_cnt;
4149
4150 pws_cnt++;
4151
4152 device_param->pws_cnt = pws_cnt;
4153 }
4154
4155 const uint pw_cnt = device_param->pw_cnt;
4156 const uint pws_cnt = device_param->pws_cnt;
4157
4158 if (pws_cnt)
4159 {
4160 run_copy (device_param, pws_cnt);
4161
4162 run_cracker (device_param, pw_cnt, pws_cnt);
4163
4164 device_param->pw_cnt = 0;
4165 device_param->pws_cnt = 0;
4166 }
4167 }
4168 }
4169
4170 return NULL;
4171 }
4172
4173 static void *thread_calc (void *p)
4174 {
4175 hc_device_param_t *device_param = (hc_device_param_t *) p;
4176
4177 if (device_param->skipped) return NULL;
4178
4179 const uint attack_mode = data.attack_mode;
4180 const uint attack_kern = data.attack_kern;
4181
4182 if (attack_mode == ATTACK_MODE_BF)
4183 {
4184 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4185 {
4186 const uint work = get_work (device_param, -1);
4187
4188 if (work == 0) break;
4189
4190 const u64 words_off = device_param->words_off;
4191 const u64 words_fin = words_off + work;
4192
4193 const uint pw_cnt = work;
4194 const uint pws_cnt = work;
4195
4196 device_param->pw_cnt = pw_cnt;
4197 device_param->pws_cnt = pws_cnt;
4198
4199 if (pws_cnt)
4200 {
4201 run_copy (device_param, pws_cnt);
4202
4203 run_cracker (device_param, pw_cnt, pws_cnt);
4204
4205 device_param->pw_cnt = 0;
4206 device_param->pws_cnt = 0;
4207 }
4208
4209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4210
4211 if (data.devices_status == STATUS_CRACKED) break;
4212 if (data.devices_status == STATUS_ABORTED) break;
4213 if (data.devices_status == STATUS_QUIT) break;
4214 if (data.devices_status == STATUS_BYPASS) break;
4215
4216 device_param->words_done = words_fin;
4217 }
4218 }
4219 else
4220 {
4221 const uint segment_size = data.segment_size;
4222
4223 char *dictfile = data.dictfile;
4224
4225 if (attack_mode == ATTACK_MODE_COMBI)
4226 {
4227 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4228 {
4229 dictfile = data.dictfile2;
4230 }
4231 }
4232
4233 FILE *fd = fopen (dictfile, "rb");
4234
4235 if (fd == NULL)
4236 {
4237 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4238
4239 return NULL;
4240 }
4241
4242 if (attack_mode == ATTACK_MODE_COMBI)
4243 {
4244 const uint combs_mode = data.combs_mode;
4245
4246 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4247 {
4248 const char *dictfilec = data.dictfile2;
4249
4250 FILE *combs_fp = fopen (dictfilec, "rb");
4251
4252 if (combs_fp == NULL)
4253 {
4254 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4255
4256 fclose (fd);
4257
4258 return NULL;
4259 }
4260
4261 device_param->combs_fp = combs_fp;
4262 }
4263 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4264 {
4265 const char *dictfilec = data.dictfile;
4266
4267 FILE *combs_fp = fopen (dictfilec, "rb");
4268
4269 if (combs_fp == NULL)
4270 {
4271 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4272
4273 fclose (fd);
4274
4275 return NULL;
4276 }
4277
4278 device_param->combs_fp = combs_fp;
4279 }
4280 }
4281
4282 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4283
4284 wl_data->buf = (char *) mymalloc (segment_size);
4285 wl_data->avail = segment_size;
4286 wl_data->incr = segment_size;
4287 wl_data->cnt = 0;
4288 wl_data->pos = 0;
4289
4290 u64 words_cur = 0;
4291
4292 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4293 {
4294 u64 words_off = 0;
4295 u64 words_fin = 0;
4296
4297 u64 max = -1;
4298
4299 while (max)
4300 {
4301 const uint work = get_work (device_param, max);
4302
4303 if (work == 0) break;
4304
4305 words_off = device_param->words_off;
4306 words_fin = words_off + work;
4307
4308 char *line_buf;
4309 uint line_len;
4310
4311 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4312
4313 max = 0;
4314
4315 for ( ; words_cur < words_fin; words_cur++)
4316 {
4317 get_next_word (wl_data, fd, &line_buf, &line_len);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (attack_kern == ATTACK_KERN_STRAIGHT)
4341 {
4342 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4343 {
4344 max++;
4345
4346 hc_thread_mutex_lock (mux_counter);
4347
4348 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4349 {
4350 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4351 }
4352
4353 hc_thread_mutex_unlock (mux_counter);
4354
4355 continue;
4356 }
4357 }
4358 else if (attack_kern == ATTACK_KERN_COMBI)
4359 {
4360 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4361 // since we still need to combine the plains
4362
4363 if (line_len > data.pw_max)
4364 {
4365 max++;
4366
4367 hc_thread_mutex_lock (mux_counter);
4368
4369 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4370 {
4371 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4372 }
4373
4374 hc_thread_mutex_unlock (mux_counter);
4375
4376 continue;
4377 }
4378 }
4379
4380 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4381
4382 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4383
4384 if (data.devices_status == STATUS_CRACKED) break;
4385 if (data.devices_status == STATUS_ABORTED) break;
4386 if (data.devices_status == STATUS_QUIT) break;
4387 if (data.devices_status == STATUS_BYPASS) break;
4388 }
4389
4390 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396 }
4397
4398 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4399
4400 if (data.devices_status == STATUS_CRACKED) break;
4401 if (data.devices_status == STATUS_ABORTED) break;
4402 if (data.devices_status == STATUS_QUIT) break;
4403 if (data.devices_status == STATUS_BYPASS) break;
4404
4405 // we need 2 flushing because we have two independant caches and it can occur
4406 // that one buffer is already at threshold plus for that length also exists
4407 // more data in the 2nd buffer so it would overflow
4408
4409 //
4410 // flush session 1
4411 //
4412
4413 {
4414 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4415 {
4416 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4417
4418 const uint pw_cache_cnt = pw_cache->cnt;
4419
4420 if (pw_cache_cnt == 0) continue;
4421
4422 pw_cache->cnt = 0;
4423
4424 uint pws_cnt = device_param->pws_cnt;
4425
4426 pw_t *pw = device_param->pws_buf + pws_cnt;
4427
4428 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4429
4430 pw->pw_len = pw_len;
4431
4432 uint pw_cnt = device_param->pw_cnt;
4433
4434 pw_cnt += pw_cache_cnt;
4435
4436 device_param->pw_cnt = pw_cnt;
4437
4438 pws_cnt++;
4439
4440 device_param->pws_cnt = pws_cnt;
4441
4442 if (pws_cnt == device_param->kernel_power_user) break;
4443 }
4444
4445 const uint pw_cnt = device_param->pw_cnt;
4446 const uint pws_cnt = device_param->pws_cnt;
4447
4448 if (pws_cnt)
4449 {
4450 run_copy (device_param, pws_cnt);
4451
4452 run_cracker (device_param, pw_cnt, pws_cnt);
4453
4454 device_param->pw_cnt = 0;
4455 device_param->pws_cnt = 0;
4456 }
4457
4458 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4459
4460 if (data.devices_status == STATUS_CRACKED) break;
4461 if (data.devices_status == STATUS_ABORTED) break;
4462 if (data.devices_status == STATUS_QUIT) break;
4463 if (data.devices_status == STATUS_BYPASS) break;
4464 }
4465
4466 //
4467 // flush session 2
4468 //
4469
4470 {
4471 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4472 {
4473 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4474
4475 const uint pw_cache_cnt = pw_cache->cnt;
4476
4477 if (pw_cache_cnt == 0) continue;
4478
4479 pw_cache->cnt = 0;
4480
4481 uint pws_cnt = device_param->pws_cnt;
4482
4483 pw_t *pw = device_param->pws_buf + pws_cnt;
4484
4485 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4486
4487 pw->pw_len = pw_len;
4488
4489 uint pw_cnt = device_param->pw_cnt;
4490
4491 pw_cnt += pw_cache_cnt;
4492
4493 device_param->pw_cnt = pw_cnt;
4494
4495 pws_cnt++;
4496
4497 device_param->pws_cnt = pws_cnt;
4498 }
4499
4500 const uint pw_cnt = device_param->pw_cnt;
4501 const uint pws_cnt = device_param->pws_cnt;
4502
4503 if (pws_cnt)
4504 {
4505 run_copy (device_param, pws_cnt);
4506
4507 run_cracker (device_param, pw_cnt, pws_cnt);
4508
4509 device_param->pw_cnt = 0;
4510 device_param->pws_cnt = 0;
4511 }
4512
4513 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4514
4515 if (data.devices_status == STATUS_CRACKED) break;
4516 if (data.devices_status == STATUS_ABORTED) break;
4517 if (data.devices_status == STATUS_QUIT) break;
4518 if (data.devices_status == STATUS_BYPASS) break;
4519 }
4520
4521 if (words_fin == 0) break;
4522
4523 device_param->words_done = words_fin;
4524 }
4525
4526 if (attack_mode == ATTACK_MODE_COMBI)
4527 {
4528 fclose (device_param->combs_fp);
4529 }
4530
4531 free (wl_data->buf);
4532 free (wl_data);
4533
4534 fclose (fd);
4535 }
4536
4537 return NULL;
4538 }
4539
4540 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4541 {
4542 salt_t *salt_buf = &data.salts_buf[salt_pos];
4543
4544 device_param->kernel_params_buf32[24] = salt_pos;
4545 device_param->kernel_params_buf32[27] = 1;
4546 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4547 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4548 device_param->kernel_params_buf32[30] = 0;
4549 device_param->kernel_params_buf32[31] = 1;
4550
4551 char *dictfile_old = data.dictfile;
4552
4553 const char *weak_hash_check = "weak-hash-check";
4554
4555 data.dictfile = (char *) weak_hash_check;
4556
4557 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4558
4559 data.kernel_rules_buf[0].cmds[0] = 0;
4560
4561 /**
4562 * run the kernel
4563 */
4564
4565 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4566 {
4567 run_kernel (KERN_RUN_1, device_param, 1);
4568 }
4569 else
4570 {
4571 run_kernel (KERN_RUN_1, device_param, 1);
4572
4573 const uint iter = salt_buf->salt_iter;
4574
4575 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4576 {
4577 uint loop_left = iter - loop_pos;
4578
4579 loop_left = MIN (loop_left, kernel_loops);
4580
4581 device_param->kernel_params_buf32[25] = loop_pos;
4582 device_param->kernel_params_buf32[26] = loop_left;
4583
4584 run_kernel (KERN_RUN_2, device_param, 1);
4585 }
4586
4587 run_kernel (KERN_RUN_3, device_param, 1);
4588 }
4589
4590 /**
4591 * result
4592 */
4593
4594 check_cracked (device_param, salt_pos);
4595
4596 /**
4597 * cleanup
4598 */
4599
4600 device_param->kernel_params_buf32[24] = 0;
4601 device_param->kernel_params_buf32[25] = 0;
4602 device_param->kernel_params_buf32[26] = 0;
4603 device_param->kernel_params_buf32[27] = 0;
4604 device_param->kernel_params_buf32[28] = 0;
4605 device_param->kernel_params_buf32[29] = 0;
4606 device_param->kernel_params_buf32[30] = 0;
4607 device_param->kernel_params_buf32[31] = 0;
4608
4609 data.dictfile = dictfile_old;
4610
4611 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4612 }
4613
4614 // hlfmt hashcat
4615
4616 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4617 {
4618 if (data.username == 0)
4619 {
4620 *hashbuf_pos = line_buf;
4621 *hashbuf_len = line_len;
4622 }
4623 else
4624 {
4625 char *pos = line_buf;
4626 int len = line_len;
4627
4628 for (int i = 0; i < line_len; i++, pos++, len--)
4629 {
4630 if (line_buf[i] == data.separator)
4631 {
4632 pos++;
4633
4634 len--;
4635
4636 break;
4637 }
4638 }
4639
4640 *hashbuf_pos = pos;
4641 *hashbuf_len = len;
4642 }
4643 }
4644
4645 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4646 {
4647 char *pos = NULL;
4648 int len = 0;
4649
4650 int sep_cnt = 0;
4651
4652 for (int i = 0; i < line_len; i++)
4653 {
4654 if (line_buf[i] == data.separator)
4655 {
4656 sep_cnt++;
4657
4658 continue;
4659 }
4660
4661 if (sep_cnt == 0)
4662 {
4663 if (pos == NULL) pos = line_buf + i;
4664
4665 len++;
4666 }
4667 }
4668
4669 *userbuf_pos = pos;
4670 *userbuf_len = len;
4671 }
4672
4673 // hlfmt pwdump
4674
4675 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4676 {
4677 int sep_cnt = 0;
4678
4679 int sep2_len = 0;
4680 int sep3_len = 0;
4681
4682 for (int i = 0; i < line_len; i++)
4683 {
4684 if (line_buf[i] == ':')
4685 {
4686 sep_cnt++;
4687
4688 continue;
4689 }
4690
4691 if (sep_cnt == 2) sep2_len++;
4692 if (sep_cnt == 3) sep3_len++;
4693 }
4694
4695 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4696
4697 return 0;
4698 }
4699
4700 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4701 {
4702 char *pos = NULL;
4703 int len = 0;
4704
4705 int sep_cnt = 0;
4706
4707 for (int i = 0; i < line_len; i++)
4708 {
4709 if (line_buf[i] == ':')
4710 {
4711 sep_cnt++;
4712
4713 continue;
4714 }
4715
4716 if (data.hash_mode == 1000)
4717 {
4718 if (sep_cnt == 3)
4719 {
4720 if (pos == NULL) pos = line_buf + i;
4721
4722 len++;
4723 }
4724 }
4725 else if (data.hash_mode == 3000)
4726 {
4727 if (sep_cnt == 2)
4728 {
4729 if (pos == NULL) pos = line_buf + i;
4730
4731 len++;
4732 }
4733 }
4734 }
4735
4736 *hashbuf_pos = pos;
4737 *hashbuf_len = len;
4738 }
4739
4740 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4741 {
4742 char *pos = NULL;
4743 int len = 0;
4744
4745 int sep_cnt = 0;
4746
4747 for (int i = 0; i < line_len; i++)
4748 {
4749 if (line_buf[i] == ':')
4750 {
4751 sep_cnt++;
4752
4753 continue;
4754 }
4755
4756 if (sep_cnt == 0)
4757 {
4758 if (pos == NULL) pos = line_buf + i;
4759
4760 len++;
4761 }
4762 }
4763
4764 *userbuf_pos = pos;
4765 *userbuf_len = len;
4766 }
4767
4768 // hlfmt passwd
4769
4770 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4771 {
4772 int sep_cnt = 0;
4773
4774 char sep5_first = 0;
4775 char sep6_first = 0;
4776
4777 for (int i = 0; i < line_len; i++)
4778 {
4779 if (line_buf[i] == ':')
4780 {
4781 sep_cnt++;
4782
4783 continue;
4784 }
4785
4786 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4787 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4788 }
4789
4790 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4791
4792 return 0;
4793 }
4794
4795 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4796 {
4797 char *pos = NULL;
4798 int len = 0;
4799
4800 int sep_cnt = 0;
4801
4802 for (int i = 0; i < line_len; i++)
4803 {
4804 if (line_buf[i] == ':')
4805 {
4806 sep_cnt++;
4807
4808 continue;
4809 }
4810
4811 if (sep_cnt == 1)
4812 {
4813 if (pos == NULL) pos = line_buf + i;
4814
4815 len++;
4816 }
4817 }
4818
4819 *hashbuf_pos = pos;
4820 *hashbuf_len = len;
4821 }
4822
4823 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4824 {
4825 char *pos = NULL;
4826 int len = 0;
4827
4828 int sep_cnt = 0;
4829
4830 for (int i = 0; i < line_len; i++)
4831 {
4832 if (line_buf[i] == ':')
4833 {
4834 sep_cnt++;
4835
4836 continue;
4837 }
4838
4839 if (sep_cnt == 0)
4840 {
4841 if (pos == NULL) pos = line_buf + i;
4842
4843 len++;
4844 }
4845 }
4846
4847 *userbuf_pos = pos;
4848 *userbuf_len = len;
4849 }
4850
4851 // hlfmt shadow
4852
4853 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4854 {
4855 int sep_cnt = 0;
4856
4857 for (int i = 0; i < line_len; i++)
4858 {
4859 if (line_buf[i] == ':') sep_cnt++;
4860 }
4861
4862 if (sep_cnt == 8) return 1;
4863
4864 return 0;
4865 }
4866
4867 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4868 {
4869 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4870 }
4871
4872 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4873 {
4874 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4875 }
4876
4877 // hlfmt main
4878
4879 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4880 {
4881 switch (hashfile_format)
4882 {
4883 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4884 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4885 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4886 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4887 }
4888 }
4889
4890 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4891 {
4892 switch (hashfile_format)
4893 {
4894 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4895 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4896 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4897 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4898 }
4899 }
4900
4901 static uint hlfmt_detect (FILE *fp, uint max_check)
4902 {
4903 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4904
4905 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4906 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4907
4908 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4909
4910 uint num_check = 0;
4911
4912 while (!feof (fp))
4913 {
4914 char line_buf[BUFSIZ];
4915
4916 int line_len = fgetl (fp, line_buf);
4917
4918 if (line_len == 0) continue;
4919
4920 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4921 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4922 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4923
4924 if (num_check == max_check) break;
4925
4926 num_check++;
4927 }
4928
4929 uint hashlist_format = HLFMT_HASHCAT;
4930
4931 for (int i = 1; i < HLFMTS_CNT; i++)
4932 {
4933 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4934
4935 hashlist_format = i;
4936 }
4937
4938 free (formats_cnt);
4939
4940 return hashlist_format;
4941 }
4942
4943 /**
4944 * some further helper function
4945 */
4946
4947 // wrapper around mymalloc for ADL
4948
4949 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4950 {
4951 return mymalloc (iSize);
4952 }
4953
4954 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)
4955 {
4956 u64 collisions = 0;
4957
4958 const uint dgst_pos0 = data.dgst_pos0;
4959 const uint dgst_pos1 = data.dgst_pos1;
4960 const uint dgst_pos2 = data.dgst_pos2;
4961 const uint dgst_pos3 = data.dgst_pos3;
4962
4963 memset (bitmap_a, 0, bitmap_size);
4964 memset (bitmap_b, 0, bitmap_size);
4965 memset (bitmap_c, 0, bitmap_size);
4966 memset (bitmap_d, 0, bitmap_size);
4967
4968 for (uint i = 0; i < digests_cnt; i++)
4969 {
4970 uint *digest_ptr = (uint *) digests_buf_ptr;
4971
4972 digests_buf_ptr += dgst_size;
4973
4974 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
4975 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
4976 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
4977 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
4978
4979 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4980 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4981 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4982 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4983
4984 if (bitmap_a[idx0] & val0) collisions++;
4985 if (bitmap_b[idx1] & val1) collisions++;
4986 if (bitmap_c[idx2] & val2) collisions++;
4987 if (bitmap_d[idx3] & val3) collisions++;
4988
4989 bitmap_a[idx0] |= val0;
4990 bitmap_b[idx1] |= val1;
4991 bitmap_c[idx2] |= val2;
4992 bitmap_d[idx3] |= val3;
4993
4994 if (collisions >= collisions_max) return 0x7fffffff;
4995 }
4996
4997 return collisions;
4998 }
4999
5000 /**
5001 * main
5002 */
5003
5004 int main (int argc, char **argv)
5005 {
5006 /**
5007 * To help users a bit
5008 */
5009
5010 char *compute = getenv ("COMPUTE");
5011
5012 if (compute)
5013 {
5014 char display[100];
5015
5016 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5017
5018 putenv (display);
5019 }
5020 else
5021 {
5022 if (getenv ("DISPLAY") == NULL)
5023 putenv ((char *) "DISPLAY=:0");
5024 }
5025
5026 /*
5027 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5028 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5029
5030 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5031 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5032 */
5033
5034 /**
5035 * Real init
5036 */
5037
5038 memset (&data, 0, sizeof (hc_global_data_t));
5039
5040 time_t proc_start;
5041
5042 time (&proc_start);
5043
5044 data.proc_start = proc_start;
5045
5046 int myargc = argc;
5047 char **myargv = argv;
5048
5049 hc_thread_mutex_init (mux_dispatcher);
5050 hc_thread_mutex_init (mux_counter);
5051 hc_thread_mutex_init (mux_display);
5052 hc_thread_mutex_init (mux_adl);
5053
5054 /**
5055 * commandline parameters
5056 */
5057
5058 uint usage = USAGE;
5059 uint version = VERSION;
5060 uint quiet = QUIET;
5061 uint benchmark = BENCHMARK;
5062 uint benchmark_mode = BENCHMARK_MODE;
5063 uint show = SHOW;
5064 uint left = LEFT;
5065 uint username = USERNAME;
5066 uint remove = REMOVE;
5067 uint remove_timer = REMOVE_TIMER;
5068 u64 skip = SKIP;
5069 u64 limit = LIMIT;
5070 uint keyspace = KEYSPACE;
5071 uint potfile_disable = POTFILE_DISABLE;
5072 uint debug_mode = DEBUG_MODE;
5073 char *debug_file = NULL;
5074 char *induction_dir = NULL;
5075 char *outfile_check_dir = NULL;
5076 uint force = FORCE;
5077 uint runtime = RUNTIME;
5078 uint hash_mode = HASH_MODE;
5079 uint attack_mode = ATTACK_MODE;
5080 uint markov_disable = MARKOV_DISABLE;
5081 uint markov_classic = MARKOV_CLASSIC;
5082 uint markov_threshold = MARKOV_THRESHOLD;
5083 char *markov_hcstat = NULL;
5084 char *outfile = NULL;
5085 uint outfile_format = OUTFILE_FORMAT;
5086 uint outfile_autohex = OUTFILE_AUTOHEX;
5087 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5088 uint restore = RESTORE;
5089 uint restore_timer = RESTORE_TIMER;
5090 uint restore_disable = RESTORE_DISABLE;
5091 uint status = STATUS;
5092 uint status_timer = STATUS_TIMER;
5093 uint status_automat = STATUS_AUTOMAT;
5094 uint loopback = LOOPBACK;
5095 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5096 char *session = NULL;
5097 uint hex_charset = HEX_CHARSET;
5098 uint hex_salt = HEX_SALT;
5099 uint hex_wordlist = HEX_WORDLIST;
5100 uint rp_gen = RP_GEN;
5101 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5102 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5103 uint rp_gen_seed = RP_GEN_SEED;
5104 char *rule_buf_l = (char *) RULE_BUF_L;
5105 char *rule_buf_r = (char *) RULE_BUF_R;
5106 uint increment = INCREMENT;
5107 uint increment_min = INCREMENT_MIN;
5108 uint increment_max = INCREMENT_MAX;
5109 char *cpu_affinity = NULL;
5110 char *opencl_devices = NULL;
5111 char *opencl_platforms = NULL;
5112 char *opencl_device_types = NULL;
5113 char *truecrypt_keyfiles = NULL;
5114 uint workload_profile = WORKLOAD_PROFILE;
5115 uint kernel_accel = KERNEL_ACCEL;
5116 uint kernel_loops = KERNEL_LOOPS;
5117 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5118 uint gpu_temp_abort = GPU_TEMP_ABORT;
5119 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5120 uint powertune_enable = POWERTUNE_ENABLE;
5121 uint logfile_disable = LOGFILE_DISABLE;
5122 uint segment_size = SEGMENT_SIZE;
5123 uint scrypt_tmto = SCRYPT_TMTO;
5124 char separator = SEPARATOR;
5125 uint bitmap_min = BITMAP_MIN;
5126 uint bitmap_max = BITMAP_MAX;
5127 char *custom_charset_1 = NULL;
5128 char *custom_charset_2 = NULL;
5129 char *custom_charset_3 = NULL;
5130 char *custom_charset_4 = NULL;
5131
5132 #define IDX_HELP 'h'
5133 #define IDX_VERSION 'V'
5134 #define IDX_VERSION_LOWER 'v'
5135 #define IDX_QUIET 0xff02
5136 #define IDX_SHOW 0xff03
5137 #define IDX_LEFT 0xff04
5138 #define IDX_REMOVE 0xff05
5139 #define IDX_REMOVE_TIMER 0xff37
5140 #define IDX_SKIP 's'
5141 #define IDX_LIMIT 'l'
5142 #define IDX_KEYSPACE 0xff35
5143 #define IDX_POTFILE_DISABLE 0xff06
5144 #define IDX_DEBUG_MODE 0xff43
5145 #define IDX_DEBUG_FILE 0xff44
5146 #define IDX_INDUCTION_DIR 0xff46
5147 #define IDX_OUTFILE_CHECK_DIR 0xff47
5148 #define IDX_USERNAME 0xff07
5149 #define IDX_FORCE 0xff08
5150 #define IDX_RUNTIME 0xff09
5151 #define IDX_BENCHMARK 'b'
5152 #define IDX_BENCHMARK_MODE 0xff32
5153 #define IDX_HASH_MODE 'm'
5154 #define IDX_ATTACK_MODE 'a'
5155 #define IDX_RP_FILE 'r'
5156 #define IDX_RP_GEN 'g'
5157 #define IDX_RP_GEN_FUNC_MIN 0xff10
5158 #define IDX_RP_GEN_FUNC_MAX 0xff11
5159 #define IDX_RP_GEN_SEED 0xff34
5160 #define IDX_RULE_BUF_L 'j'
5161 #define IDX_RULE_BUF_R 'k'
5162 #define IDX_INCREMENT 'i'
5163 #define IDX_INCREMENT_MIN 0xff12
5164 #define IDX_INCREMENT_MAX 0xff13
5165 #define IDX_OUTFILE 'o'
5166 #define IDX_OUTFILE_FORMAT 0xff14
5167 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5168 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5169 #define IDX_RESTORE 0xff15
5170 #define IDX_RESTORE_DISABLE 0xff27
5171 #define IDX_STATUS 0xff17
5172 #define IDX_STATUS_TIMER 0xff18
5173 #define IDX_STATUS_AUTOMAT 0xff50
5174 #define IDX_LOOPBACK 0xff38
5175 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5176 #define IDX_SESSION 0xff19
5177 #define IDX_HEX_CHARSET 0xff20
5178 #define IDX_HEX_SALT 0xff21
5179 #define IDX_HEX_WORDLIST 0xff40
5180 #define IDX_MARKOV_DISABLE 0xff22
5181 #define IDX_MARKOV_CLASSIC 0xff23
5182 #define IDX_MARKOV_THRESHOLD 't'
5183 #define IDX_MARKOV_HCSTAT 0xff24
5184 #define IDX_CPU_AFFINITY 0xff25
5185 #define IDX_OPENCL_DEVICES 'd'
5186 #define IDX_OPENCL_PLATFORMS 0xff72
5187 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5188 #define IDX_WORKLOAD_PROFILE 'w'
5189 #define IDX_KERNEL_ACCEL 'n'
5190 #define IDX_KERNEL_LOOPS 'u'
5191 #define IDX_GPU_TEMP_DISABLE 0xff29
5192 #define IDX_GPU_TEMP_ABORT 0xff30
5193 #define IDX_GPU_TEMP_RETAIN 0xff31
5194 #define IDX_POWERTUNE_ENABLE 0xff41
5195 #define IDX_LOGFILE_DISABLE 0xff51
5196 #define IDX_TRUECRYPT_KEYFILES 0xff52
5197 #define IDX_SCRYPT_TMTO 0xff61
5198 #define IDX_SEGMENT_SIZE 'c'
5199 #define IDX_SEPARATOR 'p'
5200 #define IDX_BITMAP_MIN 0xff70
5201 #define IDX_BITMAP_MAX 0xff71
5202 #define IDX_CUSTOM_CHARSET_1 '1'
5203 #define IDX_CUSTOM_CHARSET_2 '2'
5204 #define IDX_CUSTOM_CHARSET_3 '3'
5205 #define IDX_CUSTOM_CHARSET_4 '4'
5206
5207 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5208
5209 struct option long_options[] =
5210 {
5211 {"help", no_argument, 0, IDX_HELP},
5212 {"version", no_argument, 0, IDX_VERSION},
5213 {"quiet", no_argument, 0, IDX_QUIET},
5214 {"show", no_argument, 0, IDX_SHOW},
5215 {"left", no_argument, 0, IDX_LEFT},
5216 {"username", no_argument, 0, IDX_USERNAME},
5217 {"remove", no_argument, 0, IDX_REMOVE},
5218 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5219 {"skip", required_argument, 0, IDX_SKIP},
5220 {"limit", required_argument, 0, IDX_LIMIT},
5221 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5222 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5223 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5224 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5225 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5226 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5227 {"force", no_argument, 0, IDX_FORCE},
5228 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5229 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5230 {"restore", no_argument, 0, IDX_RESTORE},
5231 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5232 {"status", no_argument, 0, IDX_STATUS},
5233 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5234 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5235 {"loopback", no_argument, 0, IDX_LOOPBACK},
5236 {"weak-hash-threshold",
5237 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5238 {"session", required_argument, 0, IDX_SESSION},
5239 {"runtime", required_argument, 0, IDX_RUNTIME},
5240 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5241 {"generate-rules-func-min",
5242 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5243 {"generate-rules-func-max",
5244 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5245 {"generate-rules-seed",
5246 required_argument, 0, IDX_RP_GEN_SEED},
5247 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5248 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5249 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5250 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5251 {"rules-file", required_argument, 0, IDX_RP_FILE},
5252 {"outfile", required_argument, 0, IDX_OUTFILE},
5253 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5254 {"outfile-autohex-disable",
5255 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5256 {"outfile-check-timer",
5257 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5258 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5259 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5260 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5261 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5262 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5263 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5264 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5265 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5266 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5267 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5268 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5269 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5270 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5271 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5272 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5273 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5274 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5275 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5276 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5277 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5278 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5279 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5280 // deprecated
5281 {"seperator", required_argument, 0, IDX_SEPARATOR},
5282 {"separator", required_argument, 0, IDX_SEPARATOR},
5283 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5284 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5285 {"increment", no_argument, 0, IDX_INCREMENT},
5286 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5287 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5288 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5289 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5290 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5291 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5292
5293 {0, 0, 0, 0}
5294 };
5295
5296 uint rp_files_cnt = 0;
5297
5298 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5299
5300 int option_index;
5301 int c;
5302
5303 optind = 1;
5304 optopt = 0;
5305 option_index = 0;
5306
5307 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5308 {
5309 switch (c)
5310 {
5311 case IDX_HELP: usage = 1; break;
5312 case IDX_VERSION:
5313 case IDX_VERSION_LOWER: version = 1; break;
5314 case IDX_RESTORE: restore = 1; break;
5315 case IDX_SESSION: session = optarg; break;
5316 case IDX_SHOW: show = 1; break;
5317 case IDX_LEFT: left = 1; break;
5318 case '?': return (-1);
5319 }
5320 }
5321
5322 if (optopt != 0)
5323 {
5324 log_error ("ERROR: Invalid argument specified");
5325
5326 return (-1);
5327 }
5328
5329 /**
5330 * exit functions
5331 */
5332
5333 if (version)
5334 {
5335 log_info (VERSION_TXT);
5336
5337 return (0);
5338 }
5339
5340 if (usage)
5341 {
5342 usage_big_print (PROGNAME);
5343
5344 return (0);
5345 }
5346
5347 /**
5348 * session needs to be set, always!
5349 */
5350
5351 if (session == NULL) session = (char *) PROGNAME;
5352
5353 /**
5354 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5355 */
5356
5357 char *exec_path = get_exec_path ();
5358
5359 #ifdef LINUX
5360
5361 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5362 char *resolved_exec_path = realpath (exec_path, NULL);
5363
5364 char *install_dir = get_install_dir (resolved_exec_path);
5365 char *profile_dir = NULL;
5366 char *session_dir = NULL;
5367 char *shared_dir = NULL;
5368
5369 if (strcmp (install_dir, resolved_install_folder) == 0)
5370 {
5371 struct passwd *pw = getpwuid (getuid ());
5372
5373 const char *homedir = pw->pw_dir;
5374
5375 profile_dir = get_profile_dir (homedir);
5376 session_dir = get_session_dir (profile_dir);
5377 shared_dir = strdup (SHARED_FOLDER);
5378
5379 mkdir (profile_dir, 0700);
5380 mkdir (session_dir, 0700);
5381 }
5382 else
5383 {
5384 profile_dir = install_dir;
5385 session_dir = install_dir;
5386 shared_dir = install_dir;
5387 }
5388
5389 myfree (resolved_install_folder);
5390 myfree (resolved_exec_path);
5391
5392 #else
5393
5394 char *install_dir = get_install_dir (exec_path);
5395 char *profile_dir = install_dir;
5396 char *session_dir = install_dir;
5397 char *shared_dir = install_dir;
5398
5399 #endif
5400
5401 data.install_dir = install_dir;
5402 data.profile_dir = profile_dir;
5403 data.session_dir = session_dir;
5404 data.shared_dir = shared_dir;
5405
5406 myfree (exec_path);
5407
5408 /**
5409 * kernel cache, we need to make sure folder exist
5410 */
5411
5412 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5413
5414 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5415
5416 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5417
5418 mkdir (kernels_folder, 0700);
5419
5420 myfree (kernels_folder);
5421
5422 /**
5423 * session
5424 */
5425
5426 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5427
5428 data.session = session;
5429
5430 char *eff_restore_file = (char *) mymalloc (session_size);
5431 char *new_restore_file = (char *) mymalloc (session_size);
5432
5433 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5434 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5435
5436 data.eff_restore_file = eff_restore_file;
5437 data.new_restore_file = new_restore_file;
5438
5439 if (((show == 1) || (left == 1)) && (restore == 1))
5440 {
5441 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5442 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5443
5444 return (-1);
5445 }
5446
5447 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5448 if ((show == 1) || (left == 1))
5449 {
5450 restore_disable = 1;
5451
5452 restore = 0;
5453 }
5454
5455 data.restore_disable = restore_disable;
5456
5457 restore_data_t *rd = init_restore (argc, argv);
5458
5459 data.rd = rd;
5460
5461 /**
5462 * restore file
5463 */
5464
5465 if (restore == 1)
5466 {
5467 read_restore (eff_restore_file, rd);
5468
5469 if (rd->version_bin < RESTORE_MIN)
5470 {
5471 log_error ("ERROR: Incompatible restore-file version");
5472
5473 return (-1);
5474 }
5475
5476 myargc = rd->argc;
5477 myargv = rd->argv;
5478
5479 #ifdef _POSIX
5480 rd->pid = getpid ();
5481 #elif _WIN
5482 rd->pid = GetCurrentProcessId ();
5483 #endif
5484 }
5485
5486 uint hash_mode_chgd = 0;
5487 uint runtime_chgd = 0;
5488 uint kernel_loops_chgd = 0;
5489 uint kernel_accel_chgd = 0;
5490 uint attack_mode_chgd = 0;
5491 uint outfile_format_chgd = 0;
5492 uint rp_gen_seed_chgd = 0;
5493 uint remove_timer_chgd = 0;
5494 uint increment_min_chgd = 0;
5495 uint increment_max_chgd = 0;
5496 uint gpu_temp_abort_chgd = 0;
5497 uint gpu_temp_retain_chgd = 0;
5498
5499 optind = 1;
5500 optopt = 0;
5501 option_index = 0;
5502
5503 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5504 {
5505 switch (c)
5506 {
5507 //case IDX_HELP: usage = 1; break;
5508 //case IDX_VERSION: version = 1; break;
5509 //case IDX_RESTORE: restore = 1; break;
5510 case IDX_QUIET: quiet = 1; break;
5511 //case IDX_SHOW: show = 1; break;
5512 case IDX_SHOW: break;
5513 //case IDX_LEFT: left = 1; break;
5514 case IDX_LEFT: break;
5515 case IDX_USERNAME: username = 1; break;
5516 case IDX_REMOVE: remove = 1; break;
5517 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5518 remove_timer_chgd = 1; break;
5519 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5520 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5521 case IDX_DEBUG_FILE: debug_file = optarg; break;
5522 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5523 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5524 case IDX_FORCE: force = 1; break;
5525 case IDX_SKIP: skip = atoll (optarg); break;
5526 case IDX_LIMIT: limit = atoll (optarg); break;
5527 case IDX_KEYSPACE: keyspace = 1; break;
5528 case IDX_BENCHMARK: benchmark = 1; break;
5529 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5530 case IDX_RESTORE: break;
5531 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5532 case IDX_STATUS: status = 1; break;
5533 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5534 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5535 case IDX_LOOPBACK: loopback = 1; break;
5536 case IDX_WEAK_HASH_THRESHOLD:
5537 weak_hash_threshold = atoi (optarg); break;
5538 //case IDX_SESSION: session = optarg; break;
5539 case IDX_SESSION: break;
5540 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5541 hash_mode_chgd = 1; break;
5542 case IDX_RUNTIME: runtime = atoi (optarg);
5543 runtime_chgd = 1; break;
5544 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5545 attack_mode_chgd = 1; break;
5546 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5547 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5548 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5549 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5550 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5551 rp_gen_seed_chgd = 1; break;
5552 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5553 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5554 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5555 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5556 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5557 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5558 case IDX_OUTFILE: outfile = optarg; break;
5559 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5560 outfile_format_chgd = 1; break;
5561 case IDX_OUTFILE_AUTOHEX_DISABLE:
5562 outfile_autohex = 0; break;
5563 case IDX_OUTFILE_CHECK_TIMER:
5564 outfile_check_timer = atoi (optarg); break;
5565 case IDX_HEX_CHARSET: hex_charset = 1; break;
5566 case IDX_HEX_SALT: hex_salt = 1; break;
5567 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5568 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5569 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5570 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5571 case IDX_OPENCL_DEVICE_TYPES:
5572 opencl_device_types = optarg; break;
5573 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5574 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5575 kernel_accel_chgd = 1; break;
5576 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5577 kernel_loops_chgd = 1; break;
5578 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5579 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5580 gpu_temp_abort = atoi (optarg); break;
5581 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5582 gpu_temp_retain = atoi (optarg); break;
5583 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5584 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5585 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5586 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5587 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5588 case IDX_SEPARATOR: separator = optarg[0]; break;
5589 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5590 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5591 case IDX_INCREMENT: increment = 1; break;
5592 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5593 increment_min_chgd = 1; break;
5594 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5595 increment_max_chgd = 1; break;
5596 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5597 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5598 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5599 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5600
5601 default:
5602 log_error ("ERROR: Invalid argument specified");
5603 return (-1);
5604 }
5605 }
5606
5607 if (optopt != 0)
5608 {
5609 log_error ("ERROR: Invalid argument specified");
5610
5611 return (-1);
5612 }
5613
5614 /**
5615 * Inform user things getting started,
5616 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5617 * - we do not need to check algorithm_pos
5618 */
5619
5620 if (quiet == 0)
5621 {
5622 if (benchmark == 1)
5623 {
5624 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5625
5626 log_info ("");
5627 }
5628 else if (restore == 1)
5629 {
5630 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5631
5632 log_info ("");
5633 }
5634 else
5635 {
5636 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5637
5638 log_info ("");
5639 }
5640 }
5641
5642 /**
5643 * sanity check
5644 */
5645
5646 if (attack_mode > 7)
5647 {
5648 log_error ("ERROR: Invalid attack-mode specified");
5649
5650 return (-1);
5651 }
5652
5653 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5654 {
5655 log_error ("ERROR: Invalid runtime specified");
5656
5657 return (-1);
5658 }
5659
5660 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5661 {
5662 log_error ("ERROR: Invalid hash-type specified");
5663
5664 return (-1);
5665 }
5666
5667 // renamed hash modes
5668
5669 if (hash_mode_chgd)
5670 {
5671 int n = -1;
5672
5673 switch (hash_mode)
5674 {
5675 case 123: n = 124;
5676 break;
5677 }
5678
5679 if (n >= 0)
5680 {
5681 log_error ("Old -m specified, use -m %d instead", n);
5682
5683 return (-1);
5684 }
5685 }
5686
5687 if (username == 1)
5688 {
5689 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5690 {
5691 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5692
5693 return (-1);
5694 }
5695 }
5696
5697 if (outfile_format > 16)
5698 {
5699 log_error ("ERROR: Invalid outfile-format specified");
5700
5701 return (-1);
5702 }
5703
5704 if (left == 1)
5705 {
5706 if (outfile_format_chgd == 1)
5707 {
5708 if (outfile_format > 1)
5709 {
5710 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5711
5712 return (-1);
5713 }
5714 }
5715 else
5716 {
5717 outfile_format = OUTFILE_FMT_HASH;
5718 }
5719 }
5720
5721 if (show == 1)
5722 {
5723 if (outfile_format_chgd == 1)
5724 {
5725 if ((outfile_format > 7) && (outfile_format < 16))
5726 {
5727 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5728
5729 return (-1);
5730 }
5731 }
5732 }
5733
5734 if (increment_min < INCREMENT_MIN)
5735 {
5736 log_error ("ERROR: Invalid increment-min specified");
5737
5738 return (-1);
5739 }
5740
5741 if (increment_max > INCREMENT_MAX)
5742 {
5743 log_error ("ERROR: Invalid increment-max specified");
5744
5745 return (-1);
5746 }
5747
5748 if (increment_min > increment_max)
5749 {
5750 log_error ("ERROR: Invalid increment-min specified");
5751
5752 return (-1);
5753 }
5754
5755 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5756 {
5757 log_error ("ERROR: increment is not allowed in attack-mode 0");
5758
5759 return (-1);
5760 }
5761
5762 if ((increment == 0) && (increment_min_chgd == 1))
5763 {
5764 log_error ("ERROR: increment-min is only supported together with increment switch");
5765
5766 return (-1);
5767 }
5768
5769 if ((increment == 0) && (increment_max_chgd == 1))
5770 {
5771 log_error ("ERROR: increment-max is only supported together with increment switch");
5772
5773 return (-1);
5774 }
5775
5776 if (rp_files_cnt && rp_gen)
5777 {
5778 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5779
5780 return (-1);
5781 }
5782
5783 if (rp_files_cnt || rp_gen)
5784 {
5785 if (attack_mode != ATTACK_MODE_STRAIGHT)
5786 {
5787 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5788
5789 return (-1);
5790 }
5791 }
5792
5793 if (rp_gen_func_min > rp_gen_func_max)
5794 {
5795 log_error ("ERROR: Invalid rp-gen-func-min specified");
5796
5797 return (-1);
5798 }
5799
5800 if (kernel_accel_chgd == 1)
5801 {
5802 if (workload_profile != WORKLOAD_PROFILE)
5803 {
5804 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5805
5806 return (-1);
5807 }
5808
5809 if (kernel_accel < 1)
5810 {
5811 log_error ("ERROR: Invalid kernel-accel specified");
5812
5813 return (-1);
5814 }
5815
5816 if (kernel_accel > 800)
5817 {
5818 log_error ("ERROR: Invalid kernel-accel specified");
5819
5820 return (-1);
5821 }
5822 }
5823
5824 if (kernel_loops_chgd == 1)
5825 {
5826 if (workload_profile != WORKLOAD_PROFILE)
5827 {
5828 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5829
5830 return (-1);
5831 }
5832
5833 if (kernel_loops < 1)
5834 {
5835 log_error ("ERROR: Invalid kernel-loops specified");
5836
5837 return (-1);
5838 }
5839
5840 if (kernel_loops > 1024)
5841 {
5842 log_error ("ERROR: Invalid kernel-loops specified");
5843
5844 return (-1);
5845 }
5846 }
5847
5848 if (benchmark == 1)
5849 {
5850 if (workload_profile != WORKLOAD_PROFILE)
5851 {
5852 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 if ((workload_profile < 1) || (workload_profile > 3))
5859 {
5860 log_error ("ERROR: workload-profile %i not available", workload_profile);
5861
5862 return (-1);
5863 }
5864
5865 if (show == 1 || left == 1)
5866 {
5867 attack_mode = ATTACK_MODE_NONE;
5868
5869 if (remove == 1)
5870 {
5871 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5872
5873 return (-1);
5874 }
5875
5876 if (potfile_disable == 1)
5877 {
5878 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5879
5880 return (-1);
5881 }
5882 }
5883
5884 uint attack_kern = ATTACK_KERN_NONE;
5885
5886 switch (attack_mode)
5887 {
5888 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5889 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5890 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5891 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5892 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5893 }
5894
5895 if (benchmark == 0)
5896 {
5897 if (keyspace == 1)
5898 {
5899 int num_additional_params = 1;
5900
5901 if (attack_kern == ATTACK_KERN_COMBI)
5902 {
5903 num_additional_params = 2;
5904 }
5905
5906 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5907
5908 if (keyspace_wordlist_specified == 0) optind--;
5909 }
5910
5911 if (attack_kern == ATTACK_KERN_NONE)
5912 {
5913 if ((optind + 1) != myargc)
5914 {
5915 usage_mini_print (myargv[0]);
5916
5917 return (-1);
5918 }
5919 }
5920 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5921 {
5922 if ((optind + 1) > myargc)
5923 {
5924 usage_mini_print (myargv[0]);
5925
5926 return (-1);
5927 }
5928 }
5929 else if (attack_kern == ATTACK_KERN_COMBI)
5930 {
5931 if ((optind + 3) != myargc)
5932 {
5933 usage_mini_print (myargv[0]);
5934
5935 return (-1);
5936 }
5937 }
5938 else if (attack_kern == ATTACK_KERN_BF)
5939 {
5940 if ((optind + 1) > myargc)
5941 {
5942 usage_mini_print (myargv[0]);
5943
5944 return (-1);
5945 }
5946 }
5947 else
5948 {
5949 usage_mini_print (myargv[0]);
5950
5951 return (-1);
5952 }
5953 }
5954 else
5955 {
5956 if (myargv[optind] != 0)
5957 {
5958 log_error ("ERROR: Invalid argument for benchmark mode specified");
5959
5960 return (-1);
5961 }
5962
5963 if (attack_mode_chgd == 1)
5964 {
5965 if (attack_mode != ATTACK_MODE_BF)
5966 {
5967 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5968
5969 return (-1);
5970 }
5971 }
5972
5973 if (benchmark_mode == 0)
5974 {
5975 // nothing to do
5976 }
5977 else if (benchmark_mode == 1)
5978 {
5979 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5980 {
5981 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5982
5983 return (-1);
5984 }
5985 }
5986 else
5987 {
5988 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (skip != 0 && limit != 0)
5995 {
5996 limit += skip;
5997 }
5998
5999 if (keyspace == 1)
6000 {
6001 if (show == 1)
6002 {
6003 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6004
6005 return (-1);
6006 }
6007 else if (left == 1)
6008 {
6009 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6010
6011 return (-1);
6012 }
6013
6014 potfile_disable = 1;
6015
6016 restore_disable = 1;
6017
6018 restore = 0;
6019
6020 weak_hash_threshold = 0;
6021
6022 quiet = 1;
6023 }
6024
6025 if (remove_timer_chgd == 1)
6026 {
6027 if (remove == 0)
6028 {
6029 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6030
6031 return (-1);
6032 }
6033
6034 if (remove_timer < 1)
6035 {
6036 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6037
6038 return (-1);
6039 }
6040 }
6041
6042 if (loopback == 1)
6043 {
6044 if (attack_mode == ATTACK_MODE_BF)
6045 {
6046 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6047
6048 return (-1);
6049 }
6050 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6051 {
6052 if ((rp_files_cnt == 0) && (rp_gen == 0))
6053 {
6054 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6055
6056 return (-1);
6057 }
6058 }
6059 }
6060
6061 if (debug_mode > 0)
6062 {
6063 if (attack_mode != ATTACK_MODE_STRAIGHT)
6064 {
6065 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6066
6067 return (-1);
6068 }
6069
6070 if ((rp_files_cnt == 0) && (rp_gen == 0))
6071 {
6072 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6073
6074 return (-1);
6075 }
6076 }
6077
6078 if (debug_mode > 4)
6079 {
6080 log_error ("ERROR: Invalid debug-mode specified");
6081
6082 return (-1);
6083 }
6084
6085 if (debug_file != NULL)
6086 {
6087 if (debug_mode < 1)
6088 {
6089 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6090
6091 return (-1);
6092 }
6093 }
6094
6095 if (induction_dir != NULL)
6096 {
6097 if (attack_mode == ATTACK_MODE_BF)
6098 {
6099 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6100
6101 return (-1);
6102 }
6103 }
6104
6105 if (attack_mode != ATTACK_MODE_STRAIGHT)
6106 {
6107 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6108 {
6109 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6110
6111 return (-1);
6112 }
6113
6114 weak_hash_threshold = 0;
6115 }
6116
6117 /**
6118 * induction directory
6119 */
6120
6121 char *induction_directory = NULL;
6122
6123 if (attack_mode != ATTACK_MODE_BF)
6124 {
6125 if (induction_dir == NULL)
6126 {
6127 induction_directory = (char *) mymalloc (session_size);
6128
6129 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6130
6131 // create induction folder if it does not already exist
6132
6133 if (keyspace == 0)
6134 {
6135 if (rmdir (induction_directory) == -1)
6136 {
6137 if (errno == ENOENT)
6138 {
6139 // good, we can ignore
6140 }
6141 else if (errno == ENOTEMPTY)
6142 {
6143 char *induction_directory_mv = (char *) mymalloc (session_size);
6144
6145 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6146
6147 if (rename (induction_directory, induction_directory_mv) != 0)
6148 {
6149 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6150
6151 return (-1);
6152 }
6153 }
6154 else
6155 {
6156 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6157
6158 return (-1);
6159 }
6160 }
6161
6162 if (mkdir (induction_directory, 0700) == -1)
6163 {
6164 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6165
6166 return (-1);
6167 }
6168 }
6169 }
6170 else
6171 {
6172 induction_directory = induction_dir;
6173 }
6174 }
6175
6176 data.induction_directory = induction_directory;
6177
6178 /**
6179 * loopback
6180 */
6181
6182 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6183
6184 char *loopback_file = (char *) mymalloc (loopback_size);
6185
6186 /**
6187 * outfile-check directory
6188 */
6189
6190 char *outfile_check_directory = NULL;
6191
6192 if (outfile_check_dir == NULL)
6193 {
6194 outfile_check_directory = (char *) mymalloc (session_size);
6195
6196 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6197 }
6198 else
6199 {
6200 outfile_check_directory = outfile_check_dir;
6201 }
6202
6203 data.outfile_check_directory = outfile_check_directory;
6204
6205 if (keyspace == 0)
6206 {
6207 struct stat outfile_check_stat;
6208
6209 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6210 {
6211 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6212
6213 if (is_dir == 0)
6214 {
6215 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6216
6217 return (-1);
6218 }
6219 }
6220 else if (outfile_check_dir == NULL)
6221 {
6222 if (mkdir (outfile_check_directory, 0700) == -1)
6223 {
6224 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6225
6226 return (-1);
6227 }
6228 }
6229 }
6230
6231 /**
6232 * special other stuff
6233 */
6234
6235 if (hash_mode == 9710)
6236 {
6237 outfile_format = 5;
6238 outfile_format_chgd = 1;
6239 }
6240
6241 if (hash_mode == 9810)
6242 {
6243 outfile_format = 5;
6244 outfile_format_chgd = 1;
6245 }
6246
6247 if (hash_mode == 10410)
6248 {
6249 outfile_format = 5;
6250 outfile_format_chgd = 1;
6251 }
6252
6253 /**
6254 * store stuff
6255 */
6256
6257 data.hash_mode = hash_mode;
6258 data.restore = restore;
6259 data.restore_timer = restore_timer;
6260 data.restore_disable = restore_disable;
6261 data.status = status;
6262 data.status_timer = status_timer;
6263 data.status_automat = status_automat;
6264 data.loopback = loopback;
6265 data.runtime = runtime;
6266 data.remove = remove;
6267 data.remove_timer = remove_timer;
6268 data.debug_mode = debug_mode;
6269 data.debug_file = debug_file;
6270 data.username = username;
6271 data.quiet = quiet;
6272 data.outfile = outfile;
6273 data.outfile_format = outfile_format;
6274 data.outfile_autohex = outfile_autohex;
6275 data.hex_charset = hex_charset;
6276 data.hex_salt = hex_salt;
6277 data.hex_wordlist = hex_wordlist;
6278 data.separator = separator;
6279 data.rp_files = rp_files;
6280 data.rp_files_cnt = rp_files_cnt;
6281 data.rp_gen = rp_gen;
6282 data.rp_gen_seed = rp_gen_seed;
6283 data.force = force;
6284 data.benchmark = benchmark;
6285 data.skip = skip;
6286 data.limit = limit;
6287 data.powertune_enable = powertune_enable;
6288 data.logfile_disable = logfile_disable;
6289 data.truecrypt_keyfiles = truecrypt_keyfiles;
6290 data.scrypt_tmto = scrypt_tmto;
6291
6292 /**
6293 * cpu affinity
6294 */
6295
6296 if (cpu_affinity)
6297 {
6298 set_cpu_affinity (cpu_affinity);
6299 }
6300
6301 if (rp_gen_seed_chgd == 0)
6302 {
6303 srand (proc_start);
6304 }
6305 else
6306 {
6307 srand (rp_gen_seed);
6308 }
6309
6310 /**
6311 * logfile init
6312 */
6313
6314 if (logfile_disable == 0)
6315 {
6316 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6317
6318 char *logfile = (char *) mymalloc (logfile_size);
6319
6320 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6321
6322 data.logfile = logfile;
6323
6324 char *topid = logfile_generate_topid ();
6325
6326 data.topid = topid;
6327 }
6328
6329 // logfile_append() checks for logfile_disable internally to make it easier from here
6330
6331 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6332 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6333 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6334 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6335 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6336 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6337 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6338 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6339 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6340 #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));
6341
6342 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6343 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6344 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6345 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6346 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6347 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6348 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6349 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6350
6351 logfile_top_msg ("START");
6352
6353 logfile_top_uint (attack_mode);
6354 logfile_top_uint (attack_kern);
6355 logfile_top_uint (benchmark);
6356 logfile_top_uint (benchmark_mode);
6357 logfile_top_uint (bitmap_min);
6358 logfile_top_uint (bitmap_max);
6359 logfile_top_uint (debug_mode);
6360 logfile_top_uint (force);
6361 logfile_top_uint (kernel_accel);
6362 logfile_top_uint (kernel_loops);
6363 logfile_top_uint (gpu_temp_abort);
6364 logfile_top_uint (gpu_temp_disable);
6365 logfile_top_uint (gpu_temp_retain);
6366 logfile_top_uint (hash_mode);
6367 logfile_top_uint (hex_charset);
6368 logfile_top_uint (hex_salt);
6369 logfile_top_uint (hex_wordlist);
6370 logfile_top_uint (increment);
6371 logfile_top_uint (increment_max);
6372 logfile_top_uint (increment_min);
6373 logfile_top_uint (keyspace);
6374 logfile_top_uint (left);
6375 logfile_top_uint (logfile_disable);
6376 logfile_top_uint (loopback);
6377 logfile_top_uint (markov_classic);
6378 logfile_top_uint (markov_disable);
6379 logfile_top_uint (markov_threshold);
6380 logfile_top_uint (outfile_autohex);
6381 logfile_top_uint (outfile_check_timer);
6382 logfile_top_uint (outfile_format);
6383 logfile_top_uint (potfile_disable);
6384 logfile_top_uint (powertune_enable);
6385 logfile_top_uint (scrypt_tmto);
6386 logfile_top_uint (quiet);
6387 logfile_top_uint (remove);
6388 logfile_top_uint (remove_timer);
6389 logfile_top_uint (restore);
6390 logfile_top_uint (restore_disable);
6391 logfile_top_uint (restore_timer);
6392 logfile_top_uint (rp_gen);
6393 logfile_top_uint (rp_gen_func_max);
6394 logfile_top_uint (rp_gen_func_min);
6395 logfile_top_uint (rp_gen_seed);
6396 logfile_top_uint (runtime);
6397 logfile_top_uint (segment_size);
6398 logfile_top_uint (show);
6399 logfile_top_uint (status);
6400 logfile_top_uint (status_automat);
6401 logfile_top_uint (status_timer);
6402 logfile_top_uint (usage);
6403 logfile_top_uint (username);
6404 logfile_top_uint (version);
6405 logfile_top_uint (weak_hash_threshold);
6406 logfile_top_uint (workload_profile);
6407 logfile_top_uint64 (limit);
6408 logfile_top_uint64 (skip);
6409 logfile_top_char (separator);
6410 logfile_top_string (cpu_affinity);
6411 logfile_top_string (custom_charset_1);
6412 logfile_top_string (custom_charset_2);
6413 logfile_top_string (custom_charset_3);
6414 logfile_top_string (custom_charset_4);
6415 logfile_top_string (debug_file);
6416 logfile_top_string (opencl_devices);
6417 logfile_top_string (opencl_platforms);
6418 logfile_top_string (opencl_device_types);
6419 logfile_top_string (induction_dir);
6420 logfile_top_string (markov_hcstat);
6421 logfile_top_string (outfile);
6422 logfile_top_string (outfile_check_dir);
6423 logfile_top_string (rule_buf_l);
6424 logfile_top_string (rule_buf_r);
6425 logfile_top_string (session);
6426 logfile_top_string (truecrypt_keyfiles);
6427
6428 /**
6429 * OpenCL platform selection
6430 */
6431
6432 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6433
6434 /**
6435 * OpenCL device selection
6436 */
6437
6438 u32 devices_filter = setup_devices_filter (opencl_devices);
6439
6440 /**
6441 * OpenCL device type selection
6442 */
6443
6444 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6445
6446 /**
6447 * benchmark
6448 */
6449
6450 if (benchmark == 1)
6451 {
6452 /**
6453 * disable useless stuff for benchmark
6454 */
6455
6456 restore_timer = 0;
6457 status_timer = 0;
6458 restore_disable = 1;
6459 potfile_disable = 1;
6460 weak_hash_threshold = 0;
6461
6462 data.restore_timer = restore_timer;
6463 data.status_timer = status_timer;
6464 data.restore_disable = restore_disable;
6465
6466 if (benchmark_mode == 1)
6467 {
6468 markov_disable = 1;
6469 }
6470
6471 /**
6472 * force attack mode to be bruteforce
6473 */
6474
6475 attack_mode = ATTACK_MODE_BF;
6476 attack_kern = ATTACK_KERN_BF;
6477
6478 if (runtime_chgd == 0)
6479 {
6480 runtime = 4;
6481
6482 if (benchmark_mode == 1) runtime = 17;
6483
6484 data.runtime = runtime;
6485 }
6486 }
6487
6488 /**
6489 * config
6490 */
6491
6492 uint hash_type = 0;
6493 uint salt_type = 0;
6494 uint attack_exec = 0;
6495 uint opts_type = 0;
6496 uint kern_type = 0;
6497 uint dgst_size = 0;
6498 uint esalt_size = 0;
6499 uint opti_type = 0;
6500 uint dgst_pos0 = -1;
6501 uint dgst_pos1 = -1;
6502 uint dgst_pos2 = -1;
6503 uint dgst_pos3 = -1;
6504
6505 int (*parse_func) (char *, uint, hash_t *);
6506 int (*sort_by_digest) (const void *, const void *);
6507
6508 uint algorithm_pos = 0;
6509 uint algorithm_max = 1;
6510
6511 uint *algorithms = default_benchmark_algorithms;
6512
6513 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6514
6515 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6516 {
6517 /*
6518 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6519 * the following algos are skipped entirely
6520 */
6521
6522 if (algorithm_pos > 0)
6523 {
6524 local_free (rd);
6525
6526 rd = init_restore (argc, argv);
6527
6528 data.rd = rd;
6529 }
6530
6531 /**
6532 * update hash_mode in case of multihash benchmark
6533 */
6534
6535 if (benchmark == 1)
6536 {
6537 if (hash_mode_chgd == 0)
6538 {
6539 hash_mode = algorithms[algorithm_pos];
6540
6541 data.hash_mode = hash_mode;
6542 }
6543
6544 quiet = 1;
6545
6546 data.quiet = quiet;
6547 }
6548
6549 switch (hash_mode)
6550 {
6551 case 0: hash_type = HASH_TYPE_MD5;
6552 salt_type = SALT_TYPE_NONE;
6553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6554 opts_type = OPTS_TYPE_PT_GENERATE_LE
6555 | OPTS_TYPE_PT_ADD80
6556 | OPTS_TYPE_PT_ADDBITS14;
6557 kern_type = KERN_TYPE_MD5;
6558 dgst_size = DGST_SIZE_4_4;
6559 parse_func = md5_parse_hash;
6560 sort_by_digest = sort_by_digest_4_4;
6561 opti_type = OPTI_TYPE_ZERO_BYTE
6562 | OPTI_TYPE_PRECOMPUTE_INIT
6563 | OPTI_TYPE_PRECOMPUTE_MERKLE
6564 | OPTI_TYPE_MEET_IN_MIDDLE
6565 | OPTI_TYPE_EARLY_SKIP
6566 | OPTI_TYPE_NOT_ITERATED
6567 | OPTI_TYPE_NOT_SALTED
6568 | OPTI_TYPE_RAW_HASH;
6569 dgst_pos0 = 0;
6570 dgst_pos1 = 3;
6571 dgst_pos2 = 2;
6572 dgst_pos3 = 1;
6573 break;
6574
6575 case 10: hash_type = HASH_TYPE_MD5;
6576 salt_type = SALT_TYPE_INTERN;
6577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6578 opts_type = OPTS_TYPE_PT_GENERATE_LE
6579 | OPTS_TYPE_ST_ADD80
6580 | OPTS_TYPE_ST_ADDBITS14;
6581 kern_type = KERN_TYPE_MD5_PWSLT;
6582 dgst_size = DGST_SIZE_4_4;
6583 parse_func = md5s_parse_hash;
6584 sort_by_digest = sort_by_digest_4_4;
6585 opti_type = OPTI_TYPE_ZERO_BYTE
6586 | OPTI_TYPE_PRECOMPUTE_INIT
6587 | OPTI_TYPE_PRECOMPUTE_MERKLE
6588 | OPTI_TYPE_MEET_IN_MIDDLE
6589 | OPTI_TYPE_EARLY_SKIP
6590 | OPTI_TYPE_NOT_ITERATED
6591 | OPTI_TYPE_APPENDED_SALT
6592 | OPTI_TYPE_RAW_HASH;
6593 dgst_pos0 = 0;
6594 dgst_pos1 = 3;
6595 dgst_pos2 = 2;
6596 dgst_pos3 = 1;
6597 break;
6598
6599 case 11: hash_type = HASH_TYPE_MD5;
6600 salt_type = SALT_TYPE_INTERN;
6601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6602 opts_type = OPTS_TYPE_PT_GENERATE_LE
6603 | OPTS_TYPE_ST_ADD80
6604 | OPTS_TYPE_ST_ADDBITS14;
6605 kern_type = KERN_TYPE_MD5_PWSLT;
6606 dgst_size = DGST_SIZE_4_4;
6607 parse_func = joomla_parse_hash;
6608 sort_by_digest = sort_by_digest_4_4;
6609 opti_type = OPTI_TYPE_ZERO_BYTE
6610 | OPTI_TYPE_PRECOMPUTE_INIT
6611 | OPTI_TYPE_PRECOMPUTE_MERKLE
6612 | OPTI_TYPE_MEET_IN_MIDDLE
6613 | OPTI_TYPE_EARLY_SKIP
6614 | OPTI_TYPE_NOT_ITERATED
6615 | OPTI_TYPE_APPENDED_SALT
6616 | OPTI_TYPE_RAW_HASH;
6617 dgst_pos0 = 0;
6618 dgst_pos1 = 3;
6619 dgst_pos2 = 2;
6620 dgst_pos3 = 1;
6621 break;
6622
6623 case 12: hash_type = HASH_TYPE_MD5;
6624 salt_type = SALT_TYPE_INTERN;
6625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6626 opts_type = OPTS_TYPE_PT_GENERATE_LE
6627 | OPTS_TYPE_ST_ADD80
6628 | OPTS_TYPE_ST_ADDBITS14;
6629 kern_type = KERN_TYPE_MD5_PWSLT;
6630 dgst_size = DGST_SIZE_4_4;
6631 parse_func = postgresql_parse_hash;
6632 sort_by_digest = sort_by_digest_4_4;
6633 opti_type = OPTI_TYPE_ZERO_BYTE
6634 | OPTI_TYPE_PRECOMPUTE_INIT
6635 | OPTI_TYPE_PRECOMPUTE_MERKLE
6636 | OPTI_TYPE_MEET_IN_MIDDLE
6637 | OPTI_TYPE_EARLY_SKIP
6638 | OPTI_TYPE_NOT_ITERATED
6639 | OPTI_TYPE_APPENDED_SALT
6640 | OPTI_TYPE_RAW_HASH;
6641 dgst_pos0 = 0;
6642 dgst_pos1 = 3;
6643 dgst_pos2 = 2;
6644 dgst_pos3 = 1;
6645 break;
6646
6647 case 20: hash_type = HASH_TYPE_MD5;
6648 salt_type = SALT_TYPE_INTERN;
6649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6650 opts_type = OPTS_TYPE_PT_GENERATE_LE
6651 | OPTS_TYPE_PT_ADD80
6652 | OPTS_TYPE_PT_ADDBITS14;
6653 kern_type = KERN_TYPE_MD5_SLTPW;
6654 dgst_size = DGST_SIZE_4_4;
6655 parse_func = md5s_parse_hash;
6656 sort_by_digest = sort_by_digest_4_4;
6657 opti_type = OPTI_TYPE_ZERO_BYTE
6658 | OPTI_TYPE_PRECOMPUTE_INIT
6659 | OPTI_TYPE_PRECOMPUTE_MERKLE
6660 | OPTI_TYPE_EARLY_SKIP
6661 | OPTI_TYPE_NOT_ITERATED
6662 | OPTI_TYPE_PREPENDED_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 21: 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 = osc_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 22: hash_type = HASH_TYPE_MD5;
6694 salt_type = SALT_TYPE_EMBEDDED;
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 = netscreen_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 23: 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 = skype_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 30: hash_type = HASH_TYPE_MD5;
6740 salt_type = SALT_TYPE_INTERN;
6741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6742 opts_type = OPTS_TYPE_PT_GENERATE_LE
6743 | OPTS_TYPE_PT_UNICODE
6744 | OPTS_TYPE_ST_ADD80
6745 | OPTS_TYPE_ST_ADDBITS14;
6746 kern_type = KERN_TYPE_MD5_PWUSLT;
6747 dgst_size = DGST_SIZE_4_4;
6748 parse_func = md5s_parse_hash;
6749 sort_by_digest = sort_by_digest_4_4;
6750 opti_type = OPTI_TYPE_ZERO_BYTE
6751 | OPTI_TYPE_PRECOMPUTE_INIT
6752 | OPTI_TYPE_PRECOMPUTE_MERKLE
6753 | OPTI_TYPE_MEET_IN_MIDDLE
6754 | OPTI_TYPE_EARLY_SKIP
6755 | OPTI_TYPE_NOT_ITERATED
6756 | OPTI_TYPE_APPENDED_SALT
6757 | OPTI_TYPE_RAW_HASH;
6758 dgst_pos0 = 0;
6759 dgst_pos1 = 3;
6760 dgst_pos2 = 2;
6761 dgst_pos3 = 1;
6762 break;
6763
6764 case 40: hash_type = HASH_TYPE_MD5;
6765 salt_type = SALT_TYPE_INTERN;
6766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6767 opts_type = OPTS_TYPE_PT_GENERATE_LE
6768 | OPTS_TYPE_PT_ADD80
6769 | OPTS_TYPE_PT_ADDBITS14
6770 | OPTS_TYPE_PT_UNICODE;
6771 kern_type = KERN_TYPE_MD5_SLTPWU;
6772 dgst_size = DGST_SIZE_4_4;
6773 parse_func = md5s_parse_hash;
6774 sort_by_digest = sort_by_digest_4_4;
6775 opti_type = OPTI_TYPE_ZERO_BYTE
6776 | OPTI_TYPE_PRECOMPUTE_INIT
6777 | OPTI_TYPE_PRECOMPUTE_MERKLE
6778 | OPTI_TYPE_EARLY_SKIP
6779 | OPTI_TYPE_NOT_ITERATED
6780 | OPTI_TYPE_PREPENDED_SALT
6781 | OPTI_TYPE_RAW_HASH;
6782 dgst_pos0 = 0;
6783 dgst_pos1 = 3;
6784 dgst_pos2 = 2;
6785 dgst_pos3 = 1;
6786 break;
6787
6788 case 50: hash_type = HASH_TYPE_MD5;
6789 salt_type = SALT_TYPE_INTERN;
6790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6791 opts_type = OPTS_TYPE_PT_GENERATE_LE
6792 | OPTS_TYPE_ST_ADD80
6793 | OPTS_TYPE_ST_ADDBITS14;
6794 kern_type = KERN_TYPE_HMACMD5_PW;
6795 dgst_size = DGST_SIZE_4_4;
6796 parse_func = hmacmd5_parse_hash;
6797 sort_by_digest = sort_by_digest_4_4;
6798 opti_type = OPTI_TYPE_ZERO_BYTE
6799 | OPTI_TYPE_NOT_ITERATED;
6800 dgst_pos0 = 0;
6801 dgst_pos1 = 3;
6802 dgst_pos2 = 2;
6803 dgst_pos3 = 1;
6804 break;
6805
6806 case 60: hash_type = HASH_TYPE_MD5;
6807 salt_type = SALT_TYPE_INTERN;
6808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6809 opts_type = OPTS_TYPE_PT_GENERATE_LE
6810 | OPTS_TYPE_PT_ADD80
6811 | OPTS_TYPE_PT_ADDBITS14;
6812 kern_type = KERN_TYPE_HMACMD5_SLT;
6813 dgst_size = DGST_SIZE_4_4;
6814 parse_func = hmacmd5_parse_hash;
6815 sort_by_digest = sort_by_digest_4_4;
6816 opti_type = OPTI_TYPE_ZERO_BYTE
6817 | OPTI_TYPE_NOT_ITERATED;
6818 dgst_pos0 = 0;
6819 dgst_pos1 = 3;
6820 dgst_pos2 = 2;
6821 dgst_pos3 = 1;
6822 break;
6823
6824 case 100: hash_type = HASH_TYPE_SHA1;
6825 salt_type = SALT_TYPE_NONE;
6826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6827 opts_type = OPTS_TYPE_PT_GENERATE_BE
6828 | OPTS_TYPE_PT_ADD80
6829 | OPTS_TYPE_PT_ADDBITS15;
6830 kern_type = KERN_TYPE_SHA1;
6831 dgst_size = DGST_SIZE_4_5;
6832 parse_func = sha1_parse_hash;
6833 sort_by_digest = sort_by_digest_4_5;
6834 opti_type = OPTI_TYPE_ZERO_BYTE
6835 | OPTI_TYPE_PRECOMPUTE_INIT
6836 | OPTI_TYPE_PRECOMPUTE_MERKLE
6837 | OPTI_TYPE_EARLY_SKIP
6838 | OPTI_TYPE_NOT_ITERATED
6839 | OPTI_TYPE_NOT_SALTED
6840 | OPTI_TYPE_RAW_HASH;
6841 dgst_pos0 = 3;
6842 dgst_pos1 = 4;
6843 dgst_pos2 = 2;
6844 dgst_pos3 = 1;
6845 break;
6846
6847 case 101: 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 = sha1b64_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 110: hash_type = HASH_TYPE_SHA1;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_BE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1_PWSLT;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1s_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_APPENDED_SALT
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 111: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_EMBEDDED;
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 = sha1b64s_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 112: hash_type = HASH_TYPE_SHA1;
6917 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_ST_HEX;
6923 kern_type = KERN_TYPE_SHA1_PWSLT;
6924 dgst_size = DGST_SIZE_4_5;
6925 parse_func = oracles_parse_hash;
6926 sort_by_digest = sort_by_digest_4_5;
6927 opti_type = OPTI_TYPE_ZERO_BYTE
6928 | OPTI_TYPE_PRECOMPUTE_INIT
6929 | OPTI_TYPE_PRECOMPUTE_MERKLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_APPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 3;
6935 dgst_pos1 = 4;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 120: hash_type = HASH_TYPE_SHA1;
6941 salt_type = SALT_TYPE_INTERN;
6942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6943 opts_type = OPTS_TYPE_PT_GENERATE_BE
6944 | OPTS_TYPE_PT_ADD80
6945 | OPTS_TYPE_PT_ADDBITS15;
6946 kern_type = KERN_TYPE_SHA1_SLTPW;
6947 dgst_size = DGST_SIZE_4_5;
6948 parse_func = sha1s_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_PREPENDED_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 121: 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 | OPTS_TYPE_ST_LOWER;
6970 kern_type = KERN_TYPE_SHA1_SLTPW;
6971 dgst_size = DGST_SIZE_4_5;
6972 parse_func = smf_parse_hash;
6973 sort_by_digest = sort_by_digest_4_5;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_PREPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 3;
6982 dgst_pos1 = 4;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 122: hash_type = HASH_TYPE_SHA1;
6988 salt_type = SALT_TYPE_EMBEDDED;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_BE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS15
6993 | OPTS_TYPE_ST_HEX;
6994 kern_type = KERN_TYPE_SHA1_SLTPW;
6995 dgst_size = DGST_SIZE_4_5;
6996 parse_func = osx1_parse_hash;
6997 sort_by_digest = sort_by_digest_4_5;
6998 opti_type = OPTI_TYPE_ZERO_BYTE
6999 | OPTI_TYPE_PRECOMPUTE_INIT
7000 | OPTI_TYPE_PRECOMPUTE_MERKLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_PREPENDED_SALT
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 3;
7006 dgst_pos1 = 4;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 124: hash_type = HASH_TYPE_SHA1;
7012 salt_type = SALT_TYPE_EMBEDDED;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_BE
7015 | OPTS_TYPE_PT_ADD80
7016 | OPTS_TYPE_PT_ADDBITS15;
7017 kern_type = KERN_TYPE_SHA1_SLTPW;
7018 dgst_size = DGST_SIZE_4_5;
7019 parse_func = djangosha1_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 130: hash_type = HASH_TYPE_SHA1;
7035 salt_type = SALT_TYPE_INTERN;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_BE
7038 | OPTS_TYPE_PT_UNICODE
7039 | OPTS_TYPE_ST_ADD80
7040 | OPTS_TYPE_ST_ADDBITS15;
7041 kern_type = KERN_TYPE_SHA1_PWUSLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = sha1s_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_APPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 3;
7053 dgst_pos1 = 4;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 131: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_EMBEDDED;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_PT_UNICODE
7063 | OPTS_TYPE_PT_UPPER
7064 | OPTS_TYPE_ST_ADD80
7065 | OPTS_TYPE_ST_ADDBITS15
7066 | OPTS_TYPE_ST_HEX;
7067 kern_type = KERN_TYPE_SHA1_PWUSLT;
7068 dgst_size = DGST_SIZE_4_5;
7069 parse_func = mssql2000_parse_hash;
7070 sort_by_digest = sort_by_digest_4_5;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_APPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 3;
7079 dgst_pos1 = 4;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 132: hash_type = HASH_TYPE_SHA1;
7085 salt_type = SALT_TYPE_EMBEDDED;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_BE
7088 | OPTS_TYPE_PT_UNICODE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS15
7091 | OPTS_TYPE_ST_HEX;
7092 kern_type = KERN_TYPE_SHA1_PWUSLT;
7093 dgst_size = DGST_SIZE_4_5;
7094 parse_func = mssql2005_parse_hash;
7095 sort_by_digest = sort_by_digest_4_5;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_EARLY_SKIP
7100 | OPTI_TYPE_NOT_ITERATED
7101 | OPTI_TYPE_APPENDED_SALT
7102 | OPTI_TYPE_RAW_HASH;
7103 dgst_pos0 = 3;
7104 dgst_pos1 = 4;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 133: hash_type = HASH_TYPE_SHA1;
7110 salt_type = SALT_TYPE_EMBEDDED;
7111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7112 opts_type = OPTS_TYPE_PT_GENERATE_BE
7113 | OPTS_TYPE_PT_UNICODE
7114 | OPTS_TYPE_ST_ADD80
7115 | OPTS_TYPE_ST_ADDBITS15;
7116 kern_type = KERN_TYPE_SHA1_PWUSLT;
7117 dgst_size = DGST_SIZE_4_5;
7118 parse_func = peoplesoft_parse_hash;
7119 sort_by_digest = sort_by_digest_4_5;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_EARLY_SKIP
7124 | OPTI_TYPE_NOT_ITERATED
7125 | OPTI_TYPE_APPENDED_SALT
7126 | OPTI_TYPE_RAW_HASH;
7127 dgst_pos0 = 3;
7128 dgst_pos1 = 4;
7129 dgst_pos2 = 2;
7130 dgst_pos3 = 1;
7131 break;
7132
7133 case 140: hash_type = HASH_TYPE_SHA1;
7134 salt_type = SALT_TYPE_INTERN;
7135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7136 opts_type = OPTS_TYPE_PT_GENERATE_BE
7137 | OPTS_TYPE_PT_ADD80
7138 | OPTS_TYPE_PT_ADDBITS15
7139 | OPTS_TYPE_PT_UNICODE;
7140 kern_type = KERN_TYPE_SHA1_SLTPWU;
7141 dgst_size = DGST_SIZE_4_5;
7142 parse_func = sha1s_parse_hash;
7143 sort_by_digest = sort_by_digest_4_5;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_PREPENDED_SALT
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 3;
7152 dgst_pos1 = 4;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 141: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_EMBEDDED;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS15
7163 | OPTS_TYPE_PT_UNICODE
7164 | OPTS_TYPE_ST_BASE64;
7165 kern_type = KERN_TYPE_SHA1_SLTPWU;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = episerver_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_PREPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 150: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_INTERN;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_ST_ADD80
7187 | OPTS_TYPE_ST_ADDBITS15;
7188 kern_type = KERN_TYPE_HMACSHA1_PW;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = hmacsha1_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_NOT_ITERATED;
7194 dgst_pos0 = 3;
7195 dgst_pos1 = 4;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 160: hash_type = HASH_TYPE_SHA1;
7201 salt_type = SALT_TYPE_INTERN;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_BE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS15;
7206 kern_type = KERN_TYPE_HMACSHA1_SLT;
7207 dgst_size = DGST_SIZE_4_5;
7208 parse_func = hmacsha1_parse_hash;
7209 sort_by_digest = sort_by_digest_4_5;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_NOT_ITERATED;
7212 dgst_pos0 = 3;
7213 dgst_pos1 = 4;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 190: hash_type = HASH_TYPE_SHA1;
7219 salt_type = SALT_TYPE_NONE;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_BE
7222 | OPTS_TYPE_PT_ADD80
7223 | OPTS_TYPE_PT_ADDBITS15;
7224 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = sha1linkedin_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_EARLY_SKIP
7231 | OPTI_TYPE_NOT_ITERATED
7232 | OPTI_TYPE_NOT_SALTED;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 4;
7235 dgst_pos2 = 3;
7236 dgst_pos3 = 2;
7237 break;
7238
7239 case 200: hash_type = HASH_TYPE_MYSQL;
7240 salt_type = SALT_TYPE_NONE;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = 0;
7243 kern_type = KERN_TYPE_MYSQL;
7244 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7245 parse_func = mysql323_parse_hash;
7246 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7247 opti_type = OPTI_TYPE_ZERO_BYTE;
7248 dgst_pos0 = 0;
7249 dgst_pos1 = 1;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 3;
7252 break;
7253
7254 case 300: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_NONE;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15;
7260 kern_type = KERN_TYPE_MYSQL41;
7261 dgst_size = DGST_SIZE_4_5;
7262 parse_func = sha1_parse_hash;
7263 sort_by_digest = sort_by_digest_4_5;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_NOT_SALTED;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 400: hash_type = HASH_TYPE_MD5;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7280 kern_type = KERN_TYPE_PHPASS;
7281 dgst_size = DGST_SIZE_4_4;
7282 parse_func = phpass_parse_hash;
7283 sort_by_digest = sort_by_digest_4_4;
7284 opti_type = OPTI_TYPE_ZERO_BYTE;
7285 dgst_pos0 = 0;
7286 dgst_pos1 = 1;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 3;
7289 break;
7290
7291 case 500: hash_type = HASH_TYPE_MD5;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7295 kern_type = KERN_TYPE_MD5CRYPT;
7296 dgst_size = DGST_SIZE_4_4;
7297 parse_func = md5crypt_parse_hash;
7298 sort_by_digest = sort_by_digest_4_4;
7299 opti_type = OPTI_TYPE_ZERO_BYTE;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 1;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 3;
7304 break;
7305
7306 case 501: hash_type = HASH_TYPE_MD5;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_LE
7310 | OPTS_TYPE_HASH_COPY;
7311 kern_type = KERN_TYPE_MD5CRYPT;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = juniper_parse_hash;
7314 sort_by_digest = sort_by_digest_4_4;
7315 opti_type = OPTI_TYPE_ZERO_BYTE;
7316 dgst_pos0 = 0;
7317 dgst_pos1 = 1;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 3;
7320 break;
7321
7322 case 900: hash_type = HASH_TYPE_MD4;
7323 salt_type = SALT_TYPE_NONE;
7324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7325 opts_type = OPTS_TYPE_PT_GENERATE_LE
7326 | OPTS_TYPE_PT_ADD80
7327 | OPTS_TYPE_PT_ADDBITS14;
7328 kern_type = KERN_TYPE_MD4;
7329 dgst_size = DGST_SIZE_4_4;
7330 parse_func = md4_parse_hash;
7331 sort_by_digest = sort_by_digest_4_4;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_MEET_IN_MIDDLE
7336 | OPTI_TYPE_EARLY_SKIP
7337 | OPTI_TYPE_NOT_ITERATED
7338 | OPTI_TYPE_NOT_SALTED
7339 | OPTI_TYPE_RAW_HASH;
7340 dgst_pos0 = 0;
7341 dgst_pos1 = 3;
7342 dgst_pos2 = 2;
7343 dgst_pos3 = 1;
7344 break;
7345
7346 case 1000: hash_type = HASH_TYPE_MD4;
7347 salt_type = SALT_TYPE_NONE;
7348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7349 opts_type = OPTS_TYPE_PT_GENERATE_LE
7350 | OPTS_TYPE_PT_ADD80
7351 | OPTS_TYPE_PT_ADDBITS14
7352 | OPTS_TYPE_PT_UNICODE;
7353 kern_type = KERN_TYPE_MD4_PWU;
7354 dgst_size = DGST_SIZE_4_4;
7355 parse_func = md4_parse_hash;
7356 sort_by_digest = sort_by_digest_4_4;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_MEET_IN_MIDDLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_NOT_SALTED
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 0;
7366 dgst_pos1 = 3;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 1100: hash_type = HASH_TYPE_MD4;
7372 salt_type = SALT_TYPE_INTERN;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_LE
7375 | OPTS_TYPE_PT_ADD80
7376 | OPTS_TYPE_PT_ADDBITS14
7377 | OPTS_TYPE_PT_UNICODE
7378 | OPTS_TYPE_ST_ADD80
7379 | OPTS_TYPE_ST_UNICODE
7380 | OPTS_TYPE_ST_LOWER;
7381 kern_type = KERN_TYPE_MD44_PWUSLT;
7382 dgst_size = DGST_SIZE_4_4;
7383 parse_func = dcc_parse_hash;
7384 sort_by_digest = sort_by_digest_4_4;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED;
7390 dgst_pos0 = 0;
7391 dgst_pos1 = 3;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 1400: hash_type = HASH_TYPE_SHA256;
7397 salt_type = SALT_TYPE_NONE;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_ADD80
7401 | OPTS_TYPE_PT_ADDBITS15;
7402 kern_type = KERN_TYPE_SHA256;
7403 dgst_size = DGST_SIZE_4_8;
7404 parse_func = sha256_parse_hash;
7405 sort_by_digest = sort_by_digest_4_8;
7406 opti_type = OPTI_TYPE_ZERO_BYTE
7407 | OPTI_TYPE_PRECOMPUTE_INIT
7408 | OPTI_TYPE_PRECOMPUTE_MERKLE
7409 | OPTI_TYPE_EARLY_SKIP
7410 | OPTI_TYPE_NOT_ITERATED
7411 | OPTI_TYPE_NOT_SALTED
7412 | OPTI_TYPE_RAW_HASH;
7413 dgst_pos0 = 3;
7414 dgst_pos1 = 7;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 6;
7417 break;
7418
7419 case 1410: hash_type = HASH_TYPE_SHA256;
7420 salt_type = SALT_TYPE_INTERN;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_ST_ADD80
7424 | OPTS_TYPE_ST_ADDBITS15;
7425 kern_type = KERN_TYPE_SHA256_PWSLT;
7426 dgst_size = DGST_SIZE_4_8;
7427 parse_func = sha256s_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_APPENDED_SALT
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 1420: 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_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15;
7448 kern_type = KERN_TYPE_SHA256_SLTPW;
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_PREPENDED_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 1421: hash_type = HASH_TYPE_SHA256;
7466 salt_type = SALT_TYPE_EMBEDDED;
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 = hmailserver_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 1430: hash_type = HASH_TYPE_SHA256;
7489 salt_type = SALT_TYPE_INTERN;
7490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7491 opts_type = OPTS_TYPE_PT_GENERATE_BE
7492 | OPTS_TYPE_PT_UNICODE
7493 | OPTS_TYPE_ST_ADD80
7494 | OPTS_TYPE_ST_ADDBITS15;
7495 kern_type = KERN_TYPE_SHA256_PWUSLT;
7496 dgst_size = DGST_SIZE_4_8;
7497 parse_func = sha256s_parse_hash;
7498 sort_by_digest = sort_by_digest_4_8;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_PRECOMPUTE_MERKLE
7502 | OPTI_TYPE_EARLY_SKIP
7503 | OPTI_TYPE_NOT_ITERATED
7504 | OPTI_TYPE_APPENDED_SALT
7505 | OPTI_TYPE_RAW_HASH;
7506 dgst_pos0 = 3;
7507 dgst_pos1 = 7;
7508 dgst_pos2 = 2;
7509 dgst_pos3 = 6;
7510 break;
7511
7512 case 1440: hash_type = HASH_TYPE_SHA256;
7513 salt_type = SALT_TYPE_INTERN;
7514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7515 opts_type = OPTS_TYPE_PT_GENERATE_BE
7516 | OPTS_TYPE_PT_ADD80
7517 | OPTS_TYPE_PT_ADDBITS15
7518 | OPTS_TYPE_PT_UNICODE;
7519 kern_type = KERN_TYPE_SHA256_SLTPWU;
7520 dgst_size = DGST_SIZE_4_8;
7521 parse_func = sha256s_parse_hash;
7522 sort_by_digest = sort_by_digest_4_8;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED
7528 | OPTI_TYPE_PREPENDED_SALT
7529 | OPTI_TYPE_RAW_HASH;
7530 dgst_pos0 = 3;
7531 dgst_pos1 = 7;
7532 dgst_pos2 = 2;
7533 dgst_pos3 = 6;
7534 break;
7535
7536 case 1441: hash_type = HASH_TYPE_SHA256;
7537 salt_type = SALT_TYPE_EMBEDDED;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = OPTS_TYPE_PT_GENERATE_BE
7540 | OPTS_TYPE_PT_ADD80
7541 | OPTS_TYPE_PT_ADDBITS15
7542 | OPTS_TYPE_PT_UNICODE
7543 | OPTS_TYPE_ST_BASE64;
7544 kern_type = KERN_TYPE_SHA256_SLTPWU;
7545 dgst_size = DGST_SIZE_4_8;
7546 parse_func = episerver4_parse_hash;
7547 sort_by_digest = sort_by_digest_4_8;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_PRECOMPUTE_INIT
7550 | OPTI_TYPE_PRECOMPUTE_MERKLE
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_PREPENDED_SALT
7554 | OPTI_TYPE_RAW_HASH;
7555 dgst_pos0 = 3;
7556 dgst_pos1 = 7;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 6;
7559 break;
7560
7561 case 1450: hash_type = HASH_TYPE_SHA256;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_BE
7565 | OPTS_TYPE_ST_ADD80;
7566 kern_type = KERN_TYPE_HMACSHA256_PW;
7567 dgst_size = DGST_SIZE_4_8;
7568 parse_func = hmacsha256_parse_hash;
7569 sort_by_digest = sort_by_digest_4_8;
7570 opti_type = OPTI_TYPE_ZERO_BYTE
7571 | OPTI_TYPE_NOT_ITERATED;
7572 dgst_pos0 = 3;
7573 dgst_pos1 = 7;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 6;
7576 break;
7577
7578 case 1460: hash_type = HASH_TYPE_SHA256;
7579 salt_type = SALT_TYPE_INTERN;
7580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_BE
7582 | OPTS_TYPE_PT_ADD80
7583 | OPTS_TYPE_PT_ADDBITS15;
7584 kern_type = KERN_TYPE_HMACSHA256_SLT;
7585 dgst_size = DGST_SIZE_4_8;
7586 parse_func = hmacsha256_parse_hash;
7587 sort_by_digest = sort_by_digest_4_8;
7588 opti_type = OPTI_TYPE_ZERO_BYTE
7589 | OPTI_TYPE_NOT_ITERATED;
7590 dgst_pos0 = 3;
7591 dgst_pos1 = 7;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 6;
7594 break;
7595
7596 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7597 salt_type = SALT_TYPE_EMBEDDED;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_LE
7600 | OPTS_TYPE_PT_BITSLICE;
7601 kern_type = KERN_TYPE_DESCRYPT;
7602 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7603 parse_func = descrypt_parse_hash;
7604 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 1;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 3;
7611 break;
7612
7613 case 1600: hash_type = HASH_TYPE_MD5;
7614 salt_type = SALT_TYPE_EMBEDDED;
7615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7617 kern_type = KERN_TYPE_APR1CRYPT;
7618 dgst_size = DGST_SIZE_4_4;
7619 parse_func = md5apr1_parse_hash;
7620 sort_by_digest = sort_by_digest_4_4;
7621 opti_type = OPTI_TYPE_ZERO_BYTE;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 1;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 3;
7626 break;
7627
7628 case 1700: hash_type = HASH_TYPE_SHA512;
7629 salt_type = SALT_TYPE_NONE;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_BE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS15;
7634 kern_type = KERN_TYPE_SHA512;
7635 dgst_size = DGST_SIZE_8_8;
7636 parse_func = sha512_parse_hash;
7637 sort_by_digest = sort_by_digest_8_8;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_NOT_SALTED
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 14;
7646 dgst_pos1 = 15;
7647 dgst_pos2 = 6;
7648 dgst_pos3 = 7;
7649 break;
7650
7651 case 1710: hash_type = HASH_TYPE_SHA512;
7652 salt_type = SALT_TYPE_INTERN;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_ST_ADD80
7656 | OPTS_TYPE_ST_ADDBITS15;
7657 kern_type = KERN_TYPE_SHA512_PWSLT;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = sha512s_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_APPENDED_SALT
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 1711: hash_type = HASH_TYPE_SHA512;
7675 salt_type = SALT_TYPE_EMBEDDED;
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 = sha512b64s_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 1720: hash_type = HASH_TYPE_SHA512;
7698 salt_type = SALT_TYPE_INTERN;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_PT_ADD80
7702 | OPTS_TYPE_PT_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA512_SLTPW;
7704 dgst_size = DGST_SIZE_8_8;
7705 parse_func = sha512s_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_PREPENDED_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 1722: hash_type = HASH_TYPE_SHA512;
7721 salt_type = SALT_TYPE_EMBEDDED;
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 | OPTS_TYPE_ST_HEX;
7727 kern_type = KERN_TYPE_SHA512_SLTPW;
7728 dgst_size = DGST_SIZE_8_8;
7729 parse_func = osx512_parse_hash;
7730 sort_by_digest = sort_by_digest_8_8;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED
7736 | OPTI_TYPE_PREPENDED_SALT
7737 | OPTI_TYPE_RAW_HASH;
7738 dgst_pos0 = 14;
7739 dgst_pos1 = 15;
7740 dgst_pos2 = 6;
7741 dgst_pos3 = 7;
7742 break;
7743
7744 case 1730: hash_type = HASH_TYPE_SHA512;
7745 salt_type = SALT_TYPE_INTERN;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_UNICODE
7749 | OPTS_TYPE_ST_ADD80
7750 | OPTS_TYPE_ST_ADDBITS15;
7751 kern_type = KERN_TYPE_SHA512_PWSLTU;
7752 dgst_size = DGST_SIZE_8_8;
7753 parse_func = sha512s_parse_hash;
7754 sort_by_digest = sort_by_digest_8_8;
7755 opti_type = OPTI_TYPE_ZERO_BYTE
7756 | OPTI_TYPE_PRECOMPUTE_INIT
7757 | OPTI_TYPE_PRECOMPUTE_MERKLE
7758 | OPTI_TYPE_EARLY_SKIP
7759 | OPTI_TYPE_NOT_ITERATED
7760 | OPTI_TYPE_APPENDED_SALT
7761 | OPTI_TYPE_RAW_HASH;
7762 dgst_pos0 = 14;
7763 dgst_pos1 = 15;
7764 dgst_pos2 = 6;
7765 dgst_pos3 = 7;
7766 break;
7767
7768 case 1731: hash_type = HASH_TYPE_SHA512;
7769 salt_type = SALT_TYPE_EMBEDDED;
7770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7771 opts_type = OPTS_TYPE_PT_GENERATE_BE
7772 | OPTS_TYPE_PT_UNICODE
7773 | OPTS_TYPE_ST_ADD80
7774 | OPTS_TYPE_ST_ADDBITS15
7775 | OPTS_TYPE_ST_HEX;
7776 kern_type = KERN_TYPE_SHA512_PWSLTU;
7777 dgst_size = DGST_SIZE_8_8;
7778 parse_func = mssql2012_parse_hash;
7779 sort_by_digest = sort_by_digest_8_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_APPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 14;
7788 dgst_pos1 = 15;
7789 dgst_pos2 = 6;
7790 dgst_pos3 = 7;
7791 break;
7792
7793 case 1740: hash_type = HASH_TYPE_SHA512;
7794 salt_type = SALT_TYPE_INTERN;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15
7799 | OPTS_TYPE_PT_UNICODE;
7800 kern_type = KERN_TYPE_SHA512_SLTPWU;
7801 dgst_size = DGST_SIZE_8_8;
7802 parse_func = sha512s_parse_hash;
7803 sort_by_digest = sort_by_digest_8_8;
7804 opti_type = OPTI_TYPE_ZERO_BYTE
7805 | OPTI_TYPE_PRECOMPUTE_INIT
7806 | OPTI_TYPE_PRECOMPUTE_MERKLE
7807 | OPTI_TYPE_EARLY_SKIP
7808 | OPTI_TYPE_NOT_ITERATED
7809 | OPTI_TYPE_PREPENDED_SALT
7810 | OPTI_TYPE_RAW_HASH;
7811 dgst_pos0 = 14;
7812 dgst_pos1 = 15;
7813 dgst_pos2 = 6;
7814 dgst_pos3 = 7;
7815 break;
7816
7817 case 1750: hash_type = HASH_TYPE_SHA512;
7818 salt_type = SALT_TYPE_INTERN;
7819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7820 opts_type = OPTS_TYPE_PT_GENERATE_BE
7821 | OPTS_TYPE_ST_ADD80;
7822 kern_type = KERN_TYPE_HMACSHA512_PW;
7823 dgst_size = DGST_SIZE_8_8;
7824 parse_func = hmacsha512_parse_hash;
7825 sort_by_digest = sort_by_digest_8_8;
7826 opti_type = OPTI_TYPE_ZERO_BYTE
7827 | OPTI_TYPE_NOT_ITERATED;
7828 dgst_pos0 = 14;
7829 dgst_pos1 = 15;
7830 dgst_pos2 = 6;
7831 dgst_pos3 = 7;
7832 break;
7833
7834 case 1760: hash_type = HASH_TYPE_SHA512;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS15;
7840 kern_type = KERN_TYPE_HMACSHA512_SLT;
7841 dgst_size = DGST_SIZE_8_8;
7842 parse_func = hmacsha512_parse_hash;
7843 sort_by_digest = sort_by_digest_8_8;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_NOT_ITERATED;
7846 dgst_pos0 = 14;
7847 dgst_pos1 = 15;
7848 dgst_pos2 = 6;
7849 dgst_pos3 = 7;
7850 break;
7851
7852 case 1800: hash_type = HASH_TYPE_SHA512;
7853 salt_type = SALT_TYPE_EMBEDDED;
7854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7856 kern_type = KERN_TYPE_SHA512CRYPT;
7857 dgst_size = DGST_SIZE_8_8;
7858 parse_func = sha512crypt_parse_hash;
7859 sort_by_digest = sort_by_digest_8_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE;
7861 dgst_pos0 = 0;
7862 dgst_pos1 = 1;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 3;
7865 break;
7866
7867 case 2100: hash_type = HASH_TYPE_DCC2;
7868 salt_type = SALT_TYPE_EMBEDDED;
7869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7871 | OPTS_TYPE_ST_LOWER
7872 | OPTS_TYPE_ST_UNICODE;
7873 kern_type = KERN_TYPE_DCC2;
7874 dgst_size = DGST_SIZE_4_4;
7875 parse_func = dcc2_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4;
7877 opti_type = OPTI_TYPE_ZERO_BYTE;
7878 dgst_pos0 = 0;
7879 dgst_pos1 = 1;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 3;
7882 break;
7883
7884 case 2400: hash_type = HASH_TYPE_MD5;
7885 salt_type = SALT_TYPE_NONE;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7888 kern_type = KERN_TYPE_MD5PIX;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = md5pix_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_NOT_SALTED;
7898 dgst_pos0 = 0;
7899 dgst_pos1 = 3;
7900 dgst_pos2 = 2;
7901 dgst_pos3 = 1;
7902 break;
7903
7904 case 2410: hash_type = HASH_TYPE_MD5;
7905 salt_type = SALT_TYPE_INTERN;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7908 kern_type = KERN_TYPE_MD5ASA;
7909 dgst_size = DGST_SIZE_4_4;
7910 parse_func = md5asa_parse_hash;
7911 sort_by_digest = sort_by_digest_4_4;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED;
7917 dgst_pos0 = 0;
7918 dgst_pos1 = 3;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 1;
7921 break;
7922
7923 case 2500: hash_type = HASH_TYPE_WPA;
7924 salt_type = SALT_TYPE_EMBEDDED;
7925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7927 kern_type = KERN_TYPE_WPA;
7928 dgst_size = DGST_SIZE_4_4;
7929 parse_func = wpa_parse_hash;
7930 sort_by_digest = sort_by_digest_4_4;
7931 opti_type = OPTI_TYPE_ZERO_BYTE;
7932 dgst_pos0 = 0;
7933 dgst_pos1 = 1;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 3;
7936 break;
7937
7938 case 2600: hash_type = HASH_TYPE_MD5;
7939 salt_type = SALT_TYPE_VIRTUAL;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_LE
7942 | OPTS_TYPE_PT_ADD80
7943 | OPTS_TYPE_PT_ADDBITS14
7944 | OPTS_TYPE_ST_ADD80;
7945 kern_type = KERN_TYPE_MD55_PWSLT1;
7946 dgst_size = DGST_SIZE_4_4;
7947 parse_func = md5md5_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4;
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_INIT
7951 | OPTI_TYPE_PRECOMPUTE_MERKLE
7952 | OPTI_TYPE_EARLY_SKIP;
7953 dgst_pos0 = 0;
7954 dgst_pos1 = 3;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 2611: hash_type = HASH_TYPE_MD5;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS14
7965 | OPTS_TYPE_ST_ADD80;
7966 kern_type = KERN_TYPE_MD55_PWSLT1;
7967 dgst_size = DGST_SIZE_4_4;
7968 parse_func = vb3_parse_hash;
7969 sort_by_digest = sort_by_digest_4_4;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP;
7974 dgst_pos0 = 0;
7975 dgst_pos1 = 3;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 1;
7978 break;
7979
7980 case 2612: hash_type = HASH_TYPE_MD5;
7981 salt_type = SALT_TYPE_EMBEDDED;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_LE
7984 | OPTS_TYPE_PT_ADD80
7985 | OPTS_TYPE_PT_ADDBITS14
7986 | OPTS_TYPE_ST_ADD80
7987 | OPTS_TYPE_ST_HEX;
7988 kern_type = KERN_TYPE_MD55_PWSLT1;
7989 dgst_size = DGST_SIZE_4_4;
7990 parse_func = phps_parse_hash;
7991 sort_by_digest = sort_by_digest_4_4;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_PRECOMPUTE_INIT
7994 | OPTI_TYPE_PRECOMPUTE_MERKLE
7995 | OPTI_TYPE_EARLY_SKIP;
7996 dgst_pos0 = 0;
7997 dgst_pos1 = 3;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 1;
8000 break;
8001
8002 case 2711: hash_type = HASH_TYPE_MD5;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_LE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS14
8008 | OPTS_TYPE_ST_ADD80;
8009 kern_type = KERN_TYPE_MD55_PWSLT2;
8010 dgst_size = DGST_SIZE_4_4;
8011 parse_func = vb30_parse_hash;
8012 sort_by_digest = sort_by_digest_4_4;
8013 opti_type = OPTI_TYPE_ZERO_BYTE
8014 | OPTI_TYPE_PRECOMPUTE_INIT
8015 | OPTI_TYPE_EARLY_SKIP;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 3;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 1;
8020 break;
8021
8022 case 2811: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS14;
8028 kern_type = KERN_TYPE_MD55_SLTPW;
8029 dgst_size = DGST_SIZE_4_4;
8030 parse_func = ipb2_parse_hash;
8031 sort_by_digest = sort_by_digest_4_4;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_EARLY_SKIP;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 3;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 1;
8039 break;
8040
8041 case 3000: hash_type = HASH_TYPE_LM;
8042 salt_type = SALT_TYPE_NONE;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_PT_UPPER
8046 | OPTS_TYPE_PT_BITSLICE;
8047 kern_type = KERN_TYPE_LM;
8048 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8049 parse_func = lm_parse_hash;
8050 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8053 dgst_pos0 = 0;
8054 dgst_pos1 = 1;
8055 dgst_pos2 = 2;
8056 dgst_pos3 = 3;
8057 break;
8058
8059 case 3100: hash_type = HASH_TYPE_ORACLEH;
8060 salt_type = SALT_TYPE_INTERN;
8061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8062 opts_type = OPTS_TYPE_PT_GENERATE_LE
8063 | OPTS_TYPE_PT_UPPER
8064 | OPTS_TYPE_ST_UPPER;
8065 kern_type = KERN_TYPE_ORACLEH;
8066 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8067 parse_func = oracleh_parse_hash;
8068 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8069 opti_type = OPTI_TYPE_ZERO_BYTE;
8070 dgst_pos0 = 0;
8071 dgst_pos1 = 1;
8072 dgst_pos2 = 2;
8073 dgst_pos3 = 3;
8074 break;
8075
8076 case 3200: hash_type = HASH_TYPE_BCRYPT;
8077 salt_type = SALT_TYPE_EMBEDDED;
8078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_LE
8080 | OPTS_TYPE_ST_GENERATE_LE;
8081 kern_type = KERN_TYPE_BCRYPT;
8082 dgst_size = DGST_SIZE_4_6;
8083 parse_func = bcrypt_parse_hash;
8084 sort_by_digest = sort_by_digest_4_6;
8085 opti_type = OPTI_TYPE_ZERO_BYTE;
8086 dgst_pos0 = 0;
8087 dgst_pos1 = 1;
8088 dgst_pos2 = 2;
8089 dgst_pos3 = 3;
8090 break;
8091
8092 case 3710: hash_type = HASH_TYPE_MD5;
8093 salt_type = SALT_TYPE_INTERN;
8094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_LE
8096 | OPTS_TYPE_PT_ADD80
8097 | OPTS_TYPE_PT_ADDBITS14;
8098 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = md5s_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP;
8106 dgst_pos0 = 0;
8107 dgst_pos1 = 3;
8108 dgst_pos2 = 2;
8109 dgst_pos3 = 1;
8110 break;
8111
8112 case 3711: hash_type = HASH_TYPE_MD5;
8113 salt_type = SALT_TYPE_EMBEDDED;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_LE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS14;
8118 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8119 dgst_size = DGST_SIZE_4_4;
8120 parse_func = mediawiki_b_parse_hash;
8121 sort_by_digest = sort_by_digest_4_4;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_PRECOMPUTE_INIT
8124 | OPTI_TYPE_PRECOMPUTE_MERKLE
8125 | OPTI_TYPE_EARLY_SKIP;
8126 dgst_pos0 = 0;
8127 dgst_pos1 = 3;
8128 dgst_pos2 = 2;
8129 dgst_pos3 = 1;
8130 break;
8131
8132 case 3800: hash_type = HASH_TYPE_MD5;
8133 salt_type = SALT_TYPE_INTERN;
8134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8135 opts_type = OPTS_TYPE_PT_GENERATE_LE
8136 | OPTS_TYPE_ST_ADDBITS14;
8137 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8138 dgst_size = DGST_SIZE_4_4;
8139 parse_func = md5s_parse_hash;
8140 sort_by_digest = sort_by_digest_4_4;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_INIT
8143 | OPTI_TYPE_PRECOMPUTE_MERKLE
8144 | OPTI_TYPE_EARLY_SKIP
8145 | OPTI_TYPE_NOT_ITERATED
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 0;
8148 dgst_pos1 = 3;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 1;
8151 break;
8152
8153 case 4300: hash_type = HASH_TYPE_MD5;
8154 salt_type = SALT_TYPE_VIRTUAL;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_LE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS14
8159 | OPTS_TYPE_ST_ADD80;
8160 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md5md5_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 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174
8175 case 4400: hash_type = HASH_TYPE_MD5;
8176 salt_type = SALT_TYPE_NONE;
8177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_BE
8179 | OPTS_TYPE_PT_ADD80
8180 | OPTS_TYPE_PT_ADDBITS15;
8181 kern_type = KERN_TYPE_MD5_SHA1;
8182 dgst_size = DGST_SIZE_4_4;
8183 parse_func = md5_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_PRECOMPUTE_INIT
8187 | OPTI_TYPE_PRECOMPUTE_MERKLE
8188 | OPTI_TYPE_EARLY_SKIP
8189 | OPTI_TYPE_NOT_ITERATED
8190 | OPTI_TYPE_NOT_SALTED
8191 | OPTI_TYPE_RAW_HASH;
8192 dgst_pos0 = 0;
8193 dgst_pos1 = 3;
8194 dgst_pos2 = 2;
8195 dgst_pos3 = 1;
8196 break;
8197
8198 case 4500: hash_type = HASH_TYPE_SHA1;
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_SHA11;
8205 dgst_size = DGST_SIZE_4_5;
8206 parse_func = sha1_parse_hash;
8207 sort_by_digest = sort_by_digest_4_5;
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_SALTED;
8213 dgst_pos0 = 3;
8214 dgst_pos1 = 4;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 1;
8217 break;
8218
8219 case 4700: hash_type = HASH_TYPE_SHA1;
8220 salt_type = SALT_TYPE_NONE;
8221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE
8223 | OPTS_TYPE_PT_ADD80
8224 | OPTS_TYPE_PT_ADDBITS14;
8225 kern_type = KERN_TYPE_SHA1_MD5;
8226 dgst_size = DGST_SIZE_4_5;
8227 parse_func = sha1_parse_hash;
8228 sort_by_digest = sort_by_digest_4_5;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_PRECOMPUTE_INIT
8231 | OPTI_TYPE_PRECOMPUTE_MERKLE
8232 | OPTI_TYPE_EARLY_SKIP
8233 | OPTI_TYPE_NOT_ITERATED
8234 | OPTI_TYPE_NOT_SALTED
8235 | OPTI_TYPE_RAW_HASH;
8236 dgst_pos0 = 3;
8237 dgst_pos1 = 4;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 1;
8240 break;
8241
8242 case 4800: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_EMBEDDED;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE
8246 | OPTS_TYPE_PT_ADDBITS14;
8247 kern_type = KERN_TYPE_MD5_CHAP;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = chap_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_MEET_IN_MIDDLE
8255 | OPTI_TYPE_EARLY_SKIP
8256 | OPTI_TYPE_NOT_ITERATED
8257 | OPTI_TYPE_RAW_HASH;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 4900: hash_type = HASH_TYPE_SHA1;
8265 salt_type = SALT_TYPE_INTERN;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8268 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8269 dgst_size = DGST_SIZE_4_5;
8270 parse_func = sha1s_parse_hash;
8271 sort_by_digest = sort_by_digest_4_5;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP;
8276 dgst_pos0 = 3;
8277 dgst_pos1 = 4;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 1;
8280 break;
8281
8282 case 5000: hash_type = HASH_TYPE_KECCAK;
8283 salt_type = SALT_TYPE_EMBEDDED;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_ADD01;
8287 kern_type = KERN_TYPE_KECCAK;
8288 dgst_size = DGST_SIZE_8_25;
8289 parse_func = keccak_parse_hash;
8290 sort_by_digest = sort_by_digest_8_25;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_RAW_HASH;
8293 dgst_pos0 = 2;
8294 dgst_pos1 = 3;
8295 dgst_pos2 = 4;
8296 dgst_pos3 = 5;
8297 break;
8298
8299 case 5100: hash_type = HASH_TYPE_MD5H;
8300 salt_type = SALT_TYPE_NONE;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_LE
8303 | OPTS_TYPE_PT_ADD80
8304 | OPTS_TYPE_PT_ADDBITS14;
8305 kern_type = KERN_TYPE_MD5H;
8306 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8307 parse_func = md5half_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_RAW_HASH;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 1;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 3;
8315 break;
8316
8317 case 5200: hash_type = HASH_TYPE_SHA256;
8318 salt_type = SALT_TYPE_EMBEDDED;
8319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8321 kern_type = KERN_TYPE_PSAFE3;
8322 dgst_size = DGST_SIZE_4_8;
8323 parse_func = psafe3_parse_hash;
8324 sort_by_digest = sort_by_digest_4_8;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 1;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 3;
8330 break;
8331
8332 case 5300: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_ST_ADD80;
8337 kern_type = KERN_TYPE_IKEPSK_MD5;
8338 dgst_size = DGST_SIZE_4_4;
8339 parse_func = ikepsk_md5_parse_hash;
8340 sort_by_digest = sort_by_digest_4_4;
8341 opti_type = OPTI_TYPE_ZERO_BYTE;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 3;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 1;
8346 break;
8347
8348 case 5400: hash_type = HASH_TYPE_SHA1;
8349 salt_type = SALT_TYPE_EMBEDDED;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_BE
8352 | OPTS_TYPE_ST_ADD80;
8353 kern_type = KERN_TYPE_IKEPSK_SHA1;
8354 dgst_size = DGST_SIZE_4_5;
8355 parse_func = ikepsk_sha1_parse_hash;
8356 sort_by_digest = sort_by_digest_4_5;
8357 opti_type = OPTI_TYPE_ZERO_BYTE;
8358 dgst_pos0 = 3;
8359 dgst_pos1 = 4;
8360 dgst_pos2 = 2;
8361 dgst_pos3 = 1;
8362 break;
8363
8364 case 5500: hash_type = HASH_TYPE_NETNTLM;
8365 salt_type = SALT_TYPE_EMBEDDED;
8366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8367 opts_type = OPTS_TYPE_PT_GENERATE_LE
8368 | OPTS_TYPE_PT_ADD80
8369 | OPTS_TYPE_PT_ADDBITS14
8370 | OPTS_TYPE_PT_UNICODE
8371 | OPTS_TYPE_ST_HEX;
8372 kern_type = KERN_TYPE_NETNTLMv1;
8373 dgst_size = DGST_SIZE_4_4;
8374 parse_func = netntlmv1_parse_hash;
8375 sort_by_digest = sort_by_digest_4_4;
8376 opti_type = OPTI_TYPE_ZERO_BYTE
8377 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 1;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 3;
8382 break;
8383
8384 case 5600: hash_type = HASH_TYPE_MD5;
8385 salt_type = SALT_TYPE_EMBEDDED;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_PT_ADD80
8389 | OPTS_TYPE_PT_ADDBITS14
8390 | OPTS_TYPE_PT_UNICODE;
8391 kern_type = KERN_TYPE_NETNTLMv2;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = netntlmv2_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 3;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 1;
8400 break;
8401
8402 case 5700: hash_type = HASH_TYPE_SHA256;
8403 salt_type = SALT_TYPE_NONE;
8404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_BE
8406 | OPTS_TYPE_PT_ADD80
8407 | OPTS_TYPE_PT_ADDBITS15;
8408 kern_type = KERN_TYPE_SHA256;
8409 dgst_size = DGST_SIZE_4_8;
8410 parse_func = cisco4_parse_hash;
8411 sort_by_digest = sort_by_digest_4_8;
8412 opti_type = OPTI_TYPE_ZERO_BYTE
8413 | OPTI_TYPE_PRECOMPUTE_INIT
8414 | OPTI_TYPE_PRECOMPUTE_MERKLE
8415 | OPTI_TYPE_EARLY_SKIP
8416 | OPTI_TYPE_NOT_ITERATED
8417 | OPTI_TYPE_NOT_SALTED
8418 | OPTI_TYPE_RAW_HASH;
8419 dgst_pos0 = 3;
8420 dgst_pos1 = 7;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 6;
8423 break;
8424
8425 case 5800: hash_type = HASH_TYPE_SHA1;
8426 salt_type = SALT_TYPE_INTERN;
8427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8429 | OPTS_TYPE_ST_ADD80;
8430 kern_type = KERN_TYPE_ANDROIDPIN;
8431 dgst_size = DGST_SIZE_4_5;
8432 parse_func = androidpin_parse_hash;
8433 sort_by_digest = sort_by_digest_4_5;
8434 opti_type = OPTI_TYPE_ZERO_BYTE;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 1;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 3;
8439 break;
8440
8441 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8442 salt_type = SALT_TYPE_NONE;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_PT_ADD80;
8446 kern_type = KERN_TYPE_RIPEMD160;
8447 dgst_size = DGST_SIZE_4_5;
8448 parse_func = ripemd160_parse_hash;
8449 sort_by_digest = sort_by_digest_4_5;
8450 opti_type = OPTI_TYPE_ZERO_BYTE;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 1;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 3;
8455 break;
8456
8457 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_BE
8461 | OPTS_TYPE_PT_ADD80;
8462 kern_type = KERN_TYPE_WHIRLPOOL;
8463 dgst_size = DGST_SIZE_4_16;
8464 parse_func = whirlpool_parse_hash;
8465 sort_by_digest = sort_by_digest_4_16;
8466 opti_type = OPTI_TYPE_ZERO_BYTE;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 1;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 3;
8471 break;
8472
8473 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8474 salt_type = SALT_TYPE_EMBEDDED;
8475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8477 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8478 dgst_size = DGST_SIZE_4_5;
8479 parse_func = truecrypt_parse_hash_2k;
8480 sort_by_digest = sort_by_digest_4_5;
8481 opti_type = OPTI_TYPE_ZERO_BYTE;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 1;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 3;
8486 break;
8487
8488 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8489 salt_type = SALT_TYPE_EMBEDDED;
8490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8492 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8493 dgst_size = DGST_SIZE_4_5;
8494 parse_func = truecrypt_parse_hash_2k;
8495 sort_by_digest = sort_by_digest_4_5;
8496 opti_type = OPTI_TYPE_ZERO_BYTE;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8507 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8508 dgst_size = DGST_SIZE_4_5;
8509 parse_func = truecrypt_parse_hash_2k;
8510 sort_by_digest = sort_by_digest_4_5;
8511 opti_type = OPTI_TYPE_ZERO_BYTE;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 1;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 3;
8516 break;
8517
8518 case 6221: hash_type = HASH_TYPE_SHA512;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8522 kern_type = KERN_TYPE_TCSHA512_XTS512;
8523 dgst_size = DGST_SIZE_8_8;
8524 parse_func = truecrypt_parse_hash_1k;
8525 sort_by_digest = sort_by_digest_8_8;
8526 opti_type = OPTI_TYPE_ZERO_BYTE;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 6222: hash_type = HASH_TYPE_SHA512;
8534 salt_type = SALT_TYPE_EMBEDDED;
8535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8537 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8538 dgst_size = DGST_SIZE_8_8;
8539 parse_func = truecrypt_parse_hash_1k;
8540 sort_by_digest = sort_by_digest_8_8;
8541 opti_type = OPTI_TYPE_ZERO_BYTE;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 6223: hash_type = HASH_TYPE_SHA512;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8552 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8553 dgst_size = DGST_SIZE_8_8;
8554 parse_func = truecrypt_parse_hash_1k;
8555 sort_by_digest = sort_by_digest_8_8;
8556 opti_type = OPTI_TYPE_ZERO_BYTE;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 1;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 3;
8561 break;
8562
8563 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8567 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8568 dgst_size = DGST_SIZE_4_8;
8569 parse_func = truecrypt_parse_hash_1k;
8570 sort_by_digest = sort_by_digest_4_8;
8571 opti_type = OPTI_TYPE_ZERO_BYTE;
8572 dgst_pos0 = 0;
8573 dgst_pos1 = 1;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 3;
8576 break;
8577
8578 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8579 salt_type = SALT_TYPE_EMBEDDED;
8580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8582 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8583 dgst_size = DGST_SIZE_4_8;
8584 parse_func = truecrypt_parse_hash_1k;
8585 sort_by_digest = sort_by_digest_4_8;
8586 opti_type = OPTI_TYPE_ZERO_BYTE;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 1;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 3;
8591 break;
8592
8593 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8597 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8598 dgst_size = DGST_SIZE_4_8;
8599 parse_func = truecrypt_parse_hash_1k;
8600 sort_by_digest = sort_by_digest_4_8;
8601 opti_type = OPTI_TYPE_ZERO_BYTE;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8612 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8613 dgst_size = DGST_SIZE_4_5;
8614 parse_func = truecrypt_parse_hash_1k;
8615 sort_by_digest = sort_by_digest_4_5;
8616 opti_type = OPTI_TYPE_ZERO_BYTE;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 1;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 3;
8621 break;
8622
8623 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = truecrypt_parse_hash_1k;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 1;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 3;
8636 break;
8637
8638 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8642 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8643 dgst_size = DGST_SIZE_4_5;
8644 parse_func = truecrypt_parse_hash_1k;
8645 sort_by_digest = sort_by_digest_4_5;
8646 opti_type = OPTI_TYPE_ZERO_BYTE;
8647 dgst_pos0 = 0;
8648 dgst_pos1 = 1;
8649 dgst_pos2 = 2;
8650 dgst_pos3 = 3;
8651 break;
8652
8653 case 6300: hash_type = HASH_TYPE_MD5;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8657 kern_type = KERN_TYPE_MD5AIX;
8658 dgst_size = DGST_SIZE_4_4;
8659 parse_func = md5aix_parse_hash;
8660 sort_by_digest = sort_by_digest_4_4;
8661 opti_type = OPTI_TYPE_ZERO_BYTE;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 6400: hash_type = HASH_TYPE_SHA256;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8672 kern_type = KERN_TYPE_SHA256AIX;
8673 dgst_size = DGST_SIZE_4_8;
8674 parse_func = sha256aix_parse_hash;
8675 sort_by_digest = sort_by_digest_4_8;
8676 opti_type = OPTI_TYPE_ZERO_BYTE;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6500: hash_type = HASH_TYPE_SHA512;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_SHA512AIX;
8688 dgst_size = DGST_SIZE_8_8;
8689 parse_func = sha512aix_parse_hash;
8690 sort_by_digest = sort_by_digest_8_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 6600: hash_type = HASH_TYPE_AES;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8702 kern_type = KERN_TYPE_AGILEKEY;
8703 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8704 parse_func = agilekey_parse_hash;
8705 sort_by_digest = sort_by_digest_4_5;
8706 opti_type = OPTI_TYPE_ZERO_BYTE;
8707 dgst_pos0 = 0;
8708 dgst_pos1 = 1;
8709 dgst_pos2 = 2;
8710 dgst_pos3 = 3;
8711 break;
8712
8713 case 6700: hash_type = HASH_TYPE_SHA1;
8714 salt_type = SALT_TYPE_EMBEDDED;
8715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8717 kern_type = KERN_TYPE_SHA1AIX;
8718 dgst_size = DGST_SIZE_4_5;
8719 parse_func = sha1aix_parse_hash;
8720 sort_by_digest = sort_by_digest_4_5;
8721 opti_type = OPTI_TYPE_ZERO_BYTE;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 1;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 3;
8726 break;
8727
8728 case 6800: hash_type = HASH_TYPE_AES;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8732 kern_type = KERN_TYPE_LASTPASS;
8733 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8734 parse_func = lastpass_parse_hash;
8735 sort_by_digest = sort_by_digest_4_8;
8736 opti_type = OPTI_TYPE_ZERO_BYTE;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 1;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 3;
8741 break;
8742
8743 case 6900: hash_type = HASH_TYPE_GOST;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8747 kern_type = KERN_TYPE_GOST;
8748 dgst_size = DGST_SIZE_4_8;
8749 parse_func = gost_parse_hash;
8750 sort_by_digest = sort_by_digest_4_8;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 7100: hash_type = HASH_TYPE_SHA512;
8759 salt_type = SALT_TYPE_EMBEDDED;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8762 kern_type = KERN_TYPE_PBKDF2_SHA512;
8763 dgst_size = DGST_SIZE_8_16;
8764 parse_func = sha512osx_parse_hash;
8765 sort_by_digest = sort_by_digest_8_16;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 7200: hash_type = HASH_TYPE_SHA512;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8777 kern_type = KERN_TYPE_PBKDF2_SHA512;
8778 dgst_size = DGST_SIZE_8_16;
8779 parse_func = sha512grub_parse_hash;
8780 sort_by_digest = sort_by_digest_8_16;
8781 opti_type = OPTI_TYPE_ZERO_BYTE;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 7300: hash_type = HASH_TYPE_SHA1;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_BE
8792 | OPTS_TYPE_ST_ADD80
8793 | OPTS_TYPE_ST_ADDBITS15;
8794 kern_type = KERN_TYPE_RAKP;
8795 dgst_size = DGST_SIZE_4_5;
8796 parse_func = rakp_parse_hash;
8797 sort_by_digest = sort_by_digest_4_5;
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_NOT_ITERATED;
8800 dgst_pos0 = 3;
8801 dgst_pos1 = 4;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 1;
8804 break;
8805
8806 case 7400: hash_type = HASH_TYPE_SHA256;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8810 kern_type = KERN_TYPE_SHA256CRYPT;
8811 dgst_size = DGST_SIZE_4_8;
8812 parse_func = sha256crypt_parse_hash;
8813 sort_by_digest = sort_by_digest_4_8;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 7500: hash_type = HASH_TYPE_KRB5PA;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8825 kern_type = KERN_TYPE_KRB5PA;
8826 dgst_size = DGST_SIZE_4_4;
8827 parse_func = krb5pa_parse_hash;
8828 sort_by_digest = sort_by_digest_4_4;
8829 opti_type = OPTI_TYPE_ZERO_BYTE
8830 | OPTI_TYPE_NOT_ITERATED;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 7600: hash_type = HASH_TYPE_SHA1;
8838 salt_type = SALT_TYPE_INTERN;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_BE
8841 | OPTS_TYPE_PT_ADD80
8842 | OPTS_TYPE_PT_ADDBITS15;
8843 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8844 dgst_size = DGST_SIZE_4_5;
8845 parse_func = redmine_parse_hash;
8846 sort_by_digest = sort_by_digest_4_5;
8847 opti_type = OPTI_TYPE_ZERO_BYTE
8848 | OPTI_TYPE_PRECOMPUTE_INIT
8849 | OPTI_TYPE_EARLY_SKIP
8850 | OPTI_TYPE_NOT_ITERATED
8851 | OPTI_TYPE_PREPENDED_SALT;
8852 dgst_pos0 = 3;
8853 dgst_pos1 = 4;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 1;
8856 break;
8857
8858 case 7700: hash_type = HASH_TYPE_SAPB;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE
8862 | OPTS_TYPE_PT_UPPER
8863 | OPTS_TYPE_ST_UPPER;
8864 kern_type = KERN_TYPE_SAPB;
8865 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8866 parse_func = sapb_parse_hash;
8867 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8868 opti_type = OPTI_TYPE_ZERO_BYTE
8869 | OPTI_TYPE_PRECOMPUTE_INIT
8870 | OPTI_TYPE_NOT_ITERATED;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 7800: hash_type = HASH_TYPE_SAPG;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_BE
8881 | OPTS_TYPE_ST_ADD80
8882 | OPTS_TYPE_ST_UPPER;
8883 kern_type = KERN_TYPE_SAPG;
8884 dgst_size = DGST_SIZE_4_5;
8885 parse_func = sapg_parse_hash;
8886 sort_by_digest = sort_by_digest_4_5;
8887 opti_type = OPTI_TYPE_ZERO_BYTE
8888 | OPTI_TYPE_PRECOMPUTE_INIT
8889 | OPTI_TYPE_NOT_ITERATED;
8890 dgst_pos0 = 3;
8891 dgst_pos1 = 4;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 1;
8894 break;
8895
8896 case 7900: hash_type = HASH_TYPE_SHA512;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8900 kern_type = KERN_TYPE_DRUPAL7;
8901 dgst_size = DGST_SIZE_8_8;
8902 parse_func = drupal7_parse_hash;
8903 sort_by_digest = sort_by_digest_8_8;
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 8000: hash_type = HASH_TYPE_SHA256;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_BE
8915 | OPTS_TYPE_PT_UNICODE
8916 | OPTS_TYPE_ST_ADD80
8917 | OPTS_TYPE_ST_HEX;
8918 kern_type = KERN_TYPE_SYBASEASE;
8919 dgst_size = DGST_SIZE_4_8;
8920 parse_func = sybasease_parse_hash;
8921 sort_by_digest = sort_by_digest_4_8;
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_INIT
8924 | OPTI_TYPE_EARLY_SKIP
8925 | OPTI_TYPE_NOT_ITERATED
8926 | OPTI_TYPE_RAW_HASH;
8927 dgst_pos0 = 3;
8928 dgst_pos1 = 7;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 6;
8931 break;
8932
8933 case 8100: hash_type = HASH_TYPE_SHA1;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8937 kern_type = KERN_TYPE_NETSCALER;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = netscaler_parse_hash;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE
8942 | OPTI_TYPE_PRECOMPUTE_INIT
8943 | OPTI_TYPE_PRECOMPUTE_MERKLE
8944 | OPTI_TYPE_EARLY_SKIP
8945 | OPTI_TYPE_NOT_ITERATED
8946 | OPTI_TYPE_PREPENDED_SALT
8947 | OPTI_TYPE_RAW_HASH;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8200: hash_type = HASH_TYPE_SHA256;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8958 kern_type = KERN_TYPE_CLOUDKEY;
8959 dgst_size = DGST_SIZE_4_8;
8960 parse_func = cloudkey_parse_hash;
8961 sort_by_digest = sort_by_digest_4_8;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 8300: hash_type = HASH_TYPE_SHA1;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE
8973 | OPTS_TYPE_ST_HEX
8974 | OPTS_TYPE_ST_ADD80;
8975 kern_type = KERN_TYPE_NSEC3;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = nsec3_parse_hash;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 3;
8981 dgst_pos1 = 4;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 1;
8984 break;
8985
8986 case 8400: hash_type = HASH_TYPE_SHA1;
8987 salt_type = SALT_TYPE_INTERN;
8988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_BE
8990 | OPTS_TYPE_PT_ADD80
8991 | OPTS_TYPE_PT_ADDBITS15;
8992 kern_type = KERN_TYPE_WBB3;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = wbb3_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE
8997 | OPTI_TYPE_PRECOMPUTE_INIT
8998 | OPTI_TYPE_NOT_ITERATED;
8999 dgst_pos0 = 3;
9000 dgst_pos1 = 4;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 1;
9003 break;
9004
9005 case 8500: hash_type = HASH_TYPE_DESRACF;
9006 salt_type = SALT_TYPE_EMBEDDED;
9007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE
9009 | OPTS_TYPE_ST_UPPER;
9010 kern_type = KERN_TYPE_RACF;
9011 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9012 parse_func = racf_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9014 opti_type = OPTI_TYPE_ZERO_BYTE
9015 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9016 dgst_pos0 = 0;
9017 dgst_pos1 = 1;
9018 dgst_pos2 = 2;
9019 dgst_pos3 = 3;
9020 break;
9021
9022 case 8600: hash_type = HASH_TYPE_LOTUS5;
9023 salt_type = SALT_TYPE_NONE;
9024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9026 kern_type = KERN_TYPE_LOTUS5;
9027 dgst_size = DGST_SIZE_4_4;
9028 parse_func = lotus5_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4;
9030 opti_type = OPTI_TYPE_EARLY_SKIP
9031 | OPTI_TYPE_NOT_ITERATED
9032 | OPTI_TYPE_NOT_SALTED
9033 | OPTI_TYPE_RAW_HASH;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 1;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 3;
9038 break;
9039
9040 case 8700: hash_type = HASH_TYPE_LOTUS6;
9041 salt_type = SALT_TYPE_EMBEDDED;
9042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9044 kern_type = KERN_TYPE_LOTUS6;
9045 dgst_size = DGST_SIZE_4_4;
9046 parse_func = lotus6_parse_hash;
9047 sort_by_digest = sort_by_digest_4_4;
9048 opti_type = OPTI_TYPE_EARLY_SKIP
9049 | OPTI_TYPE_NOT_ITERATED
9050 | OPTI_TYPE_RAW_HASH;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_ANDROIDFDE;
9062 dgst_size = DGST_SIZE_4_4;
9063 parse_func = androidfde_parse_hash;
9064 sort_by_digest = sort_by_digest_4_4;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 8900: hash_type = HASH_TYPE_SCRYPT;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_SCRYPT;
9077 dgst_size = DGST_SIZE_4_8;
9078 parse_func = scrypt_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 9000: hash_type = HASH_TYPE_SHA1;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE
9091 | OPTS_TYPE_ST_GENERATE_LE;
9092 kern_type = KERN_TYPE_PSAFE2;
9093 dgst_size = DGST_SIZE_4_5;
9094 parse_func = psafe2_parse_hash;
9095 sort_by_digest = sort_by_digest_4_5;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 9100: hash_type = HASH_TYPE_LOTUS8;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_LOTUS8;
9108 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9109 parse_func = lotus8_parse_hash;
9110 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 9200: hash_type = HASH_TYPE_SHA256;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA256;
9123 dgst_size = DGST_SIZE_4_32;
9124 parse_func = cisco8_parse_hash;
9125 sort_by_digest = sort_by_digest_4_32;
9126 opti_type = OPTI_TYPE_ZERO_BYTE;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 9300: hash_type = HASH_TYPE_SCRYPT;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9137 kern_type = KERN_TYPE_SCRYPT;
9138 dgst_size = DGST_SIZE_4_8;
9139 parse_func = cisco9_parse_hash;
9140 sort_by_digest = sort_by_digest_4_8;
9141 opti_type = OPTI_TYPE_ZERO_BYTE;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9152 kern_type = KERN_TYPE_OFFICE2007;
9153 dgst_size = DGST_SIZE_4_4;
9154 parse_func = office2007_parse_hash;
9155 sort_by_digest = sort_by_digest_4_4;
9156 opti_type = OPTI_TYPE_ZERO_BYTE;
9157 dgst_pos0 = 0;
9158 dgst_pos1 = 1;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 3;
9161 break;
9162
9163 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9167 kern_type = KERN_TYPE_OFFICE2010;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = office2010_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_OFFICE2013;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = office2013_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE
9197 | OPTS_TYPE_PT_ADD80
9198 | OPTS_TYPE_PT_UNICODE;
9199 kern_type = KERN_TYPE_OLDOFFICE01;
9200 dgst_size = DGST_SIZE_4_4;
9201 parse_func = oldoffice01_parse_hash;
9202 sort_by_digest = sort_by_digest_4_4;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_PRECOMPUTE_INIT
9205 | OPTI_TYPE_NOT_ITERATED;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE
9216 | OPTS_TYPE_PT_ADD80;
9217 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9218 dgst_size = DGST_SIZE_4_4;
9219 parse_func = oldoffice01cm1_parse_hash;
9220 sort_by_digest = sort_by_digest_4_4;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_NOT_ITERATED;
9224 dgst_pos0 = 0;
9225 dgst_pos1 = 1;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 3;
9228 break;
9229
9230 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_LE
9234 | OPTS_TYPE_PT_ADD80
9235 | OPTS_TYPE_PT_UNICODE
9236 | OPTS_TYPE_PT_NEVERCRACK;
9237 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9238 dgst_size = DGST_SIZE_4_4;
9239 parse_func = oldoffice01cm2_parse_hash;
9240 sort_by_digest = sort_by_digest_4_4;
9241 opti_type = OPTI_TYPE_ZERO_BYTE
9242 | OPTI_TYPE_PRECOMPUTE_INIT
9243 | OPTI_TYPE_NOT_ITERATED;
9244 dgst_pos0 = 0;
9245 dgst_pos1 = 1;
9246 dgst_pos2 = 2;
9247 dgst_pos3 = 3;
9248 break;
9249
9250 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9251 salt_type = SALT_TYPE_EMBEDDED;
9252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9253 opts_type = OPTS_TYPE_PT_GENERATE_BE
9254 | OPTS_TYPE_PT_ADD80
9255 | OPTS_TYPE_PT_UNICODE;
9256 kern_type = KERN_TYPE_OLDOFFICE34;
9257 dgst_size = DGST_SIZE_4_4;
9258 parse_func = oldoffice34_parse_hash;
9259 sort_by_digest = sort_by_digest_4_4;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_PRECOMPUTE_INIT
9262 | OPTI_TYPE_NOT_ITERATED;
9263 dgst_pos0 = 0;
9264 dgst_pos1 = 1;
9265 dgst_pos2 = 2;
9266 dgst_pos3 = 3;
9267 break;
9268
9269 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9270 salt_type = SALT_TYPE_EMBEDDED;
9271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9273 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9274 dgst_size = DGST_SIZE_4_4;
9275 parse_func = oldoffice34cm1_parse_hash;
9276 sort_by_digest = sort_by_digest_4_4;
9277 opti_type = OPTI_TYPE_ZERO_BYTE
9278 | OPTI_TYPE_PRECOMPUTE_INIT
9279 | OPTI_TYPE_NOT_ITERATED;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_BE
9290 | OPTS_TYPE_PT_ADD80
9291 | OPTS_TYPE_PT_UNICODE
9292 | OPTS_TYPE_PT_NEVERCRACK;
9293 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = oldoffice34cm2_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_INIT
9299 | OPTI_TYPE_NOT_ITERATED;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 9900: hash_type = HASH_TYPE_MD5;
9307 salt_type = SALT_TYPE_NONE;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9310 kern_type = KERN_TYPE_RADMIN2;
9311 dgst_size = DGST_SIZE_4_4;
9312 parse_func = radmin2_parse_hash;
9313 sort_by_digest = sort_by_digest_4_4;
9314 opti_type = OPTI_TYPE_ZERO_BYTE
9315 | OPTI_TYPE_PRECOMPUTE_INIT
9316 | OPTI_TYPE_EARLY_SKIP
9317 | OPTI_TYPE_NOT_ITERATED
9318 | OPTI_TYPE_NOT_SALTED;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 3;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 1;
9323 break;
9324
9325 case 10000: hash_type = HASH_TYPE_SHA256;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_PBKDF2_SHA256;
9330 dgst_size = DGST_SIZE_4_32;
9331 parse_func = djangopbkdf2_parse_hash;
9332 sort_by_digest = sort_by_digest_4_32;
9333 opti_type = OPTI_TYPE_ZERO_BYTE;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 1;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 3;
9338 break;
9339
9340 case 10100: hash_type = HASH_TYPE_SIPHASH;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9344 kern_type = KERN_TYPE_SIPHASH;
9345 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9346 parse_func = siphash_parse_hash;
9347 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9348 opti_type = OPTI_TYPE_ZERO_BYTE
9349 | OPTI_TYPE_NOT_ITERATED
9350 | OPTI_TYPE_RAW_HASH;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 10200: hash_type = HASH_TYPE_MD5;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE
9361 | OPTS_TYPE_ST_ADD80
9362 | OPTS_TYPE_ST_ADDBITS14;
9363 kern_type = KERN_TYPE_HMACMD5_PW;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = crammd5_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_NOT_ITERATED;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 3;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 1;
9373 break;
9374
9375 case 10300: hash_type = HASH_TYPE_SHA1;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9379 kern_type = KERN_TYPE_SAPH_SHA1;
9380 dgst_size = DGST_SIZE_4_5;
9381 parse_func = saph_sha1_parse_hash;
9382 sort_by_digest = sort_by_digest_4_5;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 10400: hash_type = HASH_TYPE_PDFU16;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_PDF11;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = pdf11_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_NOT_ITERATED;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 10410: hash_type = HASH_TYPE_PDFU16;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9410 kern_type = KERN_TYPE_PDF11CM1;
9411 dgst_size = DGST_SIZE_4_4;
9412 parse_func = pdf11cm1_parse_hash;
9413 sort_by_digest = sort_by_digest_4_4;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_NOT_ITERATED;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 10420: hash_type = HASH_TYPE_PDFU16;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_PDF11CM2;
9427 dgst_size = DGST_SIZE_4_4;
9428 parse_func = pdf11cm2_parse_hash;
9429 sort_by_digest = sort_by_digest_4_4;
9430 opti_type = OPTI_TYPE_ZERO_BYTE
9431 | OPTI_TYPE_NOT_ITERATED;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 10500: hash_type = HASH_TYPE_PDFU16;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_PDF14;
9443 dgst_size = DGST_SIZE_4_4;
9444 parse_func = pdf14_parse_hash;
9445 sort_by_digest = sort_by_digest_4_4;
9446 opti_type = OPTI_TYPE_ZERO_BYTE
9447 | OPTI_TYPE_NOT_ITERATED;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 10600: hash_type = HASH_TYPE_SHA256;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_BE
9458 | OPTS_TYPE_ST_ADD80
9459 | OPTS_TYPE_ST_ADDBITS15
9460 | OPTS_TYPE_HASH_COPY;
9461 kern_type = KERN_TYPE_SHA256_PWSLT;
9462 dgst_size = DGST_SIZE_4_8;
9463 parse_func = pdf17l3_parse_hash;
9464 sort_by_digest = sort_by_digest_4_8;
9465 opti_type = OPTI_TYPE_ZERO_BYTE
9466 | OPTI_TYPE_PRECOMPUTE_INIT
9467 | OPTI_TYPE_PRECOMPUTE_MERKLE
9468 | OPTI_TYPE_EARLY_SKIP
9469 | OPTI_TYPE_NOT_ITERATED
9470 | OPTI_TYPE_APPENDED_SALT
9471 | OPTI_TYPE_RAW_HASH;
9472 dgst_pos0 = 3;
9473 dgst_pos1 = 7;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 6;
9476 break;
9477
9478 case 10700: hash_type = HASH_TYPE_PDFU32;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE
9482 | OPTS_TYPE_HASH_COPY;
9483 kern_type = KERN_TYPE_PDF17L8;
9484 dgst_size = DGST_SIZE_4_8;
9485 parse_func = pdf17l8_parse_hash;
9486 sort_by_digest = sort_by_digest_4_8;
9487 opti_type = OPTI_TYPE_ZERO_BYTE
9488 | OPTI_TYPE_NOT_ITERATED;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 10800: hash_type = HASH_TYPE_SHA384;
9496 salt_type = SALT_TYPE_NONE;
9497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_BE
9499 | OPTS_TYPE_PT_ADD80
9500 | OPTS_TYPE_PT_ADDBITS15;
9501 kern_type = KERN_TYPE_SHA384;
9502 dgst_size = DGST_SIZE_8_8;
9503 parse_func = sha384_parse_hash;
9504 sort_by_digest = sort_by_digest_8_8;
9505 opti_type = OPTI_TYPE_ZERO_BYTE
9506 | OPTI_TYPE_PRECOMPUTE_INIT
9507 | OPTI_TYPE_PRECOMPUTE_MERKLE
9508 | OPTI_TYPE_EARLY_SKIP
9509 | OPTI_TYPE_NOT_ITERATED
9510 | OPTI_TYPE_NOT_SALTED
9511 | OPTI_TYPE_RAW_HASH;
9512 dgst_pos0 = 6;
9513 dgst_pos1 = 7;
9514 dgst_pos2 = 4;
9515 dgst_pos3 = 5;
9516 break;
9517
9518 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE
9522 | OPTS_TYPE_ST_BASE64
9523 | OPTS_TYPE_HASH_COPY;
9524 kern_type = KERN_TYPE_PBKDF2_SHA256;
9525 dgst_size = DGST_SIZE_4_32;
9526 parse_func = pbkdf2_sha256_parse_hash;
9527 sort_by_digest = sort_by_digest_4_32;
9528 opti_type = OPTI_TYPE_ZERO_BYTE;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 11000: hash_type = HASH_TYPE_MD5;
9536 salt_type = SALT_TYPE_INTERN;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE
9539 | OPTS_TYPE_PT_ADD80;
9540 kern_type = KERN_TYPE_PRESTASHOP;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = prestashop_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4;
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_INIT
9546 | OPTI_TYPE_NOT_ITERATED
9547 | OPTI_TYPE_PREPENDED_SALT;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 3;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 1;
9552 break;
9553
9554 case 11100: hash_type = HASH_TYPE_MD5;
9555 salt_type = SALT_TYPE_EMBEDDED;
9556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE
9558 | OPTS_TYPE_ST_ADD80;
9559 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = postgresql_auth_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_PRECOMPUTE_MERKLE
9566 | OPTI_TYPE_EARLY_SKIP;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 3;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 1;
9571 break;
9572
9573 case 11200: hash_type = HASH_TYPE_SHA1;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_BE
9577 | OPTS_TYPE_PT_ADD80
9578 | OPTS_TYPE_ST_HEX;
9579 kern_type = KERN_TYPE_MYSQL_AUTH;
9580 dgst_size = DGST_SIZE_4_5;
9581 parse_func = mysql_auth_parse_hash;
9582 sort_by_digest = sort_by_digest_4_5;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_EARLY_SKIP;
9585 dgst_pos0 = 3;
9586 dgst_pos1 = 4;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 1;
9589 break;
9590
9591 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_ST_HEX
9596 | OPTS_TYPE_ST_ADD80;
9597 kern_type = KERN_TYPE_BITCOIN_WALLET;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = bitcoin_wallet_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 1;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 3;
9606 break;
9607
9608 case 11400: hash_type = HASH_TYPE_MD5;
9609 salt_type = SALT_TYPE_EMBEDDED;
9610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE
9612 | OPTS_TYPE_PT_ADD80
9613 | OPTS_TYPE_HASH_COPY;
9614 kern_type = KERN_TYPE_SIP_AUTH;
9615 dgst_size = DGST_SIZE_4_4;
9616 parse_func = sip_auth_parse_hash;
9617 sort_by_digest = sort_by_digest_4_4;
9618 opti_type = OPTI_TYPE_ZERO_BYTE;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 3;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 1;
9623 break;
9624
9625 case 11500: hash_type = HASH_TYPE_CRC32;
9626 salt_type = SALT_TYPE_INTERN;
9627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE
9629 | OPTS_TYPE_ST_GENERATE_LE
9630 | OPTS_TYPE_ST_HEX;
9631 kern_type = KERN_TYPE_CRC32;
9632 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9633 parse_func = crc32_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 11600: hash_type = HASH_TYPE_AES;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_PT_NEVERCRACK;
9647 kern_type = KERN_TYPE_SEVEN_ZIP;
9648 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9649 parse_func = seven_zip_parse_hash;
9650 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9659 salt_type = SALT_TYPE_NONE;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_PT_ADD01;
9663 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9664 dgst_size = DGST_SIZE_4_8;
9665 parse_func = gost2012sbog_256_parse_hash;
9666 sort_by_digest = sort_by_digest_4_8;
9667 opti_type = OPTI_TYPE_ZERO_BYTE;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9675 salt_type = SALT_TYPE_NONE;
9676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE
9678 | OPTS_TYPE_PT_ADD01;
9679 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9680 dgst_size = DGST_SIZE_4_16;
9681 parse_func = gost2012sbog_512_parse_hash;
9682 sort_by_digest = sort_by_digest_4_16;
9683 opti_type = OPTI_TYPE_ZERO_BYTE;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_ST_BASE64
9695 | OPTS_TYPE_HASH_COPY;
9696 kern_type = KERN_TYPE_PBKDF2_MD5;
9697 dgst_size = DGST_SIZE_4_32;
9698 parse_func = pbkdf2_md5_parse_hash;
9699 sort_by_digest = sort_by_digest_4_32;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE
9711 | OPTS_TYPE_ST_BASE64
9712 | OPTS_TYPE_HASH_COPY;
9713 kern_type = KERN_TYPE_PBKDF2_SHA1;
9714 dgst_size = DGST_SIZE_4_32;
9715 parse_func = pbkdf2_sha1_parse_hash;
9716 sort_by_digest = sort_by_digest_4_32;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_ST_BASE64
9729 | OPTS_TYPE_HASH_COPY;
9730 kern_type = KERN_TYPE_PBKDF2_SHA512;
9731 dgst_size = DGST_SIZE_8_16;
9732 parse_func = pbkdf2_sha512_parse_hash;
9733 sort_by_digest = sort_by_digest_8_16;
9734 opti_type = OPTI_TYPE_ZERO_BYTE;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9745 kern_type = KERN_TYPE_ECRYPTFS;
9746 dgst_size = DGST_SIZE_8_8;
9747 parse_func = ecryptfs_parse_hash;
9748 sort_by_digest = sort_by_digest_8_8;
9749 opti_type = OPTI_TYPE_ZERO_BYTE;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 12300: hash_type = HASH_TYPE_ORACLET;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9760 kern_type = KERN_TYPE_ORACLET;
9761 dgst_size = DGST_SIZE_8_16;
9762 parse_func = oraclet_parse_hash;
9763 sort_by_digest = sort_by_digest_8_16;
9764 opti_type = OPTI_TYPE_ZERO_BYTE;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9775 kern_type = KERN_TYPE_BSDICRYPT;
9776 dgst_size = DGST_SIZE_4_4;
9777 parse_func = bsdicrypt_parse_hash;
9778 sort_by_digest = sort_by_digest_4_4;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 12500: hash_type = HASH_TYPE_RAR3HP;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9791 kern_type = KERN_TYPE_RAR3;
9792 dgst_size = DGST_SIZE_4_4;
9793 parse_func = rar3hp_parse_hash;
9794 sort_by_digest = sort_by_digest_4_4;
9795 opti_type = OPTI_TYPE_ZERO_BYTE;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 12600: hash_type = HASH_TYPE_SHA256;
9803 salt_type = SALT_TYPE_INTERN;
9804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_BE
9806 | OPTS_TYPE_PT_ADD80;
9807 kern_type = KERN_TYPE_CF10;
9808 dgst_size = DGST_SIZE_4_8;
9809 parse_func = cf10_parse_hash;
9810 sort_by_digest = sort_by_digest_4_8;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_EARLY_SKIP
9814 | OPTI_TYPE_NOT_ITERATED;
9815 dgst_pos0 = 3;
9816 dgst_pos1 = 7;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 6;
9819 break;
9820
9821 case 12700: hash_type = HASH_TYPE_AES;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_LE
9825 | OPTS_TYPE_HASH_COPY;
9826 kern_type = KERN_TYPE_MYWALLET;
9827 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9828 parse_func = mywallet_parse_hash;
9829 sort_by_digest = sort_by_digest_4_5;
9830 opti_type = OPTI_TYPE_ZERO_BYTE;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9841 kern_type = KERN_TYPE_MS_DRSR;
9842 dgst_size = DGST_SIZE_4_8;
9843 parse_func = ms_drsr_parse_hash;
9844 sort_by_digest = sort_by_digest_4_8;
9845 opti_type = OPTI_TYPE_ZERO_BYTE;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9856 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9857 dgst_size = DGST_SIZE_4_8;
9858 parse_func = androidfde_samsung_parse_hash;
9859 sort_by_digest = sort_by_digest_4_8;
9860 opti_type = OPTI_TYPE_ZERO_BYTE;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 1;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 3;
9865 break;
9866
9867 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9871 kern_type = KERN_TYPE_RAR5;
9872 dgst_size = DGST_SIZE_4_4;
9873 parse_func = rar5_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4;
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 default: usage_mini_print (PROGNAME); return (-1);
9883 }
9884
9885 /**
9886 * transpose
9887 */
9888
9889 data.parse_func = parse_func;
9890
9891 /**
9892 * misc stuff
9893 */
9894
9895 if (hex_salt)
9896 {
9897 if (salt_type == SALT_TYPE_INTERN)
9898 {
9899 opts_type |= OPTS_TYPE_ST_HEX;
9900 }
9901 else
9902 {
9903 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9904
9905 return (-1);
9906 }
9907 }
9908
9909 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9910 | (salt_type == SALT_TYPE_EXTERN)
9911 | (salt_type == SALT_TYPE_EMBEDDED)
9912 | (salt_type == SALT_TYPE_VIRTUAL));
9913
9914 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9915
9916 data.hash_type = hash_type;
9917 data.attack_mode = attack_mode;
9918 data.attack_kern = attack_kern;
9919 data.attack_exec = attack_exec;
9920 data.kern_type = kern_type;
9921 data.opts_type = opts_type;
9922 data.dgst_size = dgst_size;
9923 data.salt_type = salt_type;
9924 data.isSalted = isSalted;
9925 data.sort_by_digest = sort_by_digest;
9926 data.dgst_pos0 = dgst_pos0;
9927 data.dgst_pos1 = dgst_pos1;
9928 data.dgst_pos2 = dgst_pos2;
9929 data.dgst_pos3 = dgst_pos3;
9930
9931 esalt_size = 0;
9932
9933 switch (hash_mode)
9934 {
9935 case 2500: esalt_size = sizeof (wpa_t); break;
9936 case 5300: esalt_size = sizeof (ikepsk_t); break;
9937 case 5400: esalt_size = sizeof (ikepsk_t); break;
9938 case 5500: esalt_size = sizeof (netntlm_t); break;
9939 case 5600: esalt_size = sizeof (netntlm_t); break;
9940 case 6211:
9941 case 6212:
9942 case 6213:
9943 case 6221:
9944 case 6222:
9945 case 6223:
9946 case 6231:
9947 case 6232:
9948 case 6233:
9949 case 6241:
9950 case 6242:
9951 case 6243: esalt_size = sizeof (tc_t); break;
9952 case 6600: esalt_size = sizeof (agilekey_t); break;
9953 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9954 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9955 case 7300: esalt_size = sizeof (rakp_t); break;
9956 case 7500: esalt_size = sizeof (krb5pa_t); break;
9957 case 8200: esalt_size = sizeof (cloudkey_t); break;
9958 case 8800: esalt_size = sizeof (androidfde_t); break;
9959 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9960 case 9400: esalt_size = sizeof (office2007_t); break;
9961 case 9500: esalt_size = sizeof (office2010_t); break;
9962 case 9600: esalt_size = sizeof (office2013_t); break;
9963 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9964 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9965 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9966 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9967 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9968 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9969 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9970 case 10200: esalt_size = sizeof (cram_md5_t); break;
9971 case 10400: esalt_size = sizeof (pdf_t); break;
9972 case 10410: esalt_size = sizeof (pdf_t); break;
9973 case 10420: esalt_size = sizeof (pdf_t); break;
9974 case 10500: esalt_size = sizeof (pdf_t); break;
9975 case 10600: esalt_size = sizeof (pdf_t); break;
9976 case 10700: esalt_size = sizeof (pdf_t); break;
9977 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9978 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9979 case 11400: esalt_size = sizeof (sip_t); break;
9980 case 11600: esalt_size = sizeof (seven_zip_t); break;
9981 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9982 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9983 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9984 case 13000: esalt_size = sizeof (rar5_t); break;
9985 }
9986
9987 data.esalt_size = esalt_size;
9988
9989 /**
9990 * choose dictionary parser
9991 */
9992
9993 if (hash_type == HASH_TYPE_LM)
9994 {
9995 get_next_word_func = get_next_word_lm;
9996 }
9997 else if (opts_type & OPTS_TYPE_PT_UPPER)
9998 {
9999 get_next_word_func = get_next_word_uc;
10000 }
10001 else
10002 {
10003 get_next_word_func = get_next_word_std;
10004 }
10005
10006 /**
10007 * dictstat
10008 */
10009
10010 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10011
10012 #ifdef _POSIX
10013 size_t dictstat_nmemb = 0;
10014 #endif
10015
10016 #ifdef _WIN
10017 uint dictstat_nmemb = 0;
10018 #endif
10019
10020 char dictstat[256];
10021
10022 FILE *dictstat_fp = NULL;
10023
10024 if (keyspace == 0)
10025 {
10026 memset (dictstat, 0, sizeof (dictstat));
10027
10028 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10029
10030 dictstat_fp = fopen (dictstat, "rb");
10031
10032 if (dictstat_fp)
10033 {
10034 #ifdef _POSIX
10035 struct stat tmpstat;
10036
10037 fstat (fileno (dictstat_fp), &tmpstat);
10038 #endif
10039
10040 #ifdef _WIN
10041 struct stat64 tmpstat;
10042
10043 _fstat64 (fileno (dictstat_fp), &tmpstat);
10044 #endif
10045
10046 if (tmpstat.st_mtime < COMPTIME)
10047 {
10048 /* with v0.15 the format changed so we have to ensure user is using a good version
10049 since there is no version-header in the dictstat file */
10050
10051 fclose (dictstat_fp);
10052
10053 unlink (dictstat);
10054 }
10055 else
10056 {
10057 while (!feof (dictstat_fp))
10058 {
10059 dictstat_t d;
10060
10061 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10062
10063 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10064
10065 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10066 {
10067 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10068
10069 return -1;
10070 }
10071 }
10072
10073 fclose (dictstat_fp);
10074 }
10075 }
10076 }
10077
10078 /**
10079 * potfile
10080 */
10081
10082 char potfile[256] = { 0 };
10083
10084 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10085
10086 data.pot_fp = NULL;
10087
10088 FILE *out_fp = NULL;
10089 FILE *pot_fp = NULL;
10090
10091 if (show == 1 || left == 1)
10092 {
10093 pot_fp = fopen (potfile, "rb");
10094
10095 if (pot_fp == NULL)
10096 {
10097 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10098
10099 return (-1);
10100 }
10101
10102 if (outfile != NULL)
10103 {
10104 if ((out_fp = fopen (outfile, "ab")) == NULL)
10105 {
10106 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10107
10108 fclose (pot_fp);
10109
10110 return (-1);
10111 }
10112 }
10113 else
10114 {
10115 out_fp = stdout;
10116 }
10117 }
10118 else
10119 {
10120 if (potfile_disable == 0)
10121 {
10122 pot_fp = fopen (potfile, "ab");
10123
10124 if (pot_fp == NULL)
10125 {
10126 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10127
10128 return (-1);
10129 }
10130
10131 data.pot_fp = pot_fp;
10132 }
10133 }
10134
10135 pot_t *pot = NULL;
10136
10137 uint pot_cnt = 0;
10138 uint pot_avail = 0;
10139
10140 if (show == 1 || left == 1)
10141 {
10142 SUPPRESS_OUTPUT = 1;
10143
10144 pot_avail = count_lines (pot_fp);
10145
10146 rewind (pot_fp);
10147
10148 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10149
10150 uint pot_hashes_avail = 0;
10151
10152 uint line_num = 0;
10153
10154 while (!feof (pot_fp))
10155 {
10156 line_num++;
10157
10158 char line_buf[BUFSIZ];
10159
10160 int line_len = fgetl (pot_fp, line_buf);
10161
10162 if (line_len == 0) continue;
10163
10164 char *plain_buf = line_buf + line_len;
10165
10166 pot_t *pot_ptr = &pot[pot_cnt];
10167
10168 hash_t *hashes_buf = &pot_ptr->hash;
10169
10170 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10171 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10172
10173 if (pot_cnt == pot_hashes_avail)
10174 {
10175 uint pos = 0;
10176
10177 for (pos = 0; pos < INCR_POT; pos++)
10178 {
10179 if ((pot_cnt + pos) >= pot_avail) break;
10180
10181 pot_t *tmp_pot = &pot[pot_cnt + pos];
10182
10183 hash_t *tmp_hash = &tmp_pot->hash;
10184
10185 tmp_hash->digest = mymalloc (dgst_size);
10186
10187 if (isSalted)
10188 {
10189 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10190 }
10191
10192 if (esalt_size)
10193 {
10194 tmp_hash->esalt = mymalloc (esalt_size);
10195 }
10196
10197 pot_hashes_avail++;
10198 }
10199 }
10200
10201 int plain_len = 0;
10202
10203 int parser_status;
10204
10205 int iter = MAX_CUT_TRIES;
10206
10207 do
10208 {
10209 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10210 {
10211 if (line_buf[i] == ':')
10212 {
10213 line_len--;
10214
10215 break;
10216 }
10217 }
10218
10219 if (data.hash_mode != 2500)
10220 {
10221 parser_status = parse_func (line_buf, line_len, hashes_buf);
10222 }
10223 else
10224 {
10225 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10226
10227 if (line_len > max_salt_size)
10228 {
10229 parser_status = PARSER_GLOBAL_LENGTH;
10230 }
10231 else
10232 {
10233 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10234
10235 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10236
10237 hashes_buf->salt->salt_len = line_len;
10238
10239 parser_status = PARSER_OK;
10240 }
10241 }
10242
10243 // if NOT parsed without error, we add the ":" to the plain
10244
10245 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10246 {
10247 plain_len++;
10248 plain_buf--;
10249 }
10250
10251 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10252
10253 if (parser_status < PARSER_GLOBAL_ZERO)
10254 {
10255 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10256
10257 continue;
10258 }
10259
10260 if (plain_len >= 255) continue;
10261
10262 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10263
10264 pot_ptr->plain_len = plain_len;
10265
10266 pot_cnt++;
10267 }
10268
10269 fclose (pot_fp);
10270
10271 SUPPRESS_OUTPUT = 0;
10272
10273 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10274 }
10275
10276 /**
10277 * kernel accel and loops auto adjustment
10278 */
10279
10280 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10281 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10282
10283 if (workload_profile == 1)
10284 {
10285 kernel_loops /= 8;
10286 kernel_accel /= 4;
10287
10288 if (kernel_loops == 0) kernel_loops = 8;
10289 if (kernel_accel == 0) kernel_accel = 2;
10290 }
10291 else if (workload_profile == 3)
10292 {
10293 kernel_loops *= 8;
10294 kernel_accel *= 4;
10295
10296 if (kernel_loops > 1024) kernel_loops = 1024;
10297 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10298 }
10299
10300 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10301
10302 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10303 {
10304 kernel_loops = 1024;
10305 }
10306
10307 if (hash_mode == 12500)
10308 {
10309 kernel_loops = ROUNDS_RAR3 / 16;
10310 }
10311
10312 data.kernel_accel = kernel_accel;
10313 data.kernel_loops = kernel_loops;
10314
10315 /**
10316 * word len
10317 */
10318
10319 uint pw_min = PW_MIN;
10320 uint pw_max = PW_MAX;
10321
10322 switch (hash_mode)
10323 {
10324 case 400: if (pw_max > 40) pw_max = 40;
10325 break;
10326 case 500: if (pw_max > 16) pw_max = 16;
10327 break;
10328 case 1500: if (pw_max > 8) pw_max = 8;
10329 break;
10330 case 1600: if (pw_max > 16) pw_max = 16;
10331 break;
10332 case 1800: if (pw_max > 16) pw_max = 16;
10333 break;
10334 case 2100: if (pw_max > 16) pw_max = 16;
10335 break;
10336 case 2500: if (pw_min < 8) pw_min = 8;
10337 break;
10338 case 3000: if (pw_max > 7) pw_max = 7;
10339 break;
10340 case 5200: if (pw_max > 24) pw_max = 24;
10341 break;
10342 case 5800: if (pw_max > 16) pw_max = 16;
10343 break;
10344 case 6300: if (pw_max > 16) pw_max = 16;
10345 break;
10346 case 7400: if (pw_max > 16) pw_max = 16;
10347 break;
10348 case 7900: if (pw_max > 48) pw_max = 48;
10349 break;
10350 case 8500: if (pw_max > 8) pw_max = 8;
10351 break;
10352 case 8600: if (pw_max > 16) pw_max = 16;
10353 break;
10354 case 9710: pw_min = 5;
10355 pw_max = 5;
10356 break;
10357 case 9810: pw_min = 5;
10358 pw_max = 5;
10359 break;
10360 case 10410: pw_min = 5;
10361 pw_max = 5;
10362 break;
10363 case 10300: if (pw_max < 3) pw_min = 3;
10364 if (pw_max > 40) pw_max = 40;
10365 break;
10366 case 10500: if (pw_max < 3) pw_min = 3;
10367 if (pw_max > 40) pw_max = 40;
10368 break;
10369 case 10700: if (pw_max > 16) pw_max = 16;
10370 break;
10371 case 11300: if (pw_max > 40) pw_max = 40;
10372 break;
10373 case 12500: if (pw_max > 20) pw_max = 20;
10374 break;
10375 case 12800: if (pw_max > 24) pw_max = 24;
10376 break;
10377 }
10378
10379 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10380 {
10381 switch (attack_kern)
10382 {
10383 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10384 break;
10385 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10386 break;
10387 }
10388 }
10389
10390 /**
10391 * charsets : keep them together for more easy maintainnce
10392 */
10393
10394 cs_t mp_sys[6] = { { { 0 }, 0 } };
10395 cs_t mp_usr[4] = { { { 0 }, 0 } };
10396
10397 mp_setup_sys (mp_sys);
10398
10399 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10400 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10401 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10402 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10403
10404 /**
10405 * load hashes, part I: find input mode, count hashes
10406 */
10407
10408 uint hashlist_mode = 0;
10409 uint hashlist_format = HLFMT_HASHCAT;
10410
10411 uint hashes_avail = 0;
10412
10413 if (benchmark == 0)
10414 {
10415 struct stat f;
10416
10417 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10418
10419 if ((hash_mode == 2500) ||
10420 (hash_mode == 5200) ||
10421 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10422 (hash_mode == 9000))
10423 {
10424 hashlist_mode = HL_MODE_ARG;
10425
10426 char *hashfile = myargv[optind];
10427
10428 data.hashfile = hashfile;
10429
10430 logfile_top_var_string ("target", hashfile);
10431 }
10432
10433 if (hashlist_mode == HL_MODE_ARG)
10434 {
10435 if (hash_mode == 2500)
10436 {
10437 struct stat st;
10438
10439 if (stat (data.hashfile, &st) == -1)
10440 {
10441 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10442
10443 return (-1);
10444 }
10445
10446 hashes_avail = st.st_size / sizeof (hccap_t);
10447 }
10448 else
10449 {
10450 hashes_avail = 1;
10451 }
10452 }
10453 else if (hashlist_mode == HL_MODE_FILE)
10454 {
10455 char *hashfile = myargv[optind];
10456
10457 data.hashfile = hashfile;
10458
10459 logfile_top_var_string ("target", hashfile);
10460
10461 FILE *fp = NULL;
10462
10463 if ((fp = fopen (hashfile, "rb")) == NULL)
10464 {
10465 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10466
10467 return (-1);
10468 }
10469
10470 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10471
10472 hashes_avail = count_lines (fp);
10473
10474 rewind (fp);
10475
10476 if (hashes_avail == 0)
10477 {
10478 log_error ("ERROR: hashfile is empty or corrupt");
10479
10480 fclose (fp);
10481
10482 return (-1);
10483 }
10484
10485 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10486
10487 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10488 {
10489 log_error ("ERROR: remove not supported in native hashfile-format mode");
10490
10491 fclose (fp);
10492
10493 return (-1);
10494 }
10495
10496 fclose (fp);
10497 }
10498 }
10499 else
10500 {
10501 hashlist_mode = HL_MODE_ARG;
10502
10503 hashes_avail = 1;
10504 }
10505
10506 if (hash_mode == 3000) hashes_avail *= 2;
10507
10508 data.hashlist_mode = hashlist_mode;
10509 data.hashlist_format = hashlist_format;
10510
10511 logfile_top_uint (hashlist_mode);
10512 logfile_top_uint (hashlist_format);
10513
10514 /**
10515 * load hashes, part II: allocate required memory, set pointers
10516 */
10517
10518 hash_t *hashes_buf = NULL;
10519 void *digests_buf = NULL;
10520 salt_t *salts_buf = NULL;
10521 void *esalts_buf = NULL;
10522
10523 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10524
10525 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10526
10527 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10528 {
10529 u32 hash_pos;
10530
10531 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10532 {
10533 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10534
10535 hashes_buf[hash_pos].hash_info = hash_info;
10536
10537 if (username && (remove || show || left))
10538 {
10539 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10540 }
10541
10542 if (benchmark)
10543 {
10544 hash_info->orighash = (char *) mymalloc (256);
10545 }
10546 }
10547 }
10548
10549 if (isSalted)
10550 {
10551 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10552
10553 if (esalt_size)
10554 {
10555 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10556 }
10557 }
10558 else
10559 {
10560 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10561 }
10562
10563 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10564 {
10565 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10566
10567 if (isSalted)
10568 {
10569 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10570
10571 if (esalt_size)
10572 {
10573 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10574 }
10575 }
10576 else
10577 {
10578 hashes_buf[hash_pos].salt = &salts_buf[0];
10579 }
10580 }
10581
10582 /**
10583 * load hashes, part III: parse hashes or generate them if benchmark
10584 */
10585
10586 uint hashes_cnt = 0;
10587
10588 if (benchmark == 0)
10589 {
10590 if (keyspace == 1)
10591 {
10592 // useless to read hash file for keyspace, cheat a little bit w/ optind
10593 }
10594 else if (hashes_avail == 0)
10595 {
10596 }
10597 else if (hashlist_mode == HL_MODE_ARG)
10598 {
10599 char *input_buf = myargv[optind];
10600
10601 uint input_len = strlen (input_buf);
10602
10603 logfile_top_var_string ("target", input_buf);
10604
10605 char *hash_buf = NULL;
10606 int hash_len = 0;
10607
10608 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10609
10610 if (hash_len)
10611 {
10612 if (opts_type & OPTS_TYPE_HASH_COPY)
10613 {
10614 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10615
10616 hash_info_tmp->orighash = mystrdup (hash_buf);
10617 }
10618
10619 if (isSalted)
10620 {
10621 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10622 }
10623
10624 int parser_status = PARSER_OK;
10625
10626 if (hash_mode == 2500)
10627 {
10628 if (hash_len == 0)
10629 {
10630 log_error ("ERROR: hccap file not specified");
10631
10632 return (-1);
10633 }
10634
10635 hashlist_mode = HL_MODE_FILE;
10636
10637 data.hashlist_mode = hashlist_mode;
10638
10639 FILE *fp = fopen (hash_buf, "rb");
10640
10641 if (fp == NULL)
10642 {
10643 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10644
10645 return (-1);
10646 }
10647
10648 if (hashes_avail < 1)
10649 {
10650 log_error ("ERROR: hccap file is empty or corrupt");
10651
10652 fclose (fp);
10653
10654 return (-1);
10655 }
10656
10657 uint hccap_size = sizeof (hccap_t);
10658
10659 char in[hccap_size];
10660
10661 while (!feof (fp))
10662 {
10663 int n = fread (&in, hccap_size, 1, fp);
10664
10665 if (n != 1)
10666 {
10667 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10668
10669 break;
10670 }
10671
10672 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10673
10674 if (parser_status != PARSER_OK)
10675 {
10676 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10677
10678 continue;
10679 }
10680
10681 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10682
10683 if ((show == 1) || (left == 1))
10684 {
10685 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10686
10687 char *salt_ptr = (char *) tmp_salt->salt_buf;
10688
10689 int cur_pos = tmp_salt->salt_len;
10690 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10691
10692 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10693
10694 u8 *pke_ptr = (u8 *) wpa->pke;
10695
10696 // do the appending task
10697
10698 snprintf (salt_ptr + cur_pos,
10699 rem_len,
10700 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10701 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10702 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10703
10704
10705 // memset () the remaining part of the salt
10706
10707 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10708 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10709
10710 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10711
10712 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10713 }
10714
10715 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);
10716 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);
10717
10718 hashes_cnt++;
10719 }
10720
10721 fclose (fp);
10722 }
10723 else if (hash_mode == 3000)
10724 {
10725 if (hash_len == 32)
10726 {
10727 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10728
10729 hash_t *lm_hash_left = NULL;
10730
10731 if (parser_status == PARSER_OK)
10732 {
10733 lm_hash_left = &hashes_buf[hashes_cnt];
10734
10735 hashes_cnt++;
10736 }
10737 else
10738 {
10739 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10740 }
10741
10742
10743 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10744
10745 hash_t *lm_hash_right = NULL;
10746
10747 if (parser_status == PARSER_OK)
10748 {
10749 lm_hash_right = &hashes_buf[hashes_cnt];
10750
10751 hashes_cnt++;
10752 }
10753 else
10754 {
10755 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10756 }
10757
10758 // show / left
10759
10760 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10761 {
10762 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);
10763 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);
10764 }
10765 }
10766 else
10767 {
10768 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10769
10770 if (parser_status == PARSER_OK)
10771 {
10772 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10773 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10774 }
10775
10776 if (parser_status == PARSER_OK)
10777 {
10778 hashes_cnt++;
10779 }
10780 else
10781 {
10782 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10783 }
10784 }
10785 }
10786 else
10787 {
10788 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10789
10790 if (parser_status == PARSER_OK)
10791 {
10792 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10793 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10794 }
10795
10796 if (parser_status == PARSER_OK)
10797 {
10798 hashes_cnt++;
10799 }
10800 else
10801 {
10802 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10803 }
10804 }
10805 }
10806 }
10807 else if (hashlist_mode == HL_MODE_FILE)
10808 {
10809 char *hashfile = data.hashfile;
10810
10811 FILE *fp;
10812
10813 if ((fp = fopen (hashfile, "rb")) == NULL)
10814 {
10815 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10816
10817 return (-1);
10818 }
10819
10820 uint line_num = 0;
10821
10822 while (!feof (fp))
10823 {
10824 line_num++;
10825
10826 char line_buf[BUFSIZ];
10827
10828 int line_len = fgetl (fp, line_buf);
10829
10830 if (line_len == 0) continue;
10831
10832 char *hash_buf = NULL;
10833 int hash_len = 0;
10834
10835 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10836
10837 if (username)
10838 {
10839 char *user_buf = NULL;
10840 int user_len = 0;
10841
10842 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10843
10844 if (remove || show)
10845 {
10846 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10847
10848 *user = (user_t *) malloc (sizeof (user_t));
10849
10850 user_t *user_ptr = *user;
10851
10852 if (user_buf != NULL)
10853 {
10854 user_ptr->user_name = mystrdup (user_buf);
10855 }
10856 else
10857 {
10858 user_ptr->user_name = mystrdup ("");
10859 }
10860
10861 user_ptr->user_len = user_len;
10862 }
10863 }
10864
10865 if (opts_type & OPTS_TYPE_HASH_COPY)
10866 {
10867 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10868
10869 hash_info_tmp->orighash = mystrdup (hash_buf);
10870 }
10871
10872 if (isSalted)
10873 {
10874 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10875 }
10876
10877 if (hash_mode == 3000)
10878 {
10879 if (hash_len == 32)
10880 {
10881 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10882
10883 if (parser_status < PARSER_GLOBAL_ZERO)
10884 {
10885 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10886
10887 continue;
10888 }
10889
10890 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10891
10892 hashes_cnt++;
10893
10894 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10895
10896 if (parser_status < PARSER_GLOBAL_ZERO)
10897 {
10898 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10899
10900 continue;
10901 }
10902
10903 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10904
10905 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);
10906
10907 hashes_cnt++;
10908
10909 // show / left
10910
10911 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);
10912 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);
10913 }
10914 else
10915 {
10916 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10917
10918 if (parser_status < PARSER_GLOBAL_ZERO)
10919 {
10920 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10921
10922 continue;
10923 }
10924
10925 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);
10926
10927 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10928 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10929
10930 hashes_cnt++;
10931 }
10932 }
10933 else
10934 {
10935 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10936
10937 if (parser_status < PARSER_GLOBAL_ZERO)
10938 {
10939 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10940
10941 continue;
10942 }
10943
10944 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);
10945
10946 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10947 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10948
10949 hashes_cnt++;
10950 }
10951 }
10952
10953 fclose (fp);
10954
10955 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10956
10957 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10958 }
10959 }
10960 else
10961 {
10962 if (isSalted)
10963 {
10964 hashes_buf[0].salt->salt_len = 8;
10965
10966 // special salt handling
10967
10968 switch (hash_mode)
10969 {
10970 case 1500: hashes_buf[0].salt->salt_len = 2;
10971 break;
10972 case 1731: hashes_buf[0].salt->salt_len = 4;
10973 break;
10974 case 2410: hashes_buf[0].salt->salt_len = 4;
10975 break;
10976 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10977 break;
10978 case 3100: hashes_buf[0].salt->salt_len = 1;
10979 break;
10980 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10981 break;
10982 case 5800: hashes_buf[0].salt->salt_len = 16;
10983 break;
10984 case 6800: hashes_buf[0].salt->salt_len = 32;
10985 break;
10986 case 8400: hashes_buf[0].salt->salt_len = 40;
10987 break;
10988 case 8800: hashes_buf[0].salt->salt_len = 16;
10989 break;
10990 case 8900: hashes_buf[0].salt->salt_len = 16;
10991 hashes_buf[0].salt->scrypt_N = 1024;
10992 hashes_buf[0].salt->scrypt_r = 1;
10993 hashes_buf[0].salt->scrypt_p = 1;
10994 break;
10995 case 9100: hashes_buf[0].salt->salt_len = 16;
10996 break;
10997 case 9300: hashes_buf[0].salt->salt_len = 14;
10998 hashes_buf[0].salt->scrypt_N = 16384;
10999 hashes_buf[0].salt->scrypt_r = 1;
11000 hashes_buf[0].salt->scrypt_p = 1;
11001 break;
11002 case 9400: hashes_buf[0].salt->salt_len = 16;
11003 break;
11004 case 9500: hashes_buf[0].salt->salt_len = 16;
11005 break;
11006 case 9600: hashes_buf[0].salt->salt_len = 16;
11007 break;
11008 case 9700: hashes_buf[0].salt->salt_len = 16;
11009 break;
11010 case 9710: hashes_buf[0].salt->salt_len = 16;
11011 break;
11012 case 9720: hashes_buf[0].salt->salt_len = 16;
11013 break;
11014 case 9800: hashes_buf[0].salt->salt_len = 16;
11015 break;
11016 case 9810: hashes_buf[0].salt->salt_len = 16;
11017 break;
11018 case 9820: hashes_buf[0].salt->salt_len = 16;
11019 break;
11020 case 10300: hashes_buf[0].salt->salt_len = 12;
11021 break;
11022 case 11500: hashes_buf[0].salt->salt_len = 4;
11023 break;
11024 case 11600: hashes_buf[0].salt->salt_len = 4;
11025 break;
11026 case 12400: hashes_buf[0].salt->salt_len = 4;
11027 break;
11028 case 12500: hashes_buf[0].salt->salt_len = 8;
11029 break;
11030 case 12600: hashes_buf[0].salt->salt_len = 64;
11031 break;
11032 }
11033
11034 // special esalt handling
11035
11036 switch (hash_mode)
11037 {
11038 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11039 break;
11040 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11041 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11042 break;
11043 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11044 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11045 break;
11046 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11047 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11048 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11049 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11050 break;
11051 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11052 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11053 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11054 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11055 break;
11056 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11057 break;
11058 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11059 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11060 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11061 break;
11062 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11063 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11064 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11065 break;
11066 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11067 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11068 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11069 break;
11070 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11071 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11072 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11073 break;
11074 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11075 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11076 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11077 break;
11078 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11079 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11080 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11081 break;
11082 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11083 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11084 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11085 break;
11086 }
11087 }
11088
11089 // set hashfile
11090
11091 switch (hash_mode)
11092 {
11093 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11094 break;
11095 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11096 break;
11097 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11098 break;
11099 case 6211:
11100 case 6212:
11101 case 6213:
11102 case 6221:
11103 case 6222:
11104 case 6223:
11105 case 6231:
11106 case 6232:
11107 case 6233:
11108 case 6241:
11109 case 6242:
11110 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11111 break;
11112 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11113 break;
11114 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11115 break;
11116 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11117 break;
11118 }
11119
11120 // set default iterations
11121
11122 switch (hash_mode)
11123 {
11124 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11125 break;
11126 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11127 break;
11128 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11129 break;
11130 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11131 break;
11132 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11133 break;
11134 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11135 break;
11136 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11137 break;
11138 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11139 break;
11140 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11141 break;
11142 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11143 break;
11144 case 6211:
11145 case 6212:
11146 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11147 break;
11148 case 6221:
11149 case 6222:
11150 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11151 break;
11152 case 6231:
11153 case 6232:
11154 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11155 break;
11156 case 6241:
11157 case 6242:
11158 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11159 break;
11160 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11161 break;
11162 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11163 break;
11164 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11165 break;
11166 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11167 break;
11168 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11169 break;
11170 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11171 break;
11172 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11173 break;
11174 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11175 break;
11176 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11177 break;
11178 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11179 break;
11180 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11181 break;
11182 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11183 break;
11184 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11185 break;
11186 case 8900: hashes_buf[0].salt->salt_iter = 1;
11187 break;
11188 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11189 break;
11190 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11191 break;
11192 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11193 break;
11194 case 9300: hashes_buf[0].salt->salt_iter = 1;
11195 break;
11196 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11197 break;
11198 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11199 break;
11200 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11201 break;
11202 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11203 break;
11204 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11205 break;
11206 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11207 break;
11208 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11209 break;
11210 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11211 break;
11212 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11213 break;
11214 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11215 break;
11216 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11217 break;
11218 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11219 break;
11220 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11221 break;
11222 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11223 break;
11224 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11225 break;
11226 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11227 break;
11228 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11229 break;
11230 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11231 break;
11232 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11233 break;
11234 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11235 break;
11236 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11237 break;
11238 }
11239
11240 // set special tuning for benchmark-mode 1
11241
11242 if (benchmark_mode == 1)
11243 {
11244 kernel_loops *= 8;
11245 kernel_accel *= 4;
11246
11247 switch (hash_mode)
11248 {
11249 case 400: kernel_loops = ROUNDS_PHPASS;
11250 kernel_accel = 32;
11251 break;
11252 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11253 kernel_accel = 32;
11254 break;
11255 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11256 kernel_accel = 32;
11257 break;
11258 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11259 kernel_accel = 32;
11260 break;
11261 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11262 kernel_accel = 16;
11263 break;
11264 case 2100: kernel_loops = ROUNDS_DCC2;
11265 kernel_accel = 16;
11266 break;
11267 case 2500: kernel_loops = ROUNDS_WPA2;
11268 kernel_accel = 32;
11269 break;
11270 case 3200: kernel_loops = ROUNDS_BCRYPT;
11271 kernel_accel = 8;
11272 break;
11273 case 5200: kernel_loops = ROUNDS_PSAFE3;
11274 kernel_accel = 16;
11275 break;
11276 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11277 kernel_accel = 16;
11278 break;
11279 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11280 kernel_accel = 64;
11281 break;
11282 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11283 kernel_accel = 32;
11284 break;
11285 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11286 kernel_accel = 32;
11287 break;
11288 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11289 kernel_accel = 8;
11290 break;
11291 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11292 kernel_accel = 8;
11293 break;
11294 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11295 kernel_accel = 8;
11296 break;
11297 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11298 kernel_accel = 8;
11299 break;
11300 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11301 kernel_accel = 8;
11302 break;
11303 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11304 kernel_accel = 8;
11305 break;
11306 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11307 kernel_accel = 128;
11308 break;
11309 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11310 kernel_accel = 64;
11311 break;
11312 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11313 kernel_accel = 64;
11314 break;
11315 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11316 kernel_accel = 32;
11317 break;
11318 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11319 kernel_accel = 128;
11320 break;
11321 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11322 kernel_accel = 128;
11323 break;
11324 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11325 kernel_accel = 32;
11326 break;
11327 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11328 kernel_accel = 64;
11329 break;
11330 case 6800: kernel_loops = ROUNDS_LASTPASS;
11331 kernel_accel = 64;
11332 break;
11333 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11334 kernel_accel = 8;
11335 break;
11336 case 7200: kernel_loops = ROUNDS_GRUB;
11337 kernel_accel = 16;
11338 break;
11339 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11340 kernel_accel = 8;
11341 break;
11342 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11343 kernel_accel = 8;
11344 break;
11345 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11346 kernel_accel = 8;
11347 break;
11348 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11349 kernel_accel = 32;
11350 break;
11351 case 8900: kernel_loops = 1;
11352 kernel_accel = 64;
11353 break;
11354 case 9000: kernel_loops = ROUNDS_PSAFE2;
11355 kernel_accel = 16;
11356 break;
11357 case 9100: kernel_loops = ROUNDS_LOTUS8;
11358 kernel_accel = 64;
11359 break;
11360 case 9200: kernel_loops = ROUNDS_CISCO8;
11361 kernel_accel = 8;
11362 break;
11363 case 9300: kernel_loops = 1;
11364 kernel_accel = 4;
11365 break;
11366 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11367 kernel_accel = 32;
11368 break;
11369 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11370 kernel_accel = 32;
11371 break;
11372 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11373 kernel_accel = 8;
11374 break;
11375 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11376 kernel_accel = 8;
11377 break;
11378 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11379 kernel_accel = 16;
11380 break;
11381 case 10500: kernel_loops = ROUNDS_PDF14;
11382 kernel_accel = 256;
11383 break;
11384 case 10700: kernel_loops = ROUNDS_PDF17L8;
11385 kernel_accel = 8;
11386 break;
11387 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11388 kernel_accel = 8;
11389 break;
11390 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11391 kernel_accel = 8;
11392 break;
11393 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11394 kernel_accel = 8;
11395 break;
11396 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11397 kernel_accel = 8;
11398 break;
11399 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11400 kernel_accel = 8;
11401 break;
11402 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11403 kernel_accel = 8;
11404 break;
11405 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11406 kernel_accel = 8;
11407 break;
11408 case 12300: kernel_loops = ROUNDS_ORACLET;
11409 kernel_accel = 8;
11410 break;
11411 case 12500: kernel_loops = ROUNDS_RAR3;
11412 kernel_accel = 32;
11413 break;
11414 case 12700: kernel_loops = ROUNDS_MYWALLET;
11415 kernel_accel = 512;
11416 break;
11417 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11418 kernel_accel = 512;
11419 break;
11420 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11421 kernel_accel = 8;
11422 break;
11423 case 13000: kernel_loops = ROUNDS_RAR5;
11424 kernel_accel = 8;
11425 break;
11426 }
11427
11428 // some algorithm collide too fast, make that impossible
11429
11430 switch (hash_mode)
11431 {
11432 case 11500: ((uint *) digests_buf)[1] = 1;
11433 break;
11434 }
11435
11436 if (kernel_loops > 1024) kernel_loops = 1024;
11437 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11438 }
11439
11440 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11441 {
11442 kernel_loops = 1024;
11443 }
11444
11445 if (hash_mode == 12500)
11446 {
11447 kernel_loops = ROUNDS_RAR3 / 16;
11448 }
11449
11450 data.kernel_accel = kernel_accel;
11451 data.kernel_loops = kernel_loops;
11452
11453 hashes_cnt = 1;
11454 }
11455
11456 if (show == 1 || left == 1)
11457 {
11458 for (uint i = 0; i < pot_cnt; i++)
11459 {
11460 pot_t *pot_ptr = &pot[i];
11461
11462 hash_t *hashes_buf = &pot_ptr->hash;
11463
11464 local_free (hashes_buf->digest);
11465
11466 if (isSalted)
11467 {
11468 local_free (hashes_buf->salt);
11469 }
11470 }
11471
11472 local_free (pot);
11473
11474 if (data.quiet == 0) log_info_nn ("");
11475
11476 return (0);
11477 }
11478
11479 if (keyspace == 0)
11480 {
11481 if (hashes_cnt == 0)
11482 {
11483 log_error ("ERROR: No hashes loaded");
11484
11485 return (-1);
11486 }
11487 }
11488
11489 /**
11490 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11491 */
11492
11493 if (data.outfile != NULL)
11494 {
11495 if (data.hashfile != NULL)
11496 {
11497 #ifdef _POSIX
11498 struct stat tmpstat_outfile;
11499 struct stat tmpstat_hashfile;
11500 #endif
11501
11502 #ifdef _WIN
11503 struct stat64 tmpstat_outfile;
11504 struct stat64 tmpstat_hashfile;
11505 #endif
11506
11507 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11508
11509 if (tmp_outfile_fp)
11510 {
11511 #ifdef _POSIX
11512 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11513 #endif
11514
11515 #ifdef _WIN
11516 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11517 #endif
11518
11519 fclose (tmp_outfile_fp);
11520 }
11521
11522 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11523
11524 if (tmp_hashfile_fp)
11525 {
11526 #ifdef _POSIX
11527 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11528 #endif
11529
11530 #ifdef _WIN
11531 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11532 #endif
11533
11534 fclose (tmp_hashfile_fp);
11535 }
11536
11537 if (tmp_outfile_fp && tmp_outfile_fp)
11538 {
11539 tmpstat_outfile.st_mode = 0;
11540 tmpstat_outfile.st_nlink = 0;
11541 tmpstat_outfile.st_uid = 0;
11542 tmpstat_outfile.st_gid = 0;
11543 tmpstat_outfile.st_rdev = 0;
11544 tmpstat_outfile.st_atime = 0;
11545
11546 tmpstat_hashfile.st_mode = 0;
11547 tmpstat_hashfile.st_nlink = 0;
11548 tmpstat_hashfile.st_uid = 0;
11549 tmpstat_hashfile.st_gid = 0;
11550 tmpstat_hashfile.st_rdev = 0;
11551 tmpstat_hashfile.st_atime = 0;
11552
11553 #ifdef _POSIX
11554 tmpstat_outfile.st_blksize = 0;
11555 tmpstat_outfile.st_blocks = 0;
11556
11557 tmpstat_hashfile.st_blksize = 0;
11558 tmpstat_hashfile.st_blocks = 0;
11559 #endif
11560
11561 #ifdef _POSIX
11562 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11563 {
11564 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11565
11566 return (-1);
11567 }
11568 #endif
11569
11570 #ifdef _WIN
11571 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11572 {
11573 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11574
11575 return (-1);
11576 }
11577 #endif
11578 }
11579 }
11580 }
11581
11582 /**
11583 * Remove duplicates
11584 */
11585
11586 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11587
11588 if (isSalted)
11589 {
11590 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11591 }
11592 else
11593 {
11594 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11595 }
11596
11597 uint hashes_cnt_orig = hashes_cnt;
11598
11599 hashes_cnt = 1;
11600
11601 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11602 {
11603 if (isSalted)
11604 {
11605 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11606 {
11607 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11608 }
11609 }
11610 else
11611 {
11612 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11613 }
11614
11615 if (hashes_pos > hashes_cnt)
11616 {
11617 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11618 }
11619
11620 hashes_cnt++;
11621 }
11622
11623 /**
11624 * Potfile removes
11625 */
11626
11627 uint potfile_remove_cracks = 0;
11628
11629 if (potfile_disable == 0)
11630 {
11631 hash_t hash_buf;
11632
11633 hash_buf.digest = mymalloc (dgst_size);
11634 hash_buf.salt = NULL;
11635 hash_buf.esalt = NULL;
11636 hash_buf.hash_info = NULL;
11637 hash_buf.cracked = 0;
11638
11639 if (isSalted)
11640 {
11641 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11642 }
11643
11644 if (esalt_size)
11645 {
11646 hash_buf.esalt = mymalloc (esalt_size);
11647 }
11648
11649 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11650
11651 // no solution for these special hash types (for instane because they use hashfile in output etc)
11652 if ((hash_mode != 5200) &&
11653 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11654 (hash_mode != 9000))
11655 {
11656 FILE *fp = fopen (potfile, "rb");
11657
11658 if (fp != NULL)
11659 {
11660 while (!feof (fp))
11661 {
11662 char line_buf[BUFSIZ];
11663
11664 memset (line_buf, 0, BUFSIZ);
11665
11666 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11667
11668 if (ptr == NULL) break;
11669
11670 int line_len = strlen (line_buf);
11671
11672 if (line_len == 0) continue;
11673
11674 int iter = MAX_CUT_TRIES;
11675
11676 for (int i = line_len - 1; i && iter; i--, line_len--)
11677 {
11678 if (line_buf[i] != ':') continue;
11679
11680 if (isSalted)
11681 {
11682 memset (hash_buf.salt, 0, sizeof (salt_t));
11683 }
11684
11685 hash_t *found = NULL;
11686
11687 if (hash_mode == 6800)
11688 {
11689 if (i < 48) // 48 = 12 * uint in salt_buf[]
11690 {
11691 // manipulate salt_buf
11692 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11693
11694 hash_buf.salt->salt_len = i;
11695
11696 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11697 }
11698 }
11699 else if (hash_mode == 2500)
11700 {
11701 if (i < 48) // 48 = 12 * uint in salt_buf[]
11702 {
11703 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11704 // manipulate salt_buf
11705
11706 // to be safe work with a copy (because of line_len loop, i etc)
11707
11708 char line_buf_cpy[BUFSIZ];
11709 memset (line_buf_cpy, 0, BUFSIZ);
11710
11711 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11712
11713 memcpy (line_buf_cpy, line_buf, i);
11714
11715 char *mac2_pos = strrchr (line_buf_cpy, ':');
11716
11717 if (mac2_pos == NULL) continue;
11718
11719 mac2_pos[0] = 0;
11720 mac2_pos++;
11721
11722 if (strlen (mac2_pos) != 12) continue;
11723
11724 char *mac1_pos = strrchr (line_buf_cpy, ':');
11725
11726 if (mac1_pos == NULL) continue;
11727
11728 mac1_pos[0] = 0;
11729 mac1_pos++;
11730
11731 if (strlen (mac1_pos) != 12) continue;
11732
11733 uint essid_length = mac1_pos - line_buf_cpy - 1;
11734
11735 // here we need the ESSID
11736 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11737
11738 hash_buf.salt->salt_len = essid_length;
11739
11740 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11741
11742 if (found)
11743 {
11744 wpa_t *wpa = (wpa_t *) found->esalt;
11745
11746 uint pke[25];
11747
11748 char *pke_ptr = (char *) pke;
11749
11750 for (uint i = 0; i < 25; i++)
11751 {
11752 pke[i] = byte_swap_32 (wpa->pke[i]);
11753 }
11754
11755 u8 mac1[6];
11756 u8 mac2[6];
11757
11758 memcpy (mac1, pke_ptr + 23, 6);
11759 memcpy (mac2, pke_ptr + 29, 6);
11760
11761 // compare hex string(s) vs binary MAC address(es)
11762
11763 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11764 {
11765 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11766 {
11767 found = NULL;
11768 break;
11769 }
11770 }
11771
11772 // early skip ;)
11773 if (!found) continue;
11774
11775 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11776 {
11777 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11778 {
11779 found = NULL;
11780 break;
11781 }
11782 }
11783 }
11784 }
11785 }
11786 else
11787 {
11788 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11789
11790 if (parser_status == PARSER_OK)
11791 {
11792 if (isSalted)
11793 {
11794 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11795 }
11796 else
11797 {
11798 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11799 }
11800 }
11801 }
11802
11803 if (found == NULL) continue;
11804
11805 if (!found->cracked) potfile_remove_cracks++;
11806
11807 found->cracked = 1;
11808
11809 if (found) break;
11810
11811 iter--;
11812 }
11813 }
11814
11815 fclose (fp);
11816 }
11817 }
11818
11819 if (esalt_size)
11820 {
11821 local_free (hash_buf.esalt);
11822 }
11823
11824 if (isSalted)
11825 {
11826 local_free (hash_buf.salt);
11827 }
11828
11829 local_free (hash_buf.digest);
11830 }
11831
11832 /**
11833 * Now generate all the buffers required for later
11834 */
11835
11836 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11837
11838 salt_t *salts_buf_new = NULL;
11839 void *esalts_buf_new = NULL;
11840
11841 if (isSalted)
11842 {
11843 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11844
11845 if (esalt_size)
11846 {
11847 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11848 }
11849 }
11850 else
11851 {
11852 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11853 }
11854
11855 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11856
11857 uint digests_cnt = hashes_cnt;
11858 uint digests_done = 0;
11859
11860 uint size_digests = digests_cnt * dgst_size;
11861 uint size_shown = digests_cnt * sizeof (uint);
11862
11863 uint *digests_shown = (uint *) mymalloc (size_shown);
11864 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11865
11866 uint salts_cnt = 0;
11867 uint salts_done = 0;
11868
11869 hashinfo_t **hash_info = NULL;
11870
11871 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11872 {
11873 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11874
11875 if (username && (remove || show))
11876 {
11877 uint user_pos;
11878
11879 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11880 {
11881 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11882
11883 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11884 }
11885 }
11886 }
11887
11888 uint *salts_shown = (uint *) mymalloc (size_shown);
11889
11890 salt_t *salt_buf;
11891
11892 {
11893 // copied from inner loop
11894
11895 salt_buf = &salts_buf_new[salts_cnt];
11896
11897 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11898
11899 if (esalt_size)
11900 {
11901 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11902 }
11903
11904 salt_buf->digests_cnt = 0;
11905 salt_buf->digests_done = 0;
11906 salt_buf->digests_offset = 0;
11907
11908 salts_cnt++;
11909 }
11910
11911 if (hashes_buf[0].cracked == 1)
11912 {
11913 digests_shown[0] = 1;
11914
11915 digests_done++;
11916
11917 salt_buf->digests_done++;
11918 }
11919
11920 salt_buf->digests_cnt++;
11921
11922 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11923
11924 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11925 {
11926 hash_info[0] = hashes_buf[0].hash_info;
11927 }
11928
11929 // copy from inner loop
11930
11931 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11932 {
11933 if (isSalted)
11934 {
11935 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11936 {
11937 salt_buf = &salts_buf_new[salts_cnt];
11938
11939 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11940
11941 if (esalt_size)
11942 {
11943 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11944 }
11945
11946 salt_buf->digests_cnt = 0;
11947 salt_buf->digests_done = 0;
11948 salt_buf->digests_offset = hashes_pos;
11949
11950 salts_cnt++;
11951 }
11952 }
11953
11954 if (hashes_buf[hashes_pos].cracked == 1)
11955 {
11956 digests_shown[hashes_pos] = 1;
11957
11958 digests_done++;
11959
11960 salt_buf->digests_done++;
11961 }
11962
11963 salt_buf->digests_cnt++;
11964
11965 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11966
11967 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11968 {
11969 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11970 }
11971 }
11972
11973 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11974 {
11975 salt_t *salt_buf = &salts_buf_new[salt_pos];
11976
11977 if (salt_buf->digests_done == salt_buf->digests_cnt)
11978 {
11979 salts_shown[salt_pos] = 1;
11980
11981 salts_done++;
11982 }
11983
11984 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11985 }
11986
11987 local_free (digests_buf);
11988 local_free (salts_buf);
11989 local_free (esalts_buf);
11990
11991 digests_buf = digests_buf_new;
11992 salts_buf = salts_buf_new;
11993 esalts_buf = esalts_buf_new;
11994
11995 local_free (hashes_buf);
11996
11997 /**
11998 * special modification not set from parser
11999 */
12000
12001 switch (hash_mode)
12002 {
12003 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12004 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12005 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12006 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12007 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12008 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12009 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12010 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12011 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12012 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12013 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12014 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12015 }
12016
12017 if (truecrypt_keyfiles)
12018 {
12019 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12020
12021 char *keyfiles = strdup (truecrypt_keyfiles);
12022
12023 char *keyfile = strtok (keyfiles, ",");
12024
12025 do
12026 {
12027 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12028
12029 } while ((keyfile = strtok (NULL, ",")) != NULL);
12030
12031 free (keyfiles);
12032 }
12033
12034 data.digests_cnt = digests_cnt;
12035 data.digests_done = digests_done;
12036 data.digests_buf = digests_buf;
12037 data.digests_shown = digests_shown;
12038 data.digests_shown_tmp = digests_shown_tmp;
12039
12040 data.salts_cnt = salts_cnt;
12041 data.salts_done = salts_done;
12042 data.salts_buf = salts_buf;
12043 data.salts_shown = salts_shown;
12044
12045 data.esalts_buf = esalts_buf;
12046 data.hash_info = hash_info;
12047
12048 /**
12049 * Automatic Optimizers
12050 */
12051
12052 if (salts_cnt == 1)
12053 opti_type |= OPTI_TYPE_SINGLE_SALT;
12054
12055 if (digests_cnt == 1)
12056 opti_type |= OPTI_TYPE_SINGLE_HASH;
12057
12058 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12059 opti_type |= OPTI_TYPE_NOT_ITERATED;
12060
12061 if (attack_mode == ATTACK_MODE_BF)
12062 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12063
12064 data.opti_type = opti_type;
12065
12066 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12067 {
12068 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12069 {
12070 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12071 {
12072 if (opts_type & OPTS_TYPE_ST_ADD80)
12073 {
12074 opts_type &= ~OPTS_TYPE_ST_ADD80;
12075 opts_type |= OPTS_TYPE_PT_ADD80;
12076 }
12077
12078 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12079 {
12080 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12081 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12082 }
12083
12084 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12085 {
12086 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12087 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12088 }
12089 }
12090 }
12091 }
12092
12093 /**
12094 * Some algorithm, like descrypt, can benefit from JIT compilation
12095 */
12096
12097 int force_jit_compilation = -1;
12098
12099 if (hash_mode == 8900)
12100 {
12101 force_jit_compilation = 8900;
12102 }
12103 else if (hash_mode == 9300)
12104 {
12105 force_jit_compilation = 8900;
12106 }
12107 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12108 {
12109 force_jit_compilation = 1500;
12110 }
12111
12112 /**
12113 * generate bitmap tables
12114 */
12115
12116 const uint bitmap_shift1 = 5;
12117 const uint bitmap_shift2 = 13;
12118
12119 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12120
12121 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12122 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12123 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12124 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12125 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12126 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12127 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12128 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12129
12130 uint bitmap_bits;
12131 uint bitmap_nums;
12132 uint bitmap_mask;
12133 uint bitmap_size;
12134
12135 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12136 {
12137 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12138
12139 bitmap_nums = 1 << bitmap_bits;
12140
12141 bitmap_mask = bitmap_nums - 1;
12142
12143 bitmap_size = bitmap_nums * sizeof (uint);
12144
12145 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12146
12147 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;
12148 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;
12149
12150 break;
12151 }
12152
12153 bitmap_nums = 1 << bitmap_bits;
12154
12155 bitmap_mask = bitmap_nums - 1;
12156
12157 bitmap_size = bitmap_nums * sizeof (uint);
12158
12159 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);
12160 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);
12161
12162 /**
12163 * prepare quick rule
12164 */
12165
12166 data.rule_buf_l = rule_buf_l;
12167 data.rule_buf_r = rule_buf_r;
12168
12169 int rule_len_l = (int) strlen (rule_buf_l);
12170 int rule_len_r = (int) strlen (rule_buf_r);
12171
12172 data.rule_len_l = rule_len_l;
12173 data.rule_len_r = rule_len_r;
12174
12175 /**
12176 * load rules
12177 */
12178
12179 uint *all_kernel_rules_cnt = NULL;
12180
12181 kernel_rule_t **all_kernel_rules_buf = NULL;
12182
12183 if (rp_files_cnt)
12184 {
12185 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12186
12187 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12188 }
12189
12190 char rule_buf[BUFSIZ];
12191
12192 int rule_len = 0;
12193
12194 for (uint i = 0; i < rp_files_cnt; i++)
12195 {
12196 uint kernel_rules_avail = 0;
12197
12198 uint kernel_rules_cnt = 0;
12199
12200 kernel_rule_t *kernel_rules_buf = NULL;
12201
12202 char *rp_file = rp_files[i];
12203
12204 char in[BLOCK_SIZE];
12205 char out[BLOCK_SIZE];
12206
12207 FILE *fp = NULL;
12208
12209 uint rule_line = 0;
12210
12211 if ((fp = fopen (rp_file, "rb")) == NULL)
12212 {
12213 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12214
12215 return (-1);
12216 }
12217
12218 while (!feof (fp))
12219 {
12220 memset (rule_buf, 0, BUFSIZ);
12221
12222 rule_len = fgetl (fp, rule_buf);
12223
12224 rule_line++;
12225
12226 if (rule_len == 0) continue;
12227
12228 if (rule_buf[0] == '#') continue;
12229
12230 if (kernel_rules_avail == kernel_rules_cnt)
12231 {
12232 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12233
12234 kernel_rules_avail += INCR_RULES;
12235 }
12236
12237 memset (in, 0, BLOCK_SIZE);
12238 memset (out, 0, BLOCK_SIZE);
12239
12240 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12241
12242 if (result == -1)
12243 {
12244 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12245
12246 continue;
12247 }
12248
12249 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12250 {
12251 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12252
12253 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12254
12255 continue;
12256 }
12257
12258 /* its so slow
12259 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12260 {
12261 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12262
12263 continue;
12264 }
12265 */
12266
12267 kernel_rules_cnt++;
12268 }
12269
12270 fclose (fp);
12271
12272 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12273
12274 all_kernel_rules_buf[i] = kernel_rules_buf;
12275 }
12276
12277 /**
12278 * merge rules or automatic rule generator
12279 */
12280
12281 uint kernel_rules_cnt = 0;
12282
12283 kernel_rule_t *kernel_rules_buf = NULL;
12284
12285 if (attack_mode == ATTACK_MODE_STRAIGHT)
12286 {
12287 if (rp_files_cnt)
12288 {
12289 kernel_rules_cnt = 1;
12290
12291 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12292
12293 repeats[0] = kernel_rules_cnt;
12294
12295 for (uint i = 0; i < rp_files_cnt; i++)
12296 {
12297 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12298
12299 repeats[i + 1] = kernel_rules_cnt;
12300 }
12301
12302 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12303
12304 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12305
12306 for (uint i = 0; i < kernel_rules_cnt; i++)
12307 {
12308 uint out_pos = 0;
12309
12310 kernel_rule_t *out = &kernel_rules_buf[i];
12311
12312 for (uint j = 0; j < rp_files_cnt; j++)
12313 {
12314 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12315 uint in_pos;
12316
12317 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12318
12319 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12320 {
12321 if (out_pos == RULES_MAX - 1)
12322 {
12323 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12324
12325 break;
12326 }
12327
12328 out->cmds[out_pos] = in->cmds[in_pos];
12329 }
12330 }
12331 }
12332
12333 local_free (repeats);
12334 }
12335 else if (rp_gen)
12336 {
12337 uint kernel_rules_avail = 0;
12338
12339 while (kernel_rules_cnt < rp_gen)
12340 {
12341 if (kernel_rules_avail == kernel_rules_cnt)
12342 {
12343 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12344
12345 kernel_rules_avail += INCR_RULES;
12346 }
12347
12348 memset (rule_buf, 0, BLOCK_SIZE);
12349
12350 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12351
12352 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12353
12354 kernel_rules_cnt++;
12355 }
12356 }
12357 }
12358
12359 /**
12360 * generate NOP rules
12361 */
12362
12363 if (kernel_rules_cnt == 0)
12364 {
12365 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12366
12367 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12368
12369 kernel_rules_cnt++;
12370 }
12371
12372 data.kernel_rules_cnt = kernel_rules_cnt;
12373 data.kernel_rules_buf = kernel_rules_buf;
12374
12375 /**
12376 * OpenCL platforms: detect
12377 */
12378
12379 cl_platform_id platforms[CL_PLATFORMS_MAX];
12380
12381 cl_uint platforms_cnt = 0;
12382
12383 cl_device_id platform_devices[DEVICES_MAX];
12384
12385 cl_uint platform_devices_cnt;
12386
12387 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12388
12389 if (platforms_cnt == 0)
12390 {
12391 log_error ("ERROR: No OpenCL compatible platform found");
12392
12393 return (-1);
12394 }
12395
12396 /**
12397 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12398 */
12399
12400 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12401 {
12402 cl_platform_id platform = platforms[platform_id];
12403
12404 char platform_vendor[INFOSZ] = { 0 };
12405
12406 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12407
12408 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12409 {
12410 // make sure that we do not directly control the fan for NVidia
12411
12412 gpu_temp_retain = 0;
12413
12414 data.gpu_temp_retain = gpu_temp_retain;
12415 }
12416 }
12417
12418 /**
12419 * OpenCL devices: simply push all devices from all platforms into the same device array
12420 */
12421
12422 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12423
12424 data.devices_param = devices_param;
12425
12426 uint devices_cnt = 0;
12427
12428 uint devices_active = 0;
12429
12430 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12431 {
12432 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12433
12434 cl_platform_id platform = platforms[platform_id];
12435
12436 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12437
12438 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12439 {
12440 const uint device_id = devices_cnt;
12441
12442 hc_device_param_t *device_param = &data.devices_param[device_id];
12443
12444 device_param->device = platform_devices[platform_devices_id];
12445
12446 device_param->device_id = device_id;
12447
12448 device_param->platform_devices_id = platform_devices_id;
12449
12450 // vendor_id
12451
12452 cl_uint vendor_id = 0;
12453
12454 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12455
12456 device_param->vendor_id = vendor_id;
12457
12458 // device_type
12459
12460 cl_device_type device_type;
12461
12462 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12463
12464 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12465
12466 device_param->device_type = device_type;
12467
12468 // device_name
12469
12470 char *device_name = (char *) mymalloc (INFOSZ);
12471
12472 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12473
12474 device_param->device_name = device_name;
12475
12476 // device_version
12477
12478 char *device_version = (char *) mymalloc (INFOSZ);
12479
12480 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12481
12482 device_param->device_version = device_version;
12483
12484 if (strstr (device_version, "pocl"))
12485 {
12486 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12487 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12488
12489 cl_uint vendor_id = 0xffff;
12490
12491 device_param->vendor_id = vendor_id;
12492 }
12493
12494 // max_compute_units
12495
12496 cl_uint device_processors;
12497
12498 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12499
12500 device_param->device_processors = device_processors;
12501
12502 // max_mem_alloc_size
12503
12504 cl_ulong device_maxmem_alloc;
12505
12506 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12507
12508 device_param->device_maxmem_alloc = device_maxmem_alloc;
12509
12510 // max_mem_alloc_size
12511
12512 cl_ulong device_global_mem;
12513
12514 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12515
12516 device_param->device_global_mem = device_global_mem;
12517
12518 // max_clock_frequency
12519
12520 cl_uint device_maxclock_frequency;
12521
12522 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12523
12524 device_param->device_maxclock_frequency = device_maxclock_frequency;
12525
12526 // skipped
12527
12528 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12529 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12530
12531 device_param->skipped = (skipped1 || skipped2);
12532
12533 // driver_version
12534
12535 char *driver_version = (char *) mymalloc (INFOSZ);
12536
12537 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12538
12539 device_param->driver_version = driver_version;
12540
12541 // device_name_chksum
12542
12543 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12544
12545 #if __x86_64__
12546 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);
12547 #else
12548 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);
12549 #endif
12550
12551 uint device_name_digest[4];
12552
12553 device_name_digest[0] = 0;
12554 device_name_digest[1] = 0;
12555 device_name_digest[2] = 0;
12556 device_name_digest[3] = 0;
12557
12558 md5_64 ((uint *) device_name_chksum, device_name_digest);
12559
12560 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12561
12562 device_param->device_name_chksum = device_name_chksum;
12563
12564 // device_processor_cores
12565
12566 if (device_type & CL_DEVICE_TYPE_CPU)
12567 {
12568 cl_uint device_processor_cores = 1;
12569
12570 device_param->device_processor_cores = device_processor_cores;
12571 }
12572
12573 if (device_type & CL_DEVICE_TYPE_GPU)
12574 {
12575 if (vendor_id == VENDOR_ID_AMD)
12576 {
12577 cl_uint device_processor_cores = 0;
12578
12579 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12580
12581 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12582
12583 device_param->device_processor_cores = device_processor_cores;
12584 }
12585 else if (vendor_id == VENDOR_ID_NV)
12586 {
12587 cl_uint kernel_exec_timeout = 0;
12588
12589 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12590
12591 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12592
12593 device_param->kernel_exec_timeout = kernel_exec_timeout;
12594
12595 cl_uint device_processor_cores = 0;
12596
12597 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12598
12599 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12600
12601 device_param->device_processor_cores = device_processor_cores;
12602
12603 cl_uint sm_minor = 0;
12604 cl_uint sm_major = 0;
12605
12606 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12607 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12608
12609 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12610 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12611
12612 device_param->sm_minor = sm_minor;
12613 device_param->sm_major = sm_major;
12614 }
12615 else
12616 {
12617 cl_uint device_processor_cores = 1;
12618
12619 device_param->device_processor_cores = device_processor_cores;
12620 }
12621 }
12622
12623 // display results
12624
12625 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12626 {
12627 if (device_param->skipped == 0)
12628 {
12629 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12630 device_id + 1,
12631 device_name,
12632 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12633 (unsigned int) (device_global_mem / 1024 / 1024),
12634 (unsigned int) (device_maxclock_frequency),
12635 (unsigned int) device_processors);
12636 }
12637 else
12638 {
12639 log_info ("Device #%u: %s, skipped",
12640 device_id + 1,
12641 device_name);
12642 }
12643 }
12644
12645 // common driver check
12646
12647 if (device_param->skipped == 0)
12648 {
12649 if (strstr (device_version, "pocl"))
12650 {
12651 if (force == 0)
12652 {
12653 log_info ("");
12654 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12655 log_info ("You are STRONGLY encouraged not to use it");
12656 log_info ("You can use --force to override this but do not post error reports if you do so");
12657 log_info ("");
12658
12659 return (-1);
12660 }
12661 }
12662
12663 if (device_type & CL_DEVICE_TYPE_GPU)
12664 {
12665 if (vendor_id == VENDOR_ID_NV)
12666 {
12667 if (device_param->kernel_exec_timeout != 0)
12668 {
12669 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);
12670 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12671 }
12672 }
12673 else if (vendor_id == VENDOR_ID_AMD)
12674 {
12675 int catalyst_check = (force == 1) ? 0 : 1;
12676
12677 int catalyst_warn = 0;
12678
12679 int catalyst_broken = 0;
12680
12681 if (catalyst_check == 1)
12682 {
12683 catalyst_warn = 1;
12684
12685 // v14.9 and higher
12686 if (atoi (device_param->driver_version) >= 1573)
12687 {
12688 catalyst_warn = 0;
12689 }
12690
12691 catalyst_check = 0;
12692 }
12693
12694 if (catalyst_broken == 1)
12695 {
12696 log_info ("");
12697 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12698 log_info ("It will pass over cracked hashes and does not report them as cracked");
12699 log_info ("You are STRONGLY encouraged not to use it");
12700 log_info ("You can use --force to override this but do not post error reports if you do so");
12701 log_info ("");
12702
12703 return (-1);
12704 }
12705
12706 if (catalyst_warn == 1)
12707 {
12708 log_info ("");
12709 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12710 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12711 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12712 #ifdef _WIN
12713 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12714 #endif
12715 log_info ("You can use --force to override this but do not post error reports if you do so");
12716 log_info ("");
12717
12718 return (-1);
12719 }
12720 }
12721 }
12722
12723 devices_active++;
12724 }
12725
12726 // next please
12727
12728 devices_cnt++;
12729 }
12730 }
12731
12732 if (devices_active == 0)
12733 {
12734 log_error ("ERROR: No devices found/left");
12735
12736 return (-1);
12737 }
12738
12739 data.devices_cnt = devices_cnt;
12740
12741 data.devices_active = devices_active;
12742
12743 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12744 {
12745 log_info ("");
12746 }
12747
12748 /**
12749 * OpenCL devices: allocate buffer for device specific information
12750 */
12751
12752 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12753
12754 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12755
12756 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12757
12758 /**
12759 * enable custom signal handler(s)
12760 */
12761
12762 if (benchmark == 0)
12763 {
12764 hc_signal (sigHandler_default);
12765 }
12766 else
12767 {
12768 hc_signal (sigHandler_benchmark);
12769 }
12770
12771 /**
12772 * User-defined GPU temp handling
12773 */
12774
12775 if (gpu_temp_disable == 1)
12776 {
12777 gpu_temp_abort = 0;
12778 gpu_temp_retain = 0;
12779 }
12780
12781 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12782 {
12783 if (gpu_temp_abort < gpu_temp_retain)
12784 {
12785 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12786
12787 return (-1);
12788 }
12789 }
12790
12791 data.gpu_temp_disable = gpu_temp_disable;
12792 data.gpu_temp_abort = gpu_temp_abort;
12793 data.gpu_temp_retain = gpu_temp_retain;
12794
12795 /**
12796 * inform the user
12797 */
12798
12799 if (data.quiet == 0)
12800 {
12801 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12802
12803 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);
12804
12805 if (attack_mode == ATTACK_MODE_STRAIGHT)
12806 {
12807 log_info ("Rules: %u", kernel_rules_cnt);
12808 }
12809
12810 if (opti_type)
12811 {
12812 log_info ("Applicable Optimizers:");
12813
12814 for (uint i = 0; i < 32; i++)
12815 {
12816 const uint opti_bit = 1u << i;
12817
12818 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12819 }
12820 }
12821
12822 /**
12823 * Watchdog and Temperature balance
12824 */
12825
12826 if (gpu_temp_abort == 0)
12827 {
12828 log_info ("Watchdog: Temperature abort trigger disabled");
12829 }
12830 else
12831 {
12832 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12833 }
12834
12835 if (gpu_temp_retain == 0)
12836 {
12837 log_info ("Watchdog: Temperature retain trigger disabled");
12838 }
12839 else
12840 {
12841 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12842 }
12843 }
12844
12845 if (data.quiet == 0) log_info ("");
12846
12847 /**
12848 * HM devices: init
12849 */
12850
12851 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12852 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12853
12854 if (gpu_temp_disable == 0)
12855 {
12856 #ifdef WIN
12857 if (NvAPI_Initialize () == NVAPI_OK)
12858 {
12859 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12860
12861 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12862
12863 int tmp_out = 0;
12864
12865 for (int i = 0; i < tmp_in; i++)
12866 {
12867 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12868 }
12869
12870 for (int i = 0; i < tmp_out; i++)
12871 {
12872 NvU32 speed;
12873
12874 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12875 }
12876 }
12877 #endif
12878
12879 #ifdef LINUX
12880 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12881
12882 data.hm_dll_nv = hm_dll_nv;
12883
12884 if (hm_dll_nv)
12885 {
12886 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12887 {
12888 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12889
12890 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12891
12892 int tmp_out = 0;
12893
12894 for (int i = 0; i < tmp_in; i++)
12895 {
12896 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12897 }
12898
12899 for (int i = 0; i < tmp_out; i++)
12900 {
12901 unsigned int speed;
12902
12903 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;
12904 }
12905 }
12906 }
12907 #endif
12908
12909 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12910
12911 data.hm_dll_amd = hm_dll_amd;
12912
12913 if (hm_dll_amd)
12914 {
12915 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12916 {
12917 // total number of adapters
12918
12919 int hm_adapters_num;
12920
12921 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12922
12923 // adapter info
12924
12925 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12926
12927 if (lpAdapterInfo == NULL) return (-1);
12928
12929 // get a list (of ids of) valid/usable adapters
12930
12931 int num_adl_adapters = 0;
12932
12933 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12934
12935 if (num_adl_adapters > 0)
12936 {
12937 hc_thread_mutex_lock (mux_adl);
12938
12939 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12940
12941 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12942
12943 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12944 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12945
12946 hc_thread_mutex_unlock (mux_adl);
12947 }
12948
12949 myfree (valid_adl_device_list);
12950 myfree (lpAdapterInfo);
12951 }
12952 }
12953 }
12954
12955 /**
12956 * HM devices: copy
12957 */
12958
12959 if (gpu_temp_disable == 0)
12960 {
12961 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12962 {
12963 hc_device_param_t *device_param = &data.devices_param[device_id];
12964
12965 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12966
12967 if (device_param->skipped) continue;
12968
12969 const uint platform_devices_id = device_param->platform_devices_id;
12970
12971 if (device_param->vendor_id == VENDOR_ID_NV)
12972 {
12973 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
12974 }
12975
12976 if (device_param->vendor_id == VENDOR_ID_AMD)
12977 {
12978 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
12979 }
12980 }
12981 }
12982
12983 /*
12984 * Temporary fix:
12985 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12986 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12987 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12988 * Driver / ADL bug?
12989 */
12990
12991 if (powertune_enable == 1)
12992 {
12993 hc_thread_mutex_lock (mux_adl);
12994
12995 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12996 {
12997 hc_device_param_t *device_param = &data.devices_param[device_id];
12998
12999 if (device_param->skipped) continue;
13000
13001 if (data.hm_device[device_id].od_version == 6)
13002 {
13003 // set powertune value only
13004
13005 int powertune_supported = 0;
13006
13007 int ADL_rc = 0;
13008
13009 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13010 {
13011 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13012
13013 return (-1);
13014 }
13015
13016 if (powertune_supported != 0)
13017 {
13018 // powertune set
13019 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13020
13021 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13022 {
13023 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13024
13025 return (-1);
13026 }
13027
13028 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13029 {
13030 log_error ("ERROR: Failed to set new ADL PowerControl values");
13031
13032 return (-1);
13033 }
13034 }
13035 }
13036 }
13037
13038 hc_thread_mutex_unlock (mux_adl);
13039 }
13040
13041 uint kernel_blocks_all = 0;
13042
13043 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13044 {
13045 /**
13046 * host buffer
13047 */
13048
13049 hc_device_param_t *device_param = &data.devices_param[device_id];
13050
13051 if (device_param->skipped) continue;
13052
13053 /**
13054 * device properties
13055 */
13056
13057 char *device_name_chksum = device_param->device_name_chksum;
13058
13059 uint device_processors = device_param->device_processors;
13060
13061 uint device_processor_cores = device_param->device_processor_cores;
13062
13063 cl_device_type device_type = device_param->device_type;
13064
13065 /**
13066 * create context for each device
13067 */
13068
13069 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13070
13071 /**
13072 * create command-queue
13073 */
13074
13075 // not support with NV
13076 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13077
13078 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13079
13080 /**
13081 * create input buffers on device
13082 */
13083
13084 uint kernel_threads = KERNEL_THREADS;
13085
13086 // bcrypt
13087 if (hash_mode == 3200) kernel_threads = 8;
13088 if (hash_mode == 9000) kernel_threads = 8;
13089
13090 if (device_type & CL_DEVICE_TYPE_CPU)
13091 {
13092 // CPU still need lots of workitems, don't know why...
13093 // for testing phase, lets start with this
13094
13095 kernel_accel = 1;
13096 }
13097
13098 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13099 uint kernel_blocks = kernel_power;
13100
13101 device_param->kernel_threads = kernel_threads;
13102 device_param->kernel_power_user = kernel_power;
13103 device_param->kernel_blocks_user = kernel_blocks;
13104
13105 kernel_blocks_all += kernel_blocks;
13106
13107 uint size_pws = kernel_power * sizeof (pw_t);
13108
13109 uint size_tmps = 4;
13110
13111 switch (hash_mode)
13112 {
13113 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13114 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13115 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13116 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13117 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13118 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13119 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13120 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13121 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13122 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13123 case 6211:
13124 case 6212:
13125 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13126 case 6221:
13127 case 6222:
13128 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13129 case 6231:
13130 case 6232:
13131 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13132 case 6241:
13133 case 6242:
13134 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13135 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13136 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13137 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13138 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13139 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13140 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13141 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13142 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13143 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13144 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13145 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13146 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13147 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13148 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13149 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13150 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13151 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13152 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13153 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13154 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13155 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13156 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13157 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13158 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13159 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13160 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13161 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13162 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13163 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13164 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13165 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13166 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13167 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13168 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13169 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13170 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13171 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13172 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13173 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13174 };
13175
13176 uint size_hooks = 4;
13177
13178 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13179 {
13180 // insert correct hook size
13181 }
13182
13183 // we can optimize some stuff here...
13184
13185 device_param->size_pws = size_pws;
13186 device_param->size_tmps = size_tmps;
13187 device_param->size_hooks = size_hooks;
13188
13189 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13190 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13191
13192 device_param->size_root_css = size_root_css;
13193 device_param->size_markov_css = size_markov_css;
13194
13195 uint size_results = KERNEL_THREADS * sizeof (uint);
13196
13197 device_param->size_results = size_results;
13198
13199 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13200 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13201
13202 uint size_plains = digests_cnt * sizeof (plain_t);
13203 uint size_salts = salts_cnt * sizeof (salt_t);
13204 uint size_esalts = salts_cnt * esalt_size;
13205
13206 device_param->size_plains = size_plains;
13207 device_param->size_digests = size_digests;
13208 device_param->size_shown = size_shown;
13209 device_param->size_salts = size_salts;
13210
13211 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13212 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13213 uint size_tm = 32 * sizeof (bs_word_t);
13214
13215 u64 size_scryptV = 1;
13216
13217 if ((hash_mode == 8900) || (hash_mode == 9300))
13218 {
13219 uint tmto_start = 0;
13220 uint tmto_stop = 10;
13221
13222 if (scrypt_tmto)
13223 {
13224 tmto_start = scrypt_tmto;
13225 }
13226 else
13227 {
13228 // in case the user did not specify the tmto manually
13229 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13230 // but set the lower end only in case the user has a device with too less memory
13231
13232 if (hash_mode == 8900)
13233 {
13234 if (device_param->vendor_id == VENDOR_ID_AMD)
13235 {
13236 tmto_start = 1;
13237 }
13238 else if (device_param->vendor_id == VENDOR_ID_NV)
13239 {
13240 tmto_start = 3;
13241 }
13242 }
13243 else if (hash_mode == 9300)
13244 {
13245 if (device_param->vendor_id == VENDOR_ID_AMD)
13246 {
13247 tmto_start = 3;
13248 }
13249 else if (device_param->vendor_id == VENDOR_ID_NV)
13250 {
13251 tmto_start = 5;
13252 }
13253 }
13254 }
13255
13256 if (quiet == 0) log_info ("");
13257
13258 uint shader_per_mp = 1;
13259
13260 if (device_param->vendor_id == VENDOR_ID_AMD)
13261 {
13262 shader_per_mp = 8;
13263 }
13264 else if (device_param->vendor_id == VENDOR_ID_NV)
13265 {
13266 shader_per_mp = 32;
13267 }
13268
13269 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13270 {
13271 // TODO: in theory the following calculation needs to be done per salt, not global
13272 // we assume all hashes have the same scrypt settings
13273
13274 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13275
13276 size_scryptV /= 1 << tmto;
13277
13278 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13279
13280 if (size_scryptV > device_param->device_maxmem_alloc)
13281 {
13282 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13283
13284 continue;
13285 }
13286
13287 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13288 {
13289 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13290 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13291 }
13292
13293 break;
13294 }
13295
13296 if (data.salts_buf[0].scrypt_phy == 0)
13297 {
13298 log_error ("ERROR: can't allocate enough device memory");
13299
13300 return -1;
13301 }
13302
13303 if (quiet == 0) log_info ("");
13304 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13305 }
13306
13307 /**
13308 * default building options
13309 */
13310
13311 char build_opts[1024];
13312
13313 // we don't have sm_* on vendors not NV but it doesn't matter
13314
13315 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);
13316
13317 /**
13318 * main kernel
13319 */
13320
13321 {
13322 /**
13323 * kernel source filename
13324 */
13325
13326 char source_file[256] = { 0 };
13327
13328 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13329
13330 struct stat sst;
13331
13332 if (stat (source_file, &sst) == -1)
13333 {
13334 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13335
13336 return -1;
13337 }
13338
13339 /**
13340 * kernel cached filename
13341 */
13342
13343 char cached_file[256] = { 0 };
13344
13345 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13346
13347 int cached = 1;
13348
13349 struct stat cst;
13350
13351 if (stat (cached_file, &cst) == -1)
13352 {
13353 cached = 0;
13354 }
13355
13356 /**
13357 * kernel compile or load
13358 */
13359
13360 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13361
13362 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13363
13364 if (force_jit_compilation == -1)
13365 {
13366 if (cached == 0)
13367 {
13368 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13369
13370 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13371
13372 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13373
13374 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13375
13376 size_t binary_size;
13377
13378 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13379
13380 u8 *binary = (u8 *) mymalloc (binary_size);
13381
13382 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13383
13384 writeProgramBin (cached_file, binary, binary_size);
13385
13386 local_free (binary);
13387 }
13388 else
13389 {
13390 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13391
13392 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13393
13394 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13395
13396 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13397 }
13398 }
13399 else
13400 {
13401 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13402
13403 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13404
13405 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13406
13407 if (force_jit_compilation == 1500)
13408 {
13409 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13410 }
13411 else if (force_jit_compilation == 8900)
13412 {
13413 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);
13414 }
13415
13416 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13417 }
13418
13419 local_free (kernel_lengths);
13420 local_free (kernel_sources[0]);
13421 local_free (kernel_sources);
13422
13423 // this is mostly for debug
13424
13425 size_t ret_val_size = 0;
13426
13427 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13428
13429 if (ret_val_size > 2)
13430 {
13431 char *build_log = (char *) mymalloc (ret_val_size + 1);
13432
13433 memset (build_log, 0, ret_val_size + 1);
13434
13435 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13436
13437 puts (build_log);
13438
13439 myfree (build_log);
13440 }
13441 }
13442
13443 /**
13444 * word generator kernel
13445 */
13446
13447 if (attack_mode != ATTACK_MODE_STRAIGHT)
13448 {
13449 /**
13450 * kernel mp source filename
13451 */
13452
13453 char source_file[256] = { 0 };
13454
13455 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13456
13457 struct stat sst;
13458
13459 if (stat (source_file, &sst) == -1)
13460 {
13461 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13462
13463 return -1;
13464 }
13465
13466 /**
13467 * kernel mp cached filename
13468 */
13469
13470 char cached_file[256] = { 0 };
13471
13472 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13473
13474 int cached = 1;
13475
13476 struct stat cst;
13477
13478 if (stat (cached_file, &cst) == -1)
13479 {
13480 cached = 0;
13481 }
13482
13483 /**
13484 * kernel compile or load
13485 */
13486
13487 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13488
13489 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13490
13491 if (cached == 0)
13492 {
13493 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13494
13495 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13496
13497 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13498
13499 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13500
13501 size_t binary_size;
13502
13503 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13504
13505 u8 *binary = (u8 *) mymalloc (binary_size);
13506
13507 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13508
13509 writeProgramBin (cached_file, binary, binary_size);
13510
13511 local_free (binary);
13512 }
13513 else
13514 {
13515 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13516
13517 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13518
13519 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13520
13521 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13522 }
13523
13524 local_free (kernel_lengths);
13525 local_free (kernel_sources[0]);
13526 local_free (kernel_sources);
13527
13528 // this is mostly for debug
13529
13530 size_t ret_val_size = 0;
13531
13532 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13533
13534 if (ret_val_size > 2)
13535 {
13536 char *build_log = (char *) mymalloc (ret_val_size + 1);
13537
13538 memset (build_log, 0, ret_val_size + 1);
13539
13540 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13541
13542 puts (build_log);
13543
13544 myfree (build_log);
13545 }
13546 }
13547
13548 /**
13549 * amplifier kernel
13550 */
13551
13552 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13553 {
13554
13555 }
13556 else
13557 {
13558 /**
13559 * kernel amp source filename
13560 */
13561
13562 char source_file[256] = { 0 };
13563
13564 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13565
13566 struct stat sst;
13567
13568 if (stat (source_file, &sst) == -1)
13569 {
13570 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13571
13572 return -1;
13573 }
13574
13575 /**
13576 * kernel amp cached filename
13577 */
13578
13579 char cached_file[256] = { 0 };
13580
13581 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13582
13583 int cached = 1;
13584
13585 struct stat cst;
13586
13587 if (stat (cached_file, &cst) == -1)
13588 {
13589 cached = 0;
13590 }
13591
13592 /**
13593 * kernel compile or load
13594 */
13595
13596 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13597
13598 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13599
13600 if (cached == 0)
13601 {
13602 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13603
13604 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13605
13606 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13607
13608 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13609
13610 size_t binary_size;
13611
13612 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13613
13614 u8 *binary = (u8 *) mymalloc (binary_size);
13615
13616 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13617
13618 writeProgramBin (cached_file, binary, binary_size);
13619
13620 local_free (binary);
13621 }
13622 else
13623 {
13624 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13625
13626 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13627
13628 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13629
13630 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13631 }
13632
13633 local_free (kernel_lengths);
13634 local_free (kernel_sources[0]);
13635 local_free (kernel_sources);
13636
13637 // this is mostly for debug
13638
13639 size_t ret_val_size = 0;
13640
13641 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13642
13643 if (ret_val_size > 2)
13644 {
13645 char *build_log = (char *) mymalloc (ret_val_size + 1);
13646
13647 memset (build_log, 0, ret_val_size + 1);
13648
13649 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13650
13651 puts (build_log);
13652
13653 myfree (build_log);
13654 }
13655 }
13656
13657 /**
13658 * global buffers
13659 */
13660
13661 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13662 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13663 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13664 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13665 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13666 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13667 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13668 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13669 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13670 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13671 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13672 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13673 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13674 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13675 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13676 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13677 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13678 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13679
13680 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13681 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13682 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13683 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13684 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13685 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13686 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13687 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13688 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13689 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13690 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13691
13692 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13693 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13694 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13695 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13696 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13697 run_kernel_bzero (device_param, device_param->d_result, size_results);
13698
13699 /**
13700 * special buffers
13701 */
13702
13703 if (attack_kern == ATTACK_KERN_STRAIGHT)
13704 {
13705 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13706 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13707
13708 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13709
13710 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13711 }
13712 else if (attack_kern == ATTACK_KERN_COMBI)
13713 {
13714 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13715 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13716 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13717 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13718
13719 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13720 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13721 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13722 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13723 }
13724 else if (attack_kern == ATTACK_KERN_BF)
13725 {
13726 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13727 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13728 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13729 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13730 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13731
13732 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13733 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13734 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13735 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13736 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13737 }
13738
13739 if (size_esalts)
13740 {
13741 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13742
13743 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13744 }
13745
13746 /**
13747 * main host data
13748 */
13749
13750 uint *result = (uint *) mymalloc (size_results);
13751
13752 memset (result, 0, size_results);
13753
13754 device_param->result = result;
13755
13756 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13757
13758 memset (pws_buf, 0, size_pws);
13759
13760 device_param->pws_buf = pws_buf;
13761
13762 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13763
13764 for (int i = 0; i < 64; i++)
13765 {
13766 pw_caches[i].pw_buf.pw_len = i;
13767 pw_caches[i].cnt = 0;
13768 }
13769
13770 device_param->pw_caches = pw_caches;
13771
13772 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13773
13774 device_param->combs_buf = combs_buf;
13775
13776 void *hooks_buf = mymalloc (size_hooks);
13777
13778 device_param->hooks_buf = hooks_buf;
13779
13780 device_param->pw_transpose = pw_transpose_to_hi1;
13781 device_param->pw_add = pw_add_to_hc1;
13782
13783 /**
13784 * kernel args
13785 */
13786
13787 device_param->kernel_params_buf32[21] = bitmap_mask;
13788 device_param->kernel_params_buf32[22] = bitmap_shift1;
13789 device_param->kernel_params_buf32[23] = bitmap_shift2;
13790 device_param->kernel_params_buf32[24] = 0; // salt_pos
13791 device_param->kernel_params_buf32[25] = 0; // loop_pos
13792 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13793 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13794 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13795 device_param->kernel_params_buf32[29] = 0; // digests_offset
13796 device_param->kernel_params_buf32[30] = 0; // combs_mode
13797 device_param->kernel_params_buf32[31] = 0; // gid_max
13798
13799 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13800 ? &device_param->d_pws_buf
13801 : &device_param->d_pws_amp_buf;
13802 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13803 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13804 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13805 device_param->kernel_params[ 4] = &device_param->d_tmps;
13806 device_param->kernel_params[ 5] = &device_param->d_hooks;
13807 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13808 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13809 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13810 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13811 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13812 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13813 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13814 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13815 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13816 device_param->kernel_params[15] = &device_param->d_digests_buf;
13817 device_param->kernel_params[16] = &device_param->d_digests_shown;
13818 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13819 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13820 device_param->kernel_params[19] = &device_param->d_result;
13821 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13822 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13823 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13824 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13825 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13826 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13827 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13828 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13829 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13830 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13831 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13832 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13833
13834 device_param->kernel_params_mp_buf64[3] = 0;
13835 device_param->kernel_params_mp_buf32[4] = 0;
13836 device_param->kernel_params_mp_buf32[5] = 0;
13837 device_param->kernel_params_mp_buf32[6] = 0;
13838 device_param->kernel_params_mp_buf32[7] = 0;
13839 device_param->kernel_params_mp_buf32[8] = 0;
13840
13841 device_param->kernel_params_mp[0] = NULL;
13842 device_param->kernel_params_mp[1] = NULL;
13843 device_param->kernel_params_mp[2] = NULL;
13844 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13845 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13846 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13847 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13848 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13849 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13850
13851 device_param->kernel_params_mp_l_buf64[3] = 0;
13852 device_param->kernel_params_mp_l_buf32[4] = 0;
13853 device_param->kernel_params_mp_l_buf32[5] = 0;
13854 device_param->kernel_params_mp_l_buf32[6] = 0;
13855 device_param->kernel_params_mp_l_buf32[7] = 0;
13856 device_param->kernel_params_mp_l_buf32[8] = 0;
13857 device_param->kernel_params_mp_l_buf32[9] = 0;
13858
13859 device_param->kernel_params_mp_l[0] = NULL;
13860 device_param->kernel_params_mp_l[1] = NULL;
13861 device_param->kernel_params_mp_l[2] = NULL;
13862 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13863 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13864 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13865 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13866 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13867 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13868 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13869
13870 device_param->kernel_params_mp_r_buf64[3] = 0;
13871 device_param->kernel_params_mp_r_buf32[4] = 0;
13872 device_param->kernel_params_mp_r_buf32[5] = 0;
13873 device_param->kernel_params_mp_r_buf32[6] = 0;
13874 device_param->kernel_params_mp_r_buf32[7] = 0;
13875 device_param->kernel_params_mp_r_buf32[8] = 0;
13876
13877 device_param->kernel_params_mp_r[0] = NULL;
13878 device_param->kernel_params_mp_r[1] = NULL;
13879 device_param->kernel_params_mp_r[2] = NULL;
13880 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13881 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13882 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13883 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13884 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13885 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13886
13887 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13888 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13889
13890 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13891 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13892 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13893 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13894 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13895 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13896 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13897
13898 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13899
13900 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13901 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13902
13903 /**
13904 * kernel name
13905 */
13906
13907 char kernel_name[64] = { 0 };
13908
13909 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13910 {
13911 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13912 {
13913 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13914
13915 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13916
13917 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13918
13919 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13920
13921 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13922
13923 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13924 }
13925 else
13926 {
13927 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13928
13929 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13930
13931 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13932
13933 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13934
13935 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13936
13937 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13938 }
13939
13940 if (data.attack_mode == ATTACK_MODE_BF)
13941 {
13942 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13943 {
13944 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13945
13946 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13947
13948 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13949
13950 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13951 }
13952 }
13953 }
13954 else
13955 {
13956 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13957
13958 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13959
13960 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13961
13962 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13963
13964 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13965
13966 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13967
13968 if (opts_type & OPTS_TYPE_HOOK12)
13969 {
13970 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13971
13972 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13973 }
13974
13975 if (opts_type & OPTS_TYPE_HOOK23)
13976 {
13977 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13978
13979 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13980 }
13981 }
13982
13983 for (uint i = 0; i <= 20; i++)
13984 {
13985 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13986 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13987 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13988
13989 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13990 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13991 }
13992
13993 for (uint i = 21; i <= 31; i++)
13994 {
13995 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13996 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13997 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13998
13999 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14000 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14001 }
14002
14003 if (attack_mode == ATTACK_MODE_BF)
14004 {
14005 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14006 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14007
14008 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14009 {
14010 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14011
14012 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14013 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14014 }
14015 }
14016 else if (attack_mode == ATTACK_MODE_HYBRID1)
14017 {
14018 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14019 }
14020 else if (attack_mode == ATTACK_MODE_HYBRID2)
14021 {
14022 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14023 }
14024
14025 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14026 {
14027 // nothing to do
14028 }
14029 else
14030 {
14031 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14032 }
14033
14034 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14035 {
14036 // nothing to do
14037 }
14038 else
14039 {
14040 for (uint i = 0; i < 5; i++)
14041 {
14042 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14043 }
14044
14045 for (uint i = 5; i < 7; i++)
14046 {
14047 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14048 }
14049 }
14050
14051 /**
14052 * Store initial fanspeed if gpu_temp_retain is enabled
14053 */
14054
14055 int gpu_temp_retain_set = 0;
14056
14057 if (gpu_temp_disable == 0)
14058 {
14059 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14060 {
14061 hc_thread_mutex_lock (mux_adl);
14062
14063 if (data.hm_device[device_id].fan_supported == 1)
14064 {
14065 if (gpu_temp_retain_chgd == 0)
14066 {
14067 uint cur_temp = 0;
14068 uint default_temp = 0;
14069
14070 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);
14071
14072 if (ADL_rc == ADL_OK)
14073 {
14074 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14075
14076 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14077
14078 // special case with multi gpu setups: always use minimum retain
14079
14080 if (gpu_temp_retain_set == 0)
14081 {
14082 gpu_temp_retain = gpu_temp_retain_target;
14083 gpu_temp_retain_set = 1;
14084 }
14085 else
14086 {
14087 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14088 }
14089
14090 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14091 }
14092 }
14093
14094 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14095
14096 temp_retain_fanspeed_value[device_id] = fan_speed;
14097
14098 if (fan_speed == -1)
14099 {
14100 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14101
14102 temp_retain_fanspeed_value[device_id] = 0;
14103 }
14104 }
14105
14106 hc_thread_mutex_unlock (mux_adl);
14107 }
14108 }
14109
14110 /**
14111 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14112 */
14113
14114 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14115 {
14116 hc_thread_mutex_lock (mux_adl);
14117
14118 if (data.hm_device[device_id].od_version == 6)
14119 {
14120 int ADL_rc;
14121
14122 // check powertune capabilities first, if not available then skip device
14123
14124 int powertune_supported = 0;
14125
14126 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14127 {
14128 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14129
14130 return (-1);
14131 }
14132
14133 if (powertune_supported != 0)
14134 {
14135 // powercontrol settings
14136
14137 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14138
14139 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14140 {
14141 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]);
14142 }
14143
14144 if (ADL_rc != ADL_OK)
14145 {
14146 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14147
14148 return (-1);
14149 }
14150
14151 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14152 {
14153 log_error ("ERROR: Failed to set new ADL PowerControl values");
14154
14155 return (-1);
14156 }
14157
14158 // clocks
14159
14160 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14161
14162 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14163
14164 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)
14165 {
14166 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14167
14168 return (-1);
14169 }
14170
14171 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14172
14173 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14174
14175 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14176 {
14177 log_error ("ERROR: Failed to get ADL device capabilities");
14178
14179 return (-1);
14180 }
14181
14182 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14183 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14184
14185 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14186 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14187
14188 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14189 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14190
14191 // warning if profile has to low max values
14192
14193 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14194 {
14195 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14196 }
14197
14198 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14199 {
14200 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14201 }
14202
14203 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14204
14205 performance_state->iNumberOfPerformanceLevels = 2;
14206
14207 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14208 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14209 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14210 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14211
14212 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)
14213 {
14214 log_info ("ERROR: Failed to set ADL performance state");
14215
14216 return (-1);
14217 }
14218
14219 local_free (performance_state);
14220 }
14221 }
14222
14223 hc_thread_mutex_unlock (mux_adl);
14224 }
14225 }
14226
14227 data.kernel_blocks_all = kernel_blocks_all;
14228
14229 if (data.quiet == 0) log_info ("");
14230
14231 /**
14232 * Inform user which algorithm is checked and at which workload setting
14233 */
14234
14235 if (benchmark == 1)
14236 {
14237 quiet = 0;
14238
14239 data.quiet = quiet;
14240
14241 char *hash_type = strhashtype (data.hash_mode); // not a bug
14242
14243 log_info ("Hashtype: %s", hash_type);
14244 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14245 log_info ("");
14246 }
14247
14248 /**
14249 * keep track of the progress
14250 */
14251
14252 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14253 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14254 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14255
14256 /**
14257 * open filehandles
14258 */
14259
14260 #if _WIN
14261 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14262 {
14263 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14264
14265 return (-1);
14266 }
14267
14268 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14269 {
14270 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14271
14272 return (-1);
14273 }
14274
14275 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14276 {
14277 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14278
14279 return (-1);
14280 }
14281 #endif
14282
14283 /**
14284 * dictionary pad
14285 */
14286
14287 segment_size *= (1024 * 1024);
14288
14289 data.segment_size = segment_size;
14290
14291 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14292
14293 wl_data->buf = (char *) mymalloc (segment_size);
14294 wl_data->avail = segment_size;
14295 wl_data->incr = segment_size;
14296 wl_data->cnt = 0;
14297 wl_data->pos = 0;
14298
14299 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14300
14301 data.wordlist_mode = wordlist_mode;
14302
14303 cs_t *css_buf = NULL;
14304 uint css_cnt = 0;
14305 uint dictcnt = 0;
14306 uint maskcnt = 1;
14307 char **masks = NULL;
14308 char **dictfiles = NULL;
14309
14310 uint mask_from_file = 0;
14311
14312 if (attack_mode == ATTACK_MODE_STRAIGHT)
14313 {
14314 if (wordlist_mode == WL_MODE_FILE)
14315 {
14316 int wls_left = myargc - (optind + 1);
14317
14318 for (int i = 0; i < wls_left; i++)
14319 {
14320 char *l0_filename = myargv[optind + 1 + i];
14321
14322 struct stat l0_stat;
14323
14324 if (stat (l0_filename, &l0_stat) == -1)
14325 {
14326 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14327
14328 return (-1);
14329 }
14330
14331 uint is_dir = S_ISDIR (l0_stat.st_mode);
14332
14333 if (is_dir == 0)
14334 {
14335 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14336
14337 dictcnt++;
14338
14339 dictfiles[dictcnt - 1] = l0_filename;
14340 }
14341 else
14342 {
14343 // do not allow --keyspace w/ a directory
14344
14345 if (keyspace == 1)
14346 {
14347 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14348
14349 return (-1);
14350 }
14351
14352 char **dictionary_files = NULL;
14353
14354 dictionary_files = scan_directory (l0_filename);
14355
14356 if (dictionary_files != NULL)
14357 {
14358 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14359
14360 for (int d = 0; dictionary_files[d] != NULL; d++)
14361 {
14362 char *l1_filename = dictionary_files[d];
14363
14364 struct stat l1_stat;
14365
14366 if (stat (l1_filename, &l1_stat) == -1)
14367 {
14368 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14369
14370 return (-1);
14371 }
14372
14373 if (S_ISREG (l1_stat.st_mode))
14374 {
14375 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14376
14377 dictcnt++;
14378
14379 dictfiles[dictcnt - 1] = strdup (l1_filename);
14380 }
14381 }
14382 }
14383
14384 local_free (dictionary_files);
14385 }
14386 }
14387
14388 if (dictcnt < 1)
14389 {
14390 log_error ("ERROR: No usable dictionary file found.");
14391
14392 return (-1);
14393 }
14394 }
14395 else if (wordlist_mode == WL_MODE_STDIN)
14396 {
14397 dictcnt = 1;
14398 }
14399 }
14400 else if (attack_mode == ATTACK_MODE_COMBI)
14401 {
14402 // display
14403
14404 char *dictfile1 = myargv[optind + 1 + 0];
14405 char *dictfile2 = myargv[optind + 1 + 1];
14406
14407 // find the bigger dictionary and use as base
14408
14409 FILE *fp1;
14410 FILE *fp2;
14411
14412 struct stat tmp_stat;
14413
14414 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14415 {
14416 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14417
14418 return (-1);
14419 }
14420
14421 if (stat (dictfile1, &tmp_stat) == -1)
14422 {
14423 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14424
14425 fclose (fp1);
14426
14427 return (-1);
14428 }
14429
14430 if (S_ISDIR (tmp_stat.st_mode))
14431 {
14432 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14433
14434 fclose (fp1);
14435
14436 return (-1);
14437 }
14438
14439 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14440 {
14441 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14442
14443 fclose (fp1);
14444
14445 return (-1);
14446 }
14447
14448 if (stat (dictfile2, &tmp_stat) == -1)
14449 {
14450 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14451
14452 fclose (fp1);
14453 fclose (fp2);
14454
14455 return (-1);
14456 }
14457
14458 if (S_ISDIR (tmp_stat.st_mode))
14459 {
14460 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14461
14462 fclose (fp1);
14463 fclose (fp2);
14464
14465 return (-1);
14466 }
14467
14468 data.combs_cnt = 1;
14469
14470 data.quiet = 1;
14471
14472 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14473
14474 data.quiet = quiet;
14475
14476 if (words1_cnt == 0)
14477 {
14478 log_error ("ERROR: %s: empty file", dictfile1);
14479
14480 fclose (fp1);
14481 fclose (fp2);
14482
14483 return (-1);
14484 }
14485
14486 data.combs_cnt = 1;
14487
14488 data.quiet = 1;
14489
14490 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14491
14492 data.quiet = quiet;
14493
14494 if (words2_cnt == 0)
14495 {
14496 log_error ("ERROR: %s: empty file", dictfile2);
14497
14498 fclose (fp1);
14499 fclose (fp2);
14500
14501 return (-1);
14502 }
14503
14504 fclose (fp1);
14505 fclose (fp2);
14506
14507 data.dictfile = dictfile1;
14508 data.dictfile2 = dictfile2;
14509
14510 if (words1_cnt >= words2_cnt)
14511 {
14512 data.combs_cnt = words2_cnt;
14513 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14514
14515 dictfiles = &data.dictfile;
14516
14517 dictcnt = 1;
14518 }
14519 else
14520 {
14521 data.combs_cnt = words1_cnt;
14522 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14523
14524 dictfiles = &data.dictfile2;
14525
14526 dictcnt = 1;
14527
14528 // we also have to switch wordlist related rules!
14529
14530 char *tmpc = data.rule_buf_l;
14531
14532 data.rule_buf_l = data.rule_buf_r;
14533 data.rule_buf_r = tmpc;
14534
14535 int tmpi = data.rule_len_l;
14536
14537 data.rule_len_l = data.rule_len_r;
14538 data.rule_len_r = tmpi;
14539 }
14540 }
14541 else if (attack_mode == ATTACK_MODE_BF)
14542 {
14543 char *mask = NULL;
14544
14545 maskcnt = 0;
14546
14547 if (benchmark == 0)
14548 {
14549 mask = myargv[optind + 1];
14550
14551 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14552
14553 if ((optind + 2) <= myargc)
14554 {
14555 struct stat file_stat;
14556
14557 if (stat (mask, &file_stat) == -1)
14558 {
14559 maskcnt = 1;
14560
14561 masks[maskcnt - 1] = mystrdup (mask);
14562 }
14563 else
14564 {
14565 int wls_left = myargc - (optind + 1);
14566
14567 uint masks_avail = INCR_MASKS;
14568
14569 for (int i = 0; i < wls_left; i++)
14570 {
14571 if (i != 0)
14572 {
14573 mask = myargv[optind + 1 + i];
14574
14575 if (stat (mask, &file_stat) == -1)
14576 {
14577 log_error ("ERROR: %s: %s", mask, strerror (errno));
14578
14579 return (-1);
14580 }
14581 }
14582
14583 uint is_file = S_ISREG (file_stat.st_mode);
14584
14585 if (is_file == 1)
14586 {
14587 FILE *mask_fp;
14588
14589 if ((mask_fp = fopen (mask, "r")) == NULL)
14590 {
14591 log_error ("ERROR: %s: %s", mask, strerror (errno));
14592
14593 return (-1);
14594 }
14595
14596 char line_buf[BUFSIZ];
14597
14598 while (!feof (mask_fp))
14599 {
14600 memset (line_buf, 0, BUFSIZ);
14601
14602 int line_len = fgetl (mask_fp, line_buf);
14603
14604 if (line_len == 0) continue;
14605
14606 if (line_buf[0] == '#') continue;
14607
14608 if (masks_avail == maskcnt)
14609 {
14610 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14611
14612 masks_avail += INCR_MASKS;
14613 }
14614
14615 masks[maskcnt] = mystrdup (line_buf);
14616
14617 maskcnt++;
14618 }
14619
14620 fclose (mask_fp);
14621 }
14622 else
14623 {
14624 log_error ("ERROR: %s: unsupported file-type", mask);
14625
14626 return (-1);
14627 }
14628 }
14629
14630 mask_from_file = 1;
14631 }
14632 }
14633 else
14634 {
14635 custom_charset_1 = (char *) "?l?d?u";
14636 custom_charset_2 = (char *) "?l?d";
14637 custom_charset_3 = (char *) "?l?d*!$@_";
14638
14639 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14640 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14641 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14642
14643 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14644
14645 wordlist_mode = WL_MODE_MASK;
14646
14647 data.wordlist_mode = wordlist_mode;
14648
14649 increment = 1;
14650
14651 maskcnt = 1;
14652 }
14653 }
14654 else
14655 {
14656 /**
14657 * generate full masks and charsets
14658 */
14659
14660 masks = (char **) mymalloc (sizeof (char *));
14661
14662 switch (hash_mode)
14663 {
14664 case 1731: pw_min = 5;
14665 pw_max = 5;
14666 mask = mystrdup ("?b?b?b?b?b");
14667 break;
14668 case 12500: pw_min = 5;
14669 pw_max = 5;
14670 mask = mystrdup ("?b?b?b?b?b");
14671 break;
14672 default: pw_min = 7;
14673 pw_max = 7;
14674 mask = mystrdup ("?b?b?b?b?b?b?b");
14675 break;
14676 }
14677
14678 maskcnt = 1;
14679
14680 masks[maskcnt - 1] = mystrdup (mask);
14681
14682 wordlist_mode = WL_MODE_MASK;
14683
14684 data.wordlist_mode = wordlist_mode;
14685
14686 increment = 1;
14687 }
14688
14689 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14690
14691 if (increment)
14692 {
14693 if (increment_min > pw_min) pw_min = increment_min;
14694
14695 if (increment_max < pw_max) pw_max = increment_max;
14696 }
14697 }
14698 else if (attack_mode == ATTACK_MODE_HYBRID1)
14699 {
14700 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14701
14702 // display
14703
14704 char *mask = myargv[myargc - 1];
14705
14706 maskcnt = 0;
14707
14708 masks = (char **) mymalloc (1 * sizeof (char *));
14709
14710 // mod
14711
14712 struct stat file_stat;
14713
14714 if (stat (mask, &file_stat) == -1)
14715 {
14716 maskcnt = 1;
14717
14718 masks[maskcnt - 1] = mystrdup (mask);
14719 }
14720 else
14721 {
14722 uint is_file = S_ISREG (file_stat.st_mode);
14723
14724 if (is_file == 1)
14725 {
14726 FILE *mask_fp;
14727
14728 if ((mask_fp = fopen (mask, "r")) == NULL)
14729 {
14730 log_error ("ERROR: %s: %s", mask, strerror (errno));
14731
14732 return (-1);
14733 }
14734
14735 char line_buf[BUFSIZ];
14736
14737 uint masks_avail = 1;
14738
14739 while (!feof (mask_fp))
14740 {
14741 memset (line_buf, 0, BUFSIZ);
14742
14743 int line_len = fgetl (mask_fp, line_buf);
14744
14745 if (line_len == 0) continue;
14746
14747 if (line_buf[0] == '#') continue;
14748
14749 if (masks_avail == maskcnt)
14750 {
14751 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14752
14753 masks_avail += INCR_MASKS;
14754 }
14755
14756 masks[maskcnt] = mystrdup (line_buf);
14757
14758 maskcnt++;
14759 }
14760
14761 fclose (mask_fp);
14762
14763 mask_from_file = 1;
14764 }
14765 else
14766 {
14767 maskcnt = 1;
14768
14769 masks[maskcnt - 1] = mystrdup (mask);
14770 }
14771 }
14772
14773 // base
14774
14775 int wls_left = myargc - (optind + 2);
14776
14777 for (int i = 0; i < wls_left; i++)
14778 {
14779 char *filename = myargv[optind + 1 + i];
14780
14781 struct stat file_stat;
14782
14783 if (stat (filename, &file_stat) == -1)
14784 {
14785 log_error ("ERROR: %s: %s", filename, strerror (errno));
14786
14787 return (-1);
14788 }
14789
14790 uint is_dir = S_ISDIR (file_stat.st_mode);
14791
14792 if (is_dir == 0)
14793 {
14794 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14795
14796 dictcnt++;
14797
14798 dictfiles[dictcnt - 1] = filename;
14799 }
14800 else
14801 {
14802 // do not allow --keyspace w/ a directory
14803
14804 if (keyspace == 1)
14805 {
14806 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14807
14808 return (-1);
14809 }
14810
14811 char **dictionary_files = NULL;
14812
14813 dictionary_files = scan_directory (filename);
14814
14815 if (dictionary_files != NULL)
14816 {
14817 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14818
14819 for (int d = 0; dictionary_files[d] != NULL; d++)
14820 {
14821 char *l1_filename = dictionary_files[d];
14822
14823 struct stat l1_stat;
14824
14825 if (stat (l1_filename, &l1_stat) == -1)
14826 {
14827 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14828
14829 return (-1);
14830 }
14831
14832 if (S_ISREG (l1_stat.st_mode))
14833 {
14834 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14835
14836 dictcnt++;
14837
14838 dictfiles[dictcnt - 1] = strdup (l1_filename);
14839 }
14840 }
14841 }
14842
14843 local_free (dictionary_files);
14844 }
14845 }
14846
14847 if (dictcnt < 1)
14848 {
14849 log_error ("ERROR: No usable dictionary file found.");
14850
14851 return (-1);
14852 }
14853
14854 if (increment)
14855 {
14856 maskcnt = 0;
14857
14858 uint mask_min = increment_min; // we can't reject smaller masks here
14859 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14860
14861 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14862 {
14863 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14864
14865 if (cur_mask == NULL) break;
14866
14867 masks[maskcnt] = cur_mask;
14868
14869 maskcnt++;
14870
14871 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14872 }
14873 }
14874 }
14875 else if (attack_mode == ATTACK_MODE_HYBRID2)
14876 {
14877 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14878
14879 // display
14880
14881 char *mask = myargv[optind + 1 + 0];
14882
14883 maskcnt = 0;
14884
14885 masks = (char **) mymalloc (1 * sizeof (char *));
14886
14887 // mod
14888
14889 struct stat file_stat;
14890
14891 if (stat (mask, &file_stat) == -1)
14892 {
14893 maskcnt = 1;
14894
14895 masks[maskcnt - 1] = mystrdup (mask);
14896 }
14897 else
14898 {
14899 uint is_file = S_ISREG (file_stat.st_mode);
14900
14901 if (is_file == 1)
14902 {
14903 FILE *mask_fp;
14904
14905 if ((mask_fp = fopen (mask, "r")) == NULL)
14906 {
14907 log_error ("ERROR: %s: %s", mask, strerror (errno));
14908
14909 return (-1);
14910 }
14911
14912 char line_buf[BUFSIZ];
14913
14914 uint masks_avail = 1;
14915
14916 while (!feof (mask_fp))
14917 {
14918 memset (line_buf, 0, BUFSIZ);
14919
14920 int line_len = fgetl (mask_fp, line_buf);
14921
14922 if (line_len == 0) continue;
14923
14924 if (line_buf[0] == '#') continue;
14925
14926 if (masks_avail == maskcnt)
14927 {
14928 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14929
14930 masks_avail += INCR_MASKS;
14931 }
14932
14933 masks[maskcnt] = mystrdup (line_buf);
14934
14935 maskcnt++;
14936 }
14937
14938 fclose (mask_fp);
14939
14940 mask_from_file = 1;
14941 }
14942 else
14943 {
14944 maskcnt = 1;
14945
14946 masks[maskcnt - 1] = mystrdup (mask);
14947 }
14948 }
14949
14950 // base
14951
14952 int wls_left = myargc - (optind + 2);
14953
14954 for (int i = 0; i < wls_left; i++)
14955 {
14956 char *filename = myargv[optind + 2 + i];
14957
14958 struct stat file_stat;
14959
14960 if (stat (filename, &file_stat) == -1)
14961 {
14962 log_error ("ERROR: %s: %s", filename, strerror (errno));
14963
14964 return (-1);
14965 }
14966
14967 uint is_dir = S_ISDIR (file_stat.st_mode);
14968
14969 if (is_dir == 0)
14970 {
14971 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14972
14973 dictcnt++;
14974
14975 dictfiles[dictcnt - 1] = filename;
14976 }
14977 else
14978 {
14979 // do not allow --keyspace w/ a directory
14980
14981 if (keyspace == 1)
14982 {
14983 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14984
14985 return (-1);
14986 }
14987
14988 char **dictionary_files = NULL;
14989
14990 dictionary_files = scan_directory (filename);
14991
14992 if (dictionary_files != NULL)
14993 {
14994 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14995
14996 for (int d = 0; dictionary_files[d] != NULL; d++)
14997 {
14998 char *l1_filename = dictionary_files[d];
14999
15000 struct stat l1_stat;
15001
15002 if (stat (l1_filename, &l1_stat) == -1)
15003 {
15004 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15005
15006 return (-1);
15007 }
15008
15009 if (S_ISREG (l1_stat.st_mode))
15010 {
15011 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15012
15013 dictcnt++;
15014
15015 dictfiles[dictcnt - 1] = strdup (l1_filename);
15016 }
15017 }
15018 }
15019
15020 local_free (dictionary_files);
15021 }
15022 }
15023
15024 if (dictcnt < 1)
15025 {
15026 log_error ("ERROR: No usable dictionary file found.");
15027
15028 return (-1);
15029 }
15030
15031 if (increment)
15032 {
15033 maskcnt = 0;
15034
15035 uint mask_min = increment_min; // we can't reject smaller masks here
15036 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15037
15038 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15039 {
15040 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15041
15042 if (cur_mask == NULL) break;
15043
15044 masks[maskcnt] = cur_mask;
15045
15046 maskcnt++;
15047
15048 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15049 }
15050 }
15051 }
15052
15053 data.pw_min = pw_min;
15054 data.pw_max = pw_max;
15055
15056 /**
15057 * weak hash check
15058 */
15059
15060 if (weak_hash_threshold >= salts_cnt)
15061 {
15062 uint first_device_id = 0;
15063
15064 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15065 {
15066 hc_device_param_t *device_param = &data.devices_param[device_id];
15067
15068 if (device_param->skipped) continue;
15069
15070 first_device_id = device_id;
15071
15072 break;
15073 }
15074
15075 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15076
15077 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15078 {
15079 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15080 }
15081 }
15082
15083 // Display hack, guarantee that there is at least one \r before real start
15084
15085 if (data.quiet == 0) log_info_nn ("");
15086
15087 /**
15088 * status and monitor threads
15089 */
15090
15091 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15092
15093 hc_thread_t i_thread = 0;
15094
15095 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15096 {
15097 hc_thread_create (i_thread, thread_keypress, &benchmark);
15098 }
15099
15100 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15101
15102 uint ni_threads_cnt = 0;
15103
15104 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15105
15106 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15107
15108 ni_threads_cnt++;
15109
15110 /**
15111 * Outfile remove
15112 */
15113
15114 if (keyspace == 0)
15115 {
15116 if (outfile_check_timer != 0)
15117 {
15118 if (data.outfile_check_directory != NULL)
15119 {
15120 if ((hash_mode != 5200) &&
15121 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15122 (hash_mode != 9000))
15123 {
15124 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15125
15126 ni_threads_cnt++;
15127 }
15128 else
15129 {
15130 outfile_check_timer = 0;
15131 }
15132 }
15133 else
15134 {
15135 outfile_check_timer = 0;
15136 }
15137 }
15138 }
15139
15140 /**
15141 * Inform the user if we got some hashes remove because of the pot file remove feature
15142 */
15143
15144 if (data.quiet == 0)
15145 {
15146 if (potfile_remove_cracks > 0)
15147 {
15148 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15149 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15150 }
15151 }
15152
15153 data.outfile_check_timer = outfile_check_timer;
15154
15155 /**
15156 * main loop
15157 */
15158
15159 char **induction_dictionaries = NULL;
15160
15161 int induction_dictionaries_cnt = 0;
15162
15163 hcstat_table_t *root_table_buf = NULL;
15164 hcstat_table_t *markov_table_buf = NULL;
15165
15166 uint initial_restore_done = 0;
15167
15168 data.maskcnt = maskcnt;
15169
15170 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15171 {
15172 if (data.devices_status == STATUS_CRACKED) break;
15173
15174 data.devices_status = STATUS_INIT;
15175
15176 if (maskpos > rd->maskpos)
15177 {
15178 rd->dictpos = 0;
15179 }
15180
15181 rd->maskpos = maskpos;
15182 data.maskpos = maskpos;
15183
15184 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15185 {
15186 char *mask = masks[maskpos];
15187
15188 if (mask_from_file == 1)
15189 {
15190 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15191
15192 char *str_ptr;
15193 uint str_pos;
15194
15195 uint mask_offset = 0;
15196
15197 uint separator_cnt;
15198
15199 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15200 {
15201 str_ptr = strstr (mask + mask_offset, ",");
15202
15203 if (str_ptr == NULL) break;
15204
15205 str_pos = str_ptr - mask;
15206
15207 // escaped separator, i.e. "\,"
15208
15209 if (str_pos > 0)
15210 {
15211 if (mask[str_pos - 1] == '\\')
15212 {
15213 separator_cnt --;
15214
15215 mask_offset = str_pos + 1;
15216
15217 continue;
15218 }
15219 }
15220
15221 // reset the offset
15222
15223 mask_offset = 0;
15224
15225 mask[str_pos] = '\0';
15226
15227 switch (separator_cnt)
15228 {
15229 case 0:
15230 mp_reset_usr (mp_usr, 0);
15231
15232 custom_charset_1 = mask;
15233 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15234 break;
15235
15236 case 1:
15237 mp_reset_usr (mp_usr, 1);
15238
15239 custom_charset_2 = mask;
15240 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15241 break;
15242
15243 case 2:
15244 mp_reset_usr (mp_usr, 2);
15245
15246 custom_charset_3 = mask;
15247 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15248 break;
15249
15250 case 3:
15251 mp_reset_usr (mp_usr, 3);
15252
15253 custom_charset_4 = mask;
15254 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15255 break;
15256 }
15257
15258 mask = mask + str_pos + 1;
15259 }
15260 }
15261
15262 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15263 {
15264 if (maskpos > 0)
15265 {
15266 local_free (css_buf);
15267 local_free (data.root_css_buf);
15268 local_free (data.markov_css_buf);
15269
15270 local_free (masks[maskpos - 1]);
15271 }
15272
15273 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15274
15275 data.mask = mask;
15276 data.css_cnt = css_cnt;
15277 data.css_buf = css_buf;
15278
15279 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15280
15281 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15282
15283 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15284 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15285
15286 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15287
15288 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15289
15290 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15291 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15292
15293 data.root_css_buf = root_css_buf;
15294 data.markov_css_buf = markov_css_buf;
15295
15296 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15297
15298 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15299
15300 local_free (root_table_buf);
15301 local_free (markov_table_buf);
15302
15303 // args
15304
15305 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15306 {
15307 hc_device_param_t *device_param = &data.devices_param[device_id];
15308
15309 if (device_param->skipped) continue;
15310
15311 device_param->kernel_params_mp[0] = &device_param->d_combs;
15312 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15313 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15314
15315 device_param->kernel_params_mp_buf64[3] = 0;
15316 device_param->kernel_params_mp_buf32[4] = css_cnt;
15317 device_param->kernel_params_mp_buf32[5] = 0;
15318 device_param->kernel_params_mp_buf32[6] = 0;
15319 device_param->kernel_params_mp_buf32[7] = 0;
15320
15321 if (attack_mode == ATTACK_MODE_HYBRID1)
15322 {
15323 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15324 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15325 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15326 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15327 }
15328 else if (attack_mode == ATTACK_MODE_HYBRID2)
15329 {
15330 device_param->kernel_params_mp_buf32[5] = 0;
15331 device_param->kernel_params_mp_buf32[6] = 0;
15332 device_param->kernel_params_mp_buf32[7] = 0;
15333 }
15334
15335 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15336 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15337 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15338
15339 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);
15340 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);
15341 }
15342 }
15343 else if (attack_mode == ATTACK_MODE_BF)
15344 {
15345 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15346
15347 if (increment)
15348 {
15349 for (uint i = 0; i < dictcnt; i++)
15350 {
15351 local_free (dictfiles[i]);
15352 }
15353
15354 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15355 {
15356 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15357
15358 if (l1_filename == NULL) break;
15359
15360 dictcnt++;
15361
15362 dictfiles[dictcnt - 1] = l1_filename;
15363 }
15364 }
15365 else
15366 {
15367 dictcnt++;
15368
15369 dictfiles[dictcnt - 1] = mask;
15370 }
15371
15372 if (dictcnt == 0)
15373 {
15374 log_error ("ERROR: Mask is too small");
15375
15376 return (-1);
15377 }
15378 }
15379 }
15380
15381 free (induction_dictionaries);
15382
15383 // induction_dictionaries_cnt = 0; // implied
15384
15385 if (attack_mode != ATTACK_MODE_BF)
15386 {
15387 if (keyspace == 0)
15388 {
15389 induction_dictionaries = scan_directory (induction_directory);
15390
15391 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15392 }
15393 }
15394
15395 if (induction_dictionaries_cnt)
15396 {
15397 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15398 }
15399
15400 /**
15401 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15402 */
15403 if (keyspace == 1)
15404 {
15405 if ((maskcnt > 1) || (dictcnt > 1))
15406 {
15407 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15408
15409 return (-1);
15410 }
15411 }
15412
15413 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15414 {
15415 char *subid = logfile_generate_subid ();
15416
15417 data.subid = subid;
15418
15419 logfile_sub_msg ("START");
15420
15421 data.devices_status = STATUS_INIT;
15422
15423 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15424 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15425 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15426
15427 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15428
15429 data.cpt_pos = 0;
15430
15431 data.cpt_start = time (NULL);
15432
15433 data.cpt_total = 0;
15434
15435 if (data.restore == 0)
15436 {
15437 rd->words_cur = skip;
15438
15439 skip = 0;
15440
15441 data.skip = 0;
15442 }
15443
15444 data.ms_paused = 0;
15445
15446 data.words_cur = rd->words_cur;
15447
15448 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15449 {
15450 hc_device_param_t *device_param = &data.devices_param[device_id];
15451
15452 if (device_param->skipped) continue;
15453
15454 device_param->speed_pos = 0;
15455
15456 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15457 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15458 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15459
15460 device_param->kernel_power = device_param->kernel_power_user;
15461 device_param->kernel_blocks = device_param->kernel_blocks_user;
15462
15463 device_param->outerloop_pos = 0;
15464 device_param->outerloop_left = 0;
15465 device_param->innerloop_pos = 0;
15466 device_param->innerloop_left = 0;
15467
15468 // some more resets:
15469
15470 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15471
15472 memset (device_param->pws_buf, 0, device_param->size_pws);
15473
15474 device_param->pw_cnt = 0;
15475 device_param->pws_cnt = 0;
15476
15477 device_param->words_off = 0;
15478 device_param->words_done = 0;
15479 }
15480
15481 data.kernel_blocks_div = 0;
15482
15483 // figure out some workload
15484
15485 if (attack_mode == ATTACK_MODE_STRAIGHT)
15486 {
15487 if (data.wordlist_mode == WL_MODE_FILE)
15488 {
15489 char *dictfile = NULL;
15490
15491 if (induction_dictionaries_cnt)
15492 {
15493 dictfile = induction_dictionaries[0];
15494 }
15495 else
15496 {
15497 dictfile = dictfiles[dictpos];
15498 }
15499
15500 data.dictfile = dictfile;
15501
15502 logfile_sub_string (dictfile);
15503
15504 for (uint i = 0; i < rp_files_cnt; i++)
15505 {
15506 logfile_sub_var_string ("rulefile", rp_files[i]);
15507 }
15508
15509 FILE *fd2 = fopen (dictfile, "rb");
15510
15511 if (fd2 == NULL)
15512 {
15513 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15514
15515 return (-1);
15516 }
15517
15518 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15519
15520 fclose (fd2);
15521
15522 if (data.words_cnt == 0)
15523 {
15524 if (data.devices_status == STATUS_CRACKED) break;
15525 if (data.devices_status == STATUS_ABORTED) break;
15526
15527 dictpos++;
15528
15529 continue;
15530 }
15531 }
15532 }
15533 else if (attack_mode == ATTACK_MODE_COMBI)
15534 {
15535 char *dictfile = data.dictfile;
15536 char *dictfile2 = data.dictfile2;
15537
15538 logfile_sub_string (dictfile);
15539 logfile_sub_string (dictfile2);
15540
15541 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
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 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15557 {
15558 FILE *fd2 = fopen (dictfile2, "rb");
15559
15560 if (fd2 == NULL)
15561 {
15562 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15563
15564 return (-1);
15565 }
15566
15567 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15568
15569 fclose (fd2);
15570 }
15571
15572 if (data.words_cnt == 0)
15573 {
15574 if (data.devices_status == STATUS_CRACKED) break;
15575 if (data.devices_status == STATUS_ABORTED) break;
15576
15577 dictpos++;
15578
15579 continue;
15580 }
15581 }
15582 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15583 {
15584 char *dictfile = NULL;
15585
15586 if (induction_dictionaries_cnt)
15587 {
15588 dictfile = induction_dictionaries[0];
15589 }
15590 else
15591 {
15592 dictfile = dictfiles[dictpos];
15593 }
15594
15595 data.dictfile = dictfile;
15596
15597 char *mask = data.mask;
15598
15599 logfile_sub_string (dictfile);
15600 logfile_sub_string (mask);
15601
15602 FILE *fd2 = fopen (dictfile, "rb");
15603
15604 if (fd2 == NULL)
15605 {
15606 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15607
15608 return (-1);
15609 }
15610
15611 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15612
15613 fclose (fd2);
15614
15615 if (data.words_cnt == 0)
15616 {
15617 if (data.devices_status == STATUS_CRACKED) break;
15618 if (data.devices_status == STATUS_ABORTED) break;
15619
15620 dictpos++;
15621
15622 continue;
15623 }
15624 }
15625 else if (attack_mode == ATTACK_MODE_BF)
15626 {
15627 local_free (css_buf);
15628 local_free (data.root_css_buf);
15629 local_free (data.markov_css_buf);
15630
15631 char *mask = dictfiles[dictpos];
15632
15633 logfile_sub_string (mask);
15634
15635 // base
15636
15637 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15638
15639 if (opts_type & OPTS_TYPE_PT_UNICODE)
15640 {
15641 uint css_cnt_unicode = css_cnt * 2;
15642
15643 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15644
15645 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15646 {
15647 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15648
15649 css_buf_unicode[j + 1].cs_buf[0] = 0;
15650 css_buf_unicode[j + 1].cs_len = 1;
15651 }
15652
15653 free (css_buf);
15654
15655 css_buf = css_buf_unicode;
15656 css_cnt = css_cnt_unicode;
15657 }
15658
15659 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15660
15661 uint mask_min = pw_min;
15662 uint mask_max = pw_max;
15663
15664 if (opts_type & OPTS_TYPE_PT_UNICODE)
15665 {
15666 mask_min *= 2;
15667 mask_max *= 2;
15668 }
15669
15670 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15671 {
15672 if (css_cnt < mask_min)
15673 {
15674 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15675 }
15676
15677 if (css_cnt > mask_max)
15678 {
15679 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15680 }
15681
15682 // skip to next mask
15683
15684 dictpos++;
15685
15686 rd->dictpos = dictpos;
15687
15688 logfile_sub_msg ("STOP");
15689
15690 continue;
15691 }
15692
15693 uint save_css_cnt = css_cnt;
15694
15695 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15696 {
15697 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15698 {
15699 uint salt_len = (uint) data.salts_buf[0].salt_len;
15700 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15701
15702 uint css_cnt_salt = css_cnt + salt_len;
15703
15704 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15705
15706 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15707
15708 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15709 {
15710 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15711 css_buf_salt[j].cs_len = 1;
15712 }
15713
15714 free (css_buf);
15715
15716 css_buf = css_buf_salt;
15717 css_cnt = css_cnt_salt;
15718 }
15719 }
15720
15721 data.mask = mask;
15722 data.css_cnt = css_cnt;
15723 data.css_buf = css_buf;
15724
15725 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15726
15727 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15728
15729 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15730
15731 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15732 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15733
15734 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15735
15736 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15737
15738 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15739 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15740
15741 data.root_css_buf = root_css_buf;
15742 data.markov_css_buf = markov_css_buf;
15743
15744 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15745
15746 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15747
15748 local_free (root_table_buf);
15749 local_free (markov_table_buf);
15750
15751 // copy + args
15752
15753 uint css_cnt_l = css_cnt;
15754 uint css_cnt_r;
15755
15756 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15757 {
15758 if (save_css_cnt < 6)
15759 {
15760 css_cnt_r = 1;
15761 }
15762 else if (save_css_cnt == 6)
15763 {
15764 css_cnt_r = 2;
15765 }
15766 else
15767 {
15768 if (opts_type & OPTS_TYPE_PT_UNICODE)
15769 {
15770 if (save_css_cnt == 8 || save_css_cnt == 10)
15771 {
15772 css_cnt_r = 2;
15773 }
15774 else
15775 {
15776 css_cnt_r = 4;
15777 }
15778 }
15779 else
15780 {
15781 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15782 {
15783 css_cnt_r = 3;
15784 }
15785 else
15786 {
15787 css_cnt_r = 4;
15788 }
15789 }
15790 }
15791 }
15792 else
15793 {
15794 css_cnt_r = 1;
15795
15796 /* unfinished code?
15797 int sum = css_buf[css_cnt_r - 1].cs_len;
15798
15799 for (uint i = 1; i < 4 && i < css_cnt; i++)
15800 {
15801 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15802
15803 css_cnt_r++;
15804
15805 sum *= css_buf[css_cnt_r - 1].cs_len;
15806 }
15807 */
15808 }
15809
15810 css_cnt_l -= css_cnt_r;
15811
15812 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15813
15814 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15815 {
15816 hc_device_param_t *device_param = &data.devices_param[device_id];
15817
15818 if (device_param->skipped) continue;
15819
15820 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15821 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15822 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15823
15824 device_param->kernel_params_mp_l_buf64[3] = 0;
15825 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15826 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15827 device_param->kernel_params_mp_l_buf32[6] = 0;
15828 device_param->kernel_params_mp_l_buf32[7] = 0;
15829 device_param->kernel_params_mp_l_buf32[8] = 0;
15830
15831 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15832 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15833 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15834 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15835
15836 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15837 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15838 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15839
15840 device_param->kernel_params_mp_r_buf64[3] = 0;
15841 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15842 device_param->kernel_params_mp_r_buf32[5] = 0;
15843 device_param->kernel_params_mp_r_buf32[6] = 0;
15844 device_param->kernel_params_mp_r_buf32[7] = 0;
15845
15846 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]);
15847 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]);
15848 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]);
15849
15850 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]);
15851 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]);
15852 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]);
15853
15854 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);
15855 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);
15856 }
15857 }
15858
15859 u64 words_base = data.words_cnt;
15860
15861 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15862 {
15863 if (data.kernel_rules_cnt)
15864 {
15865 words_base /= data.kernel_rules_cnt;
15866 }
15867 }
15868 else if (data.attack_kern == ATTACK_KERN_COMBI)
15869 {
15870 if (data.combs_cnt)
15871 {
15872 words_base /= data.combs_cnt;
15873 }
15874 }
15875 else if (data.attack_kern == ATTACK_KERN_BF)
15876 {
15877 if (data.bfs_cnt)
15878 {
15879 words_base /= data.bfs_cnt;
15880 }
15881 }
15882
15883 data.words_base = words_base;
15884
15885 if (keyspace == 1)
15886 {
15887 log_info ("%llu", (unsigned long long int) words_base);
15888
15889 return (0);
15890 }
15891
15892 if (data.words_cur > data.words_base)
15893 {
15894 log_error ("ERROR: restore value greater keyspace");
15895
15896 return (-1);
15897 }
15898
15899 if (data.words_cur)
15900 {
15901 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15902 {
15903 for (uint i = 0; i < data.salts_cnt; i++)
15904 {
15905 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15906 }
15907 }
15908 else if (data.attack_kern == ATTACK_KERN_COMBI)
15909 {
15910 for (uint i = 0; i < data.salts_cnt; i++)
15911 {
15912 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15913 }
15914 }
15915 else if (data.attack_kern == ATTACK_KERN_BF)
15916 {
15917 for (uint i = 0; i < data.salts_cnt; i++)
15918 {
15919 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15920 }
15921 }
15922 }
15923
15924 /*
15925 * Inform user about possible slow speeds
15926 */
15927
15928 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15929 {
15930 if (data.words_base < kernel_blocks_all)
15931 {
15932 if (quiet == 0)
15933 {
15934 log_info ("");
15935 log_info ("ATTENTION!");
15936 log_info (" The wordlist or mask you are using is too small.");
15937 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15938 log_info (" The cracking speed will drop.");
15939 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15940 log_info ("");
15941 }
15942 }
15943 }
15944
15945 /*
15946 * Update loopback file
15947 */
15948
15949 if (loopback == 1)
15950 {
15951 time_t now;
15952
15953 time (&now);
15954
15955 uint random_num = get_random_num (0, 9999);
15956
15957 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15958
15959 data.loopback_file = loopback_file;
15960 }
15961
15962 /*
15963 * Update dictionary statistic
15964 */
15965
15966 if (keyspace == 0)
15967 {
15968 dictstat_fp = fopen (dictstat, "wb");
15969
15970 if (dictstat_fp)
15971 {
15972 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15973
15974 fclose (dictstat_fp);
15975 }
15976 }
15977
15978 data.devices_status = STATUS_RUNNING;
15979
15980 if (initial_restore_done == 0)
15981 {
15982 if (data.restore_disable == 0) cycle_restore ();
15983
15984 initial_restore_done = 1;
15985 }
15986
15987 hc_timer_set (&data.timer_running);
15988
15989 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15990 {
15991 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15992 {
15993 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15994 if (quiet == 0) fflush (stdout);
15995 }
15996 }
15997 else if (wordlist_mode == WL_MODE_STDIN)
15998 {
15999 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16000 if (data.quiet == 0) log_info ("");
16001 }
16002
16003 time_t runtime_start;
16004
16005 time (&runtime_start);
16006
16007 data.runtime_start = runtime_start;
16008
16009 /**
16010 * create cracker threads
16011 */
16012
16013 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16014
16015 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16016 {
16017 hc_device_param_t *device_param = &devices_param[device_id];
16018
16019 if (wordlist_mode == WL_MODE_STDIN)
16020 {
16021 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16022 }
16023 else
16024 {
16025 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16026 }
16027 }
16028
16029 // wait for crack threads to exit
16030
16031 hc_thread_wait (devices_cnt, c_threads);
16032
16033 local_free (c_threads);
16034
16035 data.restore = 0;
16036
16037 // finalize task
16038
16039 logfile_sub_var_uint ("status-after-work", data.devices_status);
16040
16041 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16042
16043 if (data.devices_status == STATUS_CRACKED) break;
16044 if (data.devices_status == STATUS_ABORTED) break;
16045
16046 if (data.devices_status == STATUS_BYPASS)
16047 {
16048 data.devices_status = STATUS_RUNNING;
16049 }
16050
16051 if (induction_dictionaries_cnt)
16052 {
16053 unlink (induction_dictionaries[0]);
16054 }
16055
16056 free (induction_dictionaries);
16057
16058 if (attack_mode != ATTACK_MODE_BF)
16059 {
16060 induction_dictionaries = scan_directory (induction_directory);
16061
16062 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16063 }
16064
16065 if (benchmark == 0)
16066 {
16067 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16068 {
16069 if (quiet == 0) clear_prompt ();
16070
16071 if (quiet == 0) log_info ("");
16072
16073 if (status == 1)
16074 {
16075 status_display ();
16076 }
16077 else
16078 {
16079 if (quiet == 0) status_display ();
16080 }
16081
16082 if (quiet == 0) log_info ("");
16083 }
16084 }
16085
16086 if (attack_mode == ATTACK_MODE_BF)
16087 {
16088 dictpos++;
16089
16090 rd->dictpos = dictpos;
16091 }
16092 else
16093 {
16094 if (induction_dictionaries_cnt)
16095 {
16096 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16097 }
16098 else
16099 {
16100 dictpos++;
16101
16102 rd->dictpos = dictpos;
16103 }
16104 }
16105
16106 time_t runtime_stop;
16107
16108 time (&runtime_stop);
16109
16110 data.runtime_stop = runtime_stop;
16111
16112 logfile_sub_uint (runtime_start);
16113 logfile_sub_uint (runtime_stop);
16114
16115 logfile_sub_msg ("STOP");
16116
16117 global_free (subid);
16118 }
16119
16120 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16121
16122 if (data.devices_status == STATUS_CRACKED) break;
16123 if (data.devices_status == STATUS_ABORTED) break;
16124 if (data.devices_status == STATUS_QUIT) break;
16125
16126 if (data.devices_status == STATUS_BYPASS)
16127 {
16128 data.devices_status = STATUS_RUNNING;
16129 }
16130 }
16131
16132 // 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
16133
16134 if (attack_mode == ATTACK_MODE_STRAIGHT)
16135 {
16136 if (data.wordlist_mode == WL_MODE_FILE)
16137 {
16138 if (data.dictfile == NULL)
16139 {
16140 if (dictfiles != NULL)
16141 {
16142 data.dictfile = dictfiles[0];
16143
16144 hc_timer_set (&data.timer_running);
16145 }
16146 }
16147 }
16148 }
16149 // NOTE: combi is okay because it is already set beforehand
16150 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16151 {
16152 if (data.dictfile == NULL)
16153 {
16154 if (dictfiles != NULL)
16155 {
16156 hc_timer_set (&data.timer_running);
16157
16158 data.dictfile = dictfiles[0];
16159 }
16160 }
16161 }
16162 else if (attack_mode == ATTACK_MODE_BF)
16163 {
16164 if (data.mask == NULL)
16165 {
16166 hc_timer_set (&data.timer_running);
16167
16168 data.mask = masks[0];
16169 }
16170 }
16171
16172 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16173 {
16174 data.devices_status = STATUS_EXHAUSTED;
16175 }
16176
16177 // if cracked / aborted remove last induction dictionary
16178
16179 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16180 {
16181 struct stat induct_stat;
16182
16183 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16184 {
16185 unlink (induction_dictionaries[file_pos]);
16186 }
16187 }
16188
16189 // wait for non-interactive threads
16190
16191 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16192 {
16193 hc_thread_wait (1, &ni_threads[thread_idx]);
16194 }
16195
16196 local_free (ni_threads);
16197
16198 // wait for interactive threads
16199
16200 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16201 {
16202 hc_thread_wait (1, &i_thread);
16203 }
16204
16205 // we dont need restore file anymore
16206 if (data.restore_disable == 0)
16207 {
16208 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16209 {
16210 unlink (eff_restore_file);
16211 unlink (new_restore_file);
16212 }
16213 else
16214 {
16215 cycle_restore ();
16216 }
16217 }
16218
16219 // finally save left hashes
16220
16221 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16222 {
16223 save_hash ();
16224 }
16225
16226 /**
16227 * Clean up
16228 */
16229
16230 if (benchmark == 1)
16231 {
16232 status_benchmark ();
16233
16234 log_info ("");
16235 }
16236 else
16237 {
16238 if (quiet == 0) clear_prompt ();
16239
16240 if (quiet == 0) log_info ("");
16241
16242 if (status == 1)
16243 {
16244 status_display ();
16245 }
16246 else
16247 {
16248 if (quiet == 0) status_display ();
16249 }
16250
16251 if (quiet == 0) log_info ("");
16252 }
16253
16254 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16255 {
16256 hc_device_param_t *device_param = &data.devices_param[device_id];
16257
16258 if (device_param->skipped) continue;
16259
16260 local_free (device_param->result);
16261
16262 local_free (device_param->pw_caches);
16263
16264 local_free (device_param->combs_buf);
16265
16266 local_free (device_param->hooks_buf);
16267
16268 local_free (device_param->device_name);
16269
16270 local_free (device_param->device_name_chksum);
16271
16272 local_free (device_param->device_version);
16273
16274 local_free (device_param->driver_version);
16275
16276 if (device_param->pws_buf) myfree (device_param->pws_buf);
16277 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16278 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16279 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16280 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16281 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16282 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16283 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16284 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16285 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16286 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16287 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16288 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16289 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16290 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16291 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16292 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16293 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16294 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16295 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16296 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16297 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16298 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16299 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16300 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16301 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16302 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16303 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16304 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16305
16306 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16307 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16308 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16309 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16310 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16311 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16312 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16313 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16314 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16315 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16316 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16317
16318 if (device_param->program) hc_clReleaseProgram (device_param->program);
16319 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16320 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16321
16322 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16323 if (device_param->context) hc_clReleaseContext (device_param->context);
16324 }
16325
16326 // reset default fan speed
16327
16328 if (gpu_temp_disable == 0)
16329 {
16330 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16331 {
16332 hc_thread_mutex_lock (mux_adl);
16333
16334 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16335 {
16336 hc_device_param_t *device_param = &data.devices_param[device_id];
16337
16338 if (device_param->skipped) continue;
16339
16340 if (data.hm_device[device_id].fan_supported == 1)
16341 {
16342 int fanspeed = temp_retain_fanspeed_value[device_id];
16343
16344 if (fanspeed == -1) continue;
16345
16346 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16347
16348 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16349 }
16350 }
16351
16352 hc_thread_mutex_unlock (mux_adl);
16353 }
16354 }
16355
16356 // reset power tuning
16357
16358 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16359 {
16360 hc_thread_mutex_lock (mux_adl);
16361
16362 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16363 {
16364 hc_device_param_t *device_param = &data.devices_param[device_id];
16365
16366 if (device_param->skipped) continue;
16367
16368 if (data.hm_device[device_id].od_version == 6)
16369 {
16370 // check powertune capabilities first, if not available then skip device
16371
16372 int powertune_supported = 0;
16373
16374 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16375 {
16376 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16377
16378 return (-1);
16379 }
16380
16381 if (powertune_supported != 0)
16382 {
16383 // powercontrol settings
16384
16385 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)
16386 {
16387 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16388
16389 return (-1);
16390 }
16391
16392 // clocks
16393
16394 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16395
16396 performance_state->iNumberOfPerformanceLevels = 2;
16397
16398 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16399 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16400 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16401 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16402
16403 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)
16404 {
16405 log_info ("ERROR: Failed to restore ADL performance state");
16406
16407 return (-1);
16408 }
16409
16410 local_free (performance_state);
16411 }
16412 }
16413 }
16414
16415 hc_thread_mutex_unlock (mux_adl);
16416 }
16417
16418 if (gpu_temp_disable == 0)
16419 {
16420 #ifdef LINUX
16421 if (data.hm_dll_nv)
16422 {
16423 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16424
16425 hm_close (data.hm_dll_nv);
16426 }
16427 #endif
16428
16429 #ifdef WIN
16430 NvAPI_Unload ();
16431 #endif
16432
16433 if (data.hm_dll_amd)
16434 {
16435 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16436
16437 hm_close (data.hm_dll_amd);
16438 }
16439 }
16440
16441 // free memory
16442
16443 local_free (masks);
16444
16445 local_free (dictstat_base);
16446
16447 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16448 {
16449 pot_t *pot_ptr = &pot[pot_pos];
16450
16451 hash_t *hash = &pot_ptr->hash;
16452
16453 local_free (hash->digest);
16454
16455 if (isSalted)
16456 {
16457 local_free (hash->salt);
16458 }
16459 }
16460
16461 local_free (pot);
16462
16463 local_free (all_kernel_rules_cnt);
16464 local_free (all_kernel_rules_buf);
16465
16466 local_free (wl_data->buf);
16467 local_free (wl_data);
16468
16469 local_free (bitmap_s1_a);
16470 local_free (bitmap_s1_b);
16471 local_free (bitmap_s1_c);
16472 local_free (bitmap_s1_d);
16473 local_free (bitmap_s2_a);
16474 local_free (bitmap_s2_b);
16475 local_free (bitmap_s2_c);
16476 local_free (bitmap_s2_d);
16477
16478 local_free (temp_retain_fanspeed_value);
16479 local_free (od_clock_mem_status);
16480 local_free (od_power_control_status);
16481
16482 global_free (devices_param);
16483
16484 global_free (kernel_rules_buf);
16485
16486 global_free (root_css_buf);
16487 global_free (markov_css_buf);
16488
16489 global_free (digests_buf);
16490 global_free (digests_shown);
16491 global_free (digests_shown_tmp);
16492
16493 global_free (salts_buf);
16494 global_free (salts_shown);
16495
16496 global_free (esalts_buf);
16497
16498 global_free (words_progress_done);
16499 global_free (words_progress_rejected);
16500 global_free (words_progress_restored);
16501
16502 if (pot_fp) fclose (pot_fp);
16503
16504 if (data.devices_status == STATUS_QUIT) break;
16505 }
16506
16507 // destroy others mutex
16508
16509 hc_thread_mutex_delete (mux_dispatcher);
16510 hc_thread_mutex_delete (mux_counter);
16511 hc_thread_mutex_delete (mux_display);
16512 hc_thread_mutex_delete (mux_adl);
16513
16514 // free memory
16515
16516 local_free (eff_restore_file);
16517 local_free (new_restore_file);
16518
16519 local_free (rd);
16520
16521 // loopback
16522
16523 local_free (loopback_file);
16524
16525 if (loopback == 1) unlink (loopback_file);
16526
16527 // induction directory
16528
16529 if (induction_dir == NULL)
16530 {
16531 if (attack_mode != ATTACK_MODE_BF)
16532 {
16533 if (rmdir (induction_directory) == -1)
16534 {
16535 if (errno == ENOENT)
16536 {
16537 // good, we can ignore
16538 }
16539 else if (errno == ENOTEMPTY)
16540 {
16541 // good, we can ignore
16542 }
16543 else
16544 {
16545 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16546
16547 return (-1);
16548 }
16549 }
16550
16551 local_free (induction_directory);
16552 }
16553 }
16554
16555 // outfile-check directory
16556
16557 if (outfile_check_dir == NULL)
16558 {
16559 if (rmdir (outfile_check_directory) == -1)
16560 {
16561 if (errno == ENOENT)
16562 {
16563 // good, we can ignore
16564 }
16565 else if (errno == ENOTEMPTY)
16566 {
16567 // good, we can ignore
16568 }
16569 else
16570 {
16571 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16572
16573 return (-1);
16574 }
16575 }
16576
16577 local_free (outfile_check_directory);
16578 }
16579
16580 time_t proc_stop;
16581
16582 time (&proc_stop);
16583
16584 logfile_top_uint (proc_start);
16585 logfile_top_uint (proc_stop);
16586
16587 logfile_top_msg ("STOP");
16588
16589 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16590 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16591
16592 if (data.devices_status == STATUS_ABORTED) return 2;
16593 if (data.devices_status == STATUS_QUIT) return 2;
16594 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16595 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16596 if (data.devices_status == STATUS_CRACKED) return 0;
16597
16598 return -1;
16599 }
Hashcat additions to support pwdhash