projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
cosmetic fix: some fixed typos e.g. to -> too
[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 #define OPENCL_VECTOR_WIDTH 0
84
85 #define WL_MODE_STDIN 1
86 #define WL_MODE_FILE 2
87 #define WL_MODE_MASK 3
88
89 #define HL_MODE_FILE 4
90 #define HL_MODE_ARG 5
91
92 #define HLFMT_HASHCAT 0
93 #define HLFMT_PWDUMP 1
94 #define HLFMT_PASSWD 2
95 #define HLFMT_SHADOW 3
96 #define HLFMT_DCC 4
97 #define HLFMT_DCC2 5
98 #define HLFMT_NETNTLM1 7
99 #define HLFMT_NETNTLM2 8
100 #define HLFMT_NSLDAP 9
101 #define HLFMT_NSLDAPS 10
102 #define HLFMTS_CNT 11
103
104 #define ATTACK_MODE_STRAIGHT 0
105 #define ATTACK_MODE_COMBI 1
106 #define ATTACK_MODE_TOGGLE 2
107 #define ATTACK_MODE_BF 3
108 #define ATTACK_MODE_PERM 4
109 #define ATTACK_MODE_TABLE 5
110 #define ATTACK_MODE_HYBRID1 6
111 #define ATTACK_MODE_HYBRID2 7
112 #define ATTACK_MODE_NONE 100
113
114 #define ATTACK_KERN_STRAIGHT 0
115 #define ATTACK_KERN_COMBI 1
116 #define ATTACK_KERN_BF 3
117 #define ATTACK_KERN_NONE 100
118
119 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
120 #define ATTACK_EXEC_INSIDE_KERNEL 11
121
122 #define COMBINATOR_MODE_BASE_LEFT 10001
123 #define COMBINATOR_MODE_BASE_RIGHT 10002
124
125 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
126 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
127
128 #define MAX_CUT_TRIES 4
129
130 #define MAX_DICTSTAT 10000
131
132 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
133
134 #define global_free(attr) \
135 { \
136 myfree ((void *) data.attr); \
137 \
138 data.attr = NULL; \
139 }
140
141 #define local_free(attr) \
142 { \
143 myfree ((void *) attr); \
144 \
145 attr = NULL; \
146 }
147
148 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
149 {
150 900,
151 0,
152 5100,
153 100,
154 1400,
155 10800,
156 1700,
157 5000,
158 10100,
159 6000,
160 6100,
161 6900,
162 11700,
163 11800,
164 400,
165 8900,
166 11900,
167 12000,
168 10900,
169 12100,
170 23,
171 2500,
172 5300,
173 5400,
174 5500,
175 5600,
176 7300,
177 7500,
178 8300,
179 11100,
180 11200,
181 11400,
182 121,
183 2611,
184 2711,
185 2811,
186 8400,
187 11,
188 2612,
189 7900,
190 21,
191 11000,
192 124,
193 10000,
194 3711,
195 7600,
196 12,
197 131,
198 132,
199 1731,
200 200,
201 300,
202 3100,
203 112,
204 12300,
205 8000,
206 141,
207 1441,
208 1600,
209 12600,
210 1421,
211 101,
212 111,
213 1711,
214 3000,
215 1000,
216 1100,
217 2100,
218 12800,
219 1500,
220 12400,
221 500,
222 3200,
223 7400,
224 1800,
225 122,
226 1722,
227 7100,
228 6300,
229 6700,
230 6400,
231 6500,
232 2400,
233 2410,
234 5700,
235 9200,
236 9300,
237 22,
238 501,
239 5800,
240 8100,
241 8500,
242 7200,
243 9900,
244 7700,
245 7800,
246 10300,
247 8600,
248 8700,
249 9100,
250 133,
251 11600,
252 12500,
253 13000,
254 6211,
255 6221,
256 6231,
257 6241,
258 8800,
259 12900,
260 12200,
261 9700,
262 9710,
263 9800,
264 9810,
265 9400,
266 9500,
267 9600,
268 10400,
269 10410,
270 10500,
271 10600,
272 10700,
273 9000,
274 5200,
275 6800,
276 6600,
277 8200,
278 11300,
279 12700
280 };
281
282 /**
283 * types
284 */
285
286 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
287
288 /**
289 * globals
290 */
291
292 static unsigned int full01 = 0x01010101;
293 static unsigned int full80 = 0x80808080;
294
295 int SUPPRESS_OUTPUT = 0;
296
297 hc_thread_mutex_t mux_adl;
298 hc_thread_mutex_t mux_counter;
299 hc_thread_mutex_t mux_dispatcher;
300 hc_thread_mutex_t mux_display;
301
302 hc_global_data_t data;
303
304 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
305
306 const char *USAGE_MINI[] =
307 {
308 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
309 "",
310 "Try --help for more help.",
311 NULL
312 };
313
314 const char *USAGE_BIG[] =
315 {
316 "%s, advanced password recovery",
317 "",
318 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
319 "",
320 "=======",
321 "Options",
322 "=======",
323 "",
324 "* General:",
325 "",
326 " -m, --hash-type=NUM Hash-type, see references below",
327 " -a, --attack-mode=NUM Attack-mode, see references below",
328 " -V, --version Print version",
329 " -h, --help Print help",
330 " --quiet Suppress output",
331 "",
332 "* Benchmark:",
333 "",
334 " -b, --benchmark Run benchmark",
335 " --benchmark-mode=NUM Benchmark-mode, see references below",
336 "",
337 "* Misc:",
338 "",
339 " --hex-charset Assume charset is given in hex",
340 " --hex-salt Assume salt is given in hex",
341 " --hex-wordlist Assume words in wordlist is given in hex",
342 " --force Ignore warnings",
343 " --status Enable automatic update of the status-screen",
344 " --status-timer=NUM Seconds between status-screen update",
345 " --status-automat Display the status view in a machine readable format",
346 " --loopback Add new plains to induct directory",
347 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
348 "",
349 "* Markov:",
350 "",
351 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
352 " --markov-disable Disables markov-chains, emulates classic brute-force",
353 " --markov-classic Enables classic markov-chains, no per-position enhancement",
354 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
355 "",
356 "* Session:",
357 "",
358 " --runtime=NUM Abort session after NUM seconds of runtime",
359 " --session=STR Define specific session name",
360 " --restore Restore session from --session",
361 " --restore-disable Do not write restore file",
362 "",
363 "* Files:",
364 "",
365 " -o, --outfile=FILE Define outfile for recovered hash",
366 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
367 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
368 " --outfile-check-timer=NUM Seconds between outfile checks",
369 " -p, --separator=CHAR Separator char for hashlists and outfile",
370 " --show Show cracked passwords only",
371 " --left Show un-cracked passwords only",
372 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
373 " --remove Enable remove of hash once it is cracked",
374 " --remove-timer=NUM Update input hash file each NUM seconds",
375 " --potfile-disable Do not write potfile",
376 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
377 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
378 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
379 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
380 " --logfile-disable Disable the logfile",
381 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
382 "",
383 "* Resources:",
384 "",
385 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
386 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
387 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
388 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
389 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
390 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
391 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
392 " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4 or 8), overrides value from device query",
393 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
394 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
395 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
396 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
397 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
398 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
399 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
400 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
401 "",
402 "* Distributed:",
403 "",
404 " -s, --skip=NUM Skip number of words",
405 " -l, --limit=NUM Limit number of words",
406 " --keyspace Show keyspace base:mod values and quit",
407 "",
408 "* Rules:",
409 "",
410 " -j, --rule-left=RULE Single rule applied to each word from left dict",
411 " -k, --rule-right=RULE Single rule applied to each word from right dict",
412 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
413 " -g, --generate-rules=NUM Generate NUM random rules",
414 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
415 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
416 " --generate-rules-seed=NUM Force RNG seed to NUM",
417 "",
418 "* Custom charsets:",
419 "",
420 " -1, --custom-charset1=CS User-defined charsets",
421 " -2, --custom-charset2=CS Example:",
422 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
423 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
424 "",
425 "* Increment:",
426 "",
427 " -i, --increment Enable increment mode",
428 " --increment-min=NUM Start incrementing at NUM",
429 " --increment-max=NUM Stop incrementing at NUM",
430 "",
431 "==========",
432 "References",
433 "==========",
434 "",
435 "* Workload Profile:",
436 "",
437 " 1 = Reduced performance profile (low latency desktop)",
438 " 2 = Default performance profile",
439 " 3 = Tuned performance profile (high latency desktop)",
440 "",
441 "* Benchmark Settings:",
442 "",
443 " 0 = Manual Tuning",
444 " 1 = Performance Tuning, default",
445 "",
446 "* OpenCL device-types:",
447 "",
448 " 1 = CPU devices",
449 " 2 = GPU devices",
450 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
451 "",
452 "* Outfile Formats:",
453 "",
454 " 1 = hash[:salt]",
455 " 2 = plain",
456 " 3 = hash[:salt]:plain",
457 " 4 = hex_plain",
458 " 5 = hash[:salt]:hex_plain",
459 " 6 = plain:hex_plain",
460 " 7 = hash[:salt]:plain:hex_plain",
461 " 8 = crackpos",
462 " 9 = hash[:salt]:crackpos",
463 " 10 = plain:crackpos",
464 " 11 = hash[:salt]:plain:crackpos",
465 " 12 = hex_plain:crackpos",
466 " 13 = hash[:salt]:hex_plain:crackpos",
467 " 14 = plain:hex_plain:crackpos",
468 " 15 = hash[:salt]:plain:hex_plain:crackpos",
469 "",
470 "* Debug mode output formats (for hybrid mode only, by using rules):",
471 "",
472 " 1 = save finding rule",
473 " 2 = save original word",
474 " 3 = save original word and finding rule",
475 " 4 = save original word, finding rule and modified plain",
476 "",
477 "* Built-in charsets:",
478 "",
479 " ?l = abcdefghijklmnopqrstuvwxyz",
480 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
481 " ?d = 0123456789",
482 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
483 " ?a = ?l?u?d?s",
484 " ?b = 0x00 - 0xff",
485 "",
486 "* Attack modes:",
487 "",
488 " 0 = Straight",
489 " 1 = Combination",
490 " 3 = Brute-force",
491 " 6 = Hybrid dict + mask",
492 " 7 = Hybrid mask + dict",
493 "",
494 "* Hash types:",
495 "",
496 "[[ Roll-your-own: Raw Hashes ]]",
497 "",
498 " 900 = MD4",
499 " 0 = MD5",
500 " 5100 = Half MD5",
501 " 100 = SHA1",
502 " 10800 = SHA-384",
503 " 1400 = SHA-256",
504 " 1700 = SHA-512",
505 " 5000 = SHA-3(Keccak)",
506 " 10100 = SipHash",
507 " 6000 = RipeMD160",
508 " 6100 = Whirlpool",
509 " 6900 = GOST R 34.11-94",
510 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
511 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
512 "",
513 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
514 "",
515 " 10 = md5($pass.$salt)",
516 " 20 = md5($salt.$pass)",
517 " 30 = md5(unicode($pass).$salt)",
518 " 40 = md5($salt.unicode($pass))",
519 " 3800 = md5($salt.$pass.$salt)",
520 " 3710 = md5($salt.md5($pass))",
521 " 2600 = md5(md5($pass)",
522 " 4300 = md5(strtoupper(md5($pass)))",
523 " 4400 = md5(sha1($pass))",
524 " 110 = sha1($pass.$salt)",
525 " 120 = sha1($salt.$pass)",
526 " 130 = sha1(unicode($pass).$salt)",
527 " 140 = sha1($salt.unicode($pass))",
528 " 4500 = sha1(sha1($pass)",
529 " 4700 = sha1(md5($pass))",
530 " 4900 = sha1($salt.$pass.$salt)",
531 " 1410 = sha256($pass.$salt)",
532 " 1420 = sha256($salt.$pass)",
533 " 1430 = sha256(unicode($pass).$salt)",
534 " 1440 = sha256($salt.unicode($pass))",
535 " 1710 = sha512($pass.$salt)",
536 " 1720 = sha512($salt.$pass)",
537 " 1730 = sha512(unicode($pass).$salt)",
538 " 1740 = sha512($salt.unicode($pass))",
539 "",
540 "[[ Roll-your-own: Authenticated Hashes ]]",
541 "",
542 " 50 = HMAC-MD5 (key = $pass)",
543 " 60 = HMAC-MD5 (key = $salt)",
544 " 150 = HMAC-SHA1 (key = $pass)",
545 " 160 = HMAC-SHA1 (key = $salt)",
546 " 1450 = HMAC-SHA256 (key = $pass)",
547 " 1460 = HMAC-SHA256 (key = $salt)",
548 " 1750 = HMAC-SHA512 (key = $pass)",
549 " 1760 = HMAC-SHA512 (key = $salt)",
550 "",
551 "[[ Generic KDF ]]",
552 "",
553 " 400 = phpass",
554 " 8900 = scrypt",
555 " 11900 = PBKDF2-HMAC-MD5",
556 " 12000 = PBKDF2-HMAC-SHA1",
557 " 10900 = PBKDF2-HMAC-SHA256",
558 " 12100 = PBKDF2-HMAC-SHA512",
559 "",
560 "[[ Network protocols, Challenge-Response ]]",
561 "",
562 " 23 = Skype",
563 " 2500 = WPA/WPA2",
564 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
565 " 5300 = IKE-PSK MD5",
566 " 5400 = IKE-PSK SHA1",
567 " 5500 = NetNTLMv1",
568 " 5500 = NetNTLMv1 + ESS",
569 " 5600 = NetNTLMv2",
570 " 7300 = IPMI2 RAKP HMAC-SHA1",
571 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
572 " 8300 = DNSSEC (NSEC3)",
573 " 10200 = Cram MD5",
574 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
575 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
576 " 11400 = SIP digest authentication (MD5)",
577 "",
578 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
579 "",
580 " 121 = SMF (Simple Machines Forum)",
581 " 400 = phpBB3",
582 " 2611 = vBulletin < v3.8.5",
583 " 2711 = vBulletin > v3.8.5",
584 " 2811 = MyBB",
585 " 2811 = IPB (Invison Power Board)",
586 " 8400 = WBB3 (Woltlab Burning Board)",
587 " 11 = Joomla < 2.5.18",
588 " 400 = Joomla > 2.5.18",
589 " 400 = Wordpress",
590 " 2612 = PHPS",
591 " 7900 = Drupal7",
592 " 21 = osCommerce",
593 " 21 = xt:Commerce",
594 " 11000 = PrestaShop",
595 " 124 = Django (SHA-1)",
596 " 10000 = Django (PBKDF2-SHA256)",
597 " 3711 = Mediawiki B type",
598 " 7600 = Redmine",
599 "",
600 "[[ Database Server ]]",
601 "",
602 " 12 = PostgreSQL",
603 " 131 = MSSQL(2000)",
604 " 132 = MSSQL(2005)",
605 " 1731 = MSSQL(2012)",
606 " 1731 = MSSQL(2014)",
607 " 200 = MySQL323",
608 " 300 = MySQL4.1/MySQL5",
609 " 3100 = Oracle H: Type (Oracle 7+)",
610 " 112 = Oracle S: Type (Oracle 11+)",
611 " 12300 = Oracle T: Type (Oracle 12+)",
612 " 8000 = Sybase ASE",
613 "",
614 "[[ HTTP, SMTP, LDAP Server ]]",
615 "",
616 " 141 = EPiServer 6.x < v4",
617 " 1441 = EPiServer 6.x > v4",
618 " 1600 = Apache $apr1$",
619 " 12600 = ColdFusion 10+",
620 " 1421 = hMailServer",
621 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
622 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
623 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
624 "",
625 "[[ Checksums ]]",
626 "",
627 " 11500 = CRC32",
628 "",
629 "[[ Operating-Systems ]]",
630 "",
631 " 3000 = LM",
632 " 1000 = NTLM",
633 " 1100 = Domain Cached Credentials (DCC), MS Cache",
634 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
635 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
636 " 1500 = descrypt, DES(Unix), Traditional DES",
637 " 12400 = BSDiCrypt, Extended DES",
638 " 500 = md5crypt $1$, MD5(Unix)",
639 " 3200 = bcrypt $2*$, Blowfish(Unix)",
640 " 7400 = sha256crypt $5$, SHA256(Unix)",
641 " 1800 = sha512crypt $6$, SHA512(Unix)",
642 " 122 = OSX v10.4",
643 " 122 = OSX v10.5",
644 " 122 = OSX v10.6",
645 " 1722 = OSX v10.7",
646 " 7100 = OSX v10.8",
647 " 7100 = OSX v10.9",
648 " 7100 = OSX v10.10",
649 " 6300 = AIX {smd5}",
650 " 6700 = AIX {ssha1}",
651 " 6400 = AIX {ssha256}",
652 " 6500 = AIX {ssha512}",
653 " 2400 = Cisco-PIX",
654 " 2410 = Cisco-ASA",
655 " 500 = Cisco-IOS $1$",
656 " 5700 = Cisco-IOS $4$",
657 " 9200 = Cisco-IOS $8$",
658 " 9300 = Cisco-IOS $9$",
659 " 22 = Juniper Netscreen/SSG (ScreenOS)",
660 " 501 = Juniper IVE",
661 " 5800 = Android PIN",
662 " 8100 = Citrix Netscaler",
663 " 8500 = RACF",
664 " 7200 = GRUB 2",
665 " 9900 = Radmin2",
666 "",
667 "[[ Enterprise Application Software (EAS) ]]",
668 "",
669 " 7700 = SAP CODVN B (BCODE)",
670 " 7800 = SAP CODVN F/G (PASSCODE)",
671 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
672 " 8600 = Lotus Notes/Domino 5",
673 " 8700 = Lotus Notes/Domino 6",
674 " 9100 = Lotus Notes/Domino 8",
675 " 133 = PeopleSoft",
676 "",
677 "[[ Archives ]]",
678 "",
679 " 11600 = 7-Zip",
680 " 12500 = RAR3-hp",
681 " 13000 = RAR5",
682 "",
683 "[[ Full-Disk encryptions (FDE) ]]",
684 "",
685 " 62XY = TrueCrypt 5.0+",
686 " X = 1 = PBKDF2-HMAC-RipeMD160",
687 " X = 2 = PBKDF2-HMAC-SHA512",
688 " X = 3 = PBKDF2-HMAC-Whirlpool",
689 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
690 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
691 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
692 " Y = 3 = XTS 1536 bit (Ciphers: All)",
693 " 8800 = Android FDE < v4.3",
694 " 12900 = Android FDE (Samsung DEK)",
695 " 12200 = eCryptfs",
696 "",
697 "[[ Documents ]]",
698 "",
699 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
700 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
701 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
702 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
703 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
704 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
705 " 9400 = MS Office 2007",
706 " 9500 = MS Office 2010",
707 " 9600 = MS Office 2013",
708 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
709 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
710 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
711 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
712 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
713 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
714 "",
715 "[[ Password Managers ]]",
716 "",
717 " 9000 = Password Safe v2",
718 " 5200 = Password Safe v3",
719 " 6800 = Lastpass",
720 " 6600 = 1Password, agilekeychain",
721 " 8200 = 1Password, cloudkeychain",
722 " 11300 = Bitcoin/Litecoin wallet.dat",
723 " 12700 = Blockchain, My Wallet",
724 "",
725 NULL
726 };
727
728 /**
729 * oclHashcat specific functions
730 */
731
732 void status_display_automat ()
733 {
734 FILE *out = stdout;
735
736 fprintf (out, "STATUS\t%u\t", data.devices_status);
737
738 /**
739 * speed new
740 */
741
742 fprintf (out, "SPEED\t");
743
744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
745 {
746 hc_device_param_t *device_param = &data.devices_param[device_id];
747
748 if (device_param->skipped) continue;
749
750 u64 speed_cnt = 0;
751 float speed_ms = 0;
752
753 for (int i = 0; i < SPEED_CACHE; i++)
754 {
755 float rec_ms;
756
757 hc_timer_get (device_param->speed_rec[i], rec_ms);
758
759 if (rec_ms > SPEED_MAXAGE) continue;
760
761 speed_cnt += device_param->speed_cnt[i];
762 speed_ms += device_param->speed_ms[i];
763 }
764
765 speed_cnt /= SPEED_CACHE;
766 speed_ms /= SPEED_CACHE;
767
768 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
769 }
770
771 /**
772 * words_cur
773 */
774
775 u64 words_cur = get_lowest_words_done ();
776
777 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
778
779 /**
780 * counter
781 */
782
783 uint salts_left = data.salts_cnt - data.salts_done;
784
785 if (salts_left == 0) salts_left = 1;
786
787 u64 progress_total = data.words_cnt * salts_left;
788
789 u64 all_done = 0;
790 u64 all_rejected = 0;
791 u64 all_restored = 0;
792
793 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
794 {
795 if (salts_left > 1)
796 {
797 // otherwise the final cracked status shows 0/XXX progress
798
799 if (data.salts_shown[salt_pos] == 1) continue;
800 }
801
802 all_done += data.words_progress_done[salt_pos];
803 all_rejected += data.words_progress_rejected[salt_pos];
804 all_restored += data.words_progress_restored[salt_pos];
805 }
806
807 u64 progress_cur = all_restored + all_done + all_rejected;
808 u64 progress_end = progress_total;
809
810 u64 progress_skip = 0;
811
812 if (data.skip)
813 {
814 progress_skip = MIN (data.skip, data.words_base) * salts_left;
815
816 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
817 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
818 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
819 }
820
821 if (data.limit)
822 {
823 progress_end = MIN (data.limit, data.words_base) * salts_left;
824
825 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
826 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
827 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
828 }
829
830 u64 progress_cur_relative_skip = progress_cur - progress_skip;
831 u64 progress_end_relative_skip = progress_end - progress_skip;
832
833 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
834
835 /**
836 * cracks
837 */
838
839 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
840 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
841
842 /**
843 * temperature
844 */
845
846 if (data.gpu_temp_disable == 0)
847 {
848 fprintf (out, "TEMP\t");
849
850 hc_thread_mutex_lock (mux_adl);
851
852 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
853 {
854 hc_device_param_t *device_param = &data.devices_param[device_id];
855
856 if (device_param->skipped) continue;
857
858 int temp = hm_get_temperature_with_device_id (device_id);
859
860 fprintf (out, "%d\t", temp);
861 }
862
863 hc_thread_mutex_unlock (mux_adl);
864 }
865
866 #ifdef _WIN
867 fputc ('\r', out);
868 fputc ('\n', out);
869 #endif
870
871 #ifdef _POSIX
872 fputc ('\n', out);
873 #endif
874
875 fflush (out);
876 }
877
878 void status_display ()
879 {
880 if (data.devices_status == STATUS_INIT) return;
881 if (data.devices_status == STATUS_STARTING) return;
882 if (data.devices_status == STATUS_BYPASS) return;
883
884 if (data.status_automat == 1)
885 {
886 status_display_automat ();
887
888 return;
889 }
890
891 char tmp_buf[1000];
892
893 uint tmp_len = 0;
894
895 log_info ("Session.Name...: %s", data.session);
896
897 char *status_type = strstatus (data.devices_status);
898
899 uint hash_mode = data.hash_mode;
900
901 char *hash_type = strhashtype (hash_mode); // not a bug
902
903 log_info ("Status.........: %s", status_type);
904
905 /**
906 * show rules
907 */
908
909 if (data.rp_files_cnt)
910 {
911 uint i;
912
913 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
914 {
915 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
916 }
917
918 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
919
920 log_info ("Rules.Type.....: %s", tmp_buf);
921
922 tmp_len = 0;
923 }
924
925 if (data.rp_gen)
926 {
927 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
928
929 if (data.rp_gen_seed)
930 {
931 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
932 }
933 }
934
935 /**
936 * show input
937 */
938
939 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
940 {
941 if (data.wordlist_mode == WL_MODE_FILE)
942 {
943 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
944 }
945 else if (data.wordlist_mode == WL_MODE_STDIN)
946 {
947 log_info ("Input.Mode.....: Pipe");
948 }
949 }
950 else if (data.attack_mode == ATTACK_MODE_COMBI)
951 {
952 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
953 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
954 }
955 else if (data.attack_mode == ATTACK_MODE_BF)
956 {
957 char *mask = data.mask;
958
959 if (mask != NULL)
960 {
961 uint mask_len = data.css_cnt;
962
963 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
964
965 if (mask_len > 0)
966 {
967 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
968 {
969 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
970 {
971 mask_len -= data.salts_buf[0].salt_len;
972 }
973 }
974
975 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
976
977 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
978 }
979
980 if (data.maskcnt > 1)
981 {
982 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
983
984 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
985 }
986
987 log_info ("Input.Mode.....: %s", tmp_buf);
988 }
989
990 tmp_len = 0;
991 }
992 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
995 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
996 }
997 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
998 {
999 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1000 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1001 }
1002
1003 if (data.digests_cnt == 1)
1004 {
1005 if (data.hash_mode == 2500)
1006 {
1007 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1008
1009 uint pke[25];
1010
1011 char *pke_ptr = (char *) pke;
1012
1013 for (uint i = 0; i < 25; i++)
1014 {
1015 pke[i] = byte_swap_32 (wpa->pke[i]);
1016 }
1017
1018 char mac1[6];
1019 char mac2[6];
1020
1021 memcpy (mac1, pke_ptr + 23, 6);
1022 memcpy (mac2, pke_ptr + 29, 6);
1023
1024 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1025 (char *) data.salts_buf[0].salt_buf,
1026 mac1[0] & 0xff,
1027 mac1[1] & 0xff,
1028 mac1[2] & 0xff,
1029 mac1[3] & 0xff,
1030 mac1[4] & 0xff,
1031 mac1[5] & 0xff,
1032 mac2[0] & 0xff,
1033 mac2[1] & 0xff,
1034 mac2[2] & 0xff,
1035 mac2[3] & 0xff,
1036 mac2[4] & 0xff,
1037 mac2[5] & 0xff);
1038 }
1039 else if (data.hash_mode == 5200)
1040 {
1041 log_info ("Hash.Target....: File (%s)", data.hashfile);
1042 }
1043 else if (data.hash_mode == 9000)
1044 {
1045 log_info ("Hash.Target....: File (%s)", data.hashfile);
1046 }
1047 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1048 {
1049 log_info ("Hash.Target....: File (%s)", data.hashfile);
1050 }
1051 else
1052 {
1053 char out_buf[4096];
1054
1055 ascii_digest (out_buf, 0, 0);
1056
1057 // limit length
1058 if (strlen (out_buf) > 40)
1059 {
1060 out_buf[41] = '.';
1061 out_buf[42] = '.';
1062 out_buf[43] = '.';
1063 out_buf[44] = 0;
1064 }
1065
1066 log_info ("Hash.Target....: %s", out_buf);
1067 }
1068 }
1069 else
1070 {
1071 if (data.hash_mode == 3000)
1072 {
1073 char out_buf1[4096];
1074 char out_buf2[4096];
1075
1076 ascii_digest (out_buf1, 0, 0);
1077 ascii_digest (out_buf2, 0, 1);
1078
1079 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1080 }
1081 else
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 }
1086
1087 log_info ("Hash.Type......: %s", hash_type);
1088
1089 /**
1090 * speed new
1091 */
1092
1093 u64 speed_cnt[DEVICES_MAX];
1094 float speed_ms[DEVICES_MAX];
1095
1096 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1097 {
1098 hc_device_param_t *device_param = &data.devices_param[device_id];
1099
1100 if (device_param->skipped) continue;
1101
1102 // we need to clear values (set to 0) because in case the device does
1103 // not get new candidates it idles around but speed display would
1104 // show it as working.
1105 // if we instantly set it to 0 after reading it happens that the
1106 // speed can be shown as zero if the users refreshes too fast.
1107 // therefore, we add a timestamp when a stat was recorded and if its
1108 // too old we will not use it
1109
1110 speed_cnt[device_id] = 0;
1111 speed_ms[device_id] = 0;
1112
1113 for (int i = 0; i < SPEED_CACHE; i++)
1114 {
1115 float rec_ms;
1116
1117 hc_timer_get (device_param->speed_rec[i], rec_ms);
1118
1119 if (rec_ms > SPEED_MAXAGE) continue;
1120
1121 speed_cnt[device_id] += device_param->speed_cnt[i];
1122 speed_ms[device_id] += device_param->speed_ms[i];
1123 }
1124
1125 speed_cnt[device_id] /= SPEED_CACHE;
1126 speed_ms[device_id] /= SPEED_CACHE;
1127 }
1128
1129 float hashes_all_ms = 0;
1130
1131 float hashes_dev_ms[DEVICES_MAX];
1132
1133 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1134 {
1135 hc_device_param_t *device_param = &data.devices_param[device_id];
1136
1137 if (device_param->skipped) continue;
1138
1139 hashes_dev_ms[device_id] = 0;
1140
1141 if (speed_ms[device_id])
1142 {
1143 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1144
1145 hashes_all_ms += hashes_dev_ms[device_id];
1146 }
1147 }
1148
1149 /**
1150 * timers
1151 */
1152
1153 float ms_running = 0;
1154
1155 hc_timer_get (data.timer_running, ms_running);
1156
1157 float ms_paused = data.ms_paused;
1158
1159 if (data.devices_status == STATUS_PAUSED)
1160 {
1161 float ms_paused_tmp = 0;
1162
1163 hc_timer_get (data.timer_paused, ms_paused_tmp);
1164
1165 ms_paused += ms_paused_tmp;
1166 }
1167
1168 #ifdef WIN
1169
1170 __time64_t sec_run = ms_running / 1000;
1171
1172 #else
1173
1174 time_t sec_run = ms_running / 1000;
1175
1176 #endif
1177
1178 if (sec_run)
1179 {
1180 char display_run[32];
1181
1182 struct tm tm_run;
1183
1184 struct tm *tmp;
1185
1186 #ifdef WIN
1187
1188 tmp = _gmtime64 (&sec_run);
1189
1190 #else
1191
1192 tmp = gmtime (&sec_run);
1193
1194 #endif
1195
1196 if (tmp != NULL)
1197 {
1198 memcpy (&tm_run, tmp, sizeof (struct tm));
1199
1200 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1201
1202 char *start = ctime (&data.proc_start);
1203
1204 size_t start_len = strlen (start);
1205
1206 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1207 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1208
1209 log_info ("Time.Started...: %s (%s)", start, display_run);
1210 }
1211 }
1212 else
1213 {
1214 log_info ("Time.Started...: 0 secs");
1215 }
1216
1217 /**
1218 * counters
1219 */
1220
1221 uint salts_left = data.salts_cnt - data.salts_done;
1222
1223 if (salts_left == 0) salts_left = 1;
1224
1225 u64 progress_total = data.words_cnt * salts_left;
1226
1227 u64 all_done = 0;
1228 u64 all_rejected = 0;
1229 u64 all_restored = 0;
1230
1231 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1232 {
1233 if (salts_left > 1)
1234 {
1235 // otherwise the final cracked status shows 0/XXX progress
1236
1237 if (data.salts_shown[salt_pos] == 1) continue;
1238 }
1239
1240 all_done += data.words_progress_done[salt_pos];
1241 all_rejected += data.words_progress_rejected[salt_pos];
1242 all_restored += data.words_progress_restored[salt_pos];
1243 }
1244
1245 u64 progress_cur = all_restored + all_done + all_rejected;
1246 u64 progress_end = progress_total;
1247
1248 u64 progress_skip = 0;
1249
1250 if (data.skip)
1251 {
1252 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1253
1254 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1255 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1256 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1257 }
1258
1259 if (data.limit)
1260 {
1261 progress_end = MIN (data.limit, data.words_base) * salts_left;
1262
1263 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1264 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1265 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1266 }
1267
1268 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1269 u64 progress_end_relative_skip = progress_end - progress_skip;
1270
1271 float speed_ms_real = ms_running - ms_paused;
1272 u64 speed_plains_real = all_done;
1273
1274 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1275 {
1276 if (data.devices_status != STATUS_CRACKED)
1277 {
1278 u64 words_per_ms = 0;
1279
1280 if (speed_plains_real && speed_ms_real)
1281 {
1282 words_per_ms = speed_plains_real / speed_ms_real;
1283 }
1284
1285 #ifdef WIN
1286 __time64_t sec_etc = 0;
1287 #else
1288 time_t sec_etc = 0;
1289 #endif
1290
1291 if (words_per_ms)
1292 {
1293 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1294
1295 u64 ms_left = progress_left_relative_skip / words_per_ms;
1296
1297 sec_etc = ms_left / 1000;
1298 }
1299
1300 if (sec_etc == 0)
1301 {
1302 log_info ("Time.Estimated.: 0 secs");
1303 }
1304 else if ((u64) sec_etc > ETC_MAX)
1305 {
1306 log_info ("Time.Estimated.: > 10 Years");
1307 }
1308 else
1309 {
1310 char display_etc[32];
1311
1312 struct tm tm_etc;
1313
1314 struct tm *tmp;
1315
1316 #ifdef WIN
1317
1318 tmp = _gmtime64 (&sec_etc);
1319
1320 #else
1321
1322 tmp = gmtime (&sec_etc);
1323
1324 #endif
1325
1326 if (tmp != NULL)
1327 {
1328 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1329
1330 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1331
1332 time_t now;
1333
1334 time (&now);
1335
1336 now += sec_etc;
1337
1338 char *etc = ctime (&now);
1339
1340 size_t etc_len = strlen (etc);
1341
1342 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1343 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1344
1345 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1346 }
1347 }
1348 }
1349 }
1350
1351 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1352 {
1353 hc_device_param_t *device_param = &data.devices_param[device_id];
1354
1355 if (device_param->skipped) continue;
1356
1357 char display_dev_cur[16] = { 0 };
1358
1359 strncpy (display_dev_cur, "0.00", 4);
1360
1361 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1362
1363 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1364 }
1365
1366 char display_all_cur[16] = { 0 };
1367
1368 strncpy (display_all_cur, "0.00", 4);
1369
1370 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1371
1372 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1373
1374 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1375 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1376
1377 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);
1378
1379 // crack-per-time
1380
1381 if (data.digests_cnt > 100)
1382 {
1383 time_t now = time (NULL);
1384
1385 int cpt_cur_min = 0;
1386 int cpt_cur_hour = 0;
1387 int cpt_cur_day = 0;
1388
1389 for (int i = 0; i < CPT_BUF; i++)
1390 {
1391 const uint cracked = data.cpt_buf[i].cracked;
1392 const time_t timestamp = data.cpt_buf[i].timestamp;
1393
1394 if ((timestamp + 60) > now)
1395 {
1396 cpt_cur_min += cracked;
1397 }
1398
1399 if ((timestamp + 3600) > now)
1400 {
1401 cpt_cur_hour += cracked;
1402 }
1403
1404 if ((timestamp + 86400) > now)
1405 {
1406 cpt_cur_day += cracked;
1407 }
1408 }
1409
1410 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1411 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1412 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1413
1414 if ((data.cpt_start + 86400) < now)
1415 {
1416 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1417 cpt_cur_min,
1418 cpt_cur_hour,
1419 cpt_cur_day,
1420 cpt_avg_min,
1421 cpt_avg_hour,
1422 cpt_avg_day);
1423 }
1424 else if ((data.cpt_start + 3600) < now)
1425 {
1426 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1427 cpt_cur_min,
1428 cpt_cur_hour,
1429 cpt_avg_min,
1430 cpt_avg_hour,
1431 cpt_avg_day);
1432 }
1433 else if ((data.cpt_start + 60) < now)
1434 {
1435 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1436 cpt_cur_min,
1437 cpt_avg_min,
1438 cpt_avg_hour,
1439 cpt_avg_day);
1440 }
1441 else
1442 {
1443 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1444 cpt_avg_min,
1445 cpt_avg_hour,
1446 cpt_avg_day);
1447 }
1448 }
1449
1450 // Restore point
1451
1452 u64 restore_point = get_lowest_words_done ();
1453
1454 u64 restore_total = data.words_base;
1455
1456 float percent_restore = 0;
1457
1458 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1459
1460 if (progress_end_relative_skip)
1461 {
1462 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1463 {
1464 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1465 float percent_rejected = 0.0;
1466
1467 if (progress_cur)
1468 {
1469 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1470 }
1471
1472 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);
1473 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1474
1475 if (data.restore_disable == 0)
1476 {
1477 if (percent_finished != 1)
1478 {
1479 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1480 }
1481 }
1482 }
1483 }
1484 else
1485 {
1486 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1487 {
1488 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1489 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1490
1491 if (data.restore_disable == 0)
1492 {
1493 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1494 }
1495 }
1496 else
1497 {
1498 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1499 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1500
1501 // --restore not allowed if stdin is used -- really? why?
1502
1503 //if (data.restore_disable == 0)
1504 //{
1505 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1506 //}
1507 }
1508 }
1509
1510 if (data.gpu_temp_disable == 0)
1511 {
1512 hc_thread_mutex_lock (mux_adl);
1513
1514 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1515 {
1516 hc_device_param_t *device_param = &data.devices_param[device_id];
1517
1518 if (device_param->skipped) continue;
1519
1520 #define HM_STR_BUF_SIZE 255
1521
1522 if (data.hm_device[device_id].fan_supported == 1)
1523 {
1524 char utilization[HM_STR_BUF_SIZE];
1525 char temperature[HM_STR_BUF_SIZE];
1526 char fanspeed[HM_STR_BUF_SIZE];
1527
1528 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1529 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1530
1531 if (device_param->vendor_id == VENDOR_ID_AMD)
1532 {
1533 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1534 }
1535 else if (device_param->vendor_id == VENDOR_ID_NV)
1536 {
1537 #ifdef LINUX
1538 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1539 #else
1540 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1541 #endif
1542 }
1543
1544 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1545 }
1546 else
1547 {
1548 char utilization[HM_STR_BUF_SIZE];
1549 char temperature[HM_STR_BUF_SIZE];
1550
1551 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1552 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1553
1554 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1555 }
1556 }
1557
1558 hc_thread_mutex_unlock (mux_adl);
1559 }
1560 }
1561
1562 static void status_benchmark ()
1563 {
1564 if (data.devices_status == STATUS_INIT) return;
1565 if (data.devices_status == STATUS_STARTING) return;
1566
1567 if (data.words_cnt == 0) return;
1568
1569 u64 speed_cnt[DEVICES_MAX];
1570 float speed_ms[DEVICES_MAX];
1571
1572 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1573 {
1574 hc_device_param_t *device_param = &data.devices_param[device_id];
1575
1576 if (device_param->skipped) continue;
1577
1578 speed_cnt[device_id] = 0;
1579 speed_ms[device_id] = 0;
1580
1581 for (int i = 0; i < SPEED_CACHE; i++)
1582 {
1583 speed_cnt[device_id] += device_param->speed_cnt[i];
1584 speed_ms[device_id] += device_param->speed_ms[i];
1585 }
1586
1587 speed_cnt[device_id] /= SPEED_CACHE;
1588 speed_ms[device_id] /= SPEED_CACHE;
1589 }
1590
1591 float hashes_all_ms = 0;
1592
1593 float hashes_dev_ms[DEVICES_MAX];
1594
1595 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1596 {
1597 hc_device_param_t *device_param = &data.devices_param[device_id];
1598
1599 if (device_param->skipped) continue;
1600
1601 hashes_dev_ms[device_id] = 0;
1602
1603 if (speed_ms[device_id])
1604 {
1605 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1606
1607 hashes_all_ms += hashes_dev_ms[device_id];
1608 }
1609 }
1610
1611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1612 {
1613 hc_device_param_t *device_param = &data.devices_param[device_id];
1614
1615 if (device_param->skipped) continue;
1616
1617 char display_dev_cur[16] = { 0 };
1618
1619 strncpy (display_dev_cur, "0.00", 4);
1620
1621 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1622
1623 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1624 }
1625
1626 char display_all_cur[16] = { 0 };
1627
1628 strncpy (display_all_cur, "0.00", 4);
1629
1630 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1631
1632 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1633 }
1634
1635 /**
1636 * oclHashcat -only- functions
1637 */
1638
1639 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1640 {
1641 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1642 {
1643 if (attack_kern == ATTACK_KERN_STRAIGHT)
1644 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1645 else if (attack_kern == ATTACK_KERN_COMBI)
1646 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1647 else if (attack_kern == ATTACK_KERN_BF)
1648 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1649 }
1650 else
1651 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1652 }
1653
1654 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)
1655 {
1656 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1657 {
1658 if (attack_kern == ATTACK_KERN_STRAIGHT)
1659 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1660 else if (attack_kern == ATTACK_KERN_COMBI)
1661 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1662 else if (attack_kern == ATTACK_KERN_BF)
1663 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1664 }
1665 else
1666 {
1667 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1668 }
1669 }
1670
1671 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1672 {
1673 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1674 {
1675 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1676 }
1677 else
1678 {
1679 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1680 }
1681 }
1682
1683 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)
1684 {
1685 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1686 {
1687 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1688 }
1689 else
1690 {
1691 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1692 }
1693 }
1694
1695 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1696 {
1697 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1698 }
1699
1700 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1701 {
1702 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1703 }
1704
1705 static uint convert_from_hex (char *line_buf, const uint line_len)
1706 {
1707 if (line_len & 1) return (line_len); // not in hex
1708
1709 if (data.hex_wordlist == 1)
1710 {
1711 uint i;
1712 uint j;
1713
1714 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1715 {
1716 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1717 }
1718
1719 memset (line_buf + i, 0, line_len - i);
1720
1721 return (i);
1722 }
1723 else if (line_len >= 6) // $HEX[] = 6
1724 {
1725 if (line_buf[0] != '$') return (line_len);
1726 if (line_buf[1] != 'H') return (line_len);
1727 if (line_buf[2] != 'E') return (line_len);
1728 if (line_buf[3] != 'X') return (line_len);
1729 if (line_buf[4] != '[') return (line_len);
1730 if (line_buf[line_len - 1] != ']') return (line_len);
1731
1732 uint i;
1733 uint j;
1734
1735 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1736 {
1737 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1738 }
1739
1740 memset (line_buf + i, 0, line_len - i);
1741
1742 return (i);
1743 }
1744
1745 return (line_len);
1746 }
1747
1748 static uint count_lines (FILE *fd)
1749 {
1750 uint cnt = 0;
1751
1752 char *buf = (char *) mymalloc (BUFSIZ + 1);
1753
1754 size_t nread_tmp = 0;
1755
1756 char *ptr = buf;
1757
1758 while (!feof (fd))
1759 {
1760 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1761 nread_tmp = nread;
1762
1763 if (nread < 1) continue;
1764
1765 ptr = buf;
1766
1767 do
1768 {
1769 if (*ptr++ == '\n') cnt++;
1770
1771 } while (nread--);
1772 }
1773
1774 // special case (if last line did not contain a newline char ... at the very end of the file)
1775
1776 if (nread_tmp > 3)
1777 {
1778 ptr -= 2;
1779
1780 if (*ptr != '\n')
1781 {
1782 ptr--;
1783
1784 if (*ptr != '\n') // needed ? different on windows systems?
1785 {
1786 cnt++;
1787 }
1788 }
1789 }
1790
1791 myfree (buf);
1792
1793 return cnt;
1794 }
1795
1796 static void clear_prompt ()
1797 {
1798 fputc ('\r', stdout);
1799
1800 for (size_t i = 0; i < strlen (PROMPT); i++)
1801 {
1802 fputc (' ', stdout);
1803 }
1804
1805 fputc ('\r', stdout);
1806
1807 fflush (stdout);
1808 }
1809
1810 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1811 {
1812 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1813 }
1814
1815 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1816 {
1817 char *outfile = data.outfile;
1818 uint quiet = data.quiet;
1819 FILE *pot_fp = data.pot_fp;
1820 uint loopback = data.loopback;
1821 uint debug_mode = data.debug_mode;
1822 char *debug_file = data.debug_file;
1823
1824 char debug_rule_buf[BLOCK_SIZE];
1825 int debug_rule_len = 0; // -1 error
1826 uint debug_plain_len = 0;
1827
1828 u8 debug_plain_ptr[BLOCK_SIZE];
1829
1830 // hash
1831
1832 char out_buf[4096] = { 0 };
1833
1834 ascii_digest (out_buf, salt_pos, digest_pos);
1835
1836 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1837
1838 // plain
1839
1840 plain_t plain;
1841
1842 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1843
1844 uint gidvid = plain.gidvid;
1845 uint il_pos = plain.il_pos;
1846
1847 u64 crackpos = device_param->words_off;
1848
1849 uint plain_buf[16];
1850
1851 u8 *plain_ptr = (u8 *) plain_buf;
1852 unsigned int plain_len = 0;
1853
1854 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1855 {
1856 u64 gidd = gidvid;
1857 u64 gidm = 0;
1858
1859 pw_t pw;
1860
1861 gidd_to_pw_t (device_param, gidd, &pw);
1862
1863 for (int i = 0, j = gidm; i < 16; i++, j++)
1864 {
1865 plain_buf[i] = pw.hi1[0][j];
1866 }
1867
1868 plain_len = pw.pw_len;
1869
1870 const uint off = device_param->innerloop_pos + il_pos;
1871
1872 if (debug_mode > 0)
1873 {
1874 debug_rule_len = 0;
1875
1876 // save rule
1877 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1878 {
1879 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1880
1881 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1882 }
1883
1884 // save plain
1885 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1886 {
1887 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1888
1889 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1890
1891 debug_plain_len = plain_len;
1892 }
1893 }
1894
1895 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1896
1897 crackpos += gidvid;
1898 crackpos *= data.kernel_rules_cnt;
1899 crackpos += device_param->innerloop_pos + il_pos;
1900
1901 if (plain_len > data.pw_max) plain_len = data.pw_max;
1902 }
1903 else if (data.attack_mode == ATTACK_MODE_COMBI)
1904 {
1905 u64 gidd = gidvid;
1906 u64 gidm = 0;
1907
1908 pw_t pw;
1909
1910 gidd_to_pw_t (device_param, gidd, &pw);
1911
1912 for (int i = 0, j = gidm; i < 16; i++, j++)
1913 {
1914 plain_buf[i] = pw.hi1[0][j];
1915 }
1916
1917 plain_len = pw.pw_len;
1918
1919 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1920 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1921
1922 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1923 {
1924 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1925 }
1926 else
1927 {
1928 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1929
1930 memcpy (plain_ptr, comb_buf, comb_len);
1931 }
1932
1933 plain_len += comb_len;
1934
1935 crackpos += gidvid;
1936 crackpos *= data.combs_cnt;
1937 crackpos += device_param->innerloop_pos + il_pos;
1938
1939 if (data.pw_max != PW_DICTMAX1)
1940 {
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_BF)
1945 {
1946 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1947 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1948
1949 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1950 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1951
1952 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1953 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1954
1955 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1956 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1957
1958 plain_len = data.css_cnt;
1959
1960 crackpos += gidvid;
1961 crackpos *= data.bfs_cnt;
1962 crackpos += device_param->innerloop_pos + il_pos;
1963 }
1964 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1965 {
1966 u64 gidd = gidvid;
1967 u64 gidm = 0;
1968
1969 pw_t pw;
1970
1971 gidd_to_pw_t (device_param, gidd, &pw);
1972
1973 for (int i = 0, j = gidm; i < 16; i++, j++)
1974 {
1975 plain_buf[i] = pw.hi1[0][j];
1976 }
1977
1978 plain_len = pw.pw_len;
1979
1980 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1981
1982 uint start = 0;
1983 uint stop = device_param->kernel_params_mp_buf32[4];
1984
1985 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1986
1987 plain_len += start + stop;
1988
1989 crackpos += gidvid;
1990 crackpos *= data.combs_cnt;
1991 crackpos += device_param->innerloop_pos + il_pos;
1992
1993 if (data.pw_max != PW_DICTMAX1)
1994 {
1995 if (plain_len > data.pw_max) plain_len = data.pw_max;
1996 }
1997 }
1998 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1999 {
2000 u64 gidd = gidvid;
2001 u64 gidm = 0;
2002
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidd, &pw);
2006
2007 for (int i = 0, j = gidm; i < 16; i++, j++)
2008 {
2009 plain_buf[i] = pw.hi1[0][j];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 memmove (plain_ptr + stop, plain_ptr, plain_len);
2020
2021 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2022
2023 plain_len += start + stop;
2024
2025 crackpos += gidvid;
2026 crackpos *= data.combs_cnt;
2027 crackpos += device_param->innerloop_pos + il_pos;
2028
2029 if (data.pw_max != PW_DICTMAX1)
2030 {
2031 if (plain_len > data.pw_max) plain_len = data.pw_max;
2032 }
2033 }
2034
2035 if (data.attack_mode == ATTACK_MODE_BF)
2036 {
2037 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2038 {
2039 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2040 {
2041 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2042 {
2043 plain_len = plain_len - data.salts_buf[0].salt_len;
2044 }
2045 }
2046
2047 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2048 {
2049 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2050 {
2051 plain_ptr[j] = plain_ptr[i];
2052 }
2053
2054 plain_len = plain_len / 2;
2055 }
2056 }
2057 }
2058
2059 // if enabled, update also the potfile
2060
2061 if (pot_fp)
2062 {
2063 fprintf (pot_fp, "%s:", out_buf);
2064
2065 format_plain (pot_fp, plain_ptr, plain_len, 1);
2066
2067 fputc ('\n', pot_fp);
2068
2069 fflush (pot_fp);
2070 }
2071
2072 // outfile
2073
2074 FILE *out_fp = NULL;
2075
2076 if (outfile != NULL)
2077 {
2078 if ((out_fp = fopen (outfile, "ab")) == NULL)
2079 {
2080 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2081
2082 out_fp = stdout;
2083 }
2084 }
2085 else
2086 {
2087 out_fp = stdout;
2088
2089 if (quiet == 0) clear_prompt ();
2090 }
2091
2092 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2093
2094 if (outfile != NULL)
2095 {
2096 if (out_fp != stdout)
2097 {
2098 fclose (out_fp);
2099 }
2100 }
2101 else
2102 {
2103 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2104 {
2105 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2106 {
2107 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2108 if (quiet == 0) fflush (stdout);
2109 }
2110 }
2111 }
2112
2113 // loopback
2114
2115 if (loopback)
2116 {
2117 char *loopback_file = data.loopback_file;
2118
2119 FILE *fb_fp = NULL;
2120
2121 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2122 {
2123 format_plain (fb_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', fb_fp);
2126
2127 fclose (fb_fp);
2128 }
2129 }
2130
2131 // (rule) debug mode
2132
2133 // the next check implies that:
2134 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2135 // - debug_mode > 0
2136
2137 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2138 {
2139 if (debug_rule_len < 0) debug_rule_len = 0;
2140
2141 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2142
2143 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2144
2145 if ((quiet == 0) && (debug_file == NULL))
2146 {
2147 fprintf (stdout, "%s", PROMPT);
2148 fflush (stdout);
2149 }
2150 }
2151 }
2152
2153 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2154 {
2155 salt_t *salt_buf = &data.salts_buf[salt_pos];
2156
2157 int found = 0;
2158
2159 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2160
2161 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2162
2163 if (found == 1)
2164 {
2165 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2166
2167 log_info_nn ("");
2168
2169 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);
2170
2171 uint cpt_cracked = 0;
2172
2173 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2174 {
2175 uint idx = salt_buf->digests_offset + digest_pos;
2176
2177 if (data.digests_shown_tmp[idx] == 0) continue;
2178
2179 if (data.digests_shown[idx] == 1) continue;
2180
2181 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2182 {
2183 data.digests_shown[idx] = 1;
2184
2185 data.digests_done++;
2186
2187 cpt_cracked++;
2188
2189 salt_buf->digests_done++;
2190
2191 if (salt_buf->digests_done == salt_buf->digests_cnt)
2192 {
2193 data.salts_shown[salt_pos] = 1;
2194
2195 data.salts_done++;
2196 }
2197 }
2198
2199 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2200
2201 check_hash (device_param, salt_pos, digest_pos);
2202 }
2203
2204 if (cpt_cracked > 0)
2205 {
2206 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2207 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2208
2209 data.cpt_pos++;
2210
2211 data.cpt_total += cpt_cracked;
2212
2213 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2214 }
2215
2216 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2217 {
2218 // we need to reset cracked state on the device
2219 // otherwise host thinks again and again the hash was cracked
2220 // and returns invalid password each time
2221
2222 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2223
2224 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);
2225 }
2226
2227 memset (device_param->result, 0, device_param->size_results);
2228
2229 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2230 }
2231 }
2232
2233 static void save_hash ()
2234 {
2235 char *hashfile = data.hashfile;
2236
2237 char new_hashfile[256] = { 0 };
2238 char old_hashfile[256] = { 0 };
2239
2240 snprintf (new_hashfile, 255, "%s.new", hashfile);
2241 snprintf (old_hashfile, 255, "%s.old", hashfile);
2242
2243 unlink (new_hashfile);
2244
2245 char separator = data.separator;
2246
2247 FILE *fp = fopen (new_hashfile, "wb");
2248
2249 if (fp == NULL)
2250 {
2251 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2252
2253 exit (-1);
2254 }
2255
2256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2257 {
2258 if (data.salts_shown[salt_pos] == 1) continue;
2259
2260 salt_t *salt_buf = &data.salts_buf[salt_pos];
2261
2262 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2263 {
2264 uint idx = salt_buf->digests_offset + digest_pos;
2265
2266 if (data.digests_shown[idx] == 1) continue;
2267
2268 if (data.hash_mode != 2500)
2269 {
2270 char out_buf[4096] = { 0 };
2271
2272 if (data.username == 1)
2273 {
2274 user_t *user = data.hash_info[idx]->user;
2275
2276 uint i;
2277
2278 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2279
2280 fputc (separator, fp);
2281 }
2282
2283 ascii_digest (out_buf, salt_pos, digest_pos);
2284
2285 fputs (out_buf, fp);
2286
2287 log_out (fp, "");
2288 }
2289 else
2290 {
2291 hccap_t hccap;
2292
2293 to_hccap_t (&hccap, salt_pos, digest_pos);
2294
2295 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2296 }
2297 }
2298 }
2299
2300 fflush (fp);
2301
2302 fclose (fp);
2303
2304 unlink (old_hashfile);
2305
2306 if (rename (hashfile, old_hashfile) != 0)
2307 {
2308 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2309
2310 exit (-1);
2311 }
2312
2313 unlink (hashfile);
2314
2315 if (rename (new_hashfile, hashfile) != 0)
2316 {
2317 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2318
2319 exit (-1);
2320 }
2321
2322 unlink (old_hashfile);
2323 }
2324
2325 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2326 {
2327 // function called only in case kernel_blocks_all > words_left)
2328
2329 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2330
2331 kernel_blocks_div += kernel_blocks_div / 100;
2332
2333 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2334
2335 while (kernel_blocks_new < total_left)
2336 {
2337 kernel_blocks_div += kernel_blocks_div / 100;
2338
2339 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2340 }
2341
2342 if (data.quiet == 0)
2343 {
2344 clear_prompt ();
2345
2346 log_info ("");
2347
2348 log_info ("INFO: approaching final keyspace, workload adjusted");
2349
2350 log_info ("");
2351
2352 fprintf (stdout, "%s", PROMPT);
2353
2354 fflush (stdout);
2355 }
2356
2357 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2358
2359 return kernel_blocks_div;
2360 }
2361
2362 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2363 {
2364 uint num_elements = num;
2365
2366 device_param->kernel_params_buf32[30] = data.combs_mode;
2367 device_param->kernel_params_buf32[31] = num;
2368
2369 uint kernel_threads = device_param->kernel_threads;
2370
2371 while (num_elements % kernel_threads) num_elements++;
2372
2373 cl_kernel kernel = NULL;
2374
2375 switch (kern_run)
2376 {
2377 case KERN_RUN_1: kernel = device_param->kernel1; break;
2378 case KERN_RUN_12: kernel = device_param->kernel12; break;
2379 case KERN_RUN_2: kernel = device_param->kernel2; break;
2380 case KERN_RUN_23: kernel = device_param->kernel23; break;
2381 case KERN_RUN_3: kernel = device_param->kernel3; break;
2382 }
2383
2384 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2385 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2386 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2387 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2388 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2389 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2390 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2391 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2392 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2393 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2394 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2395
2396 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2397 {
2398 const size_t global_work_size[3] = { num_elements, 32, 1 };
2399 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2400
2401 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2402 }
2403 else
2404 {
2405 const size_t global_work_size[3] = { num_elements, 1, 1 };
2406 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2407
2408 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2409 }
2410
2411 hc_clFlush (device_param->command_queue);
2412
2413 hc_clFinish (device_param->command_queue);
2414 }
2415
2416 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2417 {
2418 uint num_elements = num;
2419
2420 switch (kern_run)
2421 {
2422 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2423 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2424 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2425 }
2426
2427 // causes problems with special threads like in bcrypt
2428 // const uint kernel_threads = device_param->kernel_threads;
2429
2430 const uint kernel_threads = KERNEL_THREADS;
2431
2432 while (num_elements % kernel_threads) num_elements++;
2433
2434 cl_kernel kernel = NULL;
2435
2436 switch (kern_run)
2437 {
2438 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2439 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2440 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2441 }
2442
2443 switch (kern_run)
2444 {
2445 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2446 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2447 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2448 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2449 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2450 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2451 break;
2452 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2453 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2454 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2455 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2456 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2457 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2458 break;
2459 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2460 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2461 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2462 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2463 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2464 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2465 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2466 break;
2467 }
2468
2469 const size_t global_work_size[3] = { num_elements, 1, 1 };
2470 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2473
2474 hc_clFlush (device_param->command_queue);
2475
2476 hc_clFinish (device_param->command_queue);
2477 }
2478
2479 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2480 {
2481 uint num_elements = num;
2482
2483 uint kernel_threads = device_param->kernel_threads;
2484
2485 while (num_elements % kernel_threads) num_elements++;
2486
2487 cl_kernel kernel = device_param->kernel_tb;
2488
2489 const size_t global_work_size[3] = { num_elements, 1, 1 };
2490 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2491
2492 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2493
2494 hc_clFlush (device_param->command_queue);
2495
2496 hc_clFinish (device_param->command_queue);
2497 }
2498
2499 static void run_kernel_tm (hc_device_param_t *device_param)
2500 {
2501 const uint num_elements = 1024; // fixed
2502
2503 const uint kernel_threads = 32;
2504
2505 cl_kernel kernel = device_param->kernel_tm;
2506
2507 const size_t global_work_size[3] = { num_elements, 1, 1 };
2508 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2509
2510 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2511
2512 hc_clFlush (device_param->command_queue);
2513
2514 hc_clFinish (device_param->command_queue);
2515 }
2516
2517 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2518 {
2519 uint num_elements = num;
2520
2521 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2522 device_param->kernel_params_amp_buf32[6] = num_elements;
2523
2524 // causes problems with special threads like in bcrypt
2525 // const uint kernel_threads = device_param->kernel_threads;
2526
2527 const uint kernel_threads = KERNEL_THREADS;
2528
2529 while (num_elements % kernel_threads) num_elements++;
2530
2531 cl_kernel kernel = device_param->kernel_amp;
2532
2533 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2534 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2535
2536 const size_t global_work_size[3] = { num_elements, 1, 1 };
2537 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2538
2539 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2540
2541 hc_clFlush (device_param->command_queue);
2542
2543 hc_clFinish (device_param->command_queue);
2544 }
2545
2546 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2547 {
2548 if (device_param->vendor_id == VENDOR_ID_AMD)
2549 {
2550 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2551
2552 const cl_uchar zero = 0;
2553
2554 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2555 }
2556 else
2557 {
2558 // NOTE: clEnqueueFillBuffer () always fails with -59
2559 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2560 // How's that possible, OpenCL 1.2 support is advertised??
2561 // We need to workaround...
2562
2563 #define FILLSZ 0x100000
2564
2565 char *tmp = (char *) mymalloc (FILLSZ);
2566
2567 memset (tmp, 0, FILLSZ);
2568
2569 for (uint i = 0; i < size; i += FILLSZ)
2570 {
2571 const int left = size - i;
2572
2573 const int fillsz = MIN (FILLSZ, left);
2574
2575 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2576 }
2577
2578 myfree (tmp);
2579 }
2580 }
2581
2582 static int run_rule_engine (const int rule_len, const char *rule_buf)
2583 {
2584 if (rule_len == 0)
2585 {
2586 return 0;
2587 }
2588 else if (rule_len == 1)
2589 {
2590 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2591 }
2592
2593 return 1;
2594 }
2595
2596 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2597 {
2598 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2599 {
2600 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);
2601 }
2602 else if (data.attack_kern == ATTACK_KERN_COMBI)
2603 {
2604 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);
2605 }
2606 else if (data.attack_kern == ATTACK_KERN_BF)
2607 {
2608 const u64 off = device_param->words_off;
2609
2610 device_param->kernel_params_mp_l_buf64[3] = off;
2611
2612 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2613 }
2614 }
2615
2616 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2617 {
2618 const uint kernel_loops = data.kernel_loops;
2619
2620 // init speed timer
2621
2622 uint speed_pos = device_param->speed_pos;
2623
2624 #ifdef _POSIX
2625 if (device_param->timer_speed.tv_sec == 0)
2626 {
2627 hc_timer_set (&device_param->timer_speed);
2628 }
2629 #endif
2630
2631 #ifdef _WIN
2632 if (device_param->timer_speed.QuadPart == 0)
2633 {
2634 hc_timer_set (&device_param->timer_speed);
2635 }
2636 #endif
2637
2638 // find higest password length, this is for optimization stuff
2639
2640 uint highest_pw_len = 0;
2641
2642 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2643 {
2644 }
2645 else if (data.attack_kern == ATTACK_KERN_COMBI)
2646 {
2647 }
2648 else if (data.attack_kern == ATTACK_KERN_BF)
2649 {
2650 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2651 + device_param->kernel_params_mp_l_buf32[5];
2652 }
2653
2654 // bitslice optimization stuff
2655
2656 if (data.attack_mode == ATTACK_MODE_BF)
2657 {
2658 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2659 {
2660 run_kernel_tb (device_param, pws_cnt);
2661 }
2662 }
2663
2664 // iteration type
2665
2666 uint innerloop_step = 0;
2667 uint innerloop_cnt = 0;
2668
2669 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2670 else innerloop_step = 1;
2671
2672 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2673 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2674 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2675
2676 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2677
2678 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2679 {
2680 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2681
2682 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2683
2684 if (data.devices_status == STATUS_CRACKED) break;
2685 if (data.devices_status == STATUS_ABORTED) break;
2686 if (data.devices_status == STATUS_QUIT) break;
2687 if (data.devices_status == STATUS_BYPASS) break;
2688
2689 if (data.salts_shown[salt_pos] == 1) continue;
2690
2691 salt_t *salt_buf = &data.salts_buf[salt_pos];
2692
2693 device_param->kernel_params_buf32[24] = salt_pos;
2694 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2695 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2696
2697 FILE *combs_fp = device_param->combs_fp;
2698
2699 if (data.attack_mode == ATTACK_MODE_COMBI)
2700 {
2701 rewind (combs_fp);
2702 }
2703
2704 // innerloops
2705
2706 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2707 {
2708 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2709
2710 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2711
2712 if (data.devices_status == STATUS_CRACKED) break;
2713 if (data.devices_status == STATUS_ABORTED) break;
2714 if (data.devices_status == STATUS_QUIT) break;
2715 if (data.devices_status == STATUS_BYPASS) break;
2716
2717 uint innerloop_left = innerloop_cnt - innerloop_pos;
2718
2719 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2720
2721 device_param->innerloop_pos = innerloop_pos;
2722 device_param->innerloop_left = innerloop_left;
2723
2724 device_param->kernel_params_buf32[27] = innerloop_left;
2725
2726 if (innerloop_left == 0) continue;
2727
2728 // initialize amplifiers
2729
2730 if (data.attack_mode == ATTACK_MODE_COMBI)
2731 {
2732 char line_buf[BUFSIZ];
2733
2734 uint i = 0;
2735
2736 while (i < innerloop_left)
2737 {
2738 if (feof (combs_fp)) break;
2739
2740 int line_len = fgetl (combs_fp, line_buf);
2741
2742 if (line_len >= PW_MAX1) continue;
2743
2744 line_len = convert_from_hex (line_buf, line_len);
2745
2746 char *line_buf_new = line_buf;
2747
2748 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2749 {
2750 char rule_buf_out[BLOCK_SIZE] = { 0 };
2751
2752 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2753
2754 if (rule_len_out < 0)
2755 {
2756 data.words_progress_rejected[salt_pos] += pw_cnt;
2757
2758 continue;
2759 }
2760
2761 line_len = rule_len_out;
2762
2763 line_buf_new = rule_buf_out;
2764 }
2765
2766 line_len = MIN (line_len, PW_DICTMAX);
2767
2768 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2769
2770 memcpy (ptr, line_buf_new, line_len);
2771
2772 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2773
2774 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2775 {
2776 uppercase (ptr, line_len);
2777 }
2778
2779 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2780 {
2781 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2782 {
2783 ptr[line_len] = 0x80;
2784 }
2785
2786 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2787 {
2788 ptr[line_len] = 0x01;
2789 }
2790 }
2791
2792 device_param->combs_buf[i].pw_len = line_len;
2793
2794 i++;
2795 }
2796
2797 for (uint j = i; j < innerloop_left; j++)
2798 {
2799 device_param->combs_buf[j].i[0] = 0;
2800 device_param->combs_buf[j].i[1] = 0;
2801 device_param->combs_buf[j].i[2] = 0;
2802 device_param->combs_buf[j].i[3] = 0;
2803 device_param->combs_buf[j].i[4] = 0;
2804 device_param->combs_buf[j].i[5] = 0;
2805 device_param->combs_buf[j].i[6] = 0;
2806 device_param->combs_buf[j].i[7] = 0;
2807
2808 device_param->combs_buf[j].pw_len = 0;
2809 }
2810
2811 innerloop_left = i;
2812 }
2813 else if (data.attack_mode == ATTACK_MODE_BF)
2814 {
2815 u64 off = innerloop_pos;
2816
2817 device_param->kernel_params_mp_r_buf64[3] = off;
2818
2819 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2820 }
2821 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2822 {
2823 u64 off = innerloop_pos;
2824
2825 device_param->kernel_params_mp_buf64[3] = off;
2826
2827 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2828 }
2829 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2830 {
2831 u64 off = innerloop_pos;
2832
2833 device_param->kernel_params_mp_buf64[3] = off;
2834
2835 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2836 }
2837
2838 // copy amplifiers
2839
2840 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2841 {
2842 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);
2843 }
2844 else if (data.attack_mode == ATTACK_MODE_COMBI)
2845 {
2846 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);
2847 }
2848 else if (data.attack_mode == ATTACK_MODE_BF)
2849 {
2850 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);
2851 }
2852 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2853 {
2854 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);
2855 }
2856 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2857 {
2858 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);
2859 }
2860
2861 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2862 {
2863 if (data.attack_mode == ATTACK_MODE_BF)
2864 {
2865 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2866 {
2867 const uint size_tm = 32 * sizeof (bs_word_t);
2868
2869 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2870
2871 run_kernel_tm (device_param);
2872
2873 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2874 }
2875 }
2876
2877 if (highest_pw_len < 16)
2878 {
2879 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2880 }
2881 else if (highest_pw_len < 32)
2882 {
2883 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2884 }
2885 else
2886 {
2887 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2888 }
2889 }
2890 else
2891 {
2892 run_kernel_amp (device_param, pws_cnt);
2893
2894 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2895
2896 if (data.opts_type & OPTS_TYPE_HOOK12)
2897 {
2898 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2899 }
2900
2901 uint iter = salt_buf->salt_iter;
2902
2903 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2904 {
2905 uint loop_left = iter - loop_pos;
2906
2907 loop_left = MIN (loop_left, kernel_loops);
2908
2909 device_param->kernel_params_buf32[25] = loop_pos;
2910 device_param->kernel_params_buf32[26] = loop_left;
2911
2912 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2913
2914 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2915
2916 if (data.devices_status == STATUS_CRACKED) break;
2917 if (data.devices_status == STATUS_ABORTED) break;
2918 if (data.devices_status == STATUS_QUIT) break;
2919 }
2920
2921 if (data.opts_type & OPTS_TYPE_HOOK23)
2922 {
2923 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2924
2925 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2926
2927 // do something with data
2928
2929 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2930 }
2931
2932 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2933 }
2934
2935 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2936
2937 if (data.devices_status == STATUS_CRACKED) break;
2938 if (data.devices_status == STATUS_ABORTED) break;
2939 if (data.devices_status == STATUS_QUIT) break;
2940
2941 /**
2942 * result
2943 */
2944
2945 hc_thread_mutex_lock (mux_display);
2946
2947 check_cracked (device_param, salt_pos);
2948
2949 hc_thread_mutex_unlock (mux_display);
2950
2951 /**
2952 * progress
2953 */
2954
2955 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2956
2957 hc_thread_mutex_lock (mux_counter);
2958
2959 data.words_progress_done[salt_pos] += perf_sum_all;
2960
2961 hc_thread_mutex_unlock (mux_counter);
2962
2963 /**
2964 * speed
2965 */
2966
2967 float speed_ms;
2968
2969 hc_timer_get (device_param->timer_speed, speed_ms);
2970
2971 hc_timer_set (&device_param->timer_speed);
2972
2973 hc_thread_mutex_lock (mux_display);
2974
2975 device_param->speed_cnt[speed_pos] = perf_sum_all;
2976
2977 device_param->speed_ms[speed_pos] = speed_ms;
2978
2979 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2980
2981 hc_thread_mutex_unlock (mux_display);
2982
2983 speed_pos++;
2984
2985 if (speed_pos == SPEED_CACHE)
2986 {
2987 speed_pos = 0;
2988 }
2989 }
2990 }
2991
2992 device_param->speed_pos = speed_pos;
2993 }
2994
2995 static void load_segment (wl_data_t *wl_data, FILE *fd)
2996 {
2997 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2998
2999 wl_data->pos = 0;
3000
3001 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3002
3003 wl_data->buf[wl_data->cnt] = 0;
3004
3005 if (wl_data->cnt == 0) return;
3006
3007 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3008
3009 while (!feof (fd))
3010 {
3011 if (wl_data->cnt == wl_data->avail)
3012 {
3013 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3014
3015 wl_data->avail += wl_data->incr;
3016 }
3017
3018 const int c = fgetc (fd);
3019
3020 if (c == EOF) break;
3021
3022 wl_data->buf[wl_data->cnt] = (char) c;
3023
3024 wl_data->cnt++;
3025
3026 if (c == '\n') break;
3027 }
3028
3029 // ensure stream ends with a newline
3030
3031 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3032 {
3033 wl_data->cnt++;
3034
3035 wl_data->buf[wl_data->cnt - 1] = '\n';
3036 }
3037
3038 return;
3039 }
3040
3041 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3042 {
3043 char *ptr = buf;
3044
3045 for (u32 i = 0; i < sz; i++, ptr++)
3046 {
3047 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3048
3049 if (i == 7)
3050 {
3051 *off = i;
3052 *len = i;
3053
3054 return;
3055 }
3056
3057 if (*ptr != '\n') continue;
3058
3059 *off = i + 1;
3060
3061 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3062
3063 *len = i;
3064
3065 return;
3066 }
3067
3068 *off = sz;
3069 *len = sz;
3070 }
3071
3072 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3073 {
3074 char *ptr = buf;
3075
3076 for (u32 i = 0; i < sz; i++, ptr++)
3077 {
3078 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3079
3080 if (*ptr != '\n') continue;
3081
3082 *off = i + 1;
3083
3084 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3085
3086 *len = i;
3087
3088 return;
3089 }
3090
3091 *off = sz;
3092 *len = sz;
3093 }
3094
3095 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3096 {
3097 char *ptr = buf;
3098
3099 for (u32 i = 0; i < sz; i++, ptr++)
3100 {
3101 if (*ptr != '\n') continue;
3102
3103 *off = i + 1;
3104
3105 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3106
3107 *len = i;
3108
3109 return;
3110 }
3111
3112 *off = sz;
3113 *len = sz;
3114 }
3115
3116 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3117 {
3118 while (wl_data->pos < wl_data->cnt)
3119 {
3120 uint off;
3121 uint len;
3122
3123 char *ptr = wl_data->buf + wl_data->pos;
3124
3125 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3126
3127 wl_data->pos += off;
3128
3129 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3130 {
3131 char rule_buf_out[BLOCK_SIZE] = { 0 };
3132
3133 int rule_len_out = -1;
3134
3135 if (len < BLOCK_SIZE)
3136 {
3137 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3138 }
3139
3140 if (rule_len_out < 0)
3141 {
3142 continue;
3143 }
3144
3145 if (rule_len_out > PW_MAX)
3146 {
3147 continue;
3148 }
3149 }
3150 else
3151 {
3152 if (len > PW_MAX)
3153 {
3154 continue;
3155 }
3156 }
3157
3158 *out_buf = ptr;
3159 *out_len = len;
3160
3161 return;
3162 }
3163
3164 if (feof (fd))
3165 {
3166 fprintf (stderr, "bug!!\n");
3167
3168 return;
3169 }
3170
3171 load_segment (wl_data, fd);
3172
3173 get_next_word (wl_data, fd, out_buf, out_len);
3174 }
3175
3176 #ifdef _POSIX
3177 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3178 #endif
3179
3180 #ifdef _WIN
3181 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3182 #endif
3183 {
3184 hc_signal (NULL);
3185
3186 dictstat_t d;
3187
3188 d.cnt = 0;
3189
3190 #ifdef _POSIX
3191 fstat (fileno (fd), &d.stat);
3192 #endif
3193
3194 #ifdef _WIN
3195 _fstat64 (fileno (fd), &d.stat);
3196 #endif
3197
3198 d.stat.st_mode = 0;
3199 d.stat.st_nlink = 0;
3200 d.stat.st_uid = 0;
3201 d.stat.st_gid = 0;
3202 d.stat.st_rdev = 0;
3203 d.stat.st_atime = 0;
3204
3205 #ifdef _POSIX
3206 d.stat.st_blksize = 0;
3207 d.stat.st_blocks = 0;
3208 #endif
3209
3210 if (d.stat.st_size == 0) return 0;
3211
3212 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3213
3214 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3215 {
3216 if (d_cache)
3217 {
3218 u64 cnt = d_cache->cnt;
3219
3220 u64 keyspace = cnt;
3221
3222 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3223 {
3224 keyspace *= data.kernel_rules_cnt;
3225 }
3226 else if (data.attack_kern == ATTACK_KERN_COMBI)
3227 {
3228 keyspace *= data.combs_cnt;
3229 }
3230
3231 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);
3232 if (data.quiet == 0) log_info ("");
3233
3234 hc_signal (sigHandler_default);
3235
3236 return (keyspace);
3237 }
3238 }
3239
3240 time_t now = 0;
3241 time_t prev = 0;
3242
3243 u64 comp = 0;
3244 u64 cnt = 0;
3245 u64 cnt2 = 0;
3246
3247 while (!feof (fd))
3248 {
3249 load_segment (wl_data, fd);
3250
3251 comp += wl_data->cnt;
3252
3253 u32 i = 0;
3254
3255 while (i < wl_data->cnt)
3256 {
3257 u32 len;
3258 u32 off;
3259
3260 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3261
3262 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3263 {
3264 char rule_buf_out[BLOCK_SIZE] = { 0 };
3265
3266 int rule_len_out = -1;
3267
3268 if (len < BLOCK_SIZE)
3269 {
3270 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3271 }
3272
3273 if (rule_len_out < 0)
3274 {
3275 len = PW_MAX1;
3276 }
3277 else
3278 {
3279 len = rule_len_out;
3280 }
3281 }
3282
3283 if (len < PW_MAX1)
3284 {
3285 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3286 {
3287 cnt += data.kernel_rules_cnt;
3288 }
3289 else if (data.attack_kern == ATTACK_KERN_COMBI)
3290 {
3291 cnt += data.combs_cnt;
3292 }
3293
3294 d.cnt++;
3295 }
3296
3297 i += off;
3298
3299 cnt2++;
3300 }
3301
3302 time (&now);
3303
3304 if ((now - prev) == 0) continue;
3305
3306 float percent = (float) comp / (float) d.stat.st_size;
3307
3308 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);
3309
3310 time (&prev);
3311 }
3312
3313 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);
3314 if (data.quiet == 0) log_info ("");
3315
3316 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3317
3318 hc_signal (sigHandler_default);
3319
3320 return (cnt);
3321 }
3322
3323 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3324 {
3325 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3326 }
3327
3328 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3329 {
3330 if (data.devices_status == STATUS_BYPASS) return 0;
3331
3332 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3333
3334 uint cache_cnt = pw_cache->cnt;
3335
3336 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3337
3338 memcpy (pw_hc1, pw_buf, pw_len);
3339
3340 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3341
3342 uint pws_cnt = device_param->pws_cnt;
3343
3344 cache_cnt++;
3345
3346 pw_t *pw = device_param->pws_buf + pws_cnt;
3347
3348 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3349
3350 pw->pw_len = pw_len;
3351
3352 pws_cnt++;
3353
3354 device_param->pws_cnt = pws_cnt;
3355 device_param->pw_cnt = pws_cnt * 1;
3356
3357 cache_cnt = 0;
3358
3359 pw_cache->cnt = cache_cnt;
3360
3361 return pws_cnt;
3362 }
3363
3364 static void *thread_monitor (void *p)
3365 {
3366 uint runtime_check = 0;
3367 uint remove_check = 0;
3368 uint status_check = 0;
3369 uint hwmon_check = 0;
3370 uint restore_check = 0;
3371
3372 uint restore_left = data.restore_timer;
3373 uint remove_left = data.remove_timer;
3374 uint status_left = data.status_timer;
3375
3376 // these variables are mainly used for fan control (AMD only)
3377
3378 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3379
3380 // temperature controller "loopback" values
3381
3382 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3383 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3384
3385 int temp_threshold = 1; // degrees celcius
3386
3387 int fan_speed_min = 15; // in percentage
3388 int fan_speed_max = 100;
3389
3390 time_t last_temp_check_time;
3391
3392 uint sleep_time = 1;
3393
3394 if (data.runtime)
3395 {
3396 runtime_check = 1;
3397 }
3398
3399 if (data.restore_timer)
3400 {
3401 restore_check = 1;
3402 }
3403
3404 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3405 {
3406 remove_check = 1;
3407 }
3408
3409 if (data.status == 1)
3410 {
3411 status_check = 1;
3412 }
3413
3414 if (data.gpu_temp_disable == 0)
3415 {
3416 time (&last_temp_check_time);
3417
3418 hwmon_check = 1;
3419 }
3420
3421 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3422 {
3423 return (p);
3424 }
3425
3426 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3427 {
3428 hc_sleep (sleep_time);
3429
3430 if (data.devices_status != STATUS_RUNNING) continue;
3431
3432 if (hwmon_check == 1)
3433 {
3434 hc_thread_mutex_lock (mux_adl);
3435
3436 time_t temp_check_time;
3437
3438 time (&temp_check_time);
3439
3440 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3441
3442 if (Ta == 0) Ta = 1;
3443
3444 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3445 {
3446 hc_device_param_t *device_param = &data.devices_param[device_id];
3447
3448 if (device_param->skipped) continue;
3449
3450 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3451
3452 const int temperature = hm_get_temperature_with_device_id (device_id);
3453
3454 if (temperature > (int) data.gpu_temp_abort)
3455 {
3456 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3457
3458 if (data.devices_status != STATUS_QUIT) myabort ();
3459
3460 break;
3461 }
3462
3463 const int gpu_temp_retain = data.gpu_temp_retain;
3464
3465 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3466 {
3467 if (data.hm_device[device_id].fan_supported == 1)
3468 {
3469 int temp_cur = temperature;
3470
3471 int temp_diff_new = gpu_temp_retain - temp_cur;
3472
3473 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3474
3475 // calculate Ta value (time difference in seconds between the last check and this check)
3476
3477 last_temp_check_time = temp_check_time;
3478
3479 float Kp = 1.8;
3480 float Ki = 0.005;
3481 float Kd = 6;
3482
3483 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3484
3485 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);
3486
3487 if (abs (fan_diff_required) >= temp_threshold)
3488 {
3489 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3490
3491 int fan_speed_level = fan_speed_cur;
3492
3493 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3494
3495 int fan_speed_new = fan_speed_level - fan_diff_required;
3496
3497 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3498 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3499
3500 if (fan_speed_new != fan_speed_cur)
3501 {
3502 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3503 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3504
3505 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3506 {
3507 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3508
3509 fan_speed_chgd[device_id] = 1;
3510 }
3511
3512 temp_diff_old[device_id] = temp_diff_new;
3513 }
3514 }
3515 }
3516 }
3517 }
3518
3519 hc_thread_mutex_unlock (mux_adl);
3520 }
3521
3522 if (restore_check == 1)
3523 {
3524 restore_left--;
3525
3526 if (restore_left == 0)
3527 {
3528 if (data.restore_disable == 0) cycle_restore ();
3529
3530 restore_left = data.restore_timer;
3531 }
3532 }
3533
3534 if ((runtime_check == 1) && (data.runtime_start > 0))
3535 {
3536 time_t runtime_cur;
3537
3538 time (&runtime_cur);
3539
3540 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3541
3542 if (runtime_left <= 0)
3543 {
3544 if (data.benchmark == 0)
3545 {
3546 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3547 }
3548
3549 if (data.devices_status != STATUS_QUIT) myabort ();
3550 }
3551 }
3552
3553 if (remove_check == 1)
3554 {
3555 remove_left--;
3556
3557 if (remove_left == 0)
3558 {
3559 if (data.digests_saved != data.digests_done)
3560 {
3561 data.digests_saved = data.digests_done;
3562
3563 save_hash ();
3564 }
3565
3566 remove_left = data.remove_timer;
3567 }
3568 }
3569
3570 if (status_check == 1)
3571 {
3572 status_left--;
3573
3574 if (status_left == 0)
3575 {
3576 hc_thread_mutex_lock (mux_display);
3577
3578 if (data.quiet == 0) clear_prompt ();
3579
3580 if (data.quiet == 0) log_info ("");
3581
3582 status_display ();
3583
3584 if (data.quiet == 0) log_info ("");
3585
3586 hc_thread_mutex_unlock (mux_display);
3587
3588 status_left = data.status_timer;
3589 }
3590 }
3591 }
3592
3593 myfree (fan_speed_chgd);
3594
3595 myfree (temp_diff_old);
3596 myfree (temp_diff_sum);
3597
3598 p = NULL;
3599
3600 return (p);
3601 }
3602
3603 static void *thread_outfile_remove (void *p)
3604 {
3605 // some hash-dependent constants
3606 char *outfile_dir = data.outfile_check_directory;
3607 uint dgst_size = data.dgst_size;
3608 uint isSalted = data.isSalted;
3609 uint esalt_size = data.esalt_size;
3610 uint hash_mode = data.hash_mode;
3611
3612 uint outfile_check_timer = data.outfile_check_timer;
3613
3614 char separator = data.separator;
3615
3616 // some hash-dependent functions
3617 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3618 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3619
3620 // buffers
3621 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3622
3623 hash_buf.digest = mymalloc (dgst_size);
3624
3625 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3626
3627 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3628
3629 uint digest_buf[64];
3630
3631 outfile_data_t *out_info = NULL;
3632
3633 char **out_files = NULL;
3634
3635 time_t folder_mtime = 0;
3636
3637 int out_cnt = 0;
3638
3639 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3640
3641 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3642 {
3643 hc_sleep (1);
3644
3645 if (data.devices_status != STATUS_RUNNING) continue;
3646
3647 check_left--;
3648
3649 if (check_left == 0)
3650 {
3651 struct stat outfile_check_stat;
3652
3653 if (stat (outfile_dir, &outfile_check_stat) == 0)
3654 {
3655 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3656
3657 if (is_dir == 1)
3658 {
3659 if (outfile_check_stat.st_mtime > folder_mtime)
3660 {
3661 char **out_files_new = scan_directory (outfile_dir);
3662
3663 int out_cnt_new = count_dictionaries (out_files_new);
3664
3665 outfile_data_t *out_info_new = NULL;
3666
3667 if (out_cnt_new > 0)
3668 {
3669 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3670
3671 for (int i = 0; i < out_cnt_new; i++)
3672 {
3673 out_info_new[i].file_name = out_files_new[i];
3674
3675 // check if there are files that we have seen/checked before (and not changed)
3676
3677 for (int j = 0; j < out_cnt; j++)
3678 {
3679 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3680 {
3681 struct stat outfile_stat;
3682
3683 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3684 {
3685 if (outfile_stat.st_ctime == out_info[j].ctime)
3686 {
3687 out_info_new[i].ctime = out_info[j].ctime;
3688 out_info_new[i].seek = out_info[j].seek;
3689 }
3690 }
3691 }
3692 }
3693 }
3694 }
3695
3696 local_free (out_info);
3697 local_free (out_files);
3698
3699 out_files = out_files_new;
3700 out_cnt = out_cnt_new;
3701 out_info = out_info_new;
3702
3703 folder_mtime = outfile_check_stat.st_mtime;
3704 }
3705
3706 for (int j = 0; j < out_cnt; j++)
3707 {
3708 FILE *fp = fopen (out_info[j].file_name, "rb");
3709
3710 if (fp != NULL)
3711 {
3712 //hc_thread_mutex_lock (mux_display);
3713
3714 #ifdef _POSIX
3715 struct stat outfile_stat;
3716
3717 fstat (fileno (fp), &outfile_stat);
3718 #endif
3719
3720 #ifdef _WIN
3721 struct stat64 outfile_stat;
3722
3723 _fstat64 (fileno (fp), &outfile_stat);
3724 #endif
3725
3726 if (outfile_stat.st_ctime > out_info[j].ctime)
3727 {
3728 out_info[j].ctime = outfile_stat.st_ctime;
3729 out_info[j].seek = 0;
3730 }
3731
3732 fseek (fp, out_info[j].seek, SEEK_SET);
3733
3734 while (!feof (fp))
3735 {
3736 char line_buf[BUFSIZ];
3737
3738 memset (line_buf, 0, BUFSIZ);
3739
3740 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3741
3742 if (ptr == NULL) break;
3743
3744 int line_len = strlen (line_buf);
3745
3746 if (line_len <= 0) continue;
3747
3748 int iter = MAX_CUT_TRIES;
3749
3750 for (uint i = line_len - 1; i && iter; i--, line_len--)
3751 {
3752 if (line_buf[i] != separator) continue;
3753
3754 int parser_status = PARSER_OK;
3755
3756 if ((hash_mode != 2500) && (hash_mode != 6800))
3757 {
3758 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3759 }
3760
3761 uint found = 0;
3762
3763 if (parser_status == PARSER_OK)
3764 {
3765 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3766 {
3767 if (data.salts_shown[salt_pos] == 1) continue;
3768
3769 salt_t *salt_buf = &data.salts_buf[salt_pos];
3770
3771 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3772 {
3773 uint idx = salt_buf->digests_offset + digest_pos;
3774
3775 if (data.digests_shown[idx] == 1) continue;
3776
3777 uint cracked = 0;
3778
3779 if (hash_mode == 6800)
3780 {
3781 if (i == salt_buf->salt_len)
3782 {
3783 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3784 }
3785 }
3786 else if (hash_mode == 2500)
3787 {
3788 // BSSID : MAC1 : MAC2 (:plain)
3789 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3790 {
3791 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3792
3793 if (!cracked) continue;
3794
3795 // now compare MAC1 and MAC2 too, since we have this additional info
3796 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3797 char *mac2_pos = mac1_pos + 12 + 1;
3798
3799 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3800 wpa_t *wpa = &wpas[salt_pos];
3801
3802 uint pke[25];
3803
3804 char *pke_ptr = (char *) pke;
3805
3806 for (uint i = 0; i < 25; i++)
3807 {
3808 pke[i] = byte_swap_32 (wpa->pke[i]);
3809 }
3810
3811 u8 mac1[6];
3812 u8 mac2[6];
3813
3814 memcpy (mac1, pke_ptr + 23, 6);
3815 memcpy (mac2, pke_ptr + 29, 6);
3816
3817 // compare hex string(s) vs binary MAC address(es)
3818
3819 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3820 {
3821 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3822 {
3823 cracked = 0;
3824 break;
3825 }
3826 }
3827
3828 // early skip ;)
3829 if (!cracked) continue;
3830
3831 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3832 {
3833 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3834 {
3835 cracked = 0;
3836 break;
3837 }
3838 }
3839 }
3840 }
3841 else
3842 {
3843 char *digests_buf_ptr = (char *) data.digests_buf;
3844
3845 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3846
3847 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3848 }
3849
3850 if (cracked == 1)
3851 {
3852 found = 1;
3853
3854 data.digests_shown[idx] = 1;
3855
3856 data.digests_done++;
3857
3858 salt_buf->digests_done++;
3859
3860 if (salt_buf->digests_done == salt_buf->digests_cnt)
3861 {
3862 data.salts_shown[salt_pos] = 1;
3863
3864 data.salts_done++;
3865
3866 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3867 }
3868 }
3869 }
3870
3871 if (data.devices_status == STATUS_CRACKED) break;
3872 }
3873 }
3874
3875 if (found) break;
3876
3877 if (data.devices_status == STATUS_CRACKED) break;
3878
3879 iter--;
3880 }
3881
3882 if (data.devices_status == STATUS_CRACKED) break;
3883 }
3884
3885 out_info[j].seek = ftell (fp);
3886
3887 //hc_thread_mutex_unlock (mux_display);
3888
3889 fclose (fp);
3890 }
3891 }
3892 }
3893 }
3894
3895 check_left = outfile_check_timer;
3896 }
3897 }
3898
3899 if (esalt_size) local_free (hash_buf.esalt);
3900
3901 if (isSalted) local_free (hash_buf.salt);
3902
3903 local_free (hash_buf.digest);
3904
3905 local_free (out_info);
3906
3907 local_free (out_files);
3908
3909 p = NULL;
3910
3911 return (p);
3912 }
3913
3914 static uint get_work (hc_device_param_t *device_param, const u64 max)
3915 {
3916 hc_thread_mutex_lock (mux_dispatcher);
3917
3918 const u64 words_cur = data.words_cur;
3919 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3920
3921 device_param->words_off = words_cur;
3922
3923 const u64 words_left = words_base - words_cur;
3924
3925 if (data.kernel_blocks_all > words_left)
3926 {
3927 if (data.kernel_blocks_div == 0)
3928 {
3929 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3930 }
3931 }
3932
3933 if (data.kernel_blocks_div)
3934 {
3935 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3936 {
3937 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3938 const u32 kernel_power_new = kernel_blocks_new;
3939
3940 if (kernel_blocks_new < device_param->kernel_blocks)
3941 {
3942 device_param->kernel_blocks = kernel_blocks_new;
3943 device_param->kernel_power = kernel_power_new;
3944 }
3945 }
3946 }
3947
3948 const uint kernel_blocks = device_param->kernel_blocks;
3949
3950 uint work = MIN (words_left, kernel_blocks);
3951
3952 work = MIN (work, max);
3953
3954 data.words_cur += work;
3955
3956 hc_thread_mutex_unlock (mux_dispatcher);
3957
3958 return work;
3959 }
3960
3961 static void *thread_calc_stdin (void *p)
3962 {
3963 hc_device_param_t *device_param = (hc_device_param_t *) p;
3964
3965 if (device_param->skipped) return NULL;
3966
3967 const uint attack_kern = data.attack_kern;
3968
3969 const uint kernel_blocks = device_param->kernel_blocks;
3970
3971 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3972 {
3973 hc_thread_mutex_lock (mux_dispatcher);
3974
3975 if (feof (stdin) != 0)
3976 {
3977 hc_thread_mutex_unlock (mux_dispatcher);
3978
3979 break;
3980 }
3981
3982 uint words_cur = 0;
3983
3984 while (words_cur < kernel_blocks)
3985 {
3986 char buf[BUFSIZ];
3987
3988 char *line_buf = fgets (buf, sizeof (buf), stdin);
3989
3990 if (line_buf == NULL) break;
3991
3992 uint line_len = in_superchop (line_buf);
3993
3994 line_len = convert_from_hex (line_buf, line_len);
3995
3996 // post-process rule engine
3997
3998 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3999 {
4000 char rule_buf_out[BLOCK_SIZE] = { 0 };
4001
4002 int rule_len_out = -1;
4003
4004 if (line_len < BLOCK_SIZE)
4005 {
4006 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4007 }
4008
4009 if (rule_len_out < 0) continue;
4010
4011 line_buf = rule_buf_out;
4012 line_len = rule_len_out;
4013 }
4014
4015 if (line_len > PW_MAX)
4016 {
4017 continue;
4018 }
4019
4020 if (attack_kern == ATTACK_KERN_STRAIGHT)
4021 {
4022 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4023 {
4024 hc_thread_mutex_lock (mux_counter);
4025
4026 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4027 {
4028 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4029 }
4030
4031 hc_thread_mutex_unlock (mux_counter);
4032
4033 continue;
4034 }
4035 }
4036 else if (attack_kern == ATTACK_KERN_COMBI)
4037 {
4038 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4039 // since we still need to combine the plains
4040
4041 if (line_len > data.pw_max)
4042 {
4043 hc_thread_mutex_lock (mux_counter);
4044
4045 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4046 {
4047 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4048 }
4049
4050 hc_thread_mutex_unlock (mux_counter);
4051
4052 continue;
4053 }
4054 }
4055
4056 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4057
4058 words_cur++;
4059
4060 if (data.devices_status == STATUS_CRACKED) break;
4061 if (data.devices_status == STATUS_ABORTED) break;
4062 if (data.devices_status == STATUS_QUIT) break;
4063 if (data.devices_status == STATUS_BYPASS) break;
4064 }
4065
4066 hc_thread_mutex_unlock (mux_dispatcher);
4067
4068 if (data.devices_status == STATUS_CRACKED) break;
4069 if (data.devices_status == STATUS_ABORTED) break;
4070 if (data.devices_status == STATUS_QUIT) break;
4071 if (data.devices_status == STATUS_BYPASS) break;
4072
4073 // we need 2 flushing because we have two independant caches and it can occur
4074 // that one buffer is already at threshold plus for that length also exists
4075 // more data in the 2nd buffer so it would overflow
4076
4077 // flush session 1
4078
4079 {
4080 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4081 {
4082 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4083
4084 const uint pw_cache_cnt = pw_cache->cnt;
4085
4086 if (pw_cache_cnt == 0) continue;
4087
4088 pw_cache->cnt = 0;
4089
4090 uint pws_cnt = device_param->pws_cnt;
4091
4092 pw_t *pw = device_param->pws_buf + pws_cnt;
4093
4094 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4095
4096 pw->pw_len = pw_len;
4097
4098 uint pw_cnt = device_param->pw_cnt;
4099
4100 pw_cnt += pw_cache_cnt;
4101
4102 device_param->pw_cnt = pw_cnt;
4103
4104 pws_cnt++;
4105
4106 device_param->pws_cnt = pws_cnt;
4107
4108 if (pws_cnt == device_param->kernel_power_user) break;
4109 }
4110
4111 const uint pw_cnt = device_param->pw_cnt;
4112 const uint pws_cnt = device_param->pws_cnt;
4113
4114 if (pws_cnt)
4115 {
4116 run_copy (device_param, pws_cnt);
4117
4118 run_cracker (device_param, pw_cnt, pws_cnt);
4119
4120 device_param->pw_cnt = 0;
4121 device_param->pws_cnt = 0;
4122 }
4123 }
4124
4125 // flush session 2
4126
4127 {
4128 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4129 {
4130 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4131
4132 const uint pw_cache_cnt = pw_cache->cnt;
4133
4134 if (pw_cache_cnt == 0) continue;
4135
4136 pw_cache->cnt = 0;
4137
4138 uint pws_cnt = device_param->pws_cnt;
4139
4140 pw_t *pw = device_param->pws_buf + pws_cnt;
4141
4142 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4143
4144 pw->pw_len = pw_len;
4145
4146 uint pw_cnt = device_param->pw_cnt;
4147
4148 pw_cnt += pw_cache_cnt;
4149
4150 device_param->pw_cnt = pw_cnt;
4151
4152 pws_cnt++;
4153
4154 device_param->pws_cnt = pws_cnt;
4155 }
4156
4157 const uint pw_cnt = device_param->pw_cnt;
4158 const uint pws_cnt = device_param->pws_cnt;
4159
4160 if (pws_cnt)
4161 {
4162 run_copy (device_param, pws_cnt);
4163
4164 run_cracker (device_param, pw_cnt, pws_cnt);
4165
4166 device_param->pw_cnt = 0;
4167 device_param->pws_cnt = 0;
4168 }
4169 }
4170 }
4171
4172 return NULL;
4173 }
4174
4175 static void *thread_calc (void *p)
4176 {
4177 hc_device_param_t *device_param = (hc_device_param_t *) p;
4178
4179 if (device_param->skipped) return NULL;
4180
4181 const uint attack_mode = data.attack_mode;
4182 const uint attack_kern = data.attack_kern;
4183
4184 if (attack_mode == ATTACK_MODE_BF)
4185 {
4186 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4187 {
4188 const uint work = get_work (device_param, -1);
4189
4190 if (work == 0) break;
4191
4192 const u64 words_off = device_param->words_off;
4193 const u64 words_fin = words_off + work;
4194
4195 const uint pw_cnt = work;
4196 const uint pws_cnt = work;
4197
4198 device_param->pw_cnt = pw_cnt;
4199 device_param->pws_cnt = pws_cnt;
4200
4201 if (pws_cnt)
4202 {
4203 run_copy (device_param, pws_cnt);
4204
4205 run_cracker (device_param, pw_cnt, pws_cnt);
4206
4207 device_param->pw_cnt = 0;
4208 device_param->pws_cnt = 0;
4209 }
4210
4211 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4212
4213 if (data.devices_status == STATUS_CRACKED) break;
4214 if (data.devices_status == STATUS_ABORTED) break;
4215 if (data.devices_status == STATUS_QUIT) break;
4216 if (data.devices_status == STATUS_BYPASS) break;
4217
4218 device_param->words_done = words_fin;
4219 }
4220 }
4221 else
4222 {
4223 const uint segment_size = data.segment_size;
4224
4225 char *dictfile = data.dictfile;
4226
4227 if (attack_mode == ATTACK_MODE_COMBI)
4228 {
4229 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4230 {
4231 dictfile = data.dictfile2;
4232 }
4233 }
4234
4235 FILE *fd = fopen (dictfile, "rb");
4236
4237 if (fd == NULL)
4238 {
4239 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4240
4241 return NULL;
4242 }
4243
4244 if (attack_mode == ATTACK_MODE_COMBI)
4245 {
4246 const uint combs_mode = data.combs_mode;
4247
4248 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4249 {
4250 const char *dictfilec = data.dictfile2;
4251
4252 FILE *combs_fp = fopen (dictfilec, "rb");
4253
4254 if (combs_fp == NULL)
4255 {
4256 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4257
4258 fclose (fd);
4259
4260 return NULL;
4261 }
4262
4263 device_param->combs_fp = combs_fp;
4264 }
4265 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4266 {
4267 const char *dictfilec = data.dictfile;
4268
4269 FILE *combs_fp = fopen (dictfilec, "rb");
4270
4271 if (combs_fp == NULL)
4272 {
4273 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4274
4275 fclose (fd);
4276
4277 return NULL;
4278 }
4279
4280 device_param->combs_fp = combs_fp;
4281 }
4282 }
4283
4284 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4285
4286 wl_data->buf = (char *) mymalloc (segment_size);
4287 wl_data->avail = segment_size;
4288 wl_data->incr = segment_size;
4289 wl_data->cnt = 0;
4290 wl_data->pos = 0;
4291
4292 u64 words_cur = 0;
4293
4294 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4295 {
4296 u64 words_off = 0;
4297 u64 words_fin = 0;
4298
4299 u64 max = -1;
4300
4301 while (max)
4302 {
4303 const uint work = get_work (device_param, max);
4304
4305 if (work == 0) break;
4306
4307 words_off = device_param->words_off;
4308 words_fin = words_off + work;
4309
4310 char *line_buf;
4311 uint line_len;
4312
4313 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4314
4315 max = 0;
4316
4317 for ( ; words_cur < words_fin; words_cur++)
4318 {
4319 get_next_word (wl_data, fd, &line_buf, &line_len);
4320
4321 line_len = convert_from_hex (line_buf, line_len);
4322
4323 // post-process rule engine
4324
4325 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4326 {
4327 char rule_buf_out[BLOCK_SIZE] = { 0 };
4328
4329 int rule_len_out = -1;
4330
4331 if (line_len < BLOCK_SIZE)
4332 {
4333 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4334 }
4335
4336 if (rule_len_out < 0) continue;
4337
4338 line_buf = rule_buf_out;
4339 line_len = rule_len_out;
4340 }
4341
4342 if (attack_kern == ATTACK_KERN_STRAIGHT)
4343 {
4344 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4345 {
4346 max++;
4347
4348 hc_thread_mutex_lock (mux_counter);
4349
4350 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4351 {
4352 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4353 }
4354
4355 hc_thread_mutex_unlock (mux_counter);
4356
4357 continue;
4358 }
4359 }
4360 else if (attack_kern == ATTACK_KERN_COMBI)
4361 {
4362 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4363 // since we still need to combine the plains
4364
4365 if (line_len > data.pw_max)
4366 {
4367 max++;
4368
4369 hc_thread_mutex_lock (mux_counter);
4370
4371 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4372 {
4373 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4374 }
4375
4376 hc_thread_mutex_unlock (mux_counter);
4377
4378 continue;
4379 }
4380 }
4381
4382 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4383
4384 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4385
4386 if (data.devices_status == STATUS_CRACKED) break;
4387 if (data.devices_status == STATUS_ABORTED) break;
4388 if (data.devices_status == STATUS_QUIT) break;
4389 if (data.devices_status == STATUS_BYPASS) break;
4390 }
4391
4392 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4393
4394 if (data.devices_status == STATUS_CRACKED) break;
4395 if (data.devices_status == STATUS_ABORTED) break;
4396 if (data.devices_status == STATUS_QUIT) break;
4397 if (data.devices_status == STATUS_BYPASS) break;
4398 }
4399
4400 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4401
4402 if (data.devices_status == STATUS_CRACKED) break;
4403 if (data.devices_status == STATUS_ABORTED) break;
4404 if (data.devices_status == STATUS_QUIT) break;
4405 if (data.devices_status == STATUS_BYPASS) break;
4406
4407 // we need 2 flushing because we have two independant caches and it can occur
4408 // that one buffer is already at threshold plus for that length also exists
4409 // more data in the 2nd buffer so it would overflow
4410
4411 //
4412 // flush session 1
4413 //
4414
4415 {
4416 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4417 {
4418 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4419
4420 const uint pw_cache_cnt = pw_cache->cnt;
4421
4422 if (pw_cache_cnt == 0) continue;
4423
4424 pw_cache->cnt = 0;
4425
4426 uint pws_cnt = device_param->pws_cnt;
4427
4428 pw_t *pw = device_param->pws_buf + pws_cnt;
4429
4430 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4431
4432 pw->pw_len = pw_len;
4433
4434 uint pw_cnt = device_param->pw_cnt;
4435
4436 pw_cnt += pw_cache_cnt;
4437
4438 device_param->pw_cnt = pw_cnt;
4439
4440 pws_cnt++;
4441
4442 device_param->pws_cnt = pws_cnt;
4443
4444 if (pws_cnt == device_param->kernel_power_user) break;
4445 }
4446
4447 const uint pw_cnt = device_param->pw_cnt;
4448 const uint pws_cnt = device_param->pws_cnt;
4449
4450 if (pws_cnt)
4451 {
4452 run_copy (device_param, pws_cnt);
4453
4454 run_cracker (device_param, pw_cnt, pws_cnt);
4455
4456 device_param->pw_cnt = 0;
4457 device_param->pws_cnt = 0;
4458 }
4459
4460 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4461
4462 if (data.devices_status == STATUS_CRACKED) break;
4463 if (data.devices_status == STATUS_ABORTED) break;
4464 if (data.devices_status == STATUS_QUIT) break;
4465 if (data.devices_status == STATUS_BYPASS) break;
4466 }
4467
4468 //
4469 // flush session 2
4470 //
4471
4472 {
4473 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4474 {
4475 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4476
4477 const uint pw_cache_cnt = pw_cache->cnt;
4478
4479 if (pw_cache_cnt == 0) continue;
4480
4481 pw_cache->cnt = 0;
4482
4483 uint pws_cnt = device_param->pws_cnt;
4484
4485 pw_t *pw = device_param->pws_buf + pws_cnt;
4486
4487 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4488
4489 pw->pw_len = pw_len;
4490
4491 uint pw_cnt = device_param->pw_cnt;
4492
4493 pw_cnt += pw_cache_cnt;
4494
4495 device_param->pw_cnt = pw_cnt;
4496
4497 pws_cnt++;
4498
4499 device_param->pws_cnt = pws_cnt;
4500 }
4501
4502 const uint pw_cnt = device_param->pw_cnt;
4503 const uint pws_cnt = device_param->pws_cnt;
4504
4505 if (pws_cnt)
4506 {
4507 run_copy (device_param, pws_cnt);
4508
4509 run_cracker (device_param, pw_cnt, pws_cnt);
4510
4511 device_param->pw_cnt = 0;
4512 device_param->pws_cnt = 0;
4513 }
4514
4515 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4516
4517 if (data.devices_status == STATUS_CRACKED) break;
4518 if (data.devices_status == STATUS_ABORTED) break;
4519 if (data.devices_status == STATUS_QUIT) break;
4520 if (data.devices_status == STATUS_BYPASS) break;
4521 }
4522
4523 if (words_fin == 0) break;
4524
4525 device_param->words_done = words_fin;
4526 }
4527
4528 if (attack_mode == ATTACK_MODE_COMBI)
4529 {
4530 fclose (device_param->combs_fp);
4531 }
4532
4533 free (wl_data->buf);
4534 free (wl_data);
4535
4536 fclose (fd);
4537 }
4538
4539 return NULL;
4540 }
4541
4542 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4543 {
4544 salt_t *salt_buf = &data.salts_buf[salt_pos];
4545
4546 device_param->kernel_params_buf32[24] = salt_pos;
4547 device_param->kernel_params_buf32[27] = 1;
4548 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4549 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4550 device_param->kernel_params_buf32[30] = 0;
4551 device_param->kernel_params_buf32[31] = 1;
4552
4553 char *dictfile_old = data.dictfile;
4554
4555 const char *weak_hash_check = "weak-hash-check";
4556
4557 data.dictfile = (char *) weak_hash_check;
4558
4559 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4560
4561 data.kernel_rules_buf[0].cmds[0] = 0;
4562
4563 /**
4564 * run the kernel
4565 */
4566
4567 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4568 {
4569 run_kernel (KERN_RUN_1, device_param, 1);
4570 }
4571 else
4572 {
4573 run_kernel (KERN_RUN_1, device_param, 1);
4574
4575 const uint iter = salt_buf->salt_iter;
4576
4577 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4578 {
4579 uint loop_left = iter - loop_pos;
4580
4581 loop_left = MIN (loop_left, kernel_loops);
4582
4583 device_param->kernel_params_buf32[25] = loop_pos;
4584 device_param->kernel_params_buf32[26] = loop_left;
4585
4586 run_kernel (KERN_RUN_2, device_param, 1);
4587 }
4588
4589 run_kernel (KERN_RUN_3, device_param, 1);
4590 }
4591
4592 /**
4593 * result
4594 */
4595
4596 check_cracked (device_param, salt_pos);
4597
4598 /**
4599 * cleanup
4600 */
4601
4602 device_param->kernel_params_buf32[24] = 0;
4603 device_param->kernel_params_buf32[25] = 0;
4604 device_param->kernel_params_buf32[26] = 0;
4605 device_param->kernel_params_buf32[27] = 0;
4606 device_param->kernel_params_buf32[28] = 0;
4607 device_param->kernel_params_buf32[29] = 0;
4608 device_param->kernel_params_buf32[30] = 0;
4609 device_param->kernel_params_buf32[31] = 0;
4610
4611 data.dictfile = dictfile_old;
4612
4613 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4614 }
4615
4616 // hlfmt hashcat
4617
4618 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4619 {
4620 if (data.username == 0)
4621 {
4622 *hashbuf_pos = line_buf;
4623 *hashbuf_len = line_len;
4624 }
4625 else
4626 {
4627 char *pos = line_buf;
4628 int len = line_len;
4629
4630 for (int i = 0; i < line_len; i++, pos++, len--)
4631 {
4632 if (line_buf[i] == data.separator)
4633 {
4634 pos++;
4635
4636 len--;
4637
4638 break;
4639 }
4640 }
4641
4642 *hashbuf_pos = pos;
4643 *hashbuf_len = len;
4644 }
4645 }
4646
4647 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4648 {
4649 char *pos = NULL;
4650 int len = 0;
4651
4652 int sep_cnt = 0;
4653
4654 for (int i = 0; i < line_len; i++)
4655 {
4656 if (line_buf[i] == data.separator)
4657 {
4658 sep_cnt++;
4659
4660 continue;
4661 }
4662
4663 if (sep_cnt == 0)
4664 {
4665 if (pos == NULL) pos = line_buf + i;
4666
4667 len++;
4668 }
4669 }
4670
4671 *userbuf_pos = pos;
4672 *userbuf_len = len;
4673 }
4674
4675 // hlfmt pwdump
4676
4677 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4678 {
4679 int sep_cnt = 0;
4680
4681 int sep2_len = 0;
4682 int sep3_len = 0;
4683
4684 for (int i = 0; i < line_len; i++)
4685 {
4686 if (line_buf[i] == ':')
4687 {
4688 sep_cnt++;
4689
4690 continue;
4691 }
4692
4693 if (sep_cnt == 2) sep2_len++;
4694 if (sep_cnt == 3) sep3_len++;
4695 }
4696
4697 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4698
4699 return 0;
4700 }
4701
4702 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4703 {
4704 char *pos = NULL;
4705 int len = 0;
4706
4707 int sep_cnt = 0;
4708
4709 for (int i = 0; i < line_len; i++)
4710 {
4711 if (line_buf[i] == ':')
4712 {
4713 sep_cnt++;
4714
4715 continue;
4716 }
4717
4718 if (data.hash_mode == 1000)
4719 {
4720 if (sep_cnt == 3)
4721 {
4722 if (pos == NULL) pos = line_buf + i;
4723
4724 len++;
4725 }
4726 }
4727 else if (data.hash_mode == 3000)
4728 {
4729 if (sep_cnt == 2)
4730 {
4731 if (pos == NULL) pos = line_buf + i;
4732
4733 len++;
4734 }
4735 }
4736 }
4737
4738 *hashbuf_pos = pos;
4739 *hashbuf_len = len;
4740 }
4741
4742 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4743 {
4744 char *pos = NULL;
4745 int len = 0;
4746
4747 int sep_cnt = 0;
4748
4749 for (int i = 0; i < line_len; i++)
4750 {
4751 if (line_buf[i] == ':')
4752 {
4753 sep_cnt++;
4754
4755 continue;
4756 }
4757
4758 if (sep_cnt == 0)
4759 {
4760 if (pos == NULL) pos = line_buf + i;
4761
4762 len++;
4763 }
4764 }
4765
4766 *userbuf_pos = pos;
4767 *userbuf_len = len;
4768 }
4769
4770 // hlfmt passwd
4771
4772 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4773 {
4774 int sep_cnt = 0;
4775
4776 char sep5_first = 0;
4777 char sep6_first = 0;
4778
4779 for (int i = 0; i < line_len; i++)
4780 {
4781 if (line_buf[i] == ':')
4782 {
4783 sep_cnt++;
4784
4785 continue;
4786 }
4787
4788 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4789 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4790 }
4791
4792 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4793
4794 return 0;
4795 }
4796
4797 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4798 {
4799 char *pos = NULL;
4800 int len = 0;
4801
4802 int sep_cnt = 0;
4803
4804 for (int i = 0; i < line_len; i++)
4805 {
4806 if (line_buf[i] == ':')
4807 {
4808 sep_cnt++;
4809
4810 continue;
4811 }
4812
4813 if (sep_cnt == 1)
4814 {
4815 if (pos == NULL) pos = line_buf + i;
4816
4817 len++;
4818 }
4819 }
4820
4821 *hashbuf_pos = pos;
4822 *hashbuf_len = len;
4823 }
4824
4825 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4826 {
4827 char *pos = NULL;
4828 int len = 0;
4829
4830 int sep_cnt = 0;
4831
4832 for (int i = 0; i < line_len; i++)
4833 {
4834 if (line_buf[i] == ':')
4835 {
4836 sep_cnt++;
4837
4838 continue;
4839 }
4840
4841 if (sep_cnt == 0)
4842 {
4843 if (pos == NULL) pos = line_buf + i;
4844
4845 len++;
4846 }
4847 }
4848
4849 *userbuf_pos = pos;
4850 *userbuf_len = len;
4851 }
4852
4853 // hlfmt shadow
4854
4855 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4856 {
4857 int sep_cnt = 0;
4858
4859 for (int i = 0; i < line_len; i++)
4860 {
4861 if (line_buf[i] == ':') sep_cnt++;
4862 }
4863
4864 if (sep_cnt == 8) return 1;
4865
4866 return 0;
4867 }
4868
4869 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4870 {
4871 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4872 }
4873
4874 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4875 {
4876 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4877 }
4878
4879 // hlfmt main
4880
4881 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4882 {
4883 switch (hashfile_format)
4884 {
4885 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4886 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4887 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4888 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4889 }
4890 }
4891
4892 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4893 {
4894 switch (hashfile_format)
4895 {
4896 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4897 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4898 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4899 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4900 }
4901 }
4902
4903 static uint hlfmt_detect (FILE *fp, uint max_check)
4904 {
4905 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4906
4907 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4908 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4909
4910 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4911
4912 uint num_check = 0;
4913
4914 while (!feof (fp))
4915 {
4916 char line_buf[BUFSIZ];
4917
4918 int line_len = fgetl (fp, line_buf);
4919
4920 if (line_len == 0) continue;
4921
4922 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4923 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4924 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4925
4926 if (num_check == max_check) break;
4927
4928 num_check++;
4929 }
4930
4931 uint hashlist_format = HLFMT_HASHCAT;
4932
4933 for (int i = 1; i < HLFMTS_CNT; i++)
4934 {
4935 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4936
4937 hashlist_format = i;
4938 }
4939
4940 free (formats_cnt);
4941
4942 return hashlist_format;
4943 }
4944
4945 /**
4946 * some further helper function
4947 */
4948
4949 // wrapper around mymalloc for ADL
4950
4951 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4952 {
4953 return mymalloc (iSize);
4954 }
4955
4956 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)
4957 {
4958 u64 collisions = 0;
4959
4960 const uint dgst_pos0 = data.dgst_pos0;
4961 const uint dgst_pos1 = data.dgst_pos1;
4962 const uint dgst_pos2 = data.dgst_pos2;
4963 const uint dgst_pos3 = data.dgst_pos3;
4964
4965 memset (bitmap_a, 0, bitmap_size);
4966 memset (bitmap_b, 0, bitmap_size);
4967 memset (bitmap_c, 0, bitmap_size);
4968 memset (bitmap_d, 0, bitmap_size);
4969
4970 for (uint i = 0; i < digests_cnt; i++)
4971 {
4972 uint *digest_ptr = (uint *) digests_buf_ptr;
4973
4974 digests_buf_ptr += dgst_size;
4975
4976 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
4977 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
4978 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
4979 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
4980
4981 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4982 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4983 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4984 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4985
4986 if (bitmap_a[idx0] & val0) collisions++;
4987 if (bitmap_b[idx1] & val1) collisions++;
4988 if (bitmap_c[idx2] & val2) collisions++;
4989 if (bitmap_d[idx3] & val3) collisions++;
4990
4991 bitmap_a[idx0] |= val0;
4992 bitmap_b[idx1] |= val1;
4993 bitmap_c[idx2] |= val2;
4994 bitmap_d[idx3] |= val3;
4995
4996 if (collisions >= collisions_max) return 0x7fffffff;
4997 }
4998
4999 return collisions;
5000 }
5001
5002 /**
5003 * main
5004 */
5005
5006 int main (int argc, char **argv)
5007 {
5008 /**
5009 * To help users a bit
5010 */
5011
5012 char *compute = getenv ("COMPUTE");
5013
5014 if (compute)
5015 {
5016 char display[100];
5017
5018 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5019
5020 putenv (display);
5021 }
5022 else
5023 {
5024 if (getenv ("DISPLAY") == NULL)
5025 putenv ((char *) "DISPLAY=:0");
5026 }
5027
5028 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5029 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5030
5031 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5032 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5033
5034 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5035 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5036
5037 /**
5038 * Real init
5039 */
5040
5041 memset (&data, 0, sizeof (hc_global_data_t));
5042
5043 time_t proc_start;
5044
5045 time (&proc_start);
5046
5047 data.proc_start = proc_start;
5048
5049 int myargc = argc;
5050 char **myargv = argv;
5051
5052 hc_thread_mutex_init (mux_dispatcher);
5053 hc_thread_mutex_init (mux_counter);
5054 hc_thread_mutex_init (mux_display);
5055 hc_thread_mutex_init (mux_adl);
5056
5057 /**
5058 * commandline parameters
5059 */
5060
5061 uint usage = USAGE;
5062 uint version = VERSION;
5063 uint quiet = QUIET;
5064 uint benchmark = BENCHMARK;
5065 uint benchmark_mode = BENCHMARK_MODE;
5066 uint show = SHOW;
5067 uint left = LEFT;
5068 uint username = USERNAME;
5069 uint remove = REMOVE;
5070 uint remove_timer = REMOVE_TIMER;
5071 u64 skip = SKIP;
5072 u64 limit = LIMIT;
5073 uint keyspace = KEYSPACE;
5074 uint potfile_disable = POTFILE_DISABLE;
5075 uint debug_mode = DEBUG_MODE;
5076 char *debug_file = NULL;
5077 char *induction_dir = NULL;
5078 char *outfile_check_dir = NULL;
5079 uint force = FORCE;
5080 uint runtime = RUNTIME;
5081 uint hash_mode = HASH_MODE;
5082 uint attack_mode = ATTACK_MODE;
5083 uint markov_disable = MARKOV_DISABLE;
5084 uint markov_classic = MARKOV_CLASSIC;
5085 uint markov_threshold = MARKOV_THRESHOLD;
5086 char *markov_hcstat = NULL;
5087 char *outfile = NULL;
5088 uint outfile_format = OUTFILE_FORMAT;
5089 uint outfile_autohex = OUTFILE_AUTOHEX;
5090 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5091 uint restore = RESTORE;
5092 uint restore_timer = RESTORE_TIMER;
5093 uint restore_disable = RESTORE_DISABLE;
5094 uint status = STATUS;
5095 uint status_timer = STATUS_TIMER;
5096 uint status_automat = STATUS_AUTOMAT;
5097 uint loopback = LOOPBACK;
5098 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5099 char *session = NULL;
5100 uint hex_charset = HEX_CHARSET;
5101 uint hex_salt = HEX_SALT;
5102 uint hex_wordlist = HEX_WORDLIST;
5103 uint rp_gen = RP_GEN;
5104 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5105 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5106 uint rp_gen_seed = RP_GEN_SEED;
5107 char *rule_buf_l = (char *) RULE_BUF_L;
5108 char *rule_buf_r = (char *) RULE_BUF_R;
5109 uint increment = INCREMENT;
5110 uint increment_min = INCREMENT_MIN;
5111 uint increment_max = INCREMENT_MAX;
5112 char *cpu_affinity = NULL;
5113 char *opencl_devices = NULL;
5114 char *opencl_platforms = NULL;
5115 char *opencl_device_types = NULL;
5116 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5117 char *truecrypt_keyfiles = NULL;
5118 uint workload_profile = WORKLOAD_PROFILE;
5119 uint kernel_accel = KERNEL_ACCEL;
5120 uint kernel_loops = KERNEL_LOOPS;
5121 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5122 uint gpu_temp_abort = GPU_TEMP_ABORT;
5123 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5124 uint powertune_enable = POWERTUNE_ENABLE;
5125 uint logfile_disable = LOGFILE_DISABLE;
5126 uint segment_size = SEGMENT_SIZE;
5127 uint scrypt_tmto = SCRYPT_TMTO;
5128 char separator = SEPARATOR;
5129 uint bitmap_min = BITMAP_MIN;
5130 uint bitmap_max = BITMAP_MAX;
5131 char *custom_charset_1 = NULL;
5132 char *custom_charset_2 = NULL;
5133 char *custom_charset_3 = NULL;
5134 char *custom_charset_4 = NULL;
5135
5136 #define IDX_HELP 'h'
5137 #define IDX_VERSION 'V'
5138 #define IDX_VERSION_LOWER 'v'
5139 #define IDX_QUIET 0xff02
5140 #define IDX_SHOW 0xff03
5141 #define IDX_LEFT 0xff04
5142 #define IDX_REMOVE 0xff05
5143 #define IDX_REMOVE_TIMER 0xff37
5144 #define IDX_SKIP 's'
5145 #define IDX_LIMIT 'l'
5146 #define IDX_KEYSPACE 0xff35
5147 #define IDX_POTFILE_DISABLE 0xff06
5148 #define IDX_DEBUG_MODE 0xff43
5149 #define IDX_DEBUG_FILE 0xff44
5150 #define IDX_INDUCTION_DIR 0xff46
5151 #define IDX_OUTFILE_CHECK_DIR 0xff47
5152 #define IDX_USERNAME 0xff07
5153 #define IDX_FORCE 0xff08
5154 #define IDX_RUNTIME 0xff09
5155 #define IDX_BENCHMARK 'b'
5156 #define IDX_BENCHMARK_MODE 0xff32
5157 #define IDX_HASH_MODE 'm'
5158 #define IDX_ATTACK_MODE 'a'
5159 #define IDX_RP_FILE 'r'
5160 #define IDX_RP_GEN 'g'
5161 #define IDX_RP_GEN_FUNC_MIN 0xff10
5162 #define IDX_RP_GEN_FUNC_MAX 0xff11
5163 #define IDX_RP_GEN_SEED 0xff34
5164 #define IDX_RULE_BUF_L 'j'
5165 #define IDX_RULE_BUF_R 'k'
5166 #define IDX_INCREMENT 'i'
5167 #define IDX_INCREMENT_MIN 0xff12
5168 #define IDX_INCREMENT_MAX 0xff13
5169 #define IDX_OUTFILE 'o'
5170 #define IDX_OUTFILE_FORMAT 0xff14
5171 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5172 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5173 #define IDX_RESTORE 0xff15
5174 #define IDX_RESTORE_DISABLE 0xff27
5175 #define IDX_STATUS 0xff17
5176 #define IDX_STATUS_TIMER 0xff18
5177 #define IDX_STATUS_AUTOMAT 0xff50
5178 #define IDX_LOOPBACK 0xff38
5179 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5180 #define IDX_SESSION 0xff19
5181 #define IDX_HEX_CHARSET 0xff20
5182 #define IDX_HEX_SALT 0xff21
5183 #define IDX_HEX_WORDLIST 0xff40
5184 #define IDX_MARKOV_DISABLE 0xff22
5185 #define IDX_MARKOV_CLASSIC 0xff23
5186 #define IDX_MARKOV_THRESHOLD 't'
5187 #define IDX_MARKOV_HCSTAT 0xff24
5188 #define IDX_CPU_AFFINITY 0xff25
5189 #define IDX_OPENCL_DEVICES 'd'
5190 #define IDX_OPENCL_PLATFORMS 0xff72
5191 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5192 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5193 #define IDX_WORKLOAD_PROFILE 'w'
5194 #define IDX_KERNEL_ACCEL 'n'
5195 #define IDX_KERNEL_LOOPS 'u'
5196 #define IDX_GPU_TEMP_DISABLE 0xff29
5197 #define IDX_GPU_TEMP_ABORT 0xff30
5198 #define IDX_GPU_TEMP_RETAIN 0xff31
5199 #define IDX_POWERTUNE_ENABLE 0xff41
5200 #define IDX_LOGFILE_DISABLE 0xff51
5201 #define IDX_TRUECRYPT_KEYFILES 0xff52
5202 #define IDX_SCRYPT_TMTO 0xff61
5203 #define IDX_SEGMENT_SIZE 'c'
5204 #define IDX_SEPARATOR 'p'
5205 #define IDX_BITMAP_MIN 0xff70
5206 #define IDX_BITMAP_MAX 0xff71
5207 #define IDX_CUSTOM_CHARSET_1 '1'
5208 #define IDX_CUSTOM_CHARSET_2 '2'
5209 #define IDX_CUSTOM_CHARSET_3 '3'
5210 #define IDX_CUSTOM_CHARSET_4 '4'
5211
5212 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5213
5214 struct option long_options[] =
5215 {
5216 {"help", no_argument, 0, IDX_HELP},
5217 {"version", no_argument, 0, IDX_VERSION},
5218 {"quiet", no_argument, 0, IDX_QUIET},
5219 {"show", no_argument, 0, IDX_SHOW},
5220 {"left", no_argument, 0, IDX_LEFT},
5221 {"username", no_argument, 0, IDX_USERNAME},
5222 {"remove", no_argument, 0, IDX_REMOVE},
5223 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5224 {"skip", required_argument, 0, IDX_SKIP},
5225 {"limit", required_argument, 0, IDX_LIMIT},
5226 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5227 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5228 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5229 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5230 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5231 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5232 {"force", no_argument, 0, IDX_FORCE},
5233 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5234 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5235 {"restore", no_argument, 0, IDX_RESTORE},
5236 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5237 {"status", no_argument, 0, IDX_STATUS},
5238 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5239 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5240 {"loopback", no_argument, 0, IDX_LOOPBACK},
5241 {"weak-hash-threshold",
5242 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5243 {"session", required_argument, 0, IDX_SESSION},
5244 {"runtime", required_argument, 0, IDX_RUNTIME},
5245 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5246 {"generate-rules-func-min",
5247 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5248 {"generate-rules-func-max",
5249 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5250 {"generate-rules-seed",
5251 required_argument, 0, IDX_RP_GEN_SEED},
5252 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5253 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5254 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5255 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5256 {"rules-file", required_argument, 0, IDX_RP_FILE},
5257 {"outfile", required_argument, 0, IDX_OUTFILE},
5258 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5259 {"outfile-autohex-disable",
5260 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5261 {"outfile-check-timer",
5262 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5263 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5264 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5265 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5266 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5267 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5268 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5269 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5270 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5271 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5272 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5273 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5274 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5275 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5276 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5277 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5278 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5279 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5280 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5281 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5282 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5283 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5284 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5285 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5286 // deprecated
5287 {"seperator", required_argument, 0, IDX_SEPARATOR},
5288 {"separator", required_argument, 0, IDX_SEPARATOR},
5289 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5290 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5291 {"increment", no_argument, 0, IDX_INCREMENT},
5292 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5293 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5294 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5295 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5296 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5297 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5298
5299 {0, 0, 0, 0}
5300 };
5301
5302 uint rp_files_cnt = 0;
5303
5304 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5305
5306 int option_index;
5307 int c;
5308
5309 optind = 1;
5310 optopt = 0;
5311 option_index = 0;
5312
5313 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5314 {
5315 switch (c)
5316 {
5317 case IDX_HELP: usage = 1; break;
5318 case IDX_VERSION:
5319 case IDX_VERSION_LOWER: version = 1; break;
5320 case IDX_RESTORE: restore = 1; break;
5321 case IDX_SESSION: session = optarg; break;
5322 case IDX_SHOW: show = 1; break;
5323 case IDX_LEFT: left = 1; break;
5324 case '?': return (-1);
5325 }
5326 }
5327
5328 if (optopt != 0)
5329 {
5330 log_error ("ERROR: Invalid argument specified");
5331
5332 return (-1);
5333 }
5334
5335 /**
5336 * exit functions
5337 */
5338
5339 if (version)
5340 {
5341 log_info (VERSION_TXT);
5342
5343 return (0);
5344 }
5345
5346 if (usage)
5347 {
5348 usage_big_print (PROGNAME);
5349
5350 return (0);
5351 }
5352
5353 /**
5354 * session needs to be set, always!
5355 */
5356
5357 if (session == NULL) session = (char *) PROGNAME;
5358
5359 /**
5360 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5361 */
5362
5363 char *exec_path = get_exec_path ();
5364
5365 #ifdef LINUX
5366
5367 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5368 char *resolved_exec_path = realpath (exec_path, NULL);
5369
5370 char *install_dir = get_install_dir (resolved_exec_path);
5371 char *profile_dir = NULL;
5372 char *session_dir = NULL;
5373 char *shared_dir = NULL;
5374
5375 if (strcmp (install_dir, resolved_install_folder) == 0)
5376 {
5377 struct passwd *pw = getpwuid (getuid ());
5378
5379 const char *homedir = pw->pw_dir;
5380
5381 profile_dir = get_profile_dir (homedir);
5382 session_dir = get_session_dir (profile_dir);
5383 shared_dir = strdup (SHARED_FOLDER);
5384
5385 mkdir (profile_dir, 0700);
5386 mkdir (session_dir, 0700);
5387 }
5388 else
5389 {
5390 profile_dir = install_dir;
5391 session_dir = install_dir;
5392 shared_dir = install_dir;
5393 }
5394
5395 myfree (resolved_install_folder);
5396 myfree (resolved_exec_path);
5397
5398 #else
5399
5400 char *install_dir = get_install_dir (exec_path);
5401 char *profile_dir = install_dir;
5402 char *session_dir = install_dir;
5403 char *shared_dir = install_dir;
5404
5405 #endif
5406
5407 data.install_dir = install_dir;
5408 data.profile_dir = profile_dir;
5409 data.session_dir = session_dir;
5410 data.shared_dir = shared_dir;
5411
5412 myfree (exec_path);
5413
5414 /**
5415 * kernel cache, we need to make sure folder exist
5416 */
5417
5418 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5419
5420 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5421
5422 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5423
5424 mkdir (kernels_folder, 0700);
5425
5426 myfree (kernels_folder);
5427
5428 /**
5429 * session
5430 */
5431
5432 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5433
5434 data.session = session;
5435
5436 char *eff_restore_file = (char *) mymalloc (session_size);
5437 char *new_restore_file = (char *) mymalloc (session_size);
5438
5439 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5440 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5441
5442 data.eff_restore_file = eff_restore_file;
5443 data.new_restore_file = new_restore_file;
5444
5445 if (((show == 1) || (left == 1)) && (restore == 1))
5446 {
5447 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5448 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5449
5450 return (-1);
5451 }
5452
5453 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5454 if ((show == 1) || (left == 1))
5455 {
5456 restore_disable = 1;
5457
5458 restore = 0;
5459 }
5460
5461 data.restore_disable = restore_disable;
5462
5463 restore_data_t *rd = init_restore (argc, argv);
5464
5465 data.rd = rd;
5466
5467 /**
5468 * restore file
5469 */
5470
5471 if (restore == 1)
5472 {
5473 read_restore (eff_restore_file, rd);
5474
5475 if (rd->version_bin < RESTORE_MIN)
5476 {
5477 log_error ("ERROR: Incompatible restore-file version");
5478
5479 return (-1);
5480 }
5481
5482 myargc = rd->argc;
5483 myargv = rd->argv;
5484
5485 #ifdef _POSIX
5486 rd->pid = getpid ();
5487 #elif _WIN
5488 rd->pid = GetCurrentProcessId ();
5489 #endif
5490 }
5491
5492 uint hash_mode_chgd = 0;
5493 uint runtime_chgd = 0;
5494 uint kernel_loops_chgd = 0;
5495 uint kernel_accel_chgd = 0;
5496 uint attack_mode_chgd = 0;
5497 uint outfile_format_chgd = 0;
5498 uint rp_gen_seed_chgd = 0;
5499 uint remove_timer_chgd = 0;
5500 uint increment_min_chgd = 0;
5501 uint increment_max_chgd = 0;
5502 uint gpu_temp_abort_chgd = 0;
5503 uint gpu_temp_retain_chgd = 0;
5504
5505 optind = 1;
5506 optopt = 0;
5507 option_index = 0;
5508
5509 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5510 {
5511 switch (c)
5512 {
5513 //case IDX_HELP: usage = 1; break;
5514 //case IDX_VERSION: version = 1; break;
5515 //case IDX_RESTORE: restore = 1; break;
5516 case IDX_QUIET: quiet = 1; break;
5517 //case IDX_SHOW: show = 1; break;
5518 case IDX_SHOW: break;
5519 //case IDX_LEFT: left = 1; break;
5520 case IDX_LEFT: break;
5521 case IDX_USERNAME: username = 1; break;
5522 case IDX_REMOVE: remove = 1; break;
5523 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5524 remove_timer_chgd = 1; break;
5525 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5526 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5527 case IDX_DEBUG_FILE: debug_file = optarg; break;
5528 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5529 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5530 case IDX_FORCE: force = 1; break;
5531 case IDX_SKIP: skip = atoll (optarg); break;
5532 case IDX_LIMIT: limit = atoll (optarg); break;
5533 case IDX_KEYSPACE: keyspace = 1; break;
5534 case IDX_BENCHMARK: benchmark = 1; break;
5535 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5536 case IDX_RESTORE: break;
5537 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5538 case IDX_STATUS: status = 1; break;
5539 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5540 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5541 case IDX_LOOPBACK: loopback = 1; break;
5542 case IDX_WEAK_HASH_THRESHOLD:
5543 weak_hash_threshold = atoi (optarg); break;
5544 //case IDX_SESSION: session = optarg; break;
5545 case IDX_SESSION: break;
5546 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5547 hash_mode_chgd = 1; break;
5548 case IDX_RUNTIME: runtime = atoi (optarg);
5549 runtime_chgd = 1; break;
5550 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5551 attack_mode_chgd = 1; break;
5552 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5553 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5554 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5555 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5556 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5557 rp_gen_seed_chgd = 1; break;
5558 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5559 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5560 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5561 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5562 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5563 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5564 case IDX_OUTFILE: outfile = optarg; break;
5565 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5566 outfile_format_chgd = 1; break;
5567 case IDX_OUTFILE_AUTOHEX_DISABLE:
5568 outfile_autohex = 0; break;
5569 case IDX_OUTFILE_CHECK_TIMER:
5570 outfile_check_timer = atoi (optarg); break;
5571 case IDX_HEX_CHARSET: hex_charset = 1; break;
5572 case IDX_HEX_SALT: hex_salt = 1; break;
5573 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5574 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5575 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5576 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5577 case IDX_OPENCL_DEVICE_TYPES:
5578 opencl_device_types = optarg; break;
5579 case IDX_OPENCL_VECTOR_WIDTH:
5580 opencl_vector_width = atoi (optarg); break;
5581 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5582 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5583 kernel_accel_chgd = 1; break;
5584 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5585 kernel_loops_chgd = 1; break;
5586 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5587 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5588 gpu_temp_abort = atoi (optarg); break;
5589 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5590 gpu_temp_retain = atoi (optarg); break;
5591 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5592 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5593 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5594 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5595 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5596 case IDX_SEPARATOR: separator = optarg[0]; break;
5597 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5598 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5599 case IDX_INCREMENT: increment = 1; break;
5600 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5601 increment_min_chgd = 1; break;
5602 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5603 increment_max_chgd = 1; break;
5604 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5605 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5606 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5607 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5608
5609 default:
5610 log_error ("ERROR: Invalid argument specified");
5611 return (-1);
5612 }
5613 }
5614
5615 if (optopt != 0)
5616 {
5617 log_error ("ERROR: Invalid argument specified");
5618
5619 return (-1);
5620 }
5621
5622 /**
5623 * Inform user things getting started,
5624 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5625 * - we do not need to check algorithm_pos
5626 */
5627
5628 if (quiet == 0)
5629 {
5630 if (benchmark == 1)
5631 {
5632 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5633
5634 log_info ("");
5635 }
5636 else if (restore == 1)
5637 {
5638 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5639
5640 log_info ("");
5641 }
5642 else
5643 {
5644 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5645
5646 log_info ("");
5647 }
5648 }
5649
5650 /**
5651 * sanity check
5652 */
5653
5654 if (attack_mode > 7)
5655 {
5656 log_error ("ERROR: Invalid attack-mode specified");
5657
5658 return (-1);
5659 }
5660
5661 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5662 {
5663 log_error ("ERROR: Invalid runtime specified");
5664
5665 return (-1);
5666 }
5667
5668 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5669 {
5670 log_error ("ERROR: Invalid hash-type specified");
5671
5672 return (-1);
5673 }
5674
5675 // renamed hash modes
5676
5677 if (hash_mode_chgd)
5678 {
5679 int n = -1;
5680
5681 switch (hash_mode)
5682 {
5683 case 123: n = 124;
5684 break;
5685 }
5686
5687 if (n >= 0)
5688 {
5689 log_error ("Old -m specified, use -m %d instead", n);
5690
5691 return (-1);
5692 }
5693 }
5694
5695 if (username == 1)
5696 {
5697 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5698 {
5699 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5700
5701 return (-1);
5702 }
5703 }
5704
5705 if (outfile_format > 16)
5706 {
5707 log_error ("ERROR: Invalid outfile-format specified");
5708
5709 return (-1);
5710 }
5711
5712 if (left == 1)
5713 {
5714 if (outfile_format_chgd == 1)
5715 {
5716 if (outfile_format > 1)
5717 {
5718 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5719
5720 return (-1);
5721 }
5722 }
5723 else
5724 {
5725 outfile_format = OUTFILE_FMT_HASH;
5726 }
5727 }
5728
5729 if (show == 1)
5730 {
5731 if (outfile_format_chgd == 1)
5732 {
5733 if ((outfile_format > 7) && (outfile_format < 16))
5734 {
5735 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5736
5737 return (-1);
5738 }
5739 }
5740 }
5741
5742 if (increment_min < INCREMENT_MIN)
5743 {
5744 log_error ("ERROR: Invalid increment-min specified");
5745
5746 return (-1);
5747 }
5748
5749 if (increment_max > INCREMENT_MAX)
5750 {
5751 log_error ("ERROR: Invalid increment-max specified");
5752
5753 return (-1);
5754 }
5755
5756 if (increment_min > increment_max)
5757 {
5758 log_error ("ERROR: Invalid increment-min specified");
5759
5760 return (-1);
5761 }
5762
5763 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5764 {
5765 log_error ("ERROR: increment is not allowed in attack-mode 0");
5766
5767 return (-1);
5768 }
5769
5770 if ((increment == 0) && (increment_min_chgd == 1))
5771 {
5772 log_error ("ERROR: increment-min is only supported together with increment switch");
5773
5774 return (-1);
5775 }
5776
5777 if ((increment == 0) && (increment_max_chgd == 1))
5778 {
5779 log_error ("ERROR: increment-max is only supported together with increment switch");
5780
5781 return (-1);
5782 }
5783
5784 if (rp_files_cnt && rp_gen)
5785 {
5786 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5787
5788 return (-1);
5789 }
5790
5791 if (rp_files_cnt || rp_gen)
5792 {
5793 if (attack_mode != ATTACK_MODE_STRAIGHT)
5794 {
5795 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5796
5797 return (-1);
5798 }
5799 }
5800
5801 if (rp_gen_func_min > rp_gen_func_max)
5802 {
5803 log_error ("ERROR: Invalid rp-gen-func-min specified");
5804
5805 return (-1);
5806 }
5807
5808 if (kernel_accel_chgd == 1)
5809 {
5810 if (workload_profile != WORKLOAD_PROFILE)
5811 {
5812 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5813
5814 return (-1);
5815 }
5816
5817 if (kernel_accel < 1)
5818 {
5819 log_error ("ERROR: Invalid kernel-accel specified");
5820
5821 return (-1);
5822 }
5823
5824 if (kernel_accel > 800)
5825 {
5826 log_error ("ERROR: Invalid kernel-accel specified");
5827
5828 return (-1);
5829 }
5830 }
5831
5832 if (kernel_loops_chgd == 1)
5833 {
5834 if (workload_profile != WORKLOAD_PROFILE)
5835 {
5836 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5837
5838 return (-1);
5839 }
5840
5841 if (kernel_loops < 1)
5842 {
5843 log_error ("ERROR: Invalid kernel-loops specified");
5844
5845 return (-1);
5846 }
5847
5848 if (kernel_loops > 1024)
5849 {
5850 log_error ("ERROR: Invalid kernel-loops specified");
5851
5852 return (-1);
5853 }
5854 }
5855
5856 if (benchmark == 1)
5857 {
5858 if (workload_profile != WORKLOAD_PROFILE)
5859 {
5860 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5861
5862 return (-1);
5863 }
5864 }
5865
5866 if ((workload_profile < 1) || (workload_profile > 3))
5867 {
5868 log_error ("ERROR: workload-profile %i not available", workload_profile);
5869
5870 return (-1);
5871 }
5872
5873 if ((opencl_vector_width != 0) && (opencl_vector_width != 1) && (opencl_vector_width != 2) && (opencl_vector_width != 4) && (opencl_vector_width != 8))
5874 {
5875 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
5876
5877 return (-1);
5878 }
5879
5880 if (show == 1 || left == 1)
5881 {
5882 attack_mode = ATTACK_MODE_NONE;
5883
5884 if (remove == 1)
5885 {
5886 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5887
5888 return (-1);
5889 }
5890
5891 if (potfile_disable == 1)
5892 {
5893 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5894
5895 return (-1);
5896 }
5897 }
5898
5899 uint attack_kern = ATTACK_KERN_NONE;
5900
5901 switch (attack_mode)
5902 {
5903 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5904 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5905 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5906 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5907 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5908 }
5909
5910 if (benchmark == 0)
5911 {
5912 if (keyspace == 1)
5913 {
5914 int num_additional_params = 1;
5915
5916 if (attack_kern == ATTACK_KERN_COMBI)
5917 {
5918 num_additional_params = 2;
5919 }
5920
5921 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5922
5923 if (keyspace_wordlist_specified == 0) optind--;
5924 }
5925
5926 if (attack_kern == ATTACK_KERN_NONE)
5927 {
5928 if ((optind + 1) != myargc)
5929 {
5930 usage_mini_print (myargv[0]);
5931
5932 return (-1);
5933 }
5934 }
5935 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5936 {
5937 if ((optind + 1) > myargc)
5938 {
5939 usage_mini_print (myargv[0]);
5940
5941 return (-1);
5942 }
5943 }
5944 else if (attack_kern == ATTACK_KERN_COMBI)
5945 {
5946 if ((optind + 3) != myargc)
5947 {
5948 usage_mini_print (myargv[0]);
5949
5950 return (-1);
5951 }
5952 }
5953 else if (attack_kern == ATTACK_KERN_BF)
5954 {
5955 if ((optind + 1) > myargc)
5956 {
5957 usage_mini_print (myargv[0]);
5958
5959 return (-1);
5960 }
5961 }
5962 else
5963 {
5964 usage_mini_print (myargv[0]);
5965
5966 return (-1);
5967 }
5968 }
5969 else
5970 {
5971 if (myargv[optind] != 0)
5972 {
5973 log_error ("ERROR: Invalid argument for benchmark mode specified");
5974
5975 return (-1);
5976 }
5977
5978 if (attack_mode_chgd == 1)
5979 {
5980 if (attack_mode != ATTACK_MODE_BF)
5981 {
5982 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5983
5984 return (-1);
5985 }
5986 }
5987
5988 if (benchmark_mode == 0)
5989 {
5990 // nothing to do
5991 }
5992 else if (benchmark_mode == 1)
5993 {
5994 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5995 {
5996 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5997
5998 return (-1);
5999 }
6000 }
6001 else
6002 {
6003 log_error ("ERROR: Benchmark-mode must be 0 or 1");
6004
6005 return (-1);
6006 }
6007 }
6008
6009 if (skip != 0 && limit != 0)
6010 {
6011 limit += skip;
6012 }
6013
6014 if (keyspace == 1)
6015 {
6016 if (show == 1)
6017 {
6018 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6019
6020 return (-1);
6021 }
6022 else if (left == 1)
6023 {
6024 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6025
6026 return (-1);
6027 }
6028
6029 potfile_disable = 1;
6030
6031 restore_disable = 1;
6032
6033 restore = 0;
6034
6035 weak_hash_threshold = 0;
6036
6037 quiet = 1;
6038 }
6039
6040 if (remove_timer_chgd == 1)
6041 {
6042 if (remove == 0)
6043 {
6044 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6045
6046 return (-1);
6047 }
6048
6049 if (remove_timer < 1)
6050 {
6051 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6052
6053 return (-1);
6054 }
6055 }
6056
6057 if (loopback == 1)
6058 {
6059 if (attack_mode == ATTACK_MODE_BF)
6060 {
6061 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6062
6063 return (-1);
6064 }
6065 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6066 {
6067 if ((rp_files_cnt == 0) && (rp_gen == 0))
6068 {
6069 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6070
6071 return (-1);
6072 }
6073 }
6074 }
6075
6076 if (debug_mode > 0)
6077 {
6078 if (attack_mode != ATTACK_MODE_STRAIGHT)
6079 {
6080 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6081
6082 return (-1);
6083 }
6084
6085 if ((rp_files_cnt == 0) && (rp_gen == 0))
6086 {
6087 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6088
6089 return (-1);
6090 }
6091 }
6092
6093 if (debug_mode > 4)
6094 {
6095 log_error ("ERROR: Invalid debug-mode specified");
6096
6097 return (-1);
6098 }
6099
6100 if (debug_file != NULL)
6101 {
6102 if (debug_mode < 1)
6103 {
6104 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6105
6106 return (-1);
6107 }
6108 }
6109
6110 if (induction_dir != NULL)
6111 {
6112 if (attack_mode == ATTACK_MODE_BF)
6113 {
6114 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6115
6116 return (-1);
6117 }
6118 }
6119
6120 if (attack_mode != ATTACK_MODE_STRAIGHT)
6121 {
6122 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6123 {
6124 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6125
6126 return (-1);
6127 }
6128
6129 weak_hash_threshold = 0;
6130 }
6131
6132 /**
6133 * induction directory
6134 */
6135
6136 char *induction_directory = NULL;
6137
6138 if (attack_mode != ATTACK_MODE_BF)
6139 {
6140 if (induction_dir == NULL)
6141 {
6142 induction_directory = (char *) mymalloc (session_size);
6143
6144 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6145
6146 // create induction folder if it does not already exist
6147
6148 if (keyspace == 0)
6149 {
6150 if (rmdir (induction_directory) == -1)
6151 {
6152 if (errno == ENOENT)
6153 {
6154 // good, we can ignore
6155 }
6156 else if (errno == ENOTEMPTY)
6157 {
6158 char *induction_directory_mv = (char *) mymalloc (session_size);
6159
6160 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6161
6162 if (rename (induction_directory, induction_directory_mv) != 0)
6163 {
6164 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6165
6166 return (-1);
6167 }
6168 }
6169 else
6170 {
6171 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6172
6173 return (-1);
6174 }
6175 }
6176
6177 if (mkdir (induction_directory, 0700) == -1)
6178 {
6179 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6180
6181 return (-1);
6182 }
6183 }
6184 }
6185 else
6186 {
6187 induction_directory = induction_dir;
6188 }
6189 }
6190
6191 data.induction_directory = induction_directory;
6192
6193 /**
6194 * loopback
6195 */
6196
6197 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6198
6199 char *loopback_file = (char *) mymalloc (loopback_size);
6200
6201 /**
6202 * outfile-check directory
6203 */
6204
6205 char *outfile_check_directory = NULL;
6206
6207 if (outfile_check_dir == NULL)
6208 {
6209 outfile_check_directory = (char *) mymalloc (session_size);
6210
6211 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6212 }
6213 else
6214 {
6215 outfile_check_directory = outfile_check_dir;
6216 }
6217
6218 data.outfile_check_directory = outfile_check_directory;
6219
6220 if (keyspace == 0)
6221 {
6222 struct stat outfile_check_stat;
6223
6224 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6225 {
6226 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6227
6228 if (is_dir == 0)
6229 {
6230 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6231
6232 return (-1);
6233 }
6234 }
6235 else if (outfile_check_dir == NULL)
6236 {
6237 if (mkdir (outfile_check_directory, 0700) == -1)
6238 {
6239 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6240
6241 return (-1);
6242 }
6243 }
6244 }
6245
6246 /**
6247 * special other stuff
6248 */
6249
6250 if (hash_mode == 9710)
6251 {
6252 outfile_format = 5;
6253 outfile_format_chgd = 1;
6254 }
6255
6256 if (hash_mode == 9810)
6257 {
6258 outfile_format = 5;
6259 outfile_format_chgd = 1;
6260 }
6261
6262 if (hash_mode == 10410)
6263 {
6264 outfile_format = 5;
6265 outfile_format_chgd = 1;
6266 }
6267
6268 /**
6269 * store stuff
6270 */
6271
6272 data.hash_mode = hash_mode;
6273 data.restore = restore;
6274 data.restore_timer = restore_timer;
6275 data.restore_disable = restore_disable;
6276 data.status = status;
6277 data.status_timer = status_timer;
6278 data.status_automat = status_automat;
6279 data.loopback = loopback;
6280 data.runtime = runtime;
6281 data.remove = remove;
6282 data.remove_timer = remove_timer;
6283 data.debug_mode = debug_mode;
6284 data.debug_file = debug_file;
6285 data.username = username;
6286 data.quiet = quiet;
6287 data.outfile = outfile;
6288 data.outfile_format = outfile_format;
6289 data.outfile_autohex = outfile_autohex;
6290 data.hex_charset = hex_charset;
6291 data.hex_salt = hex_salt;
6292 data.hex_wordlist = hex_wordlist;
6293 data.separator = separator;
6294 data.rp_files = rp_files;
6295 data.rp_files_cnt = rp_files_cnt;
6296 data.rp_gen = rp_gen;
6297 data.rp_gen_seed = rp_gen_seed;
6298 data.force = force;
6299 data.benchmark = benchmark;
6300 data.skip = skip;
6301 data.limit = limit;
6302 data.powertune_enable = powertune_enable;
6303 data.logfile_disable = logfile_disable;
6304 data.truecrypt_keyfiles = truecrypt_keyfiles;
6305 data.scrypt_tmto = scrypt_tmto;
6306
6307 /**
6308 * cpu affinity
6309 */
6310
6311 if (cpu_affinity)
6312 {
6313 set_cpu_affinity (cpu_affinity);
6314 }
6315
6316 if (rp_gen_seed_chgd == 0)
6317 {
6318 srand (proc_start);
6319 }
6320 else
6321 {
6322 srand (rp_gen_seed);
6323 }
6324
6325 /**
6326 * logfile init
6327 */
6328
6329 if (logfile_disable == 0)
6330 {
6331 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6332
6333 char *logfile = (char *) mymalloc (logfile_size);
6334
6335 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6336
6337 data.logfile = logfile;
6338
6339 char *topid = logfile_generate_topid ();
6340
6341 data.topid = topid;
6342 }
6343
6344 // logfile_append() checks for logfile_disable internally to make it easier from here
6345
6346 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6347 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6348 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6349 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6350 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6351 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6352 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6353 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6354 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6355 #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));
6356
6357 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6358 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6359 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6360 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6361 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6362 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6363 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6364 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6365
6366 logfile_top_msg ("START");
6367
6368 logfile_top_uint (attack_mode);
6369 logfile_top_uint (attack_kern);
6370 logfile_top_uint (benchmark);
6371 logfile_top_uint (benchmark_mode);
6372 logfile_top_uint (bitmap_min);
6373 logfile_top_uint (bitmap_max);
6374 logfile_top_uint (debug_mode);
6375 logfile_top_uint (force);
6376 logfile_top_uint (kernel_accel);
6377 logfile_top_uint (kernel_loops);
6378 logfile_top_uint (gpu_temp_abort);
6379 logfile_top_uint (gpu_temp_disable);
6380 logfile_top_uint (gpu_temp_retain);
6381 logfile_top_uint (hash_mode);
6382 logfile_top_uint (hex_charset);
6383 logfile_top_uint (hex_salt);
6384 logfile_top_uint (hex_wordlist);
6385 logfile_top_uint (increment);
6386 logfile_top_uint (increment_max);
6387 logfile_top_uint (increment_min);
6388 logfile_top_uint (keyspace);
6389 logfile_top_uint (left);
6390 logfile_top_uint (logfile_disable);
6391 logfile_top_uint (loopback);
6392 logfile_top_uint (markov_classic);
6393 logfile_top_uint (markov_disable);
6394 logfile_top_uint (markov_threshold);
6395 logfile_top_uint (outfile_autohex);
6396 logfile_top_uint (outfile_check_timer);
6397 logfile_top_uint (outfile_format);
6398 logfile_top_uint (potfile_disable);
6399 logfile_top_uint (powertune_enable);
6400 logfile_top_uint (scrypt_tmto);
6401 logfile_top_uint (quiet);
6402 logfile_top_uint (remove);
6403 logfile_top_uint (remove_timer);
6404 logfile_top_uint (restore);
6405 logfile_top_uint (restore_disable);
6406 logfile_top_uint (restore_timer);
6407 logfile_top_uint (rp_gen);
6408 logfile_top_uint (rp_gen_func_max);
6409 logfile_top_uint (rp_gen_func_min);
6410 logfile_top_uint (rp_gen_seed);
6411 logfile_top_uint (runtime);
6412 logfile_top_uint (segment_size);
6413 logfile_top_uint (show);
6414 logfile_top_uint (status);
6415 logfile_top_uint (status_automat);
6416 logfile_top_uint (status_timer);
6417 logfile_top_uint (usage);
6418 logfile_top_uint (username);
6419 logfile_top_uint (version);
6420 logfile_top_uint (weak_hash_threshold);
6421 logfile_top_uint (workload_profile);
6422 logfile_top_uint64 (limit);
6423 logfile_top_uint64 (skip);
6424 logfile_top_char (separator);
6425 logfile_top_string (cpu_affinity);
6426 logfile_top_string (custom_charset_1);
6427 logfile_top_string (custom_charset_2);
6428 logfile_top_string (custom_charset_3);
6429 logfile_top_string (custom_charset_4);
6430 logfile_top_string (debug_file);
6431 logfile_top_string (opencl_devices);
6432 logfile_top_string (opencl_platforms);
6433 logfile_top_string (opencl_device_types);
6434 logfile_top_uint (opencl_vector_width);
6435 logfile_top_string (induction_dir);
6436 logfile_top_string (markov_hcstat);
6437 logfile_top_string (outfile);
6438 logfile_top_string (outfile_check_dir);
6439 logfile_top_string (rule_buf_l);
6440 logfile_top_string (rule_buf_r);
6441 logfile_top_string (session);
6442 logfile_top_string (truecrypt_keyfiles);
6443
6444 /**
6445 * OpenCL platform selection
6446 */
6447
6448 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6449
6450 /**
6451 * OpenCL device selection
6452 */
6453
6454 u32 devices_filter = setup_devices_filter (opencl_devices);
6455
6456 /**
6457 * OpenCL device type selection
6458 */
6459
6460 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6461
6462 /**
6463 * benchmark
6464 */
6465
6466 if (benchmark == 1)
6467 {
6468 /**
6469 * disable useless stuff for benchmark
6470 */
6471
6472 restore_timer = 0;
6473 status_timer = 0;
6474 restore_disable = 1;
6475 potfile_disable = 1;
6476 weak_hash_threshold = 0;
6477
6478 data.restore_timer = restore_timer;
6479 data.status_timer = status_timer;
6480 data.restore_disable = restore_disable;
6481
6482 if (benchmark_mode == 1)
6483 {
6484 markov_disable = 1;
6485 }
6486
6487 /**
6488 * force attack mode to be bruteforce
6489 */
6490
6491 attack_mode = ATTACK_MODE_BF;
6492 attack_kern = ATTACK_KERN_BF;
6493
6494 if (runtime_chgd == 0)
6495 {
6496 runtime = 4;
6497
6498 if (benchmark_mode == 1) runtime = 17;
6499
6500 data.runtime = runtime;
6501 }
6502 }
6503
6504 /**
6505 * config
6506 */
6507
6508 uint hash_type = 0;
6509 uint salt_type = 0;
6510 uint attack_exec = 0;
6511 uint opts_type = 0;
6512 uint kern_type = 0;
6513 uint dgst_size = 0;
6514 uint esalt_size = 0;
6515 uint opti_type = 0;
6516 uint dgst_pos0 = -1;
6517 uint dgst_pos1 = -1;
6518 uint dgst_pos2 = -1;
6519 uint dgst_pos3 = -1;
6520
6521 int (*parse_func) (char *, uint, hash_t *);
6522 int (*sort_by_digest) (const void *, const void *);
6523
6524 uint algorithm_pos = 0;
6525 uint algorithm_max = 1;
6526
6527 uint *algorithms = default_benchmark_algorithms;
6528
6529 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6530
6531 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6532 {
6533 /*
6534 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6535 * the following algos are skipped entirely
6536 */
6537
6538 if (algorithm_pos > 0)
6539 {
6540 local_free (rd);
6541
6542 rd = init_restore (argc, argv);
6543
6544 data.rd = rd;
6545 }
6546
6547 /**
6548 * update hash_mode in case of multihash benchmark
6549 */
6550
6551 if (benchmark == 1)
6552 {
6553 if (hash_mode_chgd == 0)
6554 {
6555 hash_mode = algorithms[algorithm_pos];
6556
6557 data.hash_mode = hash_mode;
6558 }
6559
6560 quiet = 1;
6561
6562 data.quiet = quiet;
6563 }
6564
6565 switch (hash_mode)
6566 {
6567 case 0: hash_type = HASH_TYPE_MD5;
6568 salt_type = SALT_TYPE_NONE;
6569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6570 opts_type = OPTS_TYPE_PT_GENERATE_LE
6571 | OPTS_TYPE_PT_ADD80
6572 | OPTS_TYPE_PT_ADDBITS14;
6573 kern_type = KERN_TYPE_MD5;
6574 dgst_size = DGST_SIZE_4_4;
6575 parse_func = md5_parse_hash;
6576 sort_by_digest = sort_by_digest_4_4;
6577 opti_type = OPTI_TYPE_ZERO_BYTE
6578 | OPTI_TYPE_PRECOMPUTE_INIT
6579 | OPTI_TYPE_PRECOMPUTE_MERKLE
6580 | OPTI_TYPE_MEET_IN_MIDDLE
6581 | OPTI_TYPE_EARLY_SKIP
6582 | OPTI_TYPE_NOT_ITERATED
6583 | OPTI_TYPE_NOT_SALTED
6584 | OPTI_TYPE_RAW_HASH;
6585 dgst_pos0 = 0;
6586 dgst_pos1 = 3;
6587 dgst_pos2 = 2;
6588 dgst_pos3 = 1;
6589 break;
6590
6591 case 10: hash_type = HASH_TYPE_MD5;
6592 salt_type = SALT_TYPE_INTERN;
6593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6594 opts_type = OPTS_TYPE_PT_GENERATE_LE
6595 | OPTS_TYPE_ST_ADD80
6596 | OPTS_TYPE_ST_ADDBITS14;
6597 kern_type = KERN_TYPE_MD5_PWSLT;
6598 dgst_size = DGST_SIZE_4_4;
6599 parse_func = md5s_parse_hash;
6600 sort_by_digest = sort_by_digest_4_4;
6601 opti_type = OPTI_TYPE_ZERO_BYTE
6602 | OPTI_TYPE_PRECOMPUTE_INIT
6603 | OPTI_TYPE_PRECOMPUTE_MERKLE
6604 | OPTI_TYPE_MEET_IN_MIDDLE
6605 | OPTI_TYPE_EARLY_SKIP
6606 | OPTI_TYPE_NOT_ITERATED
6607 | OPTI_TYPE_APPENDED_SALT
6608 | OPTI_TYPE_RAW_HASH;
6609 dgst_pos0 = 0;
6610 dgst_pos1 = 3;
6611 dgst_pos2 = 2;
6612 dgst_pos3 = 1;
6613 break;
6614
6615 case 11: hash_type = HASH_TYPE_MD5;
6616 salt_type = SALT_TYPE_INTERN;
6617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6618 opts_type = OPTS_TYPE_PT_GENERATE_LE
6619 | OPTS_TYPE_ST_ADD80
6620 | OPTS_TYPE_ST_ADDBITS14;
6621 kern_type = KERN_TYPE_MD5_PWSLT;
6622 dgst_size = DGST_SIZE_4_4;
6623 parse_func = joomla_parse_hash;
6624 sort_by_digest = sort_by_digest_4_4;
6625 opti_type = OPTI_TYPE_ZERO_BYTE
6626 | OPTI_TYPE_PRECOMPUTE_INIT
6627 | OPTI_TYPE_PRECOMPUTE_MERKLE
6628 | OPTI_TYPE_MEET_IN_MIDDLE
6629 | OPTI_TYPE_EARLY_SKIP
6630 | OPTI_TYPE_NOT_ITERATED
6631 | OPTI_TYPE_APPENDED_SALT
6632 | OPTI_TYPE_RAW_HASH;
6633 dgst_pos0 = 0;
6634 dgst_pos1 = 3;
6635 dgst_pos2 = 2;
6636 dgst_pos3 = 1;
6637 break;
6638
6639 case 12: hash_type = HASH_TYPE_MD5;
6640 salt_type = SALT_TYPE_INTERN;
6641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6642 opts_type = OPTS_TYPE_PT_GENERATE_LE
6643 | OPTS_TYPE_ST_ADD80
6644 | OPTS_TYPE_ST_ADDBITS14;
6645 kern_type = KERN_TYPE_MD5_PWSLT;
6646 dgst_size = DGST_SIZE_4_4;
6647 parse_func = postgresql_parse_hash;
6648 sort_by_digest = sort_by_digest_4_4;
6649 opti_type = OPTI_TYPE_ZERO_BYTE
6650 | OPTI_TYPE_PRECOMPUTE_INIT
6651 | OPTI_TYPE_PRECOMPUTE_MERKLE
6652 | OPTI_TYPE_MEET_IN_MIDDLE
6653 | OPTI_TYPE_EARLY_SKIP
6654 | OPTI_TYPE_NOT_ITERATED
6655 | OPTI_TYPE_APPENDED_SALT
6656 | OPTI_TYPE_RAW_HASH;
6657 dgst_pos0 = 0;
6658 dgst_pos1 = 3;
6659 dgst_pos2 = 2;
6660 dgst_pos3 = 1;
6661 break;
6662
6663 case 20: hash_type = HASH_TYPE_MD5;
6664 salt_type = SALT_TYPE_INTERN;
6665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6666 opts_type = OPTS_TYPE_PT_GENERATE_LE
6667 | OPTS_TYPE_PT_ADD80
6668 | OPTS_TYPE_PT_ADDBITS14;
6669 kern_type = KERN_TYPE_MD5_SLTPW;
6670 dgst_size = DGST_SIZE_4_4;
6671 parse_func = md5s_parse_hash;
6672 sort_by_digest = sort_by_digest_4_4;
6673 opti_type = OPTI_TYPE_ZERO_BYTE
6674 | OPTI_TYPE_PRECOMPUTE_INIT
6675 | OPTI_TYPE_PRECOMPUTE_MERKLE
6676 | OPTI_TYPE_EARLY_SKIP
6677 | OPTI_TYPE_NOT_ITERATED
6678 | OPTI_TYPE_PREPENDED_SALT
6679 | OPTI_TYPE_RAW_HASH;
6680 dgst_pos0 = 0;
6681 dgst_pos1 = 3;
6682 dgst_pos2 = 2;
6683 dgst_pos3 = 1;
6684 break;
6685
6686 case 21: hash_type = HASH_TYPE_MD5;
6687 salt_type = SALT_TYPE_INTERN;
6688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6689 opts_type = OPTS_TYPE_PT_GENERATE_LE
6690 | OPTS_TYPE_PT_ADD80
6691 | OPTS_TYPE_PT_ADDBITS14;
6692 kern_type = KERN_TYPE_MD5_SLTPW;
6693 dgst_size = DGST_SIZE_4_4;
6694 parse_func = osc_parse_hash;
6695 sort_by_digest = sort_by_digest_4_4;
6696 opti_type = OPTI_TYPE_ZERO_BYTE
6697 | OPTI_TYPE_PRECOMPUTE_INIT
6698 | OPTI_TYPE_PRECOMPUTE_MERKLE
6699 | OPTI_TYPE_EARLY_SKIP
6700 | OPTI_TYPE_NOT_ITERATED
6701 | OPTI_TYPE_PREPENDED_SALT
6702 | OPTI_TYPE_RAW_HASH;
6703 dgst_pos0 = 0;
6704 dgst_pos1 = 3;
6705 dgst_pos2 = 2;
6706 dgst_pos3 = 1;
6707 break;
6708
6709 case 22: hash_type = HASH_TYPE_MD5;
6710 salt_type = SALT_TYPE_EMBEDDED;
6711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6712 opts_type = OPTS_TYPE_PT_GENERATE_LE
6713 | OPTS_TYPE_PT_ADD80
6714 | OPTS_TYPE_PT_ADDBITS14;
6715 kern_type = KERN_TYPE_MD5_SLTPW;
6716 dgst_size = DGST_SIZE_4_4;
6717 parse_func = netscreen_parse_hash;
6718 sort_by_digest = sort_by_digest_4_4;
6719 opti_type = OPTI_TYPE_ZERO_BYTE
6720 | OPTI_TYPE_PRECOMPUTE_INIT
6721 | OPTI_TYPE_PRECOMPUTE_MERKLE
6722 | OPTI_TYPE_EARLY_SKIP
6723 | OPTI_TYPE_NOT_ITERATED
6724 | OPTI_TYPE_PREPENDED_SALT
6725 | OPTI_TYPE_RAW_HASH;
6726 dgst_pos0 = 0;
6727 dgst_pos1 = 3;
6728 dgst_pos2 = 2;
6729 dgst_pos3 = 1;
6730 break;
6731
6732 case 23: hash_type = HASH_TYPE_MD5;
6733 salt_type = SALT_TYPE_EMBEDDED;
6734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6735 opts_type = OPTS_TYPE_PT_GENERATE_LE
6736 | OPTS_TYPE_PT_ADD80
6737 | OPTS_TYPE_PT_ADDBITS14;
6738 kern_type = KERN_TYPE_MD5_SLTPW;
6739 dgst_size = DGST_SIZE_4_4;
6740 parse_func = skype_parse_hash;
6741 sort_by_digest = sort_by_digest_4_4;
6742 opti_type = OPTI_TYPE_ZERO_BYTE
6743 | OPTI_TYPE_PRECOMPUTE_INIT
6744 | OPTI_TYPE_PRECOMPUTE_MERKLE
6745 | OPTI_TYPE_EARLY_SKIP
6746 | OPTI_TYPE_NOT_ITERATED
6747 | OPTI_TYPE_PREPENDED_SALT
6748 | OPTI_TYPE_RAW_HASH;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 30: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_INTERN;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_UNICODE
6760 | OPTS_TYPE_ST_ADD80
6761 | OPTS_TYPE_ST_ADDBITS14;
6762 kern_type = KERN_TYPE_MD5_PWUSLT;
6763 dgst_size = DGST_SIZE_4_4;
6764 parse_func = md5s_parse_hash;
6765 sort_by_digest = sort_by_digest_4_4;
6766 opti_type = OPTI_TYPE_ZERO_BYTE
6767 | OPTI_TYPE_PRECOMPUTE_INIT
6768 | OPTI_TYPE_PRECOMPUTE_MERKLE
6769 | OPTI_TYPE_MEET_IN_MIDDLE
6770 | OPTI_TYPE_EARLY_SKIP
6771 | OPTI_TYPE_NOT_ITERATED
6772 | OPTI_TYPE_APPENDED_SALT
6773 | OPTI_TYPE_RAW_HASH;
6774 dgst_pos0 = 0;
6775 dgst_pos1 = 3;
6776 dgst_pos2 = 2;
6777 dgst_pos3 = 1;
6778 break;
6779
6780 case 40: hash_type = HASH_TYPE_MD5;
6781 salt_type = SALT_TYPE_INTERN;
6782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6783 opts_type = OPTS_TYPE_PT_GENERATE_LE
6784 | OPTS_TYPE_PT_ADD80
6785 | OPTS_TYPE_PT_ADDBITS14
6786 | OPTS_TYPE_PT_UNICODE;
6787 kern_type = KERN_TYPE_MD5_SLTPWU;
6788 dgst_size = DGST_SIZE_4_4;
6789 parse_func = md5s_parse_hash;
6790 sort_by_digest = sort_by_digest_4_4;
6791 opti_type = OPTI_TYPE_ZERO_BYTE
6792 | OPTI_TYPE_PRECOMPUTE_INIT
6793 | OPTI_TYPE_PRECOMPUTE_MERKLE
6794 | OPTI_TYPE_EARLY_SKIP
6795 | OPTI_TYPE_NOT_ITERATED
6796 | OPTI_TYPE_PREPENDED_SALT
6797 | OPTI_TYPE_RAW_HASH;
6798 dgst_pos0 = 0;
6799 dgst_pos1 = 3;
6800 dgst_pos2 = 2;
6801 dgst_pos3 = 1;
6802 break;
6803
6804 case 50: hash_type = HASH_TYPE_MD5;
6805 salt_type = SALT_TYPE_INTERN;
6806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6807 opts_type = OPTS_TYPE_PT_GENERATE_LE
6808 | OPTS_TYPE_ST_ADD80
6809 | OPTS_TYPE_ST_ADDBITS14;
6810 kern_type = KERN_TYPE_HMACMD5_PW;
6811 dgst_size = DGST_SIZE_4_4;
6812 parse_func = hmacmd5_parse_hash;
6813 sort_by_digest = sort_by_digest_4_4;
6814 opti_type = OPTI_TYPE_ZERO_BYTE
6815 | OPTI_TYPE_NOT_ITERATED;
6816 dgst_pos0 = 0;
6817 dgst_pos1 = 3;
6818 dgst_pos2 = 2;
6819 dgst_pos3 = 1;
6820 break;
6821
6822 case 60: hash_type = HASH_TYPE_MD5;
6823 salt_type = SALT_TYPE_INTERN;
6824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6825 opts_type = OPTS_TYPE_PT_GENERATE_LE
6826 | OPTS_TYPE_PT_ADD80
6827 | OPTS_TYPE_PT_ADDBITS14;
6828 kern_type = KERN_TYPE_HMACMD5_SLT;
6829 dgst_size = DGST_SIZE_4_4;
6830 parse_func = hmacmd5_parse_hash;
6831 sort_by_digest = sort_by_digest_4_4;
6832 opti_type = OPTI_TYPE_ZERO_BYTE
6833 | OPTI_TYPE_NOT_ITERATED;
6834 dgst_pos0 = 0;
6835 dgst_pos1 = 3;
6836 dgst_pos2 = 2;
6837 dgst_pos3 = 1;
6838 break;
6839
6840 case 100: hash_type = HASH_TYPE_SHA1;
6841 salt_type = SALT_TYPE_NONE;
6842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6843 opts_type = OPTS_TYPE_PT_GENERATE_BE
6844 | OPTS_TYPE_PT_ADD80
6845 | OPTS_TYPE_PT_ADDBITS15;
6846 kern_type = KERN_TYPE_SHA1;
6847 dgst_size = DGST_SIZE_4_5;
6848 parse_func = sha1_parse_hash;
6849 sort_by_digest = sort_by_digest_4_5;
6850 opti_type = OPTI_TYPE_ZERO_BYTE
6851 | OPTI_TYPE_PRECOMPUTE_INIT
6852 | OPTI_TYPE_PRECOMPUTE_MERKLE
6853 | OPTI_TYPE_EARLY_SKIP
6854 | OPTI_TYPE_NOT_ITERATED
6855 | OPTI_TYPE_NOT_SALTED
6856 | OPTI_TYPE_RAW_HASH;
6857 dgst_pos0 = 3;
6858 dgst_pos1 = 4;
6859 dgst_pos2 = 2;
6860 dgst_pos3 = 1;
6861 break;
6862
6863 case 101: hash_type = HASH_TYPE_SHA1;
6864 salt_type = SALT_TYPE_NONE;
6865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6866 opts_type = OPTS_TYPE_PT_GENERATE_BE
6867 | OPTS_TYPE_PT_ADD80
6868 | OPTS_TYPE_PT_ADDBITS15;
6869 kern_type = KERN_TYPE_SHA1;
6870 dgst_size = DGST_SIZE_4_5;
6871 parse_func = sha1b64_parse_hash;
6872 sort_by_digest = sort_by_digest_4_5;
6873 opti_type = OPTI_TYPE_ZERO_BYTE
6874 | OPTI_TYPE_PRECOMPUTE_INIT
6875 | OPTI_TYPE_PRECOMPUTE_MERKLE
6876 | OPTI_TYPE_EARLY_SKIP
6877 | OPTI_TYPE_NOT_ITERATED
6878 | OPTI_TYPE_NOT_SALTED
6879 | OPTI_TYPE_RAW_HASH;
6880 dgst_pos0 = 3;
6881 dgst_pos1 = 4;
6882 dgst_pos2 = 2;
6883 dgst_pos3 = 1;
6884 break;
6885
6886 case 110: hash_type = HASH_TYPE_SHA1;
6887 salt_type = SALT_TYPE_INTERN;
6888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6889 opts_type = OPTS_TYPE_PT_GENERATE_BE
6890 | OPTS_TYPE_ST_ADD80
6891 | OPTS_TYPE_ST_ADDBITS15;
6892 kern_type = KERN_TYPE_SHA1_PWSLT;
6893 dgst_size = DGST_SIZE_4_5;
6894 parse_func = sha1s_parse_hash;
6895 sort_by_digest = sort_by_digest_4_5;
6896 opti_type = OPTI_TYPE_ZERO_BYTE
6897 | OPTI_TYPE_PRECOMPUTE_INIT
6898 | OPTI_TYPE_PRECOMPUTE_MERKLE
6899 | OPTI_TYPE_EARLY_SKIP
6900 | OPTI_TYPE_NOT_ITERATED
6901 | OPTI_TYPE_APPENDED_SALT
6902 | OPTI_TYPE_RAW_HASH;
6903 dgst_pos0 = 3;
6904 dgst_pos1 = 4;
6905 dgst_pos2 = 2;
6906 dgst_pos3 = 1;
6907 break;
6908
6909 case 111: hash_type = HASH_TYPE_SHA1;
6910 salt_type = SALT_TYPE_EMBEDDED;
6911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6912 opts_type = OPTS_TYPE_PT_GENERATE_BE
6913 | OPTS_TYPE_ST_ADD80
6914 | OPTS_TYPE_ST_ADDBITS15;
6915 kern_type = KERN_TYPE_SHA1_PWSLT;
6916 dgst_size = DGST_SIZE_4_5;
6917 parse_func = sha1b64s_parse_hash;
6918 sort_by_digest = sort_by_digest_4_5;
6919 opti_type = OPTI_TYPE_ZERO_BYTE
6920 | OPTI_TYPE_PRECOMPUTE_INIT
6921 | OPTI_TYPE_PRECOMPUTE_MERKLE
6922 | OPTI_TYPE_EARLY_SKIP
6923 | OPTI_TYPE_NOT_ITERATED
6924 | OPTI_TYPE_APPENDED_SALT
6925 | OPTI_TYPE_RAW_HASH;
6926 dgst_pos0 = 3;
6927 dgst_pos1 = 4;
6928 dgst_pos2 = 2;
6929 dgst_pos3 = 1;
6930 break;
6931
6932 case 112: hash_type = HASH_TYPE_SHA1;
6933 salt_type = SALT_TYPE_INTERN;
6934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6935 opts_type = OPTS_TYPE_PT_GENERATE_BE
6936 | OPTS_TYPE_ST_ADD80
6937 | OPTS_TYPE_ST_ADDBITS15
6938 | OPTS_TYPE_ST_HEX;
6939 kern_type = KERN_TYPE_SHA1_PWSLT;
6940 dgst_size = DGST_SIZE_4_5;
6941 parse_func = oracles_parse_hash;
6942 sort_by_digest = sort_by_digest_4_5;
6943 opti_type = OPTI_TYPE_ZERO_BYTE
6944 | OPTI_TYPE_PRECOMPUTE_INIT
6945 | OPTI_TYPE_PRECOMPUTE_MERKLE
6946 | OPTI_TYPE_EARLY_SKIP
6947 | OPTI_TYPE_NOT_ITERATED
6948 | OPTI_TYPE_APPENDED_SALT
6949 | OPTI_TYPE_RAW_HASH;
6950 dgst_pos0 = 3;
6951 dgst_pos1 = 4;
6952 dgst_pos2 = 2;
6953 dgst_pos3 = 1;
6954 break;
6955
6956 case 120: hash_type = HASH_TYPE_SHA1;
6957 salt_type = SALT_TYPE_INTERN;
6958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6959 opts_type = OPTS_TYPE_PT_GENERATE_BE
6960 | OPTS_TYPE_PT_ADD80
6961 | OPTS_TYPE_PT_ADDBITS15;
6962 kern_type = KERN_TYPE_SHA1_SLTPW;
6963 dgst_size = DGST_SIZE_4_5;
6964 parse_func = sha1s_parse_hash;
6965 sort_by_digest = sort_by_digest_4_5;
6966 opti_type = OPTI_TYPE_ZERO_BYTE
6967 | OPTI_TYPE_PRECOMPUTE_INIT
6968 | OPTI_TYPE_PRECOMPUTE_MERKLE
6969 | OPTI_TYPE_EARLY_SKIP
6970 | OPTI_TYPE_NOT_ITERATED
6971 | OPTI_TYPE_PREPENDED_SALT
6972 | OPTI_TYPE_RAW_HASH;
6973 dgst_pos0 = 3;
6974 dgst_pos1 = 4;
6975 dgst_pos2 = 2;
6976 dgst_pos3 = 1;
6977 break;
6978
6979 case 121: hash_type = HASH_TYPE_SHA1;
6980 salt_type = SALT_TYPE_INTERN;
6981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6982 opts_type = OPTS_TYPE_PT_GENERATE_BE
6983 | OPTS_TYPE_PT_ADD80
6984 | OPTS_TYPE_PT_ADDBITS15
6985 | OPTS_TYPE_ST_LOWER;
6986 kern_type = KERN_TYPE_SHA1_SLTPW;
6987 dgst_size = DGST_SIZE_4_5;
6988 parse_func = smf_parse_hash;
6989 sort_by_digest = sort_by_digest_4_5;
6990 opti_type = OPTI_TYPE_ZERO_BYTE
6991 | OPTI_TYPE_PRECOMPUTE_INIT
6992 | OPTI_TYPE_PRECOMPUTE_MERKLE
6993 | OPTI_TYPE_EARLY_SKIP
6994 | OPTI_TYPE_NOT_ITERATED
6995 | OPTI_TYPE_PREPENDED_SALT
6996 | OPTI_TYPE_RAW_HASH;
6997 dgst_pos0 = 3;
6998 dgst_pos1 = 4;
6999 dgst_pos2 = 2;
7000 dgst_pos3 = 1;
7001 break;
7002
7003 case 122: hash_type = HASH_TYPE_SHA1;
7004 salt_type = SALT_TYPE_EMBEDDED;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_BE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS15
7009 | OPTS_TYPE_ST_HEX;
7010 kern_type = KERN_TYPE_SHA1_SLTPW;
7011 dgst_size = DGST_SIZE_4_5;
7012 parse_func = osx1_parse_hash;
7013 sort_by_digest = sort_by_digest_4_5;
7014 opti_type = OPTI_TYPE_ZERO_BYTE
7015 | OPTI_TYPE_PRECOMPUTE_INIT
7016 | OPTI_TYPE_PRECOMPUTE_MERKLE
7017 | OPTI_TYPE_EARLY_SKIP
7018 | OPTI_TYPE_NOT_ITERATED
7019 | OPTI_TYPE_PREPENDED_SALT
7020 | OPTI_TYPE_RAW_HASH;
7021 dgst_pos0 = 3;
7022 dgst_pos1 = 4;
7023 dgst_pos2 = 2;
7024 dgst_pos3 = 1;
7025 break;
7026
7027 case 124: hash_type = HASH_TYPE_SHA1;
7028 salt_type = SALT_TYPE_EMBEDDED;
7029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7030 opts_type = OPTS_TYPE_PT_GENERATE_BE
7031 | OPTS_TYPE_PT_ADD80
7032 | OPTS_TYPE_PT_ADDBITS15;
7033 kern_type = KERN_TYPE_SHA1_SLTPW;
7034 dgst_size = DGST_SIZE_4_5;
7035 parse_func = djangosha1_parse_hash;
7036 sort_by_digest = sort_by_digest_4_5;
7037 opti_type = OPTI_TYPE_ZERO_BYTE
7038 | OPTI_TYPE_PRECOMPUTE_INIT
7039 | OPTI_TYPE_PRECOMPUTE_MERKLE
7040 | OPTI_TYPE_EARLY_SKIP
7041 | OPTI_TYPE_NOT_ITERATED
7042 | OPTI_TYPE_PREPENDED_SALT
7043 | OPTI_TYPE_RAW_HASH;
7044 dgst_pos0 = 3;
7045 dgst_pos1 = 4;
7046 dgst_pos2 = 2;
7047 dgst_pos3 = 1;
7048 break;
7049
7050 case 130: hash_type = HASH_TYPE_SHA1;
7051 salt_type = SALT_TYPE_INTERN;
7052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7053 opts_type = OPTS_TYPE_PT_GENERATE_BE
7054 | OPTS_TYPE_PT_UNICODE
7055 | OPTS_TYPE_ST_ADD80
7056 | OPTS_TYPE_ST_ADDBITS15;
7057 kern_type = KERN_TYPE_SHA1_PWUSLT;
7058 dgst_size = DGST_SIZE_4_5;
7059 parse_func = sha1s_parse_hash;
7060 sort_by_digest = sort_by_digest_4_5;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_PRECOMPUTE_INIT
7063 | OPTI_TYPE_PRECOMPUTE_MERKLE
7064 | OPTI_TYPE_EARLY_SKIP
7065 | OPTI_TYPE_NOT_ITERATED
7066 | OPTI_TYPE_APPENDED_SALT
7067 | OPTI_TYPE_RAW_HASH;
7068 dgst_pos0 = 3;
7069 dgst_pos1 = 4;
7070 dgst_pos2 = 2;
7071 dgst_pos3 = 1;
7072 break;
7073
7074 case 131: hash_type = HASH_TYPE_SHA1;
7075 salt_type = SALT_TYPE_EMBEDDED;
7076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7077 opts_type = OPTS_TYPE_PT_GENERATE_BE
7078 | OPTS_TYPE_PT_UNICODE
7079 | OPTS_TYPE_PT_UPPER
7080 | OPTS_TYPE_ST_ADD80
7081 | OPTS_TYPE_ST_ADDBITS15
7082 | OPTS_TYPE_ST_HEX;
7083 kern_type = KERN_TYPE_SHA1_PWUSLT;
7084 dgst_size = DGST_SIZE_4_5;
7085 parse_func = mssql2000_parse_hash;
7086 sort_by_digest = sort_by_digest_4_5;
7087 opti_type = OPTI_TYPE_ZERO_BYTE
7088 | OPTI_TYPE_PRECOMPUTE_INIT
7089 | OPTI_TYPE_PRECOMPUTE_MERKLE
7090 | OPTI_TYPE_EARLY_SKIP
7091 | OPTI_TYPE_NOT_ITERATED
7092 | OPTI_TYPE_APPENDED_SALT
7093 | OPTI_TYPE_RAW_HASH;
7094 dgst_pos0 = 3;
7095 dgst_pos1 = 4;
7096 dgst_pos2 = 2;
7097 dgst_pos3 = 1;
7098 break;
7099
7100 case 132: hash_type = HASH_TYPE_SHA1;
7101 salt_type = SALT_TYPE_EMBEDDED;
7102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7103 opts_type = OPTS_TYPE_PT_GENERATE_BE
7104 | OPTS_TYPE_PT_UNICODE
7105 | OPTS_TYPE_ST_ADD80
7106 | OPTS_TYPE_ST_ADDBITS15
7107 | OPTS_TYPE_ST_HEX;
7108 kern_type = KERN_TYPE_SHA1_PWUSLT;
7109 dgst_size = DGST_SIZE_4_5;
7110 parse_func = mssql2005_parse_hash;
7111 sort_by_digest = sort_by_digest_4_5;
7112 opti_type = OPTI_TYPE_ZERO_BYTE
7113 | OPTI_TYPE_PRECOMPUTE_INIT
7114 | OPTI_TYPE_PRECOMPUTE_MERKLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_APPENDED_SALT
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 3;
7120 dgst_pos1 = 4;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 133: hash_type = HASH_TYPE_SHA1;
7126 salt_type = SALT_TYPE_EMBEDDED;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_BE
7129 | OPTS_TYPE_PT_UNICODE
7130 | OPTS_TYPE_ST_ADD80
7131 | OPTS_TYPE_ST_ADDBITS15;
7132 kern_type = KERN_TYPE_SHA1_PWUSLT;
7133 dgst_size = DGST_SIZE_4_5;
7134 parse_func = peoplesoft_parse_hash;
7135 sort_by_digest = sort_by_digest_4_5;
7136 opti_type = OPTI_TYPE_ZERO_BYTE
7137 | OPTI_TYPE_PRECOMPUTE_INIT
7138 | OPTI_TYPE_PRECOMPUTE_MERKLE
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_APPENDED_SALT
7142 | OPTI_TYPE_RAW_HASH;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 140: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_INTERN;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15
7155 | OPTS_TYPE_PT_UNICODE;
7156 kern_type = KERN_TYPE_SHA1_SLTPWU;
7157 dgst_size = DGST_SIZE_4_5;
7158 parse_func = sha1s_parse_hash;
7159 sort_by_digest = sort_by_digest_4_5;
7160 opti_type = OPTI_TYPE_ZERO_BYTE
7161 | OPTI_TYPE_PRECOMPUTE_INIT
7162 | OPTI_TYPE_PRECOMPUTE_MERKLE
7163 | OPTI_TYPE_EARLY_SKIP
7164 | OPTI_TYPE_NOT_ITERATED
7165 | OPTI_TYPE_PREPENDED_SALT
7166 | OPTI_TYPE_RAW_HASH;
7167 dgst_pos0 = 3;
7168 dgst_pos1 = 4;
7169 dgst_pos2 = 2;
7170 dgst_pos3 = 1;
7171 break;
7172
7173 case 141: hash_type = HASH_TYPE_SHA1;
7174 salt_type = SALT_TYPE_EMBEDDED;
7175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7176 opts_type = OPTS_TYPE_PT_GENERATE_BE
7177 | OPTS_TYPE_PT_ADD80
7178 | OPTS_TYPE_PT_ADDBITS15
7179 | OPTS_TYPE_PT_UNICODE
7180 | OPTS_TYPE_ST_BASE64;
7181 kern_type = KERN_TYPE_SHA1_SLTPWU;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = episerver_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 150: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_INTERN;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_ST_ADD80
7203 | OPTS_TYPE_ST_ADDBITS15;
7204 kern_type = KERN_TYPE_HMACSHA1_PW;
7205 dgst_size = DGST_SIZE_4_5;
7206 parse_func = hmacsha1_parse_hash;
7207 sort_by_digest = sort_by_digest_4_5;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_NOT_ITERATED;
7210 dgst_pos0 = 3;
7211 dgst_pos1 = 4;
7212 dgst_pos2 = 2;
7213 dgst_pos3 = 1;
7214 break;
7215
7216 case 160: hash_type = HASH_TYPE_SHA1;
7217 salt_type = SALT_TYPE_INTERN;
7218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7219 opts_type = OPTS_TYPE_PT_GENERATE_BE
7220 | OPTS_TYPE_PT_ADD80
7221 | OPTS_TYPE_PT_ADDBITS15;
7222 kern_type = KERN_TYPE_HMACSHA1_SLT;
7223 dgst_size = DGST_SIZE_4_5;
7224 parse_func = hmacsha1_parse_hash;
7225 sort_by_digest = sort_by_digest_4_5;
7226 opti_type = OPTI_TYPE_ZERO_BYTE
7227 | OPTI_TYPE_NOT_ITERATED;
7228 dgst_pos0 = 3;
7229 dgst_pos1 = 4;
7230 dgst_pos2 = 2;
7231 dgst_pos3 = 1;
7232 break;
7233
7234 case 190: hash_type = HASH_TYPE_SHA1;
7235 salt_type = SALT_TYPE_NONE;
7236 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7237 opts_type = OPTS_TYPE_PT_GENERATE_BE
7238 | OPTS_TYPE_PT_ADD80
7239 | OPTS_TYPE_PT_ADDBITS15;
7240 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7241 dgst_size = DGST_SIZE_4_5;
7242 parse_func = sha1linkedin_parse_hash;
7243 sort_by_digest = sort_by_digest_4_5;
7244 opti_type = OPTI_TYPE_ZERO_BYTE
7245 | OPTI_TYPE_PRECOMPUTE_INIT
7246 | OPTI_TYPE_EARLY_SKIP
7247 | OPTI_TYPE_NOT_ITERATED
7248 | OPTI_TYPE_NOT_SALTED;
7249 dgst_pos0 = 0;
7250 dgst_pos1 = 4;
7251 dgst_pos2 = 3;
7252 dgst_pos3 = 2;
7253 break;
7254
7255 case 200: hash_type = HASH_TYPE_MYSQL;
7256 salt_type = SALT_TYPE_NONE;
7257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7258 opts_type = 0;
7259 kern_type = KERN_TYPE_MYSQL;
7260 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7261 parse_func = mysql323_parse_hash;
7262 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7263 opti_type = OPTI_TYPE_ZERO_BYTE;
7264 dgst_pos0 = 0;
7265 dgst_pos1 = 1;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 3;
7268 break;
7269
7270 case 300: hash_type = HASH_TYPE_SHA1;
7271 salt_type = SALT_TYPE_NONE;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_BE
7274 | OPTS_TYPE_PT_ADD80
7275 | OPTS_TYPE_PT_ADDBITS15;
7276 kern_type = KERN_TYPE_MYSQL41;
7277 dgst_size = DGST_SIZE_4_5;
7278 parse_func = sha1_parse_hash;
7279 sort_by_digest = sort_by_digest_4_5;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_PRECOMPUTE_INIT
7282 | OPTI_TYPE_PRECOMPUTE_MERKLE
7283 | OPTI_TYPE_EARLY_SKIP
7284 | OPTI_TYPE_NOT_ITERATED
7285 | OPTI_TYPE_NOT_SALTED;
7286 dgst_pos0 = 3;
7287 dgst_pos1 = 4;
7288 dgst_pos2 = 2;
7289 dgst_pos3 = 1;
7290 break;
7291
7292 case 400: hash_type = HASH_TYPE_MD5;
7293 salt_type = SALT_TYPE_EMBEDDED;
7294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7296 kern_type = KERN_TYPE_PHPASS;
7297 dgst_size = DGST_SIZE_4_4;
7298 parse_func = phpass_parse_hash;
7299 sort_by_digest = sort_by_digest_4_4;
7300 opti_type = OPTI_TYPE_ZERO_BYTE;
7301 dgst_pos0 = 0;
7302 dgst_pos1 = 1;
7303 dgst_pos2 = 2;
7304 dgst_pos3 = 3;
7305 break;
7306
7307 case 500: hash_type = HASH_TYPE_MD5;
7308 salt_type = SALT_TYPE_EMBEDDED;
7309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7310 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7311 kern_type = KERN_TYPE_MD5CRYPT;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = md5crypt_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 501: hash_type = HASH_TYPE_MD5;
7323 salt_type = SALT_TYPE_EMBEDDED;
7324 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7325 opts_type = OPTS_TYPE_PT_GENERATE_LE
7326 | OPTS_TYPE_HASH_COPY;
7327 kern_type = KERN_TYPE_MD5CRYPT;
7328 dgst_size = DGST_SIZE_4_4;
7329 parse_func = juniper_parse_hash;
7330 sort_by_digest = sort_by_digest_4_4;
7331 opti_type = OPTI_TYPE_ZERO_BYTE;
7332 dgst_pos0 = 0;
7333 dgst_pos1 = 1;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 3;
7336 break;
7337
7338 case 900: hash_type = HASH_TYPE_MD4;
7339 salt_type = SALT_TYPE_NONE;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_LE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS14;
7344 kern_type = KERN_TYPE_MD4;
7345 dgst_size = DGST_SIZE_4_4;
7346 parse_func = md4_parse_hash;
7347 sort_by_digest = sort_by_digest_4_4;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_MEET_IN_MIDDLE
7352 | OPTI_TYPE_EARLY_SKIP
7353 | OPTI_TYPE_NOT_ITERATED
7354 | OPTI_TYPE_NOT_SALTED
7355 | OPTI_TYPE_RAW_HASH;
7356 dgst_pos0 = 0;
7357 dgst_pos1 = 3;
7358 dgst_pos2 = 2;
7359 dgst_pos3 = 1;
7360 break;
7361
7362 case 1000: hash_type = HASH_TYPE_MD4;
7363 salt_type = SALT_TYPE_NONE;
7364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7365 opts_type = OPTS_TYPE_PT_GENERATE_LE
7366 | OPTS_TYPE_PT_ADD80
7367 | OPTS_TYPE_PT_ADDBITS14
7368 | OPTS_TYPE_PT_UNICODE;
7369 kern_type = KERN_TYPE_MD4_PWU;
7370 dgst_size = DGST_SIZE_4_4;
7371 parse_func = md4_parse_hash;
7372 sort_by_digest = sort_by_digest_4_4;
7373 opti_type = OPTI_TYPE_ZERO_BYTE
7374 | OPTI_TYPE_PRECOMPUTE_INIT
7375 | OPTI_TYPE_PRECOMPUTE_MERKLE
7376 | OPTI_TYPE_MEET_IN_MIDDLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_NOT_SALTED
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 0;
7382 dgst_pos1 = 3;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 1100: hash_type = HASH_TYPE_MD4;
7388 salt_type = SALT_TYPE_INTERN;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_LE
7391 | OPTS_TYPE_PT_ADD80
7392 | OPTS_TYPE_PT_ADDBITS14
7393 | OPTS_TYPE_PT_UNICODE
7394 | OPTS_TYPE_ST_ADD80
7395 | OPTS_TYPE_ST_UNICODE
7396 | OPTS_TYPE_ST_LOWER;
7397 kern_type = KERN_TYPE_MD44_PWUSLT;
7398 dgst_size = DGST_SIZE_4_4;
7399 parse_func = dcc_parse_hash;
7400 sort_by_digest = sort_by_digest_4_4;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED;
7406 dgst_pos0 = 0;
7407 dgst_pos1 = 3;
7408 dgst_pos2 = 2;
7409 dgst_pos3 = 1;
7410 break;
7411
7412 case 1400: hash_type = HASH_TYPE_SHA256;
7413 salt_type = SALT_TYPE_NONE;
7414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7415 opts_type = OPTS_TYPE_PT_GENERATE_BE
7416 | OPTS_TYPE_PT_ADD80
7417 | OPTS_TYPE_PT_ADDBITS15;
7418 kern_type = KERN_TYPE_SHA256;
7419 dgst_size = DGST_SIZE_4_8;
7420 parse_func = sha256_parse_hash;
7421 sort_by_digest = sort_by_digest_4_8;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_NOT_SALTED
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 7;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 6;
7433 break;
7434
7435 case 1410: hash_type = HASH_TYPE_SHA256;
7436 salt_type = SALT_TYPE_INTERN;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_ST_ADD80
7440 | OPTS_TYPE_ST_ADDBITS15;
7441 kern_type = KERN_TYPE_SHA256_PWSLT;
7442 dgst_size = DGST_SIZE_4_8;
7443 parse_func = sha256s_parse_hash;
7444 sort_by_digest = sort_by_digest_4_8;
7445 opti_type = OPTI_TYPE_ZERO_BYTE
7446 | OPTI_TYPE_PRECOMPUTE_INIT
7447 | OPTI_TYPE_PRECOMPUTE_MERKLE
7448 | OPTI_TYPE_EARLY_SKIP
7449 | OPTI_TYPE_NOT_ITERATED
7450 | OPTI_TYPE_APPENDED_SALT
7451 | OPTI_TYPE_RAW_HASH;
7452 dgst_pos0 = 3;
7453 dgst_pos1 = 7;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 6;
7456 break;
7457
7458 case 1420: hash_type = HASH_TYPE_SHA256;
7459 salt_type = SALT_TYPE_INTERN;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_BE
7462 | OPTS_TYPE_PT_ADD80
7463 | OPTS_TYPE_PT_ADDBITS15;
7464 kern_type = KERN_TYPE_SHA256_SLTPW;
7465 dgst_size = DGST_SIZE_4_8;
7466 parse_func = sha256s_parse_hash;
7467 sort_by_digest = sort_by_digest_4_8;
7468 opti_type = OPTI_TYPE_ZERO_BYTE
7469 | OPTI_TYPE_PRECOMPUTE_INIT
7470 | OPTI_TYPE_PRECOMPUTE_MERKLE
7471 | OPTI_TYPE_EARLY_SKIP
7472 | OPTI_TYPE_NOT_ITERATED
7473 | OPTI_TYPE_PREPENDED_SALT
7474 | OPTI_TYPE_RAW_HASH;
7475 dgst_pos0 = 3;
7476 dgst_pos1 = 7;
7477 dgst_pos2 = 2;
7478 dgst_pos3 = 6;
7479 break;
7480
7481 case 1421: hash_type = HASH_TYPE_SHA256;
7482 salt_type = SALT_TYPE_EMBEDDED;
7483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7484 opts_type = OPTS_TYPE_PT_GENERATE_BE
7485 | OPTS_TYPE_PT_ADD80
7486 | OPTS_TYPE_PT_ADDBITS15;
7487 kern_type = KERN_TYPE_SHA256_SLTPW;
7488 dgst_size = DGST_SIZE_4_8;
7489 parse_func = hmailserver_parse_hash;
7490 sort_by_digest = sort_by_digest_4_8;
7491 opti_type = OPTI_TYPE_ZERO_BYTE
7492 | OPTI_TYPE_PRECOMPUTE_INIT
7493 | OPTI_TYPE_PRECOMPUTE_MERKLE
7494 | OPTI_TYPE_EARLY_SKIP
7495 | OPTI_TYPE_NOT_ITERATED
7496 | OPTI_TYPE_PREPENDED_SALT
7497 | OPTI_TYPE_RAW_HASH;
7498 dgst_pos0 = 3;
7499 dgst_pos1 = 7;
7500 dgst_pos2 = 2;
7501 dgst_pos3 = 6;
7502 break;
7503
7504 case 1430: hash_type = HASH_TYPE_SHA256;
7505 salt_type = SALT_TYPE_INTERN;
7506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7507 opts_type = OPTS_TYPE_PT_GENERATE_BE
7508 | OPTS_TYPE_PT_UNICODE
7509 | OPTS_TYPE_ST_ADD80
7510 | OPTS_TYPE_ST_ADDBITS15;
7511 kern_type = KERN_TYPE_SHA256_PWUSLT;
7512 dgst_size = DGST_SIZE_4_8;
7513 parse_func = sha256s_parse_hash;
7514 sort_by_digest = sort_by_digest_4_8;
7515 opti_type = OPTI_TYPE_ZERO_BYTE
7516 | OPTI_TYPE_PRECOMPUTE_INIT
7517 | OPTI_TYPE_PRECOMPUTE_MERKLE
7518 | OPTI_TYPE_EARLY_SKIP
7519 | OPTI_TYPE_NOT_ITERATED
7520 | OPTI_TYPE_APPENDED_SALT
7521 | OPTI_TYPE_RAW_HASH;
7522 dgst_pos0 = 3;
7523 dgst_pos1 = 7;
7524 dgst_pos2 = 2;
7525 dgst_pos3 = 6;
7526 break;
7527
7528 case 1440: hash_type = HASH_TYPE_SHA256;
7529 salt_type = SALT_TYPE_INTERN;
7530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7531 opts_type = OPTS_TYPE_PT_GENERATE_BE
7532 | OPTS_TYPE_PT_ADD80
7533 | OPTS_TYPE_PT_ADDBITS15
7534 | OPTS_TYPE_PT_UNICODE;
7535 kern_type = KERN_TYPE_SHA256_SLTPWU;
7536 dgst_size = DGST_SIZE_4_8;
7537 parse_func = sha256s_parse_hash;
7538 sort_by_digest = sort_by_digest_4_8;
7539 opti_type = OPTI_TYPE_ZERO_BYTE
7540 | OPTI_TYPE_PRECOMPUTE_INIT
7541 | OPTI_TYPE_PRECOMPUTE_MERKLE
7542 | OPTI_TYPE_EARLY_SKIP
7543 | OPTI_TYPE_NOT_ITERATED
7544 | OPTI_TYPE_PREPENDED_SALT
7545 | OPTI_TYPE_RAW_HASH;
7546 dgst_pos0 = 3;
7547 dgst_pos1 = 7;
7548 dgst_pos2 = 2;
7549 dgst_pos3 = 6;
7550 break;
7551
7552 case 1441: hash_type = HASH_TYPE_SHA256;
7553 salt_type = SALT_TYPE_EMBEDDED;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = OPTS_TYPE_PT_GENERATE_BE
7556 | OPTS_TYPE_PT_ADD80
7557 | OPTS_TYPE_PT_ADDBITS15
7558 | OPTS_TYPE_PT_UNICODE
7559 | OPTS_TYPE_ST_BASE64;
7560 kern_type = KERN_TYPE_SHA256_SLTPWU;
7561 dgst_size = DGST_SIZE_4_8;
7562 parse_func = episerver4_parse_hash;
7563 sort_by_digest = sort_by_digest_4_8;
7564 opti_type = OPTI_TYPE_ZERO_BYTE
7565 | OPTI_TYPE_PRECOMPUTE_INIT
7566 | OPTI_TYPE_PRECOMPUTE_MERKLE
7567 | OPTI_TYPE_EARLY_SKIP
7568 | OPTI_TYPE_NOT_ITERATED
7569 | OPTI_TYPE_PREPENDED_SALT
7570 | OPTI_TYPE_RAW_HASH;
7571 dgst_pos0 = 3;
7572 dgst_pos1 = 7;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 6;
7575 break;
7576
7577 case 1450: hash_type = HASH_TYPE_SHA256;
7578 salt_type = SALT_TYPE_INTERN;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_ST_ADD80;
7582 kern_type = KERN_TYPE_HMACSHA256_PW;
7583 dgst_size = DGST_SIZE_4_8;
7584 parse_func = hmacsha256_parse_hash;
7585 sort_by_digest = sort_by_digest_4_8;
7586 opti_type = OPTI_TYPE_ZERO_BYTE
7587 | OPTI_TYPE_NOT_ITERATED;
7588 dgst_pos0 = 3;
7589 dgst_pos1 = 7;
7590 dgst_pos2 = 2;
7591 dgst_pos3 = 6;
7592 break;
7593
7594 case 1460: hash_type = HASH_TYPE_SHA256;
7595 salt_type = SALT_TYPE_INTERN;
7596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7597 opts_type = OPTS_TYPE_PT_GENERATE_BE
7598 | OPTS_TYPE_PT_ADD80
7599 | OPTS_TYPE_PT_ADDBITS15;
7600 kern_type = KERN_TYPE_HMACSHA256_SLT;
7601 dgst_size = DGST_SIZE_4_8;
7602 parse_func = hmacsha256_parse_hash;
7603 sort_by_digest = sort_by_digest_4_8;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_NOT_ITERATED;
7606 dgst_pos0 = 3;
7607 dgst_pos1 = 7;
7608 dgst_pos2 = 2;
7609 dgst_pos3 = 6;
7610 break;
7611
7612 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7613 salt_type = SALT_TYPE_EMBEDDED;
7614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7615 opts_type = OPTS_TYPE_PT_GENERATE_LE
7616 | OPTS_TYPE_PT_BITSLICE;
7617 kern_type = KERN_TYPE_DESCRYPT;
7618 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7619 parse_func = descrypt_parse_hash;
7620 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7621 opti_type = OPTI_TYPE_ZERO_BYTE
7622 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7623 dgst_pos0 = 0;
7624 dgst_pos1 = 1;
7625 dgst_pos2 = 2;
7626 dgst_pos3 = 3;
7627 break;
7628
7629 case 1600: hash_type = HASH_TYPE_MD5;
7630 salt_type = SALT_TYPE_EMBEDDED;
7631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7633 kern_type = KERN_TYPE_APR1CRYPT;
7634 dgst_size = DGST_SIZE_4_4;
7635 parse_func = md5apr1_parse_hash;
7636 sort_by_digest = sort_by_digest_4_4;
7637 opti_type = OPTI_TYPE_ZERO_BYTE;
7638 dgst_pos0 = 0;
7639 dgst_pos1 = 1;
7640 dgst_pos2 = 2;
7641 dgst_pos3 = 3;
7642 break;
7643
7644 case 1700: hash_type = HASH_TYPE_SHA512;
7645 salt_type = SALT_TYPE_NONE;
7646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7647 opts_type = OPTS_TYPE_PT_GENERATE_BE
7648 | OPTS_TYPE_PT_ADD80
7649 | OPTS_TYPE_PT_ADDBITS15;
7650 kern_type = KERN_TYPE_SHA512;
7651 dgst_size = DGST_SIZE_8_8;
7652 parse_func = sha512_parse_hash;
7653 sort_by_digest = sort_by_digest_8_8;
7654 opti_type = OPTI_TYPE_ZERO_BYTE
7655 | OPTI_TYPE_PRECOMPUTE_INIT
7656 | OPTI_TYPE_PRECOMPUTE_MERKLE
7657 | OPTI_TYPE_EARLY_SKIP
7658 | OPTI_TYPE_NOT_ITERATED
7659 | OPTI_TYPE_NOT_SALTED
7660 | OPTI_TYPE_RAW_HASH;
7661 dgst_pos0 = 14;
7662 dgst_pos1 = 15;
7663 dgst_pos2 = 6;
7664 dgst_pos3 = 7;
7665 break;
7666
7667 case 1710: hash_type = HASH_TYPE_SHA512;
7668 salt_type = SALT_TYPE_INTERN;
7669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7670 opts_type = OPTS_TYPE_PT_GENERATE_BE
7671 | OPTS_TYPE_ST_ADD80
7672 | OPTS_TYPE_ST_ADDBITS15;
7673 kern_type = KERN_TYPE_SHA512_PWSLT;
7674 dgst_size = DGST_SIZE_8_8;
7675 parse_func = sha512s_parse_hash;
7676 sort_by_digest = sort_by_digest_8_8;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_APPENDED_SALT
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 14;
7685 dgst_pos1 = 15;
7686 dgst_pos2 = 6;
7687 dgst_pos3 = 7;
7688 break;
7689
7690 case 1711: hash_type = HASH_TYPE_SHA512;
7691 salt_type = SALT_TYPE_EMBEDDED;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_BE
7694 | OPTS_TYPE_ST_ADD80
7695 | OPTS_TYPE_ST_ADDBITS15;
7696 kern_type = KERN_TYPE_SHA512_PWSLT;
7697 dgst_size = DGST_SIZE_8_8;
7698 parse_func = sha512b64s_parse_hash;
7699 sort_by_digest = sort_by_digest_8_8;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_APPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 14;
7708 dgst_pos1 = 15;
7709 dgst_pos2 = 6;
7710 dgst_pos3 = 7;
7711 break;
7712
7713 case 1720: hash_type = HASH_TYPE_SHA512;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS15;
7719 kern_type = KERN_TYPE_SHA512_SLTPW;
7720 dgst_size = DGST_SIZE_8_8;
7721 parse_func = sha512s_parse_hash;
7722 sort_by_digest = sort_by_digest_8_8;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_PRECOMPUTE_INIT
7725 | OPTI_TYPE_PRECOMPUTE_MERKLE
7726 | OPTI_TYPE_EARLY_SKIP
7727 | OPTI_TYPE_NOT_ITERATED
7728 | OPTI_TYPE_PREPENDED_SALT
7729 | OPTI_TYPE_RAW_HASH;
7730 dgst_pos0 = 14;
7731 dgst_pos1 = 15;
7732 dgst_pos2 = 6;
7733 dgst_pos3 = 7;
7734 break;
7735
7736 case 1722: hash_type = HASH_TYPE_SHA512;
7737 salt_type = SALT_TYPE_EMBEDDED;
7738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_BE
7740 | OPTS_TYPE_PT_ADD80
7741 | OPTS_TYPE_PT_ADDBITS15
7742 | OPTS_TYPE_ST_HEX;
7743 kern_type = KERN_TYPE_SHA512_SLTPW;
7744 dgst_size = DGST_SIZE_8_8;
7745 parse_func = osx512_parse_hash;
7746 sort_by_digest = sort_by_digest_8_8;
7747 opti_type = OPTI_TYPE_ZERO_BYTE
7748 | OPTI_TYPE_PRECOMPUTE_INIT
7749 | OPTI_TYPE_PRECOMPUTE_MERKLE
7750 | OPTI_TYPE_EARLY_SKIP
7751 | OPTI_TYPE_NOT_ITERATED
7752 | OPTI_TYPE_PREPENDED_SALT
7753 | OPTI_TYPE_RAW_HASH;
7754 dgst_pos0 = 14;
7755 dgst_pos1 = 15;
7756 dgst_pos2 = 6;
7757 dgst_pos3 = 7;
7758 break;
7759
7760 case 1730: hash_type = HASH_TYPE_SHA512;
7761 salt_type = SALT_TYPE_INTERN;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_PT_UNICODE
7765 | OPTS_TYPE_ST_ADD80
7766 | OPTS_TYPE_ST_ADDBITS15;
7767 kern_type = KERN_TYPE_SHA512_PWSLTU;
7768 dgst_size = DGST_SIZE_8_8;
7769 parse_func = sha512s_parse_hash;
7770 sort_by_digest = sort_by_digest_8_8;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_APPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 14;
7779 dgst_pos1 = 15;
7780 dgst_pos2 = 6;
7781 dgst_pos3 = 7;
7782 break;
7783
7784 case 1731: hash_type = HASH_TYPE_SHA512;
7785 salt_type = SALT_TYPE_EMBEDDED;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_PT_UNICODE
7789 | OPTS_TYPE_ST_ADD80
7790 | OPTS_TYPE_ST_ADDBITS15
7791 | OPTS_TYPE_ST_HEX;
7792 kern_type = KERN_TYPE_SHA512_PWSLTU;
7793 dgst_size = DGST_SIZE_8_8;
7794 parse_func = mssql2012_parse_hash;
7795 sort_by_digest = sort_by_digest_8_8;
7796 opti_type = OPTI_TYPE_ZERO_BYTE
7797 | OPTI_TYPE_PRECOMPUTE_INIT
7798 | OPTI_TYPE_PRECOMPUTE_MERKLE
7799 | OPTI_TYPE_EARLY_SKIP
7800 | OPTI_TYPE_NOT_ITERATED
7801 | OPTI_TYPE_APPENDED_SALT
7802 | OPTI_TYPE_RAW_HASH;
7803 dgst_pos0 = 14;
7804 dgst_pos1 = 15;
7805 dgst_pos2 = 6;
7806 dgst_pos3 = 7;
7807 break;
7808
7809 case 1740: hash_type = HASH_TYPE_SHA512;
7810 salt_type = SALT_TYPE_INTERN;
7811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7812 opts_type = OPTS_TYPE_PT_GENERATE_BE
7813 | OPTS_TYPE_PT_ADD80
7814 | OPTS_TYPE_PT_ADDBITS15
7815 | OPTS_TYPE_PT_UNICODE;
7816 kern_type = KERN_TYPE_SHA512_SLTPWU;
7817 dgst_size = DGST_SIZE_8_8;
7818 parse_func = sha512s_parse_hash;
7819 sort_by_digest = sort_by_digest_8_8;
7820 opti_type = OPTI_TYPE_ZERO_BYTE
7821 | OPTI_TYPE_PRECOMPUTE_INIT
7822 | OPTI_TYPE_PRECOMPUTE_MERKLE
7823 | OPTI_TYPE_EARLY_SKIP
7824 | OPTI_TYPE_NOT_ITERATED
7825 | OPTI_TYPE_PREPENDED_SALT
7826 | OPTI_TYPE_RAW_HASH;
7827 dgst_pos0 = 14;
7828 dgst_pos1 = 15;
7829 dgst_pos2 = 6;
7830 dgst_pos3 = 7;
7831 break;
7832
7833 case 1750: hash_type = HASH_TYPE_SHA512;
7834 salt_type = SALT_TYPE_INTERN;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_BE
7837 | OPTS_TYPE_ST_ADD80;
7838 kern_type = KERN_TYPE_HMACSHA512_PW;
7839 dgst_size = DGST_SIZE_8_8;
7840 parse_func = hmacsha512_parse_hash;
7841 sort_by_digest = sort_by_digest_8_8;
7842 opti_type = OPTI_TYPE_ZERO_BYTE
7843 | OPTI_TYPE_NOT_ITERATED;
7844 dgst_pos0 = 14;
7845 dgst_pos1 = 15;
7846 dgst_pos2 = 6;
7847 dgst_pos3 = 7;
7848 break;
7849
7850 case 1760: hash_type = HASH_TYPE_SHA512;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15;
7856 kern_type = KERN_TYPE_HMACSHA512_SLT;
7857 dgst_size = DGST_SIZE_8_8;
7858 parse_func = hmacsha512_parse_hash;
7859 sort_by_digest = sort_by_digest_8_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE
7861 | OPTI_TYPE_NOT_ITERATED;
7862 dgst_pos0 = 14;
7863 dgst_pos1 = 15;
7864 dgst_pos2 = 6;
7865 dgst_pos3 = 7;
7866 break;
7867
7868 case 1800: hash_type = HASH_TYPE_SHA512;
7869 salt_type = SALT_TYPE_EMBEDDED;
7870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7871 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7872 kern_type = KERN_TYPE_SHA512CRYPT;
7873 dgst_size = DGST_SIZE_8_8;
7874 parse_func = sha512crypt_parse_hash;
7875 sort_by_digest = sort_by_digest_8_8;
7876 opti_type = OPTI_TYPE_ZERO_BYTE;
7877 dgst_pos0 = 0;
7878 dgst_pos1 = 1;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 3;
7881 break;
7882
7883 case 2100: hash_type = HASH_TYPE_DCC2;
7884 salt_type = SALT_TYPE_EMBEDDED;
7885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7887 | OPTS_TYPE_ST_LOWER
7888 | OPTS_TYPE_ST_UNICODE;
7889 kern_type = KERN_TYPE_DCC2;
7890 dgst_size = DGST_SIZE_4_4;
7891 parse_func = dcc2_parse_hash;
7892 sort_by_digest = sort_by_digest_4_4;
7893 opti_type = OPTI_TYPE_ZERO_BYTE;
7894 dgst_pos0 = 0;
7895 dgst_pos1 = 1;
7896 dgst_pos2 = 2;
7897 dgst_pos3 = 3;
7898 break;
7899
7900 case 2400: hash_type = HASH_TYPE_MD5;
7901 salt_type = SALT_TYPE_NONE;
7902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7903 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7904 kern_type = KERN_TYPE_MD5PIX;
7905 dgst_size = DGST_SIZE_4_4;
7906 parse_func = md5pix_parse_hash;
7907 sort_by_digest = sort_by_digest_4_4;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_NOT_SALTED;
7914 dgst_pos0 = 0;
7915 dgst_pos1 = 3;
7916 dgst_pos2 = 2;
7917 dgst_pos3 = 1;
7918 break;
7919
7920 case 2410: hash_type = HASH_TYPE_MD5;
7921 salt_type = SALT_TYPE_INTERN;
7922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7923 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7924 kern_type = KERN_TYPE_MD5ASA;
7925 dgst_size = DGST_SIZE_4_4;
7926 parse_func = md5asa_parse_hash;
7927 sort_by_digest = sort_by_digest_4_4;
7928 opti_type = OPTI_TYPE_ZERO_BYTE
7929 | OPTI_TYPE_PRECOMPUTE_INIT
7930 | OPTI_TYPE_PRECOMPUTE_MERKLE
7931 | OPTI_TYPE_EARLY_SKIP
7932 | OPTI_TYPE_NOT_ITERATED;
7933 dgst_pos0 = 0;
7934 dgst_pos1 = 3;
7935 dgst_pos2 = 2;
7936 dgst_pos3 = 1;
7937 break;
7938
7939 case 2500: hash_type = HASH_TYPE_WPA;
7940 salt_type = SALT_TYPE_EMBEDDED;
7941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7942 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7943 kern_type = KERN_TYPE_WPA;
7944 dgst_size = DGST_SIZE_4_4;
7945 parse_func = wpa_parse_hash;
7946 sort_by_digest = sort_by_digest_4_4;
7947 opti_type = OPTI_TYPE_ZERO_BYTE;
7948 dgst_pos0 = 0;
7949 dgst_pos1 = 1;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 3;
7952 break;
7953
7954 case 2600: hash_type = HASH_TYPE_MD5;
7955 salt_type = SALT_TYPE_VIRTUAL;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_LE
7958 | OPTS_TYPE_PT_ADD80
7959 | OPTS_TYPE_PT_ADDBITS14
7960 | OPTS_TYPE_ST_ADD80;
7961 kern_type = KERN_TYPE_MD55_PWSLT1;
7962 dgst_size = DGST_SIZE_4_4;
7963 parse_func = md5md5_parse_hash;
7964 sort_by_digest = sort_by_digest_4_4;
7965 opti_type = OPTI_TYPE_ZERO_BYTE
7966 | OPTI_TYPE_PRECOMPUTE_INIT
7967 | OPTI_TYPE_PRECOMPUTE_MERKLE
7968 | OPTI_TYPE_EARLY_SKIP;
7969 dgst_pos0 = 0;
7970 dgst_pos1 = 3;
7971 dgst_pos2 = 2;
7972 dgst_pos3 = 1;
7973 break;
7974
7975 case 2611: hash_type = HASH_TYPE_MD5;
7976 salt_type = SALT_TYPE_INTERN;
7977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7978 opts_type = OPTS_TYPE_PT_GENERATE_LE
7979 | OPTS_TYPE_PT_ADD80
7980 | OPTS_TYPE_PT_ADDBITS14
7981 | OPTS_TYPE_ST_ADD80;
7982 kern_type = KERN_TYPE_MD55_PWSLT1;
7983 dgst_size = DGST_SIZE_4_4;
7984 parse_func = vb3_parse_hash;
7985 sort_by_digest = sort_by_digest_4_4;
7986 opti_type = OPTI_TYPE_ZERO_BYTE
7987 | OPTI_TYPE_PRECOMPUTE_INIT
7988 | OPTI_TYPE_PRECOMPUTE_MERKLE
7989 | OPTI_TYPE_EARLY_SKIP;
7990 dgst_pos0 = 0;
7991 dgst_pos1 = 3;
7992 dgst_pos2 = 2;
7993 dgst_pos3 = 1;
7994 break;
7995
7996 case 2612: hash_type = HASH_TYPE_MD5;
7997 salt_type = SALT_TYPE_EMBEDDED;
7998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7999 opts_type = OPTS_TYPE_PT_GENERATE_LE
8000 | OPTS_TYPE_PT_ADD80
8001 | OPTS_TYPE_PT_ADDBITS14
8002 | OPTS_TYPE_ST_ADD80
8003 | OPTS_TYPE_ST_HEX;
8004 kern_type = KERN_TYPE_MD55_PWSLT1;
8005 dgst_size = DGST_SIZE_4_4;
8006 parse_func = phps_parse_hash;
8007 sort_by_digest = sort_by_digest_4_4;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP;
8012 dgst_pos0 = 0;
8013 dgst_pos1 = 3;
8014 dgst_pos2 = 2;
8015 dgst_pos3 = 1;
8016 break;
8017
8018 case 2711: hash_type = HASH_TYPE_MD5;
8019 salt_type = SALT_TYPE_INTERN;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_LE
8022 | OPTS_TYPE_PT_ADD80
8023 | OPTS_TYPE_PT_ADDBITS14
8024 | OPTS_TYPE_ST_ADD80;
8025 kern_type = KERN_TYPE_MD55_PWSLT2;
8026 dgst_size = DGST_SIZE_4_4;
8027 parse_func = vb30_parse_hash;
8028 sort_by_digest = sort_by_digest_4_4;
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_PRECOMPUTE_INIT
8031 | OPTI_TYPE_EARLY_SKIP;
8032 dgst_pos0 = 0;
8033 dgst_pos1 = 3;
8034 dgst_pos2 = 2;
8035 dgst_pos3 = 1;
8036 break;
8037
8038 case 2811: hash_type = HASH_TYPE_MD5;
8039 salt_type = SALT_TYPE_INTERN;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_LE
8042 | OPTS_TYPE_PT_ADD80
8043 | OPTS_TYPE_PT_ADDBITS14;
8044 kern_type = KERN_TYPE_MD55_SLTPW;
8045 dgst_size = DGST_SIZE_4_4;
8046 parse_func = ipb2_parse_hash;
8047 sort_by_digest = sort_by_digest_4_4;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_EARLY_SKIP;
8051 dgst_pos0 = 0;
8052 dgst_pos1 = 3;
8053 dgst_pos2 = 2;
8054 dgst_pos3 = 1;
8055 break;
8056
8057 case 3000: hash_type = HASH_TYPE_LM;
8058 salt_type = SALT_TYPE_NONE;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_LE
8061 | OPTS_TYPE_PT_UPPER
8062 | OPTS_TYPE_PT_BITSLICE;
8063 kern_type = KERN_TYPE_LM;
8064 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8065 parse_func = lm_parse_hash;
8066 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8069 dgst_pos0 = 0;
8070 dgst_pos1 = 1;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 3;
8073 break;
8074
8075 case 3100: hash_type = HASH_TYPE_ORACLEH;
8076 salt_type = SALT_TYPE_INTERN;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE
8079 | OPTS_TYPE_PT_UPPER
8080 | OPTS_TYPE_ST_UPPER;
8081 kern_type = KERN_TYPE_ORACLEH;
8082 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8083 parse_func = oracleh_parse_hash;
8084 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 3200: hash_type = HASH_TYPE_BCRYPT;
8093 salt_type = SALT_TYPE_EMBEDDED;
8094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_LE
8096 | OPTS_TYPE_ST_GENERATE_LE;
8097 kern_type = KERN_TYPE_BCRYPT;
8098 dgst_size = DGST_SIZE_4_6;
8099 parse_func = bcrypt_parse_hash;
8100 sort_by_digest = sort_by_digest_4_6;
8101 opti_type = OPTI_TYPE_ZERO_BYTE;
8102 dgst_pos0 = 0;
8103 dgst_pos1 = 1;
8104 dgst_pos2 = 2;
8105 dgst_pos3 = 3;
8106 break;
8107
8108 case 3710: hash_type = HASH_TYPE_MD5;
8109 salt_type = SALT_TYPE_INTERN;
8110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8111 opts_type = OPTS_TYPE_PT_GENERATE_LE
8112 | OPTS_TYPE_PT_ADD80
8113 | OPTS_TYPE_PT_ADDBITS14;
8114 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8115 dgst_size = DGST_SIZE_4_4;
8116 parse_func = md5s_parse_hash;
8117 sort_by_digest = sort_by_digest_4_4;
8118 opti_type = OPTI_TYPE_ZERO_BYTE
8119 | OPTI_TYPE_PRECOMPUTE_INIT
8120 | OPTI_TYPE_PRECOMPUTE_MERKLE
8121 | OPTI_TYPE_EARLY_SKIP;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 3;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 1;
8126 break;
8127
8128 case 3711: hash_type = HASH_TYPE_MD5;
8129 salt_type = SALT_TYPE_EMBEDDED;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS14;
8134 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8135 dgst_size = DGST_SIZE_4_4;
8136 parse_func = mediawiki_b_parse_hash;
8137 sort_by_digest = sort_by_digest_4_4;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP;
8142 dgst_pos0 = 0;
8143 dgst_pos1 = 3;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 1;
8146 break;
8147
8148 case 3800: hash_type = HASH_TYPE_MD5;
8149 salt_type = SALT_TYPE_INTERN;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_LE
8152 | OPTS_TYPE_ST_ADDBITS14;
8153 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8154 dgst_size = DGST_SIZE_4_4;
8155 parse_func = md5s_parse_hash;
8156 sort_by_digest = sort_by_digest_4_4;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_ITERATED
8162 | OPTI_TYPE_RAW_HASH;
8163 dgst_pos0 = 0;
8164 dgst_pos1 = 3;
8165 dgst_pos2 = 2;
8166 dgst_pos3 = 1;
8167 break;
8168
8169 case 4300: hash_type = HASH_TYPE_MD5;
8170 salt_type = SALT_TYPE_VIRTUAL;
8171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8172 opts_type = OPTS_TYPE_PT_GENERATE_LE
8173 | OPTS_TYPE_PT_ADD80
8174 | OPTS_TYPE_PT_ADDBITS14
8175 | OPTS_TYPE_ST_ADD80;
8176 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8177 dgst_size = DGST_SIZE_4_4;
8178 parse_func = md5md5_parse_hash;
8179 sort_by_digest = sort_by_digest_4_4;
8180 opti_type = OPTI_TYPE_ZERO_BYTE
8181 | OPTI_TYPE_PRECOMPUTE_INIT
8182 | OPTI_TYPE_PRECOMPUTE_MERKLE
8183 | OPTI_TYPE_EARLY_SKIP;
8184 dgst_pos0 = 0;
8185 dgst_pos1 = 3;
8186 dgst_pos2 = 2;
8187 dgst_pos3 = 1;
8188 break;
8189
8190
8191 case 4400: hash_type = HASH_TYPE_MD5;
8192 salt_type = SALT_TYPE_NONE;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_BE
8195 | OPTS_TYPE_PT_ADD80
8196 | OPTS_TYPE_PT_ADDBITS15;
8197 kern_type = KERN_TYPE_MD5_SHA1;
8198 dgst_size = DGST_SIZE_4_4;
8199 parse_func = md5_parse_hash;
8200 sort_by_digest = sort_by_digest_4_4;
8201 opti_type = OPTI_TYPE_ZERO_BYTE
8202 | OPTI_TYPE_PRECOMPUTE_INIT
8203 | OPTI_TYPE_PRECOMPUTE_MERKLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_NOT_SALTED
8207 | OPTI_TYPE_RAW_HASH;
8208 dgst_pos0 = 0;
8209 dgst_pos1 = 3;
8210 dgst_pos2 = 2;
8211 dgst_pos3 = 1;
8212 break;
8213
8214 case 4500: hash_type = HASH_TYPE_SHA1;
8215 salt_type = SALT_TYPE_NONE;
8216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_BE
8218 | OPTS_TYPE_PT_ADD80
8219 | OPTS_TYPE_PT_ADDBITS15;
8220 kern_type = KERN_TYPE_SHA11;
8221 dgst_size = DGST_SIZE_4_5;
8222 parse_func = sha1_parse_hash;
8223 sort_by_digest = sort_by_digest_4_5;
8224 opti_type = OPTI_TYPE_ZERO_BYTE
8225 | OPTI_TYPE_PRECOMPUTE_INIT
8226 | OPTI_TYPE_PRECOMPUTE_MERKLE
8227 | OPTI_TYPE_EARLY_SKIP
8228 | OPTI_TYPE_NOT_SALTED;
8229 dgst_pos0 = 3;
8230 dgst_pos1 = 4;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 1;
8233 break;
8234
8235 case 4700: hash_type = HASH_TYPE_SHA1;
8236 salt_type = SALT_TYPE_NONE;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE
8239 | OPTS_TYPE_PT_ADD80
8240 | OPTS_TYPE_PT_ADDBITS14;
8241 kern_type = KERN_TYPE_SHA1_MD5;
8242 dgst_size = DGST_SIZE_4_5;
8243 parse_func = sha1_parse_hash;
8244 sort_by_digest = sort_by_digest_4_5;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_PRECOMPUTE_INIT
8247 | OPTI_TYPE_PRECOMPUTE_MERKLE
8248 | OPTI_TYPE_EARLY_SKIP
8249 | OPTI_TYPE_NOT_ITERATED
8250 | OPTI_TYPE_NOT_SALTED
8251 | OPTI_TYPE_RAW_HASH;
8252 dgst_pos0 = 3;
8253 dgst_pos1 = 4;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 4800: hash_type = HASH_TYPE_MD5;
8259 salt_type = SALT_TYPE_EMBEDDED;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE
8262 | OPTS_TYPE_PT_ADDBITS14;
8263 kern_type = KERN_TYPE_MD5_CHAP;
8264 dgst_size = DGST_SIZE_4_4;
8265 parse_func = chap_parse_hash;
8266 sort_by_digest = sort_by_digest_4_4;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_MEET_IN_MIDDLE
8271 | OPTI_TYPE_EARLY_SKIP
8272 | OPTI_TYPE_NOT_ITERATED
8273 | OPTI_TYPE_RAW_HASH;
8274 dgst_pos0 = 0;
8275 dgst_pos1 = 3;
8276 dgst_pos2 = 2;
8277 dgst_pos3 = 1;
8278 break;
8279
8280 case 4900: hash_type = HASH_TYPE_SHA1;
8281 salt_type = SALT_TYPE_INTERN;
8282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8283 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8284 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8285 dgst_size = DGST_SIZE_4_5;
8286 parse_func = sha1s_parse_hash;
8287 sort_by_digest = sort_by_digest_4_5;
8288 opti_type = OPTI_TYPE_ZERO_BYTE
8289 | OPTI_TYPE_PRECOMPUTE_INIT
8290 | OPTI_TYPE_PRECOMPUTE_MERKLE
8291 | OPTI_TYPE_EARLY_SKIP;
8292 dgst_pos0 = 3;
8293 dgst_pos1 = 4;
8294 dgst_pos2 = 2;
8295 dgst_pos3 = 1;
8296 break;
8297
8298 case 5000: hash_type = HASH_TYPE_KECCAK;
8299 salt_type = SALT_TYPE_EMBEDDED;
8300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8301 opts_type = OPTS_TYPE_PT_GENERATE_LE
8302 | OPTS_TYPE_PT_ADD01;
8303 kern_type = KERN_TYPE_KECCAK;
8304 dgst_size = DGST_SIZE_8_25;
8305 parse_func = keccak_parse_hash;
8306 sort_by_digest = sort_by_digest_8_25;
8307 opti_type = OPTI_TYPE_ZERO_BYTE
8308 | OPTI_TYPE_RAW_HASH;
8309 dgst_pos0 = 2;
8310 dgst_pos1 = 3;
8311 dgst_pos2 = 4;
8312 dgst_pos3 = 5;
8313 break;
8314
8315 case 5100: hash_type = HASH_TYPE_MD5H;
8316 salt_type = SALT_TYPE_NONE;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_LE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS14;
8321 kern_type = KERN_TYPE_MD5H;
8322 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8323 parse_func = md5half_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_RAW_HASH;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 1;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 3;
8331 break;
8332
8333 case 5200: hash_type = HASH_TYPE_SHA256;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8337 kern_type = KERN_TYPE_PSAFE3;
8338 dgst_size = DGST_SIZE_4_8;
8339 parse_func = psafe3_parse_hash;
8340 sort_by_digest = sort_by_digest_4_8;
8341 opti_type = OPTI_TYPE_ZERO_BYTE;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 1;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 3;
8346 break;
8347
8348 case 5300: hash_type = HASH_TYPE_MD5;
8349 salt_type = SALT_TYPE_EMBEDDED;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_LE
8352 | OPTS_TYPE_ST_ADD80;
8353 kern_type = KERN_TYPE_IKEPSK_MD5;
8354 dgst_size = DGST_SIZE_4_4;
8355 parse_func = ikepsk_md5_parse_hash;
8356 sort_by_digest = sort_by_digest_4_4;
8357 opti_type = OPTI_TYPE_ZERO_BYTE;
8358 dgst_pos0 = 0;
8359 dgst_pos1 = 3;
8360 dgst_pos2 = 2;
8361 dgst_pos3 = 1;
8362 break;
8363
8364 case 5400: hash_type = HASH_TYPE_SHA1;
8365 salt_type = SALT_TYPE_EMBEDDED;
8366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8367 opts_type = OPTS_TYPE_PT_GENERATE_BE
8368 | OPTS_TYPE_ST_ADD80;
8369 kern_type = KERN_TYPE_IKEPSK_SHA1;
8370 dgst_size = DGST_SIZE_4_5;
8371 parse_func = ikepsk_sha1_parse_hash;
8372 sort_by_digest = sort_by_digest_4_5;
8373 opti_type = OPTI_TYPE_ZERO_BYTE;
8374 dgst_pos0 = 3;
8375 dgst_pos1 = 4;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 5500: hash_type = HASH_TYPE_NETNTLM;
8381 salt_type = SALT_TYPE_EMBEDDED;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_ADD80
8385 | OPTS_TYPE_PT_ADDBITS14
8386 | OPTS_TYPE_PT_UNICODE
8387 | OPTS_TYPE_ST_HEX;
8388 kern_type = KERN_TYPE_NETNTLMv1;
8389 dgst_size = DGST_SIZE_4_4;
8390 parse_func = netntlmv1_parse_hash;
8391 sort_by_digest = sort_by_digest_4_4;
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 1;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 3;
8398 break;
8399
8400 case 5600: hash_type = HASH_TYPE_MD5;
8401 salt_type = SALT_TYPE_EMBEDDED;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_ADD80
8405 | OPTS_TYPE_PT_ADDBITS14
8406 | OPTS_TYPE_PT_UNICODE;
8407 kern_type = KERN_TYPE_NETNTLMv2;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = netntlmv2_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 3;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 1;
8416 break;
8417
8418 case 5700: hash_type = HASH_TYPE_SHA256;
8419 salt_type = SALT_TYPE_NONE;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_BE
8422 | OPTS_TYPE_PT_ADD80
8423 | OPTS_TYPE_PT_ADDBITS15;
8424 kern_type = KERN_TYPE_SHA256;
8425 dgst_size = DGST_SIZE_4_8;
8426 parse_func = cisco4_parse_hash;
8427 sort_by_digest = sort_by_digest_4_8;
8428 opti_type = OPTI_TYPE_ZERO_BYTE
8429 | OPTI_TYPE_PRECOMPUTE_INIT
8430 | OPTI_TYPE_PRECOMPUTE_MERKLE
8431 | OPTI_TYPE_EARLY_SKIP
8432 | OPTI_TYPE_NOT_ITERATED
8433 | OPTI_TYPE_NOT_SALTED
8434 | OPTI_TYPE_RAW_HASH;
8435 dgst_pos0 = 3;
8436 dgst_pos1 = 7;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 6;
8439 break;
8440
8441 case 5800: hash_type = HASH_TYPE_SHA1;
8442 salt_type = SALT_TYPE_INTERN;
8443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8445 | OPTS_TYPE_ST_ADD80;
8446 kern_type = KERN_TYPE_ANDROIDPIN;
8447 dgst_size = DGST_SIZE_4_5;
8448 parse_func = androidpin_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 6000: hash_type = HASH_TYPE_RIPEMD160;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_LE
8461 | OPTS_TYPE_PT_ADD80;
8462 kern_type = KERN_TYPE_RIPEMD160;
8463 dgst_size = DGST_SIZE_4_5;
8464 parse_func = ripemd160_parse_hash;
8465 sort_by_digest = sort_by_digest_4_5;
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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8474 salt_type = SALT_TYPE_NONE;
8475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_BE
8477 | OPTS_TYPE_PT_ADD80;
8478 kern_type = KERN_TYPE_WHIRLPOOL;
8479 dgst_size = DGST_SIZE_4_16;
8480 parse_func = whirlpool_parse_hash;
8481 sort_by_digest = sort_by_digest_4_16;
8482 opti_type = OPTI_TYPE_ZERO_BYTE;
8483 dgst_pos0 = 0;
8484 dgst_pos1 = 1;
8485 dgst_pos2 = 2;
8486 dgst_pos3 = 3;
8487 break;
8488
8489 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8490 salt_type = SALT_TYPE_EMBEDDED;
8491 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8492 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8493 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8494 dgst_size = DGST_SIZE_4_5;
8495 parse_func = truecrypt_parse_hash_2k;
8496 sort_by_digest = sort_by_digest_4_5;
8497 opti_type = OPTI_TYPE_ZERO_BYTE;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 1;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 3;
8502 break;
8503
8504 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8505 salt_type = SALT_TYPE_EMBEDDED;
8506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8508 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8509 dgst_size = DGST_SIZE_4_5;
8510 parse_func = truecrypt_parse_hash_2k;
8511 sort_by_digest = sort_by_digest_4_5;
8512 opti_type = OPTI_TYPE_ZERO_BYTE;
8513 dgst_pos0 = 0;
8514 dgst_pos1 = 1;
8515 dgst_pos2 = 2;
8516 dgst_pos3 = 3;
8517 break;
8518
8519 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8520 salt_type = SALT_TYPE_EMBEDDED;
8521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8522 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8523 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8524 dgst_size = DGST_SIZE_4_5;
8525 parse_func = truecrypt_parse_hash_2k;
8526 sort_by_digest = sort_by_digest_4_5;
8527 opti_type = OPTI_TYPE_ZERO_BYTE;
8528 dgst_pos0 = 0;
8529 dgst_pos1 = 1;
8530 dgst_pos2 = 2;
8531 dgst_pos3 = 3;
8532 break;
8533
8534 case 6221: hash_type = HASH_TYPE_SHA512;
8535 salt_type = SALT_TYPE_EMBEDDED;
8536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8538 kern_type = KERN_TYPE_TCSHA512_XTS512;
8539 dgst_size = DGST_SIZE_8_8;
8540 parse_func = truecrypt_parse_hash_1k;
8541 sort_by_digest = sort_by_digest_8_8;
8542 opti_type = OPTI_TYPE_ZERO_BYTE;
8543 dgst_pos0 = 0;
8544 dgst_pos1 = 1;
8545 dgst_pos2 = 2;
8546 dgst_pos3 = 3;
8547 break;
8548
8549 case 6222: hash_type = HASH_TYPE_SHA512;
8550 salt_type = SALT_TYPE_EMBEDDED;
8551 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8552 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8553 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8554 dgst_size = DGST_SIZE_8_8;
8555 parse_func = truecrypt_parse_hash_1k;
8556 sort_by_digest = sort_by_digest_8_8;
8557 opti_type = OPTI_TYPE_ZERO_BYTE;
8558 dgst_pos0 = 0;
8559 dgst_pos1 = 1;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 3;
8562 break;
8563
8564 case 6223: hash_type = HASH_TYPE_SHA512;
8565 salt_type = SALT_TYPE_EMBEDDED;
8566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8567 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8568 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8569 dgst_size = DGST_SIZE_8_8;
8570 parse_func = truecrypt_parse_hash_1k;
8571 sort_by_digest = sort_by_digest_8_8;
8572 opti_type = OPTI_TYPE_ZERO_BYTE;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 1;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 3;
8577 break;
8578
8579 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8580 salt_type = SALT_TYPE_EMBEDDED;
8581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8583 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8584 dgst_size = DGST_SIZE_4_8;
8585 parse_func = truecrypt_parse_hash_1k;
8586 sort_by_digest = sort_by_digest_4_8;
8587 opti_type = OPTI_TYPE_ZERO_BYTE;
8588 dgst_pos0 = 0;
8589 dgst_pos1 = 1;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 3;
8592 break;
8593
8594 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8595 salt_type = SALT_TYPE_EMBEDDED;
8596 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8598 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8599 dgst_size = DGST_SIZE_4_8;
8600 parse_func = truecrypt_parse_hash_1k;
8601 sort_by_digest = sort_by_digest_4_8;
8602 opti_type = OPTI_TYPE_ZERO_BYTE;
8603 dgst_pos0 = 0;
8604 dgst_pos1 = 1;
8605 dgst_pos2 = 2;
8606 dgst_pos3 = 3;
8607 break;
8608
8609 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8610 salt_type = SALT_TYPE_EMBEDDED;
8611 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8613 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8614 dgst_size = DGST_SIZE_4_8;
8615 parse_func = truecrypt_parse_hash_1k;
8616 sort_by_digest = sort_by_digest_4_8;
8617 opti_type = OPTI_TYPE_ZERO_BYTE;
8618 dgst_pos0 = 0;
8619 dgst_pos1 = 1;
8620 dgst_pos2 = 2;
8621 dgst_pos3 = 3;
8622 break;
8623
8624 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8625 salt_type = SALT_TYPE_EMBEDDED;
8626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8628 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8629 dgst_size = DGST_SIZE_4_5;
8630 parse_func = truecrypt_parse_hash_1k;
8631 sort_by_digest = sort_by_digest_4_5;
8632 opti_type = OPTI_TYPE_ZERO_BYTE;
8633 dgst_pos0 = 0;
8634 dgst_pos1 = 1;
8635 dgst_pos2 = 2;
8636 dgst_pos3 = 3;
8637 break;
8638
8639 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8640 salt_type = SALT_TYPE_EMBEDDED;
8641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8643 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8644 dgst_size = DGST_SIZE_4_5;
8645 parse_func = truecrypt_parse_hash_1k;
8646 sort_by_digest = sort_by_digest_4_5;
8647 opti_type = OPTI_TYPE_ZERO_BYTE;
8648 dgst_pos0 = 0;
8649 dgst_pos1 = 1;
8650 dgst_pos2 = 2;
8651 dgst_pos3 = 3;
8652 break;
8653
8654 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8655 salt_type = SALT_TYPE_EMBEDDED;
8656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8658 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8659 dgst_size = DGST_SIZE_4_5;
8660 parse_func = truecrypt_parse_hash_1k;
8661 sort_by_digest = sort_by_digest_4_5;
8662 opti_type = OPTI_TYPE_ZERO_BYTE;
8663 dgst_pos0 = 0;
8664 dgst_pos1 = 1;
8665 dgst_pos2 = 2;
8666 dgst_pos3 = 3;
8667 break;
8668
8669 case 6300: hash_type = HASH_TYPE_MD5;
8670 salt_type = SALT_TYPE_EMBEDDED;
8671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8673 kern_type = KERN_TYPE_MD5AIX;
8674 dgst_size = DGST_SIZE_4_4;
8675 parse_func = md5aix_parse_hash;
8676 sort_by_digest = sort_by_digest_4_4;
8677 opti_type = OPTI_TYPE_ZERO_BYTE;
8678 dgst_pos0 = 0;
8679 dgst_pos1 = 1;
8680 dgst_pos2 = 2;
8681 dgst_pos3 = 3;
8682 break;
8683
8684 case 6400: hash_type = HASH_TYPE_SHA256;
8685 salt_type = SALT_TYPE_EMBEDDED;
8686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8687 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8688 kern_type = KERN_TYPE_SHA256AIX;
8689 dgst_size = DGST_SIZE_4_8;
8690 parse_func = sha256aix_parse_hash;
8691 sort_by_digest = sort_by_digest_4_8;
8692 opti_type = OPTI_TYPE_ZERO_BYTE;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 1;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 3;
8697 break;
8698
8699 case 6500: hash_type = HASH_TYPE_SHA512;
8700 salt_type = SALT_TYPE_EMBEDDED;
8701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8702 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8703 kern_type = KERN_TYPE_SHA512AIX;
8704 dgst_size = DGST_SIZE_8_8;
8705 parse_func = sha512aix_parse_hash;
8706 sort_by_digest = sort_by_digest_8_8;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 1;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 3;
8712 break;
8713
8714 case 6600: hash_type = HASH_TYPE_AES;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8718 kern_type = KERN_TYPE_AGILEKEY;
8719 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8720 parse_func = agilekey_parse_hash;
8721 sort_by_digest = sort_by_digest_4_5;
8722 opti_type = OPTI_TYPE_ZERO_BYTE;
8723 dgst_pos0 = 0;
8724 dgst_pos1 = 1;
8725 dgst_pos2 = 2;
8726 dgst_pos3 = 3;
8727 break;
8728
8729 case 6700: hash_type = HASH_TYPE_SHA1;
8730 salt_type = SALT_TYPE_EMBEDDED;
8731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8732 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8733 kern_type = KERN_TYPE_SHA1AIX;
8734 dgst_size = DGST_SIZE_4_5;
8735 parse_func = sha1aix_parse_hash;
8736 sort_by_digest = sort_by_digest_4_5;
8737 opti_type = OPTI_TYPE_ZERO_BYTE;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 6800: hash_type = HASH_TYPE_AES;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8748 kern_type = KERN_TYPE_LASTPASS;
8749 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8750 parse_func = lastpass_parse_hash;
8751 sort_by_digest = sort_by_digest_4_8;
8752 opti_type = OPTI_TYPE_ZERO_BYTE;
8753 dgst_pos0 = 0;
8754 dgst_pos1 = 1;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 3;
8757 break;
8758
8759 case 6900: hash_type = HASH_TYPE_GOST;
8760 salt_type = SALT_TYPE_NONE;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8763 kern_type = KERN_TYPE_GOST;
8764 dgst_size = DGST_SIZE_4_8;
8765 parse_func = gost_parse_hash;
8766 sort_by_digest = sort_by_digest_4_8;
8767 opti_type = OPTI_TYPE_ZERO_BYTE;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 1;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 3;
8772 break;
8773
8774 case 7100: hash_type = HASH_TYPE_SHA512;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8778 kern_type = KERN_TYPE_PBKDF2_SHA512;
8779 dgst_size = DGST_SIZE_8_16;
8780 parse_func = sha512osx_parse_hash;
8781 sort_by_digest = sort_by_digest_8_16;
8782 opti_type = OPTI_TYPE_ZERO_BYTE;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 1;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 3;
8787 break;
8788
8789 case 7200: hash_type = HASH_TYPE_SHA512;
8790 salt_type = SALT_TYPE_EMBEDDED;
8791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8793 kern_type = KERN_TYPE_PBKDF2_SHA512;
8794 dgst_size = DGST_SIZE_8_16;
8795 parse_func = sha512grub_parse_hash;
8796 sort_by_digest = sort_by_digest_8_16;
8797 opti_type = OPTI_TYPE_ZERO_BYTE;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 1;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 3;
8802 break;
8803
8804 case 7300: hash_type = HASH_TYPE_SHA1;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_BE
8808 | OPTS_TYPE_ST_ADD80
8809 | OPTS_TYPE_ST_ADDBITS15;
8810 kern_type = KERN_TYPE_RAKP;
8811 dgst_size = DGST_SIZE_4_5;
8812 parse_func = rakp_parse_hash;
8813 sort_by_digest = sort_by_digest_4_5;
8814 opti_type = OPTI_TYPE_ZERO_BYTE
8815 | OPTI_TYPE_NOT_ITERATED;
8816 dgst_pos0 = 3;
8817 dgst_pos1 = 4;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 1;
8820 break;
8821
8822 case 7400: hash_type = HASH_TYPE_SHA256;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8826 kern_type = KERN_TYPE_SHA256CRYPT;
8827 dgst_size = DGST_SIZE_4_8;
8828 parse_func = sha256crypt_parse_hash;
8829 sort_by_digest = sort_by_digest_4_8;
8830 opti_type = OPTI_TYPE_ZERO_BYTE;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 7500: hash_type = HASH_TYPE_KRB5PA;
8838 salt_type = SALT_TYPE_EMBEDDED;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8841 kern_type = KERN_TYPE_KRB5PA;
8842 dgst_size = DGST_SIZE_4_4;
8843 parse_func = krb5pa_parse_hash;
8844 sort_by_digest = sort_by_digest_4_4;
8845 opti_type = OPTI_TYPE_ZERO_BYTE
8846 | OPTI_TYPE_NOT_ITERATED;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 7600: hash_type = HASH_TYPE_SHA1;
8854 salt_type = SALT_TYPE_INTERN;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_BE
8857 | OPTS_TYPE_PT_ADD80
8858 | OPTS_TYPE_PT_ADDBITS15;
8859 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8860 dgst_size = DGST_SIZE_4_5;
8861 parse_func = redmine_parse_hash;
8862 sort_by_digest = sort_by_digest_4_5;
8863 opti_type = OPTI_TYPE_ZERO_BYTE
8864 | OPTI_TYPE_PRECOMPUTE_INIT
8865 | OPTI_TYPE_EARLY_SKIP
8866 | OPTI_TYPE_NOT_ITERATED
8867 | OPTI_TYPE_PREPENDED_SALT;
8868 dgst_pos0 = 3;
8869 dgst_pos1 = 4;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 1;
8872 break;
8873
8874 case 7700: hash_type = HASH_TYPE_SAPB;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE
8878 | OPTS_TYPE_PT_UPPER
8879 | OPTS_TYPE_ST_UPPER;
8880 kern_type = KERN_TYPE_SAPB;
8881 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8882 parse_func = sapb_parse_hash;
8883 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8884 opti_type = OPTI_TYPE_ZERO_BYTE
8885 | OPTI_TYPE_PRECOMPUTE_INIT
8886 | OPTI_TYPE_NOT_ITERATED;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 1;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 3;
8891 break;
8892
8893 case 7800: hash_type = HASH_TYPE_SAPG;
8894 salt_type = SALT_TYPE_EMBEDDED;
8895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_BE
8897 | OPTS_TYPE_ST_ADD80
8898 | OPTS_TYPE_ST_UPPER;
8899 kern_type = KERN_TYPE_SAPG;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = sapg_parse_hash;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_PRECOMPUTE_INIT
8905 | OPTI_TYPE_NOT_ITERATED;
8906 dgst_pos0 = 3;
8907 dgst_pos1 = 4;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 1;
8910 break;
8911
8912 case 7900: hash_type = HASH_TYPE_SHA512;
8913 salt_type = SALT_TYPE_EMBEDDED;
8914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8916 kern_type = KERN_TYPE_DRUPAL7;
8917 dgst_size = DGST_SIZE_8_8;
8918 parse_func = drupal7_parse_hash;
8919 sort_by_digest = sort_by_digest_8_8;
8920 opti_type = OPTI_TYPE_ZERO_BYTE;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 1;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 3;
8925 break;
8926
8927 case 8000: hash_type = HASH_TYPE_SHA256;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_BE
8931 | OPTS_TYPE_PT_UNICODE
8932 | OPTS_TYPE_ST_ADD80
8933 | OPTS_TYPE_ST_HEX;
8934 kern_type = KERN_TYPE_SYBASEASE;
8935 dgst_size = DGST_SIZE_4_8;
8936 parse_func = sybasease_parse_hash;
8937 sort_by_digest = sort_by_digest_4_8;
8938 opti_type = OPTI_TYPE_ZERO_BYTE
8939 | OPTI_TYPE_PRECOMPUTE_INIT
8940 | OPTI_TYPE_EARLY_SKIP
8941 | OPTI_TYPE_NOT_ITERATED
8942 | OPTI_TYPE_RAW_HASH;
8943 dgst_pos0 = 3;
8944 dgst_pos1 = 7;
8945 dgst_pos2 = 2;
8946 dgst_pos3 = 6;
8947 break;
8948
8949 case 8100: hash_type = HASH_TYPE_SHA1;
8950 salt_type = SALT_TYPE_EMBEDDED;
8951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8952 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8953 kern_type = KERN_TYPE_NETSCALER;
8954 dgst_size = DGST_SIZE_4_5;
8955 parse_func = netscaler_parse_hash;
8956 sort_by_digest = sort_by_digest_4_5;
8957 opti_type = OPTI_TYPE_ZERO_BYTE
8958 | OPTI_TYPE_PRECOMPUTE_INIT
8959 | OPTI_TYPE_PRECOMPUTE_MERKLE
8960 | OPTI_TYPE_EARLY_SKIP
8961 | OPTI_TYPE_NOT_ITERATED
8962 | OPTI_TYPE_PREPENDED_SALT
8963 | OPTI_TYPE_RAW_HASH;
8964 dgst_pos0 = 3;
8965 dgst_pos1 = 4;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 1;
8968 break;
8969
8970 case 8200: hash_type = HASH_TYPE_SHA256;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8974 kern_type = KERN_TYPE_CLOUDKEY;
8975 dgst_size = DGST_SIZE_4_8;
8976 parse_func = cloudkey_parse_hash;
8977 sort_by_digest = sort_by_digest_4_8;
8978 opti_type = OPTI_TYPE_ZERO_BYTE;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 8300: hash_type = HASH_TYPE_SHA1;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE
8989 | OPTS_TYPE_ST_HEX
8990 | OPTS_TYPE_ST_ADD80;
8991 kern_type = KERN_TYPE_NSEC3;
8992 dgst_size = DGST_SIZE_4_5;
8993 parse_func = nsec3_parse_hash;
8994 sort_by_digest = sort_by_digest_4_5;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 3;
8997 dgst_pos1 = 4;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 1;
9000 break;
9001
9002 case 8400: hash_type = HASH_TYPE_SHA1;
9003 salt_type = SALT_TYPE_INTERN;
9004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_BE
9006 | OPTS_TYPE_PT_ADD80
9007 | OPTS_TYPE_PT_ADDBITS15;
9008 kern_type = KERN_TYPE_WBB3;
9009 dgst_size = DGST_SIZE_4_5;
9010 parse_func = wbb3_parse_hash;
9011 sort_by_digest = sort_by_digest_4_5;
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_PRECOMPUTE_INIT
9014 | OPTI_TYPE_NOT_ITERATED;
9015 dgst_pos0 = 3;
9016 dgst_pos1 = 4;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 1;
9019 break;
9020
9021 case 8500: hash_type = HASH_TYPE_DESRACF;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE
9025 | OPTS_TYPE_ST_UPPER;
9026 kern_type = KERN_TYPE_RACF;
9027 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9028 parse_func = racf_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9030 opti_type = OPTI_TYPE_ZERO_BYTE
9031 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9032 dgst_pos0 = 0;
9033 dgst_pos1 = 1;
9034 dgst_pos2 = 2;
9035 dgst_pos3 = 3;
9036 break;
9037
9038 case 8600: hash_type = HASH_TYPE_LOTUS5;
9039 salt_type = SALT_TYPE_NONE;
9040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9041 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9042 kern_type = KERN_TYPE_LOTUS5;
9043 dgst_size = DGST_SIZE_4_4;
9044 parse_func = lotus5_parse_hash;
9045 sort_by_digest = sort_by_digest_4_4;
9046 opti_type = OPTI_TYPE_EARLY_SKIP
9047 | OPTI_TYPE_NOT_ITERATED
9048 | OPTI_TYPE_NOT_SALTED
9049 | OPTI_TYPE_RAW_HASH;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 8700: hash_type = HASH_TYPE_LOTUS6;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_LOTUS6;
9061 dgst_size = DGST_SIZE_4_4;
9062 parse_func = lotus6_parse_hash;
9063 sort_by_digest = sort_by_digest_4_4;
9064 opti_type = OPTI_TYPE_EARLY_SKIP
9065 | OPTI_TYPE_NOT_ITERATED
9066 | OPTI_TYPE_RAW_HASH;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9077 kern_type = KERN_TYPE_ANDROIDFDE;
9078 dgst_size = DGST_SIZE_4_4;
9079 parse_func = androidfde_parse_hash;
9080 sort_by_digest = sort_by_digest_4_4;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 8900: hash_type = HASH_TYPE_SCRYPT;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9092 kern_type = KERN_TYPE_SCRYPT;
9093 dgst_size = DGST_SIZE_4_8;
9094 parse_func = scrypt_parse_hash;
9095 sort_by_digest = sort_by_digest_4_8;
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 9000: hash_type = HASH_TYPE_SHA1;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE
9107 | OPTS_TYPE_ST_GENERATE_LE;
9108 kern_type = KERN_TYPE_PSAFE2;
9109 dgst_size = DGST_SIZE_4_5;
9110 parse_func = psafe2_parse_hash;
9111 sort_by_digest = sort_by_digest_4_5;
9112 opti_type = OPTI_TYPE_ZERO_BYTE;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 9100: hash_type = HASH_TYPE_LOTUS8;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9123 kern_type = KERN_TYPE_LOTUS8;
9124 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9125 parse_func = lotus8_parse_hash;
9126 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9127 opti_type = OPTI_TYPE_ZERO_BYTE;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 9200: hash_type = HASH_TYPE_SHA256;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9138 kern_type = KERN_TYPE_PBKDF2_SHA256;
9139 dgst_size = DGST_SIZE_4_32;
9140 parse_func = cisco8_parse_hash;
9141 sort_by_digest = sort_by_digest_4_32;
9142 opti_type = OPTI_TYPE_ZERO_BYTE;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 9300: hash_type = HASH_TYPE_SCRYPT;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9153 kern_type = KERN_TYPE_SCRYPT;
9154 dgst_size = DGST_SIZE_4_8;
9155 parse_func = cisco9_parse_hash;
9156 sort_by_digest = sort_by_digest_4_8;
9157 opti_type = OPTI_TYPE_ZERO_BYTE;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 1;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 3;
9162 break;
9163
9164 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9168 kern_type = KERN_TYPE_OFFICE2007;
9169 dgst_size = DGST_SIZE_4_4;
9170 parse_func = office2007_parse_hash;
9171 sort_by_digest = sort_by_digest_4_4;
9172 opti_type = OPTI_TYPE_ZERO_BYTE;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9183 kern_type = KERN_TYPE_OFFICE2010;
9184 dgst_size = DGST_SIZE_4_4;
9185 parse_func = office2010_parse_hash;
9186 sort_by_digest = sort_by_digest_4_4;
9187 opti_type = OPTI_TYPE_ZERO_BYTE;
9188 dgst_pos0 = 0;
9189 dgst_pos1 = 1;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 3;
9192 break;
9193
9194 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9198 kern_type = KERN_TYPE_OFFICE2013;
9199 dgst_size = DGST_SIZE_4_4;
9200 parse_func = office2013_parse_hash;
9201 sort_by_digest = sort_by_digest_4_4;
9202 opti_type = OPTI_TYPE_ZERO_BYTE;
9203 dgst_pos0 = 0;
9204 dgst_pos1 = 1;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 3;
9207 break;
9208
9209 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9210 salt_type = SALT_TYPE_EMBEDDED;
9211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9212 opts_type = OPTS_TYPE_PT_GENERATE_LE
9213 | OPTS_TYPE_PT_ADD80
9214 | OPTS_TYPE_PT_UNICODE;
9215 kern_type = KERN_TYPE_OLDOFFICE01;
9216 dgst_size = DGST_SIZE_4_4;
9217 parse_func = oldoffice01_parse_hash;
9218 sort_by_digest = sort_by_digest_4_4;
9219 opti_type = OPTI_TYPE_ZERO_BYTE
9220 | OPTI_TYPE_PRECOMPUTE_INIT
9221 | OPTI_TYPE_NOT_ITERATED;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE
9232 | OPTS_TYPE_PT_ADD80;
9233 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9234 dgst_size = DGST_SIZE_4_4;
9235 parse_func = oldoffice01cm1_parse_hash;
9236 sort_by_digest = sort_by_digest_4_4;
9237 opti_type = OPTI_TYPE_ZERO_BYTE
9238 | OPTI_TYPE_PRECOMPUTE_INIT
9239 | OPTI_TYPE_NOT_ITERATED;
9240 dgst_pos0 = 0;
9241 dgst_pos1 = 1;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 3;
9244 break;
9245
9246 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE
9250 | OPTS_TYPE_PT_ADD80
9251 | OPTS_TYPE_PT_UNICODE
9252 | OPTS_TYPE_PT_NEVERCRACK;
9253 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9254 dgst_size = DGST_SIZE_4_4;
9255 parse_func = oldoffice01cm2_parse_hash;
9256 sort_by_digest = sort_by_digest_4_4;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_PRECOMPUTE_INIT
9259 | OPTI_TYPE_NOT_ITERATED;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9267 salt_type = SALT_TYPE_EMBEDDED;
9268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_BE
9270 | OPTS_TYPE_PT_ADD80
9271 | OPTS_TYPE_PT_UNICODE;
9272 kern_type = KERN_TYPE_OLDOFFICE34;
9273 dgst_size = DGST_SIZE_4_4;
9274 parse_func = oldoffice34_parse_hash;
9275 sort_by_digest = sort_by_digest_4_4;
9276 opti_type = OPTI_TYPE_ZERO_BYTE
9277 | OPTI_TYPE_PRECOMPUTE_INIT
9278 | OPTI_TYPE_NOT_ITERATED;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9289 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9290 dgst_size = DGST_SIZE_4_4;
9291 parse_func = oldoffice34cm1_parse_hash;
9292 sort_by_digest = sort_by_digest_4_4;
9293 opti_type = OPTI_TYPE_ZERO_BYTE
9294 | OPTI_TYPE_PRECOMPUTE_INIT
9295 | OPTI_TYPE_NOT_ITERATED;
9296 dgst_pos0 = 0;
9297 dgst_pos1 = 1;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 3;
9300 break;
9301
9302 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9303 salt_type = SALT_TYPE_EMBEDDED;
9304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_BE
9306 | OPTS_TYPE_PT_ADD80
9307 | OPTS_TYPE_PT_UNICODE
9308 | OPTS_TYPE_PT_NEVERCRACK;
9309 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9310 dgst_size = DGST_SIZE_4_4;
9311 parse_func = oldoffice34cm2_parse_hash;
9312 sort_by_digest = sort_by_digest_4_4;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_PRECOMPUTE_INIT
9315 | OPTI_TYPE_NOT_ITERATED;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 1;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 3;
9320 break;
9321
9322 case 9900: hash_type = HASH_TYPE_MD5;
9323 salt_type = SALT_TYPE_NONE;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9326 kern_type = KERN_TYPE_RADMIN2;
9327 dgst_size = DGST_SIZE_4_4;
9328 parse_func = radmin2_parse_hash;
9329 sort_by_digest = sort_by_digest_4_4;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_PRECOMPUTE_INIT
9332 | OPTI_TYPE_EARLY_SKIP
9333 | OPTI_TYPE_NOT_ITERATED
9334 | OPTI_TYPE_NOT_SALTED;
9335 dgst_pos0 = 0;
9336 dgst_pos1 = 3;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 1;
9339 break;
9340
9341 case 10000: hash_type = HASH_TYPE_SHA256;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9345 kern_type = KERN_TYPE_PBKDF2_SHA256;
9346 dgst_size = DGST_SIZE_4_32;
9347 parse_func = djangopbkdf2_parse_hash;
9348 sort_by_digest = sort_by_digest_4_32;
9349 opti_type = OPTI_TYPE_ZERO_BYTE;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 1;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 3;
9354 break;
9355
9356 case 10100: hash_type = HASH_TYPE_SIPHASH;
9357 salt_type = SALT_TYPE_EMBEDDED;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9360 kern_type = KERN_TYPE_SIPHASH;
9361 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9362 parse_func = siphash_parse_hash;
9363 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9364 opti_type = OPTI_TYPE_ZERO_BYTE
9365 | OPTI_TYPE_NOT_ITERATED
9366 | OPTI_TYPE_RAW_HASH;
9367 dgst_pos0 = 0;
9368 dgst_pos1 = 1;
9369 dgst_pos2 = 2;
9370 dgst_pos3 = 3;
9371 break;
9372
9373 case 10200: hash_type = HASH_TYPE_MD5;
9374 salt_type = SALT_TYPE_EMBEDDED;
9375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9376 opts_type = OPTS_TYPE_PT_GENERATE_LE
9377 | OPTS_TYPE_ST_ADD80
9378 | OPTS_TYPE_ST_ADDBITS14;
9379 kern_type = KERN_TYPE_HMACMD5_PW;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = crammd5_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 3;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 1;
9389 break;
9390
9391 case 10300: hash_type = HASH_TYPE_SHA1;
9392 salt_type = SALT_TYPE_EMBEDDED;
9393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9395 kern_type = KERN_TYPE_SAPH_SHA1;
9396 dgst_size = DGST_SIZE_4_5;
9397 parse_func = saph_sha1_parse_hash;
9398 sort_by_digest = sort_by_digest_4_5;
9399 opti_type = OPTI_TYPE_ZERO_BYTE;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 10400: 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_PDF11;
9411 dgst_size = DGST_SIZE_4_4;
9412 parse_func = pdf11_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 10410: 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_PDF11CM1;
9427 dgst_size = DGST_SIZE_4_4;
9428 parse_func = pdf11cm1_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 10420: hash_type = HASH_TYPE_PDFU16;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_PDF11CM2;
9443 dgst_size = DGST_SIZE_4_4;
9444 parse_func = pdf11cm2_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 10500: hash_type = HASH_TYPE_PDFU16;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9458 kern_type = KERN_TYPE_PDF14;
9459 dgst_size = DGST_SIZE_4_4;
9460 parse_func = pdf14_parse_hash;
9461 sort_by_digest = sort_by_digest_4_4;
9462 opti_type = OPTI_TYPE_ZERO_BYTE
9463 | OPTI_TYPE_NOT_ITERATED;
9464 dgst_pos0 = 0;
9465 dgst_pos1 = 1;
9466 dgst_pos2 = 2;
9467 dgst_pos3 = 3;
9468 break;
9469
9470 case 10600: hash_type = HASH_TYPE_SHA256;
9471 salt_type = SALT_TYPE_EMBEDDED;
9472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_BE
9474 | OPTS_TYPE_ST_ADD80
9475 | OPTS_TYPE_ST_ADDBITS15
9476 | OPTS_TYPE_HASH_COPY;
9477 kern_type = KERN_TYPE_SHA256_PWSLT;
9478 dgst_size = DGST_SIZE_4_8;
9479 parse_func = pdf17l3_parse_hash;
9480 sort_by_digest = sort_by_digest_4_8;
9481 opti_type = OPTI_TYPE_ZERO_BYTE
9482 | OPTI_TYPE_PRECOMPUTE_INIT
9483 | OPTI_TYPE_PRECOMPUTE_MERKLE
9484 | OPTI_TYPE_EARLY_SKIP
9485 | OPTI_TYPE_NOT_ITERATED
9486 | OPTI_TYPE_APPENDED_SALT
9487 | OPTI_TYPE_RAW_HASH;
9488 dgst_pos0 = 3;
9489 dgst_pos1 = 7;
9490 dgst_pos2 = 2;
9491 dgst_pos3 = 6;
9492 break;
9493
9494 case 10700: hash_type = HASH_TYPE_PDFU32;
9495 salt_type = SALT_TYPE_EMBEDDED;
9496 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9497 opts_type = OPTS_TYPE_PT_GENERATE_LE
9498 | OPTS_TYPE_HASH_COPY;
9499 kern_type = KERN_TYPE_PDF17L8;
9500 dgst_size = DGST_SIZE_4_8;
9501 parse_func = pdf17l8_parse_hash;
9502 sort_by_digest = sort_by_digest_4_8;
9503 opti_type = OPTI_TYPE_ZERO_BYTE
9504 | OPTI_TYPE_NOT_ITERATED;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 10800: hash_type = HASH_TYPE_SHA384;
9512 salt_type = SALT_TYPE_NONE;
9513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_BE
9515 | OPTS_TYPE_PT_ADD80
9516 | OPTS_TYPE_PT_ADDBITS15;
9517 kern_type = KERN_TYPE_SHA384;
9518 dgst_size = DGST_SIZE_8_8;
9519 parse_func = sha384_parse_hash;
9520 sort_by_digest = sort_by_digest_8_8;
9521 opti_type = OPTI_TYPE_ZERO_BYTE
9522 | OPTI_TYPE_PRECOMPUTE_INIT
9523 | OPTI_TYPE_PRECOMPUTE_MERKLE
9524 | OPTI_TYPE_EARLY_SKIP
9525 | OPTI_TYPE_NOT_ITERATED
9526 | OPTI_TYPE_NOT_SALTED
9527 | OPTI_TYPE_RAW_HASH;
9528 dgst_pos0 = 6;
9529 dgst_pos1 = 7;
9530 dgst_pos2 = 4;
9531 dgst_pos3 = 5;
9532 break;
9533
9534 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9535 salt_type = SALT_TYPE_EMBEDDED;
9536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_LE
9538 | OPTS_TYPE_ST_BASE64
9539 | OPTS_TYPE_HASH_COPY;
9540 kern_type = KERN_TYPE_PBKDF2_SHA256;
9541 dgst_size = DGST_SIZE_4_32;
9542 parse_func = pbkdf2_sha256_parse_hash;
9543 sort_by_digest = sort_by_digest_4_32;
9544 opti_type = OPTI_TYPE_ZERO_BYTE;
9545 dgst_pos0 = 0;
9546 dgst_pos1 = 1;
9547 dgst_pos2 = 2;
9548 dgst_pos3 = 3;
9549 break;
9550
9551 case 11000: hash_type = HASH_TYPE_MD5;
9552 salt_type = SALT_TYPE_INTERN;
9553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9554 opts_type = OPTS_TYPE_PT_GENERATE_LE
9555 | OPTS_TYPE_PT_ADD80;
9556 kern_type = KERN_TYPE_PRESTASHOP;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = prestashop_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_ZERO_BYTE
9561 | OPTI_TYPE_PRECOMPUTE_INIT
9562 | OPTI_TYPE_NOT_ITERATED
9563 | OPTI_TYPE_PREPENDED_SALT;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 3;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 1;
9568 break;
9569
9570 case 11100: hash_type = HASH_TYPE_MD5;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE
9574 | OPTS_TYPE_ST_ADD80;
9575 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = postgresql_auth_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_PRECOMPUTE_INIT
9581 | OPTI_TYPE_PRECOMPUTE_MERKLE
9582 | OPTI_TYPE_EARLY_SKIP;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 3;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 1;
9587 break;
9588
9589 case 11200: hash_type = HASH_TYPE_SHA1;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_BE
9593 | OPTS_TYPE_PT_ADD80
9594 | OPTS_TYPE_ST_HEX;
9595 kern_type = KERN_TYPE_MYSQL_AUTH;
9596 dgst_size = DGST_SIZE_4_5;
9597 parse_func = mysql_auth_parse_hash;
9598 sort_by_digest = sort_by_digest_4_5;
9599 opti_type = OPTI_TYPE_ZERO_BYTE
9600 | OPTI_TYPE_EARLY_SKIP;
9601 dgst_pos0 = 3;
9602 dgst_pos1 = 4;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 1;
9605 break;
9606
9607 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE
9611 | OPTS_TYPE_ST_HEX
9612 | OPTS_TYPE_ST_ADD80;
9613 kern_type = KERN_TYPE_BITCOIN_WALLET;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = bitcoin_wallet_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 11400: hash_type = HASH_TYPE_MD5;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_LE
9628 | OPTS_TYPE_PT_ADD80
9629 | OPTS_TYPE_HASH_COPY;
9630 kern_type = KERN_TYPE_SIP_AUTH;
9631 dgst_size = DGST_SIZE_4_4;
9632 parse_func = sip_auth_parse_hash;
9633 sort_by_digest = sort_by_digest_4_4;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 3;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 1;
9639 break;
9640
9641 case 11500: hash_type = HASH_TYPE_CRC32;
9642 salt_type = SALT_TYPE_INTERN;
9643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE
9645 | OPTS_TYPE_ST_GENERATE_LE
9646 | OPTS_TYPE_ST_HEX;
9647 kern_type = KERN_TYPE_CRC32;
9648 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9649 parse_func = crc32_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 11600: hash_type = HASH_TYPE_AES;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_PT_NEVERCRACK;
9663 kern_type = KERN_TYPE_SEVEN_ZIP;
9664 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9665 parse_func = seven_zip_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
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_256;
9680 dgst_size = DGST_SIZE_4_8;
9681 parse_func = gost2012sbog_256_parse_hash;
9682 sort_by_digest = sort_by_digest_4_8;
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 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9691 salt_type = SALT_TYPE_NONE;
9692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_PT_ADD01;
9695 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9696 dgst_size = DGST_SIZE_4_16;
9697 parse_func = gost2012sbog_512_parse_hash;
9698 sort_by_digest = sort_by_digest_4_16;
9699 opti_type = OPTI_TYPE_ZERO_BYTE;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 1;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 3;
9704 break;
9705
9706 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE
9710 | OPTS_TYPE_ST_BASE64
9711 | OPTS_TYPE_HASH_COPY;
9712 kern_type = KERN_TYPE_PBKDF2_MD5;
9713 dgst_size = DGST_SIZE_4_32;
9714 parse_func = pbkdf2_md5_parse_hash;
9715 sort_by_digest = sort_by_digest_4_32;
9716 opti_type = OPTI_TYPE_ZERO_BYTE;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE
9727 | OPTS_TYPE_ST_BASE64
9728 | OPTS_TYPE_HASH_COPY;
9729 kern_type = KERN_TYPE_PBKDF2_SHA1;
9730 dgst_size = DGST_SIZE_4_32;
9731 parse_func = pbkdf2_sha1_parse_hash;
9732 sort_by_digest = sort_by_digest_4_32;
9733 opti_type = OPTI_TYPE_ZERO_BYTE;
9734 dgst_pos0 = 0;
9735 dgst_pos1 = 1;
9736 dgst_pos2 = 2;
9737 dgst_pos3 = 3;
9738 break;
9739
9740 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9741 salt_type = SALT_TYPE_EMBEDDED;
9742 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9743 opts_type = OPTS_TYPE_PT_GENERATE_LE
9744 | OPTS_TYPE_ST_BASE64
9745 | OPTS_TYPE_HASH_COPY;
9746 kern_type = KERN_TYPE_PBKDF2_SHA512;
9747 dgst_size = DGST_SIZE_8_16;
9748 parse_func = pbkdf2_sha512_parse_hash;
9749 sort_by_digest = sort_by_digest_8_16;
9750 opti_type = OPTI_TYPE_ZERO_BYTE;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 1;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 3;
9755 break;
9756
9757 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9761 kern_type = KERN_TYPE_ECRYPTFS;
9762 dgst_size = DGST_SIZE_8_8;
9763 parse_func = ecryptfs_parse_hash;
9764 sort_by_digest = sort_by_digest_8_8;
9765 opti_type = OPTI_TYPE_ZERO_BYTE;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 12300: hash_type = HASH_TYPE_ORACLET;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_ORACLET;
9777 dgst_size = DGST_SIZE_8_16;
9778 parse_func = oraclet_parse_hash;
9779 sort_by_digest = sort_by_digest_8_16;
9780 opti_type = OPTI_TYPE_ZERO_BYTE;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
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_BSDICRYPT;
9792 dgst_size = DGST_SIZE_4_4;
9793 parse_func = bsdicrypt_parse_hash;
9794 sort_by_digest = sort_by_digest_4_4;
9795 opti_type = OPTI_TYPE_ZERO_BYTE
9796 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9797 dgst_pos0 = 0;
9798 dgst_pos1 = 1;
9799 dgst_pos2 = 2;
9800 dgst_pos3 = 3;
9801 break;
9802
9803 case 12500: hash_type = HASH_TYPE_RAR3HP;
9804 salt_type = SALT_TYPE_EMBEDDED;
9805 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9807 kern_type = KERN_TYPE_RAR3;
9808 dgst_size = DGST_SIZE_4_4;
9809 parse_func = rar3hp_parse_hash;
9810 sort_by_digest = sort_by_digest_4_4;
9811 opti_type = OPTI_TYPE_ZERO_BYTE;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 12600: hash_type = HASH_TYPE_SHA256;
9819 salt_type = SALT_TYPE_INTERN;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_BE
9822 | OPTS_TYPE_PT_ADD80;
9823 kern_type = KERN_TYPE_CF10;
9824 dgst_size = DGST_SIZE_4_8;
9825 parse_func = cf10_parse_hash;
9826 sort_by_digest = sort_by_digest_4_8;
9827 opti_type = OPTI_TYPE_ZERO_BYTE
9828 | OPTI_TYPE_PRECOMPUTE_INIT
9829 | OPTI_TYPE_EARLY_SKIP
9830 | OPTI_TYPE_NOT_ITERATED;
9831 dgst_pos0 = 3;
9832 dgst_pos1 = 7;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 6;
9835 break;
9836
9837 case 12700: hash_type = HASH_TYPE_AES;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE
9841 | OPTS_TYPE_HASH_COPY;
9842 kern_type = KERN_TYPE_MYWALLET;
9843 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9844 parse_func = mywallet_parse_hash;
9845 sort_by_digest = sort_by_digest_4_5;
9846 opti_type = OPTI_TYPE_ZERO_BYTE;
9847 dgst_pos0 = 0;
9848 dgst_pos1 = 1;
9849 dgst_pos2 = 2;
9850 dgst_pos3 = 3;
9851 break;
9852
9853 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9854 salt_type = SALT_TYPE_EMBEDDED;
9855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9857 kern_type = KERN_TYPE_MS_DRSR;
9858 dgst_size = DGST_SIZE_4_8;
9859 parse_func = ms_drsr_parse_hash;
9860 sort_by_digest = sort_by_digest_4_8;
9861 opti_type = OPTI_TYPE_ZERO_BYTE;
9862 dgst_pos0 = 0;
9863 dgst_pos1 = 1;
9864 dgst_pos2 = 2;
9865 dgst_pos3 = 3;
9866 break;
9867
9868 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9869 salt_type = SALT_TYPE_EMBEDDED;
9870 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9872 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9873 dgst_size = DGST_SIZE_4_8;
9874 parse_func = androidfde_samsung_parse_hash;
9875 sort_by_digest = sort_by_digest_4_8;
9876 opti_type = OPTI_TYPE_ZERO_BYTE;
9877 dgst_pos0 = 0;
9878 dgst_pos1 = 1;
9879 dgst_pos2 = 2;
9880 dgst_pos3 = 3;
9881 break;
9882
9883 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9884 salt_type = SALT_TYPE_EMBEDDED;
9885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9887 kern_type = KERN_TYPE_RAR5;
9888 dgst_size = DGST_SIZE_4_4;
9889 parse_func = rar5_parse_hash;
9890 sort_by_digest = sort_by_digest_4_4;
9891 opti_type = OPTI_TYPE_ZERO_BYTE;
9892 dgst_pos0 = 0;
9893 dgst_pos1 = 1;
9894 dgst_pos2 = 2;
9895 dgst_pos3 = 3;
9896 break;
9897
9898 default: usage_mini_print (PROGNAME); return (-1);
9899 }
9900
9901 /**
9902 * transpose
9903 */
9904
9905 data.parse_func = parse_func;
9906
9907 /**
9908 * misc stuff
9909 */
9910
9911 if (hex_salt)
9912 {
9913 if (salt_type == SALT_TYPE_INTERN)
9914 {
9915 opts_type |= OPTS_TYPE_ST_HEX;
9916 }
9917 else
9918 {
9919 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9920
9921 return (-1);
9922 }
9923 }
9924
9925 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9926 | (salt_type == SALT_TYPE_EXTERN)
9927 | (salt_type == SALT_TYPE_EMBEDDED)
9928 | (salt_type == SALT_TYPE_VIRTUAL));
9929
9930 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9931
9932 data.hash_type = hash_type;
9933 data.attack_mode = attack_mode;
9934 data.attack_kern = attack_kern;
9935 data.attack_exec = attack_exec;
9936 data.kern_type = kern_type;
9937 data.opts_type = opts_type;
9938 data.dgst_size = dgst_size;
9939 data.salt_type = salt_type;
9940 data.isSalted = isSalted;
9941 data.sort_by_digest = sort_by_digest;
9942 data.dgst_pos0 = dgst_pos0;
9943 data.dgst_pos1 = dgst_pos1;
9944 data.dgst_pos2 = dgst_pos2;
9945 data.dgst_pos3 = dgst_pos3;
9946
9947 esalt_size = 0;
9948
9949 switch (hash_mode)
9950 {
9951 case 2500: esalt_size = sizeof (wpa_t); break;
9952 case 5300: esalt_size = sizeof (ikepsk_t); break;
9953 case 5400: esalt_size = sizeof (ikepsk_t); break;
9954 case 5500: esalt_size = sizeof (netntlm_t); break;
9955 case 5600: esalt_size = sizeof (netntlm_t); break;
9956 case 6211:
9957 case 6212:
9958 case 6213:
9959 case 6221:
9960 case 6222:
9961 case 6223:
9962 case 6231:
9963 case 6232:
9964 case 6233:
9965 case 6241:
9966 case 6242:
9967 case 6243: esalt_size = sizeof (tc_t); break;
9968 case 6600: esalt_size = sizeof (agilekey_t); break;
9969 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9970 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9971 case 7300: esalt_size = sizeof (rakp_t); break;
9972 case 7500: esalt_size = sizeof (krb5pa_t); break;
9973 case 8200: esalt_size = sizeof (cloudkey_t); break;
9974 case 8800: esalt_size = sizeof (androidfde_t); break;
9975 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9976 case 9400: esalt_size = sizeof (office2007_t); break;
9977 case 9500: esalt_size = sizeof (office2010_t); break;
9978 case 9600: esalt_size = sizeof (office2013_t); break;
9979 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9980 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9981 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9982 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9983 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9984 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9985 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9986 case 10200: esalt_size = sizeof (cram_md5_t); break;
9987 case 10400: esalt_size = sizeof (pdf_t); break;
9988 case 10410: esalt_size = sizeof (pdf_t); break;
9989 case 10420: esalt_size = sizeof (pdf_t); break;
9990 case 10500: esalt_size = sizeof (pdf_t); break;
9991 case 10600: esalt_size = sizeof (pdf_t); break;
9992 case 10700: esalt_size = sizeof (pdf_t); break;
9993 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9994 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9995 case 11400: esalt_size = sizeof (sip_t); break;
9996 case 11600: esalt_size = sizeof (seven_zip_t); break;
9997 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9998 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9999 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10000 case 13000: esalt_size = sizeof (rar5_t); break;
10001 }
10002
10003 data.esalt_size = esalt_size;
10004
10005 /**
10006 * choose dictionary parser
10007 */
10008
10009 if (hash_type == HASH_TYPE_LM)
10010 {
10011 get_next_word_func = get_next_word_lm;
10012 }
10013 else if (opts_type & OPTS_TYPE_PT_UPPER)
10014 {
10015 get_next_word_func = get_next_word_uc;
10016 }
10017 else
10018 {
10019 get_next_word_func = get_next_word_std;
10020 }
10021
10022 /**
10023 * dictstat
10024 */
10025
10026 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10027
10028 #ifdef _POSIX
10029 size_t dictstat_nmemb = 0;
10030 #endif
10031
10032 #ifdef _WIN
10033 uint dictstat_nmemb = 0;
10034 #endif
10035
10036 char dictstat[256];
10037
10038 FILE *dictstat_fp = NULL;
10039
10040 if (keyspace == 0)
10041 {
10042 memset (dictstat, 0, sizeof (dictstat));
10043
10044 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10045
10046 dictstat_fp = fopen (dictstat, "rb");
10047
10048 if (dictstat_fp)
10049 {
10050 #ifdef _POSIX
10051 struct stat tmpstat;
10052
10053 fstat (fileno (dictstat_fp), &tmpstat);
10054 #endif
10055
10056 #ifdef _WIN
10057 struct stat64 tmpstat;
10058
10059 _fstat64 (fileno (dictstat_fp), &tmpstat);
10060 #endif
10061
10062 if (tmpstat.st_mtime < COMPTIME)
10063 {
10064 /* with v0.15 the format changed so we have to ensure user is using a good version
10065 since there is no version-header in the dictstat file */
10066
10067 fclose (dictstat_fp);
10068
10069 unlink (dictstat);
10070 }
10071 else
10072 {
10073 while (!feof (dictstat_fp))
10074 {
10075 dictstat_t d;
10076
10077 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10078
10079 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10080
10081 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10082 {
10083 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10084
10085 return -1;
10086 }
10087 }
10088
10089 fclose (dictstat_fp);
10090 }
10091 }
10092 }
10093
10094 /**
10095 * potfile
10096 */
10097
10098 char potfile[256] = { 0 };
10099
10100 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10101
10102 data.pot_fp = NULL;
10103
10104 FILE *out_fp = NULL;
10105 FILE *pot_fp = NULL;
10106
10107 if (show == 1 || left == 1)
10108 {
10109 pot_fp = fopen (potfile, "rb");
10110
10111 if (pot_fp == NULL)
10112 {
10113 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10114
10115 return (-1);
10116 }
10117
10118 if (outfile != NULL)
10119 {
10120 if ((out_fp = fopen (outfile, "ab")) == NULL)
10121 {
10122 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10123
10124 fclose (pot_fp);
10125
10126 return (-1);
10127 }
10128 }
10129 else
10130 {
10131 out_fp = stdout;
10132 }
10133 }
10134 else
10135 {
10136 if (potfile_disable == 0)
10137 {
10138 pot_fp = fopen (potfile, "ab");
10139
10140 if (pot_fp == NULL)
10141 {
10142 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10143
10144 return (-1);
10145 }
10146
10147 data.pot_fp = pot_fp;
10148 }
10149 }
10150
10151 pot_t *pot = NULL;
10152
10153 uint pot_cnt = 0;
10154 uint pot_avail = 0;
10155
10156 if (show == 1 || left == 1)
10157 {
10158 SUPPRESS_OUTPUT = 1;
10159
10160 pot_avail = count_lines (pot_fp);
10161
10162 rewind (pot_fp);
10163
10164 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10165
10166 uint pot_hashes_avail = 0;
10167
10168 uint line_num = 0;
10169
10170 while (!feof (pot_fp))
10171 {
10172 line_num++;
10173
10174 char line_buf[BUFSIZ];
10175
10176 int line_len = fgetl (pot_fp, line_buf);
10177
10178 if (line_len == 0) continue;
10179
10180 char *plain_buf = line_buf + line_len;
10181
10182 pot_t *pot_ptr = &pot[pot_cnt];
10183
10184 hash_t *hashes_buf = &pot_ptr->hash;
10185
10186 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10187 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10188
10189 if (pot_cnt == pot_hashes_avail)
10190 {
10191 uint pos = 0;
10192
10193 for (pos = 0; pos < INCR_POT; pos++)
10194 {
10195 if ((pot_cnt + pos) >= pot_avail) break;
10196
10197 pot_t *tmp_pot = &pot[pot_cnt + pos];
10198
10199 hash_t *tmp_hash = &tmp_pot->hash;
10200
10201 tmp_hash->digest = mymalloc (dgst_size);
10202
10203 if (isSalted)
10204 {
10205 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10206 }
10207
10208 if (esalt_size)
10209 {
10210 tmp_hash->esalt = mymalloc (esalt_size);
10211 }
10212
10213 pot_hashes_avail++;
10214 }
10215 }
10216
10217 int plain_len = 0;
10218
10219 int parser_status;
10220
10221 int iter = MAX_CUT_TRIES;
10222
10223 do
10224 {
10225 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10226 {
10227 if (line_buf[i] == ':')
10228 {
10229 line_len--;
10230
10231 break;
10232 }
10233 }
10234
10235 if (data.hash_mode != 2500)
10236 {
10237 parser_status = parse_func (line_buf, line_len, hashes_buf);
10238 }
10239 else
10240 {
10241 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10242
10243 if (line_len > max_salt_size)
10244 {
10245 parser_status = PARSER_GLOBAL_LENGTH;
10246 }
10247 else
10248 {
10249 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10250
10251 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10252
10253 hashes_buf->salt->salt_len = line_len;
10254
10255 parser_status = PARSER_OK;
10256 }
10257 }
10258
10259 // if NOT parsed without error, we add the ":" to the plain
10260
10261 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10262 {
10263 plain_len++;
10264 plain_buf--;
10265 }
10266
10267 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10268
10269 if (parser_status < PARSER_GLOBAL_ZERO)
10270 {
10271 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10272
10273 continue;
10274 }
10275
10276 if (plain_len >= 255) continue;
10277
10278 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10279
10280 pot_ptr->plain_len = plain_len;
10281
10282 pot_cnt++;
10283 }
10284
10285 fclose (pot_fp);
10286
10287 SUPPRESS_OUTPUT = 0;
10288
10289 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10290 }
10291
10292 /**
10293 * kernel accel and loops auto adjustment
10294 */
10295
10296 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10297 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10298
10299 if (workload_profile == 1)
10300 {
10301 kernel_loops /= 8;
10302 kernel_accel /= 4;
10303
10304 if (kernel_loops == 0) kernel_loops = 8;
10305 if (kernel_accel == 0) kernel_accel = 2;
10306 }
10307 else if (workload_profile == 3)
10308 {
10309 kernel_loops *= 8;
10310 kernel_accel *= 4;
10311
10312 if (kernel_loops > 1024) kernel_loops = 1024;
10313 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10314 }
10315
10316 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10317
10318 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10319 {
10320 kernel_loops = 1024;
10321 }
10322
10323 if (hash_mode == 12500)
10324 {
10325 kernel_loops = ROUNDS_RAR3 / 16;
10326 }
10327
10328 data.kernel_accel = kernel_accel;
10329 data.kernel_loops = kernel_loops;
10330
10331 /**
10332 * word len
10333 */
10334
10335 uint pw_min = PW_MIN;
10336 uint pw_max = PW_MAX;
10337
10338 switch (hash_mode)
10339 {
10340 case 400: if (pw_max > 40) pw_max = 40;
10341 break;
10342 case 500: if (pw_max > 16) pw_max = 16;
10343 break;
10344 case 1500: if (pw_max > 8) pw_max = 8;
10345 break;
10346 case 1600: if (pw_max > 16) pw_max = 16;
10347 break;
10348 case 1800: if (pw_max > 16) pw_max = 16;
10349 break;
10350 case 2100: if (pw_max > 16) pw_max = 16;
10351 break;
10352 case 2500: if (pw_min < 8) pw_min = 8;
10353 break;
10354 case 3000: if (pw_max > 7) pw_max = 7;
10355 break;
10356 case 5200: if (pw_max > 24) pw_max = 24;
10357 break;
10358 case 5800: if (pw_max > 16) pw_max = 16;
10359 break;
10360 case 6300: if (pw_max > 16) pw_max = 16;
10361 break;
10362 case 7400: if (pw_max > 16) pw_max = 16;
10363 break;
10364 case 7900: if (pw_max > 48) pw_max = 48;
10365 break;
10366 case 8500: if (pw_max > 8) pw_max = 8;
10367 break;
10368 case 8600: if (pw_max > 16) pw_max = 16;
10369 break;
10370 case 9710: pw_min = 5;
10371 pw_max = 5;
10372 break;
10373 case 9810: pw_min = 5;
10374 pw_max = 5;
10375 break;
10376 case 10410: pw_min = 5;
10377 pw_max = 5;
10378 break;
10379 case 10300: if (pw_max < 3) pw_min = 3;
10380 if (pw_max > 40) pw_max = 40;
10381 break;
10382 case 10500: if (pw_max < 3) pw_min = 3;
10383 if (pw_max > 40) pw_max = 40;
10384 break;
10385 case 10700: if (pw_max > 16) pw_max = 16;
10386 break;
10387 case 11300: if (pw_max > 40) pw_max = 40;
10388 break;
10389 case 12500: if (pw_max > 20) pw_max = 20;
10390 break;
10391 case 12800: if (pw_max > 24) pw_max = 24;
10392 break;
10393 }
10394
10395 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10396 {
10397 switch (attack_kern)
10398 {
10399 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10400 break;
10401 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10402 break;
10403 }
10404 }
10405
10406 /**
10407 * charsets : keep them together for more easy maintainnce
10408 */
10409
10410 cs_t mp_sys[6] = { { { 0 }, 0 } };
10411 cs_t mp_usr[4] = { { { 0 }, 0 } };
10412
10413 mp_setup_sys (mp_sys);
10414
10415 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10416 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10417 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10418 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10419
10420 /**
10421 * load hashes, part I: find input mode, count hashes
10422 */
10423
10424 uint hashlist_mode = 0;
10425 uint hashlist_format = HLFMT_HASHCAT;
10426
10427 uint hashes_avail = 0;
10428
10429 if (benchmark == 0)
10430 {
10431 struct stat f;
10432
10433 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10434
10435 if ((hash_mode == 2500) ||
10436 (hash_mode == 5200) ||
10437 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10438 (hash_mode == 9000))
10439 {
10440 hashlist_mode = HL_MODE_ARG;
10441
10442 char *hashfile = myargv[optind];
10443
10444 data.hashfile = hashfile;
10445
10446 logfile_top_var_string ("target", hashfile);
10447 }
10448
10449 if (hashlist_mode == HL_MODE_ARG)
10450 {
10451 if (hash_mode == 2500)
10452 {
10453 struct stat st;
10454
10455 if (stat (data.hashfile, &st) == -1)
10456 {
10457 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10458
10459 return (-1);
10460 }
10461
10462 hashes_avail = st.st_size / sizeof (hccap_t);
10463 }
10464 else
10465 {
10466 hashes_avail = 1;
10467 }
10468 }
10469 else if (hashlist_mode == HL_MODE_FILE)
10470 {
10471 char *hashfile = myargv[optind];
10472
10473 data.hashfile = hashfile;
10474
10475 logfile_top_var_string ("target", hashfile);
10476
10477 FILE *fp = NULL;
10478
10479 if ((fp = fopen (hashfile, "rb")) == NULL)
10480 {
10481 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10482
10483 return (-1);
10484 }
10485
10486 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10487
10488 hashes_avail = count_lines (fp);
10489
10490 rewind (fp);
10491
10492 if (hashes_avail == 0)
10493 {
10494 log_error ("ERROR: hashfile is empty or corrupt");
10495
10496 fclose (fp);
10497
10498 return (-1);
10499 }
10500
10501 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10502
10503 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10504 {
10505 log_error ("ERROR: remove not supported in native hashfile-format mode");
10506
10507 fclose (fp);
10508
10509 return (-1);
10510 }
10511
10512 fclose (fp);
10513 }
10514 }
10515 else
10516 {
10517 hashlist_mode = HL_MODE_ARG;
10518
10519 hashes_avail = 1;
10520 }
10521
10522 if (hash_mode == 3000) hashes_avail *= 2;
10523
10524 data.hashlist_mode = hashlist_mode;
10525 data.hashlist_format = hashlist_format;
10526
10527 logfile_top_uint (hashlist_mode);
10528 logfile_top_uint (hashlist_format);
10529
10530 /**
10531 * load hashes, part II: allocate required memory, set pointers
10532 */
10533
10534 hash_t *hashes_buf = NULL;
10535 void *digests_buf = NULL;
10536 salt_t *salts_buf = NULL;
10537 void *esalts_buf = NULL;
10538
10539 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10540
10541 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10542
10543 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10544 {
10545 u32 hash_pos;
10546
10547 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10548 {
10549 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10550
10551 hashes_buf[hash_pos].hash_info = hash_info;
10552
10553 if (username && (remove || show || left))
10554 {
10555 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10556 }
10557
10558 if (benchmark)
10559 {
10560 hash_info->orighash = (char *) mymalloc (256);
10561 }
10562 }
10563 }
10564
10565 if (isSalted)
10566 {
10567 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10568
10569 if (esalt_size)
10570 {
10571 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10572 }
10573 }
10574 else
10575 {
10576 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10577 }
10578
10579 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10580 {
10581 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10582
10583 if (isSalted)
10584 {
10585 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10586
10587 if (esalt_size)
10588 {
10589 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10590 }
10591 }
10592 else
10593 {
10594 hashes_buf[hash_pos].salt = &salts_buf[0];
10595 }
10596 }
10597
10598 /**
10599 * load hashes, part III: parse hashes or generate them if benchmark
10600 */
10601
10602 uint hashes_cnt = 0;
10603
10604 if (benchmark == 0)
10605 {
10606 if (keyspace == 1)
10607 {
10608 // useless to read hash file for keyspace, cheat a little bit w/ optind
10609 }
10610 else if (hashes_avail == 0)
10611 {
10612 }
10613 else if (hashlist_mode == HL_MODE_ARG)
10614 {
10615 char *input_buf = myargv[optind];
10616
10617 uint input_len = strlen (input_buf);
10618
10619 logfile_top_var_string ("target", input_buf);
10620
10621 char *hash_buf = NULL;
10622 int hash_len = 0;
10623
10624 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10625
10626 if (hash_len)
10627 {
10628 if (opts_type & OPTS_TYPE_HASH_COPY)
10629 {
10630 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10631
10632 hash_info_tmp->orighash = mystrdup (hash_buf);
10633 }
10634
10635 if (isSalted)
10636 {
10637 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10638 }
10639
10640 int parser_status = PARSER_OK;
10641
10642 if (hash_mode == 2500)
10643 {
10644 if (hash_len == 0)
10645 {
10646 log_error ("ERROR: hccap file not specified");
10647
10648 return (-1);
10649 }
10650
10651 hashlist_mode = HL_MODE_FILE;
10652
10653 data.hashlist_mode = hashlist_mode;
10654
10655 FILE *fp = fopen (hash_buf, "rb");
10656
10657 if (fp == NULL)
10658 {
10659 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10660
10661 return (-1);
10662 }
10663
10664 if (hashes_avail < 1)
10665 {
10666 log_error ("ERROR: hccap file is empty or corrupt");
10667
10668 fclose (fp);
10669
10670 return (-1);
10671 }
10672
10673 uint hccap_size = sizeof (hccap_t);
10674
10675 char in[hccap_size];
10676
10677 while (!feof (fp))
10678 {
10679 int n = fread (&in, hccap_size, 1, fp);
10680
10681 if (n != 1)
10682 {
10683 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10684
10685 break;
10686 }
10687
10688 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10689
10690 if (parser_status != PARSER_OK)
10691 {
10692 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10693
10694 continue;
10695 }
10696
10697 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10698
10699 if ((show == 1) || (left == 1))
10700 {
10701 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10702
10703 char *salt_ptr = (char *) tmp_salt->salt_buf;
10704
10705 int cur_pos = tmp_salt->salt_len;
10706 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10707
10708 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10709
10710 u8 *pke_ptr = (u8 *) wpa->pke;
10711
10712 // do the appending task
10713
10714 snprintf (salt_ptr + cur_pos,
10715 rem_len,
10716 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10717 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10718 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10719
10720
10721 // memset () the remaining part of the salt
10722
10723 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10724 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10725
10726 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10727
10728 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10729 }
10730
10731 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);
10732 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);
10733
10734 hashes_cnt++;
10735 }
10736
10737 fclose (fp);
10738 }
10739 else if (hash_mode == 3000)
10740 {
10741 if (hash_len == 32)
10742 {
10743 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10744
10745 hash_t *lm_hash_left = NULL;
10746
10747 if (parser_status == PARSER_OK)
10748 {
10749 lm_hash_left = &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
10759 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10760
10761 hash_t *lm_hash_right = NULL;
10762
10763 if (parser_status == PARSER_OK)
10764 {
10765 lm_hash_right = &hashes_buf[hashes_cnt];
10766
10767 hashes_cnt++;
10768 }
10769 else
10770 {
10771 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10772 }
10773
10774 // show / left
10775
10776 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10777 {
10778 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);
10779 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);
10780 }
10781 }
10782 else
10783 {
10784 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10785
10786 if (parser_status == PARSER_OK)
10787 {
10788 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10789 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10790 }
10791
10792 if (parser_status == PARSER_OK)
10793 {
10794 hashes_cnt++;
10795 }
10796 else
10797 {
10798 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10799 }
10800 }
10801 }
10802 else
10803 {
10804 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10805
10806 if (parser_status == PARSER_OK)
10807 {
10808 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10809 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10810 }
10811
10812 if (parser_status == PARSER_OK)
10813 {
10814 hashes_cnt++;
10815 }
10816 else
10817 {
10818 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10819 }
10820 }
10821 }
10822 }
10823 else if (hashlist_mode == HL_MODE_FILE)
10824 {
10825 char *hashfile = data.hashfile;
10826
10827 FILE *fp;
10828
10829 if ((fp = fopen (hashfile, "rb")) == NULL)
10830 {
10831 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10832
10833 return (-1);
10834 }
10835
10836 uint line_num = 0;
10837
10838 while (!feof (fp))
10839 {
10840 line_num++;
10841
10842 char line_buf[BUFSIZ];
10843
10844 int line_len = fgetl (fp, line_buf);
10845
10846 if (line_len == 0) continue;
10847
10848 char *hash_buf = NULL;
10849 int hash_len = 0;
10850
10851 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10852
10853 if (username)
10854 {
10855 char *user_buf = NULL;
10856 int user_len = 0;
10857
10858 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10859
10860 if (remove || show)
10861 {
10862 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10863
10864 *user = (user_t *) malloc (sizeof (user_t));
10865
10866 user_t *user_ptr = *user;
10867
10868 if (user_buf != NULL)
10869 {
10870 user_ptr->user_name = mystrdup (user_buf);
10871 }
10872 else
10873 {
10874 user_ptr->user_name = mystrdup ("");
10875 }
10876
10877 user_ptr->user_len = user_len;
10878 }
10879 }
10880
10881 if (opts_type & OPTS_TYPE_HASH_COPY)
10882 {
10883 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10884
10885 hash_info_tmp->orighash = mystrdup (hash_buf);
10886 }
10887
10888 if (isSalted)
10889 {
10890 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10891 }
10892
10893 if (hash_mode == 3000)
10894 {
10895 if (hash_len == 32)
10896 {
10897 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10898
10899 if (parser_status < PARSER_GLOBAL_ZERO)
10900 {
10901 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10902
10903 continue;
10904 }
10905
10906 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10907
10908 hashes_cnt++;
10909
10910 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10911
10912 if (parser_status < PARSER_GLOBAL_ZERO)
10913 {
10914 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10915
10916 continue;
10917 }
10918
10919 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10920
10921 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);
10922
10923 hashes_cnt++;
10924
10925 // show / left
10926
10927 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);
10928 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);
10929 }
10930 else
10931 {
10932 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10933
10934 if (parser_status < PARSER_GLOBAL_ZERO)
10935 {
10936 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10937
10938 continue;
10939 }
10940
10941 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);
10942
10943 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10944 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10945
10946 hashes_cnt++;
10947 }
10948 }
10949 else
10950 {
10951 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10952
10953 if (parser_status < PARSER_GLOBAL_ZERO)
10954 {
10955 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10956
10957 continue;
10958 }
10959
10960 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);
10961
10962 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10963 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10964
10965 hashes_cnt++;
10966 }
10967 }
10968
10969 fclose (fp);
10970
10971 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10972
10973 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10974 }
10975 }
10976 else
10977 {
10978 if (isSalted)
10979 {
10980 hashes_buf[0].salt->salt_len = 8;
10981
10982 // special salt handling
10983
10984 switch (hash_mode)
10985 {
10986 case 1500: hashes_buf[0].salt->salt_len = 2;
10987 break;
10988 case 1731: hashes_buf[0].salt->salt_len = 4;
10989 break;
10990 case 2410: hashes_buf[0].salt->salt_len = 4;
10991 break;
10992 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10993 break;
10994 case 3100: hashes_buf[0].salt->salt_len = 1;
10995 break;
10996 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10997 break;
10998 case 5800: hashes_buf[0].salt->salt_len = 16;
10999 break;
11000 case 6800: hashes_buf[0].salt->salt_len = 32;
11001 break;
11002 case 8400: hashes_buf[0].salt->salt_len = 40;
11003 break;
11004 case 8800: hashes_buf[0].salt->salt_len = 16;
11005 break;
11006 case 8900: hashes_buf[0].salt->salt_len = 16;
11007 hashes_buf[0].salt->scrypt_N = 1024;
11008 hashes_buf[0].salt->scrypt_r = 1;
11009 hashes_buf[0].salt->scrypt_p = 1;
11010 break;
11011 case 9100: hashes_buf[0].salt->salt_len = 16;
11012 break;
11013 case 9300: hashes_buf[0].salt->salt_len = 14;
11014 hashes_buf[0].salt->scrypt_N = 16384;
11015 hashes_buf[0].salt->scrypt_r = 1;
11016 hashes_buf[0].salt->scrypt_p = 1;
11017 break;
11018 case 9400: hashes_buf[0].salt->salt_len = 16;
11019 break;
11020 case 9500: hashes_buf[0].salt->salt_len = 16;
11021 break;
11022 case 9600: hashes_buf[0].salt->salt_len = 16;
11023 break;
11024 case 9700: hashes_buf[0].salt->salt_len = 16;
11025 break;
11026 case 9710: hashes_buf[0].salt->salt_len = 16;
11027 break;
11028 case 9720: hashes_buf[0].salt->salt_len = 16;
11029 break;
11030 case 9800: hashes_buf[0].salt->salt_len = 16;
11031 break;
11032 case 9810: hashes_buf[0].salt->salt_len = 16;
11033 break;
11034 case 9820: hashes_buf[0].salt->salt_len = 16;
11035 break;
11036 case 10300: hashes_buf[0].salt->salt_len = 12;
11037 break;
11038 case 11500: hashes_buf[0].salt->salt_len = 4;
11039 break;
11040 case 11600: hashes_buf[0].salt->salt_len = 4;
11041 break;
11042 case 12400: hashes_buf[0].salt->salt_len = 4;
11043 break;
11044 case 12500: hashes_buf[0].salt->salt_len = 8;
11045 break;
11046 case 12600: hashes_buf[0].salt->salt_len = 64;
11047 break;
11048 }
11049
11050 // special esalt handling
11051
11052 switch (hash_mode)
11053 {
11054 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11055 break;
11056 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11057 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11058 break;
11059 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11060 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11061 break;
11062 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11063 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11064 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11065 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11066 break;
11067 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11068 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11069 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11070 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11071 break;
11072 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11073 break;
11074 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11075 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11076 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11077 break;
11078 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11079 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11080 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11081 break;
11082 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11083 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11084 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11085 break;
11086 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11087 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11088 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11089 break;
11090 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11091 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11092 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11093 break;
11094 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11095 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11096 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11097 break;
11098 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11099 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11100 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11101 break;
11102 }
11103 }
11104
11105 // set hashfile
11106
11107 switch (hash_mode)
11108 {
11109 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11110 break;
11111 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11112 break;
11113 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11114 break;
11115 case 6211:
11116 case 6212:
11117 case 6213:
11118 case 6221:
11119 case 6222:
11120 case 6223:
11121 case 6231:
11122 case 6232:
11123 case 6233:
11124 case 6241:
11125 case 6242:
11126 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11127 break;
11128 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11129 break;
11130 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11131 break;
11132 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11133 break;
11134 }
11135
11136 // set default iterations
11137
11138 switch (hash_mode)
11139 {
11140 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11141 break;
11142 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11143 break;
11144 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11145 break;
11146 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11147 break;
11148 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11149 break;
11150 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11151 break;
11152 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11153 break;
11154 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11155 break;
11156 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11157 break;
11158 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11159 break;
11160 case 6211:
11161 case 6212:
11162 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11163 break;
11164 case 6221:
11165 case 6222:
11166 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11167 break;
11168 case 6231:
11169 case 6232:
11170 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11171 break;
11172 case 6241:
11173 case 6242:
11174 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11175 break;
11176 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11177 break;
11178 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11179 break;
11180 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11181 break;
11182 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11183 break;
11184 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11185 break;
11186 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11187 break;
11188 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11189 break;
11190 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11191 break;
11192 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11193 break;
11194 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11195 break;
11196 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11197 break;
11198 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11199 break;
11200 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11201 break;
11202 case 8900: hashes_buf[0].salt->salt_iter = 1;
11203 break;
11204 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11205 break;
11206 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11207 break;
11208 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11209 break;
11210 case 9300: hashes_buf[0].salt->salt_iter = 1;
11211 break;
11212 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11213 break;
11214 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11215 break;
11216 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11217 break;
11218 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11219 break;
11220 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11221 break;
11222 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11223 break;
11224 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11225 break;
11226 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11227 break;
11228 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11229 break;
11230 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11231 break;
11232 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11233 break;
11234 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11235 break;
11236 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11237 break;
11238 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11239 break;
11240 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11241 break;
11242 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11243 break;
11244 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11245 break;
11246 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11247 break;
11248 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11249 break;
11250 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11251 break;
11252 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11253 break;
11254 }
11255
11256 // set special tuning for benchmark-mode 1
11257
11258 if (benchmark_mode == 1)
11259 {
11260 kernel_loops *= 8;
11261 kernel_accel *= 4;
11262
11263 switch (hash_mode)
11264 {
11265 case 400: kernel_loops = ROUNDS_PHPASS;
11266 kernel_accel = 32;
11267 break;
11268 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11269 kernel_accel = 32;
11270 break;
11271 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11272 kernel_accel = 32;
11273 break;
11274 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11275 kernel_accel = 32;
11276 break;
11277 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11278 kernel_accel = 16;
11279 break;
11280 case 2100: kernel_loops = ROUNDS_DCC2;
11281 kernel_accel = 16;
11282 break;
11283 case 2500: kernel_loops = ROUNDS_WPA2;
11284 kernel_accel = 32;
11285 break;
11286 case 3200: kernel_loops = ROUNDS_BCRYPT;
11287 kernel_accel = 8;
11288 break;
11289 case 5200: kernel_loops = ROUNDS_PSAFE3;
11290 kernel_accel = 16;
11291 break;
11292 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11293 kernel_accel = 16;
11294 break;
11295 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11296 kernel_accel = 64;
11297 break;
11298 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11299 kernel_accel = 32;
11300 break;
11301 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11302 kernel_accel = 32;
11303 break;
11304 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11305 kernel_accel = 8;
11306 break;
11307 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11308 kernel_accel = 8;
11309 break;
11310 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11311 kernel_accel = 8;
11312 break;
11313 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11314 kernel_accel = 8;
11315 break;
11316 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11317 kernel_accel = 8;
11318 break;
11319 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11320 kernel_accel = 8;
11321 break;
11322 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11323 kernel_accel = 128;
11324 break;
11325 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11326 kernel_accel = 64;
11327 break;
11328 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11329 kernel_accel = 64;
11330 break;
11331 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11332 kernel_accel = 32;
11333 break;
11334 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11335 kernel_accel = 128;
11336 break;
11337 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11338 kernel_accel = 128;
11339 break;
11340 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11341 kernel_accel = 32;
11342 break;
11343 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11344 kernel_accel = 64;
11345 break;
11346 case 6800: kernel_loops = ROUNDS_LASTPASS;
11347 kernel_accel = 64;
11348 break;
11349 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11350 kernel_accel = 8;
11351 break;
11352 case 7200: kernel_loops = ROUNDS_GRUB;
11353 kernel_accel = 16;
11354 break;
11355 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11356 kernel_accel = 8;
11357 break;
11358 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11359 kernel_accel = 8;
11360 break;
11361 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11362 kernel_accel = 8;
11363 break;
11364 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11365 kernel_accel = 32;
11366 break;
11367 case 8900: kernel_loops = 1;
11368 kernel_accel = 64;
11369 break;
11370 case 9000: kernel_loops = ROUNDS_PSAFE2;
11371 kernel_accel = 16;
11372 break;
11373 case 9100: kernel_loops = ROUNDS_LOTUS8;
11374 kernel_accel = 64;
11375 break;
11376 case 9200: kernel_loops = ROUNDS_CISCO8;
11377 kernel_accel = 8;
11378 break;
11379 case 9300: kernel_loops = 1;
11380 kernel_accel = 4;
11381 break;
11382 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11383 kernel_accel = 32;
11384 break;
11385 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11386 kernel_accel = 32;
11387 break;
11388 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11389 kernel_accel = 8;
11390 break;
11391 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11392 kernel_accel = 8;
11393 break;
11394 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11395 kernel_accel = 16;
11396 break;
11397 case 10500: kernel_loops = ROUNDS_PDF14;
11398 kernel_accel = 256;
11399 break;
11400 case 10700: kernel_loops = ROUNDS_PDF17L8;
11401 kernel_accel = 8;
11402 break;
11403 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11404 kernel_accel = 8;
11405 break;
11406 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11407 kernel_accel = 8;
11408 break;
11409 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11410 kernel_accel = 8;
11411 break;
11412 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11413 kernel_accel = 8;
11414 break;
11415 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11416 kernel_accel = 8;
11417 break;
11418 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11419 kernel_accel = 8;
11420 break;
11421 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11422 kernel_accel = 8;
11423 break;
11424 case 12300: kernel_loops = ROUNDS_ORACLET;
11425 kernel_accel = 8;
11426 break;
11427 case 12500: kernel_loops = ROUNDS_RAR3;
11428 kernel_accel = 32;
11429 break;
11430 case 12700: kernel_loops = ROUNDS_MYWALLET;
11431 kernel_accel = 512;
11432 break;
11433 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11434 kernel_accel = 512;
11435 break;
11436 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11437 kernel_accel = 8;
11438 break;
11439 case 13000: kernel_loops = ROUNDS_RAR5;
11440 kernel_accel = 8;
11441 break;
11442 }
11443
11444 // some algorithm collide too fast, make that impossible
11445
11446 switch (hash_mode)
11447 {
11448 case 11500: ((uint *) digests_buf)[1] = 1;
11449 break;
11450 }
11451
11452 if (kernel_loops > 1024) kernel_loops = 1024;
11453 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11454 }
11455
11456 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11457 {
11458 kernel_loops = 1024;
11459 }
11460
11461 if (hash_mode == 12500)
11462 {
11463 kernel_loops = ROUNDS_RAR3 / 16;
11464 }
11465
11466 data.kernel_accel = kernel_accel;
11467 data.kernel_loops = kernel_loops;
11468
11469 hashes_cnt = 1;
11470 }
11471
11472 if (show == 1 || left == 1)
11473 {
11474 for (uint i = 0; i < pot_cnt; i++)
11475 {
11476 pot_t *pot_ptr = &pot[i];
11477
11478 hash_t *hashes_buf = &pot_ptr->hash;
11479
11480 local_free (hashes_buf->digest);
11481
11482 if (isSalted)
11483 {
11484 local_free (hashes_buf->salt);
11485 }
11486 }
11487
11488 local_free (pot);
11489
11490 if (data.quiet == 0) log_info_nn ("");
11491
11492 return (0);
11493 }
11494
11495 if (keyspace == 0)
11496 {
11497 if (hashes_cnt == 0)
11498 {
11499 log_error ("ERROR: No hashes loaded");
11500
11501 return (-1);
11502 }
11503 }
11504
11505 /**
11506 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11507 */
11508
11509 if (data.outfile != NULL)
11510 {
11511 if (data.hashfile != NULL)
11512 {
11513 #ifdef _POSIX
11514 struct stat tmpstat_outfile;
11515 struct stat tmpstat_hashfile;
11516 #endif
11517
11518 #ifdef _WIN
11519 struct stat64 tmpstat_outfile;
11520 struct stat64 tmpstat_hashfile;
11521 #endif
11522
11523 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11524
11525 if (tmp_outfile_fp)
11526 {
11527 #ifdef _POSIX
11528 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11529 #endif
11530
11531 #ifdef _WIN
11532 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11533 #endif
11534
11535 fclose (tmp_outfile_fp);
11536 }
11537
11538 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11539
11540 if (tmp_hashfile_fp)
11541 {
11542 #ifdef _POSIX
11543 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11544 #endif
11545
11546 #ifdef _WIN
11547 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11548 #endif
11549
11550 fclose (tmp_hashfile_fp);
11551 }
11552
11553 if (tmp_outfile_fp && tmp_outfile_fp)
11554 {
11555 tmpstat_outfile.st_mode = 0;
11556 tmpstat_outfile.st_nlink = 0;
11557 tmpstat_outfile.st_uid = 0;
11558 tmpstat_outfile.st_gid = 0;
11559 tmpstat_outfile.st_rdev = 0;
11560 tmpstat_outfile.st_atime = 0;
11561
11562 tmpstat_hashfile.st_mode = 0;
11563 tmpstat_hashfile.st_nlink = 0;
11564 tmpstat_hashfile.st_uid = 0;
11565 tmpstat_hashfile.st_gid = 0;
11566 tmpstat_hashfile.st_rdev = 0;
11567 tmpstat_hashfile.st_atime = 0;
11568
11569 #ifdef _POSIX
11570 tmpstat_outfile.st_blksize = 0;
11571 tmpstat_outfile.st_blocks = 0;
11572
11573 tmpstat_hashfile.st_blksize = 0;
11574 tmpstat_hashfile.st_blocks = 0;
11575 #endif
11576
11577 #ifdef _POSIX
11578 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11579 {
11580 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11581
11582 return (-1);
11583 }
11584 #endif
11585
11586 #ifdef _WIN
11587 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11588 {
11589 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11590
11591 return (-1);
11592 }
11593 #endif
11594 }
11595 }
11596 }
11597
11598 /**
11599 * Remove duplicates
11600 */
11601
11602 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11603
11604 if (isSalted)
11605 {
11606 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11607 }
11608 else
11609 {
11610 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11611 }
11612
11613 uint hashes_cnt_orig = hashes_cnt;
11614
11615 hashes_cnt = 1;
11616
11617 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11618 {
11619 if (isSalted)
11620 {
11621 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11622 {
11623 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11624 }
11625 }
11626 else
11627 {
11628 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11629 }
11630
11631 if (hashes_pos > hashes_cnt)
11632 {
11633 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11634 }
11635
11636 hashes_cnt++;
11637 }
11638
11639 /**
11640 * Potfile removes
11641 */
11642
11643 uint potfile_remove_cracks = 0;
11644
11645 if (potfile_disable == 0)
11646 {
11647 hash_t hash_buf;
11648
11649 hash_buf.digest = mymalloc (dgst_size);
11650 hash_buf.salt = NULL;
11651 hash_buf.esalt = NULL;
11652 hash_buf.hash_info = NULL;
11653 hash_buf.cracked = 0;
11654
11655 if (isSalted)
11656 {
11657 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11658 }
11659
11660 if (esalt_size)
11661 {
11662 hash_buf.esalt = mymalloc (esalt_size);
11663 }
11664
11665 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11666
11667 // no solution for these special hash types (for instane because they use hashfile in output etc)
11668 if ((hash_mode != 5200) &&
11669 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11670 (hash_mode != 9000))
11671 {
11672 FILE *fp = fopen (potfile, "rb");
11673
11674 if (fp != NULL)
11675 {
11676 while (!feof (fp))
11677 {
11678 char line_buf[BUFSIZ];
11679
11680 memset (line_buf, 0, BUFSIZ);
11681
11682 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11683
11684 if (ptr == NULL) break;
11685
11686 int line_len = strlen (line_buf);
11687
11688 if (line_len == 0) continue;
11689
11690 int iter = MAX_CUT_TRIES;
11691
11692 for (int i = line_len - 1; i && iter; i--, line_len--)
11693 {
11694 if (line_buf[i] != ':') continue;
11695
11696 if (isSalted)
11697 {
11698 memset (hash_buf.salt, 0, sizeof (salt_t));
11699 }
11700
11701 hash_t *found = NULL;
11702
11703 if (hash_mode == 6800)
11704 {
11705 if (i < 48) // 48 = 12 * uint in salt_buf[]
11706 {
11707 // manipulate salt_buf
11708 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11709
11710 hash_buf.salt->salt_len = i;
11711
11712 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11713 }
11714 }
11715 else if (hash_mode == 2500)
11716 {
11717 if (i < 48) // 48 = 12 * uint in salt_buf[]
11718 {
11719 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11720 // manipulate salt_buf
11721
11722 // to be safe work with a copy (because of line_len loop, i etc)
11723
11724 char line_buf_cpy[BUFSIZ];
11725 memset (line_buf_cpy, 0, BUFSIZ);
11726
11727 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11728
11729 memcpy (line_buf_cpy, line_buf, i);
11730
11731 char *mac2_pos = strrchr (line_buf_cpy, ':');
11732
11733 if (mac2_pos == NULL) continue;
11734
11735 mac2_pos[0] = 0;
11736 mac2_pos++;
11737
11738 if (strlen (mac2_pos) != 12) continue;
11739
11740 char *mac1_pos = strrchr (line_buf_cpy, ':');
11741
11742 if (mac1_pos == NULL) continue;
11743
11744 mac1_pos[0] = 0;
11745 mac1_pos++;
11746
11747 if (strlen (mac1_pos) != 12) continue;
11748
11749 uint essid_length = mac1_pos - line_buf_cpy - 1;
11750
11751 // here we need the ESSID
11752 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11753
11754 hash_buf.salt->salt_len = essid_length;
11755
11756 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11757
11758 if (found)
11759 {
11760 wpa_t *wpa = (wpa_t *) found->esalt;
11761
11762 uint pke[25];
11763
11764 char *pke_ptr = (char *) pke;
11765
11766 for (uint i = 0; i < 25; i++)
11767 {
11768 pke[i] = byte_swap_32 (wpa->pke[i]);
11769 }
11770
11771 u8 mac1[6];
11772 u8 mac2[6];
11773
11774 memcpy (mac1, pke_ptr + 23, 6);
11775 memcpy (mac2, pke_ptr + 29, 6);
11776
11777 // compare hex string(s) vs binary MAC address(es)
11778
11779 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11780 {
11781 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11782 {
11783 found = NULL;
11784 break;
11785 }
11786 }
11787
11788 // early skip ;)
11789 if (!found) continue;
11790
11791 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11792 {
11793 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11794 {
11795 found = NULL;
11796 break;
11797 }
11798 }
11799 }
11800 }
11801 }
11802 else
11803 {
11804 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11805
11806 if (parser_status == PARSER_OK)
11807 {
11808 if (isSalted)
11809 {
11810 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11811 }
11812 else
11813 {
11814 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11815 }
11816 }
11817 }
11818
11819 if (found == NULL) continue;
11820
11821 if (!found->cracked) potfile_remove_cracks++;
11822
11823 found->cracked = 1;
11824
11825 if (found) break;
11826
11827 iter--;
11828 }
11829 }
11830
11831 fclose (fp);
11832 }
11833 }
11834
11835 if (esalt_size)
11836 {
11837 local_free (hash_buf.esalt);
11838 }
11839
11840 if (isSalted)
11841 {
11842 local_free (hash_buf.salt);
11843 }
11844
11845 local_free (hash_buf.digest);
11846 }
11847
11848 /**
11849 * Now generate all the buffers required for later
11850 */
11851
11852 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11853
11854 salt_t *salts_buf_new = NULL;
11855 void *esalts_buf_new = NULL;
11856
11857 if (isSalted)
11858 {
11859 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11860
11861 if (esalt_size)
11862 {
11863 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11864 }
11865 }
11866 else
11867 {
11868 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11869 }
11870
11871 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11872
11873 uint digests_cnt = hashes_cnt;
11874 uint digests_done = 0;
11875
11876 uint size_digests = digests_cnt * dgst_size;
11877 uint size_shown = digests_cnt * sizeof (uint);
11878
11879 uint *digests_shown = (uint *) mymalloc (size_shown);
11880 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11881
11882 uint salts_cnt = 0;
11883 uint salts_done = 0;
11884
11885 hashinfo_t **hash_info = NULL;
11886
11887 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11888 {
11889 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11890
11891 if (username && (remove || show))
11892 {
11893 uint user_pos;
11894
11895 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11896 {
11897 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11898
11899 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11900 }
11901 }
11902 }
11903
11904 uint *salts_shown = (uint *) mymalloc (size_shown);
11905
11906 salt_t *salt_buf;
11907
11908 {
11909 // copied from inner loop
11910
11911 salt_buf = &salts_buf_new[salts_cnt];
11912
11913 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11914
11915 if (esalt_size)
11916 {
11917 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11918 }
11919
11920 salt_buf->digests_cnt = 0;
11921 salt_buf->digests_done = 0;
11922 salt_buf->digests_offset = 0;
11923
11924 salts_cnt++;
11925 }
11926
11927 if (hashes_buf[0].cracked == 1)
11928 {
11929 digests_shown[0] = 1;
11930
11931 digests_done++;
11932
11933 salt_buf->digests_done++;
11934 }
11935
11936 salt_buf->digests_cnt++;
11937
11938 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11939
11940 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11941 {
11942 hash_info[0] = hashes_buf[0].hash_info;
11943 }
11944
11945 // copy from inner loop
11946
11947 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11948 {
11949 if (isSalted)
11950 {
11951 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11952 {
11953 salt_buf = &salts_buf_new[salts_cnt];
11954
11955 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11956
11957 if (esalt_size)
11958 {
11959 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11960 }
11961
11962 salt_buf->digests_cnt = 0;
11963 salt_buf->digests_done = 0;
11964 salt_buf->digests_offset = hashes_pos;
11965
11966 salts_cnt++;
11967 }
11968 }
11969
11970 if (hashes_buf[hashes_pos].cracked == 1)
11971 {
11972 digests_shown[hashes_pos] = 1;
11973
11974 digests_done++;
11975
11976 salt_buf->digests_done++;
11977 }
11978
11979 salt_buf->digests_cnt++;
11980
11981 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11982
11983 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11984 {
11985 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11986 }
11987 }
11988
11989 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11990 {
11991 salt_t *salt_buf = &salts_buf_new[salt_pos];
11992
11993 if (salt_buf->digests_done == salt_buf->digests_cnt)
11994 {
11995 salts_shown[salt_pos] = 1;
11996
11997 salts_done++;
11998 }
11999
12000 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12001 }
12002
12003 local_free (digests_buf);
12004 local_free (salts_buf);
12005 local_free (esalts_buf);
12006
12007 digests_buf = digests_buf_new;
12008 salts_buf = salts_buf_new;
12009 esalts_buf = esalts_buf_new;
12010
12011 local_free (hashes_buf);
12012
12013 /**
12014 * special modification not set from parser
12015 */
12016
12017 switch (hash_mode)
12018 {
12019 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12020 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12021 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12022 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12023 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12024 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12025 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12026 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12027 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12028 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12029 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12030 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12031 }
12032
12033 if (truecrypt_keyfiles)
12034 {
12035 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12036
12037 char *keyfiles = strdup (truecrypt_keyfiles);
12038
12039 char *keyfile = strtok (keyfiles, ",");
12040
12041 do
12042 {
12043 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12044
12045 } while ((keyfile = strtok (NULL, ",")) != NULL);
12046
12047 free (keyfiles);
12048 }
12049
12050 data.digests_cnt = digests_cnt;
12051 data.digests_done = digests_done;
12052 data.digests_buf = digests_buf;
12053 data.digests_shown = digests_shown;
12054 data.digests_shown_tmp = digests_shown_tmp;
12055
12056 data.salts_cnt = salts_cnt;
12057 data.salts_done = salts_done;
12058 data.salts_buf = salts_buf;
12059 data.salts_shown = salts_shown;
12060
12061 data.esalts_buf = esalts_buf;
12062 data.hash_info = hash_info;
12063
12064 /**
12065 * Automatic Optimizers
12066 */
12067
12068 if (salts_cnt == 1)
12069 opti_type |= OPTI_TYPE_SINGLE_SALT;
12070
12071 if (digests_cnt == 1)
12072 opti_type |= OPTI_TYPE_SINGLE_HASH;
12073
12074 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12075 opti_type |= OPTI_TYPE_NOT_ITERATED;
12076
12077 if (attack_mode == ATTACK_MODE_BF)
12078 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12079
12080 data.opti_type = opti_type;
12081
12082 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12083 {
12084 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12085 {
12086 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12087 {
12088 if (opts_type & OPTS_TYPE_ST_ADD80)
12089 {
12090 opts_type &= ~OPTS_TYPE_ST_ADD80;
12091 opts_type |= OPTS_TYPE_PT_ADD80;
12092 }
12093
12094 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12095 {
12096 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12097 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12098 }
12099
12100 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12101 {
12102 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12103 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12104 }
12105 }
12106 }
12107 }
12108
12109 /**
12110 * Some algorithm, like descrypt, can benefit from JIT compilation
12111 */
12112
12113 int force_jit_compilation = -1;
12114
12115 if (hash_mode == 8900)
12116 {
12117 force_jit_compilation = 8900;
12118 }
12119 else if (hash_mode == 9300)
12120 {
12121 force_jit_compilation = 8900;
12122 }
12123 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12124 {
12125 force_jit_compilation = 1500;
12126 }
12127
12128 /**
12129 * generate bitmap tables
12130 */
12131
12132 const uint bitmap_shift1 = 5;
12133 const uint bitmap_shift2 = 13;
12134
12135 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12136
12137 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12138 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12139 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12140 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12141 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12142 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12143 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12144 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12145
12146 uint bitmap_bits;
12147 uint bitmap_nums;
12148 uint bitmap_mask;
12149 uint bitmap_size;
12150
12151 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12152 {
12153 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12154
12155 bitmap_nums = 1 << bitmap_bits;
12156
12157 bitmap_mask = bitmap_nums - 1;
12158
12159 bitmap_size = bitmap_nums * sizeof (uint);
12160
12161 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12162
12163 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;
12164 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;
12165
12166 break;
12167 }
12168
12169 bitmap_nums = 1 << bitmap_bits;
12170
12171 bitmap_mask = bitmap_nums - 1;
12172
12173 bitmap_size = bitmap_nums * sizeof (uint);
12174
12175 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);
12176 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);
12177
12178 /**
12179 * prepare quick rule
12180 */
12181
12182 data.rule_buf_l = rule_buf_l;
12183 data.rule_buf_r = rule_buf_r;
12184
12185 int rule_len_l = (int) strlen (rule_buf_l);
12186 int rule_len_r = (int) strlen (rule_buf_r);
12187
12188 data.rule_len_l = rule_len_l;
12189 data.rule_len_r = rule_len_r;
12190
12191 /**
12192 * load rules
12193 */
12194
12195 uint *all_kernel_rules_cnt = NULL;
12196
12197 kernel_rule_t **all_kernel_rules_buf = NULL;
12198
12199 if (rp_files_cnt)
12200 {
12201 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12202
12203 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12204 }
12205
12206 char rule_buf[BUFSIZ];
12207
12208 int rule_len = 0;
12209
12210 for (uint i = 0; i < rp_files_cnt; i++)
12211 {
12212 uint kernel_rules_avail = 0;
12213
12214 uint kernel_rules_cnt = 0;
12215
12216 kernel_rule_t *kernel_rules_buf = NULL;
12217
12218 char *rp_file = rp_files[i];
12219
12220 char in[BLOCK_SIZE];
12221 char out[BLOCK_SIZE];
12222
12223 FILE *fp = NULL;
12224
12225 uint rule_line = 0;
12226
12227 if ((fp = fopen (rp_file, "rb")) == NULL)
12228 {
12229 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12230
12231 return (-1);
12232 }
12233
12234 while (!feof (fp))
12235 {
12236 memset (rule_buf, 0, BUFSIZ);
12237
12238 rule_len = fgetl (fp, rule_buf);
12239
12240 rule_line++;
12241
12242 if (rule_len == 0) continue;
12243
12244 if (rule_buf[0] == '#') continue;
12245
12246 if (kernel_rules_avail == kernel_rules_cnt)
12247 {
12248 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12249
12250 kernel_rules_avail += INCR_RULES;
12251 }
12252
12253 memset (in, 0, BLOCK_SIZE);
12254 memset (out, 0, BLOCK_SIZE);
12255
12256 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12257
12258 if (result == -1)
12259 {
12260 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12261
12262 continue;
12263 }
12264
12265 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12266 {
12267 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12268
12269 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12270
12271 continue;
12272 }
12273
12274 /* its so slow
12275 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12276 {
12277 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12278
12279 continue;
12280 }
12281 */
12282
12283 kernel_rules_cnt++;
12284 }
12285
12286 fclose (fp);
12287
12288 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12289
12290 all_kernel_rules_buf[i] = kernel_rules_buf;
12291 }
12292
12293 /**
12294 * merge rules or automatic rule generator
12295 */
12296
12297 uint kernel_rules_cnt = 0;
12298
12299 kernel_rule_t *kernel_rules_buf = NULL;
12300
12301 if (attack_mode == ATTACK_MODE_STRAIGHT)
12302 {
12303 if (rp_files_cnt)
12304 {
12305 kernel_rules_cnt = 1;
12306
12307 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12308
12309 repeats[0] = kernel_rules_cnt;
12310
12311 for (uint i = 0; i < rp_files_cnt; i++)
12312 {
12313 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12314
12315 repeats[i + 1] = kernel_rules_cnt;
12316 }
12317
12318 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12319
12320 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12321
12322 for (uint i = 0; i < kernel_rules_cnt; i++)
12323 {
12324 uint out_pos = 0;
12325
12326 kernel_rule_t *out = &kernel_rules_buf[i];
12327
12328 for (uint j = 0; j < rp_files_cnt; j++)
12329 {
12330 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12331 uint in_pos;
12332
12333 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12334
12335 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12336 {
12337 if (out_pos == RULES_MAX - 1)
12338 {
12339 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12340
12341 break;
12342 }
12343
12344 out->cmds[out_pos] = in->cmds[in_pos];
12345 }
12346 }
12347 }
12348
12349 local_free (repeats);
12350 }
12351 else if (rp_gen)
12352 {
12353 uint kernel_rules_avail = 0;
12354
12355 while (kernel_rules_cnt < rp_gen)
12356 {
12357 if (kernel_rules_avail == kernel_rules_cnt)
12358 {
12359 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12360
12361 kernel_rules_avail += INCR_RULES;
12362 }
12363
12364 memset (rule_buf, 0, BLOCK_SIZE);
12365
12366 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12367
12368 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12369
12370 kernel_rules_cnt++;
12371 }
12372 }
12373 }
12374
12375 /**
12376 * generate NOP rules
12377 */
12378
12379 if (kernel_rules_cnt == 0)
12380 {
12381 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12382
12383 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12384
12385 kernel_rules_cnt++;
12386 }
12387
12388 data.kernel_rules_cnt = kernel_rules_cnt;
12389 data.kernel_rules_buf = kernel_rules_buf;
12390
12391 /**
12392 * OpenCL platforms: detect
12393 */
12394
12395 cl_platform_id platforms[CL_PLATFORMS_MAX];
12396
12397 cl_uint platforms_cnt = 0;
12398
12399 cl_device_id platform_devices[DEVICES_MAX];
12400
12401 cl_uint platform_devices_cnt;
12402
12403 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12404
12405 if (platforms_cnt == 0)
12406 {
12407 log_error ("ERROR: No OpenCL compatible platform found");
12408
12409 return (-1);
12410 }
12411
12412 /**
12413 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12414 */
12415
12416 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12417 {
12418 cl_platform_id platform = platforms[platform_id];
12419
12420 char platform_vendor[INFOSZ] = { 0 };
12421
12422 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12423
12424 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12425 {
12426 // make sure that we do not directly control the fan for NVidia
12427
12428 gpu_temp_retain = 0;
12429
12430 data.gpu_temp_retain = gpu_temp_retain;
12431 }
12432 }
12433
12434 /**
12435 * OpenCL devices: simply push all devices from all platforms into the same device array
12436 */
12437
12438 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12439
12440 data.devices_param = devices_param;
12441
12442 uint devices_cnt = 0;
12443
12444 uint devices_active = 0;
12445
12446 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12447 {
12448 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12449
12450 cl_platform_id platform = platforms[platform_id];
12451
12452 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12453
12454 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12455 {
12456 const uint device_id = devices_cnt;
12457
12458 hc_device_param_t *device_param = &data.devices_param[device_id];
12459
12460 device_param->device = platform_devices[platform_devices_id];
12461
12462 device_param->device_id = device_id;
12463
12464 device_param->platform_devices_id = platform_devices_id;
12465
12466 // vendor_id
12467
12468 cl_uint vendor_id = 0;
12469
12470 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12471
12472 device_param->vendor_id = vendor_id;
12473
12474 // device_type
12475
12476 cl_device_type device_type;
12477
12478 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12479
12480 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12481
12482 device_param->device_type = device_type;
12483
12484 // device_name
12485
12486 char *device_name = (char *) mymalloc (INFOSZ);
12487
12488 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12489
12490 device_param->device_name = device_name;
12491
12492 // device_version
12493
12494 char *device_version = (char *) mymalloc (INFOSZ);
12495
12496 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12497
12498 device_param->device_version = device_version;
12499
12500 if (strstr (device_version, "pocl"))
12501 {
12502 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12503 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12504
12505 cl_uint vendor_id = 0xffff;
12506
12507 device_param->vendor_id = vendor_id;
12508 }
12509
12510 // max_compute_units
12511
12512 cl_uint vector_width;
12513
12514 if (attack_mode == ATTACK_MODE_BF)
12515 {
12516 if (opencl_vector_width == OPENCL_VECTOR_WIDTH)
12517 {
12518 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
12519 }
12520 else
12521 {
12522 vector_width = opencl_vector_width;
12523 }
12524 }
12525 else
12526 {
12527 vector_width = 1;
12528 }
12529
12530 if (vector_width > 8) vector_width = 8;
12531
12532 device_param->vector_width = vector_width;
12533
12534 // max_compute_units
12535
12536 cl_uint device_processors;
12537
12538 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12539
12540 device_param->device_processors = device_processors;
12541
12542 // max_mem_alloc_size
12543
12544 cl_ulong device_maxmem_alloc;
12545
12546 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12547
12548 device_param->device_maxmem_alloc = device_maxmem_alloc;
12549
12550 // max_mem_alloc_size
12551
12552 cl_ulong device_global_mem;
12553
12554 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12555
12556 device_param->device_global_mem = device_global_mem;
12557
12558 // max_clock_frequency
12559
12560 cl_uint device_maxclock_frequency;
12561
12562 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12563
12564 device_param->device_maxclock_frequency = device_maxclock_frequency;
12565
12566 // skipped
12567
12568 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12569 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12570
12571 device_param->skipped = (skipped1 || skipped2);
12572
12573 // driver_version
12574
12575 char *driver_version = (char *) mymalloc (INFOSZ);
12576
12577 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12578
12579 device_param->driver_version = driver_version;
12580
12581 // device_name_chksum
12582
12583 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12584
12585 #if __x86_64__
12586 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12587 #else
12588 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12589 #endif
12590
12591 uint device_name_digest[4];
12592
12593 device_name_digest[0] = 0;
12594 device_name_digest[1] = 0;
12595 device_name_digest[2] = 0;
12596 device_name_digest[3] = 0;
12597
12598 md5_64 ((uint *) device_name_chksum, device_name_digest);
12599
12600 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12601
12602 device_param->device_name_chksum = device_name_chksum;
12603
12604 // device_processor_cores
12605
12606 if (device_type & CL_DEVICE_TYPE_CPU)
12607 {
12608 cl_uint device_processor_cores = 1;
12609
12610 device_param->device_processor_cores = device_processor_cores;
12611 }
12612
12613 if (device_type & CL_DEVICE_TYPE_GPU)
12614 {
12615 if (vendor_id == VENDOR_ID_AMD)
12616 {
12617 cl_uint device_processor_cores = 0;
12618
12619 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12620
12621 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12622
12623 device_param->device_processor_cores = device_processor_cores;
12624 }
12625 else if (vendor_id == VENDOR_ID_NV)
12626 {
12627 cl_uint kernel_exec_timeout = 0;
12628
12629 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12630
12631 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12632
12633 device_param->kernel_exec_timeout = kernel_exec_timeout;
12634
12635 cl_uint device_processor_cores = 0;
12636
12637 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12638
12639 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12640
12641 device_param->device_processor_cores = device_processor_cores;
12642
12643 cl_uint sm_minor = 0;
12644 cl_uint sm_major = 0;
12645
12646 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12647 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12648
12649 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12650 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12651
12652 device_param->sm_minor = sm_minor;
12653 device_param->sm_major = sm_major;
12654 }
12655 else
12656 {
12657 cl_uint device_processor_cores = 1;
12658
12659 device_param->device_processor_cores = device_processor_cores;
12660 }
12661 }
12662
12663 // display results
12664
12665 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12666 {
12667 if (device_param->skipped == 0)
12668 {
12669 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12670 device_id + 1,
12671 device_name,
12672 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12673 (unsigned int) (device_global_mem / 1024 / 1024),
12674 (unsigned int) (device_maxclock_frequency),
12675 (unsigned int) device_processors);
12676 }
12677 else
12678 {
12679 log_info ("Device #%u: %s, skipped",
12680 device_id + 1,
12681 device_name);
12682 }
12683 }
12684
12685 // common driver check
12686
12687 if (device_param->skipped == 0)
12688 {
12689 if (strstr (device_version, "pocl"))
12690 {
12691 if (force == 0)
12692 {
12693 log_info ("");
12694 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12695 log_info ("You are STRONGLY encouraged not to use it");
12696 log_info ("You can use --force to override this but do not post error reports if you do so");
12697 log_info ("");
12698
12699 return (-1);
12700 }
12701 }
12702
12703 if (device_type & CL_DEVICE_TYPE_GPU)
12704 {
12705 if (vendor_id == VENDOR_ID_NV)
12706 {
12707 if (device_param->kernel_exec_timeout != 0)
12708 {
12709 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);
12710 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12711 }
12712 }
12713 else if (vendor_id == VENDOR_ID_AMD)
12714 {
12715 int catalyst_check = (force == 1) ? 0 : 1;
12716
12717 int catalyst_warn = 0;
12718
12719 int catalyst_broken = 0;
12720
12721 if (catalyst_check == 1)
12722 {
12723 catalyst_warn = 1;
12724
12725 // v14.9 and higher
12726 if (atoi (device_param->driver_version) >= 1573)
12727 {
12728 catalyst_warn = 0;
12729 }
12730
12731 catalyst_check = 0;
12732 }
12733
12734 if (catalyst_broken == 1)
12735 {
12736 log_info ("");
12737 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12738 log_info ("It will pass over cracked hashes and does not report them as cracked");
12739 log_info ("You are STRONGLY encouraged not to use it");
12740 log_info ("You can use --force to override this but do not post error reports if you do so");
12741 log_info ("");
12742
12743 return (-1);
12744 }
12745
12746 if (catalyst_warn == 1)
12747 {
12748 log_info ("");
12749 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12750 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12751 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12752 #ifdef _WIN
12753 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12754 #endif
12755 log_info ("You can use --force to override this but do not post error reports if you do so");
12756 log_info ("");
12757
12758 return (-1);
12759 }
12760 }
12761 }
12762
12763 devices_active++;
12764 }
12765
12766 // next please
12767
12768 devices_cnt++;
12769 }
12770 }
12771
12772 if (devices_active == 0)
12773 {
12774 log_error ("ERROR: No devices found/left");
12775
12776 return (-1);
12777 }
12778
12779 data.devices_cnt = devices_cnt;
12780
12781 data.devices_active = devices_active;
12782
12783 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12784 {
12785 log_info ("");
12786 }
12787
12788 /**
12789 * OpenCL devices: allocate buffer for device specific information
12790 */
12791
12792 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12793
12794 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12795
12796 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12797
12798 /**
12799 * enable custom signal handler(s)
12800 */
12801
12802 if (benchmark == 0)
12803 {
12804 hc_signal (sigHandler_default);
12805 }
12806 else
12807 {
12808 hc_signal (sigHandler_benchmark);
12809 }
12810
12811 /**
12812 * User-defined GPU temp handling
12813 */
12814
12815 if (gpu_temp_disable == 1)
12816 {
12817 gpu_temp_abort = 0;
12818 gpu_temp_retain = 0;
12819 }
12820
12821 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12822 {
12823 if (gpu_temp_abort < gpu_temp_retain)
12824 {
12825 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12826
12827 return (-1);
12828 }
12829 }
12830
12831 data.gpu_temp_disable = gpu_temp_disable;
12832 data.gpu_temp_abort = gpu_temp_abort;
12833 data.gpu_temp_retain = gpu_temp_retain;
12834
12835 /**
12836 * inform the user
12837 */
12838
12839 if (data.quiet == 0)
12840 {
12841 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12842
12843 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);
12844
12845 if (attack_mode == ATTACK_MODE_STRAIGHT)
12846 {
12847 log_info ("Rules: %u", kernel_rules_cnt);
12848 }
12849
12850 if (opti_type)
12851 {
12852 log_info ("Applicable Optimizers:");
12853
12854 for (uint i = 0; i < 32; i++)
12855 {
12856 const uint opti_bit = 1u << i;
12857
12858 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12859 }
12860 }
12861
12862 /**
12863 * Watchdog and Temperature balance
12864 */
12865
12866 if (gpu_temp_abort == 0)
12867 {
12868 log_info ("Watchdog: Temperature abort trigger disabled");
12869 }
12870 else
12871 {
12872 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12873 }
12874
12875 if (gpu_temp_retain == 0)
12876 {
12877 log_info ("Watchdog: Temperature retain trigger disabled");
12878 }
12879 else
12880 {
12881 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12882 }
12883 }
12884
12885 if (data.quiet == 0) log_info ("");
12886
12887 /**
12888 * HM devices: init
12889 */
12890
12891 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12892 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12893
12894 if (gpu_temp_disable == 0)
12895 {
12896 #ifdef WIN
12897 if (NvAPI_Initialize () == NVAPI_OK)
12898 {
12899 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12900
12901 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12902
12903 int tmp_out = 0;
12904
12905 for (int i = 0; i < tmp_in; i++)
12906 {
12907 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12908 }
12909
12910 for (int i = 0; i < tmp_out; i++)
12911 {
12912 NvU32 speed;
12913
12914 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12915 }
12916 }
12917 #endif
12918
12919 #ifdef LINUX
12920 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12921
12922 data.hm_dll_nv = hm_dll_nv;
12923
12924 if (hm_dll_nv)
12925 {
12926 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12927 {
12928 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12929
12930 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12931
12932 int tmp_out = 0;
12933
12934 for (int i = 0; i < tmp_in; i++)
12935 {
12936 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12937 }
12938
12939 for (int i = 0; i < tmp_out; i++)
12940 {
12941 unsigned int speed;
12942
12943 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;
12944 }
12945 }
12946 }
12947 #endif
12948
12949 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12950
12951 data.hm_dll_amd = hm_dll_amd;
12952
12953 if (hm_dll_amd)
12954 {
12955 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12956 {
12957 // total number of adapters
12958
12959 int hm_adapters_num;
12960
12961 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12962
12963 // adapter info
12964
12965 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12966
12967 if (lpAdapterInfo == NULL) return (-1);
12968
12969 // get a list (of ids of) valid/usable adapters
12970
12971 int num_adl_adapters = 0;
12972
12973 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12974
12975 if (num_adl_adapters > 0)
12976 {
12977 hc_thread_mutex_lock (mux_adl);
12978
12979 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12980
12981 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12982
12983 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12984 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12985
12986 hc_thread_mutex_unlock (mux_adl);
12987 }
12988
12989 myfree (valid_adl_device_list);
12990 myfree (lpAdapterInfo);
12991 }
12992 }
12993 }
12994
12995 /**
12996 * HM devices: copy
12997 */
12998
12999 if (gpu_temp_disable == 0)
13000 {
13001 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13002 {
13003 hc_device_param_t *device_param = &data.devices_param[device_id];
13004
13005 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13006
13007 if (device_param->skipped) continue;
13008
13009 const uint platform_devices_id = device_param->platform_devices_id;
13010
13011 if (device_param->vendor_id == VENDOR_ID_NV)
13012 {
13013 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13014 }
13015
13016 if (device_param->vendor_id == VENDOR_ID_AMD)
13017 {
13018 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
13019 }
13020 }
13021 }
13022
13023 /*
13024 * Temporary fix:
13025 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
13026 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
13027 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
13028 * Driver / ADL bug?
13029 */
13030
13031 if (powertune_enable == 1)
13032 {
13033 hc_thread_mutex_lock (mux_adl);
13034
13035 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13036 {
13037 hc_device_param_t *device_param = &data.devices_param[device_id];
13038
13039 if (device_param->skipped) continue;
13040
13041 if (data.hm_device[device_id].od_version == 6)
13042 {
13043 // set powertune value only
13044
13045 int powertune_supported = 0;
13046
13047 int ADL_rc = 0;
13048
13049 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13050 {
13051 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13052
13053 return (-1);
13054 }
13055
13056 if (powertune_supported != 0)
13057 {
13058 // powertune set
13059 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13060
13061 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13062 {
13063 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13064
13065 return (-1);
13066 }
13067
13068 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13069 {
13070 log_error ("ERROR: Failed to set new ADL PowerControl values");
13071
13072 return (-1);
13073 }
13074 }
13075 }
13076 }
13077
13078 hc_thread_mutex_unlock (mux_adl);
13079 }
13080
13081 uint kernel_blocks_all = 0;
13082
13083 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13084 {
13085 /**
13086 * host buffer
13087 */
13088
13089 hc_device_param_t *device_param = &data.devices_param[device_id];
13090
13091 if (device_param->skipped) continue;
13092
13093 /**
13094 * device properties
13095 */
13096
13097 char *device_name_chksum = device_param->device_name_chksum;
13098
13099 uint device_processors = device_param->device_processors;
13100
13101 uint device_processor_cores = device_param->device_processor_cores;
13102
13103 cl_device_type device_type = device_param->device_type;
13104
13105 /**
13106 * create context for each device
13107 */
13108
13109 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13110
13111 /**
13112 * create command-queue
13113 */
13114
13115 // not support with NV
13116 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13117
13118 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13119
13120 /**
13121 * create input buffers on device
13122 */
13123
13124 uint kernel_threads = KERNEL_THREADS;
13125
13126 // bcrypt
13127 if (hash_mode == 3200) kernel_threads = 8;
13128 if (hash_mode == 9000) kernel_threads = 8;
13129
13130 if (device_type & CL_DEVICE_TYPE_CPU)
13131 {
13132 // CPU still need lots of workitems, don't know why...
13133 // for testing phase, lets start with this
13134
13135 // kernel_accel = 1;
13136 }
13137
13138 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13139 uint kernel_blocks = kernel_power;
13140
13141 device_param->kernel_threads = kernel_threads;
13142 device_param->kernel_power_user = kernel_power;
13143 device_param->kernel_blocks_user = kernel_blocks;
13144
13145 kernel_blocks_all += kernel_blocks;
13146
13147 uint size_pws = kernel_power * sizeof (pw_t);
13148
13149 uint size_tmps = 4;
13150
13151 switch (hash_mode)
13152 {
13153 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13154 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13155 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13156 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13157 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13158 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13159 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13160 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13161 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13162 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13163 case 6211:
13164 case 6212:
13165 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13166 case 6221:
13167 case 6222:
13168 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13169 case 6231:
13170 case 6232:
13171 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13172 case 6241:
13173 case 6242:
13174 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13175 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13176 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13177 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13178 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13179 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13180 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13181 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13182 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13183 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13184 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13185 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13186 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13187 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13188 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13189 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13190 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13191 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13192 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13193 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13194 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13195 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13196 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13197 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13198 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13199 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13200 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13201 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13202 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13203 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13204 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13205 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13206 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13207 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13208 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13209 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13210 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13211 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13212 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13213 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13214 };
13215
13216 uint size_hooks = 4;
13217
13218 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13219 {
13220 // insert correct hook size
13221 }
13222
13223 // we can optimize some stuff here...
13224
13225 device_param->size_pws = size_pws;
13226 device_param->size_tmps = size_tmps;
13227 device_param->size_hooks = size_hooks;
13228
13229 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13230 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13231
13232 device_param->size_root_css = size_root_css;
13233 device_param->size_markov_css = size_markov_css;
13234
13235 uint size_results = KERNEL_THREADS * sizeof (uint);
13236
13237 device_param->size_results = size_results;
13238
13239 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13240 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13241
13242 uint size_plains = digests_cnt * sizeof (plain_t);
13243 uint size_salts = salts_cnt * sizeof (salt_t);
13244 uint size_esalts = salts_cnt * esalt_size;
13245
13246 device_param->size_plains = size_plains;
13247 device_param->size_digests = size_digests;
13248 device_param->size_shown = size_shown;
13249 device_param->size_salts = size_salts;
13250
13251 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13252 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13253 uint size_tm = 32 * sizeof (bs_word_t);
13254
13255 u64 size_scryptV = 1;
13256
13257 if ((hash_mode == 8900) || (hash_mode == 9300))
13258 {
13259 uint tmto_start = 0;
13260 uint tmto_stop = 10;
13261
13262 if (scrypt_tmto)
13263 {
13264 tmto_start = scrypt_tmto;
13265 }
13266 else
13267 {
13268 // in case the user did not specify the tmto manually
13269 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13270 // but set the lower end only in case the user has a device with too less memory
13271
13272 if (hash_mode == 8900)
13273 {
13274 if (device_param->vendor_id == VENDOR_ID_AMD)
13275 {
13276 tmto_start = 1;
13277 }
13278 else if (device_param->vendor_id == VENDOR_ID_NV)
13279 {
13280 tmto_start = 3;
13281 }
13282 }
13283 else if (hash_mode == 9300)
13284 {
13285 if (device_param->vendor_id == VENDOR_ID_AMD)
13286 {
13287 tmto_start = 3;
13288 }
13289 else if (device_param->vendor_id == VENDOR_ID_NV)
13290 {
13291 tmto_start = 5;
13292 }
13293 }
13294 }
13295
13296 if (quiet == 0) log_info ("");
13297
13298 uint shader_per_mp = 1;
13299
13300 if (device_param->vendor_id == VENDOR_ID_AMD)
13301 {
13302 shader_per_mp = 8;
13303 }
13304 else if (device_param->vendor_id == VENDOR_ID_NV)
13305 {
13306 shader_per_mp = 32;
13307 }
13308
13309 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13310 {
13311 // TODO: in theory the following calculation needs to be done per salt, not global
13312 // we assume all hashes have the same scrypt settings
13313
13314 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13315
13316 size_scryptV /= 1 << tmto;
13317
13318 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13319
13320 if (size_scryptV > device_param->device_maxmem_alloc)
13321 {
13322 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13323
13324 continue;
13325 }
13326
13327 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13328 {
13329 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13330 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13331 }
13332
13333 break;
13334 }
13335
13336 if (data.salts_buf[0].scrypt_phy == 0)
13337 {
13338 log_error ("ERROR: can't allocate enough device memory");
13339
13340 return -1;
13341 }
13342
13343 if (quiet == 0) log_info ("");
13344 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13345 }
13346
13347 /**
13348 * default building options
13349 */
13350
13351 char build_opts[1024];
13352
13353 // we don't have sm_* on vendors not NV but it doesn't matter
13354
13355 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d -DVECT_SIZE=%u", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width);
13356
13357 /**
13358 * main kernel
13359 */
13360
13361 {
13362 /**
13363 * kernel source filename
13364 */
13365
13366 char source_file[256] = { 0 };
13367
13368 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13369
13370 struct stat sst;
13371
13372 if (stat (source_file, &sst) == -1)
13373 {
13374 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13375
13376 return -1;
13377 }
13378
13379 /**
13380 * kernel cached filename
13381 */
13382
13383 char cached_file[256] = { 0 };
13384
13385 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13386
13387 int cached = 1;
13388
13389 struct stat cst;
13390
13391 if (stat (cached_file, &cst) == -1)
13392 {
13393 cached = 0;
13394 }
13395
13396 /**
13397 * kernel compile or load
13398 */
13399
13400 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13401
13402 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13403
13404 if (force_jit_compilation == -1)
13405 {
13406 if (cached == 0)
13407 {
13408 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13409
13410 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13411
13412 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13413
13414 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13415
13416 size_t binary_size;
13417
13418 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13419
13420 u8 *binary = (u8 *) mymalloc (binary_size);
13421
13422 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13423
13424 writeProgramBin (cached_file, binary, binary_size);
13425
13426 local_free (binary);
13427 }
13428 else
13429 {
13430 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13431
13432 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13433
13434 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13435
13436 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13437 }
13438 }
13439 else
13440 {
13441 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13442
13443 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13444
13445 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13446
13447 if (force_jit_compilation == 1500)
13448 {
13449 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13450 }
13451 else if (force_jit_compilation == 8900)
13452 {
13453 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);
13454 }
13455
13456 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13457 }
13458
13459 local_free (kernel_lengths);
13460 local_free (kernel_sources[0]);
13461 local_free (kernel_sources);
13462
13463 // this is mostly for debug
13464
13465 size_t ret_val_size = 0;
13466
13467 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13468
13469 if (ret_val_size > 2)
13470 {
13471 char *build_log = (char *) mymalloc (ret_val_size + 1);
13472
13473 memset (build_log, 0, ret_val_size + 1);
13474
13475 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13476
13477 puts (build_log);
13478
13479 myfree (build_log);
13480 }
13481 }
13482
13483 /**
13484 * word generator kernel
13485 */
13486
13487 if (attack_mode != ATTACK_MODE_STRAIGHT)
13488 {
13489 /**
13490 * kernel mp source filename
13491 */
13492
13493 char source_file[256] = { 0 };
13494
13495 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13496
13497 struct stat sst;
13498
13499 if (stat (source_file, &sst) == -1)
13500 {
13501 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13502
13503 return -1;
13504 }
13505
13506 /**
13507 * kernel mp cached filename
13508 */
13509
13510 char cached_file[256] = { 0 };
13511
13512 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13513
13514 int cached = 1;
13515
13516 struct stat cst;
13517
13518 if (stat (cached_file, &cst) == -1)
13519 {
13520 cached = 0;
13521 }
13522
13523 /**
13524 * kernel compile or load
13525 */
13526
13527 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13528
13529 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13530
13531 if (cached == 0)
13532 {
13533 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13534
13535 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13536
13537 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13538
13539 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13540
13541 size_t binary_size;
13542
13543 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13544
13545 u8 *binary = (u8 *) mymalloc (binary_size);
13546
13547 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13548
13549 writeProgramBin (cached_file, binary, binary_size);
13550
13551 local_free (binary);
13552 }
13553 else
13554 {
13555 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13556
13557 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13558
13559 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13560
13561 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13562 }
13563
13564 local_free (kernel_lengths);
13565 local_free (kernel_sources[0]);
13566 local_free (kernel_sources);
13567
13568 // this is mostly for debug
13569
13570 size_t ret_val_size = 0;
13571
13572 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13573
13574 if (ret_val_size > 2)
13575 {
13576 char *build_log = (char *) mymalloc (ret_val_size + 1);
13577
13578 memset (build_log, 0, ret_val_size + 1);
13579
13580 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13581
13582 puts (build_log);
13583
13584 myfree (build_log);
13585 }
13586 }
13587
13588 /**
13589 * amplifier kernel
13590 */
13591
13592 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13593 {
13594
13595 }
13596 else
13597 {
13598 /**
13599 * kernel amp source filename
13600 */
13601
13602 char source_file[256] = { 0 };
13603
13604 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13605
13606 struct stat sst;
13607
13608 if (stat (source_file, &sst) == -1)
13609 {
13610 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13611
13612 return -1;
13613 }
13614
13615 /**
13616 * kernel amp cached filename
13617 */
13618
13619 char cached_file[256] = { 0 };
13620
13621 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13622
13623 int cached = 1;
13624
13625 struct stat cst;
13626
13627 if (stat (cached_file, &cst) == -1)
13628 {
13629 cached = 0;
13630 }
13631
13632 /**
13633 * kernel compile or load
13634 */
13635
13636 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13637
13638 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13639
13640 if (cached == 0)
13641 {
13642 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13643
13644 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13645
13646 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13647
13648 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13649
13650 size_t binary_size;
13651
13652 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13653
13654 u8 *binary = (u8 *) mymalloc (binary_size);
13655
13656 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13657
13658 writeProgramBin (cached_file, binary, binary_size);
13659
13660 local_free (binary);
13661 }
13662 else
13663 {
13664 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13665
13666 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13667
13668 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13669
13670 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13671 }
13672
13673 local_free (kernel_lengths);
13674 local_free (kernel_sources[0]);
13675 local_free (kernel_sources);
13676
13677 // this is mostly for debug
13678
13679 size_t ret_val_size = 0;
13680
13681 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13682
13683 if (ret_val_size > 2)
13684 {
13685 char *build_log = (char *) mymalloc (ret_val_size + 1);
13686
13687 memset (build_log, 0, ret_val_size + 1);
13688
13689 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13690
13691 puts (build_log);
13692
13693 myfree (build_log);
13694 }
13695 }
13696
13697 /**
13698 * global buffers
13699 */
13700
13701 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13702 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13703 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13704 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13705 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13706 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13707 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13708 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13709 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13710 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13711 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13712 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13713 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13714 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13715 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13716 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13717 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13718 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13719
13720 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13721 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13722 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13723 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13724 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13725 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13726 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13727 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13728 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13729 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13730 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13731
13732 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13733 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13734 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13735 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13736 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13737 run_kernel_bzero (device_param, device_param->d_result, size_results);
13738
13739 /**
13740 * special buffers
13741 */
13742
13743 if (attack_kern == ATTACK_KERN_STRAIGHT)
13744 {
13745 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13746 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13747
13748 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13749
13750 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13751 }
13752 else if (attack_kern == ATTACK_KERN_COMBI)
13753 {
13754 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13755 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13756 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13757 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13758
13759 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13760 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13761 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13762 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13763 }
13764 else if (attack_kern == ATTACK_KERN_BF)
13765 {
13766 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13767 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13768 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13769 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13770 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13771
13772 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13773 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13774 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13775 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13776 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13777 }
13778
13779 if (size_esalts)
13780 {
13781 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13782
13783 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13784 }
13785
13786 /**
13787 * main host data
13788 */
13789
13790 uint *result = (uint *) mymalloc (size_results);
13791
13792 memset (result, 0, size_results);
13793
13794 device_param->result = result;
13795
13796 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13797
13798 memset (pws_buf, 0, size_pws);
13799
13800 device_param->pws_buf = pws_buf;
13801
13802 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13803
13804 for (int i = 0; i < 64; i++)
13805 {
13806 pw_caches[i].pw_buf.pw_len = i;
13807 pw_caches[i].cnt = 0;
13808 }
13809
13810 device_param->pw_caches = pw_caches;
13811
13812 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13813
13814 device_param->combs_buf = combs_buf;
13815
13816 void *hooks_buf = mymalloc (size_hooks);
13817
13818 device_param->hooks_buf = hooks_buf;
13819
13820 device_param->pw_transpose = pw_transpose_to_hi1;
13821 device_param->pw_add = pw_add_to_hc1;
13822
13823 /**
13824 * kernel args
13825 */
13826
13827 device_param->kernel_params_buf32[21] = bitmap_mask;
13828 device_param->kernel_params_buf32[22] = bitmap_shift1;
13829 device_param->kernel_params_buf32[23] = bitmap_shift2;
13830 device_param->kernel_params_buf32[24] = 0; // salt_pos
13831 device_param->kernel_params_buf32[25] = 0; // loop_pos
13832 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13833 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13834 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13835 device_param->kernel_params_buf32[29] = 0; // digests_offset
13836 device_param->kernel_params_buf32[30] = 0; // combs_mode
13837 device_param->kernel_params_buf32[31] = 0; // gid_max
13838
13839 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13840 ? &device_param->d_pws_buf
13841 : &device_param->d_pws_amp_buf;
13842 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13843 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13844 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13845 device_param->kernel_params[ 4] = &device_param->d_tmps;
13846 device_param->kernel_params[ 5] = &device_param->d_hooks;
13847 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13848 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13849 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13850 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13851 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13852 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13853 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13854 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13855 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13856 device_param->kernel_params[15] = &device_param->d_digests_buf;
13857 device_param->kernel_params[16] = &device_param->d_digests_shown;
13858 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13859 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13860 device_param->kernel_params[19] = &device_param->d_result;
13861 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13862 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13863 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13864 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13865 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13866 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13867 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13868 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13869 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13870 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13871 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13872 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13873
13874 device_param->kernel_params_mp_buf64[3] = 0;
13875 device_param->kernel_params_mp_buf32[4] = 0;
13876 device_param->kernel_params_mp_buf32[5] = 0;
13877 device_param->kernel_params_mp_buf32[6] = 0;
13878 device_param->kernel_params_mp_buf32[7] = 0;
13879 device_param->kernel_params_mp_buf32[8] = 0;
13880
13881 device_param->kernel_params_mp[0] = NULL;
13882 device_param->kernel_params_mp[1] = NULL;
13883 device_param->kernel_params_mp[2] = NULL;
13884 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13885 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13886 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13887 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13888 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13889 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13890
13891 device_param->kernel_params_mp_l_buf64[3] = 0;
13892 device_param->kernel_params_mp_l_buf32[4] = 0;
13893 device_param->kernel_params_mp_l_buf32[5] = 0;
13894 device_param->kernel_params_mp_l_buf32[6] = 0;
13895 device_param->kernel_params_mp_l_buf32[7] = 0;
13896 device_param->kernel_params_mp_l_buf32[8] = 0;
13897 device_param->kernel_params_mp_l_buf32[9] = 0;
13898
13899 device_param->kernel_params_mp_l[0] = NULL;
13900 device_param->kernel_params_mp_l[1] = NULL;
13901 device_param->kernel_params_mp_l[2] = NULL;
13902 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13903 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13904 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13905 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13906 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13907 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13908 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13909
13910 device_param->kernel_params_mp_r_buf64[3] = 0;
13911 device_param->kernel_params_mp_r_buf32[4] = 0;
13912 device_param->kernel_params_mp_r_buf32[5] = 0;
13913 device_param->kernel_params_mp_r_buf32[6] = 0;
13914 device_param->kernel_params_mp_r_buf32[7] = 0;
13915 device_param->kernel_params_mp_r_buf32[8] = 0;
13916
13917 device_param->kernel_params_mp_r[0] = NULL;
13918 device_param->kernel_params_mp_r[1] = NULL;
13919 device_param->kernel_params_mp_r[2] = NULL;
13920 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13921 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13922 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13923 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13924 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13925 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13926
13927 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13928 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13929
13930 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13931 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13932 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13933 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13934 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13935 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13936 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13937
13938 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13939
13940 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13941 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13942
13943 /**
13944 * kernel name
13945 */
13946
13947 char kernel_name[64] = { 0 };
13948
13949 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13950 {
13951 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13952 {
13953 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13954
13955 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13956
13957 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13958
13959 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13960
13961 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13962
13963 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13964 }
13965 else
13966 {
13967 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13968
13969 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13970
13971 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13972
13973 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13974
13975 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13976
13977 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13978 }
13979
13980 if (data.attack_mode == ATTACK_MODE_BF)
13981 {
13982 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13983 {
13984 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13985
13986 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13987
13988 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13989
13990 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13991 }
13992 }
13993 }
13994 else
13995 {
13996 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13997
13998 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13999
14000 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
14001
14002 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
14003
14004 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
14005
14006 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
14007
14008 if (opts_type & OPTS_TYPE_HOOK12)
14009 {
14010 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
14011
14012 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
14013 }
14014
14015 if (opts_type & OPTS_TYPE_HOOK23)
14016 {
14017 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
14018
14019 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
14020 }
14021 }
14022
14023 for (uint i = 0; i <= 20; i++)
14024 {
14025 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
14026 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
14027 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
14028
14029 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
14030 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
14031 }
14032
14033 for (uint i = 21; i <= 31; i++)
14034 {
14035 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
14036 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
14037 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
14038
14039 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
14040 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
14041 }
14042
14043 if (attack_mode == ATTACK_MODE_BF)
14044 {
14045 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14046 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14047
14048 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14049 {
14050 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14051
14052 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14053 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14054 }
14055 }
14056 else if (attack_mode == ATTACK_MODE_HYBRID1)
14057 {
14058 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14059 }
14060 else if (attack_mode == ATTACK_MODE_HYBRID2)
14061 {
14062 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14063 }
14064
14065 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14066 {
14067 // nothing to do
14068 }
14069 else
14070 {
14071 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14072 }
14073
14074 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14075 {
14076 // nothing to do
14077 }
14078 else
14079 {
14080 for (uint i = 0; i < 5; i++)
14081 {
14082 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14083 }
14084
14085 for (uint i = 5; i < 7; i++)
14086 {
14087 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14088 }
14089 }
14090
14091 /**
14092 * Store initial fanspeed if gpu_temp_retain is enabled
14093 */
14094
14095 int gpu_temp_retain_set = 0;
14096
14097 if (gpu_temp_disable == 0)
14098 {
14099 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14100 {
14101 hc_thread_mutex_lock (mux_adl);
14102
14103 if (data.hm_device[device_id].fan_supported == 1)
14104 {
14105 if (gpu_temp_retain_chgd == 0)
14106 {
14107 uint cur_temp = 0;
14108 uint default_temp = 0;
14109
14110 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);
14111
14112 if (ADL_rc == ADL_OK)
14113 {
14114 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14115
14116 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14117
14118 // special case with multi gpu setups: always use minimum retain
14119
14120 if (gpu_temp_retain_set == 0)
14121 {
14122 gpu_temp_retain = gpu_temp_retain_target;
14123 gpu_temp_retain_set = 1;
14124 }
14125 else
14126 {
14127 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14128 }
14129
14130 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14131 }
14132 }
14133
14134 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14135
14136 temp_retain_fanspeed_value[device_id] = fan_speed;
14137
14138 if (fan_speed == -1)
14139 {
14140 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14141
14142 temp_retain_fanspeed_value[device_id] = 0;
14143 }
14144 }
14145
14146 hc_thread_mutex_unlock (mux_adl);
14147 }
14148 }
14149
14150 /**
14151 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14152 */
14153
14154 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14155 {
14156 hc_thread_mutex_lock (mux_adl);
14157
14158 if (data.hm_device[device_id].od_version == 6)
14159 {
14160 int ADL_rc;
14161
14162 // check powertune capabilities first, if not available then skip device
14163
14164 int powertune_supported = 0;
14165
14166 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14167 {
14168 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14169
14170 return (-1);
14171 }
14172
14173 if (powertune_supported != 0)
14174 {
14175 // powercontrol settings
14176
14177 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14178
14179 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14180 {
14181 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]);
14182 }
14183
14184 if (ADL_rc != ADL_OK)
14185 {
14186 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14187
14188 return (-1);
14189 }
14190
14191 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14192 {
14193 log_error ("ERROR: Failed to set new ADL PowerControl values");
14194
14195 return (-1);
14196 }
14197
14198 // clocks
14199
14200 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14201
14202 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14203
14204 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)
14205 {
14206 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14207
14208 return (-1);
14209 }
14210
14211 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14212
14213 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14214
14215 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14216 {
14217 log_error ("ERROR: Failed to get ADL device capabilities");
14218
14219 return (-1);
14220 }
14221
14222 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14223 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14224
14225 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14226 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14227
14228 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14229 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14230
14231 // warning if profile has too low max values
14232
14233 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14234 {
14235 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14236 }
14237
14238 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14239 {
14240 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14241 }
14242
14243 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14244
14245 performance_state->iNumberOfPerformanceLevels = 2;
14246
14247 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14248 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14249 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14250 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14251
14252 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)
14253 {
14254 log_info ("ERROR: Failed to set ADL performance state");
14255
14256 return (-1);
14257 }
14258
14259 local_free (performance_state);
14260 }
14261 }
14262
14263 hc_thread_mutex_unlock (mux_adl);
14264 }
14265 }
14266
14267 data.kernel_blocks_all = kernel_blocks_all;
14268
14269 if (data.quiet == 0) log_info ("");
14270
14271 /**
14272 * Inform user which algorithm is checked and at which workload setting
14273 */
14274
14275 if (benchmark == 1)
14276 {
14277 quiet = 0;
14278
14279 data.quiet = quiet;
14280
14281 char *hash_type = strhashtype (data.hash_mode); // not a bug
14282
14283 log_info ("Hashtype: %s", hash_type);
14284 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14285 log_info ("");
14286 }
14287
14288 /**
14289 * keep track of the progress
14290 */
14291
14292 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14293 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14294 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14295
14296 /**
14297 * open filehandles
14298 */
14299
14300 #if _WIN
14301 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14302 {
14303 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14304
14305 return (-1);
14306 }
14307
14308 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14309 {
14310 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14311
14312 return (-1);
14313 }
14314
14315 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14316 {
14317 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14318
14319 return (-1);
14320 }
14321 #endif
14322
14323 /**
14324 * dictionary pad
14325 */
14326
14327 segment_size *= (1024 * 1024);
14328
14329 data.segment_size = segment_size;
14330
14331 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14332
14333 wl_data->buf = (char *) mymalloc (segment_size);
14334 wl_data->avail = segment_size;
14335 wl_data->incr = segment_size;
14336 wl_data->cnt = 0;
14337 wl_data->pos = 0;
14338
14339 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14340
14341 data.wordlist_mode = wordlist_mode;
14342
14343 cs_t *css_buf = NULL;
14344 uint css_cnt = 0;
14345 uint dictcnt = 0;
14346 uint maskcnt = 1;
14347 char **masks = NULL;
14348 char **dictfiles = NULL;
14349
14350 uint mask_from_file = 0;
14351
14352 if (attack_mode == ATTACK_MODE_STRAIGHT)
14353 {
14354 if (wordlist_mode == WL_MODE_FILE)
14355 {
14356 int wls_left = myargc - (optind + 1);
14357
14358 for (int i = 0; i < wls_left; i++)
14359 {
14360 char *l0_filename = myargv[optind + 1 + i];
14361
14362 struct stat l0_stat;
14363
14364 if (stat (l0_filename, &l0_stat) == -1)
14365 {
14366 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14367
14368 return (-1);
14369 }
14370
14371 uint is_dir = S_ISDIR (l0_stat.st_mode);
14372
14373 if (is_dir == 0)
14374 {
14375 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14376
14377 dictcnt++;
14378
14379 dictfiles[dictcnt - 1] = l0_filename;
14380 }
14381 else
14382 {
14383 // do not allow --keyspace w/ a directory
14384
14385 if (keyspace == 1)
14386 {
14387 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14388
14389 return (-1);
14390 }
14391
14392 char **dictionary_files = NULL;
14393
14394 dictionary_files = scan_directory (l0_filename);
14395
14396 if (dictionary_files != NULL)
14397 {
14398 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14399
14400 for (int d = 0; dictionary_files[d] != NULL; d++)
14401 {
14402 char *l1_filename = dictionary_files[d];
14403
14404 struct stat l1_stat;
14405
14406 if (stat (l1_filename, &l1_stat) == -1)
14407 {
14408 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14409
14410 return (-1);
14411 }
14412
14413 if (S_ISREG (l1_stat.st_mode))
14414 {
14415 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14416
14417 dictcnt++;
14418
14419 dictfiles[dictcnt - 1] = strdup (l1_filename);
14420 }
14421 }
14422 }
14423
14424 local_free (dictionary_files);
14425 }
14426 }
14427
14428 if (dictcnt < 1)
14429 {
14430 log_error ("ERROR: No usable dictionary file found.");
14431
14432 return (-1);
14433 }
14434 }
14435 else if (wordlist_mode == WL_MODE_STDIN)
14436 {
14437 dictcnt = 1;
14438 }
14439 }
14440 else if (attack_mode == ATTACK_MODE_COMBI)
14441 {
14442 // display
14443
14444 char *dictfile1 = myargv[optind + 1 + 0];
14445 char *dictfile2 = myargv[optind + 1 + 1];
14446
14447 // find the bigger dictionary and use as base
14448
14449 FILE *fp1;
14450 FILE *fp2;
14451
14452 struct stat tmp_stat;
14453
14454 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14455 {
14456 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14457
14458 return (-1);
14459 }
14460
14461 if (stat (dictfile1, &tmp_stat) == -1)
14462 {
14463 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14464
14465 fclose (fp1);
14466
14467 return (-1);
14468 }
14469
14470 if (S_ISDIR (tmp_stat.st_mode))
14471 {
14472 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14473
14474 fclose (fp1);
14475
14476 return (-1);
14477 }
14478
14479 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14480 {
14481 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14482
14483 fclose (fp1);
14484
14485 return (-1);
14486 }
14487
14488 if (stat (dictfile2, &tmp_stat) == -1)
14489 {
14490 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14491
14492 fclose (fp1);
14493 fclose (fp2);
14494
14495 return (-1);
14496 }
14497
14498 if (S_ISDIR (tmp_stat.st_mode))
14499 {
14500 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14501
14502 fclose (fp1);
14503 fclose (fp2);
14504
14505 return (-1);
14506 }
14507
14508 data.combs_cnt = 1;
14509
14510 data.quiet = 1;
14511
14512 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14513
14514 data.quiet = quiet;
14515
14516 if (words1_cnt == 0)
14517 {
14518 log_error ("ERROR: %s: empty file", dictfile1);
14519
14520 fclose (fp1);
14521 fclose (fp2);
14522
14523 return (-1);
14524 }
14525
14526 data.combs_cnt = 1;
14527
14528 data.quiet = 1;
14529
14530 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14531
14532 data.quiet = quiet;
14533
14534 if (words2_cnt == 0)
14535 {
14536 log_error ("ERROR: %s: empty file", dictfile2);
14537
14538 fclose (fp1);
14539 fclose (fp2);
14540
14541 return (-1);
14542 }
14543
14544 fclose (fp1);
14545 fclose (fp2);
14546
14547 data.dictfile = dictfile1;
14548 data.dictfile2 = dictfile2;
14549
14550 if (words1_cnt >= words2_cnt)
14551 {
14552 data.combs_cnt = words2_cnt;
14553 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14554
14555 dictfiles = &data.dictfile;
14556
14557 dictcnt = 1;
14558 }
14559 else
14560 {
14561 data.combs_cnt = words1_cnt;
14562 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14563
14564 dictfiles = &data.dictfile2;
14565
14566 dictcnt = 1;
14567
14568 // we also have to switch wordlist related rules!
14569
14570 char *tmpc = data.rule_buf_l;
14571
14572 data.rule_buf_l = data.rule_buf_r;
14573 data.rule_buf_r = tmpc;
14574
14575 int tmpi = data.rule_len_l;
14576
14577 data.rule_len_l = data.rule_len_r;
14578 data.rule_len_r = tmpi;
14579 }
14580 }
14581 else if (attack_mode == ATTACK_MODE_BF)
14582 {
14583 char *mask = NULL;
14584
14585 maskcnt = 0;
14586
14587 if (benchmark == 0)
14588 {
14589 mask = myargv[optind + 1];
14590
14591 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14592
14593 if ((optind + 2) <= myargc)
14594 {
14595 struct stat file_stat;
14596
14597 if (stat (mask, &file_stat) == -1)
14598 {
14599 maskcnt = 1;
14600
14601 masks[maskcnt - 1] = mystrdup (mask);
14602 }
14603 else
14604 {
14605 int wls_left = myargc - (optind + 1);
14606
14607 uint masks_avail = INCR_MASKS;
14608
14609 for (int i = 0; i < wls_left; i++)
14610 {
14611 if (i != 0)
14612 {
14613 mask = myargv[optind + 1 + i];
14614
14615 if (stat (mask, &file_stat) == -1)
14616 {
14617 log_error ("ERROR: %s: %s", mask, strerror (errno));
14618
14619 return (-1);
14620 }
14621 }
14622
14623 uint is_file = S_ISREG (file_stat.st_mode);
14624
14625 if (is_file == 1)
14626 {
14627 FILE *mask_fp;
14628
14629 if ((mask_fp = fopen (mask, "r")) == NULL)
14630 {
14631 log_error ("ERROR: %s: %s", mask, strerror (errno));
14632
14633 return (-1);
14634 }
14635
14636 char line_buf[BUFSIZ];
14637
14638 while (!feof (mask_fp))
14639 {
14640 memset (line_buf, 0, BUFSIZ);
14641
14642 int line_len = fgetl (mask_fp, line_buf);
14643
14644 if (line_len == 0) continue;
14645
14646 if (line_buf[0] == '#') continue;
14647
14648 if (masks_avail == maskcnt)
14649 {
14650 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14651
14652 masks_avail += INCR_MASKS;
14653 }
14654
14655 masks[maskcnt] = mystrdup (line_buf);
14656
14657 maskcnt++;
14658 }
14659
14660 fclose (mask_fp);
14661 }
14662 else
14663 {
14664 log_error ("ERROR: %s: unsupported file-type", mask);
14665
14666 return (-1);
14667 }
14668 }
14669
14670 mask_from_file = 1;
14671 }
14672 }
14673 else
14674 {
14675 custom_charset_1 = (char *) "?l?d?u";
14676 custom_charset_2 = (char *) "?l?d";
14677 custom_charset_3 = (char *) "?l?d*!$@_";
14678
14679 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14680 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14681 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14682
14683 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14684
14685 wordlist_mode = WL_MODE_MASK;
14686
14687 data.wordlist_mode = wordlist_mode;
14688
14689 increment = 1;
14690
14691 maskcnt = 1;
14692 }
14693 }
14694 else
14695 {
14696 /**
14697 * generate full masks and charsets
14698 */
14699
14700 masks = (char **) mymalloc (sizeof (char *));
14701
14702 switch (hash_mode)
14703 {
14704 case 1731: pw_min = 5;
14705 pw_max = 5;
14706 mask = mystrdup ("?b?b?b?b?b");
14707 break;
14708 case 12500: pw_min = 5;
14709 pw_max = 5;
14710 mask = mystrdup ("?b?b?b?b?b");
14711 break;
14712 default: pw_min = 7;
14713 pw_max = 7;
14714 mask = mystrdup ("?b?b?b?b?b?b?b");
14715 break;
14716 }
14717
14718 maskcnt = 1;
14719
14720 masks[maskcnt - 1] = mystrdup (mask);
14721
14722 wordlist_mode = WL_MODE_MASK;
14723
14724 data.wordlist_mode = wordlist_mode;
14725
14726 increment = 1;
14727 }
14728
14729 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14730
14731 if (increment)
14732 {
14733 if (increment_min > pw_min) pw_min = increment_min;
14734
14735 if (increment_max < pw_max) pw_max = increment_max;
14736 }
14737 }
14738 else if (attack_mode == ATTACK_MODE_HYBRID1)
14739 {
14740 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14741
14742 // display
14743
14744 char *mask = myargv[myargc - 1];
14745
14746 maskcnt = 0;
14747
14748 masks = (char **) mymalloc (1 * sizeof (char *));
14749
14750 // mod
14751
14752 struct stat file_stat;
14753
14754 if (stat (mask, &file_stat) == -1)
14755 {
14756 maskcnt = 1;
14757
14758 masks[maskcnt - 1] = mystrdup (mask);
14759 }
14760 else
14761 {
14762 uint is_file = S_ISREG (file_stat.st_mode);
14763
14764 if (is_file == 1)
14765 {
14766 FILE *mask_fp;
14767
14768 if ((mask_fp = fopen (mask, "r")) == NULL)
14769 {
14770 log_error ("ERROR: %s: %s", mask, strerror (errno));
14771
14772 return (-1);
14773 }
14774
14775 char line_buf[BUFSIZ];
14776
14777 uint masks_avail = 1;
14778
14779 while (!feof (mask_fp))
14780 {
14781 memset (line_buf, 0, BUFSIZ);
14782
14783 int line_len = fgetl (mask_fp, line_buf);
14784
14785 if (line_len == 0) continue;
14786
14787 if (line_buf[0] == '#') continue;
14788
14789 if (masks_avail == maskcnt)
14790 {
14791 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14792
14793 masks_avail += INCR_MASKS;
14794 }
14795
14796 masks[maskcnt] = mystrdup (line_buf);
14797
14798 maskcnt++;
14799 }
14800
14801 fclose (mask_fp);
14802
14803 mask_from_file = 1;
14804 }
14805 else
14806 {
14807 maskcnt = 1;
14808
14809 masks[maskcnt - 1] = mystrdup (mask);
14810 }
14811 }
14812
14813 // base
14814
14815 int wls_left = myargc - (optind + 2);
14816
14817 for (int i = 0; i < wls_left; i++)
14818 {
14819 char *filename = myargv[optind + 1 + i];
14820
14821 struct stat file_stat;
14822
14823 if (stat (filename, &file_stat) == -1)
14824 {
14825 log_error ("ERROR: %s: %s", filename, strerror (errno));
14826
14827 return (-1);
14828 }
14829
14830 uint is_dir = S_ISDIR (file_stat.st_mode);
14831
14832 if (is_dir == 0)
14833 {
14834 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14835
14836 dictcnt++;
14837
14838 dictfiles[dictcnt - 1] = filename;
14839 }
14840 else
14841 {
14842 // do not allow --keyspace w/ a directory
14843
14844 if (keyspace == 1)
14845 {
14846 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14847
14848 return (-1);
14849 }
14850
14851 char **dictionary_files = NULL;
14852
14853 dictionary_files = scan_directory (filename);
14854
14855 if (dictionary_files != NULL)
14856 {
14857 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14858
14859 for (int d = 0; dictionary_files[d] != NULL; d++)
14860 {
14861 char *l1_filename = dictionary_files[d];
14862
14863 struct stat l1_stat;
14864
14865 if (stat (l1_filename, &l1_stat) == -1)
14866 {
14867 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14868
14869 return (-1);
14870 }
14871
14872 if (S_ISREG (l1_stat.st_mode))
14873 {
14874 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14875
14876 dictcnt++;
14877
14878 dictfiles[dictcnt - 1] = strdup (l1_filename);
14879 }
14880 }
14881 }
14882
14883 local_free (dictionary_files);
14884 }
14885 }
14886
14887 if (dictcnt < 1)
14888 {
14889 log_error ("ERROR: No usable dictionary file found.");
14890
14891 return (-1);
14892 }
14893
14894 if (increment)
14895 {
14896 maskcnt = 0;
14897
14898 uint mask_min = increment_min; // we can't reject smaller masks here
14899 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14900
14901 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14902 {
14903 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14904
14905 if (cur_mask == NULL) break;
14906
14907 masks[maskcnt] = cur_mask;
14908
14909 maskcnt++;
14910
14911 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14912 }
14913 }
14914 }
14915 else if (attack_mode == ATTACK_MODE_HYBRID2)
14916 {
14917 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14918
14919 // display
14920
14921 char *mask = myargv[optind + 1 + 0];
14922
14923 maskcnt = 0;
14924
14925 masks = (char **) mymalloc (1 * sizeof (char *));
14926
14927 // mod
14928
14929 struct stat file_stat;
14930
14931 if (stat (mask, &file_stat) == -1)
14932 {
14933 maskcnt = 1;
14934
14935 masks[maskcnt - 1] = mystrdup (mask);
14936 }
14937 else
14938 {
14939 uint is_file = S_ISREG (file_stat.st_mode);
14940
14941 if (is_file == 1)
14942 {
14943 FILE *mask_fp;
14944
14945 if ((mask_fp = fopen (mask, "r")) == NULL)
14946 {
14947 log_error ("ERROR: %s: %s", mask, strerror (errno));
14948
14949 return (-1);
14950 }
14951
14952 char line_buf[BUFSIZ];
14953
14954 uint masks_avail = 1;
14955
14956 while (!feof (mask_fp))
14957 {
14958 memset (line_buf, 0, BUFSIZ);
14959
14960 int line_len = fgetl (mask_fp, line_buf);
14961
14962 if (line_len == 0) continue;
14963
14964 if (line_buf[0] == '#') continue;
14965
14966 if (masks_avail == maskcnt)
14967 {
14968 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14969
14970 masks_avail += INCR_MASKS;
14971 }
14972
14973 masks[maskcnt] = mystrdup (line_buf);
14974
14975 maskcnt++;
14976 }
14977
14978 fclose (mask_fp);
14979
14980 mask_from_file = 1;
14981 }
14982 else
14983 {
14984 maskcnt = 1;
14985
14986 masks[maskcnt - 1] = mystrdup (mask);
14987 }
14988 }
14989
14990 // base
14991
14992 int wls_left = myargc - (optind + 2);
14993
14994 for (int i = 0; i < wls_left; i++)
14995 {
14996 char *filename = myargv[optind + 2 + i];
14997
14998 struct stat file_stat;
14999
15000 if (stat (filename, &file_stat) == -1)
15001 {
15002 log_error ("ERROR: %s: %s", filename, strerror (errno));
15003
15004 return (-1);
15005 }
15006
15007 uint is_dir = S_ISDIR (file_stat.st_mode);
15008
15009 if (is_dir == 0)
15010 {
15011 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15012
15013 dictcnt++;
15014
15015 dictfiles[dictcnt - 1] = filename;
15016 }
15017 else
15018 {
15019 // do not allow --keyspace w/ a directory
15020
15021 if (keyspace == 1)
15022 {
15023 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15024
15025 return (-1);
15026 }
15027
15028 char **dictionary_files = NULL;
15029
15030 dictionary_files = scan_directory (filename);
15031
15032 if (dictionary_files != NULL)
15033 {
15034 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15035
15036 for (int d = 0; dictionary_files[d] != NULL; d++)
15037 {
15038 char *l1_filename = dictionary_files[d];
15039
15040 struct stat l1_stat;
15041
15042 if (stat (l1_filename, &l1_stat) == -1)
15043 {
15044 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15045
15046 return (-1);
15047 }
15048
15049 if (S_ISREG (l1_stat.st_mode))
15050 {
15051 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15052
15053 dictcnt++;
15054
15055 dictfiles[dictcnt - 1] = strdup (l1_filename);
15056 }
15057 }
15058 }
15059
15060 local_free (dictionary_files);
15061 }
15062 }
15063
15064 if (dictcnt < 1)
15065 {
15066 log_error ("ERROR: No usable dictionary file found.");
15067
15068 return (-1);
15069 }
15070
15071 if (increment)
15072 {
15073 maskcnt = 0;
15074
15075 uint mask_min = increment_min; // we can't reject smaller masks here
15076 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15077
15078 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15079 {
15080 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15081
15082 if (cur_mask == NULL) break;
15083
15084 masks[maskcnt] = cur_mask;
15085
15086 maskcnt++;
15087
15088 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15089 }
15090 }
15091 }
15092
15093 data.pw_min = pw_min;
15094 data.pw_max = pw_max;
15095
15096 /**
15097 * weak hash check
15098 */
15099
15100 if (weak_hash_threshold >= salts_cnt)
15101 {
15102 uint first_device_id = 0;
15103
15104 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15105 {
15106 hc_device_param_t *device_param = &data.devices_param[device_id];
15107
15108 if (device_param->skipped) continue;
15109
15110 first_device_id = device_id;
15111
15112 break;
15113 }
15114
15115 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15116
15117 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15118 {
15119 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15120 }
15121 }
15122
15123 // Display hack, guarantee that there is at least one \r before real start
15124
15125 if (data.quiet == 0) log_info_nn ("");
15126
15127 /**
15128 * status and monitor threads
15129 */
15130
15131 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15132
15133 hc_thread_t i_thread = 0;
15134
15135 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15136 {
15137 hc_thread_create (i_thread, thread_keypress, &benchmark);
15138 }
15139
15140 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15141
15142 uint ni_threads_cnt = 0;
15143
15144 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15145
15146 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15147
15148 ni_threads_cnt++;
15149
15150 /**
15151 * Outfile remove
15152 */
15153
15154 if (keyspace == 0)
15155 {
15156 if (outfile_check_timer != 0)
15157 {
15158 if (data.outfile_check_directory != NULL)
15159 {
15160 if ((hash_mode != 5200) &&
15161 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15162 (hash_mode != 9000))
15163 {
15164 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15165
15166 ni_threads_cnt++;
15167 }
15168 else
15169 {
15170 outfile_check_timer = 0;
15171 }
15172 }
15173 else
15174 {
15175 outfile_check_timer = 0;
15176 }
15177 }
15178 }
15179
15180 /**
15181 * Inform the user if we got some hashes remove because of the pot file remove feature
15182 */
15183
15184 if (data.quiet == 0)
15185 {
15186 if (potfile_remove_cracks > 0)
15187 {
15188 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15189 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15190 }
15191 }
15192
15193 data.outfile_check_timer = outfile_check_timer;
15194
15195 /**
15196 * main loop
15197 */
15198
15199 char **induction_dictionaries = NULL;
15200
15201 int induction_dictionaries_cnt = 0;
15202
15203 hcstat_table_t *root_table_buf = NULL;
15204 hcstat_table_t *markov_table_buf = NULL;
15205
15206 uint initial_restore_done = 0;
15207
15208 data.maskcnt = maskcnt;
15209
15210 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15211 {
15212 if (data.devices_status == STATUS_CRACKED) break;
15213
15214 data.devices_status = STATUS_INIT;
15215
15216 if (maskpos > rd->maskpos)
15217 {
15218 rd->dictpos = 0;
15219 }
15220
15221 rd->maskpos = maskpos;
15222 data.maskpos = maskpos;
15223
15224 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15225 {
15226 char *mask = masks[maskpos];
15227
15228 if (mask_from_file == 1)
15229 {
15230 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15231
15232 char *str_ptr;
15233 uint str_pos;
15234
15235 uint mask_offset = 0;
15236
15237 uint separator_cnt;
15238
15239 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15240 {
15241 str_ptr = strstr (mask + mask_offset, ",");
15242
15243 if (str_ptr == NULL) break;
15244
15245 str_pos = str_ptr - mask;
15246
15247 // escaped separator, i.e. "\,"
15248
15249 if (str_pos > 0)
15250 {
15251 if (mask[str_pos - 1] == '\\')
15252 {
15253 separator_cnt --;
15254
15255 mask_offset = str_pos + 1;
15256
15257 continue;
15258 }
15259 }
15260
15261 // reset the offset
15262
15263 mask_offset = 0;
15264
15265 mask[str_pos] = '\0';
15266
15267 switch (separator_cnt)
15268 {
15269 case 0:
15270 mp_reset_usr (mp_usr, 0);
15271
15272 custom_charset_1 = mask;
15273 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15274 break;
15275
15276 case 1:
15277 mp_reset_usr (mp_usr, 1);
15278
15279 custom_charset_2 = mask;
15280 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15281 break;
15282
15283 case 2:
15284 mp_reset_usr (mp_usr, 2);
15285
15286 custom_charset_3 = mask;
15287 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15288 break;
15289
15290 case 3:
15291 mp_reset_usr (mp_usr, 3);
15292
15293 custom_charset_4 = mask;
15294 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15295 break;
15296 }
15297
15298 mask = mask + str_pos + 1;
15299 }
15300 }
15301
15302 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15303 {
15304 if (maskpos > 0)
15305 {
15306 local_free (css_buf);
15307 local_free (data.root_css_buf);
15308 local_free (data.markov_css_buf);
15309
15310 local_free (masks[maskpos - 1]);
15311 }
15312
15313 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15314
15315 data.mask = mask;
15316 data.css_cnt = css_cnt;
15317 data.css_buf = css_buf;
15318
15319 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15320
15321 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15322
15323 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15324 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15325
15326 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15327
15328 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15329
15330 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15331 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15332
15333 data.root_css_buf = root_css_buf;
15334 data.markov_css_buf = markov_css_buf;
15335
15336 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15337
15338 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15339
15340 local_free (root_table_buf);
15341 local_free (markov_table_buf);
15342
15343 // args
15344
15345 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15346 {
15347 hc_device_param_t *device_param = &data.devices_param[device_id];
15348
15349 if (device_param->skipped) continue;
15350
15351 device_param->kernel_params_mp[0] = &device_param->d_combs;
15352 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15353 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15354
15355 device_param->kernel_params_mp_buf64[3] = 0;
15356 device_param->kernel_params_mp_buf32[4] = css_cnt;
15357 device_param->kernel_params_mp_buf32[5] = 0;
15358 device_param->kernel_params_mp_buf32[6] = 0;
15359 device_param->kernel_params_mp_buf32[7] = 0;
15360
15361 if (attack_mode == ATTACK_MODE_HYBRID1)
15362 {
15363 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15364 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15365 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15366 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15367 }
15368 else if (attack_mode == ATTACK_MODE_HYBRID2)
15369 {
15370 device_param->kernel_params_mp_buf32[5] = 0;
15371 device_param->kernel_params_mp_buf32[6] = 0;
15372 device_param->kernel_params_mp_buf32[7] = 0;
15373 }
15374
15375 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15376 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15377 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15378
15379 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);
15380 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);
15381 }
15382 }
15383 else if (attack_mode == ATTACK_MODE_BF)
15384 {
15385 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15386
15387 if (increment)
15388 {
15389 for (uint i = 0; i < dictcnt; i++)
15390 {
15391 local_free (dictfiles[i]);
15392 }
15393
15394 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15395 {
15396 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15397
15398 if (l1_filename == NULL) break;
15399
15400 dictcnt++;
15401
15402 dictfiles[dictcnt - 1] = l1_filename;
15403 }
15404 }
15405 else
15406 {
15407 dictcnt++;
15408
15409 dictfiles[dictcnt - 1] = mask;
15410 }
15411
15412 if (dictcnt == 0)
15413 {
15414 log_error ("ERROR: Mask is too small");
15415
15416 return (-1);
15417 }
15418 }
15419 }
15420
15421 free (induction_dictionaries);
15422
15423 // induction_dictionaries_cnt = 0; // implied
15424
15425 if (attack_mode != ATTACK_MODE_BF)
15426 {
15427 if (keyspace == 0)
15428 {
15429 induction_dictionaries = scan_directory (induction_directory);
15430
15431 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15432 }
15433 }
15434
15435 if (induction_dictionaries_cnt)
15436 {
15437 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15438 }
15439
15440 /**
15441 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15442 */
15443 if (keyspace == 1)
15444 {
15445 if ((maskcnt > 1) || (dictcnt > 1))
15446 {
15447 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15448
15449 return (-1);
15450 }
15451 }
15452
15453 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15454 {
15455 char *subid = logfile_generate_subid ();
15456
15457 data.subid = subid;
15458
15459 logfile_sub_msg ("START");
15460
15461 data.devices_status = STATUS_INIT;
15462
15463 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15464 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15465 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15466
15467 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15468
15469 data.cpt_pos = 0;
15470
15471 data.cpt_start = time (NULL);
15472
15473 data.cpt_total = 0;
15474
15475 if (data.restore == 0)
15476 {
15477 rd->words_cur = skip;
15478
15479 skip = 0;
15480
15481 data.skip = 0;
15482 }
15483
15484 data.ms_paused = 0;
15485
15486 data.words_cur = rd->words_cur;
15487
15488 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15489 {
15490 hc_device_param_t *device_param = &data.devices_param[device_id];
15491
15492 if (device_param->skipped) continue;
15493
15494 device_param->speed_pos = 0;
15495
15496 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15497 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15498 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15499
15500 device_param->kernel_power = device_param->kernel_power_user;
15501 device_param->kernel_blocks = device_param->kernel_blocks_user;
15502
15503 device_param->outerloop_pos = 0;
15504 device_param->outerloop_left = 0;
15505 device_param->innerloop_pos = 0;
15506 device_param->innerloop_left = 0;
15507
15508 // some more resets:
15509
15510 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15511
15512 memset (device_param->pws_buf, 0, device_param->size_pws);
15513
15514 device_param->pw_cnt = 0;
15515 device_param->pws_cnt = 0;
15516
15517 device_param->words_off = 0;
15518 device_param->words_done = 0;
15519 }
15520
15521 data.kernel_blocks_div = 0;
15522
15523 // figure out some workload
15524
15525 if (attack_mode == ATTACK_MODE_STRAIGHT)
15526 {
15527 if (data.wordlist_mode == WL_MODE_FILE)
15528 {
15529 char *dictfile = NULL;
15530
15531 if (induction_dictionaries_cnt)
15532 {
15533 dictfile = induction_dictionaries[0];
15534 }
15535 else
15536 {
15537 dictfile = dictfiles[dictpos];
15538 }
15539
15540 data.dictfile = dictfile;
15541
15542 logfile_sub_string (dictfile);
15543
15544 for (uint i = 0; i < rp_files_cnt; i++)
15545 {
15546 logfile_sub_var_string ("rulefile", rp_files[i]);
15547 }
15548
15549 FILE *fd2 = fopen (dictfile, "rb");
15550
15551 if (fd2 == NULL)
15552 {
15553 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15554
15555 return (-1);
15556 }
15557
15558 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15559
15560 fclose (fd2);
15561
15562 if (data.words_cnt == 0)
15563 {
15564 if (data.devices_status == STATUS_CRACKED) break;
15565 if (data.devices_status == STATUS_ABORTED) break;
15566
15567 dictpos++;
15568
15569 continue;
15570 }
15571 }
15572 }
15573 else if (attack_mode == ATTACK_MODE_COMBI)
15574 {
15575 char *dictfile = data.dictfile;
15576 char *dictfile2 = data.dictfile2;
15577
15578 logfile_sub_string (dictfile);
15579 logfile_sub_string (dictfile2);
15580
15581 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15582 {
15583 FILE *fd2 = fopen (dictfile, "rb");
15584
15585 if (fd2 == NULL)
15586 {
15587 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15588
15589 return (-1);
15590 }
15591
15592 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15593
15594 fclose (fd2);
15595 }
15596 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15597 {
15598 FILE *fd2 = fopen (dictfile2, "rb");
15599
15600 if (fd2 == NULL)
15601 {
15602 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15603
15604 return (-1);
15605 }
15606
15607 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15608
15609 fclose (fd2);
15610 }
15611
15612 if (data.words_cnt == 0)
15613 {
15614 if (data.devices_status == STATUS_CRACKED) break;
15615 if (data.devices_status == STATUS_ABORTED) break;
15616
15617 dictpos++;
15618
15619 continue;
15620 }
15621 }
15622 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15623 {
15624 char *dictfile = NULL;
15625
15626 if (induction_dictionaries_cnt)
15627 {
15628 dictfile = induction_dictionaries[0];
15629 }
15630 else
15631 {
15632 dictfile = dictfiles[dictpos];
15633 }
15634
15635 data.dictfile = dictfile;
15636
15637 char *mask = data.mask;
15638
15639 logfile_sub_string (dictfile);
15640 logfile_sub_string (mask);
15641
15642 FILE *fd2 = fopen (dictfile, "rb");
15643
15644 if (fd2 == NULL)
15645 {
15646 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15647
15648 return (-1);
15649 }
15650
15651 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15652
15653 fclose (fd2);
15654
15655 if (data.words_cnt == 0)
15656 {
15657 if (data.devices_status == STATUS_CRACKED) break;
15658 if (data.devices_status == STATUS_ABORTED) break;
15659
15660 dictpos++;
15661
15662 continue;
15663 }
15664 }
15665 else if (attack_mode == ATTACK_MODE_BF)
15666 {
15667 local_free (css_buf);
15668 local_free (data.root_css_buf);
15669 local_free (data.markov_css_buf);
15670
15671 char *mask = dictfiles[dictpos];
15672
15673 logfile_sub_string (mask);
15674
15675 // base
15676
15677 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15678
15679 if (opts_type & OPTS_TYPE_PT_UNICODE)
15680 {
15681 uint css_cnt_unicode = css_cnt * 2;
15682
15683 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15684
15685 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15686 {
15687 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15688
15689 css_buf_unicode[j + 1].cs_buf[0] = 0;
15690 css_buf_unicode[j + 1].cs_len = 1;
15691 }
15692
15693 free (css_buf);
15694
15695 css_buf = css_buf_unicode;
15696 css_cnt = css_cnt_unicode;
15697 }
15698
15699 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15700
15701 uint mask_min = pw_min;
15702 uint mask_max = pw_max;
15703
15704 if (opts_type & OPTS_TYPE_PT_UNICODE)
15705 {
15706 mask_min *= 2;
15707 mask_max *= 2;
15708 }
15709
15710 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15711 {
15712 if (css_cnt < mask_min)
15713 {
15714 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15715 }
15716
15717 if (css_cnt > mask_max)
15718 {
15719 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15720 }
15721
15722 // skip to next mask
15723
15724 dictpos++;
15725
15726 rd->dictpos = dictpos;
15727
15728 logfile_sub_msg ("STOP");
15729
15730 continue;
15731 }
15732
15733 uint save_css_cnt = css_cnt;
15734
15735 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15736 {
15737 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15738 {
15739 uint salt_len = (uint) data.salts_buf[0].salt_len;
15740 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15741
15742 uint css_cnt_salt = css_cnt + salt_len;
15743
15744 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15745
15746 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15747
15748 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15749 {
15750 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15751 css_buf_salt[j].cs_len = 1;
15752 }
15753
15754 free (css_buf);
15755
15756 css_buf = css_buf_salt;
15757 css_cnt = css_cnt_salt;
15758 }
15759 }
15760
15761 data.mask = mask;
15762 data.css_cnt = css_cnt;
15763 data.css_buf = css_buf;
15764
15765 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15766
15767 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15768
15769 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15770
15771 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15772 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15773
15774 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15775
15776 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15777
15778 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15779 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15780
15781 data.root_css_buf = root_css_buf;
15782 data.markov_css_buf = markov_css_buf;
15783
15784 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15785
15786 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15787
15788 local_free (root_table_buf);
15789 local_free (markov_table_buf);
15790
15791 // copy + args
15792
15793 uint css_cnt_l = css_cnt;
15794 uint css_cnt_r;
15795
15796 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15797 {
15798 if (save_css_cnt < 6)
15799 {
15800 css_cnt_r = 1;
15801 }
15802 else if (save_css_cnt == 6)
15803 {
15804 css_cnt_r = 2;
15805 }
15806 else
15807 {
15808 if (opts_type & OPTS_TYPE_PT_UNICODE)
15809 {
15810 if (save_css_cnt == 8 || save_css_cnt == 10)
15811 {
15812 css_cnt_r = 2;
15813 }
15814 else
15815 {
15816 css_cnt_r = 4;
15817 }
15818 }
15819 else
15820 {
15821 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15822 {
15823 css_cnt_r = 3;
15824 }
15825 else
15826 {
15827 css_cnt_r = 4;
15828 }
15829 }
15830 }
15831 }
15832 else
15833 {
15834 css_cnt_r = 1;
15835
15836 /* unfinished code?
15837 int sum = css_buf[css_cnt_r - 1].cs_len;
15838
15839 for (uint i = 1; i < 4 && i < css_cnt; i++)
15840 {
15841 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15842
15843 css_cnt_r++;
15844
15845 sum *= css_buf[css_cnt_r - 1].cs_len;
15846 }
15847 */
15848 }
15849
15850 css_cnt_l -= css_cnt_r;
15851
15852 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15853
15854 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15855 {
15856 hc_device_param_t *device_param = &data.devices_param[device_id];
15857
15858 if (device_param->skipped) continue;
15859
15860 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15861 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15862 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15863
15864 device_param->kernel_params_mp_l_buf64[3] = 0;
15865 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15866 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15867 device_param->kernel_params_mp_l_buf32[6] = 0;
15868 device_param->kernel_params_mp_l_buf32[7] = 0;
15869 device_param->kernel_params_mp_l_buf32[8] = 0;
15870
15871 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15872 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15873 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15874 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15875
15876 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15877 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15878 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15879
15880 device_param->kernel_params_mp_r_buf64[3] = 0;
15881 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15882 device_param->kernel_params_mp_r_buf32[5] = 0;
15883 device_param->kernel_params_mp_r_buf32[6] = 0;
15884 device_param->kernel_params_mp_r_buf32[7] = 0;
15885
15886 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]);
15887 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]);
15888 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]);
15889
15890 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]);
15891 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]);
15892 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]);
15893
15894 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);
15895 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);
15896 }
15897 }
15898
15899 u64 words_base = data.words_cnt;
15900
15901 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15902 {
15903 if (data.kernel_rules_cnt)
15904 {
15905 words_base /= data.kernel_rules_cnt;
15906 }
15907 }
15908 else if (data.attack_kern == ATTACK_KERN_COMBI)
15909 {
15910 if (data.combs_cnt)
15911 {
15912 words_base /= data.combs_cnt;
15913 }
15914 }
15915 else if (data.attack_kern == ATTACK_KERN_BF)
15916 {
15917 if (data.bfs_cnt)
15918 {
15919 words_base /= data.bfs_cnt;
15920 }
15921 }
15922
15923 data.words_base = words_base;
15924
15925 if (keyspace == 1)
15926 {
15927 log_info ("%llu", (unsigned long long int) words_base);
15928
15929 return (0);
15930 }
15931
15932 if (data.words_cur > data.words_base)
15933 {
15934 log_error ("ERROR: restore value greater keyspace");
15935
15936 return (-1);
15937 }
15938
15939 if (data.words_cur)
15940 {
15941 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15942 {
15943 for (uint i = 0; i < data.salts_cnt; i++)
15944 {
15945 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15946 }
15947 }
15948 else if (data.attack_kern == ATTACK_KERN_COMBI)
15949 {
15950 for (uint i = 0; i < data.salts_cnt; i++)
15951 {
15952 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15953 }
15954 }
15955 else if (data.attack_kern == ATTACK_KERN_BF)
15956 {
15957 for (uint i = 0; i < data.salts_cnt; i++)
15958 {
15959 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15960 }
15961 }
15962 }
15963
15964 /*
15965 * Inform user about possible slow speeds
15966 */
15967
15968 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15969 {
15970 if (data.words_base < kernel_blocks_all)
15971 {
15972 if (quiet == 0)
15973 {
15974 log_info ("");
15975 log_info ("ATTENTION!");
15976 log_info (" The wordlist or mask you are using is too small.");
15977 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15978 log_info (" The cracking speed will drop.");
15979 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15980 log_info ("");
15981 }
15982 }
15983 }
15984
15985 /*
15986 * Update loopback file
15987 */
15988
15989 if (loopback == 1)
15990 {
15991 time_t now;
15992
15993 time (&now);
15994
15995 uint random_num = get_random_num (0, 9999);
15996
15997 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15998
15999 data.loopback_file = loopback_file;
16000 }
16001
16002 /*
16003 * Update dictionary statistic
16004 */
16005
16006 if (keyspace == 0)
16007 {
16008 dictstat_fp = fopen (dictstat, "wb");
16009
16010 if (dictstat_fp)
16011 {
16012 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
16013
16014 fclose (dictstat_fp);
16015 }
16016 }
16017
16018 data.devices_status = STATUS_RUNNING;
16019
16020 if (initial_restore_done == 0)
16021 {
16022 if (data.restore_disable == 0) cycle_restore ();
16023
16024 initial_restore_done = 1;
16025 }
16026
16027 hc_timer_set (&data.timer_running);
16028
16029 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
16030 {
16031 if ((quiet == 0) && (status == 0) && (benchmark == 0))
16032 {
16033 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
16034 if (quiet == 0) fflush (stdout);
16035 }
16036 }
16037 else if (wordlist_mode == WL_MODE_STDIN)
16038 {
16039 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
16040 if (data.quiet == 0) log_info ("");
16041 }
16042
16043 time_t runtime_start;
16044
16045 time (&runtime_start);
16046
16047 data.runtime_start = runtime_start;
16048
16049 /**
16050 * create cracker threads
16051 */
16052
16053 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16054
16055 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16056 {
16057 hc_device_param_t *device_param = &devices_param[device_id];
16058
16059 if (wordlist_mode == WL_MODE_STDIN)
16060 {
16061 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16062 }
16063 else
16064 {
16065 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16066 }
16067 }
16068
16069 // wait for crack threads to exit
16070
16071 hc_thread_wait (devices_cnt, c_threads);
16072
16073 local_free (c_threads);
16074
16075 data.restore = 0;
16076
16077 // finalize task
16078
16079 logfile_sub_var_uint ("status-after-work", data.devices_status);
16080
16081 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16082
16083 if (data.devices_status == STATUS_CRACKED) break;
16084 if (data.devices_status == STATUS_ABORTED) break;
16085
16086 if (data.devices_status == STATUS_BYPASS)
16087 {
16088 data.devices_status = STATUS_RUNNING;
16089 }
16090
16091 if (induction_dictionaries_cnt)
16092 {
16093 unlink (induction_dictionaries[0]);
16094 }
16095
16096 free (induction_dictionaries);
16097
16098 if (attack_mode != ATTACK_MODE_BF)
16099 {
16100 induction_dictionaries = scan_directory (induction_directory);
16101
16102 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16103 }
16104
16105 if (benchmark == 0)
16106 {
16107 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16108 {
16109 if (quiet == 0) clear_prompt ();
16110
16111 if (quiet == 0) log_info ("");
16112
16113 if (status == 1)
16114 {
16115 status_display ();
16116 }
16117 else
16118 {
16119 if (quiet == 0) status_display ();
16120 }
16121
16122 if (quiet == 0) log_info ("");
16123 }
16124 }
16125
16126 if (attack_mode == ATTACK_MODE_BF)
16127 {
16128 dictpos++;
16129
16130 rd->dictpos = dictpos;
16131 }
16132 else
16133 {
16134 if (induction_dictionaries_cnt)
16135 {
16136 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16137 }
16138 else
16139 {
16140 dictpos++;
16141
16142 rd->dictpos = dictpos;
16143 }
16144 }
16145
16146 time_t runtime_stop;
16147
16148 time (&runtime_stop);
16149
16150 data.runtime_stop = runtime_stop;
16151
16152 logfile_sub_uint (runtime_start);
16153 logfile_sub_uint (runtime_stop);
16154
16155 logfile_sub_msg ("STOP");
16156
16157 global_free (subid);
16158 }
16159
16160 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16161
16162 if (data.devices_status == STATUS_CRACKED) break;
16163 if (data.devices_status == STATUS_ABORTED) break;
16164 if (data.devices_status == STATUS_QUIT) break;
16165
16166 if (data.devices_status == STATUS_BYPASS)
16167 {
16168 data.devices_status = STATUS_RUNNING;
16169 }
16170 }
16171
16172 // 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
16173
16174 if (attack_mode == ATTACK_MODE_STRAIGHT)
16175 {
16176 if (data.wordlist_mode == WL_MODE_FILE)
16177 {
16178 if (data.dictfile == NULL)
16179 {
16180 if (dictfiles != NULL)
16181 {
16182 data.dictfile = dictfiles[0];
16183
16184 hc_timer_set (&data.timer_running);
16185 }
16186 }
16187 }
16188 }
16189 // NOTE: combi is okay because it is already set beforehand
16190 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16191 {
16192 if (data.dictfile == NULL)
16193 {
16194 if (dictfiles != NULL)
16195 {
16196 hc_timer_set (&data.timer_running);
16197
16198 data.dictfile = dictfiles[0];
16199 }
16200 }
16201 }
16202 else if (attack_mode == ATTACK_MODE_BF)
16203 {
16204 if (data.mask == NULL)
16205 {
16206 hc_timer_set (&data.timer_running);
16207
16208 data.mask = masks[0];
16209 }
16210 }
16211
16212 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16213 {
16214 data.devices_status = STATUS_EXHAUSTED;
16215 }
16216
16217 // if cracked / aborted remove last induction dictionary
16218
16219 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16220 {
16221 struct stat induct_stat;
16222
16223 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16224 {
16225 unlink (induction_dictionaries[file_pos]);
16226 }
16227 }
16228
16229 // wait for non-interactive threads
16230
16231 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16232 {
16233 hc_thread_wait (1, &ni_threads[thread_idx]);
16234 }
16235
16236 local_free (ni_threads);
16237
16238 // wait for interactive threads
16239
16240 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16241 {
16242 hc_thread_wait (1, &i_thread);
16243 }
16244
16245 // we dont need restore file anymore
16246 if (data.restore_disable == 0)
16247 {
16248 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16249 {
16250 unlink (eff_restore_file);
16251 unlink (new_restore_file);
16252 }
16253 else
16254 {
16255 cycle_restore ();
16256 }
16257 }
16258
16259 // finally save left hashes
16260
16261 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16262 {
16263 save_hash ();
16264 }
16265
16266 /**
16267 * Clean up
16268 */
16269
16270 if (benchmark == 1)
16271 {
16272 status_benchmark ();
16273
16274 log_info ("");
16275 }
16276 else
16277 {
16278 if (quiet == 0) clear_prompt ();
16279
16280 if (quiet == 0) log_info ("");
16281
16282 if (status == 1)
16283 {
16284 status_display ();
16285 }
16286 else
16287 {
16288 if (quiet == 0) status_display ();
16289 }
16290
16291 if (quiet == 0) log_info ("");
16292 }
16293
16294 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16295 {
16296 hc_device_param_t *device_param = &data.devices_param[device_id];
16297
16298 if (device_param->skipped) continue;
16299
16300 local_free (device_param->result);
16301
16302 local_free (device_param->pw_caches);
16303
16304 local_free (device_param->combs_buf);
16305
16306 local_free (device_param->hooks_buf);
16307
16308 local_free (device_param->device_name);
16309
16310 local_free (device_param->device_name_chksum);
16311
16312 local_free (device_param->device_version);
16313
16314 local_free (device_param->driver_version);
16315
16316 if (device_param->pws_buf) myfree (device_param->pws_buf);
16317 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16318 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16319 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16320 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16321 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16322 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16323 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16324 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16325 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16326 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16327 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16328 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16329 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16330 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16331 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16332 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16333 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16334 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16335 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16336 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16337 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16338 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16339 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16340 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16341 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16342 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16343 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16344 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16345
16346 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16347 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16348 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16349 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16350 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16351 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16352 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16353 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16354 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16355 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16356 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16357
16358 if (device_param->program) hc_clReleaseProgram (device_param->program);
16359 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16360 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16361
16362 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16363 if (device_param->context) hc_clReleaseContext (device_param->context);
16364 }
16365
16366 // reset default fan speed
16367
16368 if (gpu_temp_disable == 0)
16369 {
16370 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16371 {
16372 hc_thread_mutex_lock (mux_adl);
16373
16374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16375 {
16376 hc_device_param_t *device_param = &data.devices_param[device_id];
16377
16378 if (device_param->skipped) continue;
16379
16380 if (data.hm_device[device_id].fan_supported == 1)
16381 {
16382 int fanspeed = temp_retain_fanspeed_value[device_id];
16383
16384 if (fanspeed == -1) continue;
16385
16386 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16387
16388 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16389 }
16390 }
16391
16392 hc_thread_mutex_unlock (mux_adl);
16393 }
16394 }
16395
16396 // reset power tuning
16397
16398 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16399 {
16400 hc_thread_mutex_lock (mux_adl);
16401
16402 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16403 {
16404 hc_device_param_t *device_param = &data.devices_param[device_id];
16405
16406 if (device_param->skipped) continue;
16407
16408 if (data.hm_device[device_id].od_version == 6)
16409 {
16410 // check powertune capabilities first, if not available then skip device
16411
16412 int powertune_supported = 0;
16413
16414 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16415 {
16416 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16417
16418 return (-1);
16419 }
16420
16421 if (powertune_supported != 0)
16422 {
16423 // powercontrol settings
16424
16425 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)
16426 {
16427 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16428
16429 return (-1);
16430 }
16431
16432 // clocks
16433
16434 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16435
16436 performance_state->iNumberOfPerformanceLevels = 2;
16437
16438 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16439 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16440 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16441 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16442
16443 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)
16444 {
16445 log_info ("ERROR: Failed to restore ADL performance state");
16446
16447 return (-1);
16448 }
16449
16450 local_free (performance_state);
16451 }
16452 }
16453 }
16454
16455 hc_thread_mutex_unlock (mux_adl);
16456 }
16457
16458 if (gpu_temp_disable == 0)
16459 {
16460 #ifdef LINUX
16461 if (data.hm_dll_nv)
16462 {
16463 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16464
16465 hm_close (data.hm_dll_nv);
16466 }
16467 #endif
16468
16469 #ifdef WIN
16470 NvAPI_Unload ();
16471 #endif
16472
16473 if (data.hm_dll_amd)
16474 {
16475 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16476
16477 hm_close (data.hm_dll_amd);
16478 }
16479 }
16480
16481 // free memory
16482
16483 local_free (masks);
16484
16485 local_free (dictstat_base);
16486
16487 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16488 {
16489 pot_t *pot_ptr = &pot[pot_pos];
16490
16491 hash_t *hash = &pot_ptr->hash;
16492
16493 local_free (hash->digest);
16494
16495 if (isSalted)
16496 {
16497 local_free (hash->salt);
16498 }
16499 }
16500
16501 local_free (pot);
16502
16503 local_free (all_kernel_rules_cnt);
16504 local_free (all_kernel_rules_buf);
16505
16506 local_free (wl_data->buf);
16507 local_free (wl_data);
16508
16509 local_free (bitmap_s1_a);
16510 local_free (bitmap_s1_b);
16511 local_free (bitmap_s1_c);
16512 local_free (bitmap_s1_d);
16513 local_free (bitmap_s2_a);
16514 local_free (bitmap_s2_b);
16515 local_free (bitmap_s2_c);
16516 local_free (bitmap_s2_d);
16517
16518 local_free (temp_retain_fanspeed_value);
16519 local_free (od_clock_mem_status);
16520 local_free (od_power_control_status);
16521
16522 global_free (devices_param);
16523
16524 global_free (kernel_rules_buf);
16525
16526 global_free (root_css_buf);
16527 global_free (markov_css_buf);
16528
16529 global_free (digests_buf);
16530 global_free (digests_shown);
16531 global_free (digests_shown_tmp);
16532
16533 global_free (salts_buf);
16534 global_free (salts_shown);
16535
16536 global_free (esalts_buf);
16537
16538 global_free (words_progress_done);
16539 global_free (words_progress_rejected);
16540 global_free (words_progress_restored);
16541
16542 if (pot_fp) fclose (pot_fp);
16543
16544 if (data.devices_status == STATUS_QUIT) break;
16545 }
16546
16547 // destroy others mutex
16548
16549 hc_thread_mutex_delete (mux_dispatcher);
16550 hc_thread_mutex_delete (mux_counter);
16551 hc_thread_mutex_delete (mux_display);
16552 hc_thread_mutex_delete (mux_adl);
16553
16554 // free memory
16555
16556 local_free (eff_restore_file);
16557 local_free (new_restore_file);
16558
16559 local_free (rd);
16560
16561 // loopback
16562
16563 local_free (loopback_file);
16564
16565 if (loopback == 1) unlink (loopback_file);
16566
16567 // induction directory
16568
16569 if (induction_dir == NULL)
16570 {
16571 if (attack_mode != ATTACK_MODE_BF)
16572 {
16573 if (rmdir (induction_directory) == -1)
16574 {
16575 if (errno == ENOENT)
16576 {
16577 // good, we can ignore
16578 }
16579 else if (errno == ENOTEMPTY)
16580 {
16581 // good, we can ignore
16582 }
16583 else
16584 {
16585 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16586
16587 return (-1);
16588 }
16589 }
16590
16591 local_free (induction_directory);
16592 }
16593 }
16594
16595 // outfile-check directory
16596
16597 if (outfile_check_dir == NULL)
16598 {
16599 if (rmdir (outfile_check_directory) == -1)
16600 {
16601 if (errno == ENOENT)
16602 {
16603 // good, we can ignore
16604 }
16605 else if (errno == ENOTEMPTY)
16606 {
16607 // good, we can ignore
16608 }
16609 else
16610 {
16611 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16612
16613 return (-1);
16614 }
16615 }
16616
16617 local_free (outfile_check_directory);
16618 }
16619
16620 time_t proc_stop;
16621
16622 time (&proc_stop);
16623
16624 logfile_top_uint (proc_start);
16625 logfile_top_uint (proc_stop);
16626
16627 logfile_top_msg ("STOP");
16628
16629 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16630 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16631
16632 if (data.devices_status == STATUS_ABORTED) return 2;
16633 if (data.devices_status == STATUS_QUIT) return 2;
16634 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16635 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16636 if (data.devices_status == STATUS_CRACKED) return 0;
16637
16638 return -1;
16639 }
Hashcat additions to support pwdhash