projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Make sure to spawn threads for all devices, even skipped, and then instantly return
[hashcat.git] / src / oclHashcat.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include <common.h>
7 #include <shared.h>
8 #include <rp_kernel_on_cpu.h>
9 #include <getopt.h>
10
11 const char *PROGNAME = "oclHashcat";
12 const char *VERSION_TXT = "2.10";
13 const uint VERSION_BIN = 210;
14 const uint RESTORE_MIN = 210;
15
16 #define INCR_RULES 10000
17 #define INCR_SALTS 100000
18 #define INCR_MASKS 1000
19 #define INCR_POT 1000
20
21 #define USAGE 0
22 #define VERSION 0
23 #define QUIET 0
24 #define MARKOV_THRESHOLD 0
25 #define MARKOV_DISABLE 0
26 #define MARKOV_CLASSIC 0
27 #define BENCHMARK 0
28 #define BENCHMARK_MODE 1
29 #define RESTORE 0
30 #define RESTORE_TIMER 60
31 #define RESTORE_DISABLE 0
32 #define STATUS 0
33 #define STATUS_TIMER 10
34 #define STATUS_AUTOMAT 0
35 #define LOOPBACK 0
36 #define WEAK_HASH_THRESHOLD 100
37 #define SHOW 0
38 #define LEFT 0
39 #define USERNAME 0
40 #define REMOVE 0
41 #define REMOVE_TIMER 60
42 #define SKIP 0
43 #define LIMIT 0
44 #define KEYSPACE 0
45 #define POTFILE_DISABLE 0
46 #define DEBUG_MODE 0
47 #define RP_GEN 0
48 #define RP_GEN_FUNC_MIN 1
49 #define RP_GEN_FUNC_MAX 4
50 #define RP_GEN_SEED 0
51 #define RULE_BUF_L ":"
52 #define RULE_BUF_R ":"
53 #define FORCE 0
54 #define RUNTIME 0
55 #define HEX_CHARSET 0
56 #define HEX_SALT 0
57 #define HEX_WORDLIST 0
58 #define OUTFILE_FORMAT 3
59 #define OUTFILE_AUTOHEX 1
60 #define OUTFILE_CHECK_TIMER 5
61 #define ATTACK_MODE 0
62 #define HASH_MODE 0
63 #define SEGMENT_SIZE 32
64 #define INCREMENT 0
65 #define INCREMENT_MIN 1
66 #define INCREMENT_MAX PW_MAX
67 #define SEPARATOR ':'
68 #define BITMAP_MIN 16
69 #define BITMAP_MAX 24
70 #define GPU_TEMP_DISABLE 0
71 #define GPU_TEMP_ABORT 90
72 #define GPU_TEMP_RETAIN 80
73 #define WORKLOAD_PROFILE 2
74 #define KERNEL_ACCEL 0
75 #define KERNEL_LOOPS 0
76 #define KERNEL_RULES 1024
77 #define KERNEL_COMBS 1024
78 #define KERNEL_BFS 1024
79 #define KERNEL_THREADS 64
80 #define POWERTUNE_ENABLE 0
81 #define LOGFILE_DISABLE 0
82 #define SCRYPT_TMTO 0
83
84 #define WL_MODE_STDIN 1
85 #define WL_MODE_FILE 2
86 #define WL_MODE_MASK 3
87
88 #define HL_MODE_FILE 4
89 #define HL_MODE_ARG 5
90
91 #define HLFMT_HASHCAT 0
92 #define HLFMT_PWDUMP 1
93 #define HLFMT_PASSWD 2
94 #define HLFMT_SHADOW 3
95 #define HLFMT_DCC 4
96 #define HLFMT_DCC2 5
97 #define HLFMT_NETNTLM1 7
98 #define HLFMT_NETNTLM2 8
99 #define HLFMT_NSLDAP 9
100 #define HLFMT_NSLDAPS 10
101 #define HLFMTS_CNT 11
102
103 #define ATTACK_MODE_STRAIGHT 0
104 #define ATTACK_MODE_COMBI 1
105 #define ATTACK_MODE_TOGGLE 2
106 #define ATTACK_MODE_BF 3
107 #define ATTACK_MODE_PERM 4
108 #define ATTACK_MODE_TABLE 5
109 #define ATTACK_MODE_HYBRID1 6
110 #define ATTACK_MODE_HYBRID2 7
111 #define ATTACK_MODE_NONE 100
112
113 #define ATTACK_KERN_STRAIGHT 0
114 #define ATTACK_KERN_COMBI 1
115 #define ATTACK_KERN_BF 3
116 #define ATTACK_KERN_NONE 100
117
118 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
119 #define ATTACK_EXEC_INSIDE_KERNEL 11
120
121 #define COMBINATOR_MODE_BASE_LEFT 10001
122 #define COMBINATOR_MODE_BASE_RIGHT 10002
123
124 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
125 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
126
127 #define MAX_CUT_TRIES 4
128
129 #define MAX_DICTSTAT 10000
130
131 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 130
132
133 #define global_free(attr) \
134 { \
135 myfree ((void *) data.attr); \
136 \
137 data.attr = NULL; \
138 }
139
140 #define local_free(attr) \
141 { \
142 myfree ((void *) attr); \
143 \
144 attr = NULL; \
145 }
146
147 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
148 {
149 900,
150 0,
151 5100,
152 100,
153 1400,
154 10800,
155 1700,
156 5000,
157 10100,
158 6000,
159 6100,
160 6900,
161 11700,
162 11800,
163 400,
164 8900,
165 11900,
166 12000,
167 10900,
168 12100,
169 23,
170 2500,
171 5300,
172 5400,
173 5500,
174 5600,
175 7300,
176 7500,
177 8300,
178 11100,
179 11200,
180 11400,
181 121,
182 2611,
183 2711,
184 2811,
185 8400,
186 11,
187 2612,
188 7900,
189 21,
190 11000,
191 124,
192 10000,
193 3711,
194 7600,
195 12,
196 131,
197 132,
198 1731,
199 200,
200 300,
201 3100,
202 112,
203 12300,
204 8000,
205 141,
206 1441,
207 1600,
208 12600,
209 1421,
210 101,
211 111,
212 1711,
213 3000,
214 1000,
215 1100,
216 2100,
217 12800,
218 1500,
219 12400,
220 500,
221 3200,
222 7400,
223 1800,
224 122,
225 1722,
226 7100,
227 6300,
228 6700,
229 6400,
230 6500,
231 2400,
232 2410,
233 5700,
234 9200,
235 9300,
236 22,
237 501,
238 5800,
239 8100,
240 8500,
241 7200,
242 9900,
243 7700,
244 7800,
245 10300,
246 8600,
247 8700,
248 9100,
249 133,
250 11600,
251 12500,
252 13000,
253 6211,
254 6221,
255 6231,
256 6241,
257 8800,
258 12900,
259 12200,
260 9700,
261 9710,
262 9800,
263 9810,
264 9400,
265 9500,
266 9600,
267 10400,
268 10410,
269 10500,
270 10600,
271 10700,
272 9000,
273 5200,
274 6800,
275 6600,
276 8200,
277 11300,
278 12700
279 };
280
281 /**
282 * types
283 */
284
285 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
286
287 /**
288 * globals
289 */
290
291 static unsigned int full01 = 0x01010101;
292 static unsigned int full80 = 0x80808080;
293
294 int SUPPRESS_OUTPUT = 0;
295
296 hc_thread_mutex_t mux_adl;
297 hc_thread_mutex_t mux_counter;
298 hc_thread_mutex_t mux_dispatcher;
299 hc_thread_mutex_t mux_display;
300
301 hc_global_data_t data;
302
303 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
304
305 const char *USAGE_MINI[] =
306 {
307 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
308 "",
309 "Try --help for more help.",
310 NULL
311 };
312
313 const char *USAGE_BIG[] =
314 {
315 "%s, advanced password recovery",
316 "",
317 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
318 "",
319 "=======",
320 "Options",
321 "=======",
322 "",
323 "* General:",
324 "",
325 " -m, --hash-type=NUM Hash-type, see references below",
326 " -a, --attack-mode=NUM Attack-mode, see references below",
327 " -V, --version Print version",
328 " -h, --help Print help",
329 " --quiet Suppress output",
330 "",
331 "* Benchmark:",
332 "",
333 " -b, --benchmark Run benchmark",
334 " --benchmark-mode=NUM Benchmark-mode, see references below",
335 "",
336 "* Misc:",
337 "",
338 " --hex-charset Assume charset is given in hex",
339 " --hex-salt Assume salt is given in hex",
340 " --hex-wordlist Assume words in wordlist is given in hex",
341 " --force Ignore warnings",
342 " --status Enable automatic update of the status-screen",
343 " --status-timer=NUM Seconds between status-screen update",
344 " --status-automat Display the status view in a machine readable format",
345 " --loopback Add new plains to induct directory",
346 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
347 "",
348 "* Markov:",
349 "",
350 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
351 " --markov-disable Disables markov-chains, emulates classic brute-force",
352 " --markov-classic Enables classic markov-chains, no per-position enhancement",
353 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
354 "",
355 "* Session:",
356 "",
357 " --runtime=NUM Abort session after NUM seconds of runtime",
358 " --session=STR Define specific session name",
359 " --restore Restore session from --session",
360 " --restore-disable Do not write restore file",
361 "",
362 "* Files:",
363 "",
364 " -o, --outfile=FILE Define outfile for recovered hash",
365 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
366 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
367 " --outfile-check-timer=NUM Seconds between outfile checks",
368 " -p, --separator=CHAR Separator char for hashlists and outfile",
369 " --show Show cracked passwords only",
370 " --left Show un-cracked passwords only",
371 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
372 " --remove Enable remove of hash once it is cracked",
373 " --remove-timer=NUM Update input hash file each NUM seconds",
374 " --potfile-disable Do not write potfile",
375 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
376 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
377 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
378 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
379 " --logfile-disable Disable the logfile",
380 " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma",
381 "",
382 "* Resources:",
383 "",
384 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
385 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
386 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
387 " --cpu-affinity=STR Locks to CPU devices, separate with comma",
388 " --opencl-platforms=STR OpenCL platforms to use, separate with comma",
389 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
390 " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below",
391 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
392 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
393 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
394 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
395 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
396 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
397 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
398 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
399 "",
400 "* Distributed:",
401 "",
402 " -s, --skip=NUM Skip number of words",
403 " -l, --limit=NUM Limit number of words",
404 " --keyspace Show keyspace base:mod values and quit",
405 "",
406 "* Rules:",
407 "",
408 " -j, --rule-left=RULE Single rule applied to each word from left dict",
409 " -k, --rule-right=RULE Single rule applied to each word from right dict",
410 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
411 " -g, --generate-rules=NUM Generate NUM random rules",
412 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
413 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
414 " --generate-rules-seed=NUM Force RNG seed to NUM",
415 "",
416 "* Custom charsets:",
417 "",
418 " -1, --custom-charset1=CS User-defined charsets",
419 " -2, --custom-charset2=CS Example:",
420 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
421 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
422 "",
423 "* Increment:",
424 "",
425 " -i, --increment Enable increment mode",
426 " --increment-min=NUM Start incrementing at NUM",
427 " --increment-max=NUM Stop incrementing at NUM",
428 "",
429 "==========",
430 "References",
431 "==========",
432 "",
433 "* Workload Profile:",
434 "",
435 " 1 = Reduced performance profile (low latency desktop)",
436 " 2 = Default performance profile",
437 " 3 = Tuned performance profile (high latency desktop)",
438 "",
439 "* Benchmark Settings:",
440 "",
441 " 0 = Manual Tuning",
442 " 1 = Performance Tuning, default",
443 "",
444 "* OpenCL device-types:",
445 "",
446 " 1 = CPU devices",
447 " 2 = GPU devices",
448 " 3 = Accelerator devices (FPGA, CELL Blade, etc.)",
449 "",
450 "* Outfile Formats:",
451 "",
452 " 1 = hash[:salt]",
453 " 2 = plain",
454 " 3 = hash[:salt]:plain",
455 " 4 = hex_plain",
456 " 5 = hash[:salt]:hex_plain",
457 " 6 = plain:hex_plain",
458 " 7 = hash[:salt]:plain:hex_plain",
459 " 8 = crackpos",
460 " 9 = hash[:salt]:crackpos",
461 " 10 = plain:crackpos",
462 " 11 = hash[:salt]:plain:crackpos",
463 " 12 = hex_plain:crackpos",
464 " 13 = hash[:salt]:hex_plain:crackpos",
465 " 14 = plain:hex_plain:crackpos",
466 " 15 = hash[:salt]:plain:hex_plain:crackpos",
467 "",
468 "* Debug mode output formats (for hybrid mode only, by using rules):",
469 "",
470 " 1 = save finding rule",
471 " 2 = save original word",
472 " 3 = save original word and finding rule",
473 " 4 = save original word, finding rule and modified plain",
474 "",
475 "* Built-in charsets:",
476 "",
477 " ?l = abcdefghijklmnopqrstuvwxyz",
478 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
479 " ?d = 0123456789",
480 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
481 " ?a = ?l?u?d?s",
482 " ?b = 0x00 - 0xff",
483 "",
484 "* Attack modes:",
485 "",
486 " 0 = Straight",
487 " 1 = Combination",
488 " 3 = Brute-force",
489 " 6 = Hybrid dict + mask",
490 " 7 = Hybrid mask + dict",
491 "",
492 "* Hash types:",
493 "",
494 "[[ Roll-your-own: Raw Hashes ]]",
495 "",
496 " 900 = MD4",
497 " 0 = MD5",
498 " 5100 = Half MD5",
499 " 100 = SHA1",
500 " 10800 = SHA-384",
501 " 1400 = SHA-256",
502 " 1700 = SHA-512",
503 " 5000 = SHA-3(Keccak)",
504 " 10100 = SipHash",
505 " 6000 = RipeMD160",
506 " 6100 = Whirlpool",
507 " 6900 = GOST R 34.11-94",
508 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
509 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
510 "",
511 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
512 "",
513 " 10 = md5($pass.$salt)",
514 " 20 = md5($salt.$pass)",
515 " 30 = md5(unicode($pass).$salt)",
516 " 40 = md5($salt.unicode($pass))",
517 " 3800 = md5($salt.$pass.$salt)",
518 " 3710 = md5($salt.md5($pass))",
519 " 2600 = md5(md5($pass)",
520 " 4300 = md5(strtoupper(md5($pass)))",
521 " 4400 = md5(sha1($pass))",
522 " 110 = sha1($pass.$salt)",
523 " 120 = sha1($salt.$pass)",
524 " 130 = sha1(unicode($pass).$salt)",
525 " 140 = sha1($salt.unicode($pass))",
526 " 4500 = sha1(sha1($pass)",
527 " 4700 = sha1(md5($pass))",
528 " 4900 = sha1($salt.$pass.$salt)",
529 " 1410 = sha256($pass.$salt)",
530 " 1420 = sha256($salt.$pass)",
531 " 1430 = sha256(unicode($pass).$salt)",
532 " 1440 = sha256($salt.unicode($pass))",
533 " 1710 = sha512($pass.$salt)",
534 " 1720 = sha512($salt.$pass)",
535 " 1730 = sha512(unicode($pass).$salt)",
536 " 1740 = sha512($salt.unicode($pass))",
537 "",
538 "[[ Roll-your-own: Authenticated Hashes ]]",
539 "",
540 " 50 = HMAC-MD5 (key = $pass)",
541 " 60 = HMAC-MD5 (key = $salt)",
542 " 150 = HMAC-SHA1 (key = $pass)",
543 " 160 = HMAC-SHA1 (key = $salt)",
544 " 1450 = HMAC-SHA256 (key = $pass)",
545 " 1460 = HMAC-SHA256 (key = $salt)",
546 " 1750 = HMAC-SHA512 (key = $pass)",
547 " 1760 = HMAC-SHA512 (key = $salt)",
548 "",
549 "[[ Generic KDF ]]",
550 "",
551 " 400 = phpass",
552 " 8900 = scrypt",
553 " 11900 = PBKDF2-HMAC-MD5",
554 " 12000 = PBKDF2-HMAC-SHA1",
555 " 10900 = PBKDF2-HMAC-SHA256",
556 " 12100 = PBKDF2-HMAC-SHA512",
557 "",
558 "[[ Network protocols, Challenge-Response ]]",
559 "",
560 " 23 = Skype",
561 " 2500 = WPA/WPA2",
562 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
563 " 5300 = IKE-PSK MD5",
564 " 5400 = IKE-PSK SHA1",
565 " 5500 = NetNTLMv1",
566 " 5500 = NetNTLMv1 + ESS",
567 " 5600 = NetNTLMv2",
568 " 7300 = IPMI2 RAKP HMAC-SHA1",
569 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
570 " 8300 = DNSSEC (NSEC3)",
571 " 10200 = Cram MD5",
572 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
573 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
574 " 11400 = SIP digest authentication (MD5)",
575 "",
576 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
577 "",
578 " 121 = SMF (Simple Machines Forum)",
579 " 400 = phpBB3",
580 " 2611 = vBulletin < v3.8.5",
581 " 2711 = vBulletin > v3.8.5",
582 " 2811 = MyBB",
583 " 2811 = IPB (Invison Power Board)",
584 " 8400 = WBB3 (Woltlab Burning Board)",
585 " 11 = Joomla < 2.5.18",
586 " 400 = Joomla > 2.5.18",
587 " 400 = Wordpress",
588 " 2612 = PHPS",
589 " 7900 = Drupal7",
590 " 21 = osCommerce",
591 " 21 = xt:Commerce",
592 " 11000 = PrestaShop",
593 " 124 = Django (SHA-1)",
594 " 10000 = Django (PBKDF2-SHA256)",
595 " 3711 = Mediawiki B type",
596 " 7600 = Redmine",
597 "",
598 "[[ Database Server ]]",
599 "",
600 " 12 = PostgreSQL",
601 " 131 = MSSQL(2000)",
602 " 132 = MSSQL(2005)",
603 " 1731 = MSSQL(2012)",
604 " 1731 = MSSQL(2014)",
605 " 200 = MySQL323",
606 " 300 = MySQL4.1/MySQL5",
607 " 3100 = Oracle H: Type (Oracle 7+)",
608 " 112 = Oracle S: Type (Oracle 11+)",
609 " 12300 = Oracle T: Type (Oracle 12+)",
610 " 8000 = Sybase ASE",
611 "",
612 "[[ HTTP, SMTP, LDAP Server ]]",
613 "",
614 " 141 = EPiServer 6.x < v4",
615 " 1441 = EPiServer 6.x > v4",
616 " 1600 = Apache $apr1$",
617 " 12600 = ColdFusion 10+",
618 " 1421 = hMailServer",
619 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
620 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
621 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
622 "",
623 "[[ Checksums ]]",
624 "",
625 " 11500 = CRC32",
626 "",
627 "[[ Operating-Systems ]]",
628 "",
629 " 3000 = LM",
630 " 1000 = NTLM",
631 " 1100 = Domain Cached Credentials (DCC), MS Cache",
632 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
633 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
634 " 1500 = descrypt, DES(Unix), Traditional DES",
635 " 12400 = BSDiCrypt, Extended DES",
636 " 500 = md5crypt $1$, MD5(Unix)",
637 " 3200 = bcrypt $2*$, Blowfish(Unix)",
638 " 7400 = sha256crypt $5$, SHA256(Unix)",
639 " 1800 = sha512crypt $6$, SHA512(Unix)",
640 " 122 = OSX v10.4",
641 " 122 = OSX v10.5",
642 " 122 = OSX v10.6",
643 " 1722 = OSX v10.7",
644 " 7100 = OSX v10.8",
645 " 7100 = OSX v10.9",
646 " 7100 = OSX v10.10",
647 " 6300 = AIX {smd5}",
648 " 6700 = AIX {ssha1}",
649 " 6400 = AIX {ssha256}",
650 " 6500 = AIX {ssha512}",
651 " 2400 = Cisco-PIX",
652 " 2410 = Cisco-ASA",
653 " 500 = Cisco-IOS $1$",
654 " 5700 = Cisco-IOS $4$",
655 " 9200 = Cisco-IOS $8$",
656 " 9300 = Cisco-IOS $9$",
657 " 22 = Juniper Netscreen/SSG (ScreenOS)",
658 " 501 = Juniper IVE",
659 " 5800 = Android PIN",
660 " 8100 = Citrix Netscaler",
661 " 8500 = RACF",
662 " 7200 = GRUB 2",
663 " 9900 = Radmin2",
664 "",
665 "[[ Enterprise Application Software (EAS) ]]",
666 "",
667 " 7700 = SAP CODVN B (BCODE)",
668 " 7800 = SAP CODVN F/G (PASSCODE)",
669 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
670 " 8600 = Lotus Notes/Domino 5",
671 " 8700 = Lotus Notes/Domino 6",
672 " 9100 = Lotus Notes/Domino 8",
673 " 133 = PeopleSoft",
674 "",
675 "[[ Archives ]]",
676 "",
677 " 11600 = 7-Zip",
678 " 12500 = RAR3-hp",
679 " 13000 = RAR5",
680 "",
681 "[[ Full-Disk encryptions (FDE) ]]",
682 "",
683 " 62XY = TrueCrypt 5.0+",
684 " X = 1 = PBKDF2-HMAC-RipeMD160",
685 " X = 2 = PBKDF2-HMAC-SHA512",
686 " X = 3 = PBKDF2-HMAC-Whirlpool",
687 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
688 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
689 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
690 " Y = 3 = XTS 1536 bit (Ciphers: All)",
691 " 8800 = Android FDE < v4.3",
692 " 12900 = Android FDE (Samsung DEK)",
693 " 12200 = eCryptfs",
694 "",
695 "[[ Documents ]]",
696 "",
697 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
698 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
699 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
700 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
701 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
702 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
703 " 9400 = MS Office 2007",
704 " 9500 = MS Office 2010",
705 " 9600 = MS Office 2013",
706 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
707 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
708 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
709 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
710 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
711 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
712 "",
713 "[[ Password Managers ]]",
714 "",
715 " 9000 = Password Safe v2",
716 " 5200 = Password Safe v3",
717 " 6800 = Lastpass",
718 " 6600 = 1Password, agilekeychain",
719 " 8200 = 1Password, cloudkeychain",
720 " 11300 = Bitcoin/Litecoin wallet.dat",
721 " 12700 = Blockchain, My Wallet",
722 "",
723 NULL
724 };
725
726 /**
727 * oclHashcat specific functions
728 */
729
730 void status_display_automat ()
731 {
732 FILE *out = stdout;
733
734 fprintf (out, "STATUS\t%u\t", data.devices_status);
735
736 /**
737 * speed new
738 */
739
740 fprintf (out, "SPEED\t");
741
742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
743 {
744 hc_device_param_t *device_param = &data.devices_param[device_id];
745
746 if (device_param->skipped) continue;
747
748 u64 speed_cnt = 0;
749 float speed_ms = 0;
750
751 for (int i = 0; i < SPEED_CACHE; i++)
752 {
753 float rec_ms;
754
755 hc_timer_get (device_param->speed_rec[i], rec_ms);
756
757 if (rec_ms > SPEED_MAXAGE) continue;
758
759 speed_cnt += device_param->speed_cnt[i];
760 speed_ms += device_param->speed_ms[i];
761 }
762
763 speed_cnt /= SPEED_CACHE;
764 speed_ms /= SPEED_CACHE;
765
766 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
767 }
768
769 /**
770 * words_cur
771 */
772
773 u64 words_cur = get_lowest_words_done ();
774
775 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
776
777 /**
778 * counter
779 */
780
781 uint salts_left = data.salts_cnt - data.salts_done;
782
783 if (salts_left == 0) salts_left = 1;
784
785 u64 progress_total = data.words_cnt * salts_left;
786
787 u64 all_done = 0;
788 u64 all_rejected = 0;
789 u64 all_restored = 0;
790
791 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
792 {
793 if (salts_left > 1)
794 {
795 // otherwise the final cracked status shows 0/XXX progress
796
797 if (data.salts_shown[salt_pos] == 1) continue;
798 }
799
800 all_done += data.words_progress_done[salt_pos];
801 all_rejected += data.words_progress_rejected[salt_pos];
802 all_restored += data.words_progress_restored[salt_pos];
803 }
804
805 u64 progress_cur = all_restored + all_done + all_rejected;
806 u64 progress_end = progress_total;
807
808 u64 progress_skip = 0;
809
810 if (data.skip)
811 {
812 progress_skip = MIN (data.skip, data.words_base) * salts_left;
813
814 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
815 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
816 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
817 }
818
819 if (data.limit)
820 {
821 progress_end = MIN (data.limit, data.words_base) * salts_left;
822
823 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
824 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
825 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
826 }
827
828 u64 progress_cur_relative_skip = progress_cur - progress_skip;
829 u64 progress_end_relative_skip = progress_end - progress_skip;
830
831 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
832
833 /**
834 * cracks
835 */
836
837 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
838 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
839
840 /**
841 * temperature
842 */
843
844 if (data.gpu_temp_disable == 0)
845 {
846 fprintf (out, "TEMP\t");
847
848 hc_thread_mutex_lock (mux_adl);
849
850 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
851 {
852 hc_device_param_t *device_param = &data.devices_param[device_id];
853
854 if (device_param->skipped) continue;
855
856 int temp = hm_get_temperature_with_device_id (device_id);
857
858 fprintf (out, "%d\t", temp);
859 }
860
861 hc_thread_mutex_unlock (mux_adl);
862 }
863
864 #ifdef _WIN
865 fputc ('\r', out);
866 fputc ('\n', out);
867 #endif
868
869 #ifdef _POSIX
870 fputc ('\n', out);
871 #endif
872
873 fflush (out);
874 }
875
876 void status_display ()
877 {
878 if (data.devices_status == STATUS_INIT) return;
879 if (data.devices_status == STATUS_STARTING) return;
880 if (data.devices_status == STATUS_BYPASS) return;
881
882 if (data.status_automat == 1)
883 {
884 status_display_automat ();
885
886 return;
887 }
888
889 char tmp_buf[1000];
890
891 uint tmp_len = 0;
892
893 log_info ("Session.Name...: %s", data.session);
894
895 char *status_type = strstatus (data.devices_status);
896
897 uint hash_mode = data.hash_mode;
898
899 char *hash_type = strhashtype (hash_mode); // not a bug
900
901 log_info ("Status.........: %s", status_type);
902
903 /**
904 * show rules
905 */
906
907 if (data.rp_files_cnt)
908 {
909 uint i;
910
911 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
912 {
913 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
914 }
915
916 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
917
918 log_info ("Rules.Type.....: %s", tmp_buf);
919
920 tmp_len = 0;
921 }
922
923 if (data.rp_gen)
924 {
925 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
926
927 if (data.rp_gen_seed)
928 {
929 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
930 }
931 }
932
933 /**
934 * show input
935 */
936
937 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
938 {
939 if (data.wordlist_mode == WL_MODE_FILE)
940 {
941 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
942 }
943 else if (data.wordlist_mode == WL_MODE_STDIN)
944 {
945 log_info ("Input.Mode.....: Pipe");
946 }
947 }
948 else if (data.attack_mode == ATTACK_MODE_COMBI)
949 {
950 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
951 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
952 }
953 else if (data.attack_mode == ATTACK_MODE_BF)
954 {
955 char *mask = data.mask;
956
957 if (mask != NULL)
958 {
959 uint mask_len = data.css_cnt;
960
961 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
962
963 if (mask_len > 0)
964 {
965 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
966 {
967 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
968 {
969 mask_len -= data.salts_buf[0].salt_len;
970 }
971 }
972
973 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
974
975 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
976 }
977
978 if (data.maskcnt > 1)
979 {
980 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
981
982 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
983 }
984
985 log_info ("Input.Mode.....: %s", tmp_buf);
986 }
987
988 tmp_len = 0;
989 }
990 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
994 }
995 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
996 {
997 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
998 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
999 }
1000
1001 if (data.digests_cnt == 1)
1002 {
1003 if (data.hash_mode == 2500)
1004 {
1005 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1006
1007 uint pke[25];
1008
1009 char *pke_ptr = (char *) pke;
1010
1011 for (uint i = 0; i < 25; i++)
1012 {
1013 pke[i] = byte_swap_32 (wpa->pke[i]);
1014 }
1015
1016 char mac1[6];
1017 char mac2[6];
1018
1019 memcpy (mac1, pke_ptr + 23, 6);
1020 memcpy (mac2, pke_ptr + 29, 6);
1021
1022 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1023 (char *) data.salts_buf[0].salt_buf,
1024 mac1[0] & 0xff,
1025 mac1[1] & 0xff,
1026 mac1[2] & 0xff,
1027 mac1[3] & 0xff,
1028 mac1[4] & 0xff,
1029 mac1[5] & 0xff,
1030 mac2[0] & 0xff,
1031 mac2[1] & 0xff,
1032 mac2[2] & 0xff,
1033 mac2[3] & 0xff,
1034 mac2[4] & 0xff,
1035 mac2[5] & 0xff);
1036 }
1037 else if (data.hash_mode == 5200)
1038 {
1039 log_info ("Hash.Target....: File (%s)", data.hashfile);
1040 }
1041 else if (data.hash_mode == 9000)
1042 {
1043 log_info ("Hash.Target....: File (%s)", data.hashfile);
1044 }
1045 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1046 {
1047 log_info ("Hash.Target....: File (%s)", data.hashfile);
1048 }
1049 else
1050 {
1051 char out_buf[4096];
1052
1053 ascii_digest (out_buf, 0, 0);
1054
1055 // limit length
1056 if (strlen (out_buf) > 40)
1057 {
1058 out_buf[41] = '.';
1059 out_buf[42] = '.';
1060 out_buf[43] = '.';
1061 out_buf[44] = 0;
1062 }
1063
1064 log_info ("Hash.Target....: %s", out_buf);
1065 }
1066 }
1067 else
1068 {
1069 if (data.hash_mode == 3000)
1070 {
1071 char out_buf1[4096];
1072 char out_buf2[4096];
1073
1074 ascii_digest (out_buf1, 0, 0);
1075 ascii_digest (out_buf2, 0, 1);
1076
1077 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1078 }
1079 else
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 }
1084
1085 log_info ("Hash.Type......: %s", hash_type);
1086
1087 /**
1088 * speed new
1089 */
1090
1091 u64 speed_cnt[DEVICES_MAX];
1092 float speed_ms[DEVICES_MAX];
1093
1094 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1095 {
1096 hc_device_param_t *device_param = &data.devices_param[device_id];
1097
1098 if (device_param->skipped) continue;
1099
1100 // we need to clear values (set to 0) because in case the device does
1101 // not get new candidates it idles around but speed display would
1102 // show it as working.
1103 // if we instantly set it to 0 after reading it happens that the
1104 // speed can be shown as zero if the users refreshs to fast.
1105 // therefore, we add a timestamp when a stat was recorded and if its
1106 // to old we will not use it
1107
1108 speed_cnt[device_id] = 0;
1109 speed_ms[device_id] = 0;
1110
1111 for (int i = 0; i < SPEED_CACHE; i++)
1112 {
1113 float rec_ms;
1114
1115 hc_timer_get (device_param->speed_rec[i], rec_ms);
1116
1117 if (rec_ms > SPEED_MAXAGE) continue;
1118
1119 speed_cnt[device_id] += device_param->speed_cnt[i];
1120 speed_ms[device_id] += device_param->speed_ms[i];
1121 }
1122
1123 speed_cnt[device_id] /= SPEED_CACHE;
1124 speed_ms[device_id] /= SPEED_CACHE;
1125 }
1126
1127 float hashes_all_ms = 0;
1128
1129 float hashes_dev_ms[DEVICES_MAX];
1130
1131 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1132 {
1133 hc_device_param_t *device_param = &data.devices_param[device_id];
1134
1135 if (device_param->skipped) continue;
1136
1137 hashes_dev_ms[device_id] = 0;
1138
1139 if (speed_ms[device_id])
1140 {
1141 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1142
1143 hashes_all_ms += hashes_dev_ms[device_id];
1144 }
1145 }
1146
1147 /**
1148 * timers
1149 */
1150
1151 float ms_running = 0;
1152
1153 hc_timer_get (data.timer_running, ms_running);
1154
1155 float ms_paused = data.ms_paused;
1156
1157 if (data.devices_status == STATUS_PAUSED)
1158 {
1159 float ms_paused_tmp = 0;
1160
1161 hc_timer_get (data.timer_paused, ms_paused_tmp);
1162
1163 ms_paused += ms_paused_tmp;
1164 }
1165
1166 #ifdef WIN
1167
1168 __time64_t sec_run = ms_running / 1000;
1169
1170 #else
1171
1172 time_t sec_run = ms_running / 1000;
1173
1174 #endif
1175
1176 if (sec_run)
1177 {
1178 char display_run[32];
1179
1180 struct tm tm_run;
1181
1182 struct tm *tmp;
1183
1184 #ifdef WIN
1185
1186 tmp = _gmtime64 (&sec_run);
1187
1188 #else
1189
1190 tmp = gmtime (&sec_run);
1191
1192 #endif
1193
1194 if (tmp != NULL)
1195 {
1196 memcpy (&tm_run, tmp, sizeof (struct tm));
1197
1198 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1199
1200 char *start = ctime (&data.proc_start);
1201
1202 size_t start_len = strlen (start);
1203
1204 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1205 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1206
1207 log_info ("Time.Started...: %s (%s)", start, display_run);
1208 }
1209 }
1210 else
1211 {
1212 log_info ("Time.Started...: 0 secs");
1213 }
1214
1215 /**
1216 * counters
1217 */
1218
1219 uint salts_left = data.salts_cnt - data.salts_done;
1220
1221 if (salts_left == 0) salts_left = 1;
1222
1223 u64 progress_total = data.words_cnt * salts_left;
1224
1225 u64 all_done = 0;
1226 u64 all_rejected = 0;
1227 u64 all_restored = 0;
1228
1229 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1230 {
1231 if (salts_left > 1)
1232 {
1233 // otherwise the final cracked status shows 0/XXX progress
1234
1235 if (data.salts_shown[salt_pos] == 1) continue;
1236 }
1237
1238 all_done += data.words_progress_done[salt_pos];
1239 all_rejected += data.words_progress_rejected[salt_pos];
1240 all_restored += data.words_progress_restored[salt_pos];
1241 }
1242
1243 u64 progress_cur = all_restored + all_done + all_rejected;
1244 u64 progress_end = progress_total;
1245
1246 u64 progress_skip = 0;
1247
1248 if (data.skip)
1249 {
1250 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1251
1252 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1253 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1254 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1255 }
1256
1257 if (data.limit)
1258 {
1259 progress_end = MIN (data.limit, data.words_base) * salts_left;
1260
1261 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1262 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1263 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1264 }
1265
1266 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1267 u64 progress_end_relative_skip = progress_end - progress_skip;
1268
1269 float speed_ms_real = ms_running - ms_paused;
1270 u64 speed_plains_real = all_done;
1271
1272 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1273 {
1274 if (data.devices_status != STATUS_CRACKED)
1275 {
1276 u64 words_per_ms = 0;
1277
1278 if (speed_plains_real && speed_ms_real)
1279 {
1280 words_per_ms = speed_plains_real / speed_ms_real;
1281 }
1282
1283 #ifdef WIN
1284 __time64_t sec_etc = 0;
1285 #else
1286 time_t sec_etc = 0;
1287 #endif
1288
1289 if (words_per_ms)
1290 {
1291 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1292
1293 u64 ms_left = progress_left_relative_skip / words_per_ms;
1294
1295 sec_etc = ms_left / 1000;
1296 }
1297
1298 if (sec_etc == 0)
1299 {
1300 log_info ("Time.Estimated.: 0 secs");
1301 }
1302 else if ((u64) sec_etc > ETC_MAX)
1303 {
1304 log_info ("Time.Estimated.: > 10 Years");
1305 }
1306 else
1307 {
1308 char display_etc[32];
1309
1310 struct tm tm_etc;
1311
1312 struct tm *tmp;
1313
1314 #ifdef WIN
1315
1316 tmp = _gmtime64 (&sec_etc);
1317
1318 #else
1319
1320 tmp = gmtime (&sec_etc);
1321
1322 #endif
1323
1324 if (tmp != NULL)
1325 {
1326 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1327
1328 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1329
1330 time_t now;
1331
1332 time (&now);
1333
1334 now += sec_etc;
1335
1336 char *etc = ctime (&now);
1337
1338 size_t etc_len = strlen (etc);
1339
1340 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1341 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1342
1343 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1344 }
1345 }
1346 }
1347 }
1348
1349 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1350 {
1351 hc_device_param_t *device_param = &data.devices_param[device_id];
1352
1353 if (device_param->skipped) continue;
1354
1355 char display_dev_cur[16] = { 0 };
1356
1357 strncpy (display_dev_cur, "0.00", 4);
1358
1359 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1360
1361 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1362 }
1363
1364 char display_all_cur[16] = { 0 };
1365
1366 strncpy (display_all_cur, "0.00", 4);
1367
1368 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1369
1370 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1371
1372 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1373 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1374
1375 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1376
1377 // crack-per-time
1378
1379 if (data.digests_cnt > 100)
1380 {
1381 time_t now = time (NULL);
1382
1383 int cpt_cur_min = 0;
1384 int cpt_cur_hour = 0;
1385 int cpt_cur_day = 0;
1386
1387 for (int i = 0; i < CPT_BUF; i++)
1388 {
1389 const uint cracked = data.cpt_buf[i].cracked;
1390 const time_t timestamp = data.cpt_buf[i].timestamp;
1391
1392 if ((timestamp + 60) > now)
1393 {
1394 cpt_cur_min += cracked;
1395 }
1396
1397 if ((timestamp + 3600) > now)
1398 {
1399 cpt_cur_hour += cracked;
1400 }
1401
1402 if ((timestamp + 86400) > now)
1403 {
1404 cpt_cur_day += cracked;
1405 }
1406 }
1407
1408 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1409 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1410 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1411
1412 if ((data.cpt_start + 86400) < now)
1413 {
1414 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1415 cpt_cur_min,
1416 cpt_cur_hour,
1417 cpt_cur_day,
1418 cpt_avg_min,
1419 cpt_avg_hour,
1420 cpt_avg_day);
1421 }
1422 else if ((data.cpt_start + 3600) < now)
1423 {
1424 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1425 cpt_cur_min,
1426 cpt_cur_hour,
1427 cpt_avg_min,
1428 cpt_avg_hour,
1429 cpt_avg_day);
1430 }
1431 else if ((data.cpt_start + 60) < now)
1432 {
1433 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1434 cpt_cur_min,
1435 cpt_avg_min,
1436 cpt_avg_hour,
1437 cpt_avg_day);
1438 }
1439 else
1440 {
1441 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_avg_min,
1443 cpt_avg_hour,
1444 cpt_avg_day);
1445 }
1446 }
1447
1448 // Restore point
1449
1450 u64 restore_point = get_lowest_words_done ();
1451
1452 u64 restore_total = data.words_base;
1453
1454 float percent_restore = 0;
1455
1456 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1457
1458 if (progress_end_relative_skip)
1459 {
1460 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1461 {
1462 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1463 float percent_rejected = 0.0;
1464
1465 if (progress_cur)
1466 {
1467 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1468 }
1469
1470 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1471 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1472
1473 if (data.restore_disable == 0)
1474 {
1475 if (percent_finished != 1)
1476 {
1477 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1478 }
1479 }
1480 }
1481 }
1482 else
1483 {
1484 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1485 {
1486 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1487 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1488
1489 if (data.restore_disable == 0)
1490 {
1491 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1492 }
1493 }
1494 else
1495 {
1496 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1497 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1498
1499 // --restore not allowed if stdin is used -- really? why?
1500
1501 //if (data.restore_disable == 0)
1502 //{
1503 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1504 //}
1505 }
1506 }
1507
1508 if (data.gpu_temp_disable == 0)
1509 {
1510 hc_thread_mutex_lock (mux_adl);
1511
1512 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1513 {
1514 hc_device_param_t *device_param = &data.devices_param[device_id];
1515
1516 if (device_param->skipped) continue;
1517
1518 #define HM_STR_BUF_SIZE 255
1519
1520 if (data.hm_device[device_id].fan_supported == 1)
1521 {
1522 char utilization[HM_STR_BUF_SIZE];
1523 char temperature[HM_STR_BUF_SIZE];
1524 char fanspeed[HM_STR_BUF_SIZE];
1525
1526 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1527 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1528
1529 if (device_param->vendor_id == VENDOR_ID_AMD)
1530 {
1531 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1532 }
1533 else if (device_param->vendor_id == VENDOR_ID_NV)
1534 {
1535 #ifdef LINUX
1536 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1537 #else
1538 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "rpm", hm_get_fanspeed_with_device_id (device_id));
1539 #endif
1540 }
1541
1542 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1543 }
1544 else
1545 {
1546 char utilization[HM_STR_BUF_SIZE];
1547 char temperature[HM_STR_BUF_SIZE];
1548
1549 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1550 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1551
1552 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1553 }
1554 }
1555
1556 hc_thread_mutex_unlock (mux_adl);
1557 }
1558 }
1559
1560 static void status_benchmark ()
1561 {
1562 if (data.devices_status == STATUS_INIT) return;
1563 if (data.devices_status == STATUS_STARTING) return;
1564
1565 if (data.words_cnt == 0) return;
1566
1567 u64 speed_cnt[DEVICES_MAX];
1568 float speed_ms[DEVICES_MAX];
1569
1570 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1571 {
1572 hc_device_param_t *device_param = &data.devices_param[device_id];
1573
1574 if (device_param->skipped) continue;
1575
1576 speed_cnt[device_id] = 0;
1577 speed_ms[device_id] = 0;
1578
1579 for (int i = 0; i < SPEED_CACHE; i++)
1580 {
1581 speed_cnt[device_id] += device_param->speed_cnt[i];
1582 speed_ms[device_id] += device_param->speed_ms[i];
1583 }
1584
1585 speed_cnt[device_id] /= SPEED_CACHE;
1586 speed_ms[device_id] /= SPEED_CACHE;
1587 }
1588
1589 float hashes_all_ms = 0;
1590
1591 float hashes_dev_ms[DEVICES_MAX];
1592
1593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1594 {
1595 hc_device_param_t *device_param = &data.devices_param[device_id];
1596
1597 if (device_param->skipped) continue;
1598
1599 hashes_dev_ms[device_id] = 0;
1600
1601 if (speed_ms[device_id])
1602 {
1603 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1604
1605 hashes_all_ms += hashes_dev_ms[device_id];
1606 }
1607 }
1608
1609 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1610 {
1611 hc_device_param_t *device_param = &data.devices_param[device_id];
1612
1613 if (device_param->skipped) continue;
1614
1615 char display_dev_cur[16] = { 0 };
1616
1617 strncpy (display_dev_cur, "0.00", 4);
1618
1619 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1620
1621 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1622 }
1623
1624 char display_all_cur[16] = { 0 };
1625
1626 strncpy (display_all_cur, "0.00", 4);
1627
1628 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1629
1630 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1631 }
1632
1633 /**
1634 * oclHashcat -only- functions
1635 */
1636
1637 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1638 {
1639 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1640 {
1641 if (attack_kern == ATTACK_KERN_STRAIGHT)
1642 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1643 else if (attack_kern == ATTACK_KERN_COMBI)
1644 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1645 else if (attack_kern == ATTACK_KERN_BF)
1646 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1647 }
1648 else
1649 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1650 }
1651
1652 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1653 {
1654 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1655 {
1656 if (attack_kern == ATTACK_KERN_STRAIGHT)
1657 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1658 else if (attack_kern == ATTACK_KERN_COMBI)
1659 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1660 else if (attack_kern == ATTACK_KERN_BF)
1661 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1662 }
1663 else
1664 {
1665 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1666 }
1667 }
1668
1669 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1670 {
1671 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1672 {
1673 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1674 }
1675 else
1676 {
1677 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1678 }
1679 }
1680
1681 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, char *cached_file)
1682 {
1683 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1684 {
1685 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1686 }
1687 else
1688 {
1689 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1690 }
1691 }
1692
1693 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1694 {
1695 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1696 }
1697
1698 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, char *cached_file)
1699 {
1700 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1701 }
1702
1703 static uint convert_from_hex (char *line_buf, const uint line_len)
1704 {
1705 if (line_len & 1) return (line_len); // not in hex
1706
1707 if (data.hex_wordlist == 1)
1708 {
1709 uint i;
1710 uint j;
1711
1712 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1713 {
1714 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1715 }
1716
1717 memset (line_buf + i, 0, line_len - i);
1718
1719 return (i);
1720 }
1721 else if (line_len >= 6) // $HEX[] = 6
1722 {
1723 if (line_buf[0] != '$') return (line_len);
1724 if (line_buf[1] != 'H') return (line_len);
1725 if (line_buf[2] != 'E') return (line_len);
1726 if (line_buf[3] != 'X') return (line_len);
1727 if (line_buf[4] != '[') return (line_len);
1728 if (line_buf[line_len - 1] != ']') return (line_len);
1729
1730 uint i;
1731 uint j;
1732
1733 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1734 {
1735 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1736 }
1737
1738 memset (line_buf + i, 0, line_len - i);
1739
1740 return (i);
1741 }
1742
1743 return (line_len);
1744 }
1745
1746 static uint count_lines (FILE *fd)
1747 {
1748 uint cnt = 0;
1749
1750 char *buf = (char *) mymalloc (BUFSIZ + 1);
1751
1752 size_t nread_tmp = 0;
1753
1754 char *ptr = buf;
1755
1756 while (!feof (fd))
1757 {
1758 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1759 nread_tmp = nread;
1760
1761 if (nread < 1) continue;
1762
1763 ptr = buf;
1764
1765 do
1766 {
1767 if (*ptr++ == '\n') cnt++;
1768
1769 } while (nread--);
1770 }
1771
1772 // special case (if last line did not contain a newline char ... at the very end of the file)
1773
1774 if (nread_tmp > 3)
1775 {
1776 ptr -= 2;
1777
1778 if (*ptr != '\n')
1779 {
1780 ptr--;
1781
1782 if (*ptr != '\n') // needed ? different on windows systems?
1783 {
1784 cnt++;
1785 }
1786 }
1787 }
1788
1789 myfree (buf);
1790
1791 return cnt;
1792 }
1793
1794 static void clear_prompt ()
1795 {
1796 fputc ('\r', stdout);
1797
1798 for (size_t i = 0; i < strlen (PROMPT); i++)
1799 {
1800 fputc (' ', stdout);
1801 }
1802
1803 fputc ('\r', stdout);
1804
1805 fflush (stdout);
1806 }
1807
1808 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1809 {
1810 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1811 }
1812
1813 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1814 {
1815 char *outfile = data.outfile;
1816 uint quiet = data.quiet;
1817 FILE *pot_fp = data.pot_fp;
1818 uint loopback = data.loopback;
1819 uint debug_mode = data.debug_mode;
1820 char *debug_file = data.debug_file;
1821
1822 char debug_rule_buf[BLOCK_SIZE];
1823 int debug_rule_len = 0; // -1 error
1824 uint debug_plain_len = 0;
1825
1826 u8 debug_plain_ptr[BLOCK_SIZE];
1827
1828 // hash
1829
1830 char out_buf[4096] = { 0 };
1831
1832 ascii_digest (out_buf, salt_pos, digest_pos);
1833
1834 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1835
1836 // plain
1837
1838 plain_t plain;
1839
1840 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1841
1842 uint gidvid = plain.gidvid;
1843 uint il_pos = plain.il_pos;
1844
1845 u64 crackpos = device_param->words_off;
1846
1847 uint plain_buf[16];
1848
1849 u8 *plain_ptr = (u8 *) plain_buf;
1850 unsigned int plain_len = 0;
1851
1852 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1853 {
1854 u64 gidd = gidvid;
1855 u64 gidm = 0;
1856
1857 pw_t pw;
1858
1859 gidd_to_pw_t (device_param, gidd, &pw);
1860
1861 for (int i = 0, j = gidm; i < 16; i++, j++)
1862 {
1863 plain_buf[i] = pw.hi1[0][j];
1864 }
1865
1866 plain_len = pw.pw_len;
1867
1868 const uint off = device_param->innerloop_pos + il_pos;
1869
1870 if (debug_mode > 0)
1871 {
1872 debug_rule_len = 0;
1873
1874 // save rule
1875 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1876 {
1877 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1878
1879 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1880 }
1881
1882 // save plain
1883 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1884 {
1885 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1886
1887 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1888
1889 debug_plain_len = plain_len;
1890 }
1891 }
1892
1893 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1894
1895 crackpos += gidvid;
1896 crackpos *= data.kernel_rules_cnt;
1897 crackpos += device_param->innerloop_pos + il_pos;
1898
1899 if (plain_len > data.pw_max) plain_len = data.pw_max;
1900 }
1901 else if (data.attack_mode == ATTACK_MODE_COMBI)
1902 {
1903 u64 gidd = gidvid;
1904 u64 gidm = 0;
1905
1906 pw_t pw;
1907
1908 gidd_to_pw_t (device_param, gidd, &pw);
1909
1910 for (int i = 0, j = gidm; i < 16; i++, j++)
1911 {
1912 plain_buf[i] = pw.hi1[0][j];
1913 }
1914
1915 plain_len = pw.pw_len;
1916
1917 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1918 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1919
1920 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1921 {
1922 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1923 }
1924 else
1925 {
1926 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1927
1928 memcpy (plain_ptr, comb_buf, comb_len);
1929 }
1930
1931 plain_len += comb_len;
1932
1933 crackpos += gidvid;
1934 crackpos *= data.combs_cnt;
1935 crackpos += device_param->innerloop_pos + il_pos;
1936
1937 if (data.pw_max != PW_DICTMAX1)
1938 {
1939 if (plain_len > data.pw_max) plain_len = data.pw_max;
1940 }
1941 }
1942 else if (data.attack_mode == ATTACK_MODE_BF)
1943 {
1944 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1945 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1946
1947 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1948 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1949
1950 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1951 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1952
1953 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1954 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1955
1956 plain_len = data.css_cnt;
1957
1958 crackpos += gidvid;
1959 crackpos *= data.bfs_cnt;
1960 crackpos += device_param->innerloop_pos + il_pos;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1963 {
1964 u64 gidd = gidvid;
1965 u64 gidm = 0;
1966
1967 pw_t pw;
1968
1969 gidd_to_pw_t (device_param, gidd, &pw);
1970
1971 for (int i = 0, j = gidm; i < 16; i++, j++)
1972 {
1973 plain_buf[i] = pw.hi1[0][j];
1974 }
1975
1976 plain_len = pw.pw_len;
1977
1978 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1979
1980 uint start = 0;
1981 uint stop = device_param->kernel_params_mp_buf32[4];
1982
1983 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1984
1985 plain_len += start + stop;
1986
1987 crackpos += gidvid;
1988 crackpos *= data.combs_cnt;
1989 crackpos += device_param->innerloop_pos + il_pos;
1990
1991 if (data.pw_max != PW_DICTMAX1)
1992 {
1993 if (plain_len > data.pw_max) plain_len = data.pw_max;
1994 }
1995 }
1996 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1997 {
1998 u64 gidd = gidvid;
1999 u64 gidm = 0;
2000
2001 pw_t pw;
2002
2003 gidd_to_pw_t (device_param, gidd, &pw);
2004
2005 for (int i = 0, j = gidm; i < 16; i++, j++)
2006 {
2007 plain_buf[i] = pw.hi1[0][j];
2008 }
2009
2010 plain_len = pw.pw_len;
2011
2012 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2013
2014 uint start = 0;
2015 uint stop = device_param->kernel_params_mp_buf32[4];
2016
2017 memmove (plain_ptr + stop, plain_ptr, plain_len);
2018
2019 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032
2033 if (data.attack_mode == ATTACK_MODE_BF)
2034 {
2035 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2036 {
2037 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2038 {
2039 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2040 {
2041 plain_len = plain_len - data.salts_buf[0].salt_len;
2042 }
2043 }
2044
2045 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2046 {
2047 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2048 {
2049 plain_ptr[j] = plain_ptr[i];
2050 }
2051
2052 plain_len = plain_len / 2;
2053 }
2054 }
2055 }
2056
2057 // if enabled, update also the potfile
2058
2059 if (pot_fp)
2060 {
2061 fprintf (pot_fp, "%s:", out_buf);
2062
2063 format_plain (pot_fp, plain_ptr, plain_len, 1);
2064
2065 fputc ('\n', pot_fp);
2066
2067 fflush (pot_fp);
2068 }
2069
2070 // outfile
2071
2072 FILE *out_fp = NULL;
2073
2074 if (outfile != NULL)
2075 {
2076 if ((out_fp = fopen (outfile, "ab")) == NULL)
2077 {
2078 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2079
2080 out_fp = stdout;
2081 }
2082 }
2083 else
2084 {
2085 out_fp = stdout;
2086
2087 if (quiet == 0) clear_prompt ();
2088 }
2089
2090 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2091
2092 if (outfile != NULL)
2093 {
2094 if (out_fp != stdout)
2095 {
2096 fclose (out_fp);
2097 }
2098 }
2099 else
2100 {
2101 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2102 {
2103 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2104 {
2105 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2106 if (quiet == 0) fflush (stdout);
2107 }
2108 }
2109 }
2110
2111 // loopback
2112
2113 if (loopback)
2114 {
2115 char *loopback_file = data.loopback_file;
2116
2117 FILE *fb_fp = NULL;
2118
2119 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2120 {
2121 format_plain (fb_fp, plain_ptr, plain_len, 1);
2122
2123 fputc ('\n', fb_fp);
2124
2125 fclose (fb_fp);
2126 }
2127 }
2128
2129 // (rule) debug mode
2130
2131 // the next check implies that:
2132 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2133 // - debug_mode > 0
2134
2135 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2136 {
2137 if (debug_rule_len < 0) debug_rule_len = 0;
2138
2139 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2140
2141 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2142
2143 if ((quiet == 0) && (debug_file == NULL))
2144 {
2145 fprintf (stdout, "%s", PROMPT);
2146 fflush (stdout);
2147 }
2148 }
2149 }
2150
2151 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2152 {
2153 salt_t *salt_buf = &data.salts_buf[salt_pos];
2154
2155 int found = 0;
2156
2157 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2158
2159 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2160
2161 if (found == 1)
2162 {
2163 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2164
2165 log_info_nn ("");
2166
2167 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2168
2169 uint cpt_cracked = 0;
2170
2171 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2172 {
2173 uint idx = salt_buf->digests_offset + digest_pos;
2174
2175 if (data.digests_shown_tmp[idx] == 0) continue;
2176
2177 if (data.digests_shown[idx] == 1) continue;
2178
2179 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2180 {
2181 data.digests_shown[idx] = 1;
2182
2183 data.digests_done++;
2184
2185 cpt_cracked++;
2186
2187 salt_buf->digests_done++;
2188
2189 if (salt_buf->digests_done == salt_buf->digests_cnt)
2190 {
2191 data.salts_shown[salt_pos] = 1;
2192
2193 data.salts_done++;
2194 }
2195 }
2196
2197 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2198
2199 check_hash (device_param, salt_pos, digest_pos);
2200 }
2201
2202 if (cpt_cracked > 0)
2203 {
2204 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2205 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2206
2207 data.cpt_pos++;
2208
2209 data.cpt_total += cpt_cracked;
2210
2211 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2212 }
2213
2214 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2215 {
2216 // we need to reset cracked state on the device
2217 // otherwise host thinks again and again the hash was cracked
2218 // and returns invalid password each time
2219
2220 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2221
2222 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2223 }
2224
2225 memset (device_param->result, 0, device_param->size_results);
2226
2227 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2228 }
2229 }
2230
2231 static void save_hash ()
2232 {
2233 char *hashfile = data.hashfile;
2234
2235 char new_hashfile[256] = { 0 };
2236 char old_hashfile[256] = { 0 };
2237
2238 snprintf (new_hashfile, 255, "%s.new", hashfile);
2239 snprintf (old_hashfile, 255, "%s.old", hashfile);
2240
2241 unlink (new_hashfile);
2242
2243 char separator = data.separator;
2244
2245 FILE *fp = fopen (new_hashfile, "wb");
2246
2247 if (fp == NULL)
2248 {
2249 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2250
2251 exit (-1);
2252 }
2253
2254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2255 {
2256 if (data.salts_shown[salt_pos] == 1) continue;
2257
2258 salt_t *salt_buf = &data.salts_buf[salt_pos];
2259
2260 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2261 {
2262 uint idx = salt_buf->digests_offset + digest_pos;
2263
2264 if (data.digests_shown[idx] == 1) continue;
2265
2266 if (data.hash_mode != 2500)
2267 {
2268 char out_buf[4096] = { 0 };
2269
2270 if (data.username == 1)
2271 {
2272 user_t *user = data.hash_info[idx]->user;
2273
2274 uint i;
2275
2276 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2277
2278 fputc (separator, fp);
2279 }
2280
2281 ascii_digest (out_buf, salt_pos, digest_pos);
2282
2283 fputs (out_buf, fp);
2284
2285 log_out (fp, "");
2286 }
2287 else
2288 {
2289 hccap_t hccap;
2290
2291 to_hccap_t (&hccap, salt_pos, digest_pos);
2292
2293 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2294 }
2295 }
2296 }
2297
2298 fflush (fp);
2299
2300 fclose (fp);
2301
2302 unlink (old_hashfile);
2303
2304 if (rename (hashfile, old_hashfile) != 0)
2305 {
2306 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2307
2308 exit (-1);
2309 }
2310
2311 unlink (hashfile);
2312
2313 if (rename (new_hashfile, hashfile) != 0)
2314 {
2315 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2316
2317 exit (-1);
2318 }
2319
2320 unlink (old_hashfile);
2321 }
2322
2323 static float find_kernel_blocks_div (const u64 total_left, const uint kernel_blocks_all)
2324 {
2325 // function called only in case kernel_blocks_all > words_left)
2326
2327 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2328
2329 kernel_blocks_div += kernel_blocks_div / 100;
2330
2331 u32 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2332
2333 while (kernel_blocks_new < total_left)
2334 {
2335 kernel_blocks_div += kernel_blocks_div / 100;
2336
2337 kernel_blocks_new = (u32) (kernel_blocks_all * kernel_blocks_div);
2338 }
2339
2340 if (data.quiet == 0)
2341 {
2342 clear_prompt ();
2343
2344 log_info ("");
2345
2346 log_info ("INFO: approaching final keyspace, workload adjusted");
2347
2348 log_info ("");
2349
2350 fprintf (stdout, "%s", PROMPT);
2351
2352 fflush (stdout);
2353 }
2354
2355 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2356
2357 return kernel_blocks_div;
2358 }
2359
2360 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2361 {
2362 uint num_elements = num;
2363
2364 device_param->kernel_params_buf32[30] = data.combs_mode;
2365 device_param->kernel_params_buf32[31] = num;
2366
2367 uint kernel_threads = device_param->kernel_threads;
2368
2369 while (num_elements % kernel_threads) num_elements++;
2370
2371 cl_kernel kernel = NULL;
2372
2373 switch (kern_run)
2374 {
2375 case KERN_RUN_1: kernel = device_param->kernel1; break;
2376 case KERN_RUN_12: kernel = device_param->kernel12; break;
2377 case KERN_RUN_2: kernel = device_param->kernel2; break;
2378 case KERN_RUN_23: kernel = device_param->kernel23; break;
2379 case KERN_RUN_3: kernel = device_param->kernel3; break;
2380 }
2381
2382 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2383 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2384 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2385 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2386 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2387 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2388 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2389 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2390 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2391 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2392 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2393
2394 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2395 {
2396 const size_t global_work_size[3] = { num_elements, 32, 1 };
2397 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2398
2399 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2400 }
2401 else
2402 {
2403 const size_t global_work_size[3] = { num_elements, 1, 1 };
2404 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2405
2406 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2407 }
2408
2409 hc_clFlush (device_param->command_queue);
2410
2411 hc_clFinish (device_param->command_queue);
2412 }
2413
2414 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2415 {
2416 uint num_elements = num;
2417
2418 switch (kern_run)
2419 {
2420 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2421 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2422 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2423 }
2424
2425 // causes problems with special threads like in bcrypt
2426 // const uint kernel_threads = device_param->kernel_threads;
2427
2428 const uint kernel_threads = KERNEL_THREADS;
2429
2430 while (num_elements % kernel_threads) num_elements++;
2431
2432 cl_kernel kernel = NULL;
2433
2434 switch (kern_run)
2435 {
2436 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2437 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2438 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2439 }
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2444 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2445 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2446 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2447 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2448 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2449 break;
2450 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2451 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2452 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2453 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2454 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2455 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2456 break;
2457 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2458 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2459 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2460 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2461 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2462 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2463 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2464 break;
2465 }
2466
2467 const size_t global_work_size[3] = { num_elements, 1, 1 };
2468 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2469
2470 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2471
2472 hc_clFlush (device_param->command_queue);
2473
2474 hc_clFinish (device_param->command_queue);
2475 }
2476
2477 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2478 {
2479 uint num_elements = num;
2480
2481 uint kernel_threads = device_param->kernel_threads;
2482
2483 while (num_elements % kernel_threads) num_elements++;
2484
2485 cl_kernel kernel = device_param->kernel_tb;
2486
2487 const size_t global_work_size[3] = { num_elements, 1, 1 };
2488 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2489
2490 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2491
2492 hc_clFlush (device_param->command_queue);
2493
2494 hc_clFinish (device_param->command_queue);
2495 }
2496
2497 static void run_kernel_tm (hc_device_param_t *device_param)
2498 {
2499 const uint num_elements = 1024; // fixed
2500
2501 const uint kernel_threads = 32;
2502
2503 cl_kernel kernel = device_param->kernel_tm;
2504
2505 const size_t global_work_size[3] = { num_elements, 1, 1 };
2506 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2507
2508 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2509
2510 hc_clFlush (device_param->command_queue);
2511
2512 hc_clFinish (device_param->command_queue);
2513 }
2514
2515 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2516 {
2517 uint num_elements = num;
2518
2519 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2520 device_param->kernel_params_amp_buf32[6] = num_elements;
2521
2522 // causes problems with special threads like in bcrypt
2523 // const uint kernel_threads = device_param->kernel_threads;
2524
2525 const uint kernel_threads = KERNEL_THREADS;
2526
2527 while (num_elements % kernel_threads) num_elements++;
2528
2529 cl_kernel kernel = device_param->kernel_amp;
2530
2531 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2532 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2533
2534 const size_t global_work_size[3] = { num_elements, 1, 1 };
2535 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2536
2537 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2538
2539 hc_clFlush (device_param->command_queue);
2540
2541 hc_clFinish (device_param->command_queue);
2542 }
2543
2544 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2545 {
2546 if (device_param->vendor_id == VENDOR_ID_AMD)
2547 {
2548 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2549
2550 const cl_uchar zero = 0;
2551
2552 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2553 }
2554 else
2555 {
2556 // NOTE: clEnqueueFillBuffer () always fails with -59
2557 // IOW, it's not supported by Nvidia ForceWare <= 352.21, also pocl segfaults
2558 // How's that possible, OpenCL 1.2 support is advertised??
2559 // We need to workaround...
2560
2561 #define FILLSZ 0x100000
2562
2563 char *tmp = (char *) mymalloc (FILLSZ);
2564
2565 memset (tmp, 0, FILLSZ);
2566
2567 for (uint i = 0; i < size; i += FILLSZ)
2568 {
2569 const int left = size - i;
2570
2571 const int fillsz = MIN (FILLSZ, left);
2572
2573 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2574 }
2575
2576 myfree (tmp);
2577 }
2578 }
2579
2580 static int run_rule_engine (const int rule_len, const char *rule_buf)
2581 {
2582 if (rule_len == 0)
2583 {
2584 return 0;
2585 }
2586 else if (rule_len == 1)
2587 {
2588 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2589 }
2590
2591 return 1;
2592 }
2593
2594 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2595 {
2596 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2597 {
2598 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2599 }
2600 else if (data.attack_kern == ATTACK_KERN_COMBI)
2601 {
2602 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2603 }
2604 else if (data.attack_kern == ATTACK_KERN_BF)
2605 {
2606 const u64 off = device_param->words_off;
2607
2608 device_param->kernel_params_mp_l_buf64[3] = off;
2609
2610 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2611 }
2612 }
2613
2614 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2615 {
2616 const uint kernel_loops = data.kernel_loops;
2617
2618 // init speed timer
2619
2620 uint speed_pos = device_param->speed_pos;
2621
2622 #ifdef _POSIX
2623 if (device_param->timer_speed.tv_sec == 0)
2624 {
2625 hc_timer_set (&device_param->timer_speed);
2626 }
2627 #endif
2628
2629 #ifdef _WIN
2630 if (device_param->timer_speed.QuadPart == 0)
2631 {
2632 hc_timer_set (&device_param->timer_speed);
2633 }
2634 #endif
2635
2636 // find higest password length, this is for optimization stuff
2637
2638 uint highest_pw_len = 0;
2639
2640 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2641 {
2642 }
2643 else if (data.attack_kern == ATTACK_KERN_COMBI)
2644 {
2645 }
2646 else if (data.attack_kern == ATTACK_KERN_BF)
2647 {
2648 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2649 + device_param->kernel_params_mp_l_buf32[5];
2650 }
2651
2652 // bitslice optimization stuff
2653
2654 if (data.attack_mode == ATTACK_MODE_BF)
2655 {
2656 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2657 {
2658 run_kernel_tb (device_param, pws_cnt);
2659 }
2660 }
2661
2662 // iteration type
2663
2664 uint innerloop_step = 0;
2665 uint innerloop_cnt = 0;
2666
2667 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2668 else innerloop_step = 1;
2669
2670 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2671 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2672 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2673
2674 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2675
2676 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2677 {
2678 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2679
2680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2681
2682 if (data.devices_status == STATUS_CRACKED) break;
2683 if (data.devices_status == STATUS_ABORTED) break;
2684 if (data.devices_status == STATUS_QUIT) break;
2685 if (data.devices_status == STATUS_BYPASS) break;
2686
2687 if (data.salts_shown[salt_pos] == 1) continue;
2688
2689 salt_t *salt_buf = &data.salts_buf[salt_pos];
2690
2691 device_param->kernel_params_buf32[24] = salt_pos;
2692 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2693 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2694
2695 FILE *combs_fp = device_param->combs_fp;
2696
2697 if (data.attack_mode == ATTACK_MODE_COMBI)
2698 {
2699 rewind (combs_fp);
2700 }
2701
2702 // innerloops
2703
2704 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2705 {
2706 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2707
2708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2709
2710 if (data.devices_status == STATUS_CRACKED) break;
2711 if (data.devices_status == STATUS_ABORTED) break;
2712 if (data.devices_status == STATUS_QUIT) break;
2713 if (data.devices_status == STATUS_BYPASS) break;
2714
2715 uint innerloop_left = innerloop_cnt - innerloop_pos;
2716
2717 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2718
2719 device_param->innerloop_pos = innerloop_pos;
2720 device_param->innerloop_left = innerloop_left;
2721
2722 device_param->kernel_params_buf32[27] = innerloop_left;
2723
2724 if (innerloop_left == 0) continue;
2725
2726 // initialize amplifiers
2727
2728 if (data.attack_mode == ATTACK_MODE_COMBI)
2729 {
2730 char line_buf[BUFSIZ];
2731
2732 uint i = 0;
2733
2734 while (i < innerloop_left)
2735 {
2736 if (feof (combs_fp)) break;
2737
2738 int line_len = fgetl (combs_fp, line_buf);
2739
2740 if (line_len >= PW_MAX1) continue;
2741
2742 line_len = convert_from_hex (line_buf, line_len);
2743
2744 char *line_buf_new = line_buf;
2745
2746 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2747 {
2748 char rule_buf_out[BLOCK_SIZE] = { 0 };
2749
2750 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2751
2752 if (rule_len_out < 0)
2753 {
2754 data.words_progress_rejected[salt_pos] += pw_cnt;
2755
2756 continue;
2757 }
2758
2759 line_len = rule_len_out;
2760
2761 line_buf_new = rule_buf_out;
2762 }
2763
2764 line_len = MIN (line_len, PW_DICTMAX);
2765
2766 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
2767
2768 memcpy (ptr, line_buf_new, line_len);
2769
2770 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2771
2772 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2773 {
2774 uppercase (ptr, line_len);
2775 }
2776
2777 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2778 {
2779 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2780 {
2781 ptr[line_len] = 0x80;
2782 }
2783
2784 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2785 {
2786 ptr[line_len] = 0x01;
2787 }
2788 }
2789
2790 device_param->combs_buf[i].pw_len = line_len;
2791
2792 i++;
2793 }
2794
2795 for (uint j = i; j < innerloop_left; j++)
2796 {
2797 device_param->combs_buf[j].i[0] = 0;
2798 device_param->combs_buf[j].i[1] = 0;
2799 device_param->combs_buf[j].i[2] = 0;
2800 device_param->combs_buf[j].i[3] = 0;
2801 device_param->combs_buf[j].i[4] = 0;
2802 device_param->combs_buf[j].i[5] = 0;
2803 device_param->combs_buf[j].i[6] = 0;
2804 device_param->combs_buf[j].i[7] = 0;
2805
2806 device_param->combs_buf[j].pw_len = 0;
2807 }
2808
2809 innerloop_left = i;
2810 }
2811 else if (data.attack_mode == ATTACK_MODE_BF)
2812 {
2813 u64 off = innerloop_pos;
2814
2815 device_param->kernel_params_mp_r_buf64[3] = off;
2816
2817 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2818 }
2819 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2820 {
2821 u64 off = innerloop_pos;
2822
2823 device_param->kernel_params_mp_buf64[3] = off;
2824
2825 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2826 }
2827 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2828 {
2829 u64 off = innerloop_pos;
2830
2831 device_param->kernel_params_mp_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2834 }
2835
2836 // copy amplifiers
2837
2838 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2839 {
2840 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
2841 }
2842 else if (data.attack_mode == ATTACK_MODE_COMBI)
2843 {
2844 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
2845 }
2846 else if (data.attack_mode == ATTACK_MODE_BF)
2847 {
2848 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
2849 }
2850 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2851 {
2852 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2853 }
2854 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2855 {
2856 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
2857 }
2858
2859 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2860 {
2861 if (data.attack_mode == ATTACK_MODE_BF)
2862 {
2863 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2864 {
2865 const uint size_tm = 32 * sizeof (bs_word_t);
2866
2867 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2868
2869 run_kernel_tm (device_param);
2870
2871 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2872 }
2873 }
2874
2875 if (highest_pw_len < 16)
2876 {
2877 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2878 }
2879 else if (highest_pw_len < 32)
2880 {
2881 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2882 }
2883 else
2884 {
2885 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2886 }
2887 }
2888 else
2889 {
2890 run_kernel_amp (device_param, pws_cnt);
2891
2892 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2893
2894 if (data.opts_type & OPTS_TYPE_HOOK12)
2895 {
2896 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2897 }
2898
2899 uint iter = salt_buf->salt_iter;
2900
2901 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2902 {
2903 uint loop_left = iter - loop_pos;
2904
2905 loop_left = MIN (loop_left, kernel_loops);
2906
2907 device_param->kernel_params_buf32[25] = loop_pos;
2908 device_param->kernel_params_buf32[26] = loop_left;
2909
2910 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2911
2912 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2913
2914 if (data.devices_status == STATUS_CRACKED) break;
2915 if (data.devices_status == STATUS_ABORTED) break;
2916 if (data.devices_status == STATUS_QUIT) break;
2917 }
2918
2919 if (data.opts_type & OPTS_TYPE_HOOK23)
2920 {
2921 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2922
2923 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2924
2925 // do something with data
2926
2927 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2928 }
2929
2930 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2931 }
2932
2933 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2934
2935 if (data.devices_status == STATUS_CRACKED) break;
2936 if (data.devices_status == STATUS_ABORTED) break;
2937 if (data.devices_status == STATUS_QUIT) break;
2938
2939 /**
2940 * result
2941 */
2942
2943 hc_thread_mutex_lock (mux_display);
2944
2945 check_cracked (device_param, salt_pos);
2946
2947 hc_thread_mutex_unlock (mux_display);
2948
2949 /**
2950 * progress
2951 */
2952
2953 u64 perf_sum_all = (u64) pw_cnt * (u64) innerloop_left;
2954
2955 hc_thread_mutex_lock (mux_counter);
2956
2957 data.words_progress_done[salt_pos] += perf_sum_all;
2958
2959 hc_thread_mutex_unlock (mux_counter);
2960
2961 /**
2962 * speed
2963 */
2964
2965 float speed_ms;
2966
2967 hc_timer_get (device_param->timer_speed, speed_ms);
2968
2969 hc_timer_set (&device_param->timer_speed);
2970
2971 hc_thread_mutex_lock (mux_display);
2972
2973 device_param->speed_cnt[speed_pos] = perf_sum_all;
2974
2975 device_param->speed_ms[speed_pos] = speed_ms;
2976
2977 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2978
2979 hc_thread_mutex_unlock (mux_display);
2980
2981 speed_pos++;
2982
2983 if (speed_pos == SPEED_CACHE)
2984 {
2985 speed_pos = 0;
2986 }
2987 }
2988 }
2989
2990 device_param->speed_pos = speed_pos;
2991 }
2992
2993 static void load_segment (wl_data_t *wl_data, FILE *fd)
2994 {
2995 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2996
2997 wl_data->pos = 0;
2998
2999 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3000
3001 wl_data->buf[wl_data->cnt] = 0;
3002
3003 if (wl_data->cnt == 0) return;
3004
3005 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3006
3007 while (!feof (fd))
3008 {
3009 if (wl_data->cnt == wl_data->avail)
3010 {
3011 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3012
3013 wl_data->avail += wl_data->incr;
3014 }
3015
3016 const int c = fgetc (fd);
3017
3018 if (c == EOF) break;
3019
3020 wl_data->buf[wl_data->cnt] = (char) c;
3021
3022 wl_data->cnt++;
3023
3024 if (c == '\n') break;
3025 }
3026
3027 // ensure stream ends with a newline
3028
3029 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3030 {
3031 wl_data->cnt++;
3032
3033 wl_data->buf[wl_data->cnt - 1] = '\n';
3034 }
3035
3036 return;
3037 }
3038
3039 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3040 {
3041 char *ptr = buf;
3042
3043 for (u32 i = 0; i < sz; i++, ptr++)
3044 {
3045 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3046
3047 if (i == 7)
3048 {
3049 *off = i;
3050 *len = i;
3051
3052 return;
3053 }
3054
3055 if (*ptr != '\n') continue;
3056
3057 *off = i + 1;
3058
3059 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3060
3061 *len = i;
3062
3063 return;
3064 }
3065
3066 *off = sz;
3067 *len = sz;
3068 }
3069
3070 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3071 {
3072 char *ptr = buf;
3073
3074 for (u32 i = 0; i < sz; i++, ptr++)
3075 {
3076 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3077
3078 if (*ptr != '\n') continue;
3079
3080 *off = i + 1;
3081
3082 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3083
3084 *len = i;
3085
3086 return;
3087 }
3088
3089 *off = sz;
3090 *len = sz;
3091 }
3092
3093 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3094 {
3095 char *ptr = buf;
3096
3097 for (u32 i = 0; i < sz; i++, ptr++)
3098 {
3099 if (*ptr != '\n') continue;
3100
3101 *off = i + 1;
3102
3103 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3104
3105 *len = i;
3106
3107 return;
3108 }
3109
3110 *off = sz;
3111 *len = sz;
3112 }
3113
3114 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3115 {
3116 while (wl_data->pos < wl_data->cnt)
3117 {
3118 uint off;
3119 uint len;
3120
3121 char *ptr = wl_data->buf + wl_data->pos;
3122
3123 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3124
3125 wl_data->pos += off;
3126
3127 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3128 {
3129 char rule_buf_out[BLOCK_SIZE] = { 0 };
3130
3131 int rule_len_out = -1;
3132
3133 if (len < BLOCK_SIZE)
3134 {
3135 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3136 }
3137
3138 if (rule_len_out < 0)
3139 {
3140 continue;
3141 }
3142
3143 if (rule_len_out > PW_MAX)
3144 {
3145 continue;
3146 }
3147 }
3148 else
3149 {
3150 if (len > PW_MAX)
3151 {
3152 continue;
3153 }
3154 }
3155
3156 *out_buf = ptr;
3157 *out_len = len;
3158
3159 return;
3160 }
3161
3162 if (feof (fd))
3163 {
3164 fprintf (stderr, "bug!!\n");
3165
3166 return;
3167 }
3168
3169 load_segment (wl_data, fd);
3170
3171 get_next_word (wl_data, fd, out_buf, out_len);
3172 }
3173
3174 #ifdef _POSIX
3175 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3176 #endif
3177
3178 #ifdef _WIN
3179 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3180 #endif
3181 {
3182 hc_signal (NULL);
3183
3184 dictstat_t d;
3185
3186 d.cnt = 0;
3187
3188 #ifdef _POSIX
3189 fstat (fileno (fd), &d.stat);
3190 #endif
3191
3192 #ifdef _WIN
3193 _fstat64 (fileno (fd), &d.stat);
3194 #endif
3195
3196 d.stat.st_mode = 0;
3197 d.stat.st_nlink = 0;
3198 d.stat.st_uid = 0;
3199 d.stat.st_gid = 0;
3200 d.stat.st_rdev = 0;
3201 d.stat.st_atime = 0;
3202
3203 #ifdef _POSIX
3204 d.stat.st_blksize = 0;
3205 d.stat.st_blocks = 0;
3206 #endif
3207
3208 if (d.stat.st_size == 0) return 0;
3209
3210 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3211
3212 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3213 {
3214 if (d_cache)
3215 {
3216 u64 cnt = d_cache->cnt;
3217
3218 u64 keyspace = cnt;
3219
3220 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3221 {
3222 keyspace *= data.kernel_rules_cnt;
3223 }
3224 else if (data.attack_kern == ATTACK_KERN_COMBI)
3225 {
3226 keyspace *= data.combs_cnt;
3227 }
3228
3229 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3230 if (data.quiet == 0) log_info ("");
3231
3232 hc_signal (sigHandler_default);
3233
3234 return (keyspace);
3235 }
3236 }
3237
3238 time_t now = 0;
3239 time_t prev = 0;
3240
3241 u64 comp = 0;
3242 u64 cnt = 0;
3243 u64 cnt2 = 0;
3244
3245 while (!feof (fd))
3246 {
3247 load_segment (wl_data, fd);
3248
3249 comp += wl_data->cnt;
3250
3251 u32 i = 0;
3252
3253 while (i < wl_data->cnt)
3254 {
3255 u32 len;
3256 u32 off;
3257
3258 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3259
3260 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3261 {
3262 char rule_buf_out[BLOCK_SIZE] = { 0 };
3263
3264 int rule_len_out = -1;
3265
3266 if (len < BLOCK_SIZE)
3267 {
3268 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3269 }
3270
3271 if (rule_len_out < 0)
3272 {
3273 len = PW_MAX1;
3274 }
3275 else
3276 {
3277 len = rule_len_out;
3278 }
3279 }
3280
3281 if (len < PW_MAX1)
3282 {
3283 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3284 {
3285 cnt += data.kernel_rules_cnt;
3286 }
3287 else if (data.attack_kern == ATTACK_KERN_COMBI)
3288 {
3289 cnt += data.combs_cnt;
3290 }
3291
3292 d.cnt++;
3293 }
3294
3295 i += off;
3296
3297 cnt2++;
3298 }
3299
3300 time (&now);
3301
3302 if ((now - prev) == 0) continue;
3303
3304 float percent = (float) comp / (float) d.stat.st_size;
3305
3306 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3307
3308 time (&prev);
3309 }
3310
3311 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3312 if (data.quiet == 0) log_info ("");
3313
3314 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3315
3316 hc_signal (sigHandler_default);
3317
3318 return (cnt);
3319 }
3320
3321 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3322 {
3323 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3324 }
3325
3326 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const u8 *pw_buf, const uint pw_len)
3327 {
3328 if (data.devices_status == STATUS_BYPASS) return 0;
3329
3330 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3331
3332 uint cache_cnt = pw_cache->cnt;
3333
3334 u8 *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3335
3336 memcpy (pw_hc1, pw_buf, pw_len);
3337
3338 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3339
3340 uint pws_cnt = device_param->pws_cnt;
3341
3342 cache_cnt++;
3343
3344 pw_t *pw = device_param->pws_buf + pws_cnt;
3345
3346 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3347
3348 pw->pw_len = pw_len;
3349
3350 pws_cnt++;
3351
3352 device_param->pws_cnt = pws_cnt;
3353 device_param->pw_cnt = pws_cnt * 1;
3354
3355 cache_cnt = 0;
3356
3357 pw_cache->cnt = cache_cnt;
3358
3359 return pws_cnt;
3360 }
3361
3362 static void *thread_monitor (void *p)
3363 {
3364 uint runtime_check = 0;
3365 uint remove_check = 0;
3366 uint status_check = 0;
3367 uint hwmon_check = 0;
3368 uint restore_check = 0;
3369
3370 uint restore_left = data.restore_timer;
3371 uint remove_left = data.remove_timer;
3372 uint status_left = data.status_timer;
3373
3374 // these variables are mainly used for fan control (AMD only)
3375
3376 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3377
3378 // temperature controller "loopback" values
3379
3380 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3381 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3382
3383 int temp_threshold = 1; // degrees celcius
3384
3385 int fan_speed_min = 15; // in percentage
3386 int fan_speed_max = 100;
3387
3388 time_t last_temp_check_time;
3389
3390 uint sleep_time = 1;
3391
3392 if (data.runtime)
3393 {
3394 runtime_check = 1;
3395 }
3396
3397 if (data.restore_timer)
3398 {
3399 restore_check = 1;
3400 }
3401
3402 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3403 {
3404 remove_check = 1;
3405 }
3406
3407 if (data.status == 1)
3408 {
3409 status_check = 1;
3410 }
3411
3412 if (data.gpu_temp_disable == 0)
3413 {
3414 time (&last_temp_check_time);
3415
3416 hwmon_check = 1;
3417 }
3418
3419 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3420 {
3421 return (p);
3422 }
3423
3424 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3425 {
3426 hc_sleep (sleep_time);
3427
3428 if (data.devices_status != STATUS_RUNNING) continue;
3429
3430 if (hwmon_check == 1)
3431 {
3432 hc_thread_mutex_lock (mux_adl);
3433
3434 time_t temp_check_time;
3435
3436 time (&temp_check_time);
3437
3438 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3439
3440 if (Ta == 0) Ta = 1;
3441
3442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3443 {
3444 hc_device_param_t *device_param = &data.devices_param[device_id];
3445
3446 if (device_param->skipped) continue;
3447
3448 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3449
3450 const int temperature = hm_get_temperature_with_device_id (device_id);
3451
3452 if (temperature > (int) data.gpu_temp_abort)
3453 {
3454 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3455
3456 if (data.devices_status != STATUS_QUIT) myabort ();
3457
3458 break;
3459 }
3460
3461 const int gpu_temp_retain = data.gpu_temp_retain;
3462
3463 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3464 {
3465 if (data.hm_device[device_id].fan_supported == 1)
3466 {
3467 int temp_cur = temperature;
3468
3469 int temp_diff_new = gpu_temp_retain - temp_cur;
3470
3471 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3472
3473 // calculate Ta value (time difference in seconds between the last check and this check)
3474
3475 last_temp_check_time = temp_check_time;
3476
3477 float Kp = 1.8;
3478 float Ki = 0.005;
3479 float Kd = 6;
3480
3481 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3482
3483 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3484
3485 if (abs (fan_diff_required) >= temp_threshold)
3486 {
3487 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3488
3489 int fan_speed_level = fan_speed_cur;
3490
3491 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3492
3493 int fan_speed_new = fan_speed_level - fan_diff_required;
3494
3495 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3496 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3497
3498 if (fan_speed_new != fan_speed_cur)
3499 {
3500 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3501 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3502
3503 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3504 {
3505 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3506
3507 fan_speed_chgd[device_id] = 1;
3508 }
3509
3510 temp_diff_old[device_id] = temp_diff_new;
3511 }
3512 }
3513 }
3514 }
3515 }
3516
3517 hc_thread_mutex_unlock (mux_adl);
3518 }
3519
3520 if (restore_check == 1)
3521 {
3522 restore_left--;
3523
3524 if (restore_left == 0)
3525 {
3526 if (data.restore_disable == 0) cycle_restore ();
3527
3528 restore_left = data.restore_timer;
3529 }
3530 }
3531
3532 if ((runtime_check == 1) && (data.runtime_start > 0))
3533 {
3534 time_t runtime_cur;
3535
3536 time (&runtime_cur);
3537
3538 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3539
3540 if (runtime_left <= 0)
3541 {
3542 if (data.benchmark == 0)
3543 {
3544 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3545 }
3546
3547 if (data.devices_status != STATUS_QUIT) myabort ();
3548 }
3549 }
3550
3551 if (remove_check == 1)
3552 {
3553 remove_left--;
3554
3555 if (remove_left == 0)
3556 {
3557 if (data.digests_saved != data.digests_done)
3558 {
3559 data.digests_saved = data.digests_done;
3560
3561 save_hash ();
3562 }
3563
3564 remove_left = data.remove_timer;
3565 }
3566 }
3567
3568 if (status_check == 1)
3569 {
3570 status_left--;
3571
3572 if (status_left == 0)
3573 {
3574 hc_thread_mutex_lock (mux_display);
3575
3576 if (data.quiet == 0) clear_prompt ();
3577
3578 if (data.quiet == 0) log_info ("");
3579
3580 status_display ();
3581
3582 if (data.quiet == 0) log_info ("");
3583
3584 hc_thread_mutex_unlock (mux_display);
3585
3586 status_left = data.status_timer;
3587 }
3588 }
3589 }
3590
3591 myfree (fan_speed_chgd);
3592
3593 myfree (temp_diff_old);
3594 myfree (temp_diff_sum);
3595
3596 p = NULL;
3597
3598 return (p);
3599 }
3600
3601 static void *thread_outfile_remove (void *p)
3602 {
3603 // some hash-dependent constants
3604 char *outfile_dir = data.outfile_check_directory;
3605 uint dgst_size = data.dgst_size;
3606 uint isSalted = data.isSalted;
3607 uint esalt_size = data.esalt_size;
3608 uint hash_mode = data.hash_mode;
3609
3610 uint outfile_check_timer = data.outfile_check_timer;
3611
3612 char separator = data.separator;
3613
3614 // some hash-dependent functions
3615 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3616 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3617
3618 // buffers
3619 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3620
3621 hash_buf.digest = mymalloc (dgst_size);
3622
3623 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3624
3625 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3626
3627 uint digest_buf[64];
3628
3629 outfile_data_t *out_info = NULL;
3630
3631 char **out_files = NULL;
3632
3633 time_t folder_mtime = 0;
3634
3635 int out_cnt = 0;
3636
3637 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3638
3639 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3640 {
3641 hc_sleep (1);
3642
3643 if (data.devices_status != STATUS_RUNNING) continue;
3644
3645 check_left--;
3646
3647 if (check_left == 0)
3648 {
3649 struct stat outfile_check_stat;
3650
3651 if (stat (outfile_dir, &outfile_check_stat) == 0)
3652 {
3653 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3654
3655 if (is_dir == 1)
3656 {
3657 if (outfile_check_stat.st_mtime > folder_mtime)
3658 {
3659 char **out_files_new = scan_directory (outfile_dir);
3660
3661 int out_cnt_new = count_dictionaries (out_files_new);
3662
3663 outfile_data_t *out_info_new = NULL;
3664
3665 if (out_cnt_new > 0)
3666 {
3667 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3668
3669 for (int i = 0; i < out_cnt_new; i++)
3670 {
3671 out_info_new[i].file_name = out_files_new[i];
3672
3673 // check if there are files that we have seen/checked before (and not changed)
3674
3675 for (int j = 0; j < out_cnt; j++)
3676 {
3677 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3678 {
3679 struct stat outfile_stat;
3680
3681 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3682 {
3683 if (outfile_stat.st_ctime == out_info[j].ctime)
3684 {
3685 out_info_new[i].ctime = out_info[j].ctime;
3686 out_info_new[i].seek = out_info[j].seek;
3687 }
3688 }
3689 }
3690 }
3691 }
3692 }
3693
3694 local_free (out_info);
3695 local_free (out_files);
3696
3697 out_files = out_files_new;
3698 out_cnt = out_cnt_new;
3699 out_info = out_info_new;
3700
3701 folder_mtime = outfile_check_stat.st_mtime;
3702 }
3703
3704 for (int j = 0; j < out_cnt; j++)
3705 {
3706 FILE *fp = fopen (out_info[j].file_name, "rb");
3707
3708 if (fp != NULL)
3709 {
3710 //hc_thread_mutex_lock (mux_display);
3711
3712 #ifdef _POSIX
3713 struct stat outfile_stat;
3714
3715 fstat (fileno (fp), &outfile_stat);
3716 #endif
3717
3718 #ifdef _WIN
3719 struct stat64 outfile_stat;
3720
3721 _fstat64 (fileno (fp), &outfile_stat);
3722 #endif
3723
3724 if (outfile_stat.st_ctime > out_info[j].ctime)
3725 {
3726 out_info[j].ctime = outfile_stat.st_ctime;
3727 out_info[j].seek = 0;
3728 }
3729
3730 fseek (fp, out_info[j].seek, SEEK_SET);
3731
3732 while (!feof (fp))
3733 {
3734 char line_buf[BUFSIZ];
3735
3736 memset (line_buf, 0, BUFSIZ);
3737
3738 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3739
3740 if (ptr == NULL) break;
3741
3742 int line_len = strlen (line_buf);
3743
3744 if (line_len <= 0) continue;
3745
3746 int iter = MAX_CUT_TRIES;
3747
3748 for (uint i = line_len - 1; i && iter; i--, line_len--)
3749 {
3750 if (line_buf[i] != separator) continue;
3751
3752 int parser_status = PARSER_OK;
3753
3754 if ((hash_mode != 2500) && (hash_mode != 6800))
3755 {
3756 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3757 }
3758
3759 uint found = 0;
3760
3761 if (parser_status == PARSER_OK)
3762 {
3763 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3764 {
3765 if (data.salts_shown[salt_pos] == 1) continue;
3766
3767 salt_t *salt_buf = &data.salts_buf[salt_pos];
3768
3769 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3770 {
3771 uint idx = salt_buf->digests_offset + digest_pos;
3772
3773 if (data.digests_shown[idx] == 1) continue;
3774
3775 uint cracked = 0;
3776
3777 if (hash_mode == 6800)
3778 {
3779 if (i == salt_buf->salt_len)
3780 {
3781 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3782 }
3783 }
3784 else if (hash_mode == 2500)
3785 {
3786 // BSSID : MAC1 : MAC2 (:plain)
3787 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3788 {
3789 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3790
3791 if (!cracked) continue;
3792
3793 // now compare MAC1 and MAC2 too, since we have this additional info
3794 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3795 char *mac2_pos = mac1_pos + 12 + 1;
3796
3797 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3798 wpa_t *wpa = &wpas[salt_pos];
3799
3800 uint pke[25];
3801
3802 char *pke_ptr = (char *) pke;
3803
3804 for (uint i = 0; i < 25; i++)
3805 {
3806 pke[i] = byte_swap_32 (wpa->pke[i]);
3807 }
3808
3809 u8 mac1[6];
3810 u8 mac2[6];
3811
3812 memcpy (mac1, pke_ptr + 23, 6);
3813 memcpy (mac2, pke_ptr + 29, 6);
3814
3815 // compare hex string(s) vs binary MAC address(es)
3816
3817 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3818 {
3819 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
3820 {
3821 cracked = 0;
3822 break;
3823 }
3824 }
3825
3826 // early skip ;)
3827 if (!cracked) continue;
3828
3829 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3830 {
3831 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
3832 {
3833 cracked = 0;
3834 break;
3835 }
3836 }
3837 }
3838 }
3839 else
3840 {
3841 char *digests_buf_ptr = (char *) data.digests_buf;
3842
3843 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3844
3845 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3846 }
3847
3848 if (cracked == 1)
3849 {
3850 found = 1;
3851
3852 data.digests_shown[idx] = 1;
3853
3854 data.digests_done++;
3855
3856 salt_buf->digests_done++;
3857
3858 if (salt_buf->digests_done == salt_buf->digests_cnt)
3859 {
3860 data.salts_shown[salt_pos] = 1;
3861
3862 data.salts_done++;
3863
3864 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3865 }
3866 }
3867 }
3868
3869 if (data.devices_status == STATUS_CRACKED) break;
3870 }
3871 }
3872
3873 if (found) break;
3874
3875 if (data.devices_status == STATUS_CRACKED) break;
3876
3877 iter--;
3878 }
3879
3880 if (data.devices_status == STATUS_CRACKED) break;
3881 }
3882
3883 out_info[j].seek = ftell (fp);
3884
3885 //hc_thread_mutex_unlock (mux_display);
3886
3887 fclose (fp);
3888 }
3889 }
3890 }
3891 }
3892
3893 check_left = outfile_check_timer;
3894 }
3895 }
3896
3897 if (esalt_size) local_free (hash_buf.esalt);
3898
3899 if (isSalted) local_free (hash_buf.salt);
3900
3901 local_free (hash_buf.digest);
3902
3903 local_free (out_info);
3904
3905 local_free (out_files);
3906
3907 p = NULL;
3908
3909 return (p);
3910 }
3911
3912 static uint get_work (hc_device_param_t *device_param, const u64 max)
3913 {
3914 hc_thread_mutex_lock (mux_dispatcher);
3915
3916 const u64 words_cur = data.words_cur;
3917 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
3918
3919 device_param->words_off = words_cur;
3920
3921 const u64 words_left = words_base - words_cur;
3922
3923 if (data.kernel_blocks_all > words_left)
3924 {
3925 if (data.kernel_blocks_div == 0)
3926 {
3927 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3928 }
3929 }
3930
3931 if (data.kernel_blocks_div)
3932 {
3933 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3934 {
3935 const u32 kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3936 const u32 kernel_power_new = kernel_blocks_new;
3937
3938 if (kernel_blocks_new < device_param->kernel_blocks)
3939 {
3940 device_param->kernel_blocks = kernel_blocks_new;
3941 device_param->kernel_power = kernel_power_new;
3942 }
3943 }
3944 }
3945
3946 const uint kernel_blocks = device_param->kernel_blocks;
3947
3948 uint work = MIN (words_left, kernel_blocks);
3949
3950 work = MIN (work, max);
3951
3952 data.words_cur += work;
3953
3954 hc_thread_mutex_unlock (mux_dispatcher);
3955
3956 return work;
3957 }
3958
3959 static void *thread_calc_stdin (void *p)
3960 {
3961 hc_device_param_t *device_param = (hc_device_param_t *) p;
3962
3963 if (device_param->skipped) return NULL;
3964
3965 const uint attack_kern = data.attack_kern;
3966
3967 const uint kernel_blocks = device_param->kernel_blocks;
3968
3969 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3970 {
3971 hc_thread_mutex_lock (mux_dispatcher);
3972
3973 if (feof (stdin) != 0)
3974 {
3975 hc_thread_mutex_unlock (mux_dispatcher);
3976
3977 break;
3978 }
3979
3980 uint words_cur = 0;
3981
3982 while (words_cur < kernel_blocks)
3983 {
3984 char buf[BUFSIZ];
3985
3986 char *line_buf = fgets (buf, sizeof (buf), stdin);
3987
3988 if (line_buf == NULL) break;
3989
3990 uint line_len = in_superchop (line_buf);
3991
3992 line_len = convert_from_hex (line_buf, line_len);
3993
3994 // post-process rule engine
3995
3996 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3997 {
3998 char rule_buf_out[BLOCK_SIZE] = { 0 };
3999
4000 int rule_len_out = -1;
4001
4002 if (line_len < BLOCK_SIZE)
4003 {
4004 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4005 }
4006
4007 if (rule_len_out < 0) continue;
4008
4009 line_buf = rule_buf_out;
4010 line_len = rule_len_out;
4011 }
4012
4013 if (line_len > PW_MAX)
4014 {
4015 continue;
4016 }
4017
4018 if (attack_kern == ATTACK_KERN_STRAIGHT)
4019 {
4020 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4021 {
4022 hc_thread_mutex_lock (mux_counter);
4023
4024 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4025 {
4026 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4027 }
4028
4029 hc_thread_mutex_unlock (mux_counter);
4030
4031 continue;
4032 }
4033 }
4034 else if (attack_kern == ATTACK_KERN_COMBI)
4035 {
4036 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4037 // since we still need to combine the plains
4038
4039 if (line_len > data.pw_max)
4040 {
4041 hc_thread_mutex_lock (mux_counter);
4042
4043 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4044 {
4045 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4046 }
4047
4048 hc_thread_mutex_unlock (mux_counter);
4049
4050 continue;
4051 }
4052 }
4053
4054 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4055
4056 words_cur++;
4057
4058 if (data.devices_status == STATUS_CRACKED) break;
4059 if (data.devices_status == STATUS_ABORTED) break;
4060 if (data.devices_status == STATUS_QUIT) break;
4061 if (data.devices_status == STATUS_BYPASS) break;
4062 }
4063
4064 hc_thread_mutex_unlock (mux_dispatcher);
4065
4066 if (data.devices_status == STATUS_CRACKED) break;
4067 if (data.devices_status == STATUS_ABORTED) break;
4068 if (data.devices_status == STATUS_QUIT) break;
4069 if (data.devices_status == STATUS_BYPASS) break;
4070
4071 // we need 2 flushing because we have two independant caches and it can occur
4072 // that one buffer is already at threshold plus for that length also exists
4073 // more data in the 2nd buffer so it would overflow
4074
4075 // flush session 1
4076
4077 {
4078 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4079 {
4080 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4081
4082 const uint pw_cache_cnt = pw_cache->cnt;
4083
4084 if (pw_cache_cnt == 0) continue;
4085
4086 pw_cache->cnt = 0;
4087
4088 uint pws_cnt = device_param->pws_cnt;
4089
4090 pw_t *pw = device_param->pws_buf + pws_cnt;
4091
4092 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4093
4094 pw->pw_len = pw_len;
4095
4096 uint pw_cnt = device_param->pw_cnt;
4097
4098 pw_cnt += pw_cache_cnt;
4099
4100 device_param->pw_cnt = pw_cnt;
4101
4102 pws_cnt++;
4103
4104 device_param->pws_cnt = pws_cnt;
4105
4106 if (pws_cnt == device_param->kernel_power_user) break;
4107 }
4108
4109 const uint pw_cnt = device_param->pw_cnt;
4110 const uint pws_cnt = device_param->pws_cnt;
4111
4112 if (pws_cnt)
4113 {
4114 run_copy (device_param, pws_cnt);
4115
4116 run_cracker (device_param, pw_cnt, pws_cnt);
4117
4118 device_param->pw_cnt = 0;
4119 device_param->pws_cnt = 0;
4120 }
4121 }
4122
4123 // flush session 2
4124
4125 {
4126 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4127 {
4128 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4129
4130 const uint pw_cache_cnt = pw_cache->cnt;
4131
4132 if (pw_cache_cnt == 0) continue;
4133
4134 pw_cache->cnt = 0;
4135
4136 uint pws_cnt = device_param->pws_cnt;
4137
4138 pw_t *pw = device_param->pws_buf + pws_cnt;
4139
4140 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4141
4142 pw->pw_len = pw_len;
4143
4144 uint pw_cnt = device_param->pw_cnt;
4145
4146 pw_cnt += pw_cache_cnt;
4147
4148 device_param->pw_cnt = pw_cnt;
4149
4150 pws_cnt++;
4151
4152 device_param->pws_cnt = pws_cnt;
4153 }
4154
4155 const uint pw_cnt = device_param->pw_cnt;
4156 const uint pws_cnt = device_param->pws_cnt;
4157
4158 if (pws_cnt)
4159 {
4160 run_copy (device_param, pws_cnt);
4161
4162 run_cracker (device_param, pw_cnt, pws_cnt);
4163
4164 device_param->pw_cnt = 0;
4165 device_param->pws_cnt = 0;
4166 }
4167 }
4168 }
4169
4170 return NULL;
4171 }
4172
4173 static void *thread_calc (void *p)
4174 {
4175 hc_device_param_t *device_param = (hc_device_param_t *) p;
4176
4177 if (device_param->skipped) return NULL;
4178
4179 const uint attack_mode = data.attack_mode;
4180 const uint attack_kern = data.attack_kern;
4181
4182 if (attack_mode == ATTACK_MODE_BF)
4183 {
4184 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4185 {
4186 const uint work = get_work (device_param, -1);
4187
4188 if (work == 0) break;
4189
4190 const u64 words_off = device_param->words_off;
4191 const u64 words_fin = words_off + work;
4192
4193 const uint pw_cnt = work;
4194 const uint pws_cnt = work;
4195
4196 device_param->pw_cnt = pw_cnt;
4197 device_param->pws_cnt = pws_cnt;
4198
4199 if (pws_cnt)
4200 {
4201 run_copy (device_param, pws_cnt);
4202
4203 run_cracker (device_param, pw_cnt, pws_cnt);
4204
4205 device_param->pw_cnt = 0;
4206 device_param->pws_cnt = 0;
4207 }
4208
4209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4210
4211 if (data.devices_status == STATUS_CRACKED) break;
4212 if (data.devices_status == STATUS_ABORTED) break;
4213 if (data.devices_status == STATUS_QUIT) break;
4214 if (data.devices_status == STATUS_BYPASS) break;
4215
4216 device_param->words_done = words_fin;
4217 }
4218 }
4219 else
4220 {
4221 const uint segment_size = data.segment_size;
4222
4223 char *dictfile = data.dictfile;
4224
4225 if (attack_mode == ATTACK_MODE_COMBI)
4226 {
4227 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4228 {
4229 dictfile = data.dictfile2;
4230 }
4231 }
4232
4233 FILE *fd = fopen (dictfile, "rb");
4234
4235 if (fd == NULL)
4236 {
4237 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4238
4239 return NULL;
4240 }
4241
4242 if (attack_mode == ATTACK_MODE_COMBI)
4243 {
4244 const uint combs_mode = data.combs_mode;
4245
4246 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4247 {
4248 const char *dictfilec = data.dictfile2;
4249
4250 FILE *combs_fp = fopen (dictfilec, "rb");
4251
4252 if (combs_fp == NULL)
4253 {
4254 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4255
4256 fclose (fd);
4257
4258 return NULL;
4259 }
4260
4261 device_param->combs_fp = combs_fp;
4262 }
4263 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4264 {
4265 const char *dictfilec = data.dictfile;
4266
4267 FILE *combs_fp = fopen (dictfilec, "rb");
4268
4269 if (combs_fp == NULL)
4270 {
4271 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4272
4273 fclose (fd);
4274
4275 return NULL;
4276 }
4277
4278 device_param->combs_fp = combs_fp;
4279 }
4280 }
4281
4282 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4283
4284 wl_data->buf = (char *) mymalloc (segment_size);
4285 wl_data->avail = segment_size;
4286 wl_data->incr = segment_size;
4287 wl_data->cnt = 0;
4288 wl_data->pos = 0;
4289
4290 u64 words_cur = 0;
4291
4292 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4293 {
4294 u64 words_off = 0;
4295 u64 words_fin = 0;
4296
4297 u64 max = -1;
4298
4299 while (max)
4300 {
4301 const uint work = get_work (device_param, max);
4302
4303 if (work == 0) break;
4304
4305 words_off = device_param->words_off;
4306 words_fin = words_off + work;
4307
4308 char *line_buf;
4309 uint line_len;
4310
4311 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4312
4313 max = 0;
4314
4315 for ( ; words_cur < words_fin; words_cur++)
4316 {
4317 get_next_word (wl_data, fd, &line_buf, &line_len);
4318
4319 line_len = convert_from_hex (line_buf, line_len);
4320
4321 // post-process rule engine
4322
4323 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4324 {
4325 char rule_buf_out[BLOCK_SIZE] = { 0 };
4326
4327 int rule_len_out = -1;
4328
4329 if (line_len < BLOCK_SIZE)
4330 {
4331 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4332 }
4333
4334 if (rule_len_out < 0) continue;
4335
4336 line_buf = rule_buf_out;
4337 line_len = rule_len_out;
4338 }
4339
4340 if (attack_kern == ATTACK_KERN_STRAIGHT)
4341 {
4342 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4343 {
4344 max++;
4345
4346 hc_thread_mutex_lock (mux_counter);
4347
4348 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4349 {
4350 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4351 }
4352
4353 hc_thread_mutex_unlock (mux_counter);
4354
4355 continue;
4356 }
4357 }
4358 else if (attack_kern == ATTACK_KERN_COMBI)
4359 {
4360 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4361 // since we still need to combine the plains
4362
4363 if (line_len > data.pw_max)
4364 {
4365 max++;
4366
4367 hc_thread_mutex_lock (mux_counter);
4368
4369 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4370 {
4371 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4372 }
4373
4374 hc_thread_mutex_unlock (mux_counter);
4375
4376 continue;
4377 }
4378 }
4379
4380 device_param->pw_add (device_param, (u8 *) line_buf, line_len);
4381
4382 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4383
4384 if (data.devices_status == STATUS_CRACKED) break;
4385 if (data.devices_status == STATUS_ABORTED) break;
4386 if (data.devices_status == STATUS_QUIT) break;
4387 if (data.devices_status == STATUS_BYPASS) break;
4388 }
4389
4390 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396 }
4397
4398 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4399
4400 if (data.devices_status == STATUS_CRACKED) break;
4401 if (data.devices_status == STATUS_ABORTED) break;
4402 if (data.devices_status == STATUS_QUIT) break;
4403 if (data.devices_status == STATUS_BYPASS) break;
4404
4405 // we need 2 flushing because we have two independant caches and it can occur
4406 // that one buffer is already at threshold plus for that length also exists
4407 // more data in the 2nd buffer so it would overflow
4408
4409 //
4410 // flush session 1
4411 //
4412
4413 {
4414 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4415 {
4416 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4417
4418 const uint pw_cache_cnt = pw_cache->cnt;
4419
4420 if (pw_cache_cnt == 0) continue;
4421
4422 pw_cache->cnt = 0;
4423
4424 uint pws_cnt = device_param->pws_cnt;
4425
4426 pw_t *pw = device_param->pws_buf + pws_cnt;
4427
4428 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4429
4430 pw->pw_len = pw_len;
4431
4432 uint pw_cnt = device_param->pw_cnt;
4433
4434 pw_cnt += pw_cache_cnt;
4435
4436 device_param->pw_cnt = pw_cnt;
4437
4438 pws_cnt++;
4439
4440 device_param->pws_cnt = pws_cnt;
4441
4442 if (pws_cnt == device_param->kernel_power_user) break;
4443 }
4444
4445 const uint pw_cnt = device_param->pw_cnt;
4446 const uint pws_cnt = device_param->pws_cnt;
4447
4448 if (pws_cnt)
4449 {
4450 run_copy (device_param, pws_cnt);
4451
4452 run_cracker (device_param, pw_cnt, pws_cnt);
4453
4454 device_param->pw_cnt = 0;
4455 device_param->pws_cnt = 0;
4456 }
4457
4458 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4459
4460 if (data.devices_status == STATUS_CRACKED) break;
4461 if (data.devices_status == STATUS_ABORTED) break;
4462 if (data.devices_status == STATUS_QUIT) break;
4463 if (data.devices_status == STATUS_BYPASS) break;
4464 }
4465
4466 //
4467 // flush session 2
4468 //
4469
4470 {
4471 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4472 {
4473 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4474
4475 const uint pw_cache_cnt = pw_cache->cnt;
4476
4477 if (pw_cache_cnt == 0) continue;
4478
4479 pw_cache->cnt = 0;
4480
4481 uint pws_cnt = device_param->pws_cnt;
4482
4483 pw_t *pw = device_param->pws_buf + pws_cnt;
4484
4485 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4486
4487 pw->pw_len = pw_len;
4488
4489 uint pw_cnt = device_param->pw_cnt;
4490
4491 pw_cnt += pw_cache_cnt;
4492
4493 device_param->pw_cnt = pw_cnt;
4494
4495 pws_cnt++;
4496
4497 device_param->pws_cnt = pws_cnt;
4498 }
4499
4500 const uint pw_cnt = device_param->pw_cnt;
4501 const uint pws_cnt = device_param->pws_cnt;
4502
4503 if (pws_cnt)
4504 {
4505 run_copy (device_param, pws_cnt);
4506
4507 run_cracker (device_param, pw_cnt, pws_cnt);
4508
4509 device_param->pw_cnt = 0;
4510 device_param->pws_cnt = 0;
4511 }
4512
4513 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4514
4515 if (data.devices_status == STATUS_CRACKED) break;
4516 if (data.devices_status == STATUS_ABORTED) break;
4517 if (data.devices_status == STATUS_QUIT) break;
4518 if (data.devices_status == STATUS_BYPASS) break;
4519 }
4520
4521 if (words_fin == 0) break;
4522
4523 device_param->words_done = words_fin;
4524 }
4525
4526 if (attack_mode == ATTACK_MODE_COMBI)
4527 {
4528 fclose (device_param->combs_fp);
4529 }
4530
4531 free (wl_data->buf);
4532 free (wl_data);
4533
4534 fclose (fd);
4535 }
4536
4537 return NULL;
4538 }
4539
4540 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4541 {
4542 salt_t *salt_buf = &data.salts_buf[salt_pos];
4543
4544 device_param->kernel_params_buf32[24] = salt_pos;
4545 device_param->kernel_params_buf32[27] = 1;
4546 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4547 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4548 device_param->kernel_params_buf32[30] = 0;
4549 device_param->kernel_params_buf32[31] = 1;
4550
4551 char *dictfile_old = data.dictfile;
4552
4553 const char *weak_hash_check = "weak-hash-check";
4554
4555 data.dictfile = (char *) weak_hash_check;
4556
4557 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4558
4559 data.kernel_rules_buf[0].cmds[0] = 0;
4560
4561 /**
4562 * run the kernel
4563 */
4564
4565 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4566 {
4567 run_kernel (KERN_RUN_1, device_param, 1);
4568 }
4569 else
4570 {
4571 run_kernel (KERN_RUN_1, device_param, 1);
4572
4573 const uint iter = salt_buf->salt_iter;
4574
4575 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4576 {
4577 uint loop_left = iter - loop_pos;
4578
4579 loop_left = MIN (loop_left, kernel_loops);
4580
4581 device_param->kernel_params_buf32[25] = loop_pos;
4582 device_param->kernel_params_buf32[26] = loop_left;
4583
4584 run_kernel (KERN_RUN_2, device_param, 1);
4585 }
4586
4587 run_kernel (KERN_RUN_3, device_param, 1);
4588 }
4589
4590 /**
4591 * result
4592 */
4593
4594 check_cracked (device_param, salt_pos);
4595
4596 /**
4597 * cleanup
4598 */
4599
4600 device_param->kernel_params_buf32[24] = 0;
4601 device_param->kernel_params_buf32[25] = 0;
4602 device_param->kernel_params_buf32[26] = 0;
4603 device_param->kernel_params_buf32[27] = 0;
4604 device_param->kernel_params_buf32[28] = 0;
4605 device_param->kernel_params_buf32[29] = 0;
4606 device_param->kernel_params_buf32[30] = 0;
4607 device_param->kernel_params_buf32[31] = 0;
4608
4609 data.dictfile = dictfile_old;
4610
4611 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4612 }
4613
4614 // hlfmt hashcat
4615
4616 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4617 {
4618 if (data.username == 0)
4619 {
4620 *hashbuf_pos = line_buf;
4621 *hashbuf_len = line_len;
4622 }
4623 else
4624 {
4625 char *pos = line_buf;
4626 int len = line_len;
4627
4628 for (int i = 0; i < line_len; i++, pos++, len--)
4629 {
4630 if (line_buf[i] == data.separator)
4631 {
4632 pos++;
4633
4634 len--;
4635
4636 break;
4637 }
4638 }
4639
4640 *hashbuf_pos = pos;
4641 *hashbuf_len = len;
4642 }
4643 }
4644
4645 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4646 {
4647 char *pos = NULL;
4648 int len = 0;
4649
4650 int sep_cnt = 0;
4651
4652 for (int i = 0; i < line_len; i++)
4653 {
4654 if (line_buf[i] == data.separator)
4655 {
4656 sep_cnt++;
4657
4658 continue;
4659 }
4660
4661 if (sep_cnt == 0)
4662 {
4663 if (pos == NULL) pos = line_buf + i;
4664
4665 len++;
4666 }
4667 }
4668
4669 *userbuf_pos = pos;
4670 *userbuf_len = len;
4671 }
4672
4673 // hlfmt pwdump
4674
4675 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4676 {
4677 int sep_cnt = 0;
4678
4679 int sep2_len = 0;
4680 int sep3_len = 0;
4681
4682 for (int i = 0; i < line_len; i++)
4683 {
4684 if (line_buf[i] == ':')
4685 {
4686 sep_cnt++;
4687
4688 continue;
4689 }
4690
4691 if (sep_cnt == 2) sep2_len++;
4692 if (sep_cnt == 3) sep3_len++;
4693 }
4694
4695 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4696
4697 return 0;
4698 }
4699
4700 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4701 {
4702 char *pos = NULL;
4703 int len = 0;
4704
4705 int sep_cnt = 0;
4706
4707 for (int i = 0; i < line_len; i++)
4708 {
4709 if (line_buf[i] == ':')
4710 {
4711 sep_cnt++;
4712
4713 continue;
4714 }
4715
4716 if (data.hash_mode == 1000)
4717 {
4718 if (sep_cnt == 3)
4719 {
4720 if (pos == NULL) pos = line_buf + i;
4721
4722 len++;
4723 }
4724 }
4725 else if (data.hash_mode == 3000)
4726 {
4727 if (sep_cnt == 2)
4728 {
4729 if (pos == NULL) pos = line_buf + i;
4730
4731 len++;
4732 }
4733 }
4734 }
4735
4736 *hashbuf_pos = pos;
4737 *hashbuf_len = len;
4738 }
4739
4740 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4741 {
4742 char *pos = NULL;
4743 int len = 0;
4744
4745 int sep_cnt = 0;
4746
4747 for (int i = 0; i < line_len; i++)
4748 {
4749 if (line_buf[i] == ':')
4750 {
4751 sep_cnt++;
4752
4753 continue;
4754 }
4755
4756 if (sep_cnt == 0)
4757 {
4758 if (pos == NULL) pos = line_buf + i;
4759
4760 len++;
4761 }
4762 }
4763
4764 *userbuf_pos = pos;
4765 *userbuf_len = len;
4766 }
4767
4768 // hlfmt passwd
4769
4770 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4771 {
4772 int sep_cnt = 0;
4773
4774 char sep5_first = 0;
4775 char sep6_first = 0;
4776
4777 for (int i = 0; i < line_len; i++)
4778 {
4779 if (line_buf[i] == ':')
4780 {
4781 sep_cnt++;
4782
4783 continue;
4784 }
4785
4786 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4787 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4788 }
4789
4790 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4791
4792 return 0;
4793 }
4794
4795 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4796 {
4797 char *pos = NULL;
4798 int len = 0;
4799
4800 int sep_cnt = 0;
4801
4802 for (int i = 0; i < line_len; i++)
4803 {
4804 if (line_buf[i] == ':')
4805 {
4806 sep_cnt++;
4807
4808 continue;
4809 }
4810
4811 if (sep_cnt == 1)
4812 {
4813 if (pos == NULL) pos = line_buf + i;
4814
4815 len++;
4816 }
4817 }
4818
4819 *hashbuf_pos = pos;
4820 *hashbuf_len = len;
4821 }
4822
4823 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4824 {
4825 char *pos = NULL;
4826 int len = 0;
4827
4828 int sep_cnt = 0;
4829
4830 for (int i = 0; i < line_len; i++)
4831 {
4832 if (line_buf[i] == ':')
4833 {
4834 sep_cnt++;
4835
4836 continue;
4837 }
4838
4839 if (sep_cnt == 0)
4840 {
4841 if (pos == NULL) pos = line_buf + i;
4842
4843 len++;
4844 }
4845 }
4846
4847 *userbuf_pos = pos;
4848 *userbuf_len = len;
4849 }
4850
4851 // hlfmt shadow
4852
4853 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4854 {
4855 int sep_cnt = 0;
4856
4857 for (int i = 0; i < line_len; i++)
4858 {
4859 if (line_buf[i] == ':') sep_cnt++;
4860 }
4861
4862 if (sep_cnt == 8) return 1;
4863
4864 return 0;
4865 }
4866
4867 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4868 {
4869 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4870 }
4871
4872 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4873 {
4874 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4875 }
4876
4877 // hlfmt main
4878
4879 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4880 {
4881 switch (hashfile_format)
4882 {
4883 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4884 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4885 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4886 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4887 }
4888 }
4889
4890 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4891 {
4892 switch (hashfile_format)
4893 {
4894 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4895 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4896 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4897 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4898 }
4899 }
4900
4901 static uint hlfmt_detect (FILE *fp, uint max_check)
4902 {
4903 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4904
4905 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4906 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4907
4908 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4909
4910 uint num_check = 0;
4911
4912 while (!feof (fp))
4913 {
4914 char line_buf[BUFSIZ];
4915
4916 int line_len = fgetl (fp, line_buf);
4917
4918 if (line_len == 0) continue;
4919
4920 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4921 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4922 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4923
4924 if (num_check == max_check) break;
4925
4926 num_check++;
4927 }
4928
4929 uint hashlist_format = HLFMT_HASHCAT;
4930
4931 for (int i = 1; i < HLFMTS_CNT; i++)
4932 {
4933 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4934
4935 hashlist_format = i;
4936 }
4937
4938 free (formats_cnt);
4939
4940 return hashlist_format;
4941 }
4942
4943 /**
4944 * some further helper function
4945 */
4946
4947 // wrapper around mymalloc for ADL
4948
4949 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4950 {
4951 return mymalloc (iSize);
4952 }
4953
4954 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
4955 {
4956 u64 collisions = 0;
4957
4958 const uint dgst_pos0 = data.dgst_pos0;
4959 const uint dgst_pos1 = data.dgst_pos1;
4960 const uint dgst_pos2 = data.dgst_pos2;
4961 const uint dgst_pos3 = data.dgst_pos3;
4962
4963 memset (bitmap_a, 0, bitmap_size);
4964 memset (bitmap_b, 0, bitmap_size);
4965 memset (bitmap_c, 0, bitmap_size);
4966 memset (bitmap_d, 0, bitmap_size);
4967
4968 for (uint i = 0; i < digests_cnt; i++)
4969 {
4970 uint *digest_ptr = (uint *) digests_buf_ptr;
4971
4972 digests_buf_ptr += dgst_size;
4973
4974 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
4975 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
4976 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
4977 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
4978
4979 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4980 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4981 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4982 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4983
4984 if (bitmap_a[idx0] & val0) collisions++;
4985 if (bitmap_b[idx1] & val1) collisions++;
4986 if (bitmap_c[idx2] & val2) collisions++;
4987 if (bitmap_d[idx3] & val3) collisions++;
4988
4989 bitmap_a[idx0] |= val0;
4990 bitmap_b[idx1] |= val1;
4991 bitmap_c[idx2] |= val2;
4992 bitmap_d[idx3] |= val3;
4993
4994 if (collisions >= collisions_max) return 0x7fffffff;
4995 }
4996
4997 return collisions;
4998 }
4999
5000 /**
5001 * main
5002 */
5003
5004 int main (int argc, char **argv)
5005 {
5006 /**
5007 * To help users a bit
5008 */
5009
5010 char *compute = getenv ("COMPUTE");
5011
5012 if (compute)
5013 {
5014 char display[100];
5015
5016 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5017
5018 putenv (display);
5019 }
5020 else
5021 {
5022 if (getenv ("DISPLAY") == NULL)
5023 putenv ((char *) "DISPLAY=:0");
5024 }
5025
5026 /*
5027 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5028 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5029
5030 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5031 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5032 */
5033
5034 /**
5035 * Real init
5036 */
5037
5038 memset (&data, 0, sizeof (hc_global_data_t));
5039
5040 time_t proc_start;
5041
5042 time (&proc_start);
5043
5044 data.proc_start = proc_start;
5045
5046 int myargc = argc;
5047 char **myargv = argv;
5048
5049 hc_thread_mutex_init (mux_dispatcher);
5050 hc_thread_mutex_init (mux_counter);
5051 hc_thread_mutex_init (mux_display);
5052 hc_thread_mutex_init (mux_adl);
5053
5054 /**
5055 * commandline parameters
5056 */
5057
5058 uint usage = USAGE;
5059 uint version = VERSION;
5060 uint quiet = QUIET;
5061 uint benchmark = BENCHMARK;
5062 uint benchmark_mode = BENCHMARK_MODE;
5063 uint show = SHOW;
5064 uint left = LEFT;
5065 uint username = USERNAME;
5066 uint remove = REMOVE;
5067 uint remove_timer = REMOVE_TIMER;
5068 u64 skip = SKIP;
5069 u64 limit = LIMIT;
5070 uint keyspace = KEYSPACE;
5071 uint potfile_disable = POTFILE_DISABLE;
5072 uint debug_mode = DEBUG_MODE;
5073 char *debug_file = NULL;
5074 char *induction_dir = NULL;
5075 char *outfile_check_dir = NULL;
5076 uint force = FORCE;
5077 uint runtime = RUNTIME;
5078 uint hash_mode = HASH_MODE;
5079 uint attack_mode = ATTACK_MODE;
5080 uint markov_disable = MARKOV_DISABLE;
5081 uint markov_classic = MARKOV_CLASSIC;
5082 uint markov_threshold = MARKOV_THRESHOLD;
5083 char *markov_hcstat = NULL;
5084 char *outfile = NULL;
5085 uint outfile_format = OUTFILE_FORMAT;
5086 uint outfile_autohex = OUTFILE_AUTOHEX;
5087 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5088 uint restore = RESTORE;
5089 uint restore_timer = RESTORE_TIMER;
5090 uint restore_disable = RESTORE_DISABLE;
5091 uint status = STATUS;
5092 uint status_timer = STATUS_TIMER;
5093 uint status_automat = STATUS_AUTOMAT;
5094 uint loopback = LOOPBACK;
5095 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5096 char *session = NULL;
5097 uint hex_charset = HEX_CHARSET;
5098 uint hex_salt = HEX_SALT;
5099 uint hex_wordlist = HEX_WORDLIST;
5100 uint rp_gen = RP_GEN;
5101 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5102 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5103 uint rp_gen_seed = RP_GEN_SEED;
5104 char *rule_buf_l = (char *) RULE_BUF_L;
5105 char *rule_buf_r = (char *) RULE_BUF_R;
5106 uint increment = INCREMENT;
5107 uint increment_min = INCREMENT_MIN;
5108 uint increment_max = INCREMENT_MAX;
5109 char *cpu_affinity = NULL;
5110 char *opencl_devices = NULL;
5111 char *opencl_platforms = NULL;
5112 char *opencl_device_types = NULL;
5113 char *truecrypt_keyfiles = NULL;
5114 uint workload_profile = WORKLOAD_PROFILE;
5115 uint kernel_accel = KERNEL_ACCEL;
5116 uint kernel_loops = KERNEL_LOOPS;
5117 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5118 uint gpu_temp_abort = GPU_TEMP_ABORT;
5119 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5120 uint powertune_enable = POWERTUNE_ENABLE;
5121 uint logfile_disable = LOGFILE_DISABLE;
5122 uint segment_size = SEGMENT_SIZE;
5123 uint scrypt_tmto = SCRYPT_TMTO;
5124 char separator = SEPARATOR;
5125 uint bitmap_min = BITMAP_MIN;
5126 uint bitmap_max = BITMAP_MAX;
5127 char *custom_charset_1 = NULL;
5128 char *custom_charset_2 = NULL;
5129 char *custom_charset_3 = NULL;
5130 char *custom_charset_4 = NULL;
5131
5132 #define IDX_HELP 'h'
5133 #define IDX_VERSION 'V'
5134 #define IDX_VERSION_LOWER 'v'
5135 #define IDX_QUIET 0xff02
5136 #define IDX_SHOW 0xff03
5137 #define IDX_LEFT 0xff04
5138 #define IDX_REMOVE 0xff05
5139 #define IDX_REMOVE_TIMER 0xff37
5140 #define IDX_SKIP 's'
5141 #define IDX_LIMIT 'l'
5142 #define IDX_KEYSPACE 0xff35
5143 #define IDX_POTFILE_DISABLE 0xff06
5144 #define IDX_DEBUG_MODE 0xff43
5145 #define IDX_DEBUG_FILE 0xff44
5146 #define IDX_INDUCTION_DIR 0xff46
5147 #define IDX_OUTFILE_CHECK_DIR 0xff47
5148 #define IDX_USERNAME 0xff07
5149 #define IDX_FORCE 0xff08
5150 #define IDX_RUNTIME 0xff09
5151 #define IDX_BENCHMARK 'b'
5152 #define IDX_BENCHMARK_MODE 0xff32
5153 #define IDX_HASH_MODE 'm'
5154 #define IDX_ATTACK_MODE 'a'
5155 #define IDX_RP_FILE 'r'
5156 #define IDX_RP_GEN 'g'
5157 #define IDX_RP_GEN_FUNC_MIN 0xff10
5158 #define IDX_RP_GEN_FUNC_MAX 0xff11
5159 #define IDX_RP_GEN_SEED 0xff34
5160 #define IDX_RULE_BUF_L 'j'
5161 #define IDX_RULE_BUF_R 'k'
5162 #define IDX_INCREMENT 'i'
5163 #define IDX_INCREMENT_MIN 0xff12
5164 #define IDX_INCREMENT_MAX 0xff13
5165 #define IDX_OUTFILE 'o'
5166 #define IDX_OUTFILE_FORMAT 0xff14
5167 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5168 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5169 #define IDX_RESTORE 0xff15
5170 #define IDX_RESTORE_DISABLE 0xff27
5171 #define IDX_STATUS 0xff17
5172 #define IDX_STATUS_TIMER 0xff18
5173 #define IDX_STATUS_AUTOMAT 0xff50
5174 #define IDX_LOOPBACK 0xff38
5175 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5176 #define IDX_SESSION 0xff19
5177 #define IDX_HEX_CHARSET 0xff20
5178 #define IDX_HEX_SALT 0xff21
5179 #define IDX_HEX_WORDLIST 0xff40
5180 #define IDX_MARKOV_DISABLE 0xff22
5181 #define IDX_MARKOV_CLASSIC 0xff23
5182 #define IDX_MARKOV_THRESHOLD 't'
5183 #define IDX_MARKOV_HCSTAT 0xff24
5184 #define IDX_CPU_AFFINITY 0xff25
5185 #define IDX_OPENCL_DEVICES 'd'
5186 #define IDX_OPENCL_PLATFORMS 0xff72
5187 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5188 #define IDX_WORKLOAD_PROFILE 'w'
5189 #define IDX_KERNEL_ACCEL 'n'
5190 #define IDX_KERNEL_LOOPS 'u'
5191 #define IDX_GPU_TEMP_DISABLE 0xff29
5192 #define IDX_GPU_TEMP_ABORT 0xff30
5193 #define IDX_GPU_TEMP_RETAIN 0xff31
5194 #define IDX_POWERTUNE_ENABLE 0xff41
5195 #define IDX_LOGFILE_DISABLE 0xff51
5196 #define IDX_TRUECRYPT_KEYFILES 0xff52
5197 #define IDX_SCRYPT_TMTO 0xff61
5198 #define IDX_SEGMENT_SIZE 'c'
5199 #define IDX_SEPARATOR 'p'
5200 #define IDX_BITMAP_MIN 0xff70
5201 #define IDX_BITMAP_MAX 0xff71
5202 #define IDX_CUSTOM_CHARSET_1 '1'
5203 #define IDX_CUSTOM_CHARSET_2 '2'
5204 #define IDX_CUSTOM_CHARSET_3 '3'
5205 #define IDX_CUSTOM_CHARSET_4 '4'
5206
5207 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5208
5209 struct option long_options[] =
5210 {
5211 {"help", no_argument, 0, IDX_HELP},
5212 {"version", no_argument, 0, IDX_VERSION},
5213 {"quiet", no_argument, 0, IDX_QUIET},
5214 {"show", no_argument, 0, IDX_SHOW},
5215 {"left", no_argument, 0, IDX_LEFT},
5216 {"username", no_argument, 0, IDX_USERNAME},
5217 {"remove", no_argument, 0, IDX_REMOVE},
5218 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5219 {"skip", required_argument, 0, IDX_SKIP},
5220 {"limit", required_argument, 0, IDX_LIMIT},
5221 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5222 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5223 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5224 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5225 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5226 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5227 {"force", no_argument, 0, IDX_FORCE},
5228 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5229 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5230 {"restore", no_argument, 0, IDX_RESTORE},
5231 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5232 {"status", no_argument, 0, IDX_STATUS},
5233 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5234 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5235 {"loopback", no_argument, 0, IDX_LOOPBACK},
5236 {"weak-hash-threshold",
5237 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5238 {"session", required_argument, 0, IDX_SESSION},
5239 {"runtime", required_argument, 0, IDX_RUNTIME},
5240 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5241 {"generate-rules-func-min",
5242 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5243 {"generate-rules-func-max",
5244 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5245 {"generate-rules-seed",
5246 required_argument, 0, IDX_RP_GEN_SEED},
5247 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5248 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5249 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5250 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5251 {"rules-file", required_argument, 0, IDX_RP_FILE},
5252 {"outfile", required_argument, 0, IDX_OUTFILE},
5253 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5254 {"outfile-autohex-disable",
5255 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5256 {"outfile-check-timer",
5257 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5258 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5259 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5260 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5261 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5262 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5263 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5264 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5265 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5266 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5267 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5268 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5269 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5270 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5271 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5272 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5273 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5274 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5275 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5276 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5277 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5278 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5279 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5280 // deprecated
5281 {"seperator", required_argument, 0, IDX_SEPARATOR},
5282 {"separator", required_argument, 0, IDX_SEPARATOR},
5283 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5284 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5285 {"increment", no_argument, 0, IDX_INCREMENT},
5286 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5287 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5288 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5289 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5290 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5291 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5292
5293 {0, 0, 0, 0}
5294 };
5295
5296 uint rp_files_cnt = 0;
5297
5298 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5299
5300 int option_index;
5301 int c;
5302
5303 optind = 1;
5304 optopt = 0;
5305 option_index = 0;
5306
5307 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5308 {
5309 switch (c)
5310 {
5311 case IDX_HELP: usage = 1; break;
5312 case IDX_VERSION:
5313 case IDX_VERSION_LOWER: version = 1; break;
5314 case IDX_RESTORE: restore = 1; break;
5315 case IDX_SESSION: session = optarg; break;
5316 case IDX_SHOW: show = 1; break;
5317 case IDX_LEFT: left = 1; break;
5318 case '?': return (-1);
5319 }
5320 }
5321
5322 if (optopt != 0)
5323 {
5324 log_error ("ERROR: Invalid argument specified");
5325
5326 return (-1);
5327 }
5328
5329 /**
5330 * exit functions
5331 */
5332
5333 if (version)
5334 {
5335 log_info (VERSION_TXT);
5336
5337 return (0);
5338 }
5339
5340 if (usage)
5341 {
5342 usage_big_print (PROGNAME);
5343
5344 return (0);
5345 }
5346
5347 /**
5348 * session needs to be set, always!
5349 */
5350
5351 if (session == NULL) session = (char *) PROGNAME;
5352
5353 /**
5354 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5355 */
5356
5357 char *exec_path = get_exec_path ();
5358
5359 #ifdef LINUX
5360
5361 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5362 char *resolved_exec_path = realpath (exec_path, NULL);
5363
5364 char *install_dir = get_install_dir (resolved_exec_path);
5365 char *profile_dir = NULL;
5366 char *session_dir = NULL;
5367 char *shared_dir = NULL;
5368
5369 if (strcmp (install_dir, resolved_install_folder) == 0)
5370 {
5371 struct passwd *pw = getpwuid (getuid ());
5372
5373 const char *homedir = pw->pw_dir;
5374
5375 profile_dir = get_profile_dir (homedir);
5376 session_dir = get_session_dir (profile_dir);
5377 shared_dir = strdup (SHARED_FOLDER);
5378
5379 mkdir (profile_dir, 0700);
5380 mkdir (session_dir, 0700);
5381 }
5382 else
5383 {
5384 profile_dir = install_dir;
5385 session_dir = install_dir;
5386 shared_dir = install_dir;
5387 }
5388
5389 myfree (resolved_install_folder);
5390 myfree (resolved_exec_path);
5391
5392 #else
5393
5394 char *install_dir = get_install_dir (exec_path);
5395 char *profile_dir = install_dir;
5396 char *session_dir = install_dir;
5397 char *shared_dir = install_dir;
5398
5399 #endif
5400
5401 data.install_dir = install_dir;
5402 data.profile_dir = profile_dir;
5403 data.session_dir = session_dir;
5404 data.shared_dir = shared_dir;
5405
5406 myfree (exec_path);
5407
5408 /**
5409 * kernel cache, we need to make sure folder exist
5410 */
5411
5412 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5413
5414 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5415
5416 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5417
5418 mkdir (kernels_folder, 0700);
5419
5420 myfree (kernels_folder);
5421
5422 /**
5423 * session
5424 */
5425
5426 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5427
5428 data.session = session;
5429
5430 char *eff_restore_file = (char *) mymalloc (session_size);
5431 char *new_restore_file = (char *) mymalloc (session_size);
5432
5433 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5434 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5435
5436 data.eff_restore_file = eff_restore_file;
5437 data.new_restore_file = new_restore_file;
5438
5439 if (((show == 1) || (left == 1)) && (restore == 1))
5440 {
5441 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5442 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5443
5444 return (-1);
5445 }
5446
5447 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5448 if ((show == 1) || (left == 1))
5449 {
5450 restore_disable = 1;
5451
5452 restore = 0;
5453 }
5454
5455 data.restore_disable = restore_disable;
5456
5457 restore_data_t *rd = init_restore (argc, argv);
5458
5459 data.rd = rd;
5460
5461 /**
5462 * restore file
5463 */
5464
5465 if (restore == 1)
5466 {
5467 read_restore (eff_restore_file, rd);
5468
5469 if (rd->version_bin < RESTORE_MIN)
5470 {
5471 log_error ("ERROR: Incompatible restore-file version");
5472
5473 return (-1);
5474 }
5475
5476 myargc = rd->argc;
5477 myargv = rd->argv;
5478
5479 #ifdef _POSIX
5480 rd->pid = getpid ();
5481 #elif _WIN
5482 rd->pid = GetCurrentProcessId ();
5483 #endif
5484 }
5485
5486 uint hash_mode_chgd = 0;
5487 uint runtime_chgd = 0;
5488 uint kernel_loops_chgd = 0;
5489 uint kernel_accel_chgd = 0;
5490 uint attack_mode_chgd = 0;
5491 uint outfile_format_chgd = 0;
5492 uint rp_gen_seed_chgd = 0;
5493 uint remove_timer_chgd = 0;
5494 uint increment_min_chgd = 0;
5495 uint increment_max_chgd = 0;
5496 uint gpu_temp_abort_chgd = 0;
5497 uint gpu_temp_retain_chgd = 0;
5498
5499 optind = 1;
5500 optopt = 0;
5501 option_index = 0;
5502
5503 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5504 {
5505 switch (c)
5506 {
5507 //case IDX_HELP: usage = 1; break;
5508 //case IDX_VERSION: version = 1; break;
5509 //case IDX_RESTORE: restore = 1; break;
5510 case IDX_QUIET: quiet = 1; break;
5511 //case IDX_SHOW: show = 1; break;
5512 case IDX_SHOW: break;
5513 //case IDX_LEFT: left = 1; break;
5514 case IDX_LEFT: break;
5515 case IDX_USERNAME: username = 1; break;
5516 case IDX_REMOVE: remove = 1; break;
5517 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5518 remove_timer_chgd = 1; break;
5519 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5520 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5521 case IDX_DEBUG_FILE: debug_file = optarg; break;
5522 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5523 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5524 case IDX_FORCE: force = 1; break;
5525 case IDX_SKIP: skip = atoll (optarg); break;
5526 case IDX_LIMIT: limit = atoll (optarg); break;
5527 case IDX_KEYSPACE: keyspace = 1; break;
5528 case IDX_BENCHMARK: benchmark = 1; break;
5529 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5530 case IDX_RESTORE: break;
5531 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5532 case IDX_STATUS: status = 1; break;
5533 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5534 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5535 case IDX_LOOPBACK: loopback = 1; break;
5536 case IDX_WEAK_HASH_THRESHOLD:
5537 weak_hash_threshold = atoi (optarg); break;
5538 //case IDX_SESSION: session = optarg; break;
5539 case IDX_SESSION: break;
5540 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5541 hash_mode_chgd = 1; break;
5542 case IDX_RUNTIME: runtime = atoi (optarg);
5543 runtime_chgd = 1; break;
5544 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5545 attack_mode_chgd = 1; break;
5546 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5547 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5548 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5549 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5550 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5551 rp_gen_seed_chgd = 1; break;
5552 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5553 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5554 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5555 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5556 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5557 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5558 case IDX_OUTFILE: outfile = optarg; break;
5559 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5560 outfile_format_chgd = 1; break;
5561 case IDX_OUTFILE_AUTOHEX_DISABLE:
5562 outfile_autohex = 0; break;
5563 case IDX_OUTFILE_CHECK_TIMER:
5564 outfile_check_timer = atoi (optarg); break;
5565 case IDX_HEX_CHARSET: hex_charset = 1; break;
5566 case IDX_HEX_SALT: hex_salt = 1; break;
5567 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5568 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5569 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5570 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5571 case IDX_OPENCL_DEVICE_TYPES:
5572 opencl_device_types = optarg; break;
5573 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5574 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5575 kernel_accel_chgd = 1; break;
5576 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5577 kernel_loops_chgd = 1; break;
5578 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5579 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5580 gpu_temp_abort = atoi (optarg); break;
5581 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5582 gpu_temp_retain = atoi (optarg); break;
5583 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5584 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5585 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5586 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5587 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5588 case IDX_SEPARATOR: separator = optarg[0]; break;
5589 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5590 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5591 case IDX_INCREMENT: increment = 1; break;
5592 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5593 increment_min_chgd = 1; break;
5594 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5595 increment_max_chgd = 1; break;
5596 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5597 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5598 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5599 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5600
5601 default:
5602 log_error ("ERROR: Invalid argument specified");
5603 return (-1);
5604 }
5605 }
5606
5607 if (optopt != 0)
5608 {
5609 log_error ("ERROR: Invalid argument specified");
5610
5611 return (-1);
5612 }
5613
5614 /**
5615 * Inform user things getting started,
5616 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5617 * - we do not need to check algorithm_pos
5618 */
5619
5620 if (quiet == 0)
5621 {
5622 if (benchmark == 1)
5623 {
5624 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5625
5626 log_info ("");
5627 }
5628 else if (restore == 1)
5629 {
5630 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5631
5632 log_info ("");
5633 }
5634 else
5635 {
5636 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5637
5638 log_info ("");
5639 }
5640 }
5641
5642 /**
5643 * sanity check
5644 */
5645
5646 if (attack_mode > 7)
5647 {
5648 log_error ("ERROR: Invalid attack-mode specified");
5649
5650 return (-1);
5651 }
5652
5653 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5654 {
5655 log_error ("ERROR: Invalid runtime specified");
5656
5657 return (-1);
5658 }
5659
5660 if (hash_mode_chgd && hash_mode > 13000) // just added to remove compiler warnings for hash_mode_chgd
5661 {
5662 log_error ("ERROR: Invalid hash-type specified");
5663
5664 return (-1);
5665 }
5666
5667 // renamed hash modes
5668
5669 if (hash_mode_chgd)
5670 {
5671 int n = -1;
5672
5673 switch (hash_mode)
5674 {
5675 case 123: n = 124;
5676 break;
5677 }
5678
5679 if (n >= 0)
5680 {
5681 log_error ("Old -m specified, use -m %d instead", n);
5682
5683 return (-1);
5684 }
5685 }
5686
5687 if (username == 1)
5688 {
5689 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5690 {
5691 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5692
5693 return (-1);
5694 }
5695 }
5696
5697 if (outfile_format > 16)
5698 {
5699 log_error ("ERROR: Invalid outfile-format specified");
5700
5701 return (-1);
5702 }
5703
5704 if (left == 1)
5705 {
5706 if (outfile_format_chgd == 1)
5707 {
5708 if (outfile_format > 1)
5709 {
5710 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5711
5712 return (-1);
5713 }
5714 }
5715 else
5716 {
5717 outfile_format = OUTFILE_FMT_HASH;
5718 }
5719 }
5720
5721 if (show == 1)
5722 {
5723 if (outfile_format_chgd == 1)
5724 {
5725 if ((outfile_format > 7) && (outfile_format < 16))
5726 {
5727 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5728
5729 return (-1);
5730 }
5731 }
5732 }
5733
5734 if (increment_min < INCREMENT_MIN)
5735 {
5736 log_error ("ERROR: Invalid increment-min specified");
5737
5738 return (-1);
5739 }
5740
5741 if (increment_max > INCREMENT_MAX)
5742 {
5743 log_error ("ERROR: Invalid increment-max specified");
5744
5745 return (-1);
5746 }
5747
5748 if (increment_min > increment_max)
5749 {
5750 log_error ("ERROR: Invalid increment-min specified");
5751
5752 return (-1);
5753 }
5754
5755 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5756 {
5757 log_error ("ERROR: increment is not allowed in attack-mode 0");
5758
5759 return (-1);
5760 }
5761
5762 if ((increment == 0) && (increment_min_chgd == 1))
5763 {
5764 log_error ("ERROR: increment-min is only supported together with increment switch");
5765
5766 return (-1);
5767 }
5768
5769 if ((increment == 0) && (increment_max_chgd == 1))
5770 {
5771 log_error ("ERROR: increment-max is only supported together with increment switch");
5772
5773 return (-1);
5774 }
5775
5776 if (rp_files_cnt && rp_gen)
5777 {
5778 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5779
5780 return (-1);
5781 }
5782
5783 if (rp_files_cnt || rp_gen)
5784 {
5785 if (attack_mode != ATTACK_MODE_STRAIGHT)
5786 {
5787 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5788
5789 return (-1);
5790 }
5791 }
5792
5793 if (rp_gen_func_min > rp_gen_func_max)
5794 {
5795 log_error ("ERROR: Invalid rp-gen-func-min specified");
5796
5797 return (-1);
5798 }
5799
5800 if (kernel_accel_chgd == 1)
5801 {
5802 if (workload_profile != WORKLOAD_PROFILE)
5803 {
5804 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5805
5806 return (-1);
5807 }
5808
5809 if (kernel_accel < 1)
5810 {
5811 log_error ("ERROR: Invalid kernel-accel specified");
5812
5813 return (-1);
5814 }
5815
5816 if (kernel_accel > 800)
5817 {
5818 log_error ("ERROR: Invalid kernel-accel specified");
5819
5820 return (-1);
5821 }
5822 }
5823
5824 if (kernel_loops_chgd == 1)
5825 {
5826 if (workload_profile != WORKLOAD_PROFILE)
5827 {
5828 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5829
5830 return (-1);
5831 }
5832
5833 if (kernel_loops < 1)
5834 {
5835 log_error ("ERROR: Invalid kernel-loops specified");
5836
5837 return (-1);
5838 }
5839
5840 if (kernel_loops > 1024)
5841 {
5842 log_error ("ERROR: Invalid kernel-loops specified");
5843
5844 return (-1);
5845 }
5846 }
5847
5848 if (benchmark == 1)
5849 {
5850 if (workload_profile != WORKLOAD_PROFILE)
5851 {
5852 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 if ((workload_profile < 1) || (workload_profile > 3))
5859 {
5860 log_error ("ERROR: workload-profile %i not available", workload_profile);
5861
5862 return (-1);
5863 }
5864
5865 if (show == 1 || left == 1)
5866 {
5867 attack_mode = ATTACK_MODE_NONE;
5868
5869 if (remove == 1)
5870 {
5871 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5872
5873 return (-1);
5874 }
5875
5876 if (potfile_disable == 1)
5877 {
5878 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5879
5880 return (-1);
5881 }
5882 }
5883
5884 uint attack_kern = ATTACK_KERN_NONE;
5885
5886 switch (attack_mode)
5887 {
5888 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5889 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5890 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5891 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5892 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5893 }
5894
5895 if (benchmark == 0)
5896 {
5897 if (keyspace == 1)
5898 {
5899 int num_additional_params = 1;
5900
5901 if (attack_kern == ATTACK_KERN_COMBI)
5902 {
5903 num_additional_params = 2;
5904 }
5905
5906 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5907
5908 if (keyspace_wordlist_specified == 0) optind--;
5909 }
5910
5911 if (attack_kern == ATTACK_KERN_NONE)
5912 {
5913 if ((optind + 1) != myargc)
5914 {
5915 usage_mini_print (myargv[0]);
5916
5917 return (-1);
5918 }
5919 }
5920 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5921 {
5922 if ((optind + 1) > myargc)
5923 {
5924 usage_mini_print (myargv[0]);
5925
5926 return (-1);
5927 }
5928 }
5929 else if (attack_kern == ATTACK_KERN_COMBI)
5930 {
5931 if ((optind + 3) != myargc)
5932 {
5933 usage_mini_print (myargv[0]);
5934
5935 return (-1);
5936 }
5937 }
5938 else if (attack_kern == ATTACK_KERN_BF)
5939 {
5940 if ((optind + 1) > myargc)
5941 {
5942 usage_mini_print (myargv[0]);
5943
5944 return (-1);
5945 }
5946 }
5947 else
5948 {
5949 usage_mini_print (myargv[0]);
5950
5951 return (-1);
5952 }
5953 }
5954 else
5955 {
5956 if (myargv[optind] != 0)
5957 {
5958 log_error ("ERROR: Invalid argument for benchmark mode specified");
5959
5960 return (-1);
5961 }
5962
5963 if (attack_mode_chgd == 1)
5964 {
5965 if (attack_mode != ATTACK_MODE_BF)
5966 {
5967 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5968
5969 return (-1);
5970 }
5971 }
5972
5973 if (benchmark_mode == 0)
5974 {
5975 // nothing to do
5976 }
5977 else if (benchmark_mode == 1)
5978 {
5979 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5980 {
5981 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5982
5983 return (-1);
5984 }
5985 }
5986 else
5987 {
5988 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (skip != 0 && limit != 0)
5995 {
5996 limit += skip;
5997 }
5998
5999 if (keyspace == 1)
6000 {
6001 if (show == 1)
6002 {
6003 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6004
6005 return (-1);
6006 }
6007 else if (left == 1)
6008 {
6009 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6010
6011 return (-1);
6012 }
6013
6014 potfile_disable = 1;
6015
6016 restore_disable = 1;
6017
6018 restore = 0;
6019
6020 weak_hash_threshold = 0;
6021
6022 quiet = 1;
6023 }
6024
6025 if (remove_timer_chgd == 1)
6026 {
6027 if (remove == 0)
6028 {
6029 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6030
6031 return (-1);
6032 }
6033
6034 if (remove_timer < 1)
6035 {
6036 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6037
6038 return (-1);
6039 }
6040 }
6041
6042 if (loopback == 1)
6043 {
6044 if (attack_mode == ATTACK_MODE_BF)
6045 {
6046 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6047
6048 return (-1);
6049 }
6050 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6051 {
6052 if ((rp_files_cnt == 0) && (rp_gen == 0))
6053 {
6054 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6055
6056 return (-1);
6057 }
6058 }
6059 }
6060
6061 if (debug_mode > 0)
6062 {
6063 if (attack_mode != ATTACK_MODE_STRAIGHT)
6064 {
6065 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6066
6067 return (-1);
6068 }
6069
6070 if ((rp_files_cnt == 0) && (rp_gen == 0))
6071 {
6072 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6073
6074 return (-1);
6075 }
6076 }
6077
6078 if (debug_mode > 4)
6079 {
6080 log_error ("ERROR: Invalid debug-mode specified");
6081
6082 return (-1);
6083 }
6084
6085 if (debug_file != NULL)
6086 {
6087 if (debug_mode < 1)
6088 {
6089 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6090
6091 return (-1);
6092 }
6093 }
6094
6095 if (induction_dir != NULL)
6096 {
6097 if (attack_mode == ATTACK_MODE_BF)
6098 {
6099 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6100
6101 return (-1);
6102 }
6103 }
6104
6105 if (attack_mode != ATTACK_MODE_STRAIGHT)
6106 {
6107 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6108 {
6109 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6110
6111 return (-1);
6112 }
6113
6114 weak_hash_threshold = 0;
6115 }
6116
6117 /**
6118 * induction directory
6119 */
6120
6121 char *induction_directory = NULL;
6122
6123 if (attack_mode != ATTACK_MODE_BF)
6124 {
6125 if (induction_dir == NULL)
6126 {
6127 induction_directory = (char *) mymalloc (session_size);
6128
6129 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6130
6131 // create induction folder if it does not already exist
6132
6133 if (keyspace == 0)
6134 {
6135 if (rmdir (induction_directory) == -1)
6136 {
6137 if (errno == ENOENT)
6138 {
6139 // good, we can ignore
6140 }
6141 else if (errno == ENOTEMPTY)
6142 {
6143 char *induction_directory_mv = (char *) mymalloc (session_size);
6144
6145 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6146
6147 if (rename (induction_directory, induction_directory_mv) != 0)
6148 {
6149 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6150
6151 return (-1);
6152 }
6153 }
6154 else
6155 {
6156 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6157
6158 return (-1);
6159 }
6160 }
6161
6162 if (mkdir (induction_directory, 0700) == -1)
6163 {
6164 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6165
6166 return (-1);
6167 }
6168 }
6169 }
6170 else
6171 {
6172 induction_directory = induction_dir;
6173 }
6174 }
6175
6176 data.induction_directory = induction_directory;
6177
6178 /**
6179 * loopback
6180 */
6181
6182 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6183
6184 char *loopback_file = (char *) mymalloc (loopback_size);
6185
6186 /**
6187 * outfile-check directory
6188 */
6189
6190 char *outfile_check_directory = NULL;
6191
6192 if (outfile_check_dir == NULL)
6193 {
6194 outfile_check_directory = (char *) mymalloc (session_size);
6195
6196 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6197 }
6198 else
6199 {
6200 outfile_check_directory = outfile_check_dir;
6201 }
6202
6203 data.outfile_check_directory = outfile_check_directory;
6204
6205 if (keyspace == 0)
6206 {
6207 struct stat outfile_check_stat;
6208
6209 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6210 {
6211 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6212
6213 if (is_dir == 0)
6214 {
6215 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6216
6217 return (-1);
6218 }
6219 }
6220 else if (outfile_check_dir == NULL)
6221 {
6222 if (mkdir (outfile_check_directory, 0700) == -1)
6223 {
6224 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6225
6226 return (-1);
6227 }
6228 }
6229 }
6230
6231 /**
6232 * special other stuff
6233 */
6234
6235 if (hash_mode == 9710)
6236 {
6237 outfile_format = 5;
6238 outfile_format_chgd = 1;
6239 }
6240
6241 if (hash_mode == 9810)
6242 {
6243 outfile_format = 5;
6244 outfile_format_chgd = 1;
6245 }
6246
6247 if (hash_mode == 10410)
6248 {
6249 outfile_format = 5;
6250 outfile_format_chgd = 1;
6251 }
6252
6253 /**
6254 * store stuff
6255 */
6256
6257 data.hash_mode = hash_mode;
6258 data.restore = restore;
6259 data.restore_timer = restore_timer;
6260 data.restore_disable = restore_disable;
6261 data.status = status;
6262 data.status_timer = status_timer;
6263 data.status_automat = status_automat;
6264 data.loopback = loopback;
6265 data.runtime = runtime;
6266 data.remove = remove;
6267 data.remove_timer = remove_timer;
6268 data.debug_mode = debug_mode;
6269 data.debug_file = debug_file;
6270 data.username = username;
6271 data.quiet = quiet;
6272 data.outfile = outfile;
6273 data.outfile_format = outfile_format;
6274 data.outfile_autohex = outfile_autohex;
6275 data.hex_charset = hex_charset;
6276 data.hex_salt = hex_salt;
6277 data.hex_wordlist = hex_wordlist;
6278 data.separator = separator;
6279 data.rp_files = rp_files;
6280 data.rp_files_cnt = rp_files_cnt;
6281 data.rp_gen = rp_gen;
6282 data.rp_gen_seed = rp_gen_seed;
6283 data.force = force;
6284 data.benchmark = benchmark;
6285 data.skip = skip;
6286 data.limit = limit;
6287 data.powertune_enable = powertune_enable;
6288 data.logfile_disable = logfile_disable;
6289 data.truecrypt_keyfiles = truecrypt_keyfiles;
6290 data.scrypt_tmto = scrypt_tmto;
6291
6292 /**
6293 * cpu affinity
6294 */
6295
6296 if (cpu_affinity)
6297 {
6298 set_cpu_affinity (cpu_affinity);
6299 }
6300
6301 if (rp_gen_seed_chgd == 0)
6302 {
6303 srand (proc_start);
6304 }
6305 else
6306 {
6307 srand (rp_gen_seed);
6308 }
6309
6310 /**
6311 * logfile init
6312 */
6313
6314 if (logfile_disable == 0)
6315 {
6316 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6317
6318 char *logfile = (char *) mymalloc (logfile_size);
6319
6320 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6321
6322 data.logfile = logfile;
6323
6324 char *topid = logfile_generate_topid ();
6325
6326 data.topid = topid;
6327 }
6328
6329 // logfile_append() checks for logfile_disable internally to make it easier from here
6330
6331 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6332 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6333 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6334 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6335 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6336 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6337 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6338 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6339 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6340 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6341
6342 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6343 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6344 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6345 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6346 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6347 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6348 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6349 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6350
6351 logfile_top_msg ("START");
6352
6353 logfile_top_uint (attack_mode);
6354 logfile_top_uint (attack_kern);
6355 logfile_top_uint (benchmark);
6356 logfile_top_uint (benchmark_mode);
6357 logfile_top_uint (bitmap_min);
6358 logfile_top_uint (bitmap_max);
6359 logfile_top_uint (debug_mode);
6360 logfile_top_uint (force);
6361 logfile_top_uint (kernel_accel);
6362 logfile_top_uint (kernel_loops);
6363 logfile_top_uint (gpu_temp_abort);
6364 logfile_top_uint (gpu_temp_disable);
6365 logfile_top_uint (gpu_temp_retain);
6366 logfile_top_uint (hash_mode);
6367 logfile_top_uint (hex_charset);
6368 logfile_top_uint (hex_salt);
6369 logfile_top_uint (hex_wordlist);
6370 logfile_top_uint (increment);
6371 logfile_top_uint (increment_max);
6372 logfile_top_uint (increment_min);
6373 logfile_top_uint (keyspace);
6374 logfile_top_uint (left);
6375 logfile_top_uint (logfile_disable);
6376 logfile_top_uint (loopback);
6377 logfile_top_uint (markov_classic);
6378 logfile_top_uint (markov_disable);
6379 logfile_top_uint (markov_threshold);
6380 logfile_top_uint (outfile_autohex);
6381 logfile_top_uint (outfile_check_timer);
6382 logfile_top_uint (outfile_format);
6383 logfile_top_uint (potfile_disable);
6384 logfile_top_uint (powertune_enable);
6385 logfile_top_uint (scrypt_tmto);
6386 logfile_top_uint (quiet);
6387 logfile_top_uint (remove);
6388 logfile_top_uint (remove_timer);
6389 logfile_top_uint (restore);
6390 logfile_top_uint (restore_disable);
6391 logfile_top_uint (restore_timer);
6392 logfile_top_uint (rp_gen);
6393 logfile_top_uint (rp_gen_func_max);
6394 logfile_top_uint (rp_gen_func_min);
6395 logfile_top_uint (rp_gen_seed);
6396 logfile_top_uint (runtime);
6397 logfile_top_uint (segment_size);
6398 logfile_top_uint (show);
6399 logfile_top_uint (status);
6400 logfile_top_uint (status_automat);
6401 logfile_top_uint (status_timer);
6402 logfile_top_uint (usage);
6403 logfile_top_uint (username);
6404 logfile_top_uint (version);
6405 logfile_top_uint (weak_hash_threshold);
6406 logfile_top_uint (workload_profile);
6407 logfile_top_uint64 (limit);
6408 logfile_top_uint64 (skip);
6409 logfile_top_char (separator);
6410 logfile_top_string (cpu_affinity);
6411 logfile_top_string (custom_charset_1);
6412 logfile_top_string (custom_charset_2);
6413 logfile_top_string (custom_charset_3);
6414 logfile_top_string (custom_charset_4);
6415 logfile_top_string (debug_file);
6416 logfile_top_string (opencl_devices);
6417 logfile_top_string (opencl_platforms);
6418 logfile_top_string (opencl_device_types);
6419 logfile_top_string (induction_dir);
6420 logfile_top_string (markov_hcstat);
6421 logfile_top_string (outfile);
6422 logfile_top_string (outfile_check_dir);
6423 logfile_top_string (rule_buf_l);
6424 logfile_top_string (rule_buf_r);
6425 logfile_top_string (session);
6426 logfile_top_string (truecrypt_keyfiles);
6427
6428 /**
6429 * OpenCL platform selection
6430 */
6431
6432 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6433
6434 /**
6435 * OpenCL device selection
6436 */
6437
6438 u32 devices_filter = setup_devices_filter (opencl_devices);
6439
6440 /**
6441 * OpenCL device type selection
6442 */
6443
6444 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6445
6446 /**
6447 * benchmark
6448 */
6449
6450 if (benchmark == 1)
6451 {
6452 /**
6453 * disable useless stuff for benchmark
6454 */
6455
6456 restore_timer = 0;
6457 status_timer = 0;
6458 restore_disable = 1;
6459 potfile_disable = 1;
6460 weak_hash_threshold = 0;
6461
6462 data.restore_timer = restore_timer;
6463 data.status_timer = status_timer;
6464 data.restore_disable = restore_disable;
6465
6466 if (benchmark_mode == 1)
6467 {
6468 markov_disable = 1;
6469 }
6470
6471 /**
6472 * force attack mode to be bruteforce
6473 */
6474
6475 attack_mode = ATTACK_MODE_BF;
6476 attack_kern = ATTACK_KERN_BF;
6477
6478 if (runtime_chgd == 0)
6479 {
6480 runtime = 4;
6481
6482 if (benchmark_mode == 1) runtime = 17;
6483
6484 data.runtime = runtime;
6485 }
6486 }
6487
6488 /**
6489 * config
6490 */
6491
6492 uint hash_type = 0;
6493 uint salt_type = 0;
6494 uint attack_exec = 0;
6495 uint opts_type = 0;
6496 uint kern_type = 0;
6497 uint dgst_size = 0;
6498 uint esalt_size = 0;
6499 uint opti_type = 0;
6500 uint dgst_pos0 = -1;
6501 uint dgst_pos1 = -1;
6502 uint dgst_pos2 = -1;
6503 uint dgst_pos3 = -1;
6504
6505 int (*parse_func) (char *, uint, hash_t *);
6506 int (*sort_by_digest) (const void *, const void *);
6507
6508 uint algorithm_pos = 0;
6509 uint algorithm_max = 1;
6510
6511 uint *algorithms = default_benchmark_algorithms;
6512
6513 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6514
6515 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6516 {
6517 /*
6518 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6519 * the following algos are skipped entirely
6520 */
6521
6522 if (algorithm_pos > 0)
6523 {
6524 local_free (rd);
6525
6526 rd = init_restore (argc, argv);
6527
6528 data.rd = rd;
6529 }
6530
6531 /**
6532 * update hash_mode in case of multihash benchmark
6533 */
6534
6535 if (benchmark == 1)
6536 {
6537 if (hash_mode_chgd == 0)
6538 {
6539 hash_mode = algorithms[algorithm_pos];
6540
6541 data.hash_mode = hash_mode;
6542 }
6543
6544 quiet = 1;
6545
6546 data.quiet = quiet;
6547 }
6548
6549 switch (hash_mode)
6550 {
6551 case 0: hash_type = HASH_TYPE_MD5;
6552 salt_type = SALT_TYPE_NONE;
6553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6554 opts_type = OPTS_TYPE_PT_GENERATE_LE
6555 | OPTS_TYPE_PT_ADD80
6556 | OPTS_TYPE_PT_ADDBITS14;
6557 kern_type = KERN_TYPE_MD5;
6558 dgst_size = DGST_SIZE_4_4;
6559 parse_func = md5_parse_hash;
6560 sort_by_digest = sort_by_digest_4_4;
6561 opti_type = OPTI_TYPE_ZERO_BYTE
6562 | OPTI_TYPE_PRECOMPUTE_INIT
6563 | OPTI_TYPE_PRECOMPUTE_MERKLE
6564 | OPTI_TYPE_MEET_IN_MIDDLE
6565 | OPTI_TYPE_EARLY_SKIP
6566 | OPTI_TYPE_NOT_ITERATED
6567 | OPTI_TYPE_NOT_SALTED
6568 | OPTI_TYPE_RAW_HASH;
6569 dgst_pos0 = 0;
6570 dgst_pos1 = 3;
6571 dgst_pos2 = 2;
6572 dgst_pos3 = 1;
6573 break;
6574
6575 case 10: hash_type = HASH_TYPE_MD5;
6576 salt_type = SALT_TYPE_INTERN;
6577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6578 opts_type = OPTS_TYPE_PT_GENERATE_LE
6579 | OPTS_TYPE_ST_ADD80
6580 | OPTS_TYPE_ST_ADDBITS14;
6581 kern_type = KERN_TYPE_MD5_PWSLT;
6582 dgst_size = DGST_SIZE_4_4;
6583 parse_func = md5s_parse_hash;
6584 sort_by_digest = sort_by_digest_4_4;
6585 opti_type = OPTI_TYPE_ZERO_BYTE
6586 | OPTI_TYPE_PRECOMPUTE_INIT
6587 | OPTI_TYPE_PRECOMPUTE_MERKLE
6588 | OPTI_TYPE_MEET_IN_MIDDLE
6589 | OPTI_TYPE_EARLY_SKIP
6590 | OPTI_TYPE_NOT_ITERATED
6591 | OPTI_TYPE_APPENDED_SALT
6592 | OPTI_TYPE_RAW_HASH;
6593 dgst_pos0 = 0;
6594 dgst_pos1 = 3;
6595 dgst_pos2 = 2;
6596 dgst_pos3 = 1;
6597 break;
6598
6599 case 11: hash_type = HASH_TYPE_MD5;
6600 salt_type = SALT_TYPE_INTERN;
6601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6602 opts_type = OPTS_TYPE_PT_GENERATE_LE
6603 | OPTS_TYPE_ST_ADD80
6604 | OPTS_TYPE_ST_ADDBITS14;
6605 kern_type = KERN_TYPE_MD5_PWSLT;
6606 dgst_size = DGST_SIZE_4_4;
6607 parse_func = joomla_parse_hash;
6608 sort_by_digest = sort_by_digest_4_4;
6609 opti_type = OPTI_TYPE_ZERO_BYTE
6610 | OPTI_TYPE_PRECOMPUTE_INIT
6611 | OPTI_TYPE_PRECOMPUTE_MERKLE
6612 | OPTI_TYPE_MEET_IN_MIDDLE
6613 | OPTI_TYPE_EARLY_SKIP
6614 | OPTI_TYPE_NOT_ITERATED
6615 | OPTI_TYPE_APPENDED_SALT
6616 | OPTI_TYPE_RAW_HASH;
6617 dgst_pos0 = 0;
6618 dgst_pos1 = 3;
6619 dgst_pos2 = 2;
6620 dgst_pos3 = 1;
6621 break;
6622
6623 case 12: hash_type = HASH_TYPE_MD5;
6624 salt_type = SALT_TYPE_INTERN;
6625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6626 opts_type = OPTS_TYPE_PT_GENERATE_LE
6627 | OPTS_TYPE_ST_ADD80
6628 | OPTS_TYPE_ST_ADDBITS14;
6629 kern_type = KERN_TYPE_MD5_PWSLT;
6630 dgst_size = DGST_SIZE_4_4;
6631 parse_func = postgresql_parse_hash;
6632 sort_by_digest = sort_by_digest_4_4;
6633 opti_type = OPTI_TYPE_ZERO_BYTE
6634 | OPTI_TYPE_PRECOMPUTE_INIT
6635 | OPTI_TYPE_PRECOMPUTE_MERKLE
6636 | OPTI_TYPE_MEET_IN_MIDDLE
6637 | OPTI_TYPE_EARLY_SKIP
6638 | OPTI_TYPE_NOT_ITERATED
6639 | OPTI_TYPE_APPENDED_SALT
6640 | OPTI_TYPE_RAW_HASH;
6641 dgst_pos0 = 0;
6642 dgst_pos1 = 3;
6643 dgst_pos2 = 2;
6644 dgst_pos3 = 1;
6645 break;
6646
6647 case 20: hash_type = HASH_TYPE_MD5;
6648 salt_type = SALT_TYPE_INTERN;
6649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6650 opts_type = OPTS_TYPE_PT_GENERATE_LE
6651 | OPTS_TYPE_PT_ADD80
6652 | OPTS_TYPE_PT_ADDBITS14;
6653 kern_type = KERN_TYPE_MD5_SLTPW;
6654 dgst_size = DGST_SIZE_4_4;
6655 parse_func = md5s_parse_hash;
6656 sort_by_digest = sort_by_digest_4_4;
6657 opti_type = OPTI_TYPE_ZERO_BYTE
6658 | OPTI_TYPE_PRECOMPUTE_INIT
6659 | OPTI_TYPE_PRECOMPUTE_MERKLE
6660 | OPTI_TYPE_EARLY_SKIP
6661 | OPTI_TYPE_NOT_ITERATED
6662 | OPTI_TYPE_PREPENDED_SALT
6663 | OPTI_TYPE_RAW_HASH;
6664 dgst_pos0 = 0;
6665 dgst_pos1 = 3;
6666 dgst_pos2 = 2;
6667 dgst_pos3 = 1;
6668 break;
6669
6670 case 21: hash_type = HASH_TYPE_MD5;
6671 salt_type = SALT_TYPE_INTERN;
6672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6673 opts_type = OPTS_TYPE_PT_GENERATE_LE
6674 | OPTS_TYPE_PT_ADD80
6675 | OPTS_TYPE_PT_ADDBITS14;
6676 kern_type = KERN_TYPE_MD5_SLTPW;
6677 dgst_size = DGST_SIZE_4_4;
6678 parse_func = osc_parse_hash;
6679 sort_by_digest = sort_by_digest_4_4;
6680 opti_type = OPTI_TYPE_ZERO_BYTE
6681 | OPTI_TYPE_PRECOMPUTE_INIT
6682 | OPTI_TYPE_PRECOMPUTE_MERKLE
6683 | OPTI_TYPE_EARLY_SKIP
6684 | OPTI_TYPE_NOT_ITERATED
6685 | OPTI_TYPE_PREPENDED_SALT
6686 | OPTI_TYPE_RAW_HASH;
6687 dgst_pos0 = 0;
6688 dgst_pos1 = 3;
6689 dgst_pos2 = 2;
6690 dgst_pos3 = 1;
6691 break;
6692
6693 case 22: hash_type = HASH_TYPE_MD5;
6694 salt_type = SALT_TYPE_EMBEDDED;
6695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6696 opts_type = OPTS_TYPE_PT_GENERATE_LE
6697 | OPTS_TYPE_PT_ADD80
6698 | OPTS_TYPE_PT_ADDBITS14;
6699 kern_type = KERN_TYPE_MD5_SLTPW;
6700 dgst_size = DGST_SIZE_4_4;
6701 parse_func = netscreen_parse_hash;
6702 sort_by_digest = sort_by_digest_4_4;
6703 opti_type = OPTI_TYPE_ZERO_BYTE
6704 | OPTI_TYPE_PRECOMPUTE_INIT
6705 | OPTI_TYPE_PRECOMPUTE_MERKLE
6706 | OPTI_TYPE_EARLY_SKIP
6707 | OPTI_TYPE_NOT_ITERATED
6708 | OPTI_TYPE_PREPENDED_SALT
6709 | OPTI_TYPE_RAW_HASH;
6710 dgst_pos0 = 0;
6711 dgst_pos1 = 3;
6712 dgst_pos2 = 2;
6713 dgst_pos3 = 1;
6714 break;
6715
6716 case 23: hash_type = HASH_TYPE_MD5;
6717 salt_type = SALT_TYPE_EMBEDDED;
6718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6719 opts_type = OPTS_TYPE_PT_GENERATE_LE
6720 | OPTS_TYPE_PT_ADD80
6721 | OPTS_TYPE_PT_ADDBITS14;
6722 kern_type = KERN_TYPE_MD5_SLTPW;
6723 dgst_size = DGST_SIZE_4_4;
6724 parse_func = skype_parse_hash;
6725 sort_by_digest = sort_by_digest_4_4;
6726 opti_type = OPTI_TYPE_ZERO_BYTE
6727 | OPTI_TYPE_PRECOMPUTE_INIT
6728 | OPTI_TYPE_PRECOMPUTE_MERKLE
6729 | OPTI_TYPE_EARLY_SKIP
6730 | OPTI_TYPE_NOT_ITERATED
6731 | OPTI_TYPE_PREPENDED_SALT
6732 | OPTI_TYPE_RAW_HASH;
6733 dgst_pos0 = 0;
6734 dgst_pos1 = 3;
6735 dgst_pos2 = 2;
6736 dgst_pos3 = 1;
6737 break;
6738
6739 case 30: hash_type = HASH_TYPE_MD5;
6740 salt_type = SALT_TYPE_INTERN;
6741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6742 opts_type = OPTS_TYPE_PT_GENERATE_LE
6743 | OPTS_TYPE_PT_UNICODE
6744 | OPTS_TYPE_ST_ADD80
6745 | OPTS_TYPE_ST_ADDBITS14;
6746 kern_type = KERN_TYPE_MD5_PWUSLT;
6747 dgst_size = DGST_SIZE_4_4;
6748 parse_func = md5s_parse_hash;
6749 sort_by_digest = sort_by_digest_4_4;
6750 opti_type = OPTI_TYPE_ZERO_BYTE
6751 | OPTI_TYPE_PRECOMPUTE_INIT
6752 | OPTI_TYPE_PRECOMPUTE_MERKLE
6753 | OPTI_TYPE_MEET_IN_MIDDLE
6754 | OPTI_TYPE_EARLY_SKIP
6755 | OPTI_TYPE_NOT_ITERATED
6756 | OPTI_TYPE_APPENDED_SALT
6757 | OPTI_TYPE_RAW_HASH;
6758 dgst_pos0 = 0;
6759 dgst_pos1 = 3;
6760 dgst_pos2 = 2;
6761 dgst_pos3 = 1;
6762 break;
6763
6764 case 40: hash_type = HASH_TYPE_MD5;
6765 salt_type = SALT_TYPE_INTERN;
6766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6767 opts_type = OPTS_TYPE_PT_GENERATE_LE
6768 | OPTS_TYPE_PT_ADD80
6769 | OPTS_TYPE_PT_ADDBITS14
6770 | OPTS_TYPE_PT_UNICODE;
6771 kern_type = KERN_TYPE_MD5_SLTPWU;
6772 dgst_size = DGST_SIZE_4_4;
6773 parse_func = md5s_parse_hash;
6774 sort_by_digest = sort_by_digest_4_4;
6775 opti_type = OPTI_TYPE_ZERO_BYTE
6776 | OPTI_TYPE_PRECOMPUTE_INIT
6777 | OPTI_TYPE_PRECOMPUTE_MERKLE
6778 | OPTI_TYPE_EARLY_SKIP
6779 | OPTI_TYPE_NOT_ITERATED
6780 | OPTI_TYPE_PREPENDED_SALT
6781 | OPTI_TYPE_RAW_HASH;
6782 dgst_pos0 = 0;
6783 dgst_pos1 = 3;
6784 dgst_pos2 = 2;
6785 dgst_pos3 = 1;
6786 break;
6787
6788 case 50: hash_type = HASH_TYPE_MD5;
6789 salt_type = SALT_TYPE_INTERN;
6790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6791 opts_type = OPTS_TYPE_PT_GENERATE_LE
6792 | OPTS_TYPE_ST_ADD80
6793 | OPTS_TYPE_ST_ADDBITS14;
6794 kern_type = KERN_TYPE_HMACMD5_PW;
6795 dgst_size = DGST_SIZE_4_4;
6796 parse_func = hmacmd5_parse_hash;
6797 sort_by_digest = sort_by_digest_4_4;
6798 opti_type = OPTI_TYPE_ZERO_BYTE
6799 | OPTI_TYPE_NOT_ITERATED;
6800 dgst_pos0 = 0;
6801 dgst_pos1 = 3;
6802 dgst_pos2 = 2;
6803 dgst_pos3 = 1;
6804 break;
6805
6806 case 60: hash_type = HASH_TYPE_MD5;
6807 salt_type = SALT_TYPE_INTERN;
6808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6809 opts_type = OPTS_TYPE_PT_GENERATE_LE
6810 | OPTS_TYPE_PT_ADD80
6811 | OPTS_TYPE_PT_ADDBITS14;
6812 kern_type = KERN_TYPE_HMACMD5_SLT;
6813 dgst_size = DGST_SIZE_4_4;
6814 parse_func = hmacmd5_parse_hash;
6815 sort_by_digest = sort_by_digest_4_4;
6816 opti_type = OPTI_TYPE_ZERO_BYTE
6817 | OPTI_TYPE_NOT_ITERATED;
6818 dgst_pos0 = 0;
6819 dgst_pos1 = 3;
6820 dgst_pos2 = 2;
6821 dgst_pos3 = 1;
6822 break;
6823
6824 case 100: hash_type = HASH_TYPE_SHA1;
6825 salt_type = SALT_TYPE_NONE;
6826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6827 opts_type = OPTS_TYPE_PT_GENERATE_BE
6828 | OPTS_TYPE_PT_ADD80
6829 | OPTS_TYPE_PT_ADDBITS15;
6830 kern_type = KERN_TYPE_SHA1;
6831 dgst_size = DGST_SIZE_4_5;
6832 parse_func = sha1_parse_hash;
6833 sort_by_digest = sort_by_digest_4_5;
6834 opti_type = OPTI_TYPE_ZERO_BYTE
6835 | OPTI_TYPE_PRECOMPUTE_INIT
6836 | OPTI_TYPE_PRECOMPUTE_MERKLE
6837 | OPTI_TYPE_EARLY_SKIP
6838 | OPTI_TYPE_NOT_ITERATED
6839 | OPTI_TYPE_NOT_SALTED
6840 | OPTI_TYPE_RAW_HASH;
6841 dgst_pos0 = 3;
6842 dgst_pos1 = 4;
6843 dgst_pos2 = 2;
6844 dgst_pos3 = 1;
6845 break;
6846
6847 case 101: hash_type = HASH_TYPE_SHA1;
6848 salt_type = SALT_TYPE_NONE;
6849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6850 opts_type = OPTS_TYPE_PT_GENERATE_BE
6851 | OPTS_TYPE_PT_ADD80
6852 | OPTS_TYPE_PT_ADDBITS15;
6853 kern_type = KERN_TYPE_SHA1;
6854 dgst_size = DGST_SIZE_4_5;
6855 parse_func = sha1b64_parse_hash;
6856 sort_by_digest = sort_by_digest_4_5;
6857 opti_type = OPTI_TYPE_ZERO_BYTE
6858 | OPTI_TYPE_PRECOMPUTE_INIT
6859 | OPTI_TYPE_PRECOMPUTE_MERKLE
6860 | OPTI_TYPE_EARLY_SKIP
6861 | OPTI_TYPE_NOT_ITERATED
6862 | OPTI_TYPE_NOT_SALTED
6863 | OPTI_TYPE_RAW_HASH;
6864 dgst_pos0 = 3;
6865 dgst_pos1 = 4;
6866 dgst_pos2 = 2;
6867 dgst_pos3 = 1;
6868 break;
6869
6870 case 110: hash_type = HASH_TYPE_SHA1;
6871 salt_type = SALT_TYPE_INTERN;
6872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6873 opts_type = OPTS_TYPE_PT_GENERATE_BE
6874 | OPTS_TYPE_ST_ADD80
6875 | OPTS_TYPE_ST_ADDBITS15;
6876 kern_type = KERN_TYPE_SHA1_PWSLT;
6877 dgst_size = DGST_SIZE_4_5;
6878 parse_func = sha1s_parse_hash;
6879 sort_by_digest = sort_by_digest_4_5;
6880 opti_type = OPTI_TYPE_ZERO_BYTE
6881 | OPTI_TYPE_PRECOMPUTE_INIT
6882 | OPTI_TYPE_PRECOMPUTE_MERKLE
6883 | OPTI_TYPE_EARLY_SKIP
6884 | OPTI_TYPE_NOT_ITERATED
6885 | OPTI_TYPE_APPENDED_SALT
6886 | OPTI_TYPE_RAW_HASH;
6887 dgst_pos0 = 3;
6888 dgst_pos1 = 4;
6889 dgst_pos2 = 2;
6890 dgst_pos3 = 1;
6891 break;
6892
6893 case 111: hash_type = HASH_TYPE_SHA1;
6894 salt_type = SALT_TYPE_EMBEDDED;
6895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6896 opts_type = OPTS_TYPE_PT_GENERATE_BE
6897 | OPTS_TYPE_ST_ADD80
6898 | OPTS_TYPE_ST_ADDBITS15;
6899 kern_type = KERN_TYPE_SHA1_PWSLT;
6900 dgst_size = DGST_SIZE_4_5;
6901 parse_func = sha1b64s_parse_hash;
6902 sort_by_digest = sort_by_digest_4_5;
6903 opti_type = OPTI_TYPE_ZERO_BYTE
6904 | OPTI_TYPE_PRECOMPUTE_INIT
6905 | OPTI_TYPE_PRECOMPUTE_MERKLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_APPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 3;
6911 dgst_pos1 = 4;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 112: hash_type = HASH_TYPE_SHA1;
6917 salt_type = SALT_TYPE_INTERN;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_BE
6920 | OPTS_TYPE_ST_ADD80
6921 | OPTS_TYPE_ST_ADDBITS15
6922 | OPTS_TYPE_ST_HEX;
6923 kern_type = KERN_TYPE_SHA1_PWSLT;
6924 dgst_size = DGST_SIZE_4_5;
6925 parse_func = oracles_parse_hash;
6926 sort_by_digest = sort_by_digest_4_5;
6927 opti_type = OPTI_TYPE_ZERO_BYTE
6928 | OPTI_TYPE_PRECOMPUTE_INIT
6929 | OPTI_TYPE_PRECOMPUTE_MERKLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_APPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 3;
6935 dgst_pos1 = 4;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 120: hash_type = HASH_TYPE_SHA1;
6941 salt_type = SALT_TYPE_INTERN;
6942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6943 opts_type = OPTS_TYPE_PT_GENERATE_BE
6944 | OPTS_TYPE_PT_ADD80
6945 | OPTS_TYPE_PT_ADDBITS15;
6946 kern_type = KERN_TYPE_SHA1_SLTPW;
6947 dgst_size = DGST_SIZE_4_5;
6948 parse_func = sha1s_parse_hash;
6949 sort_by_digest = sort_by_digest_4_5;
6950 opti_type = OPTI_TYPE_ZERO_BYTE
6951 | OPTI_TYPE_PRECOMPUTE_INIT
6952 | OPTI_TYPE_PRECOMPUTE_MERKLE
6953 | OPTI_TYPE_EARLY_SKIP
6954 | OPTI_TYPE_NOT_ITERATED
6955 | OPTI_TYPE_PREPENDED_SALT
6956 | OPTI_TYPE_RAW_HASH;
6957 dgst_pos0 = 3;
6958 dgst_pos1 = 4;
6959 dgst_pos2 = 2;
6960 dgst_pos3 = 1;
6961 break;
6962
6963 case 121: hash_type = HASH_TYPE_SHA1;
6964 salt_type = SALT_TYPE_INTERN;
6965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6966 opts_type = OPTS_TYPE_PT_GENERATE_BE
6967 | OPTS_TYPE_PT_ADD80
6968 | OPTS_TYPE_PT_ADDBITS15
6969 | OPTS_TYPE_ST_LOWER;
6970 kern_type = KERN_TYPE_SHA1_SLTPW;
6971 dgst_size = DGST_SIZE_4_5;
6972 parse_func = smf_parse_hash;
6973 sort_by_digest = sort_by_digest_4_5;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_PREPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 3;
6982 dgst_pos1 = 4;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 122: hash_type = HASH_TYPE_SHA1;
6988 salt_type = SALT_TYPE_EMBEDDED;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_BE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS15
6993 | OPTS_TYPE_ST_HEX;
6994 kern_type = KERN_TYPE_SHA1_SLTPW;
6995 dgst_size = DGST_SIZE_4_5;
6996 parse_func = osx1_parse_hash;
6997 sort_by_digest = sort_by_digest_4_5;
6998 opti_type = OPTI_TYPE_ZERO_BYTE
6999 | OPTI_TYPE_PRECOMPUTE_INIT
7000 | OPTI_TYPE_PRECOMPUTE_MERKLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_PREPENDED_SALT
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 3;
7006 dgst_pos1 = 4;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 124: hash_type = HASH_TYPE_SHA1;
7012 salt_type = SALT_TYPE_EMBEDDED;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_BE
7015 | OPTS_TYPE_PT_ADD80
7016 | OPTS_TYPE_PT_ADDBITS15;
7017 kern_type = KERN_TYPE_SHA1_SLTPW;
7018 dgst_size = DGST_SIZE_4_5;
7019 parse_func = djangosha1_parse_hash;
7020 sort_by_digest = sort_by_digest_4_5;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_EARLY_SKIP
7025 | OPTI_TYPE_NOT_ITERATED
7026 | OPTI_TYPE_PREPENDED_SALT
7027 | OPTI_TYPE_RAW_HASH;
7028 dgst_pos0 = 3;
7029 dgst_pos1 = 4;
7030 dgst_pos2 = 2;
7031 dgst_pos3 = 1;
7032 break;
7033
7034 case 130: hash_type = HASH_TYPE_SHA1;
7035 salt_type = SALT_TYPE_INTERN;
7036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7037 opts_type = OPTS_TYPE_PT_GENERATE_BE
7038 | OPTS_TYPE_PT_UNICODE
7039 | OPTS_TYPE_ST_ADD80
7040 | OPTS_TYPE_ST_ADDBITS15;
7041 kern_type = KERN_TYPE_SHA1_PWUSLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = sha1s_parse_hash;
7044 sort_by_digest = sort_by_digest_4_5;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_EARLY_SKIP
7049 | OPTI_TYPE_NOT_ITERATED
7050 | OPTI_TYPE_APPENDED_SALT
7051 | OPTI_TYPE_RAW_HASH;
7052 dgst_pos0 = 3;
7053 dgst_pos1 = 4;
7054 dgst_pos2 = 2;
7055 dgst_pos3 = 1;
7056 break;
7057
7058 case 131: hash_type = HASH_TYPE_SHA1;
7059 salt_type = SALT_TYPE_EMBEDDED;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_BE
7062 | OPTS_TYPE_PT_UNICODE
7063 | OPTS_TYPE_PT_UPPER
7064 | OPTS_TYPE_ST_ADD80
7065 | OPTS_TYPE_ST_ADDBITS15
7066 | OPTS_TYPE_ST_HEX;
7067 kern_type = KERN_TYPE_SHA1_PWUSLT;
7068 dgst_size = DGST_SIZE_4_5;
7069 parse_func = mssql2000_parse_hash;
7070 sort_by_digest = sort_by_digest_4_5;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_EARLY_SKIP
7075 | OPTI_TYPE_NOT_ITERATED
7076 | OPTI_TYPE_APPENDED_SALT
7077 | OPTI_TYPE_RAW_HASH;
7078 dgst_pos0 = 3;
7079 dgst_pos1 = 4;
7080 dgst_pos2 = 2;
7081 dgst_pos3 = 1;
7082 break;
7083
7084 case 132: hash_type = HASH_TYPE_SHA1;
7085 salt_type = SALT_TYPE_EMBEDDED;
7086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7087 opts_type = OPTS_TYPE_PT_GENERATE_BE
7088 | OPTS_TYPE_PT_UNICODE
7089 | OPTS_TYPE_ST_ADD80
7090 | OPTS_TYPE_ST_ADDBITS15
7091 | OPTS_TYPE_ST_HEX;
7092 kern_type = KERN_TYPE_SHA1_PWUSLT;
7093 dgst_size = DGST_SIZE_4_5;
7094 parse_func = mssql2005_parse_hash;
7095 sort_by_digest = sort_by_digest_4_5;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_EARLY_SKIP
7100 | OPTI_TYPE_NOT_ITERATED
7101 | OPTI_TYPE_APPENDED_SALT
7102 | OPTI_TYPE_RAW_HASH;
7103 dgst_pos0 = 3;
7104 dgst_pos1 = 4;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 133: hash_type = HASH_TYPE_SHA1;
7110 salt_type = SALT_TYPE_EMBEDDED;
7111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7112 opts_type = OPTS_TYPE_PT_GENERATE_BE
7113 | OPTS_TYPE_PT_UNICODE
7114 | OPTS_TYPE_ST_ADD80
7115 | OPTS_TYPE_ST_ADDBITS15;
7116 kern_type = KERN_TYPE_SHA1_PWUSLT;
7117 dgst_size = DGST_SIZE_4_5;
7118 parse_func = peoplesoft_parse_hash;
7119 sort_by_digest = sort_by_digest_4_5;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_EARLY_SKIP
7124 | OPTI_TYPE_NOT_ITERATED
7125 | OPTI_TYPE_APPENDED_SALT
7126 | OPTI_TYPE_RAW_HASH;
7127 dgst_pos0 = 3;
7128 dgst_pos1 = 4;
7129 dgst_pos2 = 2;
7130 dgst_pos3 = 1;
7131 break;
7132
7133 case 140: hash_type = HASH_TYPE_SHA1;
7134 salt_type = SALT_TYPE_INTERN;
7135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7136 opts_type = OPTS_TYPE_PT_GENERATE_BE
7137 | OPTS_TYPE_PT_ADD80
7138 | OPTS_TYPE_PT_ADDBITS15
7139 | OPTS_TYPE_PT_UNICODE;
7140 kern_type = KERN_TYPE_SHA1_SLTPWU;
7141 dgst_size = DGST_SIZE_4_5;
7142 parse_func = sha1s_parse_hash;
7143 sort_by_digest = sort_by_digest_4_5;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_PREPENDED_SALT
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 3;
7152 dgst_pos1 = 4;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 141: hash_type = HASH_TYPE_SHA1;
7158 salt_type = SALT_TYPE_EMBEDDED;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_BE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS15
7163 | OPTS_TYPE_PT_UNICODE
7164 | OPTS_TYPE_ST_BASE64;
7165 kern_type = KERN_TYPE_SHA1_SLTPWU;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = episerver_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_PREPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 150: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_INTERN;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_ST_ADD80
7187 | OPTS_TYPE_ST_ADDBITS15;
7188 kern_type = KERN_TYPE_HMACSHA1_PW;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = hmacsha1_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_NOT_ITERATED;
7194 dgst_pos0 = 3;
7195 dgst_pos1 = 4;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 160: hash_type = HASH_TYPE_SHA1;
7201 salt_type = SALT_TYPE_INTERN;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_BE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS15;
7206 kern_type = KERN_TYPE_HMACSHA1_SLT;
7207 dgst_size = DGST_SIZE_4_5;
7208 parse_func = hmacsha1_parse_hash;
7209 sort_by_digest = sort_by_digest_4_5;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_NOT_ITERATED;
7212 dgst_pos0 = 3;
7213 dgst_pos1 = 4;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 190: hash_type = HASH_TYPE_SHA1;
7219 salt_type = SALT_TYPE_NONE;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_BE
7222 | OPTS_TYPE_PT_ADD80
7223 | OPTS_TYPE_PT_ADDBITS15;
7224 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7225 dgst_size = DGST_SIZE_4_5;
7226 parse_func = sha1linkedin_parse_hash;
7227 sort_by_digest = sort_by_digest_4_5;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_EARLY_SKIP
7231 | OPTI_TYPE_NOT_ITERATED
7232 | OPTI_TYPE_NOT_SALTED;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 4;
7235 dgst_pos2 = 3;
7236 dgst_pos3 = 2;
7237 break;
7238
7239 case 200: hash_type = HASH_TYPE_MYSQL;
7240 salt_type = SALT_TYPE_NONE;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = 0;
7243 kern_type = KERN_TYPE_MYSQL;
7244 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7245 parse_func = mysql323_parse_hash;
7246 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7247 opti_type = OPTI_TYPE_ZERO_BYTE;
7248 dgst_pos0 = 0;
7249 dgst_pos1 = 1;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 3;
7252 break;
7253
7254 case 300: hash_type = HASH_TYPE_SHA1;
7255 salt_type = SALT_TYPE_NONE;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_BE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS15;
7260 kern_type = KERN_TYPE_MYSQL41;
7261 dgst_size = DGST_SIZE_4_5;
7262 parse_func = sha1_parse_hash;
7263 sort_by_digest = sort_by_digest_4_5;
7264 opti_type = OPTI_TYPE_ZERO_BYTE
7265 | OPTI_TYPE_PRECOMPUTE_INIT
7266 | OPTI_TYPE_PRECOMPUTE_MERKLE
7267 | OPTI_TYPE_EARLY_SKIP
7268 | OPTI_TYPE_NOT_ITERATED
7269 | OPTI_TYPE_NOT_SALTED;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 400: hash_type = HASH_TYPE_MD5;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7280 kern_type = KERN_TYPE_PHPASS;
7281 dgst_size = DGST_SIZE_4_4;
7282 parse_func = phpass_parse_hash;
7283 sort_by_digest = sort_by_digest_4_4;
7284 opti_type = OPTI_TYPE_ZERO_BYTE;
7285 dgst_pos0 = 0;
7286 dgst_pos1 = 1;
7287 dgst_pos2 = 2;
7288 dgst_pos3 = 3;
7289 break;
7290
7291 case 500: hash_type = HASH_TYPE_MD5;
7292 salt_type = SALT_TYPE_EMBEDDED;
7293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7295 kern_type = KERN_TYPE_MD5CRYPT;
7296 dgst_size = DGST_SIZE_4_4;
7297 parse_func = md5crypt_parse_hash;
7298 sort_by_digest = sort_by_digest_4_4;
7299 opti_type = OPTI_TYPE_ZERO_BYTE;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 1;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 3;
7304 break;
7305
7306 case 501: hash_type = HASH_TYPE_MD5;
7307 salt_type = SALT_TYPE_EMBEDDED;
7308 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_LE
7310 | OPTS_TYPE_HASH_COPY;
7311 kern_type = KERN_TYPE_MD5CRYPT;
7312 dgst_size = DGST_SIZE_4_4;
7313 parse_func = juniper_parse_hash;
7314 sort_by_digest = sort_by_digest_4_4;
7315 opti_type = OPTI_TYPE_ZERO_BYTE;
7316 dgst_pos0 = 0;
7317 dgst_pos1 = 1;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 3;
7320 break;
7321
7322 case 900: hash_type = HASH_TYPE_MD4;
7323 salt_type = SALT_TYPE_NONE;
7324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7325 opts_type = OPTS_TYPE_PT_GENERATE_LE
7326 | OPTS_TYPE_PT_ADD80
7327 | OPTS_TYPE_PT_ADDBITS14;
7328 kern_type = KERN_TYPE_MD4;
7329 dgst_size = DGST_SIZE_4_4;
7330 parse_func = md4_parse_hash;
7331 sort_by_digest = sort_by_digest_4_4;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_MEET_IN_MIDDLE
7336 | OPTI_TYPE_EARLY_SKIP
7337 | OPTI_TYPE_NOT_ITERATED
7338 | OPTI_TYPE_NOT_SALTED
7339 | OPTI_TYPE_RAW_HASH;
7340 dgst_pos0 = 0;
7341 dgst_pos1 = 3;
7342 dgst_pos2 = 2;
7343 dgst_pos3 = 1;
7344 break;
7345
7346 case 1000: hash_type = HASH_TYPE_MD4;
7347 salt_type = SALT_TYPE_NONE;
7348 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7349 opts_type = OPTS_TYPE_PT_GENERATE_LE
7350 | OPTS_TYPE_PT_ADD80
7351 | OPTS_TYPE_PT_ADDBITS14
7352 | OPTS_TYPE_PT_UNICODE;
7353 kern_type = KERN_TYPE_MD4_PWU;
7354 dgst_size = DGST_SIZE_4_4;
7355 parse_func = md4_parse_hash;
7356 sort_by_digest = sort_by_digest_4_4;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_MEET_IN_MIDDLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_NOT_SALTED
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 0;
7366 dgst_pos1 = 3;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 1100: hash_type = HASH_TYPE_MD4;
7372 salt_type = SALT_TYPE_INTERN;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_LE
7375 | OPTS_TYPE_PT_ADD80
7376 | OPTS_TYPE_PT_ADDBITS14
7377 | OPTS_TYPE_PT_UNICODE
7378 | OPTS_TYPE_ST_ADD80
7379 | OPTS_TYPE_ST_UNICODE
7380 | OPTS_TYPE_ST_LOWER;
7381 kern_type = KERN_TYPE_MD44_PWUSLT;
7382 dgst_size = DGST_SIZE_4_4;
7383 parse_func = dcc_parse_hash;
7384 sort_by_digest = sort_by_digest_4_4;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED;
7390 dgst_pos0 = 0;
7391 dgst_pos1 = 3;
7392 dgst_pos2 = 2;
7393 dgst_pos3 = 1;
7394 break;
7395
7396 case 1400: hash_type = HASH_TYPE_SHA256;
7397 salt_type = SALT_TYPE_NONE;
7398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7399 opts_type = OPTS_TYPE_PT_GENERATE_BE
7400 | OPTS_TYPE_PT_ADD80
7401 | OPTS_TYPE_PT_ADDBITS15;
7402 kern_type = KERN_TYPE_SHA256;
7403 dgst_size = DGST_SIZE_4_8;
7404 parse_func = sha256_parse_hash;
7405 sort_by_digest = sort_by_digest_4_8;
7406 opti_type = OPTI_TYPE_ZERO_BYTE
7407 | OPTI_TYPE_PRECOMPUTE_INIT
7408 | OPTI_TYPE_PRECOMPUTE_MERKLE
7409 | OPTI_TYPE_EARLY_SKIP
7410 | OPTI_TYPE_NOT_ITERATED
7411 | OPTI_TYPE_NOT_SALTED
7412 | OPTI_TYPE_RAW_HASH;
7413 dgst_pos0 = 3;
7414 dgst_pos1 = 7;
7415 dgst_pos2 = 2;
7416 dgst_pos3 = 6;
7417 break;
7418
7419 case 1410: hash_type = HASH_TYPE_SHA256;
7420 salt_type = SALT_TYPE_INTERN;
7421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7422 opts_type = OPTS_TYPE_PT_GENERATE_BE
7423 | OPTS_TYPE_ST_ADD80
7424 | OPTS_TYPE_ST_ADDBITS15;
7425 kern_type = KERN_TYPE_SHA256_PWSLT;
7426 dgst_size = DGST_SIZE_4_8;
7427 parse_func = sha256s_parse_hash;
7428 sort_by_digest = sort_by_digest_4_8;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_APPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 7;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 6;
7440 break;
7441
7442 case 1420: hash_type = HASH_TYPE_SHA256;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15;
7448 kern_type = KERN_TYPE_SHA256_SLTPW;
7449 dgst_size = DGST_SIZE_4_8;
7450 parse_func = sha256s_parse_hash;
7451 sort_by_digest = sort_by_digest_4_8;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_EARLY_SKIP
7456 | OPTI_TYPE_NOT_ITERATED
7457 | OPTI_TYPE_PREPENDED_SALT
7458 | OPTI_TYPE_RAW_HASH;
7459 dgst_pos0 = 3;
7460 dgst_pos1 = 7;
7461 dgst_pos2 = 2;
7462 dgst_pos3 = 6;
7463 break;
7464
7465 case 1421: hash_type = HASH_TYPE_SHA256;
7466 salt_type = SALT_TYPE_EMBEDDED;
7467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7468 opts_type = OPTS_TYPE_PT_GENERATE_BE
7469 | OPTS_TYPE_PT_ADD80
7470 | OPTS_TYPE_PT_ADDBITS15;
7471 kern_type = KERN_TYPE_SHA256_SLTPW;
7472 dgst_size = DGST_SIZE_4_8;
7473 parse_func = hmailserver_parse_hash;
7474 sort_by_digest = sort_by_digest_4_8;
7475 opti_type = OPTI_TYPE_ZERO_BYTE
7476 | OPTI_TYPE_PRECOMPUTE_INIT
7477 | OPTI_TYPE_PRECOMPUTE_MERKLE
7478 | OPTI_TYPE_EARLY_SKIP
7479 | OPTI_TYPE_NOT_ITERATED
7480 | OPTI_TYPE_PREPENDED_SALT
7481 | OPTI_TYPE_RAW_HASH;
7482 dgst_pos0 = 3;
7483 dgst_pos1 = 7;
7484 dgst_pos2 = 2;
7485 dgst_pos3 = 6;
7486 break;
7487
7488 case 1430: hash_type = HASH_TYPE_SHA256;
7489 salt_type = SALT_TYPE_INTERN;
7490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7491 opts_type = OPTS_TYPE_PT_GENERATE_BE
7492 | OPTS_TYPE_PT_UNICODE
7493 | OPTS_TYPE_ST_ADD80
7494 | OPTS_TYPE_ST_ADDBITS15;
7495 kern_type = KERN_TYPE_SHA256_PWUSLT;
7496 dgst_size = DGST_SIZE_4_8;
7497 parse_func = sha256s_parse_hash;
7498 sort_by_digest = sort_by_digest_4_8;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_PRECOMPUTE_MERKLE
7502 | OPTI_TYPE_EARLY_SKIP
7503 | OPTI_TYPE_NOT_ITERATED
7504 | OPTI_TYPE_APPENDED_SALT
7505 | OPTI_TYPE_RAW_HASH;
7506 dgst_pos0 = 3;
7507 dgst_pos1 = 7;
7508 dgst_pos2 = 2;
7509 dgst_pos3 = 6;
7510 break;
7511
7512 case 1440: hash_type = HASH_TYPE_SHA256;
7513 salt_type = SALT_TYPE_INTERN;
7514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7515 opts_type = OPTS_TYPE_PT_GENERATE_BE
7516 | OPTS_TYPE_PT_ADD80
7517 | OPTS_TYPE_PT_ADDBITS15
7518 | OPTS_TYPE_PT_UNICODE;
7519 kern_type = KERN_TYPE_SHA256_SLTPWU;
7520 dgst_size = DGST_SIZE_4_8;
7521 parse_func = sha256s_parse_hash;
7522 sort_by_digest = sort_by_digest_4_8;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED
7528 | OPTI_TYPE_PREPENDED_SALT
7529 | OPTI_TYPE_RAW_HASH;
7530 dgst_pos0 = 3;
7531 dgst_pos1 = 7;
7532 dgst_pos2 = 2;
7533 dgst_pos3 = 6;
7534 break;
7535
7536 case 1441: hash_type = HASH_TYPE_SHA256;
7537 salt_type = SALT_TYPE_EMBEDDED;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = OPTS_TYPE_PT_GENERATE_BE
7540 | OPTS_TYPE_PT_ADD80
7541 | OPTS_TYPE_PT_ADDBITS15
7542 | OPTS_TYPE_PT_UNICODE
7543 | OPTS_TYPE_ST_BASE64;
7544 kern_type = KERN_TYPE_SHA256_SLTPWU;
7545 dgst_size = DGST_SIZE_4_8;
7546 parse_func = episerver4_parse_hash;
7547 sort_by_digest = sort_by_digest_4_8;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_PRECOMPUTE_INIT
7550 | OPTI_TYPE_PRECOMPUTE_MERKLE
7551 | OPTI_TYPE_EARLY_SKIP
7552 | OPTI_TYPE_NOT_ITERATED
7553 | OPTI_TYPE_PREPENDED_SALT
7554 | OPTI_TYPE_RAW_HASH;
7555 dgst_pos0 = 3;
7556 dgst_pos1 = 7;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 6;
7559 break;
7560
7561 case 1450: hash_type = HASH_TYPE_SHA256;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_BE
7565 | OPTS_TYPE_ST_ADD80;
7566 kern_type = KERN_TYPE_HMACSHA256_PW;
7567 dgst_size = DGST_SIZE_4_8;
7568 parse_func = hmacsha256_parse_hash;
7569 sort_by_digest = sort_by_digest_4_8;
7570 opti_type = OPTI_TYPE_ZERO_BYTE
7571 | OPTI_TYPE_NOT_ITERATED;
7572 dgst_pos0 = 3;
7573 dgst_pos1 = 7;
7574 dgst_pos2 = 2;
7575 dgst_pos3 = 6;
7576 break;
7577
7578 case 1460: hash_type = HASH_TYPE_SHA256;
7579 salt_type = SALT_TYPE_INTERN;
7580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7581 opts_type = OPTS_TYPE_PT_GENERATE_BE
7582 | OPTS_TYPE_PT_ADD80
7583 | OPTS_TYPE_PT_ADDBITS15;
7584 kern_type = KERN_TYPE_HMACSHA256_SLT;
7585 dgst_size = DGST_SIZE_4_8;
7586 parse_func = hmacsha256_parse_hash;
7587 sort_by_digest = sort_by_digest_4_8;
7588 opti_type = OPTI_TYPE_ZERO_BYTE
7589 | OPTI_TYPE_NOT_ITERATED;
7590 dgst_pos0 = 3;
7591 dgst_pos1 = 7;
7592 dgst_pos2 = 2;
7593 dgst_pos3 = 6;
7594 break;
7595
7596 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7597 salt_type = SALT_TYPE_EMBEDDED;
7598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7599 opts_type = OPTS_TYPE_PT_GENERATE_LE
7600 | OPTS_TYPE_PT_BITSLICE;
7601 kern_type = KERN_TYPE_DESCRYPT;
7602 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7603 parse_func = descrypt_parse_hash;
7604 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 1;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 3;
7611 break;
7612
7613 case 1600: hash_type = HASH_TYPE_MD5;
7614 salt_type = SALT_TYPE_EMBEDDED;
7615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7617 kern_type = KERN_TYPE_APR1CRYPT;
7618 dgst_size = DGST_SIZE_4_4;
7619 parse_func = md5apr1_parse_hash;
7620 sort_by_digest = sort_by_digest_4_4;
7621 opti_type = OPTI_TYPE_ZERO_BYTE;
7622 dgst_pos0 = 0;
7623 dgst_pos1 = 1;
7624 dgst_pos2 = 2;
7625 dgst_pos3 = 3;
7626 break;
7627
7628 case 1700: hash_type = HASH_TYPE_SHA512;
7629 salt_type = SALT_TYPE_NONE;
7630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7631 opts_type = OPTS_TYPE_PT_GENERATE_BE
7632 | OPTS_TYPE_PT_ADD80
7633 | OPTS_TYPE_PT_ADDBITS15;
7634 kern_type = KERN_TYPE_SHA512;
7635 dgst_size = DGST_SIZE_8_8;
7636 parse_func = sha512_parse_hash;
7637 sort_by_digest = sort_by_digest_8_8;
7638 opti_type = OPTI_TYPE_ZERO_BYTE
7639 | OPTI_TYPE_PRECOMPUTE_INIT
7640 | OPTI_TYPE_PRECOMPUTE_MERKLE
7641 | OPTI_TYPE_EARLY_SKIP
7642 | OPTI_TYPE_NOT_ITERATED
7643 | OPTI_TYPE_NOT_SALTED
7644 | OPTI_TYPE_RAW_HASH;
7645 dgst_pos0 = 14;
7646 dgst_pos1 = 15;
7647 dgst_pos2 = 6;
7648 dgst_pos3 = 7;
7649 break;
7650
7651 case 1710: hash_type = HASH_TYPE_SHA512;
7652 salt_type = SALT_TYPE_INTERN;
7653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7654 opts_type = OPTS_TYPE_PT_GENERATE_BE
7655 | OPTS_TYPE_ST_ADD80
7656 | OPTS_TYPE_ST_ADDBITS15;
7657 kern_type = KERN_TYPE_SHA512_PWSLT;
7658 dgst_size = DGST_SIZE_8_8;
7659 parse_func = sha512s_parse_hash;
7660 sort_by_digest = sort_by_digest_8_8;
7661 opti_type = OPTI_TYPE_ZERO_BYTE
7662 | OPTI_TYPE_PRECOMPUTE_INIT
7663 | OPTI_TYPE_PRECOMPUTE_MERKLE
7664 | OPTI_TYPE_EARLY_SKIP
7665 | OPTI_TYPE_NOT_ITERATED
7666 | OPTI_TYPE_APPENDED_SALT
7667 | OPTI_TYPE_RAW_HASH;
7668 dgst_pos0 = 14;
7669 dgst_pos1 = 15;
7670 dgst_pos2 = 6;
7671 dgst_pos3 = 7;
7672 break;
7673
7674 case 1711: hash_type = HASH_TYPE_SHA512;
7675 salt_type = SALT_TYPE_EMBEDDED;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_BE
7678 | OPTS_TYPE_ST_ADD80
7679 | OPTS_TYPE_ST_ADDBITS15;
7680 kern_type = KERN_TYPE_SHA512_PWSLT;
7681 dgst_size = DGST_SIZE_8_8;
7682 parse_func = sha512b64s_parse_hash;
7683 sort_by_digest = sort_by_digest_8_8;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_EARLY_SKIP
7688 | OPTI_TYPE_NOT_ITERATED
7689 | OPTI_TYPE_APPENDED_SALT
7690 | OPTI_TYPE_RAW_HASH;
7691 dgst_pos0 = 14;
7692 dgst_pos1 = 15;
7693 dgst_pos2 = 6;
7694 dgst_pos3 = 7;
7695 break;
7696
7697 case 1720: hash_type = HASH_TYPE_SHA512;
7698 salt_type = SALT_TYPE_INTERN;
7699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7700 opts_type = OPTS_TYPE_PT_GENERATE_BE
7701 | OPTS_TYPE_PT_ADD80
7702 | OPTS_TYPE_PT_ADDBITS15;
7703 kern_type = KERN_TYPE_SHA512_SLTPW;
7704 dgst_size = DGST_SIZE_8_8;
7705 parse_func = sha512s_parse_hash;
7706 sort_by_digest = sort_by_digest_8_8;
7707 opti_type = OPTI_TYPE_ZERO_BYTE
7708 | OPTI_TYPE_PRECOMPUTE_INIT
7709 | OPTI_TYPE_PRECOMPUTE_MERKLE
7710 | OPTI_TYPE_EARLY_SKIP
7711 | OPTI_TYPE_NOT_ITERATED
7712 | OPTI_TYPE_PREPENDED_SALT
7713 | OPTI_TYPE_RAW_HASH;
7714 dgst_pos0 = 14;
7715 dgst_pos1 = 15;
7716 dgst_pos2 = 6;
7717 dgst_pos3 = 7;
7718 break;
7719
7720 case 1722: hash_type = HASH_TYPE_SHA512;
7721 salt_type = SALT_TYPE_EMBEDDED;
7722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7723 opts_type = OPTS_TYPE_PT_GENERATE_BE
7724 | OPTS_TYPE_PT_ADD80
7725 | OPTS_TYPE_PT_ADDBITS15
7726 | OPTS_TYPE_ST_HEX;
7727 kern_type = KERN_TYPE_SHA512_SLTPW;
7728 dgst_size = DGST_SIZE_8_8;
7729 parse_func = osx512_parse_hash;
7730 sort_by_digest = sort_by_digest_8_8;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED
7736 | OPTI_TYPE_PREPENDED_SALT
7737 | OPTI_TYPE_RAW_HASH;
7738 dgst_pos0 = 14;
7739 dgst_pos1 = 15;
7740 dgst_pos2 = 6;
7741 dgst_pos3 = 7;
7742 break;
7743
7744 case 1730: hash_type = HASH_TYPE_SHA512;
7745 salt_type = SALT_TYPE_INTERN;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_UNICODE
7749 | OPTS_TYPE_ST_ADD80
7750 | OPTS_TYPE_ST_ADDBITS15;
7751 kern_type = KERN_TYPE_SHA512_PWSLTU;
7752 dgst_size = DGST_SIZE_8_8;
7753 parse_func = sha512s_parse_hash;
7754 sort_by_digest = sort_by_digest_8_8;
7755 opti_type = OPTI_TYPE_ZERO_BYTE
7756 | OPTI_TYPE_PRECOMPUTE_INIT
7757 | OPTI_TYPE_PRECOMPUTE_MERKLE
7758 | OPTI_TYPE_EARLY_SKIP
7759 | OPTI_TYPE_NOT_ITERATED
7760 | OPTI_TYPE_APPENDED_SALT
7761 | OPTI_TYPE_RAW_HASH;
7762 dgst_pos0 = 14;
7763 dgst_pos1 = 15;
7764 dgst_pos2 = 6;
7765 dgst_pos3 = 7;
7766 break;
7767
7768 case 1731: hash_type = HASH_TYPE_SHA512;
7769 salt_type = SALT_TYPE_EMBEDDED;
7770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7771 opts_type = OPTS_TYPE_PT_GENERATE_BE
7772 | OPTS_TYPE_PT_UNICODE
7773 | OPTS_TYPE_ST_ADD80
7774 | OPTS_TYPE_ST_ADDBITS15
7775 | OPTS_TYPE_ST_HEX;
7776 kern_type = KERN_TYPE_SHA512_PWSLTU;
7777 dgst_size = DGST_SIZE_8_8;
7778 parse_func = mssql2012_parse_hash;
7779 sort_by_digest = sort_by_digest_8_8;
7780 opti_type = OPTI_TYPE_ZERO_BYTE
7781 | OPTI_TYPE_PRECOMPUTE_INIT
7782 | OPTI_TYPE_PRECOMPUTE_MERKLE
7783 | OPTI_TYPE_EARLY_SKIP
7784 | OPTI_TYPE_NOT_ITERATED
7785 | OPTI_TYPE_APPENDED_SALT
7786 | OPTI_TYPE_RAW_HASH;
7787 dgst_pos0 = 14;
7788 dgst_pos1 = 15;
7789 dgst_pos2 = 6;
7790 dgst_pos3 = 7;
7791 break;
7792
7793 case 1740: hash_type = HASH_TYPE_SHA512;
7794 salt_type = SALT_TYPE_INTERN;
7795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7796 opts_type = OPTS_TYPE_PT_GENERATE_BE
7797 | OPTS_TYPE_PT_ADD80
7798 | OPTS_TYPE_PT_ADDBITS15
7799 | OPTS_TYPE_PT_UNICODE;
7800 kern_type = KERN_TYPE_SHA512_SLTPWU;
7801 dgst_size = DGST_SIZE_8_8;
7802 parse_func = sha512s_parse_hash;
7803 sort_by_digest = sort_by_digest_8_8;
7804 opti_type = OPTI_TYPE_ZERO_BYTE
7805 | OPTI_TYPE_PRECOMPUTE_INIT
7806 | OPTI_TYPE_PRECOMPUTE_MERKLE
7807 | OPTI_TYPE_EARLY_SKIP
7808 | OPTI_TYPE_NOT_ITERATED
7809 | OPTI_TYPE_PREPENDED_SALT
7810 | OPTI_TYPE_RAW_HASH;
7811 dgst_pos0 = 14;
7812 dgst_pos1 = 15;
7813 dgst_pos2 = 6;
7814 dgst_pos3 = 7;
7815 break;
7816
7817 case 1750: hash_type = HASH_TYPE_SHA512;
7818 salt_type = SALT_TYPE_INTERN;
7819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7820 opts_type = OPTS_TYPE_PT_GENERATE_BE
7821 | OPTS_TYPE_ST_ADD80;
7822 kern_type = KERN_TYPE_HMACSHA512_PW;
7823 dgst_size = DGST_SIZE_8_8;
7824 parse_func = hmacsha512_parse_hash;
7825 sort_by_digest = sort_by_digest_8_8;
7826 opti_type = OPTI_TYPE_ZERO_BYTE
7827 | OPTI_TYPE_NOT_ITERATED;
7828 dgst_pos0 = 14;
7829 dgst_pos1 = 15;
7830 dgst_pos2 = 6;
7831 dgst_pos3 = 7;
7832 break;
7833
7834 case 1760: hash_type = HASH_TYPE_SHA512;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS15;
7840 kern_type = KERN_TYPE_HMACSHA512_SLT;
7841 dgst_size = DGST_SIZE_8_8;
7842 parse_func = hmacsha512_parse_hash;
7843 sort_by_digest = sort_by_digest_8_8;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_NOT_ITERATED;
7846 dgst_pos0 = 14;
7847 dgst_pos1 = 15;
7848 dgst_pos2 = 6;
7849 dgst_pos3 = 7;
7850 break;
7851
7852 case 1800: hash_type = HASH_TYPE_SHA512;
7853 salt_type = SALT_TYPE_EMBEDDED;
7854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7855 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7856 kern_type = KERN_TYPE_SHA512CRYPT;
7857 dgst_size = DGST_SIZE_8_8;
7858 parse_func = sha512crypt_parse_hash;
7859 sort_by_digest = sort_by_digest_8_8;
7860 opti_type = OPTI_TYPE_ZERO_BYTE;
7861 dgst_pos0 = 0;
7862 dgst_pos1 = 1;
7863 dgst_pos2 = 2;
7864 dgst_pos3 = 3;
7865 break;
7866
7867 case 2100: hash_type = HASH_TYPE_DCC2;
7868 salt_type = SALT_TYPE_EMBEDDED;
7869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7870 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7871 | OPTS_TYPE_ST_LOWER
7872 | OPTS_TYPE_ST_UNICODE;
7873 kern_type = KERN_TYPE_DCC2;
7874 dgst_size = DGST_SIZE_4_4;
7875 parse_func = dcc2_parse_hash;
7876 sort_by_digest = sort_by_digest_4_4;
7877 opti_type = OPTI_TYPE_ZERO_BYTE;
7878 dgst_pos0 = 0;
7879 dgst_pos1 = 1;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 3;
7882 break;
7883
7884 case 2400: hash_type = HASH_TYPE_MD5;
7885 salt_type = SALT_TYPE_NONE;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7888 kern_type = KERN_TYPE_MD5PIX;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = md5pix_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_NOT_SALTED;
7898 dgst_pos0 = 0;
7899 dgst_pos1 = 3;
7900 dgst_pos2 = 2;
7901 dgst_pos3 = 1;
7902 break;
7903
7904 case 2410: hash_type = HASH_TYPE_MD5;
7905 salt_type = SALT_TYPE_INTERN;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7908 kern_type = KERN_TYPE_MD5ASA;
7909 dgst_size = DGST_SIZE_4_4;
7910 parse_func = md5asa_parse_hash;
7911 sort_by_digest = sort_by_digest_4_4;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED;
7917 dgst_pos0 = 0;
7918 dgst_pos1 = 3;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 1;
7921 break;
7922
7923 case 2500: hash_type = HASH_TYPE_WPA;
7924 salt_type = SALT_TYPE_EMBEDDED;
7925 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7927 kern_type = KERN_TYPE_WPA;
7928 dgst_size = DGST_SIZE_4_4;
7929 parse_func = wpa_parse_hash;
7930 sort_by_digest = sort_by_digest_4_4;
7931 opti_type = OPTI_TYPE_ZERO_BYTE;
7932 dgst_pos0 = 0;
7933 dgst_pos1 = 1;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 3;
7936 break;
7937
7938 case 2600: hash_type = HASH_TYPE_MD5;
7939 salt_type = SALT_TYPE_VIRTUAL;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_LE
7942 | OPTS_TYPE_PT_ADD80
7943 | OPTS_TYPE_PT_ADDBITS14
7944 | OPTS_TYPE_ST_ADD80;
7945 kern_type = KERN_TYPE_MD55_PWSLT1;
7946 dgst_size = DGST_SIZE_4_4;
7947 parse_func = md5md5_parse_hash;
7948 sort_by_digest = sort_by_digest_4_4;
7949 opti_type = OPTI_TYPE_ZERO_BYTE
7950 | OPTI_TYPE_PRECOMPUTE_INIT
7951 | OPTI_TYPE_PRECOMPUTE_MERKLE
7952 | OPTI_TYPE_EARLY_SKIP;
7953 dgst_pos0 = 0;
7954 dgst_pos1 = 3;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 1;
7957 break;
7958
7959 case 2611: hash_type = HASH_TYPE_MD5;
7960 salt_type = SALT_TYPE_INTERN;
7961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE
7963 | OPTS_TYPE_PT_ADD80
7964 | OPTS_TYPE_PT_ADDBITS14
7965 | OPTS_TYPE_ST_ADD80;
7966 kern_type = KERN_TYPE_MD55_PWSLT1;
7967 dgst_size = DGST_SIZE_4_4;
7968 parse_func = vb3_parse_hash;
7969 sort_by_digest = sort_by_digest_4_4;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP;
7974 dgst_pos0 = 0;
7975 dgst_pos1 = 3;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 1;
7978 break;
7979
7980 case 2612: hash_type = HASH_TYPE_MD5;
7981 salt_type = SALT_TYPE_EMBEDDED;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_LE
7984 | OPTS_TYPE_PT_ADD80
7985 | OPTS_TYPE_PT_ADDBITS14
7986 | OPTS_TYPE_ST_ADD80
7987 | OPTS_TYPE_ST_HEX;
7988 kern_type = KERN_TYPE_MD55_PWSLT1;
7989 dgst_size = DGST_SIZE_4_4;
7990 parse_func = phps_parse_hash;
7991 sort_by_digest = sort_by_digest_4_4;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_PRECOMPUTE_INIT
7994 | OPTI_TYPE_PRECOMPUTE_MERKLE
7995 | OPTI_TYPE_EARLY_SKIP;
7996 dgst_pos0 = 0;
7997 dgst_pos1 = 3;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 1;
8000 break;
8001
8002 case 2711: hash_type = HASH_TYPE_MD5;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_LE
8006 | OPTS_TYPE_PT_ADD80
8007 | OPTS_TYPE_PT_ADDBITS14
8008 | OPTS_TYPE_ST_ADD80;
8009 kern_type = KERN_TYPE_MD55_PWSLT2;
8010 dgst_size = DGST_SIZE_4_4;
8011 parse_func = vb30_parse_hash;
8012 sort_by_digest = sort_by_digest_4_4;
8013 opti_type = OPTI_TYPE_ZERO_BYTE
8014 | OPTI_TYPE_PRECOMPUTE_INIT
8015 | OPTI_TYPE_EARLY_SKIP;
8016 dgst_pos0 = 0;
8017 dgst_pos1 = 3;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 1;
8020 break;
8021
8022 case 2811: hash_type = HASH_TYPE_MD5;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_LE
8026 | OPTS_TYPE_PT_ADD80
8027 | OPTS_TYPE_PT_ADDBITS14;
8028 kern_type = KERN_TYPE_MD55_SLTPW;
8029 dgst_size = DGST_SIZE_4_4;
8030 parse_func = ipb2_parse_hash;
8031 sort_by_digest = sort_by_digest_4_4;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_EARLY_SKIP;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 3;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 1;
8039 break;
8040
8041 case 3000: hash_type = HASH_TYPE_LM;
8042 salt_type = SALT_TYPE_NONE;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_PT_UPPER
8046 | OPTS_TYPE_PT_BITSLICE;
8047 kern_type = KERN_TYPE_LM;
8048 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8049 parse_func = lm_parse_hash;
8050 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8053 dgst_pos0 = 0;
8054 dgst_pos1 = 1;
8055 dgst_pos2 = 2;
8056 dgst_pos3 = 3;
8057 break;
8058
8059 case 3100: hash_type = HASH_TYPE_ORACLEH;
8060 salt_type = SALT_TYPE_INTERN;
8061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8062 opts_type = OPTS_TYPE_PT_GENERATE_LE
8063 | OPTS_TYPE_PT_UPPER
8064 | OPTS_TYPE_ST_UPPER;
8065 kern_type = KERN_TYPE_ORACLEH;
8066 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8067 parse_func = oracleh_parse_hash;
8068 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8069 opti_type = OPTI_TYPE_ZERO_BYTE;
8070 dgst_pos0 = 0;
8071 dgst_pos1 = 1;
8072 dgst_pos2 = 2;
8073 dgst_pos3 = 3;
8074 break;
8075
8076 case 3200: hash_type = HASH_TYPE_BCRYPT;
8077 salt_type = SALT_TYPE_EMBEDDED;
8078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_LE
8080 | OPTS_TYPE_ST_GENERATE_LE;
8081 kern_type = KERN_TYPE_BCRYPT;
8082 dgst_size = DGST_SIZE_4_6;
8083 parse_func = bcrypt_parse_hash;
8084 sort_by_digest = sort_by_digest_4_6;
8085 opti_type = OPTI_TYPE_ZERO_BYTE;
8086 dgst_pos0 = 0;
8087 dgst_pos1 = 1;
8088 dgst_pos2 = 2;
8089 dgst_pos3 = 3;
8090 break;
8091
8092 case 3710: hash_type = HASH_TYPE_MD5;
8093 salt_type = SALT_TYPE_INTERN;
8094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_LE
8096 | OPTS_TYPE_PT_ADD80
8097 | OPTS_TYPE_PT_ADDBITS14;
8098 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = md5s_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP;
8106 dgst_pos0 = 0;
8107 dgst_pos1 = 3;
8108 dgst_pos2 = 2;
8109 dgst_pos3 = 1;
8110 break;
8111
8112 case 3711: hash_type = HASH_TYPE_MD5;
8113 salt_type = SALT_TYPE_EMBEDDED;
8114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8115 opts_type = OPTS_TYPE_PT_GENERATE_LE
8116 | OPTS_TYPE_PT_ADD80
8117 | OPTS_TYPE_PT_ADDBITS14;
8118 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8119 dgst_size = DGST_SIZE_4_4;
8120 parse_func = mediawiki_b_parse_hash;
8121 sort_by_digest = sort_by_digest_4_4;
8122 opti_type = OPTI_TYPE_ZERO_BYTE
8123 | OPTI_TYPE_PRECOMPUTE_INIT
8124 | OPTI_TYPE_PRECOMPUTE_MERKLE
8125 | OPTI_TYPE_EARLY_SKIP;
8126 dgst_pos0 = 0;
8127 dgst_pos1 = 3;
8128 dgst_pos2 = 2;
8129 dgst_pos3 = 1;
8130 break;
8131
8132 case 3800: hash_type = HASH_TYPE_MD5;
8133 salt_type = SALT_TYPE_INTERN;
8134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8135 opts_type = OPTS_TYPE_PT_GENERATE_LE
8136 | OPTS_TYPE_ST_ADDBITS14;
8137 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8138 dgst_size = DGST_SIZE_4_4;
8139 parse_func = md5s_parse_hash;
8140 sort_by_digest = sort_by_digest_4_4;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_INIT
8143 | OPTI_TYPE_PRECOMPUTE_MERKLE
8144 | OPTI_TYPE_EARLY_SKIP
8145 | OPTI_TYPE_NOT_ITERATED
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 0;
8148 dgst_pos1 = 3;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 1;
8151 break;
8152
8153 case 4300: hash_type = HASH_TYPE_MD5;
8154 salt_type = SALT_TYPE_VIRTUAL;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_LE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS14
8159 | OPTS_TYPE_ST_ADD80;
8160 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8161 dgst_size = DGST_SIZE_4_4;
8162 parse_func = md5md5_parse_hash;
8163 sort_by_digest = sort_by_digest_4_4;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_EARLY_SKIP;
8168 dgst_pos0 = 0;
8169 dgst_pos1 = 3;
8170 dgst_pos2 = 2;
8171 dgst_pos3 = 1;
8172 break;
8173
8174
8175 case 4400: hash_type = HASH_TYPE_MD5;
8176 salt_type = SALT_TYPE_NONE;
8177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8178 opts_type = OPTS_TYPE_PT_GENERATE_BE
8179 | OPTS_TYPE_PT_ADD80
8180 | OPTS_TYPE_PT_ADDBITS15;
8181 kern_type = KERN_TYPE_MD5_SHA1;
8182 dgst_size = DGST_SIZE_4_4;
8183 parse_func = md5_parse_hash;
8184 sort_by_digest = sort_by_digest_4_4;
8185 opti_type = OPTI_TYPE_ZERO_BYTE
8186 | OPTI_TYPE_PRECOMPUTE_INIT
8187 | OPTI_TYPE_PRECOMPUTE_MERKLE
8188 | OPTI_TYPE_EARLY_SKIP
8189 | OPTI_TYPE_NOT_ITERATED
8190 | OPTI_TYPE_NOT_SALTED
8191 | OPTI_TYPE_RAW_HASH;
8192 dgst_pos0 = 0;
8193 dgst_pos1 = 3;
8194 dgst_pos2 = 2;
8195 dgst_pos3 = 1;
8196 break;
8197
8198 case 4500: hash_type = HASH_TYPE_SHA1;
8199 salt_type = SALT_TYPE_NONE;
8200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_BE
8202 | OPTS_TYPE_PT_ADD80
8203 | OPTS_TYPE_PT_ADDBITS15;
8204 kern_type = KERN_TYPE_SHA11;
8205 dgst_size = DGST_SIZE_4_5;
8206 parse_func = sha1_parse_hash;
8207 sort_by_digest = sort_by_digest_4_5;
8208 opti_type = OPTI_TYPE_ZERO_BYTE
8209 | OPTI_TYPE_PRECOMPUTE_INIT
8210 | OPTI_TYPE_PRECOMPUTE_MERKLE
8211 | OPTI_TYPE_EARLY_SKIP
8212 | OPTI_TYPE_NOT_SALTED;
8213 dgst_pos0 = 3;
8214 dgst_pos1 = 4;
8215 dgst_pos2 = 2;
8216 dgst_pos3 = 1;
8217 break;
8218
8219 case 4700: hash_type = HASH_TYPE_SHA1;
8220 salt_type = SALT_TYPE_NONE;
8221 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE
8223 | OPTS_TYPE_PT_ADD80
8224 | OPTS_TYPE_PT_ADDBITS14;
8225 kern_type = KERN_TYPE_SHA1_MD5;
8226 dgst_size = DGST_SIZE_4_5;
8227 parse_func = sha1_parse_hash;
8228 sort_by_digest = sort_by_digest_4_5;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_PRECOMPUTE_INIT
8231 | OPTI_TYPE_PRECOMPUTE_MERKLE
8232 | OPTI_TYPE_EARLY_SKIP
8233 | OPTI_TYPE_NOT_ITERATED
8234 | OPTI_TYPE_NOT_SALTED
8235 | OPTI_TYPE_RAW_HASH;
8236 dgst_pos0 = 3;
8237 dgst_pos1 = 4;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 1;
8240 break;
8241
8242 case 4800: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_EMBEDDED;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE
8246 | OPTS_TYPE_PT_ADDBITS14;
8247 kern_type = KERN_TYPE_MD5_CHAP;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = chap_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_PRECOMPUTE_INIT
8253 | OPTI_TYPE_PRECOMPUTE_MERKLE
8254 | OPTI_TYPE_MEET_IN_MIDDLE
8255 | OPTI_TYPE_EARLY_SKIP
8256 | OPTI_TYPE_NOT_ITERATED
8257 | OPTI_TYPE_RAW_HASH;
8258 dgst_pos0 = 0;
8259 dgst_pos1 = 3;
8260 dgst_pos2 = 2;
8261 dgst_pos3 = 1;
8262 break;
8263
8264 case 4900: hash_type = HASH_TYPE_SHA1;
8265 salt_type = SALT_TYPE_INTERN;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8268 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8269 dgst_size = DGST_SIZE_4_5;
8270 parse_func = sha1s_parse_hash;
8271 sort_by_digest = sort_by_digest_4_5;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP;
8276 dgst_pos0 = 3;
8277 dgst_pos1 = 4;
8278 dgst_pos2 = 2;
8279 dgst_pos3 = 1;
8280 break;
8281
8282 case 5000: hash_type = HASH_TYPE_KECCAK;
8283 salt_type = SALT_TYPE_EMBEDDED;
8284 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8285 opts_type = OPTS_TYPE_PT_GENERATE_LE
8286 | OPTS_TYPE_PT_ADD01;
8287 kern_type = KERN_TYPE_KECCAK;
8288 dgst_size = DGST_SIZE_8_25;
8289 parse_func = keccak_parse_hash;
8290 sort_by_digest = sort_by_digest_8_25;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_RAW_HASH;
8293 dgst_pos0 = 2;
8294 dgst_pos1 = 3;
8295 dgst_pos2 = 4;
8296 dgst_pos3 = 5;
8297 break;
8298
8299 case 5100: hash_type = HASH_TYPE_MD5H;
8300 salt_type = SALT_TYPE_NONE;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_LE
8303 | OPTS_TYPE_PT_ADD80
8304 | OPTS_TYPE_PT_ADDBITS14;
8305 kern_type = KERN_TYPE_MD5H;
8306 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8307 parse_func = md5half_parse_hash;
8308 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8309 opti_type = OPTI_TYPE_ZERO_BYTE
8310 | OPTI_TYPE_RAW_HASH;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 1;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 3;
8315 break;
8316
8317 case 5200: hash_type = HASH_TYPE_SHA256;
8318 salt_type = SALT_TYPE_EMBEDDED;
8319 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8321 kern_type = KERN_TYPE_PSAFE3;
8322 dgst_size = DGST_SIZE_4_8;
8323 parse_func = psafe3_parse_hash;
8324 sort_by_digest = sort_by_digest_4_8;
8325 opti_type = OPTI_TYPE_ZERO_BYTE;
8326 dgst_pos0 = 0;
8327 dgst_pos1 = 1;
8328 dgst_pos2 = 2;
8329 dgst_pos3 = 3;
8330 break;
8331
8332 case 5300: hash_type = HASH_TYPE_MD5;
8333 salt_type = SALT_TYPE_EMBEDDED;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_LE
8336 | OPTS_TYPE_ST_ADD80;
8337 kern_type = KERN_TYPE_IKEPSK_MD5;
8338 dgst_size = DGST_SIZE_4_4;
8339 parse_func = ikepsk_md5_parse_hash;
8340 sort_by_digest = sort_by_digest_4_4;
8341 opti_type = OPTI_TYPE_ZERO_BYTE;
8342 dgst_pos0 = 0;
8343 dgst_pos1 = 3;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 1;
8346 break;
8347
8348 case 5400: hash_type = HASH_TYPE_SHA1;
8349 salt_type = SALT_TYPE_EMBEDDED;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_BE
8352 | OPTS_TYPE_ST_ADD80;
8353 kern_type = KERN_TYPE_IKEPSK_SHA1;
8354 dgst_size = DGST_SIZE_4_5;
8355 parse_func = ikepsk_sha1_parse_hash;
8356 sort_by_digest = sort_by_digest_4_5;
8357 opti_type = OPTI_TYPE_ZERO_BYTE;
8358 dgst_pos0 = 3;
8359 dgst_pos1 = 4;
8360 dgst_pos2 = 2;
8361 dgst_pos3 = 1;
8362 break;
8363
8364 case 5500: hash_type = HASH_TYPE_NETNTLM;
8365 salt_type = SALT_TYPE_EMBEDDED;
8366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8367 opts_type = OPTS_TYPE_PT_GENERATE_LE
8368 | OPTS_TYPE_PT_ADD80
8369 | OPTS_TYPE_PT_ADDBITS14
8370 | OPTS_TYPE_PT_UNICODE
8371 | OPTS_TYPE_ST_HEX;
8372 kern_type = KERN_TYPE_NETNTLMv1;
8373 dgst_size = DGST_SIZE_4_4;
8374 parse_func = netntlmv1_parse_hash;
8375 sort_by_digest = sort_by_digest_4_4;
8376 opti_type = OPTI_TYPE_ZERO_BYTE
8377 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 1;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 3;
8382 break;
8383
8384 case 5600: hash_type = HASH_TYPE_MD5;
8385 salt_type = SALT_TYPE_EMBEDDED;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_PT_ADD80
8389 | OPTS_TYPE_PT_ADDBITS14
8390 | OPTS_TYPE_PT_UNICODE;
8391 kern_type = KERN_TYPE_NETNTLMv2;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = netntlmv2_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 3;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 1;
8400 break;
8401
8402 case 5700: hash_type = HASH_TYPE_SHA256;
8403 salt_type = SALT_TYPE_NONE;
8404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_BE
8406 | OPTS_TYPE_PT_ADD80
8407 | OPTS_TYPE_PT_ADDBITS15;
8408 kern_type = KERN_TYPE_SHA256;
8409 dgst_size = DGST_SIZE_4_8;
8410 parse_func = cisco4_parse_hash;
8411 sort_by_digest = sort_by_digest_4_8;
8412 opti_type = OPTI_TYPE_ZERO_BYTE
8413 | OPTI_TYPE_PRECOMPUTE_INIT
8414 | OPTI_TYPE_PRECOMPUTE_MERKLE
8415 | OPTI_TYPE_EARLY_SKIP
8416 | OPTI_TYPE_NOT_ITERATED
8417 | OPTI_TYPE_NOT_SALTED
8418 | OPTI_TYPE_RAW_HASH;
8419 dgst_pos0 = 3;
8420 dgst_pos1 = 7;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 6;
8423 break;
8424
8425 case 5800: hash_type = HASH_TYPE_SHA1;
8426 salt_type = SALT_TYPE_INTERN;
8427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8429 | OPTS_TYPE_ST_ADD80;
8430 kern_type = KERN_TYPE_ANDROIDPIN;
8431 dgst_size = DGST_SIZE_4_5;
8432 parse_func = androidpin_parse_hash;
8433 sort_by_digest = sort_by_digest_4_5;
8434 opti_type = OPTI_TYPE_ZERO_BYTE;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 1;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 3;
8439 break;
8440
8441 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8442 salt_type = SALT_TYPE_NONE;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_PT_ADD80;
8446 kern_type = KERN_TYPE_RIPEMD160;
8447 dgst_size = DGST_SIZE_4_5;
8448 parse_func = ripemd160_parse_hash;
8449 sort_by_digest = sort_by_digest_4_5;
8450 opti_type = OPTI_TYPE_ZERO_BYTE;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 1;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 3;
8455 break;
8456
8457 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8458 salt_type = SALT_TYPE_NONE;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_BE
8461 | OPTS_TYPE_PT_ADD80;
8462 kern_type = KERN_TYPE_WHIRLPOOL;
8463 dgst_size = DGST_SIZE_4_16;
8464 parse_func = whirlpool_parse_hash;
8465 sort_by_digest = sort_by_digest_4_16;
8466 opti_type = OPTI_TYPE_ZERO_BYTE;
8467 dgst_pos0 = 0;
8468 dgst_pos1 = 1;
8469 dgst_pos2 = 2;
8470 dgst_pos3 = 3;
8471 break;
8472
8473 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8474 salt_type = SALT_TYPE_EMBEDDED;
8475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8477 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8478 dgst_size = DGST_SIZE_4_5;
8479 parse_func = truecrypt_parse_hash_2k;
8480 sort_by_digest = sort_by_digest_4_5;
8481 opti_type = OPTI_TYPE_ZERO_BYTE;
8482 dgst_pos0 = 0;
8483 dgst_pos1 = 1;
8484 dgst_pos2 = 2;
8485 dgst_pos3 = 3;
8486 break;
8487
8488 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8489 salt_type = SALT_TYPE_EMBEDDED;
8490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8492 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8493 dgst_size = DGST_SIZE_4_5;
8494 parse_func = truecrypt_parse_hash_2k;
8495 sort_by_digest = sort_by_digest_4_5;
8496 opti_type = OPTI_TYPE_ZERO_BYTE;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 1;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 3;
8501 break;
8502
8503 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8507 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8508 dgst_size = DGST_SIZE_4_5;
8509 parse_func = truecrypt_parse_hash_2k;
8510 sort_by_digest = sort_by_digest_4_5;
8511 opti_type = OPTI_TYPE_ZERO_BYTE;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 1;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 3;
8516 break;
8517
8518 case 6221: hash_type = HASH_TYPE_SHA512;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8522 kern_type = KERN_TYPE_TCSHA512_XTS512;
8523 dgst_size = DGST_SIZE_8_8;
8524 parse_func = truecrypt_parse_hash_1k;
8525 sort_by_digest = sort_by_digest_8_8;
8526 opti_type = OPTI_TYPE_ZERO_BYTE;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 6222: hash_type = HASH_TYPE_SHA512;
8534 salt_type = SALT_TYPE_EMBEDDED;
8535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8537 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8538 dgst_size = DGST_SIZE_8_8;
8539 parse_func = truecrypt_parse_hash_1k;
8540 sort_by_digest = sort_by_digest_8_8;
8541 opti_type = OPTI_TYPE_ZERO_BYTE;
8542 dgst_pos0 = 0;
8543 dgst_pos1 = 1;
8544 dgst_pos2 = 2;
8545 dgst_pos3 = 3;
8546 break;
8547
8548 case 6223: hash_type = HASH_TYPE_SHA512;
8549 salt_type = SALT_TYPE_EMBEDDED;
8550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8552 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8553 dgst_size = DGST_SIZE_8_8;
8554 parse_func = truecrypt_parse_hash_1k;
8555 sort_by_digest = sort_by_digest_8_8;
8556 opti_type = OPTI_TYPE_ZERO_BYTE;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 1;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 3;
8561 break;
8562
8563 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8567 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8568 dgst_size = DGST_SIZE_4_8;
8569 parse_func = truecrypt_parse_hash_1k;
8570 sort_by_digest = sort_by_digest_4_8;
8571 opti_type = OPTI_TYPE_ZERO_BYTE;
8572 dgst_pos0 = 0;
8573 dgst_pos1 = 1;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 3;
8576 break;
8577
8578 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8579 salt_type = SALT_TYPE_EMBEDDED;
8580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8582 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8583 dgst_size = DGST_SIZE_4_8;
8584 parse_func = truecrypt_parse_hash_1k;
8585 sort_by_digest = sort_by_digest_4_8;
8586 opti_type = OPTI_TYPE_ZERO_BYTE;
8587 dgst_pos0 = 0;
8588 dgst_pos1 = 1;
8589 dgst_pos2 = 2;
8590 dgst_pos3 = 3;
8591 break;
8592
8593 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8594 salt_type = SALT_TYPE_EMBEDDED;
8595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8597 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8598 dgst_size = DGST_SIZE_4_8;
8599 parse_func = truecrypt_parse_hash_1k;
8600 sort_by_digest = sort_by_digest_4_8;
8601 opti_type = OPTI_TYPE_ZERO_BYTE;
8602 dgst_pos0 = 0;
8603 dgst_pos1 = 1;
8604 dgst_pos2 = 2;
8605 dgst_pos3 = 3;
8606 break;
8607
8608 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8609 salt_type = SALT_TYPE_EMBEDDED;
8610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8611 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8612 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8613 dgst_size = DGST_SIZE_4_5;
8614 parse_func = truecrypt_parse_hash_1k;
8615 sort_by_digest = sort_by_digest_4_5;
8616 opti_type = OPTI_TYPE_ZERO_BYTE;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 1;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 3;
8621 break;
8622
8623 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8624 salt_type = SALT_TYPE_EMBEDDED;
8625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = truecrypt_parse_hash_1k;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 1;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 3;
8636 break;
8637
8638 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8639 salt_type = SALT_TYPE_EMBEDDED;
8640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8642 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8643 dgst_size = DGST_SIZE_4_5;
8644 parse_func = truecrypt_parse_hash_1k;
8645 sort_by_digest = sort_by_digest_4_5;
8646 opti_type = OPTI_TYPE_ZERO_BYTE;
8647 dgst_pos0 = 0;
8648 dgst_pos1 = 1;
8649 dgst_pos2 = 2;
8650 dgst_pos3 = 3;
8651 break;
8652
8653 case 6300: hash_type = HASH_TYPE_MD5;
8654 salt_type = SALT_TYPE_EMBEDDED;
8655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8657 kern_type = KERN_TYPE_MD5AIX;
8658 dgst_size = DGST_SIZE_4_4;
8659 parse_func = md5aix_parse_hash;
8660 sort_by_digest = sort_by_digest_4_4;
8661 opti_type = OPTI_TYPE_ZERO_BYTE;
8662 dgst_pos0 = 0;
8663 dgst_pos1 = 1;
8664 dgst_pos2 = 2;
8665 dgst_pos3 = 3;
8666 break;
8667
8668 case 6400: hash_type = HASH_TYPE_SHA256;
8669 salt_type = SALT_TYPE_EMBEDDED;
8670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8671 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8672 kern_type = KERN_TYPE_SHA256AIX;
8673 dgst_size = DGST_SIZE_4_8;
8674 parse_func = sha256aix_parse_hash;
8675 sort_by_digest = sort_by_digest_4_8;
8676 opti_type = OPTI_TYPE_ZERO_BYTE;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 6500: hash_type = HASH_TYPE_SHA512;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_SHA512AIX;
8688 dgst_size = DGST_SIZE_8_8;
8689 parse_func = sha512aix_parse_hash;
8690 sort_by_digest = sort_by_digest_8_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 6600: hash_type = HASH_TYPE_AES;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8702 kern_type = KERN_TYPE_AGILEKEY;
8703 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8704 parse_func = agilekey_parse_hash;
8705 sort_by_digest = sort_by_digest_4_5;
8706 opti_type = OPTI_TYPE_ZERO_BYTE;
8707 dgst_pos0 = 0;
8708 dgst_pos1 = 1;
8709 dgst_pos2 = 2;
8710 dgst_pos3 = 3;
8711 break;
8712
8713 case 6700: hash_type = HASH_TYPE_SHA1;
8714 salt_type = SALT_TYPE_EMBEDDED;
8715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8717 kern_type = KERN_TYPE_SHA1AIX;
8718 dgst_size = DGST_SIZE_4_5;
8719 parse_func = sha1aix_parse_hash;
8720 sort_by_digest = sort_by_digest_4_5;
8721 opti_type = OPTI_TYPE_ZERO_BYTE;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 1;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 3;
8726 break;
8727
8728 case 6800: hash_type = HASH_TYPE_AES;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8732 kern_type = KERN_TYPE_LASTPASS;
8733 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8734 parse_func = lastpass_parse_hash;
8735 sort_by_digest = sort_by_digest_4_8;
8736 opti_type = OPTI_TYPE_ZERO_BYTE;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 1;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 3;
8741 break;
8742
8743 case 6900: hash_type = HASH_TYPE_GOST;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8747 kern_type = KERN_TYPE_GOST;
8748 dgst_size = DGST_SIZE_4_8;
8749 parse_func = gost_parse_hash;
8750 sort_by_digest = sort_by_digest_4_8;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 1;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 3;
8756 break;
8757
8758 case 7100: hash_type = HASH_TYPE_SHA512;
8759 salt_type = SALT_TYPE_EMBEDDED;
8760 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8762 kern_type = KERN_TYPE_PBKDF2_SHA512;
8763 dgst_size = DGST_SIZE_8_16;
8764 parse_func = sha512osx_parse_hash;
8765 sort_by_digest = sort_by_digest_8_16;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 1;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 3;
8771 break;
8772
8773 case 7200: hash_type = HASH_TYPE_SHA512;
8774 salt_type = SALT_TYPE_EMBEDDED;
8775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8777 kern_type = KERN_TYPE_PBKDF2_SHA512;
8778 dgst_size = DGST_SIZE_8_16;
8779 parse_func = sha512grub_parse_hash;
8780 sort_by_digest = sort_by_digest_8_16;
8781 opti_type = OPTI_TYPE_ZERO_BYTE;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 1;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 3;
8786 break;
8787
8788 case 7300: hash_type = HASH_TYPE_SHA1;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_BE
8792 | OPTS_TYPE_ST_ADD80
8793 | OPTS_TYPE_ST_ADDBITS15;
8794 kern_type = KERN_TYPE_RAKP;
8795 dgst_size = DGST_SIZE_4_5;
8796 parse_func = rakp_parse_hash;
8797 sort_by_digest = sort_by_digest_4_5;
8798 opti_type = OPTI_TYPE_ZERO_BYTE
8799 | OPTI_TYPE_NOT_ITERATED;
8800 dgst_pos0 = 3;
8801 dgst_pos1 = 4;
8802 dgst_pos2 = 2;
8803 dgst_pos3 = 1;
8804 break;
8805
8806 case 7400: hash_type = HASH_TYPE_SHA256;
8807 salt_type = SALT_TYPE_EMBEDDED;
8808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8809 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8810 kern_type = KERN_TYPE_SHA256CRYPT;
8811 dgst_size = DGST_SIZE_4_8;
8812 parse_func = sha256crypt_parse_hash;
8813 sort_by_digest = sort_by_digest_4_8;
8814 opti_type = OPTI_TYPE_ZERO_BYTE;
8815 dgst_pos0 = 0;
8816 dgst_pos1 = 1;
8817 dgst_pos2 = 2;
8818 dgst_pos3 = 3;
8819 break;
8820
8821 case 7500: hash_type = HASH_TYPE_KRB5PA;
8822 salt_type = SALT_TYPE_EMBEDDED;
8823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8825 kern_type = KERN_TYPE_KRB5PA;
8826 dgst_size = DGST_SIZE_4_4;
8827 parse_func = krb5pa_parse_hash;
8828 sort_by_digest = sort_by_digest_4_4;
8829 opti_type = OPTI_TYPE_ZERO_BYTE
8830 | OPTI_TYPE_NOT_ITERATED;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 1;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 3;
8835 break;
8836
8837 case 7600: hash_type = HASH_TYPE_SHA1;
8838 salt_type = SALT_TYPE_INTERN;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_BE
8841 | OPTS_TYPE_PT_ADD80
8842 | OPTS_TYPE_PT_ADDBITS15;
8843 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8844 dgst_size = DGST_SIZE_4_5;
8845 parse_func = redmine_parse_hash;
8846 sort_by_digest = sort_by_digest_4_5;
8847 opti_type = OPTI_TYPE_ZERO_BYTE
8848 | OPTI_TYPE_PRECOMPUTE_INIT
8849 | OPTI_TYPE_EARLY_SKIP
8850 | OPTI_TYPE_NOT_ITERATED
8851 | OPTI_TYPE_PREPENDED_SALT;
8852 dgst_pos0 = 3;
8853 dgst_pos1 = 4;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 1;
8856 break;
8857
8858 case 7700: hash_type = HASH_TYPE_SAPB;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE
8862 | OPTS_TYPE_PT_UPPER
8863 | OPTS_TYPE_ST_UPPER;
8864 kern_type = KERN_TYPE_SAPB;
8865 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8866 parse_func = sapb_parse_hash;
8867 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8868 opti_type = OPTI_TYPE_ZERO_BYTE
8869 | OPTI_TYPE_PRECOMPUTE_INIT
8870 | OPTI_TYPE_NOT_ITERATED;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 7800: hash_type = HASH_TYPE_SAPG;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_BE
8881 | OPTS_TYPE_ST_ADD80
8882 | OPTS_TYPE_ST_UPPER;
8883 kern_type = KERN_TYPE_SAPG;
8884 dgst_size = DGST_SIZE_4_5;
8885 parse_func = sapg_parse_hash;
8886 sort_by_digest = sort_by_digest_4_5;
8887 opti_type = OPTI_TYPE_ZERO_BYTE
8888 | OPTI_TYPE_PRECOMPUTE_INIT
8889 | OPTI_TYPE_NOT_ITERATED;
8890 dgst_pos0 = 3;
8891 dgst_pos1 = 4;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 1;
8894 break;
8895
8896 case 7900: hash_type = HASH_TYPE_SHA512;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8900 kern_type = KERN_TYPE_DRUPAL7;
8901 dgst_size = DGST_SIZE_8_8;
8902 parse_func = drupal7_parse_hash;
8903 sort_by_digest = sort_by_digest_8_8;
8904 opti_type = OPTI_TYPE_ZERO_BYTE;
8905 dgst_pos0 = 0;
8906 dgst_pos1 = 1;
8907 dgst_pos2 = 2;
8908 dgst_pos3 = 3;
8909 break;
8910
8911 case 8000: hash_type = HASH_TYPE_SHA256;
8912 salt_type = SALT_TYPE_EMBEDDED;
8913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8914 opts_type = OPTS_TYPE_PT_GENERATE_BE
8915 | OPTS_TYPE_PT_UNICODE
8916 | OPTS_TYPE_ST_ADD80
8917 | OPTS_TYPE_ST_HEX;
8918 kern_type = KERN_TYPE_SYBASEASE;
8919 dgst_size = DGST_SIZE_4_8;
8920 parse_func = sybasease_parse_hash;
8921 sort_by_digest = sort_by_digest_4_8;
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_INIT
8924 | OPTI_TYPE_EARLY_SKIP
8925 | OPTI_TYPE_NOT_ITERATED
8926 | OPTI_TYPE_RAW_HASH;
8927 dgst_pos0 = 3;
8928 dgst_pos1 = 7;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 6;
8931 break;
8932
8933 case 8100: hash_type = HASH_TYPE_SHA1;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8937 kern_type = KERN_TYPE_NETSCALER;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = netscaler_parse_hash;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE
8942 | OPTI_TYPE_PRECOMPUTE_INIT
8943 | OPTI_TYPE_PRECOMPUTE_MERKLE
8944 | OPTI_TYPE_EARLY_SKIP
8945 | OPTI_TYPE_NOT_ITERATED
8946 | OPTI_TYPE_PREPENDED_SALT
8947 | OPTI_TYPE_RAW_HASH;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8200: hash_type = HASH_TYPE_SHA256;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8958 kern_type = KERN_TYPE_CLOUDKEY;
8959 dgst_size = DGST_SIZE_4_8;
8960 parse_func = cloudkey_parse_hash;
8961 sort_by_digest = sort_by_digest_4_8;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 8300: hash_type = HASH_TYPE_SHA1;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE
8973 | OPTS_TYPE_ST_HEX
8974 | OPTS_TYPE_ST_ADD80;
8975 kern_type = KERN_TYPE_NSEC3;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = nsec3_parse_hash;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 3;
8981 dgst_pos1 = 4;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 1;
8984 break;
8985
8986 case 8400: hash_type = HASH_TYPE_SHA1;
8987 salt_type = SALT_TYPE_INTERN;
8988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_BE
8990 | OPTS_TYPE_PT_ADD80
8991 | OPTS_TYPE_PT_ADDBITS15;
8992 kern_type = KERN_TYPE_WBB3;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = wbb3_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE
8997 | OPTI_TYPE_PRECOMPUTE_INIT
8998 | OPTI_TYPE_NOT_ITERATED;
8999 dgst_pos0 = 3;
9000 dgst_pos1 = 4;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 1;
9003 break;
9004
9005 case 8500: hash_type = HASH_TYPE_DESRACF;
9006 salt_type = SALT_TYPE_EMBEDDED;
9007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE
9009 | OPTS_TYPE_ST_UPPER;
9010 kern_type = KERN_TYPE_RACF;
9011 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9012 parse_func = racf_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9014 opti_type = OPTI_TYPE_ZERO_BYTE
9015 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9016 dgst_pos0 = 0;
9017 dgst_pos1 = 1;
9018 dgst_pos2 = 2;
9019 dgst_pos3 = 3;
9020 break;
9021
9022 case 8600: hash_type = HASH_TYPE_LOTUS5;
9023 salt_type = SALT_TYPE_NONE;
9024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9026 kern_type = KERN_TYPE_LOTUS5;
9027 dgst_size = DGST_SIZE_4_4;
9028 parse_func = lotus5_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4;
9030 opti_type = OPTI_TYPE_EARLY_SKIP
9031 | OPTI_TYPE_NOT_ITERATED
9032 | OPTI_TYPE_NOT_SALTED
9033 | OPTI_TYPE_RAW_HASH;
9034 dgst_pos0 = 0;
9035 dgst_pos1 = 1;
9036 dgst_pos2 = 2;
9037 dgst_pos3 = 3;
9038 break;
9039
9040 case 8700: hash_type = HASH_TYPE_LOTUS6;
9041 salt_type = SALT_TYPE_EMBEDDED;
9042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9043 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9044 kern_type = KERN_TYPE_LOTUS6;
9045 dgst_size = DGST_SIZE_4_4;
9046 parse_func = lotus6_parse_hash;
9047 sort_by_digest = sort_by_digest_4_4;
9048 opti_type = OPTI_TYPE_EARLY_SKIP
9049 | OPTI_TYPE_NOT_ITERATED
9050 | OPTI_TYPE_RAW_HASH;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_ANDROIDFDE;
9062 dgst_size = DGST_SIZE_4_4;
9063 parse_func = androidfde_parse_hash;
9064 sort_by_digest = sort_by_digest_4_4;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 8900: hash_type = HASH_TYPE_SCRYPT;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_SCRYPT;
9077 dgst_size = DGST_SIZE_4_8;
9078 parse_func = scrypt_parse_hash;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 9000: hash_type = HASH_TYPE_SHA1;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE
9091 | OPTS_TYPE_ST_GENERATE_LE;
9092 kern_type = KERN_TYPE_PSAFE2;
9093 dgst_size = DGST_SIZE_4_5;
9094 parse_func = psafe2_parse_hash;
9095 sort_by_digest = sort_by_digest_4_5;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 9100: hash_type = HASH_TYPE_LOTUS8;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_LOTUS8;
9108 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9109 parse_func = lotus8_parse_hash;
9110 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 9200: hash_type = HASH_TYPE_SHA256;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA256;
9123 dgst_size = DGST_SIZE_4_32;
9124 parse_func = cisco8_parse_hash;
9125 sort_by_digest = sort_by_digest_4_32;
9126 opti_type = OPTI_TYPE_ZERO_BYTE;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 9300: hash_type = HASH_TYPE_SCRYPT;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9137 kern_type = KERN_TYPE_SCRYPT;
9138 dgst_size = DGST_SIZE_4_8;
9139 parse_func = cisco9_parse_hash;
9140 sort_by_digest = sort_by_digest_4_8;
9141 opti_type = OPTI_TYPE_ZERO_BYTE;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9152 kern_type = KERN_TYPE_OFFICE2007;
9153 dgst_size = DGST_SIZE_4_4;
9154 parse_func = office2007_parse_hash;
9155 sort_by_digest = sort_by_digest_4_4;
9156 opti_type = OPTI_TYPE_ZERO_BYTE;
9157 dgst_pos0 = 0;
9158 dgst_pos1 = 1;
9159 dgst_pos2 = 2;
9160 dgst_pos3 = 3;
9161 break;
9162
9163 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9164 salt_type = SALT_TYPE_EMBEDDED;
9165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9167 kern_type = KERN_TYPE_OFFICE2010;
9168 dgst_size = DGST_SIZE_4_4;
9169 parse_func = office2010_parse_hash;
9170 sort_by_digest = sort_by_digest_4_4;
9171 opti_type = OPTI_TYPE_ZERO_BYTE;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9179 salt_type = SALT_TYPE_EMBEDDED;
9180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_OFFICE2013;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = office2013_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE
9197 | OPTS_TYPE_PT_ADD80
9198 | OPTS_TYPE_PT_UNICODE;
9199 kern_type = KERN_TYPE_OLDOFFICE01;
9200 dgst_size = DGST_SIZE_4_4;
9201 parse_func = oldoffice01_parse_hash;
9202 sort_by_digest = sort_by_digest_4_4;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_PRECOMPUTE_INIT
9205 | OPTI_TYPE_NOT_ITERATED;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE
9216 | OPTS_TYPE_PT_ADD80;
9217 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9218 dgst_size = DGST_SIZE_4_4;
9219 parse_func = oldoffice01cm1_parse_hash;
9220 sort_by_digest = sort_by_digest_4_4;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_NOT_ITERATED;
9224 dgst_pos0 = 0;
9225 dgst_pos1 = 1;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 3;
9228 break;
9229
9230 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9231 salt_type = SALT_TYPE_EMBEDDED;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_LE
9234 | OPTS_TYPE_PT_ADD80
9235 | OPTS_TYPE_PT_UNICODE
9236 | OPTS_TYPE_PT_NEVERCRACK;
9237 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9238 dgst_size = DGST_SIZE_4_4;
9239 parse_func = oldoffice01cm2_parse_hash;
9240 sort_by_digest = sort_by_digest_4_4;
9241 opti_type = OPTI_TYPE_ZERO_BYTE
9242 | OPTI_TYPE_PRECOMPUTE_INIT
9243 | OPTI_TYPE_NOT_ITERATED;
9244 dgst_pos0 = 0;
9245 dgst_pos1 = 1;
9246 dgst_pos2 = 2;
9247 dgst_pos3 = 3;
9248 break;
9249
9250 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9251 salt_type = SALT_TYPE_EMBEDDED;
9252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9253 opts_type = OPTS_TYPE_PT_GENERATE_BE
9254 | OPTS_TYPE_PT_ADD80
9255 | OPTS_TYPE_PT_UNICODE;
9256 kern_type = KERN_TYPE_OLDOFFICE34;
9257 dgst_size = DGST_SIZE_4_4;
9258 parse_func = oldoffice34_parse_hash;
9259 sort_by_digest = sort_by_digest_4_4;
9260 opti_type = OPTI_TYPE_ZERO_BYTE
9261 | OPTI_TYPE_PRECOMPUTE_INIT
9262 | OPTI_TYPE_NOT_ITERATED;
9263 dgst_pos0 = 0;
9264 dgst_pos1 = 1;
9265 dgst_pos2 = 2;
9266 dgst_pos3 = 3;
9267 break;
9268
9269 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9270 salt_type = SALT_TYPE_EMBEDDED;
9271 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9273 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9274 dgst_size = DGST_SIZE_4_4;
9275 parse_func = oldoffice34cm1_parse_hash;
9276 sort_by_digest = sort_by_digest_4_4;
9277 opti_type = OPTI_TYPE_ZERO_BYTE
9278 | OPTI_TYPE_PRECOMPUTE_INIT
9279 | OPTI_TYPE_NOT_ITERATED;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_BE
9290 | OPTS_TYPE_PT_ADD80
9291 | OPTS_TYPE_PT_UNICODE
9292 | OPTS_TYPE_PT_NEVERCRACK;
9293 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9294 dgst_size = DGST_SIZE_4_4;
9295 parse_func = oldoffice34cm2_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_INIT
9299 | OPTI_TYPE_NOT_ITERATED;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 9900: hash_type = HASH_TYPE_MD5;
9307 salt_type = SALT_TYPE_NONE;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9310 kern_type = KERN_TYPE_RADMIN2;
9311 dgst_size = DGST_SIZE_4_4;
9312 parse_func = radmin2_parse_hash;
9313 sort_by_digest = sort_by_digest_4_4;
9314 opti_type = OPTI_TYPE_ZERO_BYTE
9315 | OPTI_TYPE_PRECOMPUTE_INIT
9316 | OPTI_TYPE_EARLY_SKIP
9317 | OPTI_TYPE_NOT_ITERATED
9318 | OPTI_TYPE_NOT_SALTED;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 3;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 1;
9323 break;
9324
9325 case 10000: hash_type = HASH_TYPE_SHA256;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_PBKDF2_SHA256;
9330 dgst_size = DGST_SIZE_4_32;
9331 parse_func = djangopbkdf2_parse_hash;
9332 sort_by_digest = sort_by_digest_4_32;
9333 opti_type = OPTI_TYPE_ZERO_BYTE;
9334 dgst_pos0 = 0;
9335 dgst_pos1 = 1;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 3;
9338 break;
9339
9340 case 10100: hash_type = HASH_TYPE_SIPHASH;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9344 kern_type = KERN_TYPE_SIPHASH;
9345 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9346 parse_func = siphash_parse_hash;
9347 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9348 opti_type = OPTI_TYPE_ZERO_BYTE
9349 | OPTI_TYPE_NOT_ITERATED
9350 | OPTI_TYPE_RAW_HASH;
9351 dgst_pos0 = 0;
9352 dgst_pos1 = 1;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 3;
9355 break;
9356
9357 case 10200: hash_type = HASH_TYPE_MD5;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE
9361 | OPTS_TYPE_ST_ADD80
9362 | OPTS_TYPE_ST_ADDBITS14;
9363 kern_type = KERN_TYPE_HMACMD5_PW;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = crammd5_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_NOT_ITERATED;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 3;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 1;
9373 break;
9374
9375 case 10300: hash_type = HASH_TYPE_SHA1;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9379 kern_type = KERN_TYPE_SAPH_SHA1;
9380 dgst_size = DGST_SIZE_4_5;
9381 parse_func = saph_sha1_parse_hash;
9382 sort_by_digest = sort_by_digest_4_5;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 10400: hash_type = HASH_TYPE_PDFU16;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_PDF11;
9395 dgst_size = DGST_SIZE_4_4;
9396 parse_func = pdf11_parse_hash;
9397 sort_by_digest = sort_by_digest_4_4;
9398 opti_type = OPTI_TYPE_ZERO_BYTE
9399 | OPTI_TYPE_NOT_ITERATED;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 10410: hash_type = HASH_TYPE_PDFU16;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9410 kern_type = KERN_TYPE_PDF11CM1;
9411 dgst_size = DGST_SIZE_4_4;
9412 parse_func = pdf11cm1_parse_hash;
9413 sort_by_digest = sort_by_digest_4_4;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_NOT_ITERATED;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 10420: hash_type = HASH_TYPE_PDFU16;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_PDF11CM2;
9427 dgst_size = DGST_SIZE_4_4;
9428 parse_func = pdf11cm2_parse_hash;
9429 sort_by_digest = sort_by_digest_4_4;
9430 opti_type = OPTI_TYPE_ZERO_BYTE
9431 | OPTI_TYPE_NOT_ITERATED;
9432 dgst_pos0 = 0;
9433 dgst_pos1 = 1;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 3;
9436 break;
9437
9438 case 10500: hash_type = HASH_TYPE_PDFU16;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9442 kern_type = KERN_TYPE_PDF14;
9443 dgst_size = DGST_SIZE_4_4;
9444 parse_func = pdf14_parse_hash;
9445 sort_by_digest = sort_by_digest_4_4;
9446 opti_type = OPTI_TYPE_ZERO_BYTE
9447 | OPTI_TYPE_NOT_ITERATED;
9448 dgst_pos0 = 0;
9449 dgst_pos1 = 1;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 3;
9452 break;
9453
9454 case 10600: hash_type = HASH_TYPE_SHA256;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_BE
9458 | OPTS_TYPE_ST_ADD80
9459 | OPTS_TYPE_ST_ADDBITS15
9460 | OPTS_TYPE_HASH_COPY;
9461 kern_type = KERN_TYPE_SHA256_PWSLT;
9462 dgst_size = DGST_SIZE_4_8;
9463 parse_func = pdf17l3_parse_hash;
9464 sort_by_digest = sort_by_digest_4_8;
9465 opti_type = OPTI_TYPE_ZERO_BYTE
9466 | OPTI_TYPE_PRECOMPUTE_INIT
9467 | OPTI_TYPE_PRECOMPUTE_MERKLE
9468 | OPTI_TYPE_EARLY_SKIP
9469 | OPTI_TYPE_NOT_ITERATED
9470 | OPTI_TYPE_APPENDED_SALT
9471 | OPTI_TYPE_RAW_HASH;
9472 dgst_pos0 = 3;
9473 dgst_pos1 = 7;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 6;
9476 break;
9477
9478 case 10700: hash_type = HASH_TYPE_PDFU32;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE
9482 | OPTS_TYPE_HASH_COPY;
9483 kern_type = KERN_TYPE_PDF17L8;
9484 dgst_size = DGST_SIZE_4_8;
9485 parse_func = pdf17l8_parse_hash;
9486 sort_by_digest = sort_by_digest_4_8;
9487 opti_type = OPTI_TYPE_ZERO_BYTE
9488 | OPTI_TYPE_NOT_ITERATED;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 10800: hash_type = HASH_TYPE_SHA384;
9496 salt_type = SALT_TYPE_NONE;
9497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_BE
9499 | OPTS_TYPE_PT_ADD80
9500 | OPTS_TYPE_PT_ADDBITS15;
9501 kern_type = KERN_TYPE_SHA384;
9502 dgst_size = DGST_SIZE_8_8;
9503 parse_func = sha384_parse_hash;
9504 sort_by_digest = sort_by_digest_8_8;
9505 opti_type = OPTI_TYPE_ZERO_BYTE
9506 | OPTI_TYPE_PRECOMPUTE_INIT
9507 | OPTI_TYPE_PRECOMPUTE_MERKLE
9508 | OPTI_TYPE_EARLY_SKIP
9509 | OPTI_TYPE_NOT_ITERATED
9510 | OPTI_TYPE_NOT_SALTED
9511 | OPTI_TYPE_RAW_HASH;
9512 dgst_pos0 = 6;
9513 dgst_pos1 = 7;
9514 dgst_pos2 = 4;
9515 dgst_pos3 = 5;
9516 break;
9517
9518 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE
9522 | OPTS_TYPE_ST_BASE64
9523 | OPTS_TYPE_HASH_COPY;
9524 kern_type = KERN_TYPE_PBKDF2_SHA256;
9525 dgst_size = DGST_SIZE_4_32;
9526 parse_func = pbkdf2_sha256_parse_hash;
9527 sort_by_digest = sort_by_digest_4_32;
9528 opti_type = OPTI_TYPE_ZERO_BYTE;
9529 dgst_pos0 = 0;
9530 dgst_pos1 = 1;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 3;
9533 break;
9534
9535 case 11000: hash_type = HASH_TYPE_MD5;
9536 salt_type = SALT_TYPE_INTERN;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE
9539 | OPTS_TYPE_PT_ADD80;
9540 kern_type = KERN_TYPE_PRESTASHOP;
9541 dgst_size = DGST_SIZE_4_4;
9542 parse_func = prestashop_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4;
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_INIT
9546 | OPTI_TYPE_NOT_ITERATED
9547 | OPTI_TYPE_PREPENDED_SALT;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 3;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 1;
9552 break;
9553
9554 case 11100: hash_type = HASH_TYPE_MD5;
9555 salt_type = SALT_TYPE_EMBEDDED;
9556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE
9558 | OPTS_TYPE_ST_ADD80;
9559 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9560 dgst_size = DGST_SIZE_4_4;
9561 parse_func = postgresql_auth_parse_hash;
9562 sort_by_digest = sort_by_digest_4_4;
9563 opti_type = OPTI_TYPE_ZERO_BYTE
9564 | OPTI_TYPE_PRECOMPUTE_INIT
9565 | OPTI_TYPE_PRECOMPUTE_MERKLE
9566 | OPTI_TYPE_EARLY_SKIP;
9567 dgst_pos0 = 0;
9568 dgst_pos1 = 3;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 1;
9571 break;
9572
9573 case 11200: hash_type = HASH_TYPE_SHA1;
9574 salt_type = SALT_TYPE_EMBEDDED;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_BE
9577 | OPTS_TYPE_PT_ADD80
9578 | OPTS_TYPE_ST_HEX;
9579 kern_type = KERN_TYPE_MYSQL_AUTH;
9580 dgst_size = DGST_SIZE_4_5;
9581 parse_func = mysql_auth_parse_hash;
9582 sort_by_digest = sort_by_digest_4_5;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_EARLY_SKIP;
9585 dgst_pos0 = 3;
9586 dgst_pos1 = 4;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 1;
9589 break;
9590
9591 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_ST_HEX
9596 | OPTS_TYPE_ST_ADD80;
9597 kern_type = KERN_TYPE_BITCOIN_WALLET;
9598 dgst_size = DGST_SIZE_4_4;
9599 parse_func = bitcoin_wallet_parse_hash;
9600 sort_by_digest = sort_by_digest_4_4;
9601 opti_type = OPTI_TYPE_ZERO_BYTE;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 1;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 3;
9606 break;
9607
9608 case 11400: hash_type = HASH_TYPE_MD5;
9609 salt_type = SALT_TYPE_EMBEDDED;
9610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE
9612 | OPTS_TYPE_PT_ADD80
9613 | OPTS_TYPE_HASH_COPY;
9614 kern_type = KERN_TYPE_SIP_AUTH;
9615 dgst_size = DGST_SIZE_4_4;
9616 parse_func = sip_auth_parse_hash;
9617 sort_by_digest = sort_by_digest_4_4;
9618 opti_type = OPTI_TYPE_ZERO_BYTE;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 3;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 1;
9623 break;
9624
9625 case 11500: hash_type = HASH_TYPE_CRC32;
9626 salt_type = SALT_TYPE_INTERN;
9627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE
9629 | OPTS_TYPE_ST_GENERATE_LE
9630 | OPTS_TYPE_ST_HEX;
9631 kern_type = KERN_TYPE_CRC32;
9632 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9633 parse_func = crc32_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 11600: hash_type = HASH_TYPE_AES;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_PT_NEVERCRACK;
9647 kern_type = KERN_TYPE_SEVEN_ZIP;
9648 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9649 parse_func = seven_zip_parse_hash;
9650 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9659 salt_type = SALT_TYPE_NONE;
9660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE
9662 | OPTS_TYPE_PT_ADD01;
9663 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9664 dgst_size = DGST_SIZE_4_8;
9665 parse_func = gost2012sbog_256_parse_hash;
9666 sort_by_digest = sort_by_digest_4_8;
9667 opti_type = OPTI_TYPE_ZERO_BYTE;
9668 dgst_pos0 = 0;
9669 dgst_pos1 = 1;
9670 dgst_pos2 = 2;
9671 dgst_pos3 = 3;
9672 break;
9673
9674 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9675 salt_type = SALT_TYPE_NONE;
9676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9677 opts_type = OPTS_TYPE_PT_GENERATE_LE
9678 | OPTS_TYPE_PT_ADD01;
9679 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9680 dgst_size = DGST_SIZE_4_16;
9681 parse_func = gost2012sbog_512_parse_hash;
9682 sort_by_digest = sort_by_digest_4_16;
9683 opti_type = OPTI_TYPE_ZERO_BYTE;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_ST_BASE64
9695 | OPTS_TYPE_HASH_COPY;
9696 kern_type = KERN_TYPE_PBKDF2_MD5;
9697 dgst_size = DGST_SIZE_4_32;
9698 parse_func = pbkdf2_md5_parse_hash;
9699 sort_by_digest = sort_by_digest_4_32;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE
9711 | OPTS_TYPE_ST_BASE64
9712 | OPTS_TYPE_HASH_COPY;
9713 kern_type = KERN_TYPE_PBKDF2_SHA1;
9714 dgst_size = DGST_SIZE_4_32;
9715 parse_func = pbkdf2_sha1_parse_hash;
9716 sort_by_digest = sort_by_digest_4_32;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_ST_BASE64
9729 | OPTS_TYPE_HASH_COPY;
9730 kern_type = KERN_TYPE_PBKDF2_SHA512;
9731 dgst_size = DGST_SIZE_8_16;
9732 parse_func = pbkdf2_sha512_parse_hash;
9733 sort_by_digest = sort_by_digest_8_16;
9734 opti_type = OPTI_TYPE_ZERO_BYTE;
9735 dgst_pos0 = 0;
9736 dgst_pos1 = 1;
9737 dgst_pos2 = 2;
9738 dgst_pos3 = 3;
9739 break;
9740
9741 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
9742 salt_type = SALT_TYPE_EMBEDDED;
9743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9744 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9745 kern_type = KERN_TYPE_ECRYPTFS;
9746 dgst_size = DGST_SIZE_8_8;
9747 parse_func = ecryptfs_parse_hash;
9748 sort_by_digest = sort_by_digest_8_8;
9749 opti_type = OPTI_TYPE_ZERO_BYTE;
9750 dgst_pos0 = 0;
9751 dgst_pos1 = 1;
9752 dgst_pos2 = 2;
9753 dgst_pos3 = 3;
9754 break;
9755
9756 case 12300: hash_type = HASH_TYPE_ORACLET;
9757 salt_type = SALT_TYPE_EMBEDDED;
9758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9760 kern_type = KERN_TYPE_ORACLET;
9761 dgst_size = DGST_SIZE_8_16;
9762 parse_func = oraclet_parse_hash;
9763 sort_by_digest = sort_by_digest_8_16;
9764 opti_type = OPTI_TYPE_ZERO_BYTE;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9775 kern_type = KERN_TYPE_BSDICRYPT;
9776 dgst_size = DGST_SIZE_4_4;
9777 parse_func = bsdicrypt_parse_hash;
9778 sort_by_digest = sort_by_digest_4_4;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 12500: hash_type = HASH_TYPE_RAR3HP;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9791 kern_type = KERN_TYPE_RAR3;
9792 dgst_size = DGST_SIZE_4_4;
9793 parse_func = rar3hp_parse_hash;
9794 sort_by_digest = sort_by_digest_4_4;
9795 opti_type = OPTI_TYPE_ZERO_BYTE;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 12600: hash_type = HASH_TYPE_SHA256;
9803 salt_type = SALT_TYPE_INTERN;
9804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_BE
9806 | OPTS_TYPE_PT_ADD80;
9807 kern_type = KERN_TYPE_CF10;
9808 dgst_size = DGST_SIZE_4_8;
9809 parse_func = cf10_parse_hash;
9810 sort_by_digest = sort_by_digest_4_8;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_EARLY_SKIP
9814 | OPTI_TYPE_NOT_ITERATED;
9815 dgst_pos0 = 3;
9816 dgst_pos1 = 7;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 6;
9819 break;
9820
9821 case 12700: hash_type = HASH_TYPE_AES;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_LE
9825 | OPTS_TYPE_HASH_COPY;
9826 kern_type = KERN_TYPE_MYWALLET;
9827 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9828 parse_func = mywallet_parse_hash;
9829 sort_by_digest = sort_by_digest_4_5;
9830 opti_type = OPTI_TYPE_ZERO_BYTE;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9841 kern_type = KERN_TYPE_MS_DRSR;
9842 dgst_size = DGST_SIZE_4_8;
9843 parse_func = ms_drsr_parse_hash;
9844 sort_by_digest = sort_by_digest_4_8;
9845 opti_type = OPTI_TYPE_ZERO_BYTE;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9856 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
9857 dgst_size = DGST_SIZE_4_8;
9858 parse_func = androidfde_samsung_parse_hash;
9859 sort_by_digest = sort_by_digest_4_8;
9860 opti_type = OPTI_TYPE_ZERO_BYTE;
9861 dgst_pos0 = 0;
9862 dgst_pos1 = 1;
9863 dgst_pos2 = 2;
9864 dgst_pos3 = 3;
9865 break;
9866
9867 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
9868 salt_type = SALT_TYPE_EMBEDDED;
9869 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9870 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9871 kern_type = KERN_TYPE_RAR5;
9872 dgst_size = DGST_SIZE_4_4;
9873 parse_func = rar5_parse_hash;
9874 sort_by_digest = sort_by_digest_4_4;
9875 opti_type = OPTI_TYPE_ZERO_BYTE;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 default: usage_mini_print (PROGNAME); return (-1);
9883 }
9884
9885 /**
9886 * transpose
9887 */
9888
9889 data.parse_func = parse_func;
9890
9891 /**
9892 * misc stuff
9893 */
9894
9895 if (hex_salt)
9896 {
9897 if (salt_type == SALT_TYPE_INTERN)
9898 {
9899 opts_type |= OPTS_TYPE_ST_HEX;
9900 }
9901 else
9902 {
9903 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9904
9905 return (-1);
9906 }
9907 }
9908
9909 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9910 | (salt_type == SALT_TYPE_EXTERN)
9911 | (salt_type == SALT_TYPE_EMBEDDED)
9912 | (salt_type == SALT_TYPE_VIRTUAL));
9913
9914 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9915
9916 data.hash_type = hash_type;
9917 data.attack_mode = attack_mode;
9918 data.attack_kern = attack_kern;
9919 data.attack_exec = attack_exec;
9920 data.kern_type = kern_type;
9921 data.opts_type = opts_type;
9922 data.dgst_size = dgst_size;
9923 data.salt_type = salt_type;
9924 data.isSalted = isSalted;
9925 data.sort_by_digest = sort_by_digest;
9926 data.dgst_pos0 = dgst_pos0;
9927 data.dgst_pos1 = dgst_pos1;
9928 data.dgst_pos2 = dgst_pos2;
9929 data.dgst_pos3 = dgst_pos3;
9930
9931 esalt_size = 0;
9932
9933 switch (hash_mode)
9934 {
9935 case 2500: esalt_size = sizeof (wpa_t); break;
9936 case 5300: esalt_size = sizeof (ikepsk_t); break;
9937 case 5400: esalt_size = sizeof (ikepsk_t); break;
9938 case 5500: esalt_size = sizeof (netntlm_t); break;
9939 case 5600: esalt_size = sizeof (netntlm_t); break;
9940 case 6211:
9941 case 6212:
9942 case 6213:
9943 case 6221:
9944 case 6222:
9945 case 6223:
9946 case 6231:
9947 case 6232:
9948 case 6233:
9949 case 6241:
9950 case 6242:
9951 case 6243: esalt_size = sizeof (tc_t); break;
9952 case 6600: esalt_size = sizeof (agilekey_t); break;
9953 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9954 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9955 case 7300: esalt_size = sizeof (rakp_t); break;
9956 case 7500: esalt_size = sizeof (krb5pa_t); break;
9957 case 8200: esalt_size = sizeof (cloudkey_t); break;
9958 case 8800: esalt_size = sizeof (androidfde_t); break;
9959 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9960 case 9400: esalt_size = sizeof (office2007_t); break;
9961 case 9500: esalt_size = sizeof (office2010_t); break;
9962 case 9600: esalt_size = sizeof (office2013_t); break;
9963 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9964 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9965 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9966 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9967 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9968 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9969 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9970 case 10200: esalt_size = sizeof (cram_md5_t); break;
9971 case 10400: esalt_size = sizeof (pdf_t); break;
9972 case 10410: esalt_size = sizeof (pdf_t); break;
9973 case 10420: esalt_size = sizeof (pdf_t); break;
9974 case 10500: esalt_size = sizeof (pdf_t); break;
9975 case 10600: esalt_size = sizeof (pdf_t); break;
9976 case 10700: esalt_size = sizeof (pdf_t); break;
9977 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9978 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9979 case 11400: esalt_size = sizeof (sip_t); break;
9980 case 11600: esalt_size = sizeof (seven_zip_t); break;
9981 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9982 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9983 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9984 case 13000: esalt_size = sizeof (rar5_t); break;
9985 }
9986
9987 data.esalt_size = esalt_size;
9988
9989 /**
9990 * choose dictionary parser
9991 */
9992
9993 if (hash_type == HASH_TYPE_LM)
9994 {
9995 get_next_word_func = get_next_word_lm;
9996 }
9997 else if (opts_type & OPTS_TYPE_PT_UPPER)
9998 {
9999 get_next_word_func = get_next_word_uc;
10000 }
10001 else
10002 {
10003 get_next_word_func = get_next_word_std;
10004 }
10005
10006 /**
10007 * dictstat
10008 */
10009
10010 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10011
10012 #ifdef _POSIX
10013 size_t dictstat_nmemb = 0;
10014 #endif
10015
10016 #ifdef _WIN
10017 uint dictstat_nmemb = 0;
10018 #endif
10019
10020 char dictstat[256];
10021
10022 FILE *dictstat_fp = NULL;
10023
10024 if (keyspace == 0)
10025 {
10026 memset (dictstat, 0, sizeof (dictstat));
10027
10028 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
10029
10030 dictstat_fp = fopen (dictstat, "rb");
10031
10032 if (dictstat_fp)
10033 {
10034 #ifdef _POSIX
10035 struct stat tmpstat;
10036
10037 fstat (fileno (dictstat_fp), &tmpstat);
10038 #endif
10039
10040 #ifdef _WIN
10041 struct stat64 tmpstat;
10042
10043 _fstat64 (fileno (dictstat_fp), &tmpstat);
10044 #endif
10045
10046 if (tmpstat.st_mtime < COMPTIME)
10047 {
10048 /* with v0.15 the format changed so we have to ensure user is using a good version
10049 since there is no version-header in the dictstat file */
10050
10051 fclose (dictstat_fp);
10052
10053 unlink (dictstat);
10054 }
10055 else
10056 {
10057 while (!feof (dictstat_fp))
10058 {
10059 dictstat_t d;
10060
10061 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10062
10063 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10064
10065 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10066 {
10067 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10068
10069 return -1;
10070 }
10071 }
10072
10073 fclose (dictstat_fp);
10074 }
10075 }
10076 }
10077
10078 /**
10079 * potfile
10080 */
10081
10082 char potfile[256] = { 0 };
10083
10084 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10085
10086 data.pot_fp = NULL;
10087
10088 FILE *out_fp = NULL;
10089 FILE *pot_fp = NULL;
10090
10091 if (show == 1 || left == 1)
10092 {
10093 pot_fp = fopen (potfile, "rb");
10094
10095 if (pot_fp == NULL)
10096 {
10097 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10098
10099 return (-1);
10100 }
10101
10102 if (outfile != NULL)
10103 {
10104 if ((out_fp = fopen (outfile, "ab")) == NULL)
10105 {
10106 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10107
10108 fclose (pot_fp);
10109
10110 return (-1);
10111 }
10112 }
10113 else
10114 {
10115 out_fp = stdout;
10116 }
10117 }
10118 else
10119 {
10120 if (potfile_disable == 0)
10121 {
10122 pot_fp = fopen (potfile, "ab");
10123
10124 if (pot_fp == NULL)
10125 {
10126 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10127
10128 return (-1);
10129 }
10130
10131 data.pot_fp = pot_fp;
10132 }
10133 }
10134
10135 pot_t *pot = NULL;
10136
10137 uint pot_cnt = 0;
10138 uint pot_avail = 0;
10139
10140 if (show == 1 || left == 1)
10141 {
10142 SUPPRESS_OUTPUT = 1;
10143
10144 pot_avail = count_lines (pot_fp);
10145
10146 rewind (pot_fp);
10147
10148 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10149
10150 uint pot_hashes_avail = 0;
10151
10152 uint line_num = 0;
10153
10154 while (!feof (pot_fp))
10155 {
10156 line_num++;
10157
10158 char line_buf[BUFSIZ];
10159
10160 int line_len = fgetl (pot_fp, line_buf);
10161
10162 if (line_len == 0) continue;
10163
10164 char *plain_buf = line_buf + line_len;
10165
10166 pot_t *pot_ptr = &pot[pot_cnt];
10167
10168 hash_t *hashes_buf = &pot_ptr->hash;
10169
10170 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10171 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10172
10173 if (pot_cnt == pot_hashes_avail)
10174 {
10175 uint pos = 0;
10176
10177 for (pos = 0; pos < INCR_POT; pos++)
10178 {
10179 if ((pot_cnt + pos) >= pot_avail) break;
10180
10181 pot_t *tmp_pot = &pot[pot_cnt + pos];
10182
10183 hash_t *tmp_hash = &tmp_pot->hash;
10184
10185 tmp_hash->digest = mymalloc (dgst_size);
10186
10187 if (isSalted)
10188 {
10189 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10190 }
10191
10192 if (esalt_size)
10193 {
10194 tmp_hash->esalt = mymalloc (esalt_size);
10195 }
10196
10197 pot_hashes_avail++;
10198 }
10199 }
10200
10201 int plain_len = 0;
10202
10203 int parser_status;
10204
10205 int iter = MAX_CUT_TRIES;
10206
10207 do
10208 {
10209 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10210 {
10211 if (line_buf[i] == ':')
10212 {
10213 line_len--;
10214
10215 break;
10216 }
10217 }
10218
10219 if (data.hash_mode != 2500)
10220 {
10221 parser_status = parse_func (line_buf, line_len, hashes_buf);
10222 }
10223 else
10224 {
10225 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10226
10227 if (line_len > max_salt_size)
10228 {
10229 parser_status = PARSER_GLOBAL_LENGTH;
10230 }
10231 else
10232 {
10233 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10234
10235 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10236
10237 hashes_buf->salt->salt_len = line_len;
10238
10239 parser_status = PARSER_OK;
10240 }
10241 }
10242
10243 // if NOT parsed without error, we add the ":" to the plain
10244
10245 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10246 {
10247 plain_len++;
10248 plain_buf--;
10249 }
10250
10251 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10252
10253 if (parser_status < PARSER_GLOBAL_ZERO)
10254 {
10255 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10256
10257 continue;
10258 }
10259
10260 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10261
10262 pot_ptr->plain_len = plain_len;
10263
10264 pot_cnt++;
10265 }
10266
10267 fclose (pot_fp);
10268
10269 SUPPRESS_OUTPUT = 0;
10270
10271 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10272 }
10273
10274 /**
10275 * kernel accel and loops auto adjustment
10276 */
10277
10278 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10279 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10280
10281 if (workload_profile == 1)
10282 {
10283 kernel_loops /= 8;
10284 kernel_accel /= 4;
10285
10286 if (kernel_loops == 0) kernel_loops = 8;
10287 if (kernel_accel == 0) kernel_accel = 2;
10288 }
10289 else if (workload_profile == 3)
10290 {
10291 kernel_loops *= 8;
10292 kernel_accel *= 4;
10293
10294 if (kernel_loops > 1024) kernel_loops = 1024;
10295 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10296 }
10297
10298 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10299
10300 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10301 {
10302 kernel_loops = 1024;
10303 }
10304
10305 if (hash_mode == 12500)
10306 {
10307 kernel_loops = ROUNDS_RAR3 / 16;
10308 }
10309
10310 data.kernel_accel = kernel_accel;
10311 data.kernel_loops = kernel_loops;
10312
10313 /**
10314 * word len
10315 */
10316
10317 uint pw_min = PW_MIN;
10318 uint pw_max = PW_MAX;
10319
10320 switch (hash_mode)
10321 {
10322 case 400: if (pw_max > 40) pw_max = 40;
10323 break;
10324 case 500: if (pw_max > 16) pw_max = 16;
10325 break;
10326 case 1500: if (pw_max > 8) pw_max = 8;
10327 break;
10328 case 1600: if (pw_max > 16) pw_max = 16;
10329 break;
10330 case 1800: if (pw_max > 16) pw_max = 16;
10331 break;
10332 case 2100: if (pw_max > 16) pw_max = 16;
10333 break;
10334 case 2500: if (pw_min < 8) pw_min = 8;
10335 break;
10336 case 3000: if (pw_max > 7) pw_max = 7;
10337 break;
10338 case 5200: if (pw_max > 24) pw_max = 24;
10339 break;
10340 case 5800: if (pw_max > 16) pw_max = 16;
10341 break;
10342 case 6300: if (pw_max > 16) pw_max = 16;
10343 break;
10344 case 7400: if (pw_max > 16) pw_max = 16;
10345 break;
10346 case 7900: if (pw_max > 48) pw_max = 48;
10347 break;
10348 case 8500: if (pw_max > 8) pw_max = 8;
10349 break;
10350 case 8600: if (pw_max > 16) pw_max = 16;
10351 break;
10352 case 9710: pw_min = 5;
10353 pw_max = 5;
10354 break;
10355 case 9810: pw_min = 5;
10356 pw_max = 5;
10357 break;
10358 case 10410: pw_min = 5;
10359 pw_max = 5;
10360 break;
10361 case 10300: if (pw_max < 3) pw_min = 3;
10362 if (pw_max > 40) pw_max = 40;
10363 break;
10364 case 10500: if (pw_max < 3) pw_min = 3;
10365 if (pw_max > 40) pw_max = 40;
10366 break;
10367 case 10700: if (pw_max > 16) pw_max = 16;
10368 break;
10369 case 11300: if (pw_max > 40) pw_max = 40;
10370 break;
10371 case 12500: if (pw_max > 20) pw_max = 20;
10372 break;
10373 case 12800: if (pw_max > 24) pw_max = 24;
10374 break;
10375 }
10376
10377 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10378 {
10379 switch (attack_kern)
10380 {
10381 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10382 break;
10383 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10384 break;
10385 }
10386 }
10387
10388 /**
10389 * charsets : keep them together for more easy maintainnce
10390 */
10391
10392 cs_t mp_sys[6] = { { { 0 }, 0 } };
10393 cs_t mp_usr[4] = { { { 0 }, 0 } };
10394
10395 mp_setup_sys (mp_sys);
10396
10397 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10398 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10399 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10400 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10401
10402 /**
10403 * load hashes, part I: find input mode, count hashes
10404 */
10405
10406 uint hashlist_mode = 0;
10407 uint hashlist_format = HLFMT_HASHCAT;
10408
10409 uint hashes_avail = 0;
10410
10411 if (benchmark == 0)
10412 {
10413 struct stat f;
10414
10415 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10416
10417 if ((hash_mode == 2500) ||
10418 (hash_mode == 5200) ||
10419 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10420 (hash_mode == 9000))
10421 {
10422 hashlist_mode = HL_MODE_ARG;
10423
10424 char *hashfile = myargv[optind];
10425
10426 data.hashfile = hashfile;
10427
10428 logfile_top_var_string ("target", hashfile);
10429 }
10430
10431 if (hashlist_mode == HL_MODE_ARG)
10432 {
10433 if (hash_mode == 2500)
10434 {
10435 struct stat st;
10436
10437 if (stat (data.hashfile, &st) == -1)
10438 {
10439 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10440
10441 return (-1);
10442 }
10443
10444 hashes_avail = st.st_size / sizeof (hccap_t);
10445 }
10446 else
10447 {
10448 hashes_avail = 1;
10449 }
10450 }
10451 else if (hashlist_mode == HL_MODE_FILE)
10452 {
10453 char *hashfile = myargv[optind];
10454
10455 data.hashfile = hashfile;
10456
10457 logfile_top_var_string ("target", hashfile);
10458
10459 FILE *fp = NULL;
10460
10461 if ((fp = fopen (hashfile, "rb")) == NULL)
10462 {
10463 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10464
10465 return (-1);
10466 }
10467
10468 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10469
10470 hashes_avail = count_lines (fp);
10471
10472 rewind (fp);
10473
10474 if (hashes_avail == 0)
10475 {
10476 log_error ("ERROR: hashfile is empty or corrupt");
10477
10478 fclose (fp);
10479
10480 return (-1);
10481 }
10482
10483 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10484
10485 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10486 {
10487 log_error ("ERROR: remove not supported in native hashfile-format mode");
10488
10489 fclose (fp);
10490
10491 return (-1);
10492 }
10493
10494 fclose (fp);
10495 }
10496 }
10497 else
10498 {
10499 hashlist_mode = HL_MODE_ARG;
10500
10501 hashes_avail = 1;
10502 }
10503
10504 if (hash_mode == 3000) hashes_avail *= 2;
10505
10506 data.hashlist_mode = hashlist_mode;
10507 data.hashlist_format = hashlist_format;
10508
10509 logfile_top_uint (hashlist_mode);
10510 logfile_top_uint (hashlist_format);
10511
10512 /**
10513 * load hashes, part II: allocate required memory, set pointers
10514 */
10515
10516 hash_t *hashes_buf = NULL;
10517 void *digests_buf = NULL;
10518 salt_t *salts_buf = NULL;
10519 void *esalts_buf = NULL;
10520
10521 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10522
10523 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10524
10525 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10526 {
10527 u32 hash_pos;
10528
10529 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10530 {
10531 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10532
10533 hashes_buf[hash_pos].hash_info = hash_info;
10534
10535 if (username && (remove || show || left))
10536 {
10537 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10538 }
10539
10540 if (benchmark)
10541 {
10542 hash_info->orighash = (char *) mymalloc (256);
10543 }
10544 }
10545 }
10546
10547 if (isSalted)
10548 {
10549 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10550
10551 if (esalt_size)
10552 {
10553 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10554 }
10555 }
10556 else
10557 {
10558 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10559 }
10560
10561 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10562 {
10563 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10564
10565 if (isSalted)
10566 {
10567 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10568
10569 if (esalt_size)
10570 {
10571 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10572 }
10573 }
10574 else
10575 {
10576 hashes_buf[hash_pos].salt = &salts_buf[0];
10577 }
10578 }
10579
10580 /**
10581 * load hashes, part III: parse hashes or generate them if benchmark
10582 */
10583
10584 uint hashes_cnt = 0;
10585
10586 if (benchmark == 0)
10587 {
10588 if (keyspace == 1)
10589 {
10590 // useless to read hash file for keyspace, cheat a little bit w/ optind
10591 }
10592 else if (hashes_avail == 0)
10593 {
10594 }
10595 else if (hashlist_mode == HL_MODE_ARG)
10596 {
10597 char *input_buf = myargv[optind];
10598
10599 uint input_len = strlen (input_buf);
10600
10601 logfile_top_var_string ("target", input_buf);
10602
10603 char *hash_buf = NULL;
10604 int hash_len = 0;
10605
10606 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10607
10608 if (hash_len)
10609 {
10610 if (opts_type & OPTS_TYPE_HASH_COPY)
10611 {
10612 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10613
10614 hash_info_tmp->orighash = mystrdup (hash_buf);
10615 }
10616
10617 if (isSalted)
10618 {
10619 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10620 }
10621
10622 int parser_status = PARSER_OK;
10623
10624 if (hash_mode == 2500)
10625 {
10626 if (hash_len == 0)
10627 {
10628 log_error ("ERROR: hccap file not specified");
10629
10630 return (-1);
10631 }
10632
10633 hashlist_mode = HL_MODE_FILE;
10634
10635 data.hashlist_mode = hashlist_mode;
10636
10637 FILE *fp = fopen (hash_buf, "rb");
10638
10639 if (fp == NULL)
10640 {
10641 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10642
10643 return (-1);
10644 }
10645
10646 if (hashes_avail < 1)
10647 {
10648 log_error ("ERROR: hccap file is empty or corrupt");
10649
10650 fclose (fp);
10651
10652 return (-1);
10653 }
10654
10655 uint hccap_size = sizeof (hccap_t);
10656
10657 char in[hccap_size];
10658
10659 while (!feof (fp))
10660 {
10661 int n = fread (&in, hccap_size, 1, fp);
10662
10663 if (n != 1)
10664 {
10665 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10666
10667 break;
10668 }
10669
10670 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10671
10672 if (parser_status != PARSER_OK)
10673 {
10674 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10675
10676 continue;
10677 }
10678
10679 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10680
10681 if ((show == 1) || (left == 1))
10682 {
10683 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10684
10685 char *salt_ptr = (char *) tmp_salt->salt_buf;
10686
10687 int cur_pos = tmp_salt->salt_len;
10688 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10689
10690 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10691
10692 u8 *pke_ptr = (u8 *) wpa->pke;
10693
10694 // do the appending task
10695
10696 snprintf (salt_ptr + cur_pos,
10697 rem_len,
10698 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10699 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10700 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10701
10702
10703 // memset () the remaining part of the salt
10704
10705 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10706 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10707
10708 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10709
10710 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10711 }
10712
10713 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);
10714 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);
10715
10716 hashes_cnt++;
10717 }
10718
10719 fclose (fp);
10720 }
10721 else if (hash_mode == 3000)
10722 {
10723 if (hash_len == 32)
10724 {
10725 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10726
10727 hash_t *lm_hash_left = NULL;
10728
10729 if (parser_status == PARSER_OK)
10730 {
10731 lm_hash_left = &hashes_buf[hashes_cnt];
10732
10733 hashes_cnt++;
10734 }
10735 else
10736 {
10737 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10738 }
10739
10740
10741 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10742
10743 hash_t *lm_hash_right = NULL;
10744
10745 if (parser_status == PARSER_OK)
10746 {
10747 lm_hash_right = &hashes_buf[hashes_cnt];
10748
10749 hashes_cnt++;
10750 }
10751 else
10752 {
10753 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10754 }
10755
10756 // show / left
10757
10758 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10759 {
10760 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);
10761 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);
10762 }
10763 }
10764 else
10765 {
10766 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10767
10768 if (parser_status == PARSER_OK)
10769 {
10770 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10771 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10772 }
10773
10774 if (parser_status == PARSER_OK)
10775 {
10776 hashes_cnt++;
10777 }
10778 else
10779 {
10780 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10781 }
10782 }
10783 }
10784 else
10785 {
10786 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10787
10788 if (parser_status == PARSER_OK)
10789 {
10790 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10791 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10792 }
10793
10794 if (parser_status == PARSER_OK)
10795 {
10796 hashes_cnt++;
10797 }
10798 else
10799 {
10800 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10801 }
10802 }
10803 }
10804 }
10805 else if (hashlist_mode == HL_MODE_FILE)
10806 {
10807 char *hashfile = data.hashfile;
10808
10809 FILE *fp;
10810
10811 if ((fp = fopen (hashfile, "rb")) == NULL)
10812 {
10813 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10814
10815 return (-1);
10816 }
10817
10818 uint line_num = 0;
10819
10820 while (!feof (fp))
10821 {
10822 line_num++;
10823
10824 char line_buf[BUFSIZ];
10825
10826 int line_len = fgetl (fp, line_buf);
10827
10828 if (line_len == 0) continue;
10829
10830 char *hash_buf = NULL;
10831 int hash_len = 0;
10832
10833 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10834
10835 if (username)
10836 {
10837 char *user_buf = NULL;
10838 int user_len = 0;
10839
10840 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10841
10842 if (remove || show)
10843 {
10844 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10845
10846 *user = (user_t *) malloc (sizeof (user_t));
10847
10848 user_t *user_ptr = *user;
10849
10850 if (user_buf != NULL)
10851 {
10852 user_ptr->user_name = mystrdup (user_buf);
10853 }
10854 else
10855 {
10856 user_ptr->user_name = mystrdup ("");
10857 }
10858
10859 user_ptr->user_len = user_len;
10860 }
10861 }
10862
10863 if (opts_type & OPTS_TYPE_HASH_COPY)
10864 {
10865 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10866
10867 hash_info_tmp->orighash = mystrdup (hash_buf);
10868 }
10869
10870 if (isSalted)
10871 {
10872 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10873 }
10874
10875 if (hash_mode == 3000)
10876 {
10877 if (hash_len == 32)
10878 {
10879 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10880
10881 if (parser_status < PARSER_GLOBAL_ZERO)
10882 {
10883 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10884
10885 continue;
10886 }
10887
10888 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10889
10890 hashes_cnt++;
10891
10892 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10893
10894 if (parser_status < PARSER_GLOBAL_ZERO)
10895 {
10896 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10897
10898 continue;
10899 }
10900
10901 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10902
10903 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);
10904
10905 hashes_cnt++;
10906
10907 // show / left
10908
10909 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);
10910 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);
10911 }
10912 else
10913 {
10914 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10915
10916 if (parser_status < PARSER_GLOBAL_ZERO)
10917 {
10918 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10919
10920 continue;
10921 }
10922
10923 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);
10924
10925 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10926 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10927
10928 hashes_cnt++;
10929 }
10930 }
10931 else
10932 {
10933 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10934
10935 if (parser_status < PARSER_GLOBAL_ZERO)
10936 {
10937 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10938
10939 continue;
10940 }
10941
10942 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);
10943
10944 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10945 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10946
10947 hashes_cnt++;
10948 }
10949 }
10950
10951 fclose (fp);
10952
10953 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10954
10955 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10956 }
10957 }
10958 else
10959 {
10960 if (isSalted)
10961 {
10962 hashes_buf[0].salt->salt_len = 8;
10963
10964 // special salt handling
10965
10966 switch (hash_mode)
10967 {
10968 case 1500: hashes_buf[0].salt->salt_len = 2;
10969 break;
10970 case 1731: hashes_buf[0].salt->salt_len = 4;
10971 break;
10972 case 2410: hashes_buf[0].salt->salt_len = 4;
10973 break;
10974 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10975 break;
10976 case 3100: hashes_buf[0].salt->salt_len = 1;
10977 break;
10978 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10979 break;
10980 case 5800: hashes_buf[0].salt->salt_len = 16;
10981 break;
10982 case 6800: hashes_buf[0].salt->salt_len = 32;
10983 break;
10984 case 8400: hashes_buf[0].salt->salt_len = 40;
10985 break;
10986 case 8800: hashes_buf[0].salt->salt_len = 16;
10987 break;
10988 case 8900: hashes_buf[0].salt->salt_len = 16;
10989 hashes_buf[0].salt->scrypt_N = 1024;
10990 hashes_buf[0].salt->scrypt_r = 1;
10991 hashes_buf[0].salt->scrypt_p = 1;
10992 break;
10993 case 9100: hashes_buf[0].salt->salt_len = 16;
10994 break;
10995 case 9300: hashes_buf[0].salt->salt_len = 14;
10996 hashes_buf[0].salt->scrypt_N = 16384;
10997 hashes_buf[0].salt->scrypt_r = 1;
10998 hashes_buf[0].salt->scrypt_p = 1;
10999 break;
11000 case 9400: hashes_buf[0].salt->salt_len = 16;
11001 break;
11002 case 9500: hashes_buf[0].salt->salt_len = 16;
11003 break;
11004 case 9600: hashes_buf[0].salt->salt_len = 16;
11005 break;
11006 case 9700: hashes_buf[0].salt->salt_len = 16;
11007 break;
11008 case 9710: hashes_buf[0].salt->salt_len = 16;
11009 break;
11010 case 9720: hashes_buf[0].salt->salt_len = 16;
11011 break;
11012 case 9800: hashes_buf[0].salt->salt_len = 16;
11013 break;
11014 case 9810: hashes_buf[0].salt->salt_len = 16;
11015 break;
11016 case 9820: hashes_buf[0].salt->salt_len = 16;
11017 break;
11018 case 10300: hashes_buf[0].salt->salt_len = 12;
11019 break;
11020 case 11500: hashes_buf[0].salt->salt_len = 4;
11021 break;
11022 case 11600: hashes_buf[0].salt->salt_len = 4;
11023 break;
11024 case 12400: hashes_buf[0].salt->salt_len = 4;
11025 break;
11026 case 12500: hashes_buf[0].salt->salt_len = 8;
11027 break;
11028 case 12600: hashes_buf[0].salt->salt_len = 64;
11029 break;
11030 }
11031
11032 // special esalt handling
11033
11034 switch (hash_mode)
11035 {
11036 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11037 break;
11038 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11039 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11040 break;
11041 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11042 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11043 break;
11044 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11045 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11046 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11047 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11048 break;
11049 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11050 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11051 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11052 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11053 break;
11054 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11055 break;
11056 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11057 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11058 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11059 break;
11060 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11061 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11062 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11063 break;
11064 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11065 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11066 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11067 break;
11068 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11069 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11070 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11071 break;
11072 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11073 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11074 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11075 break;
11076 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11077 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11078 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11079 break;
11080 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11081 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11082 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11083 break;
11084 }
11085 }
11086
11087 // set hashfile
11088
11089 switch (hash_mode)
11090 {
11091 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11092 break;
11093 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11094 break;
11095 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11096 break;
11097 case 6211:
11098 case 6212:
11099 case 6213:
11100 case 6221:
11101 case 6222:
11102 case 6223:
11103 case 6231:
11104 case 6232:
11105 case 6233:
11106 case 6241:
11107 case 6242:
11108 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11109 break;
11110 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11111 break;
11112 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11113 break;
11114 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11115 break;
11116 }
11117
11118 // set default iterations
11119
11120 switch (hash_mode)
11121 {
11122 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11123 break;
11124 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11125 break;
11126 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11127 break;
11128 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11129 break;
11130 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11131 break;
11132 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11133 break;
11134 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11135 break;
11136 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11137 break;
11138 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11139 break;
11140 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11141 break;
11142 case 6211:
11143 case 6212:
11144 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11145 break;
11146 case 6221:
11147 case 6222:
11148 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11149 break;
11150 case 6231:
11151 case 6232:
11152 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11153 break;
11154 case 6241:
11155 case 6242:
11156 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11157 break;
11158 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11159 break;
11160 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11161 break;
11162 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11163 break;
11164 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11165 break;
11166 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11167 break;
11168 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11169 break;
11170 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11171 break;
11172 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11173 break;
11174 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11175 break;
11176 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11177 break;
11178 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11179 break;
11180 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11181 break;
11182 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11183 break;
11184 case 8900: hashes_buf[0].salt->salt_iter = 1;
11185 break;
11186 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11187 break;
11188 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11189 break;
11190 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11191 break;
11192 case 9300: hashes_buf[0].salt->salt_iter = 1;
11193 break;
11194 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11195 break;
11196 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11197 break;
11198 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11199 break;
11200 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11201 break;
11202 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11203 break;
11204 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11205 break;
11206 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11207 break;
11208 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11209 break;
11210 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11211 break;
11212 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11213 break;
11214 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11215 break;
11216 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11217 break;
11218 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11219 break;
11220 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11221 break;
11222 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11223 break;
11224 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11225 break;
11226 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11227 break;
11228 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11229 break;
11230 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11231 break;
11232 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
11233 break;
11234 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
11235 break;
11236 }
11237
11238 // set special tuning for benchmark-mode 1
11239
11240 if (benchmark_mode == 1)
11241 {
11242 kernel_loops *= 8;
11243 kernel_accel *= 4;
11244
11245 switch (hash_mode)
11246 {
11247 case 400: kernel_loops = ROUNDS_PHPASS;
11248 kernel_accel = 32;
11249 break;
11250 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11251 kernel_accel = 32;
11252 break;
11253 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11254 kernel_accel = 32;
11255 break;
11256 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11257 kernel_accel = 32;
11258 break;
11259 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11260 kernel_accel = 16;
11261 break;
11262 case 2100: kernel_loops = ROUNDS_DCC2;
11263 kernel_accel = 16;
11264 break;
11265 case 2500: kernel_loops = ROUNDS_WPA2;
11266 kernel_accel = 32;
11267 break;
11268 case 3200: kernel_loops = ROUNDS_BCRYPT;
11269 kernel_accel = 8;
11270 break;
11271 case 5200: kernel_loops = ROUNDS_PSAFE3;
11272 kernel_accel = 16;
11273 break;
11274 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11275 kernel_accel = 16;
11276 break;
11277 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11278 kernel_accel = 64;
11279 break;
11280 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11281 kernel_accel = 32;
11282 break;
11283 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11284 kernel_accel = 32;
11285 break;
11286 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11287 kernel_accel = 8;
11288 break;
11289 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11290 kernel_accel = 8;
11291 break;
11292 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11293 kernel_accel = 8;
11294 break;
11295 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11296 kernel_accel = 8;
11297 break;
11298 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11299 kernel_accel = 8;
11300 break;
11301 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11302 kernel_accel = 8;
11303 break;
11304 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11305 kernel_accel = 128;
11306 break;
11307 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11308 kernel_accel = 64;
11309 break;
11310 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11311 kernel_accel = 64;
11312 break;
11313 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11314 kernel_accel = 32;
11315 break;
11316 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11317 kernel_accel = 128;
11318 break;
11319 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11320 kernel_accel = 128;
11321 break;
11322 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11323 kernel_accel = 32;
11324 break;
11325 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11326 kernel_accel = 64;
11327 break;
11328 case 6800: kernel_loops = ROUNDS_LASTPASS;
11329 kernel_accel = 64;
11330 break;
11331 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11332 kernel_accel = 8;
11333 break;
11334 case 7200: kernel_loops = ROUNDS_GRUB;
11335 kernel_accel = 16;
11336 break;
11337 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11338 kernel_accel = 8;
11339 break;
11340 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11341 kernel_accel = 8;
11342 break;
11343 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11344 kernel_accel = 8;
11345 break;
11346 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11347 kernel_accel = 32;
11348 break;
11349 case 8900: kernel_loops = 1;
11350 kernel_accel = 64;
11351 break;
11352 case 9000: kernel_loops = ROUNDS_PSAFE2;
11353 kernel_accel = 16;
11354 break;
11355 case 9100: kernel_loops = ROUNDS_LOTUS8;
11356 kernel_accel = 64;
11357 break;
11358 case 9200: kernel_loops = ROUNDS_CISCO8;
11359 kernel_accel = 8;
11360 break;
11361 case 9300: kernel_loops = 1;
11362 kernel_accel = 4;
11363 break;
11364 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11365 kernel_accel = 32;
11366 break;
11367 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11368 kernel_accel = 32;
11369 break;
11370 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11371 kernel_accel = 8;
11372 break;
11373 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11374 kernel_accel = 8;
11375 break;
11376 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11377 kernel_accel = 16;
11378 break;
11379 case 10500: kernel_loops = ROUNDS_PDF14;
11380 kernel_accel = 256;
11381 break;
11382 case 10700: kernel_loops = ROUNDS_PDF17L8;
11383 kernel_accel = 8;
11384 break;
11385 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11386 kernel_accel = 8;
11387 break;
11388 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11389 kernel_accel = 8;
11390 break;
11391 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11392 kernel_accel = 8;
11393 break;
11394 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11395 kernel_accel = 8;
11396 break;
11397 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11398 kernel_accel = 8;
11399 break;
11400 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11401 kernel_accel = 8;
11402 break;
11403 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11404 kernel_accel = 8;
11405 break;
11406 case 12300: kernel_loops = ROUNDS_ORACLET;
11407 kernel_accel = 8;
11408 break;
11409 case 12500: kernel_loops = ROUNDS_RAR3;
11410 kernel_accel = 32;
11411 break;
11412 case 12700: kernel_loops = ROUNDS_MYWALLET;
11413 kernel_accel = 512;
11414 break;
11415 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11416 kernel_accel = 512;
11417 break;
11418 case 12900: kernel_loops = ROUNDS_ANDROIDFDE_SAMSUNG;
11419 kernel_accel = 8;
11420 break;
11421 case 13000: kernel_loops = ROUNDS_RAR5;
11422 kernel_accel = 8;
11423 break;
11424 }
11425
11426 // some algorithm collide too fast, make that impossible
11427
11428 switch (hash_mode)
11429 {
11430 case 11500: ((uint *) digests_buf)[1] = 1;
11431 break;
11432 }
11433
11434 if (kernel_loops > 1024) kernel_loops = 1024;
11435 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11436 }
11437
11438 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11439 {
11440 kernel_loops = 1024;
11441 }
11442
11443 if (hash_mode == 12500)
11444 {
11445 kernel_loops = ROUNDS_RAR3 / 16;
11446 }
11447
11448 data.kernel_accel = kernel_accel;
11449 data.kernel_loops = kernel_loops;
11450
11451 hashes_cnt = 1;
11452 }
11453
11454 if (show == 1 || left == 1)
11455 {
11456 for (uint i = 0; i < pot_cnt; i++)
11457 {
11458 pot_t *pot_ptr = &pot[i];
11459
11460 hash_t *hashes_buf = &pot_ptr->hash;
11461
11462 local_free (hashes_buf->digest);
11463
11464 if (isSalted)
11465 {
11466 local_free (hashes_buf->salt);
11467 }
11468 }
11469
11470 local_free (pot);
11471
11472 if (data.quiet == 0) log_info_nn ("");
11473
11474 return (0);
11475 }
11476
11477 if (keyspace == 0)
11478 {
11479 if (hashes_cnt == 0)
11480 {
11481 log_error ("ERROR: No hashes loaded");
11482
11483 return (-1);
11484 }
11485 }
11486
11487 /**
11488 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11489 */
11490
11491 if (data.outfile != NULL)
11492 {
11493 if (data.hashfile != NULL)
11494 {
11495 #ifdef _POSIX
11496 struct stat tmpstat_outfile;
11497 struct stat tmpstat_hashfile;
11498 #endif
11499
11500 #ifdef _WIN
11501 struct stat64 tmpstat_outfile;
11502 struct stat64 tmpstat_hashfile;
11503 #endif
11504
11505 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11506
11507 if (tmp_outfile_fp)
11508 {
11509 #ifdef _POSIX
11510 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11511 #endif
11512
11513 #ifdef _WIN
11514 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11515 #endif
11516
11517 fclose (tmp_outfile_fp);
11518 }
11519
11520 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11521
11522 if (tmp_hashfile_fp)
11523 {
11524 #ifdef _POSIX
11525 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11526 #endif
11527
11528 #ifdef _WIN
11529 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11530 #endif
11531
11532 fclose (tmp_hashfile_fp);
11533 }
11534
11535 if (tmp_outfile_fp && tmp_outfile_fp)
11536 {
11537 tmpstat_outfile.st_mode = 0;
11538 tmpstat_outfile.st_nlink = 0;
11539 tmpstat_outfile.st_uid = 0;
11540 tmpstat_outfile.st_gid = 0;
11541 tmpstat_outfile.st_rdev = 0;
11542 tmpstat_outfile.st_atime = 0;
11543
11544 tmpstat_hashfile.st_mode = 0;
11545 tmpstat_hashfile.st_nlink = 0;
11546 tmpstat_hashfile.st_uid = 0;
11547 tmpstat_hashfile.st_gid = 0;
11548 tmpstat_hashfile.st_rdev = 0;
11549 tmpstat_hashfile.st_atime = 0;
11550
11551 #ifdef _POSIX
11552 tmpstat_outfile.st_blksize = 0;
11553 tmpstat_outfile.st_blocks = 0;
11554
11555 tmpstat_hashfile.st_blksize = 0;
11556 tmpstat_hashfile.st_blocks = 0;
11557 #endif
11558
11559 #ifdef _POSIX
11560 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11561 {
11562 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11563
11564 return (-1);
11565 }
11566 #endif
11567
11568 #ifdef _WIN
11569 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11570 {
11571 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11572
11573 return (-1);
11574 }
11575 #endif
11576 }
11577 }
11578 }
11579
11580 /**
11581 * Remove duplicates
11582 */
11583
11584 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11585
11586 if (isSalted)
11587 {
11588 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11589 }
11590 else
11591 {
11592 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11593 }
11594
11595 uint hashes_cnt_orig = hashes_cnt;
11596
11597 hashes_cnt = 1;
11598
11599 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11600 {
11601 if (isSalted)
11602 {
11603 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11604 {
11605 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11606 }
11607 }
11608 else
11609 {
11610 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11611 }
11612
11613 if (hashes_pos > hashes_cnt)
11614 {
11615 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11616 }
11617
11618 hashes_cnt++;
11619 }
11620
11621 /**
11622 * Potfile removes
11623 */
11624
11625 uint potfile_remove_cracks = 0;
11626
11627 if (potfile_disable == 0)
11628 {
11629 hash_t hash_buf;
11630
11631 hash_buf.digest = mymalloc (dgst_size);
11632 hash_buf.salt = NULL;
11633 hash_buf.esalt = NULL;
11634 hash_buf.hash_info = NULL;
11635 hash_buf.cracked = 0;
11636
11637 if (isSalted)
11638 {
11639 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11640 }
11641
11642 if (esalt_size)
11643 {
11644 hash_buf.esalt = mymalloc (esalt_size);
11645 }
11646
11647 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11648
11649 // no solution for these special hash types (for instane because they use hashfile in output etc)
11650 if ((hash_mode != 5200) &&
11651 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11652 (hash_mode != 9000))
11653 {
11654 FILE *fp = fopen (potfile, "rb");
11655
11656 if (fp != NULL)
11657 {
11658 while (!feof (fp))
11659 {
11660 char line_buf[BUFSIZ];
11661
11662 memset (line_buf, 0, BUFSIZ);
11663
11664 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11665
11666 if (ptr == NULL) break;
11667
11668 int line_len = strlen (line_buf);
11669
11670 if (line_len == 0) continue;
11671
11672 int iter = MAX_CUT_TRIES;
11673
11674 for (int i = line_len - 1; i && iter; i--, line_len--)
11675 {
11676 if (line_buf[i] != ':') continue;
11677
11678 if (isSalted)
11679 {
11680 memset (hash_buf.salt, 0, sizeof (salt_t));
11681 }
11682
11683 hash_t *found = NULL;
11684
11685 if (hash_mode == 6800)
11686 {
11687 if (i < 48) // 48 = 12 * uint in salt_buf[]
11688 {
11689 // manipulate salt_buf
11690 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11691
11692 hash_buf.salt->salt_len = i;
11693
11694 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11695 }
11696 }
11697 else if (hash_mode == 2500)
11698 {
11699 if (i < 48) // 48 = 12 * uint in salt_buf[]
11700 {
11701 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11702 // manipulate salt_buf
11703
11704 // to be safe work with a copy (because of line_len loop, i etc)
11705
11706 char line_buf_cpy[BUFSIZ];
11707 memset (line_buf_cpy, 0, BUFSIZ);
11708
11709 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11710
11711 memcpy (line_buf_cpy, line_buf, i);
11712
11713 char *mac2_pos = strrchr (line_buf_cpy, ':');
11714
11715 if (mac2_pos == NULL) continue;
11716
11717 mac2_pos[0] = 0;
11718 mac2_pos++;
11719
11720 if (strlen (mac2_pos) != 12) continue;
11721
11722 char *mac1_pos = strrchr (line_buf_cpy, ':');
11723
11724 if (mac1_pos == NULL) continue;
11725
11726 mac1_pos[0] = 0;
11727 mac1_pos++;
11728
11729 if (strlen (mac1_pos) != 12) continue;
11730
11731 uint essid_length = mac1_pos - line_buf_cpy - 1;
11732
11733 // here we need the ESSID
11734 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11735
11736 hash_buf.salt->salt_len = essid_length;
11737
11738 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11739
11740 if (found)
11741 {
11742 wpa_t *wpa = (wpa_t *) found->esalt;
11743
11744 uint pke[25];
11745
11746 char *pke_ptr = (char *) pke;
11747
11748 for (uint i = 0; i < 25; i++)
11749 {
11750 pke[i] = byte_swap_32 (wpa->pke[i]);
11751 }
11752
11753 u8 mac1[6];
11754 u8 mac2[6];
11755
11756 memcpy (mac1, pke_ptr + 23, 6);
11757 memcpy (mac2, pke_ptr + 29, 6);
11758
11759 // compare hex string(s) vs binary MAC address(es)
11760
11761 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11762 {
11763 if (mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
11764 {
11765 found = NULL;
11766 break;
11767 }
11768 }
11769
11770 // early skip ;)
11771 if (!found) continue;
11772
11773 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11774 {
11775 if (mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
11776 {
11777 found = NULL;
11778 break;
11779 }
11780 }
11781 }
11782 }
11783 }
11784 else
11785 {
11786 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11787
11788 if (parser_status == PARSER_OK)
11789 {
11790 if (isSalted)
11791 {
11792 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11793 }
11794 else
11795 {
11796 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11797 }
11798 }
11799 }
11800
11801 if (found == NULL) continue;
11802
11803 if (!found->cracked) potfile_remove_cracks++;
11804
11805 found->cracked = 1;
11806
11807 if (found) break;
11808
11809 iter--;
11810 }
11811 }
11812
11813 fclose (fp);
11814 }
11815 }
11816
11817 if (esalt_size)
11818 {
11819 local_free (hash_buf.esalt);
11820 }
11821
11822 if (isSalted)
11823 {
11824 local_free (hash_buf.salt);
11825 }
11826
11827 local_free (hash_buf.digest);
11828 }
11829
11830 /**
11831 * Now generate all the buffers required for later
11832 */
11833
11834 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11835
11836 salt_t *salts_buf_new = NULL;
11837 void *esalts_buf_new = NULL;
11838
11839 if (isSalted)
11840 {
11841 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11842
11843 if (esalt_size)
11844 {
11845 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11846 }
11847 }
11848 else
11849 {
11850 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11851 }
11852
11853 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11854
11855 uint digests_cnt = hashes_cnt;
11856 uint digests_done = 0;
11857
11858 uint size_digests = digests_cnt * dgst_size;
11859 uint size_shown = digests_cnt * sizeof (uint);
11860
11861 uint *digests_shown = (uint *) mymalloc (size_shown);
11862 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11863
11864 uint salts_cnt = 0;
11865 uint salts_done = 0;
11866
11867 hashinfo_t **hash_info = NULL;
11868
11869 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11870 {
11871 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11872
11873 if (username && (remove || show))
11874 {
11875 uint user_pos;
11876
11877 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11878 {
11879 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11880
11881 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11882 }
11883 }
11884 }
11885
11886 uint *salts_shown = (uint *) mymalloc (size_shown);
11887
11888 salt_t *salt_buf;
11889
11890 {
11891 // copied from inner loop
11892
11893 salt_buf = &salts_buf_new[salts_cnt];
11894
11895 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11896
11897 if (esalt_size)
11898 {
11899 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11900 }
11901
11902 salt_buf->digests_cnt = 0;
11903 salt_buf->digests_done = 0;
11904 salt_buf->digests_offset = 0;
11905
11906 salts_cnt++;
11907 }
11908
11909 if (hashes_buf[0].cracked == 1)
11910 {
11911 digests_shown[0] = 1;
11912
11913 digests_done++;
11914
11915 salt_buf->digests_done++;
11916 }
11917
11918 salt_buf->digests_cnt++;
11919
11920 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11921
11922 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11923 {
11924 hash_info[0] = hashes_buf[0].hash_info;
11925 }
11926
11927 // copy from inner loop
11928
11929 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11930 {
11931 if (isSalted)
11932 {
11933 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11934 {
11935 salt_buf = &salts_buf_new[salts_cnt];
11936
11937 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11938
11939 if (esalt_size)
11940 {
11941 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11942 }
11943
11944 salt_buf->digests_cnt = 0;
11945 salt_buf->digests_done = 0;
11946 salt_buf->digests_offset = hashes_pos;
11947
11948 salts_cnt++;
11949 }
11950 }
11951
11952 if (hashes_buf[hashes_pos].cracked == 1)
11953 {
11954 digests_shown[hashes_pos] = 1;
11955
11956 digests_done++;
11957
11958 salt_buf->digests_done++;
11959 }
11960
11961 salt_buf->digests_cnt++;
11962
11963 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11964
11965 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11966 {
11967 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11968 }
11969 }
11970
11971 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11972 {
11973 salt_t *salt_buf = &salts_buf_new[salt_pos];
11974
11975 if (salt_buf->digests_done == salt_buf->digests_cnt)
11976 {
11977 salts_shown[salt_pos] = 1;
11978
11979 salts_done++;
11980 }
11981
11982 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11983 }
11984
11985 local_free (digests_buf);
11986 local_free (salts_buf);
11987 local_free (esalts_buf);
11988
11989 digests_buf = digests_buf_new;
11990 salts_buf = salts_buf_new;
11991 esalts_buf = esalts_buf_new;
11992
11993 local_free (hashes_buf);
11994
11995 /**
11996 * special modification not set from parser
11997 */
11998
11999 switch (hash_mode)
12000 {
12001 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12002 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12003 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12004 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12005 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12006 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12007 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12008 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12009 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12010 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12011 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12012 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12013 }
12014
12015 if (truecrypt_keyfiles)
12016 {
12017 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12018
12019 char *keyfiles = strdup (truecrypt_keyfiles);
12020
12021 char *keyfile = strtok (keyfiles, ",");
12022
12023 do
12024 {
12025 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12026
12027 } while ((keyfile = strtok (NULL, ",")) != NULL);
12028
12029 free (keyfiles);
12030 }
12031
12032 data.digests_cnt = digests_cnt;
12033 data.digests_done = digests_done;
12034 data.digests_buf = digests_buf;
12035 data.digests_shown = digests_shown;
12036 data.digests_shown_tmp = digests_shown_tmp;
12037
12038 data.salts_cnt = salts_cnt;
12039 data.salts_done = salts_done;
12040 data.salts_buf = salts_buf;
12041 data.salts_shown = salts_shown;
12042
12043 data.esalts_buf = esalts_buf;
12044 data.hash_info = hash_info;
12045
12046 /**
12047 * Automatic Optimizers
12048 */
12049
12050 if (salts_cnt == 1)
12051 opti_type |= OPTI_TYPE_SINGLE_SALT;
12052
12053 if (digests_cnt == 1)
12054 opti_type |= OPTI_TYPE_SINGLE_HASH;
12055
12056 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12057 opti_type |= OPTI_TYPE_NOT_ITERATED;
12058
12059 if (attack_mode == ATTACK_MODE_BF)
12060 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12061
12062 data.opti_type = opti_type;
12063
12064 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12065 {
12066 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12067 {
12068 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12069 {
12070 if (opts_type & OPTS_TYPE_ST_ADD80)
12071 {
12072 opts_type &= ~OPTS_TYPE_ST_ADD80;
12073 opts_type |= OPTS_TYPE_PT_ADD80;
12074 }
12075
12076 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12077 {
12078 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12079 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12080 }
12081
12082 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12083 {
12084 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12085 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12086 }
12087 }
12088 }
12089 }
12090
12091 /**
12092 * Some algorithm, like descrypt, can benefit from JIT compilation
12093 */
12094
12095 int force_jit_compilation = -1;
12096
12097 if (hash_mode == 8900)
12098 {
12099 force_jit_compilation = 8900;
12100 }
12101 else if (hash_mode == 9300)
12102 {
12103 force_jit_compilation = 8900;
12104 }
12105 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12106 {
12107 force_jit_compilation = 1500;
12108 }
12109
12110 /**
12111 * generate bitmap tables
12112 */
12113
12114 const uint bitmap_shift1 = 5;
12115 const uint bitmap_shift2 = 13;
12116
12117 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12118
12119 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12120 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12121 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12122 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12123 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12124 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12125 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12126 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12127
12128 uint bitmap_bits;
12129 uint bitmap_nums;
12130 uint bitmap_mask;
12131 uint bitmap_size;
12132
12133 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12134 {
12135 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12136
12137 bitmap_nums = 1 << bitmap_bits;
12138
12139 bitmap_mask = bitmap_nums - 1;
12140
12141 bitmap_size = bitmap_nums * sizeof (uint);
12142
12143 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12144
12145 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;
12146 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;
12147
12148 break;
12149 }
12150
12151 bitmap_nums = 1 << bitmap_bits;
12152
12153 bitmap_mask = bitmap_nums - 1;
12154
12155 bitmap_size = bitmap_nums * sizeof (uint);
12156
12157 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);
12158 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);
12159
12160 /**
12161 * prepare quick rule
12162 */
12163
12164 data.rule_buf_l = rule_buf_l;
12165 data.rule_buf_r = rule_buf_r;
12166
12167 int rule_len_l = (int) strlen (rule_buf_l);
12168 int rule_len_r = (int) strlen (rule_buf_r);
12169
12170 data.rule_len_l = rule_len_l;
12171 data.rule_len_r = rule_len_r;
12172
12173 /**
12174 * load rules
12175 */
12176
12177 uint *all_kernel_rules_cnt = NULL;
12178
12179 kernel_rule_t **all_kernel_rules_buf = NULL;
12180
12181 if (rp_files_cnt)
12182 {
12183 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12184
12185 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12186 }
12187
12188 char rule_buf[BUFSIZ];
12189
12190 int rule_len = 0;
12191
12192 for (uint i = 0; i < rp_files_cnt; i++)
12193 {
12194 uint kernel_rules_avail = 0;
12195
12196 uint kernel_rules_cnt = 0;
12197
12198 kernel_rule_t *kernel_rules_buf = NULL;
12199
12200 char *rp_file = rp_files[i];
12201
12202 char in[BLOCK_SIZE];
12203 char out[BLOCK_SIZE];
12204
12205 FILE *fp = NULL;
12206
12207 uint rule_line = 0;
12208
12209 if ((fp = fopen (rp_file, "rb")) == NULL)
12210 {
12211 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12212
12213 return (-1);
12214 }
12215
12216 while (!feof (fp))
12217 {
12218 memset (rule_buf, 0, BUFSIZ);
12219
12220 rule_len = fgetl (fp, rule_buf);
12221
12222 rule_line++;
12223
12224 if (rule_len == 0) continue;
12225
12226 if (rule_buf[0] == '#') continue;
12227
12228 if (kernel_rules_avail == kernel_rules_cnt)
12229 {
12230 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12231
12232 kernel_rules_avail += INCR_RULES;
12233 }
12234
12235 memset (in, 0, BLOCK_SIZE);
12236 memset (out, 0, BLOCK_SIZE);
12237
12238 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12239
12240 if (result == -1)
12241 {
12242 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12243
12244 continue;
12245 }
12246
12247 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12248 {
12249 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12250
12251 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12252
12253 continue;
12254 }
12255
12256 /* its so slow
12257 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12258 {
12259 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12260
12261 continue;
12262 }
12263 */
12264
12265 kernel_rules_cnt++;
12266 }
12267
12268 fclose (fp);
12269
12270 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12271
12272 all_kernel_rules_buf[i] = kernel_rules_buf;
12273 }
12274
12275 /**
12276 * merge rules or automatic rule generator
12277 */
12278
12279 uint kernel_rules_cnt = 0;
12280
12281 kernel_rule_t *kernel_rules_buf = NULL;
12282
12283 if (attack_mode == ATTACK_MODE_STRAIGHT)
12284 {
12285 if (rp_files_cnt)
12286 {
12287 kernel_rules_cnt = 1;
12288
12289 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12290
12291 repeats[0] = kernel_rules_cnt;
12292
12293 for (uint i = 0; i < rp_files_cnt; i++)
12294 {
12295 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12296
12297 repeats[i + 1] = kernel_rules_cnt;
12298 }
12299
12300 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12301
12302 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12303
12304 for (uint i = 0; i < kernel_rules_cnt; i++)
12305 {
12306 uint out_pos = 0;
12307
12308 kernel_rule_t *out = &kernel_rules_buf[i];
12309
12310 for (uint j = 0; j < rp_files_cnt; j++)
12311 {
12312 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12313 uint in_pos;
12314
12315 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12316
12317 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12318 {
12319 if (out_pos == RULES_MAX - 1)
12320 {
12321 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12322
12323 break;
12324 }
12325
12326 out->cmds[out_pos] = in->cmds[in_pos];
12327 }
12328 }
12329 }
12330
12331 local_free (repeats);
12332 }
12333 else if (rp_gen)
12334 {
12335 uint kernel_rules_avail = 0;
12336
12337 while (kernel_rules_cnt < rp_gen)
12338 {
12339 if (kernel_rules_avail == kernel_rules_cnt)
12340 {
12341 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12342
12343 kernel_rules_avail += INCR_RULES;
12344 }
12345
12346 memset (rule_buf, 0, BLOCK_SIZE);
12347
12348 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12349
12350 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12351
12352 kernel_rules_cnt++;
12353 }
12354 }
12355 }
12356
12357 /**
12358 * generate NOP rules
12359 */
12360
12361 if (kernel_rules_cnt == 0)
12362 {
12363 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12364
12365 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12366
12367 kernel_rules_cnt++;
12368 }
12369
12370 data.kernel_rules_cnt = kernel_rules_cnt;
12371 data.kernel_rules_buf = kernel_rules_buf;
12372
12373 /**
12374 * OpenCL platforms: detect
12375 */
12376
12377 cl_platform_id platforms[CL_PLATFORMS_MAX];
12378
12379 cl_uint platforms_cnt = 0;
12380
12381 cl_device_id platform_devices[DEVICES_MAX];
12382
12383 cl_uint platform_devices_cnt;
12384
12385 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, platforms, &platforms_cnt);
12386
12387 if (platforms_cnt == 0)
12388 {
12389 log_error ("ERROR: No OpenCL compatible platform found");
12390
12391 return (-1);
12392 }
12393
12394 /**
12395 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
12396 */
12397
12398 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12399 {
12400 cl_platform_id platform = platforms[platform_id];
12401
12402 char platform_vendor[INFOSZ] = { 0 };
12403
12404 hc_clGetPlatformInfo (platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
12405
12406 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
12407 {
12408 // make sure that we do not directly control the fan for NVidia
12409
12410 gpu_temp_retain = 0;
12411
12412 data.gpu_temp_retain = gpu_temp_retain;
12413 }
12414 }
12415
12416 /**
12417 * OpenCL devices: simply push all devices from all platforms into the same device array
12418 */
12419
12420 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
12421
12422 data.devices_param = devices_param;
12423
12424 uint devices_cnt = 0;
12425
12426 uint devices_active = 0;
12427
12428 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
12429 {
12430 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
12431
12432 cl_platform_id platform = platforms[platform_id];
12433
12434 hc_clGetDeviceIDs (platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
12435
12436 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
12437 {
12438 const uint device_id = devices_cnt;
12439
12440 hc_device_param_t *device_param = &data.devices_param[device_id];
12441
12442 device_param->device = platform_devices[platform_devices_id];
12443
12444 device_param->device_id = device_id;
12445
12446 device_param->platform_devices_id = platform_devices_id;
12447
12448 // vendor_id
12449
12450 cl_uint vendor_id = 0;
12451
12452 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VENDOR_ID, sizeof (vendor_id), &vendor_id, NULL);
12453
12454 device_param->vendor_id = vendor_id;
12455
12456 // device_type
12457
12458 cl_device_type device_type;
12459
12460 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12461
12462 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
12463
12464 device_param->device_type = device_type;
12465
12466 // device_name
12467
12468 char *device_name = (char *) mymalloc (INFOSZ);
12469
12470 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_NAME, INFOSZ, device_name, NULL);
12471
12472 device_param->device_name = device_name;
12473
12474 // device_version
12475
12476 char *device_version = (char *) mymalloc (INFOSZ);
12477
12478 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_VERSION, INFOSZ, device_version, NULL);
12479
12480 device_param->device_version = device_version;
12481
12482 if (strstr (device_version, "pocl"))
12483 {
12484 // pocl returns the real vendor_id in CL_DEVICE_VENDOR_ID which causes many problems because of hms and missing amd_bfe () etc
12485 // we need to overwrite vendor_id to avoid this. maybe open pocl issue?
12486
12487 cl_uint vendor_id = 0xffff;
12488
12489 device_param->vendor_id = vendor_id;
12490 }
12491
12492 // max_compute_units
12493
12494 cl_uint device_processors;
12495
12496 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
12497
12498 device_param->device_processors = device_processors;
12499
12500 // max_mem_alloc_size
12501
12502 cl_ulong device_maxmem_alloc;
12503
12504 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
12505
12506 device_param->device_maxmem_alloc = device_maxmem_alloc;
12507
12508 // max_mem_alloc_size
12509
12510 cl_ulong device_global_mem;
12511
12512 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
12513
12514 device_param->device_global_mem = device_global_mem;
12515
12516 // max_clock_frequency
12517
12518 cl_uint device_maxclock_frequency;
12519
12520 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
12521
12522 device_param->device_maxclock_frequency = device_maxclock_frequency;
12523
12524 // skipped
12525
12526 const u32 skipped1 = ((devices_filter & (1 << device_id)) == 0);
12527 const u32 skipped2 = ((device_types_filter & (device_type)) == 0);
12528
12529 device_param->skipped = (skipped1 || skipped2);
12530
12531 // driver_version
12532
12533 char *driver_version = (char *) mymalloc (INFOSZ);
12534
12535 hc_clGetDeviceInfo (device_param->device, CL_DRIVER_VERSION, INFOSZ, driver_version, NULL);
12536
12537 device_param->driver_version = driver_version;
12538
12539 // device_name_chksum
12540
12541 char *device_name_chksum = (char *) mymalloc (INFOSZ);
12542
12543 #if __x86_64__
12544 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12545 #else
12546 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12547 #endif
12548
12549 uint device_name_digest[4];
12550
12551 device_name_digest[0] = 0;
12552 device_name_digest[1] = 0;
12553 device_name_digest[2] = 0;
12554 device_name_digest[3] = 0;
12555
12556 md5_64 ((uint *) device_name_chksum, device_name_digest);
12557
12558 sprintf (device_name_chksum, "%08x", device_name_digest[0]);
12559
12560 device_param->device_name_chksum = device_name_chksum;
12561
12562 // device_processor_cores
12563
12564 if (device_type & CL_DEVICE_TYPE_CPU)
12565 {
12566 cl_uint device_processor_cores = 1;
12567
12568 device_param->device_processor_cores = device_processor_cores;
12569 }
12570
12571 if (device_type & CL_DEVICE_TYPE_GPU)
12572 {
12573 if (vendor_id == VENDOR_ID_AMD)
12574 {
12575 cl_uint device_processor_cores = 0;
12576
12577 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12578
12579 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12580
12581 device_param->device_processor_cores = device_processor_cores;
12582 }
12583 else if (vendor_id == VENDOR_ID_NV)
12584 {
12585 cl_uint kernel_exec_timeout = 0;
12586
12587 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12588
12589 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12590
12591 device_param->kernel_exec_timeout = kernel_exec_timeout;
12592
12593 cl_uint device_processor_cores = 0;
12594
12595 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12596
12597 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12598
12599 device_param->device_processor_cores = device_processor_cores;
12600
12601 cl_uint sm_minor = 0;
12602 cl_uint sm_major = 0;
12603
12604 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12605 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12606
12607 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12608 hc_clGetDeviceInfo (device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12609
12610 device_param->sm_minor = sm_minor;
12611 device_param->sm_major = sm_major;
12612 }
12613 else
12614 {
12615 cl_uint device_processor_cores = 1;
12616
12617 device_param->device_processor_cores = device_processor_cores;
12618 }
12619 }
12620
12621 // display results
12622
12623 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12624 {
12625 if (device_param->skipped == 0)
12626 {
12627 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12628 device_id + 1,
12629 device_name,
12630 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
12631 (unsigned int) (device_global_mem / 1024 / 1024),
12632 (unsigned int) (device_maxclock_frequency),
12633 (unsigned int) device_processors);
12634 }
12635 else
12636 {
12637 log_info ("Device #%u: %s, skipped",
12638 device_id + 1,
12639 device_name);
12640 }
12641 }
12642
12643 // common driver check
12644
12645 if (device_param->skipped == 0)
12646 {
12647 if (strstr (device_version, "pocl"))
12648 {
12649 if (force == 0)
12650 {
12651 log_info ("");
12652 log_info ("ATTENTION! All pocl drivers are known to be broken due to broken LLVM <= 3.7");
12653 log_info ("You are STRONGLY encouraged not to use it");
12654 log_info ("You can use --force to override this but do not post error reports if you do so");
12655 log_info ("");
12656
12657 return (-1);
12658 }
12659 }
12660
12661 if (device_type & CL_DEVICE_TYPE_GPU)
12662 {
12663 if (vendor_id == VENDOR_ID_NV)
12664 {
12665 if (device_param->kernel_exec_timeout != 0)
12666 {
12667 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);
12668 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12669 }
12670 }
12671 else if (vendor_id == VENDOR_ID_AMD)
12672 {
12673 int catalyst_check = (force == 1) ? 0 : 1;
12674
12675 int catalyst_warn = 0;
12676
12677 int catalyst_broken = 0;
12678
12679 if (catalyst_check == 1)
12680 {
12681 catalyst_warn = 1;
12682
12683 // v14.9 and higher
12684 if (atoi (device_param->driver_version) >= 1573)
12685 {
12686 catalyst_warn = 0;
12687 }
12688
12689 catalyst_check = 0;
12690 }
12691
12692 if (catalyst_broken == 1)
12693 {
12694 log_info ("");
12695 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12696 log_info ("It will pass over cracked hashes and does not report them as cracked");
12697 log_info ("You are STRONGLY encouraged not to use it");
12698 log_info ("You can use --force to override this but do not post error reports if you do so");
12699 log_info ("");
12700
12701 return (-1);
12702 }
12703
12704 if (catalyst_warn == 1)
12705 {
12706 log_info ("");
12707 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12708 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12709 log_info ("See oclHashcat's homepage for official supported catalyst drivers");
12710 #ifdef _WIN
12711 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12712 #endif
12713 log_info ("You can use --force to override this but do not post error reports if you do so");
12714 log_info ("");
12715
12716 return (-1);
12717 }
12718 }
12719 }
12720
12721 devices_active++;
12722 }
12723
12724 // next please
12725
12726 devices_cnt++;
12727 }
12728 }
12729
12730 if (devices_active == 0)
12731 {
12732 log_error ("ERROR: No devices found/left");
12733
12734 return (-1);
12735 }
12736
12737 data.devices_cnt = devices_cnt;
12738
12739 data.devices_active = devices_active;
12740
12741 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12742 {
12743 log_info ("");
12744 }
12745
12746 /**
12747 * OpenCL devices: allocate buffer for device specific information
12748 */
12749
12750 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12751
12752 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12753
12754 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12755
12756 /**
12757 * enable custom signal handler(s)
12758 */
12759
12760 if (benchmark == 0)
12761 {
12762 hc_signal (sigHandler_default);
12763 }
12764 else
12765 {
12766 hc_signal (sigHandler_benchmark);
12767 }
12768
12769 /**
12770 * User-defined GPU temp handling
12771 */
12772
12773 if (gpu_temp_disable == 1)
12774 {
12775 gpu_temp_abort = 0;
12776 gpu_temp_retain = 0;
12777 }
12778
12779 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12780 {
12781 if (gpu_temp_abort < gpu_temp_retain)
12782 {
12783 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12784
12785 return (-1);
12786 }
12787 }
12788
12789 data.gpu_temp_disable = gpu_temp_disable;
12790 data.gpu_temp_abort = gpu_temp_abort;
12791 data.gpu_temp_retain = gpu_temp_retain;
12792
12793 /**
12794 * inform the user
12795 */
12796
12797 if (data.quiet == 0)
12798 {
12799 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12800
12801 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);
12802
12803 if (attack_mode == ATTACK_MODE_STRAIGHT)
12804 {
12805 log_info ("Rules: %u", kernel_rules_cnt);
12806 }
12807
12808 if (opti_type)
12809 {
12810 log_info ("Applicable Optimizers:");
12811
12812 for (uint i = 0; i < 32; i++)
12813 {
12814 const uint opti_bit = 1u << i;
12815
12816 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12817 }
12818 }
12819
12820 /**
12821 * Watchdog and Temperature balance
12822 */
12823
12824 if (gpu_temp_abort == 0)
12825 {
12826 log_info ("Watchdog: Temperature abort trigger disabled");
12827 }
12828 else
12829 {
12830 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12831 }
12832
12833 if (gpu_temp_retain == 0)
12834 {
12835 log_info ("Watchdog: Temperature retain trigger disabled");
12836 }
12837 else
12838 {
12839 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12840 }
12841 }
12842
12843 if (data.quiet == 0) log_info ("");
12844
12845 /**
12846 * HM devices: init
12847 */
12848
12849 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12850 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
12851
12852 if (gpu_temp_disable == 0)
12853 {
12854 #ifdef WIN
12855 if (NvAPI_Initialize () == NVAPI_OK)
12856 {
12857 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12858
12859 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12860
12861 int tmp_out = 0;
12862
12863 for (int i = 0; i < tmp_in; i++)
12864 {
12865 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12866 }
12867
12868 for (int i = 0; i < tmp_out; i++)
12869 {
12870 NvU32 speed;
12871
12872 if (NvAPI_GPU_GetTachReading (hm_adapters_nv[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
12873 }
12874 }
12875 #endif
12876
12877 #ifdef LINUX
12878 HM_LIB hm_dll_nv = hm_init (VENDOR_ID_NV);
12879
12880 data.hm_dll_nv = hm_dll_nv;
12881
12882 if (hm_dll_nv)
12883 {
12884 if (hc_NVML_nvmlInit (hm_dll_nv) == NVML_SUCCESS)
12885 {
12886 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12887
12888 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12889
12890 int tmp_out = 0;
12891
12892 for (int i = 0; i < tmp_in; i++)
12893 {
12894 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12895 }
12896
12897 for (int i = 0; i < tmp_out; i++)
12898 {
12899 unsigned int speed;
12900
12901 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;
12902 }
12903 }
12904 }
12905 #endif
12906
12907 HM_LIB hm_dll_amd = hm_init (VENDOR_ID_AMD);
12908
12909 data.hm_dll_amd = hm_dll_amd;
12910
12911 if (hm_dll_amd)
12912 {
12913 if (hc_ADL_Main_Control_Create (hm_dll_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12914 {
12915 // total number of adapters
12916
12917 int hm_adapters_num;
12918
12919 if (get_adapters_num_amd (hm_dll_amd, &hm_adapters_num) != 0) return (-1);
12920
12921 // adapter info
12922
12923 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll_amd, hm_adapters_num);
12924
12925 if (lpAdapterInfo == NULL) return (-1);
12926
12927 // get a list (of ids of) valid/usable adapters
12928
12929 int num_adl_adapters = 0;
12930
12931 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12932
12933 if (num_adl_adapters > 0)
12934 {
12935 hc_thread_mutex_lock (mux_adl);
12936
12937 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
12938
12939 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12940
12941 hm_get_overdrive_version (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12942 hm_check_fanspeed_control (hm_dll_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12943
12944 hc_thread_mutex_unlock (mux_adl);
12945 }
12946
12947 myfree (valid_adl_device_list);
12948 myfree (lpAdapterInfo);
12949 }
12950 }
12951 }
12952
12953 /**
12954 * HM devices: copy
12955 */
12956
12957 if (gpu_temp_disable == 0)
12958 {
12959 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12960 {
12961 hc_device_param_t *device_param = &data.devices_param[device_id];
12962
12963 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
12964
12965 if (device_param->skipped) continue;
12966
12967 const uint platform_devices_id = device_param->platform_devices_id;
12968
12969 if (device_param->vendor_id == VENDOR_ID_NV)
12970 {
12971 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
12972 }
12973
12974 if (device_param->vendor_id == VENDOR_ID_AMD)
12975 {
12976 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
12977 }
12978 }
12979 }
12980
12981 /*
12982 * Temporary fix:
12983 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12984 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12985 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12986 * Driver / ADL bug?
12987 */
12988
12989 if (powertune_enable == 1)
12990 {
12991 hc_thread_mutex_lock (mux_adl);
12992
12993 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12994 {
12995 hc_device_param_t *device_param = &data.devices_param[device_id];
12996
12997 if (device_param->skipped) continue;
12998
12999 if (data.hm_device[device_id].od_version == 6)
13000 {
13001 // set powertune value only
13002
13003 int powertune_supported = 0;
13004
13005 int ADL_rc = 0;
13006
13007 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
13008 {
13009 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
13010
13011 return (-1);
13012 }
13013
13014 if (powertune_supported != 0)
13015 {
13016 // powertune set
13017 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
13018
13019 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
13020 {
13021 log_error ("ERROR: Failed to get current ADL PowerControl settings");
13022
13023 return (-1);
13024 }
13025
13026 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
13027 {
13028 log_error ("ERROR: Failed to set new ADL PowerControl values");
13029
13030 return (-1);
13031 }
13032 }
13033 }
13034 }
13035
13036 hc_thread_mutex_unlock (mux_adl);
13037 }
13038
13039 uint kernel_blocks_all = 0;
13040
13041 for (uint device_id = 0; device_id < devices_cnt; device_id++)
13042 {
13043 /**
13044 * host buffer
13045 */
13046
13047 hc_device_param_t *device_param = &data.devices_param[device_id];
13048
13049 if (device_param->skipped) continue;
13050
13051 /**
13052 * device properties
13053 */
13054
13055 char *device_name_chksum = device_param->device_name_chksum;
13056
13057 uint device_processors = device_param->device_processors;
13058
13059 uint device_processor_cores = device_param->device_processor_cores;
13060
13061 cl_device_type device_type = device_param->device_type;
13062
13063 /**
13064 * create context for each device
13065 */
13066
13067 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
13068
13069 /**
13070 * create command-queue
13071 */
13072
13073 // not support with NV
13074 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
13075
13076 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
13077
13078 /**
13079 * create input buffers on device
13080 */
13081
13082 uint kernel_threads = KERNEL_THREADS;
13083
13084 // bcrypt
13085 if (hash_mode == 3200) kernel_threads = 8;
13086 if (hash_mode == 9000) kernel_threads = 8;
13087
13088 if (device_type & CL_DEVICE_TYPE_CPU)
13089 {
13090 // CPU still need lots of workitems, don't know why...
13091 // for testing phase, lets start with this
13092
13093 kernel_accel = 1;
13094 }
13095
13096 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13097 uint kernel_blocks = kernel_power;
13098
13099 device_param->kernel_threads = kernel_threads;
13100 device_param->kernel_power_user = kernel_power;
13101 device_param->kernel_blocks_user = kernel_blocks;
13102
13103 kernel_blocks_all += kernel_blocks;
13104
13105 uint size_pws = kernel_power * sizeof (pw_t);
13106
13107 uint size_tmps = 4;
13108
13109 switch (hash_mode)
13110 {
13111 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13112 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13113 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13114 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13115 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13116 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13117 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13118 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13119 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13120 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13121 case 6211:
13122 case 6212:
13123 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13124 case 6221:
13125 case 6222:
13126 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13127 case 6231:
13128 case 6232:
13129 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13130 case 6241:
13131 case 6242:
13132 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13133 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13134 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13135 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13136 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13137 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13138 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13139 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13140 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13141 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13142 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13143 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13144 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13145 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13146 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13147 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13148 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13149 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13150 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13151 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13152 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13153 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13154 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13155 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13156 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13157 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13158 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13159 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13160 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13161 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13162 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13163 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13164 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13165 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13166 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13167 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13168 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13169 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13170 case 12900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13171 case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13172 };
13173
13174 uint size_hooks = 4;
13175
13176 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13177 {
13178 // insert correct hook size
13179 }
13180
13181 // we can optimize some stuff here...
13182
13183 device_param->size_pws = size_pws;
13184 device_param->size_tmps = size_tmps;
13185 device_param->size_hooks = size_hooks;
13186
13187 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13188 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13189
13190 device_param->size_root_css = size_root_css;
13191 device_param->size_markov_css = size_markov_css;
13192
13193 uint size_results = KERNEL_THREADS * sizeof (uint);
13194
13195 device_param->size_results = size_results;
13196
13197 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13198 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13199
13200 uint size_plains = digests_cnt * sizeof (plain_t);
13201 uint size_salts = salts_cnt * sizeof (salt_t);
13202 uint size_esalts = salts_cnt * esalt_size;
13203
13204 device_param->size_plains = size_plains;
13205 device_param->size_digests = size_digests;
13206 device_param->size_shown = size_shown;
13207 device_param->size_salts = size_salts;
13208
13209 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13210 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13211 uint size_tm = 32 * sizeof (bs_word_t);
13212
13213 u64 size_scryptV = 1;
13214
13215 if ((hash_mode == 8900) || (hash_mode == 9300))
13216 {
13217 uint tmto_start = 0;
13218 uint tmto_stop = 10;
13219
13220 if (scrypt_tmto)
13221 {
13222 tmto_start = scrypt_tmto;
13223 }
13224 else
13225 {
13226 // in case the user did not specify the tmto manually
13227 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13228 // but set the lower end only in case the user has a device with too less memory
13229
13230 if (hash_mode == 8900)
13231 {
13232 if (device_param->vendor_id == VENDOR_ID_AMD)
13233 {
13234 tmto_start = 1;
13235 }
13236 else if (device_param->vendor_id == VENDOR_ID_NV)
13237 {
13238 tmto_start = 3;
13239 }
13240 }
13241 else if (hash_mode == 9300)
13242 {
13243 if (device_param->vendor_id == VENDOR_ID_AMD)
13244 {
13245 tmto_start = 3;
13246 }
13247 else if (device_param->vendor_id == VENDOR_ID_NV)
13248 {
13249 tmto_start = 5;
13250 }
13251 }
13252 }
13253
13254 if (quiet == 0) log_info ("");
13255
13256 uint shader_per_mp = 1;
13257
13258 if (device_param->vendor_id == VENDOR_ID_AMD)
13259 {
13260 shader_per_mp = 8;
13261 }
13262 else if (device_param->vendor_id == VENDOR_ID_NV)
13263 {
13264 shader_per_mp = 32;
13265 }
13266
13267 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13268 {
13269 // TODO: in theory the following calculation needs to be done per salt, not global
13270 // we assume all hashes have the same scrypt settings
13271
13272 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13273
13274 size_scryptV /= 1 << tmto;
13275
13276 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13277
13278 if (size_scryptV > device_param->device_maxmem_alloc)
13279 {
13280 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13281
13282 continue;
13283 }
13284
13285 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13286 {
13287 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13288 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13289 }
13290
13291 break;
13292 }
13293
13294 if (data.salts_buf[0].scrypt_phy == 0)
13295 {
13296 log_error ("ERROR: can't allocate enough device memory");
13297
13298 return -1;
13299 }
13300
13301 if (quiet == 0) log_info ("");
13302 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13303 }
13304
13305 /**
13306 * default building options
13307 */
13308
13309 char build_opts[1024];
13310
13311 // we don't have sm_* on vendors not NV but it doesn't matter
13312
13313 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13314
13315 /**
13316 * main kernel
13317 */
13318
13319 {
13320 /**
13321 * kernel source filename
13322 */
13323
13324 char source_file[256] = { 0 };
13325
13326 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13327
13328 struct stat sst;
13329
13330 if (stat (source_file, &sst) == -1)
13331 {
13332 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13333
13334 return -1;
13335 }
13336
13337 /**
13338 * kernel cached filename
13339 */
13340
13341 char cached_file[256] = { 0 };
13342
13343 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
13344
13345 int cached = 1;
13346
13347 struct stat cst;
13348
13349 if (stat (cached_file, &cst) == -1)
13350 {
13351 cached = 0;
13352 }
13353
13354 /**
13355 * kernel compile or load
13356 */
13357
13358 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13359
13360 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13361
13362 if (force_jit_compilation == -1)
13363 {
13364 if (cached == 0)
13365 {
13366 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13367
13368 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13369
13370 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13371
13372 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13373
13374 size_t binary_size;
13375
13376 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13377
13378 u8 *binary = (u8 *) mymalloc (binary_size);
13379
13380 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13381
13382 writeProgramBin (cached_file, binary, binary_size);
13383
13384 local_free (binary);
13385 }
13386 else
13387 {
13388 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13389
13390 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13391
13392 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13393
13394 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13395 }
13396 }
13397 else
13398 {
13399 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13400
13401 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13402
13403 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13404
13405 if (force_jit_compilation == 1500)
13406 {
13407 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13408 }
13409 else if (force_jit_compilation == 8900)
13410 {
13411 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);
13412 }
13413
13414 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13415 }
13416
13417 local_free (kernel_lengths);
13418 local_free (kernel_sources[0]);
13419 local_free (kernel_sources);
13420
13421 // this is mostly for debug
13422
13423 size_t ret_val_size = 0;
13424
13425 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13426
13427 if (ret_val_size > 2)
13428 {
13429 char *build_log = (char *) mymalloc (ret_val_size + 1);
13430
13431 memset (build_log, 0, ret_val_size + 1);
13432
13433 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13434
13435 puts (build_log);
13436
13437 myfree (build_log);
13438 }
13439 }
13440
13441 /**
13442 * word generator kernel
13443 */
13444
13445 if (attack_mode != ATTACK_MODE_STRAIGHT)
13446 {
13447 /**
13448 * kernel mp source filename
13449 */
13450
13451 char source_file[256] = { 0 };
13452
13453 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13454
13455 struct stat sst;
13456
13457 if (stat (source_file, &sst) == -1)
13458 {
13459 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13460
13461 return -1;
13462 }
13463
13464 /**
13465 * kernel mp cached filename
13466 */
13467
13468 char cached_file[256] = { 0 };
13469
13470 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
13471
13472 int cached = 1;
13473
13474 struct stat cst;
13475
13476 if (stat (cached_file, &cst) == -1)
13477 {
13478 cached = 0;
13479 }
13480
13481 /**
13482 * kernel compile or load
13483 */
13484
13485 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13486
13487 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13488
13489 if (cached == 0)
13490 {
13491 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13492
13493 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13494
13495 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13496
13497 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13498
13499 size_t binary_size;
13500
13501 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13502
13503 u8 *binary = (u8 *) mymalloc (binary_size);
13504
13505 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13506
13507 writeProgramBin (cached_file, binary, binary_size);
13508
13509 local_free (binary);
13510 }
13511 else
13512 {
13513 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13514
13515 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13516
13517 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13518
13519 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13520 }
13521
13522 local_free (kernel_lengths);
13523 local_free (kernel_sources[0]);
13524 local_free (kernel_sources);
13525
13526 // this is mostly for debug
13527
13528 size_t ret_val_size = 0;
13529
13530 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13531
13532 if (ret_val_size > 2)
13533 {
13534 char *build_log = (char *) mymalloc (ret_val_size + 1);
13535
13536 memset (build_log, 0, ret_val_size + 1);
13537
13538 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13539
13540 puts (build_log);
13541
13542 myfree (build_log);
13543 }
13544 }
13545
13546 /**
13547 * amplifier kernel
13548 */
13549
13550 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13551 {
13552
13553 }
13554 else
13555 {
13556 /**
13557 * kernel amp source filename
13558 */
13559
13560 char source_file[256] = { 0 };
13561
13562 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13563
13564 struct stat sst;
13565
13566 if (stat (source_file, &sst) == -1)
13567 {
13568 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13569
13570 return -1;
13571 }
13572
13573 /**
13574 * kernel amp cached filename
13575 */
13576
13577 char cached_file[256] = { 0 };
13578
13579 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
13580
13581 int cached = 1;
13582
13583 struct stat cst;
13584
13585 if (stat (cached_file, &cst) == -1)
13586 {
13587 cached = 0;
13588 }
13589
13590 /**
13591 * kernel compile or load
13592 */
13593
13594 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13595
13596 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
13597
13598 if (cached == 0)
13599 {
13600 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13601
13602 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13603
13604 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13605
13606 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13607
13608 size_t binary_size;
13609
13610 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13611
13612 u8 *binary = (u8 *) mymalloc (binary_size);
13613
13614 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13615
13616 writeProgramBin (cached_file, binary, binary_size);
13617
13618 local_free (binary);
13619 }
13620 else
13621 {
13622 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13623
13624 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13625
13626 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
13627
13628 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13629 }
13630
13631 local_free (kernel_lengths);
13632 local_free (kernel_sources[0]);
13633 local_free (kernel_sources);
13634
13635 // this is mostly for debug
13636
13637 size_t ret_val_size = 0;
13638
13639 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13640
13641 if (ret_val_size > 2)
13642 {
13643 char *build_log = (char *) mymalloc (ret_val_size + 1);
13644
13645 memset (build_log, 0, ret_val_size + 1);
13646
13647 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13648
13649 puts (build_log);
13650
13651 myfree (build_log);
13652 }
13653 }
13654
13655 /**
13656 * global buffers
13657 */
13658
13659 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13660 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13661 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13662 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13663 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13664 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13665 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13666 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13667 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13668 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13669 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13670 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13671 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13672 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13673 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13674 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13675 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13676 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13677
13678 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13679 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13680 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13681 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13682 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13683 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13684 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13685 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13686 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13687 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13688 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13689
13690 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13691 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13692 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13693 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13694 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13695 run_kernel_bzero (device_param, device_param->d_result, size_results);
13696
13697 /**
13698 * special buffers
13699 */
13700
13701 if (attack_kern == ATTACK_KERN_STRAIGHT)
13702 {
13703 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13704 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13705
13706 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13707
13708 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13709 }
13710 else if (attack_kern == ATTACK_KERN_COMBI)
13711 {
13712 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13713 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13714 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13715 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13716
13717 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13718 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13719 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13720 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13721 }
13722 else if (attack_kern == ATTACK_KERN_BF)
13723 {
13724 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13725 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13726 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13727 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13728 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13729
13730 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13731 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13732 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13733 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13734 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13735 }
13736
13737 if (size_esalts)
13738 {
13739 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13740
13741 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13742 }
13743
13744 /**
13745 * main host data
13746 */
13747
13748 uint *result = (uint *) mymalloc (size_results);
13749
13750 memset (result, 0, size_results);
13751
13752 device_param->result = result;
13753
13754 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13755
13756 memset (pws_buf, 0, size_pws);
13757
13758 device_param->pws_buf = pws_buf;
13759
13760 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13761
13762 for (int i = 0; i < 64; i++)
13763 {
13764 pw_caches[i].pw_buf.pw_len = i;
13765 pw_caches[i].cnt = 0;
13766 }
13767
13768 device_param->pw_caches = pw_caches;
13769
13770 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13771
13772 device_param->combs_buf = combs_buf;
13773
13774 void *hooks_buf = mymalloc (size_hooks);
13775
13776 device_param->hooks_buf = hooks_buf;
13777
13778 device_param->pw_transpose = pw_transpose_to_hi1;
13779 device_param->pw_add = pw_add_to_hc1;
13780
13781 /**
13782 * kernel args
13783 */
13784
13785 device_param->kernel_params_buf32[21] = bitmap_mask;
13786 device_param->kernel_params_buf32[22] = bitmap_shift1;
13787 device_param->kernel_params_buf32[23] = bitmap_shift2;
13788 device_param->kernel_params_buf32[24] = 0; // salt_pos
13789 device_param->kernel_params_buf32[25] = 0; // loop_pos
13790 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13791 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13792 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13793 device_param->kernel_params_buf32[29] = 0; // digests_offset
13794 device_param->kernel_params_buf32[30] = 0; // combs_mode
13795 device_param->kernel_params_buf32[31] = 0; // gid_max
13796
13797 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13798 ? &device_param->d_pws_buf
13799 : &device_param->d_pws_amp_buf;
13800 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13801 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13802 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13803 device_param->kernel_params[ 4] = &device_param->d_tmps;
13804 device_param->kernel_params[ 5] = &device_param->d_hooks;
13805 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13806 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13807 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13808 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13809 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13810 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13811 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13812 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13813 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13814 device_param->kernel_params[15] = &device_param->d_digests_buf;
13815 device_param->kernel_params[16] = &device_param->d_digests_shown;
13816 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13817 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13818 device_param->kernel_params[19] = &device_param->d_result;
13819 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13820 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13821 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13822 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13823 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13824 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13825 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13826 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13827 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13828 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13829 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13830 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13831
13832 device_param->kernel_params_mp_buf64[3] = 0;
13833 device_param->kernel_params_mp_buf32[4] = 0;
13834 device_param->kernel_params_mp_buf32[5] = 0;
13835 device_param->kernel_params_mp_buf32[6] = 0;
13836 device_param->kernel_params_mp_buf32[7] = 0;
13837 device_param->kernel_params_mp_buf32[8] = 0;
13838
13839 device_param->kernel_params_mp[0] = NULL;
13840 device_param->kernel_params_mp[1] = NULL;
13841 device_param->kernel_params_mp[2] = NULL;
13842 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13843 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13844 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13845 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13846 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13847 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13848
13849 device_param->kernel_params_mp_l_buf64[3] = 0;
13850 device_param->kernel_params_mp_l_buf32[4] = 0;
13851 device_param->kernel_params_mp_l_buf32[5] = 0;
13852 device_param->kernel_params_mp_l_buf32[6] = 0;
13853 device_param->kernel_params_mp_l_buf32[7] = 0;
13854 device_param->kernel_params_mp_l_buf32[8] = 0;
13855 device_param->kernel_params_mp_l_buf32[9] = 0;
13856
13857 device_param->kernel_params_mp_l[0] = NULL;
13858 device_param->kernel_params_mp_l[1] = NULL;
13859 device_param->kernel_params_mp_l[2] = NULL;
13860 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13861 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13862 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13863 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13864 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13865 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13866 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13867
13868 device_param->kernel_params_mp_r_buf64[3] = 0;
13869 device_param->kernel_params_mp_r_buf32[4] = 0;
13870 device_param->kernel_params_mp_r_buf32[5] = 0;
13871 device_param->kernel_params_mp_r_buf32[6] = 0;
13872 device_param->kernel_params_mp_r_buf32[7] = 0;
13873 device_param->kernel_params_mp_r_buf32[8] = 0;
13874
13875 device_param->kernel_params_mp_r[0] = NULL;
13876 device_param->kernel_params_mp_r[1] = NULL;
13877 device_param->kernel_params_mp_r[2] = NULL;
13878 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13879 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13880 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13881 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13882 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13883 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13884
13885 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13886 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13887
13888 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13889 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13890 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13891 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13892 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13893 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13894 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13895
13896 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13897
13898 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13899 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13900
13901 /**
13902 * kernel name
13903 */
13904
13905 char kernel_name[64] = { 0 };
13906
13907 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13908 {
13909 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13910 {
13911 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13912
13913 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13914
13915 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13916
13917 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13918
13919 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13920
13921 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13922 }
13923 else
13924 {
13925 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13926
13927 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13928
13929 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13930
13931 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13932
13933 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13934
13935 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13936 }
13937
13938 if (data.attack_mode == ATTACK_MODE_BF)
13939 {
13940 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13941 {
13942 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13943
13944 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13945
13946 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13947
13948 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13949 }
13950 }
13951 }
13952 else
13953 {
13954 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13955
13956 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13957
13958 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13959
13960 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13961
13962 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13963
13964 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13965
13966 if (opts_type & OPTS_TYPE_HOOK12)
13967 {
13968 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13969
13970 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13971 }
13972
13973 if (opts_type & OPTS_TYPE_HOOK23)
13974 {
13975 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13976
13977 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13978 }
13979 }
13980
13981 for (uint i = 0; i <= 20; i++)
13982 {
13983 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13984 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13985 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13986
13987 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13988 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13989 }
13990
13991 for (uint i = 21; i <= 31; i++)
13992 {
13993 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13994 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13995 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13996
13997 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13998 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13999 }
14000
14001 if (attack_mode == ATTACK_MODE_BF)
14002 {
14003 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
14004 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
14005
14006 if (opts_type & OPTS_TYPE_PT_BITSLICE)
14007 {
14008 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
14009
14010 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
14011 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
14012 }
14013 }
14014 else if (attack_mode == ATTACK_MODE_HYBRID1)
14015 {
14016 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14017 }
14018 else if (attack_mode == ATTACK_MODE_HYBRID2)
14019 {
14020 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
14021 }
14022
14023 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14024 {
14025 // nothing to do
14026 }
14027 else
14028 {
14029 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
14030 }
14031
14032 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14033 {
14034 // nothing to do
14035 }
14036 else
14037 {
14038 for (uint i = 0; i < 5; i++)
14039 {
14040 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
14041 }
14042
14043 for (uint i = 5; i < 7; i++)
14044 {
14045 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
14046 }
14047 }
14048
14049 /**
14050 * Store initial fanspeed if gpu_temp_retain is enabled
14051 */
14052
14053 int gpu_temp_retain_set = 0;
14054
14055 if (gpu_temp_disable == 0)
14056 {
14057 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
14058 {
14059 hc_thread_mutex_lock (mux_adl);
14060
14061 if (data.hm_device[device_id].fan_supported == 1)
14062 {
14063 if (gpu_temp_retain_chgd == 0)
14064 {
14065 uint cur_temp = 0;
14066 uint default_temp = 0;
14067
14068 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);
14069
14070 if (ADL_rc == ADL_OK)
14071 {
14072 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14073
14074 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14075
14076 // special case with multi gpu setups: always use minimum retain
14077
14078 if (gpu_temp_retain_set == 0)
14079 {
14080 gpu_temp_retain = gpu_temp_retain_target;
14081 gpu_temp_retain_set = 1;
14082 }
14083 else
14084 {
14085 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14086 }
14087
14088 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14089 }
14090 }
14091
14092 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14093
14094 temp_retain_fanspeed_value[device_id] = fan_speed;
14095
14096 if (fan_speed == -1)
14097 {
14098 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14099
14100 temp_retain_fanspeed_value[device_id] = 0;
14101 }
14102 }
14103
14104 hc_thread_mutex_unlock (mux_adl);
14105 }
14106 }
14107
14108 /**
14109 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14110 */
14111
14112 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14113 {
14114 hc_thread_mutex_lock (mux_adl);
14115
14116 if (data.hm_device[device_id].od_version == 6)
14117 {
14118 int ADL_rc;
14119
14120 // check powertune capabilities first, if not available then skip device
14121
14122 int powertune_supported = 0;
14123
14124 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14125 {
14126 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14127
14128 return (-1);
14129 }
14130
14131 if (powertune_supported != 0)
14132 {
14133 // powercontrol settings
14134
14135 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14136
14137 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14138 {
14139 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]);
14140 }
14141
14142 if (ADL_rc != ADL_OK)
14143 {
14144 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14145
14146 return (-1);
14147 }
14148
14149 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14150 {
14151 log_error ("ERROR: Failed to set new ADL PowerControl values");
14152
14153 return (-1);
14154 }
14155
14156 // clocks
14157
14158 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14159
14160 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14161
14162 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)
14163 {
14164 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14165
14166 return (-1);
14167 }
14168
14169 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14170
14171 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14172
14173 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14174 {
14175 log_error ("ERROR: Failed to get ADL device capabilities");
14176
14177 return (-1);
14178 }
14179
14180 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14181 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14182
14183 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14184 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14185
14186 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14187 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14188
14189 // warning if profile has to low max values
14190
14191 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14192 {
14193 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14194 }
14195
14196 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14197 {
14198 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14199 }
14200
14201 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14202
14203 performance_state->iNumberOfPerformanceLevels = 2;
14204
14205 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14206 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14207 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14208 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14209
14210 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)
14211 {
14212 log_info ("ERROR: Failed to set ADL performance state");
14213
14214 return (-1);
14215 }
14216
14217 local_free (performance_state);
14218 }
14219 }
14220
14221 hc_thread_mutex_unlock (mux_adl);
14222 }
14223 }
14224
14225 data.kernel_blocks_all = kernel_blocks_all;
14226
14227 if (data.quiet == 0) log_info ("");
14228
14229 /**
14230 * Inform user which algorithm is checked and at which workload setting
14231 */
14232
14233 if (benchmark == 1)
14234 {
14235 quiet = 0;
14236
14237 data.quiet = quiet;
14238
14239 char *hash_type = strhashtype (data.hash_mode); // not a bug
14240
14241 log_info ("Hashtype: %s", hash_type);
14242 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14243 log_info ("");
14244 }
14245
14246 /**
14247 * keep track of the progress
14248 */
14249
14250 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14251 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14252 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
14253
14254 /**
14255 * open filehandles
14256 */
14257
14258 #if _WIN
14259 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14260 {
14261 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14262
14263 return (-1);
14264 }
14265
14266 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14267 {
14268 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14269
14270 return (-1);
14271 }
14272
14273 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14274 {
14275 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14276
14277 return (-1);
14278 }
14279 #endif
14280
14281 /**
14282 * dictionary pad
14283 */
14284
14285 segment_size *= (1024 * 1024);
14286
14287 data.segment_size = segment_size;
14288
14289 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14290
14291 wl_data->buf = (char *) mymalloc (segment_size);
14292 wl_data->avail = segment_size;
14293 wl_data->incr = segment_size;
14294 wl_data->cnt = 0;
14295 wl_data->pos = 0;
14296
14297 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14298
14299 data.wordlist_mode = wordlist_mode;
14300
14301 cs_t *css_buf = NULL;
14302 uint css_cnt = 0;
14303 uint dictcnt = 0;
14304 uint maskcnt = 1;
14305 char **masks = NULL;
14306 char **dictfiles = NULL;
14307
14308 uint mask_from_file = 0;
14309
14310 if (attack_mode == ATTACK_MODE_STRAIGHT)
14311 {
14312 if (wordlist_mode == WL_MODE_FILE)
14313 {
14314 int wls_left = myargc - (optind + 1);
14315
14316 for (int i = 0; i < wls_left; i++)
14317 {
14318 char *l0_filename = myargv[optind + 1 + i];
14319
14320 struct stat l0_stat;
14321
14322 if (stat (l0_filename, &l0_stat) == -1)
14323 {
14324 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14325
14326 return (-1);
14327 }
14328
14329 uint is_dir = S_ISDIR (l0_stat.st_mode);
14330
14331 if (is_dir == 0)
14332 {
14333 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14334
14335 dictcnt++;
14336
14337 dictfiles[dictcnt - 1] = l0_filename;
14338 }
14339 else
14340 {
14341 // do not allow --keyspace w/ a directory
14342
14343 if (keyspace == 1)
14344 {
14345 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14346
14347 return (-1);
14348 }
14349
14350 char **dictionary_files = NULL;
14351
14352 dictionary_files = scan_directory (l0_filename);
14353
14354 if (dictionary_files != NULL)
14355 {
14356 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14357
14358 for (int d = 0; dictionary_files[d] != NULL; d++)
14359 {
14360 char *l1_filename = dictionary_files[d];
14361
14362 struct stat l1_stat;
14363
14364 if (stat (l1_filename, &l1_stat) == -1)
14365 {
14366 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14367
14368 return (-1);
14369 }
14370
14371 if (S_ISREG (l1_stat.st_mode))
14372 {
14373 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14374
14375 dictcnt++;
14376
14377 dictfiles[dictcnt - 1] = strdup (l1_filename);
14378 }
14379 }
14380 }
14381
14382 local_free (dictionary_files);
14383 }
14384 }
14385
14386 if (dictcnt < 1)
14387 {
14388 log_error ("ERROR: No usable dictionary file found.");
14389
14390 return (-1);
14391 }
14392 }
14393 else if (wordlist_mode == WL_MODE_STDIN)
14394 {
14395 dictcnt = 1;
14396 }
14397 }
14398 else if (attack_mode == ATTACK_MODE_COMBI)
14399 {
14400 // display
14401
14402 char *dictfile1 = myargv[optind + 1 + 0];
14403 char *dictfile2 = myargv[optind + 1 + 1];
14404
14405 // find the bigger dictionary and use as base
14406
14407 FILE *fp1;
14408 FILE *fp2;
14409
14410 struct stat tmp_stat;
14411
14412 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14413 {
14414 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14415
14416 return (-1);
14417 }
14418
14419 if (stat (dictfile1, &tmp_stat) == -1)
14420 {
14421 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14422
14423 fclose (fp1);
14424
14425 return (-1);
14426 }
14427
14428 if (S_ISDIR (tmp_stat.st_mode))
14429 {
14430 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14431
14432 fclose (fp1);
14433
14434 return (-1);
14435 }
14436
14437 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14438 {
14439 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14440
14441 fclose (fp1);
14442
14443 return (-1);
14444 }
14445
14446 if (stat (dictfile2, &tmp_stat) == -1)
14447 {
14448 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14449
14450 fclose (fp1);
14451 fclose (fp2);
14452
14453 return (-1);
14454 }
14455
14456 if (S_ISDIR (tmp_stat.st_mode))
14457 {
14458 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14459
14460 fclose (fp1);
14461 fclose (fp2);
14462
14463 return (-1);
14464 }
14465
14466 data.combs_cnt = 1;
14467
14468 data.quiet = 1;
14469
14470 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14471
14472 data.quiet = quiet;
14473
14474 if (words1_cnt == 0)
14475 {
14476 log_error ("ERROR: %s: empty file", dictfile1);
14477
14478 fclose (fp1);
14479 fclose (fp2);
14480
14481 return (-1);
14482 }
14483
14484 data.combs_cnt = 1;
14485
14486 data.quiet = 1;
14487
14488 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14489
14490 data.quiet = quiet;
14491
14492 if (words2_cnt == 0)
14493 {
14494 log_error ("ERROR: %s: empty file", dictfile2);
14495
14496 fclose (fp1);
14497 fclose (fp2);
14498
14499 return (-1);
14500 }
14501
14502 fclose (fp1);
14503 fclose (fp2);
14504
14505 data.dictfile = dictfile1;
14506 data.dictfile2 = dictfile2;
14507
14508 if (words1_cnt >= words2_cnt)
14509 {
14510 data.combs_cnt = words2_cnt;
14511 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14512
14513 dictfiles = &data.dictfile;
14514
14515 dictcnt = 1;
14516 }
14517 else
14518 {
14519 data.combs_cnt = words1_cnt;
14520 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14521
14522 dictfiles = &data.dictfile2;
14523
14524 dictcnt = 1;
14525
14526 // we also have to switch wordlist related rules!
14527
14528 char *tmpc = data.rule_buf_l;
14529
14530 data.rule_buf_l = data.rule_buf_r;
14531 data.rule_buf_r = tmpc;
14532
14533 int tmpi = data.rule_len_l;
14534
14535 data.rule_len_l = data.rule_len_r;
14536 data.rule_len_r = tmpi;
14537 }
14538 }
14539 else if (attack_mode == ATTACK_MODE_BF)
14540 {
14541 char *mask = NULL;
14542
14543 maskcnt = 0;
14544
14545 if (benchmark == 0)
14546 {
14547 mask = myargv[optind + 1];
14548
14549 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14550
14551 if ((optind + 2) <= myargc)
14552 {
14553 struct stat file_stat;
14554
14555 if (stat (mask, &file_stat) == -1)
14556 {
14557 maskcnt = 1;
14558
14559 masks[maskcnt - 1] = mystrdup (mask);
14560 }
14561 else
14562 {
14563 int wls_left = myargc - (optind + 1);
14564
14565 uint masks_avail = INCR_MASKS;
14566
14567 for (int i = 0; i < wls_left; i++)
14568 {
14569 if (i != 0)
14570 {
14571 mask = myargv[optind + 1 + i];
14572
14573 if (stat (mask, &file_stat) == -1)
14574 {
14575 log_error ("ERROR: %s: %s", mask, strerror (errno));
14576
14577 return (-1);
14578 }
14579 }
14580
14581 uint is_file = S_ISREG (file_stat.st_mode);
14582
14583 if (is_file == 1)
14584 {
14585 FILE *mask_fp;
14586
14587 if ((mask_fp = fopen (mask, "r")) == NULL)
14588 {
14589 log_error ("ERROR: %s: %s", mask, strerror (errno));
14590
14591 return (-1);
14592 }
14593
14594 char line_buf[BUFSIZ];
14595
14596 while (!feof (mask_fp))
14597 {
14598 memset (line_buf, 0, BUFSIZ);
14599
14600 int line_len = fgetl (mask_fp, line_buf);
14601
14602 if (line_len == 0) continue;
14603
14604 if (line_buf[0] == '#') continue;
14605
14606 if (masks_avail == maskcnt)
14607 {
14608 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14609
14610 masks_avail += INCR_MASKS;
14611 }
14612
14613 masks[maskcnt] = mystrdup (line_buf);
14614
14615 maskcnt++;
14616 }
14617
14618 fclose (mask_fp);
14619 }
14620 else
14621 {
14622 log_error ("ERROR: %s: unsupported file-type", mask);
14623
14624 return (-1);
14625 }
14626 }
14627
14628 mask_from_file = 1;
14629 }
14630 }
14631 else
14632 {
14633 custom_charset_1 = (char *) "?l?d?u";
14634 custom_charset_2 = (char *) "?l?d";
14635 custom_charset_3 = (char *) "?l?d*!$@_";
14636
14637 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14638 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14639 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14640
14641 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14642
14643 wordlist_mode = WL_MODE_MASK;
14644
14645 data.wordlist_mode = wordlist_mode;
14646
14647 increment = 1;
14648
14649 maskcnt = 1;
14650 }
14651 }
14652 else
14653 {
14654 /**
14655 * generate full masks and charsets
14656 */
14657
14658 masks = (char **) mymalloc (sizeof (char *));
14659
14660 switch (hash_mode)
14661 {
14662 case 1731: pw_min = 5;
14663 pw_max = 5;
14664 mask = mystrdup ("?b?b?b?b?b");
14665 break;
14666 case 12500: pw_min = 5;
14667 pw_max = 5;
14668 mask = mystrdup ("?b?b?b?b?b");
14669 break;
14670 default: pw_min = 7;
14671 pw_max = 7;
14672 mask = mystrdup ("?b?b?b?b?b?b?b");
14673 break;
14674 }
14675
14676 maskcnt = 1;
14677
14678 masks[maskcnt - 1] = mystrdup (mask);
14679
14680 wordlist_mode = WL_MODE_MASK;
14681
14682 data.wordlist_mode = wordlist_mode;
14683
14684 increment = 1;
14685 }
14686
14687 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14688
14689 if (increment)
14690 {
14691 if (increment_min > pw_min) pw_min = increment_min;
14692
14693 if (increment_max < pw_max) pw_max = increment_max;
14694 }
14695 }
14696 else if (attack_mode == ATTACK_MODE_HYBRID1)
14697 {
14698 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14699
14700 // display
14701
14702 char *mask = myargv[myargc - 1];
14703
14704 maskcnt = 0;
14705
14706 masks = (char **) mymalloc (1 * sizeof (char *));
14707
14708 // mod
14709
14710 struct stat file_stat;
14711
14712 if (stat (mask, &file_stat) == -1)
14713 {
14714 maskcnt = 1;
14715
14716 masks[maskcnt - 1] = mystrdup (mask);
14717 }
14718 else
14719 {
14720 uint is_file = S_ISREG (file_stat.st_mode);
14721
14722 if (is_file == 1)
14723 {
14724 FILE *mask_fp;
14725
14726 if ((mask_fp = fopen (mask, "r")) == NULL)
14727 {
14728 log_error ("ERROR: %s: %s", mask, strerror (errno));
14729
14730 return (-1);
14731 }
14732
14733 char line_buf[BUFSIZ];
14734
14735 uint masks_avail = 1;
14736
14737 while (!feof (mask_fp))
14738 {
14739 memset (line_buf, 0, BUFSIZ);
14740
14741 int line_len = fgetl (mask_fp, line_buf);
14742
14743 if (line_len == 0) continue;
14744
14745 if (line_buf[0] == '#') continue;
14746
14747 if (masks_avail == maskcnt)
14748 {
14749 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14750
14751 masks_avail += INCR_MASKS;
14752 }
14753
14754 masks[maskcnt] = mystrdup (line_buf);
14755
14756 maskcnt++;
14757 }
14758
14759 fclose (mask_fp);
14760
14761 mask_from_file = 1;
14762 }
14763 else
14764 {
14765 maskcnt = 1;
14766
14767 masks[maskcnt - 1] = mystrdup (mask);
14768 }
14769 }
14770
14771 // base
14772
14773 int wls_left = myargc - (optind + 2);
14774
14775 for (int i = 0; i < wls_left; i++)
14776 {
14777 char *filename = myargv[optind + 1 + i];
14778
14779 struct stat file_stat;
14780
14781 if (stat (filename, &file_stat) == -1)
14782 {
14783 log_error ("ERROR: %s: %s", filename, strerror (errno));
14784
14785 return (-1);
14786 }
14787
14788 uint is_dir = S_ISDIR (file_stat.st_mode);
14789
14790 if (is_dir == 0)
14791 {
14792 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14793
14794 dictcnt++;
14795
14796 dictfiles[dictcnt - 1] = filename;
14797 }
14798 else
14799 {
14800 // do not allow --keyspace w/ a directory
14801
14802 if (keyspace == 1)
14803 {
14804 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14805
14806 return (-1);
14807 }
14808
14809 char **dictionary_files = NULL;
14810
14811 dictionary_files = scan_directory (filename);
14812
14813 if (dictionary_files != NULL)
14814 {
14815 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14816
14817 for (int d = 0; dictionary_files[d] != NULL; d++)
14818 {
14819 char *l1_filename = dictionary_files[d];
14820
14821 struct stat l1_stat;
14822
14823 if (stat (l1_filename, &l1_stat) == -1)
14824 {
14825 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14826
14827 return (-1);
14828 }
14829
14830 if (S_ISREG (l1_stat.st_mode))
14831 {
14832 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14833
14834 dictcnt++;
14835
14836 dictfiles[dictcnt - 1] = strdup (l1_filename);
14837 }
14838 }
14839 }
14840
14841 local_free (dictionary_files);
14842 }
14843 }
14844
14845 if (dictcnt < 1)
14846 {
14847 log_error ("ERROR: No usable dictionary file found.");
14848
14849 return (-1);
14850 }
14851
14852 if (increment)
14853 {
14854 maskcnt = 0;
14855
14856 uint mask_min = increment_min; // we can't reject smaller masks here
14857 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14858
14859 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14860 {
14861 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14862
14863 if (cur_mask == NULL) break;
14864
14865 masks[maskcnt] = cur_mask;
14866
14867 maskcnt++;
14868
14869 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14870 }
14871 }
14872 }
14873 else if (attack_mode == ATTACK_MODE_HYBRID2)
14874 {
14875 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14876
14877 // display
14878
14879 char *mask = myargv[optind + 1 + 0];
14880
14881 maskcnt = 0;
14882
14883 masks = (char **) mymalloc (1 * sizeof (char *));
14884
14885 // mod
14886
14887 struct stat file_stat;
14888
14889 if (stat (mask, &file_stat) == -1)
14890 {
14891 maskcnt = 1;
14892
14893 masks[maskcnt - 1] = mystrdup (mask);
14894 }
14895 else
14896 {
14897 uint is_file = S_ISREG (file_stat.st_mode);
14898
14899 if (is_file == 1)
14900 {
14901 FILE *mask_fp;
14902
14903 if ((mask_fp = fopen (mask, "r")) == NULL)
14904 {
14905 log_error ("ERROR: %s: %s", mask, strerror (errno));
14906
14907 return (-1);
14908 }
14909
14910 char line_buf[BUFSIZ];
14911
14912 uint masks_avail = 1;
14913
14914 while (!feof (mask_fp))
14915 {
14916 memset (line_buf, 0, BUFSIZ);
14917
14918 int line_len = fgetl (mask_fp, line_buf);
14919
14920 if (line_len == 0) continue;
14921
14922 if (line_buf[0] == '#') continue;
14923
14924 if (masks_avail == maskcnt)
14925 {
14926 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14927
14928 masks_avail += INCR_MASKS;
14929 }
14930
14931 masks[maskcnt] = mystrdup (line_buf);
14932
14933 maskcnt++;
14934 }
14935
14936 fclose (mask_fp);
14937
14938 mask_from_file = 1;
14939 }
14940 else
14941 {
14942 maskcnt = 1;
14943
14944 masks[maskcnt - 1] = mystrdup (mask);
14945 }
14946 }
14947
14948 // base
14949
14950 int wls_left = myargc - (optind + 2);
14951
14952 for (int i = 0; i < wls_left; i++)
14953 {
14954 char *filename = myargv[optind + 2 + i];
14955
14956 struct stat file_stat;
14957
14958 if (stat (filename, &file_stat) == -1)
14959 {
14960 log_error ("ERROR: %s: %s", filename, strerror (errno));
14961
14962 return (-1);
14963 }
14964
14965 uint is_dir = S_ISDIR (file_stat.st_mode);
14966
14967 if (is_dir == 0)
14968 {
14969 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14970
14971 dictcnt++;
14972
14973 dictfiles[dictcnt - 1] = filename;
14974 }
14975 else
14976 {
14977 // do not allow --keyspace w/ a directory
14978
14979 if (keyspace == 1)
14980 {
14981 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14982
14983 return (-1);
14984 }
14985
14986 char **dictionary_files = NULL;
14987
14988 dictionary_files = scan_directory (filename);
14989
14990 if (dictionary_files != NULL)
14991 {
14992 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14993
14994 for (int d = 0; dictionary_files[d] != NULL; d++)
14995 {
14996 char *l1_filename = dictionary_files[d];
14997
14998 struct stat l1_stat;
14999
15000 if (stat (l1_filename, &l1_stat) == -1)
15001 {
15002 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15003
15004 return (-1);
15005 }
15006
15007 if (S_ISREG (l1_stat.st_mode))
15008 {
15009 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15010
15011 dictcnt++;
15012
15013 dictfiles[dictcnt - 1] = strdup (l1_filename);
15014 }
15015 }
15016 }
15017
15018 local_free (dictionary_files);
15019 }
15020 }
15021
15022 if (dictcnt < 1)
15023 {
15024 log_error ("ERROR: No usable dictionary file found.");
15025
15026 return (-1);
15027 }
15028
15029 if (increment)
15030 {
15031 maskcnt = 0;
15032
15033 uint mask_min = increment_min; // we can't reject smaller masks here
15034 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
15035
15036 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
15037 {
15038 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
15039
15040 if (cur_mask == NULL) break;
15041
15042 masks[maskcnt] = cur_mask;
15043
15044 maskcnt++;
15045
15046 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
15047 }
15048 }
15049 }
15050
15051 data.pw_min = pw_min;
15052 data.pw_max = pw_max;
15053
15054 /**
15055 * weak hash check
15056 */
15057
15058 if (weak_hash_threshold >= salts_cnt)
15059 {
15060 uint first_device_id = 0;
15061
15062 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15063 {
15064 hc_device_param_t *device_param = &data.devices_param[device_id];
15065
15066 if (device_param->skipped) continue;
15067
15068 first_device_id = device_id;
15069
15070 break;
15071 }
15072
15073 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
15074
15075 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
15076 {
15077 weak_hash_check (&data.devices_param[first_device_id], salt_pos, kernel_loops);
15078 }
15079 }
15080
15081 // Display hack, guarantee that there is at least one \r before real start
15082
15083 if (data.quiet == 0) log_info_nn ("");
15084
15085 /**
15086 * status and monitor threads
15087 */
15088
15089 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15090
15091 hc_thread_t i_thread = 0;
15092
15093 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15094 {
15095 hc_thread_create (i_thread, thread_keypress, &benchmark);
15096 }
15097
15098 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15099
15100 uint ni_threads_cnt = 0;
15101
15102 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15103
15104 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15105
15106 ni_threads_cnt++;
15107
15108 /**
15109 * Outfile remove
15110 */
15111
15112 if (keyspace == 0)
15113 {
15114 if (outfile_check_timer != 0)
15115 {
15116 if (data.outfile_check_directory != NULL)
15117 {
15118 if ((hash_mode != 5200) &&
15119 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15120 (hash_mode != 9000))
15121 {
15122 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15123
15124 ni_threads_cnt++;
15125 }
15126 else
15127 {
15128 outfile_check_timer = 0;
15129 }
15130 }
15131 else
15132 {
15133 outfile_check_timer = 0;
15134 }
15135 }
15136 }
15137
15138 /**
15139 * Inform the user if we got some hashes remove because of the pot file remove feature
15140 */
15141
15142 if (data.quiet == 0)
15143 {
15144 if (potfile_remove_cracks > 0)
15145 {
15146 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15147 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15148 }
15149 }
15150
15151 data.outfile_check_timer = outfile_check_timer;
15152
15153 /**
15154 * main loop
15155 */
15156
15157 char **induction_dictionaries = NULL;
15158
15159 int induction_dictionaries_cnt = 0;
15160
15161 hcstat_table_t *root_table_buf = NULL;
15162 hcstat_table_t *markov_table_buf = NULL;
15163
15164 uint initial_restore_done = 0;
15165
15166 data.maskcnt = maskcnt;
15167
15168 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15169 {
15170 if (data.devices_status == STATUS_CRACKED) break;
15171
15172 data.devices_status = STATUS_INIT;
15173
15174 if (maskpos > rd->maskpos)
15175 {
15176 rd->dictpos = 0;
15177 }
15178
15179 rd->maskpos = maskpos;
15180 data.maskpos = maskpos;
15181
15182 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15183 {
15184 char *mask = masks[maskpos];
15185
15186 if (mask_from_file == 1)
15187 {
15188 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15189
15190 char *str_ptr;
15191 uint str_pos;
15192
15193 uint mask_offset = 0;
15194
15195 uint separator_cnt;
15196
15197 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15198 {
15199 str_ptr = strstr (mask + mask_offset, ",");
15200
15201 if (str_ptr == NULL) break;
15202
15203 str_pos = str_ptr - mask;
15204
15205 // escaped separator, i.e. "\,"
15206
15207 if (str_pos > 0)
15208 {
15209 if (mask[str_pos - 1] == '\\')
15210 {
15211 separator_cnt --;
15212
15213 mask_offset = str_pos + 1;
15214
15215 continue;
15216 }
15217 }
15218
15219 // reset the offset
15220
15221 mask_offset = 0;
15222
15223 mask[str_pos] = '\0';
15224
15225 switch (separator_cnt)
15226 {
15227 case 0:
15228 mp_reset_usr (mp_usr, 0);
15229
15230 custom_charset_1 = mask;
15231 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15232 break;
15233
15234 case 1:
15235 mp_reset_usr (mp_usr, 1);
15236
15237 custom_charset_2 = mask;
15238 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15239 break;
15240
15241 case 2:
15242 mp_reset_usr (mp_usr, 2);
15243
15244 custom_charset_3 = mask;
15245 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15246 break;
15247
15248 case 3:
15249 mp_reset_usr (mp_usr, 3);
15250
15251 custom_charset_4 = mask;
15252 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15253 break;
15254 }
15255
15256 mask = mask + str_pos + 1;
15257 }
15258 }
15259
15260 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15261 {
15262 if (maskpos > 0)
15263 {
15264 local_free (css_buf);
15265 local_free (data.root_css_buf);
15266 local_free (data.markov_css_buf);
15267
15268 local_free (masks[maskpos - 1]);
15269 }
15270
15271 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15272
15273 data.mask = mask;
15274 data.css_cnt = css_cnt;
15275 data.css_buf = css_buf;
15276
15277 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15278
15279 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15280
15281 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15282 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15283
15284 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15285
15286 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15287
15288 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15289 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15290
15291 data.root_css_buf = root_css_buf;
15292 data.markov_css_buf = markov_css_buf;
15293
15294 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15295
15296 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15297
15298 local_free (root_table_buf);
15299 local_free (markov_table_buf);
15300
15301 // args
15302
15303 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15304 {
15305 hc_device_param_t *device_param = &data.devices_param[device_id];
15306
15307 if (device_param->skipped) continue;
15308
15309 device_param->kernel_params_mp[0] = &device_param->d_combs;
15310 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15311 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15312
15313 device_param->kernel_params_mp_buf64[3] = 0;
15314 device_param->kernel_params_mp_buf32[4] = css_cnt;
15315 device_param->kernel_params_mp_buf32[5] = 0;
15316 device_param->kernel_params_mp_buf32[6] = 0;
15317 device_param->kernel_params_mp_buf32[7] = 0;
15318
15319 if (attack_mode == ATTACK_MODE_HYBRID1)
15320 {
15321 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15322 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15323 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15324 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15325 }
15326 else if (attack_mode == ATTACK_MODE_HYBRID2)
15327 {
15328 device_param->kernel_params_mp_buf32[5] = 0;
15329 device_param->kernel_params_mp_buf32[6] = 0;
15330 device_param->kernel_params_mp_buf32[7] = 0;
15331 }
15332
15333 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15334 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15335 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15336
15337 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);
15338 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);
15339 }
15340 }
15341 else if (attack_mode == ATTACK_MODE_BF)
15342 {
15343 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15344
15345 if (increment)
15346 {
15347 for (uint i = 0; i < dictcnt; i++)
15348 {
15349 local_free (dictfiles[i]);
15350 }
15351
15352 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15353 {
15354 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15355
15356 if (l1_filename == NULL) break;
15357
15358 dictcnt++;
15359
15360 dictfiles[dictcnt - 1] = l1_filename;
15361 }
15362 }
15363 else
15364 {
15365 dictcnt++;
15366
15367 dictfiles[dictcnt - 1] = mask;
15368 }
15369
15370 if (dictcnt == 0)
15371 {
15372 log_error ("ERROR: Mask is too small");
15373
15374 return (-1);
15375 }
15376 }
15377 }
15378
15379 free (induction_dictionaries);
15380
15381 // induction_dictionaries_cnt = 0; // implied
15382
15383 if (attack_mode != ATTACK_MODE_BF)
15384 {
15385 if (keyspace == 0)
15386 {
15387 induction_dictionaries = scan_directory (induction_directory);
15388
15389 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15390 }
15391 }
15392
15393 if (induction_dictionaries_cnt)
15394 {
15395 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15396 }
15397
15398 /**
15399 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15400 */
15401 if (keyspace == 1)
15402 {
15403 if ((maskcnt > 1) || (dictcnt > 1))
15404 {
15405 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15406
15407 return (-1);
15408 }
15409 }
15410
15411 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15412 {
15413 char *subid = logfile_generate_subid ();
15414
15415 data.subid = subid;
15416
15417 logfile_sub_msg ("START");
15418
15419 data.devices_status = STATUS_INIT;
15420
15421 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
15422 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
15423 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
15424
15425 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15426
15427 data.cpt_pos = 0;
15428
15429 data.cpt_start = time (NULL);
15430
15431 data.cpt_total = 0;
15432
15433 if (data.restore == 0)
15434 {
15435 rd->words_cur = skip;
15436
15437 skip = 0;
15438
15439 data.skip = 0;
15440 }
15441
15442 data.ms_paused = 0;
15443
15444 data.words_cur = rd->words_cur;
15445
15446 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15447 {
15448 hc_device_param_t *device_param = &data.devices_param[device_id];
15449
15450 if (device_param->skipped) continue;
15451
15452 device_param->speed_pos = 0;
15453
15454 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
15455 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15456 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15457
15458 device_param->kernel_power = device_param->kernel_power_user;
15459 device_param->kernel_blocks = device_param->kernel_blocks_user;
15460
15461 device_param->outerloop_pos = 0;
15462 device_param->outerloop_left = 0;
15463 device_param->innerloop_pos = 0;
15464 device_param->innerloop_left = 0;
15465
15466 // some more resets:
15467
15468 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15469
15470 memset (device_param->pws_buf, 0, device_param->size_pws);
15471
15472 device_param->pw_cnt = 0;
15473 device_param->pws_cnt = 0;
15474
15475 device_param->words_off = 0;
15476 device_param->words_done = 0;
15477 }
15478
15479 data.kernel_blocks_div = 0;
15480
15481 // figure out some workload
15482
15483 if (attack_mode == ATTACK_MODE_STRAIGHT)
15484 {
15485 if (data.wordlist_mode == WL_MODE_FILE)
15486 {
15487 char *dictfile = NULL;
15488
15489 if (induction_dictionaries_cnt)
15490 {
15491 dictfile = induction_dictionaries[0];
15492 }
15493 else
15494 {
15495 dictfile = dictfiles[dictpos];
15496 }
15497
15498 data.dictfile = dictfile;
15499
15500 logfile_sub_string (dictfile);
15501
15502 for (uint i = 0; i < rp_files_cnt; i++)
15503 {
15504 logfile_sub_var_string ("rulefile", rp_files[i]);
15505 }
15506
15507 FILE *fd2 = fopen (dictfile, "rb");
15508
15509 if (fd2 == NULL)
15510 {
15511 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15512
15513 return (-1);
15514 }
15515
15516 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15517
15518 fclose (fd2);
15519
15520 if (data.words_cnt == 0)
15521 {
15522 if (data.devices_status == STATUS_CRACKED) break;
15523 if (data.devices_status == STATUS_ABORTED) break;
15524
15525 dictpos++;
15526
15527 continue;
15528 }
15529 }
15530 }
15531 else if (attack_mode == ATTACK_MODE_COMBI)
15532 {
15533 char *dictfile = data.dictfile;
15534 char *dictfile2 = data.dictfile2;
15535
15536 logfile_sub_string (dictfile);
15537 logfile_sub_string (dictfile2);
15538
15539 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15540 {
15541 FILE *fd2 = fopen (dictfile, "rb");
15542
15543 if (fd2 == NULL)
15544 {
15545 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15546
15547 return (-1);
15548 }
15549
15550 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15551
15552 fclose (fd2);
15553 }
15554 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15555 {
15556 FILE *fd2 = fopen (dictfile2, "rb");
15557
15558 if (fd2 == NULL)
15559 {
15560 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15561
15562 return (-1);
15563 }
15564
15565 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15566
15567 fclose (fd2);
15568 }
15569
15570 if (data.words_cnt == 0)
15571 {
15572 if (data.devices_status == STATUS_CRACKED) break;
15573 if (data.devices_status == STATUS_ABORTED) break;
15574
15575 dictpos++;
15576
15577 continue;
15578 }
15579 }
15580 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15581 {
15582 char *dictfile = NULL;
15583
15584 if (induction_dictionaries_cnt)
15585 {
15586 dictfile = induction_dictionaries[0];
15587 }
15588 else
15589 {
15590 dictfile = dictfiles[dictpos];
15591 }
15592
15593 data.dictfile = dictfile;
15594
15595 char *mask = data.mask;
15596
15597 logfile_sub_string (dictfile);
15598 logfile_sub_string (mask);
15599
15600 FILE *fd2 = fopen (dictfile, "rb");
15601
15602 if (fd2 == NULL)
15603 {
15604 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15605
15606 return (-1);
15607 }
15608
15609 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15610
15611 fclose (fd2);
15612
15613 if (data.words_cnt == 0)
15614 {
15615 if (data.devices_status == STATUS_CRACKED) break;
15616 if (data.devices_status == STATUS_ABORTED) break;
15617
15618 dictpos++;
15619
15620 continue;
15621 }
15622 }
15623 else if (attack_mode == ATTACK_MODE_BF)
15624 {
15625 local_free (css_buf);
15626 local_free (data.root_css_buf);
15627 local_free (data.markov_css_buf);
15628
15629 char *mask = dictfiles[dictpos];
15630
15631 logfile_sub_string (mask);
15632
15633 // base
15634
15635 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15636
15637 if (opts_type & OPTS_TYPE_PT_UNICODE)
15638 {
15639 uint css_cnt_unicode = css_cnt * 2;
15640
15641 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15642
15643 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15644 {
15645 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15646
15647 css_buf_unicode[j + 1].cs_buf[0] = 0;
15648 css_buf_unicode[j + 1].cs_len = 1;
15649 }
15650
15651 free (css_buf);
15652
15653 css_buf = css_buf_unicode;
15654 css_cnt = css_cnt_unicode;
15655 }
15656
15657 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15658
15659 uint mask_min = pw_min;
15660 uint mask_max = pw_max;
15661
15662 if (opts_type & OPTS_TYPE_PT_UNICODE)
15663 {
15664 mask_min *= 2;
15665 mask_max *= 2;
15666 }
15667
15668 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15669 {
15670 if (css_cnt < mask_min)
15671 {
15672 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15673 }
15674
15675 if (css_cnt > mask_max)
15676 {
15677 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15678 }
15679
15680 // skip to next mask
15681
15682 dictpos++;
15683
15684 rd->dictpos = dictpos;
15685
15686 logfile_sub_msg ("STOP");
15687
15688 continue;
15689 }
15690
15691 uint save_css_cnt = css_cnt;
15692
15693 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15694 {
15695 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15696 {
15697 uint salt_len = (uint) data.salts_buf[0].salt_len;
15698 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15699
15700 uint css_cnt_salt = css_cnt + salt_len;
15701
15702 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15703
15704 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15705
15706 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15707 {
15708 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15709 css_buf_salt[j].cs_len = 1;
15710 }
15711
15712 free (css_buf);
15713
15714 css_buf = css_buf_salt;
15715 css_cnt = css_cnt_salt;
15716 }
15717 }
15718
15719 data.mask = mask;
15720 data.css_cnt = css_cnt;
15721 data.css_buf = css_buf;
15722
15723 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15724
15725 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
15726
15727 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15728
15729 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15730 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15731
15732 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15733
15734 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15735
15736 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15737 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15738
15739 data.root_css_buf = root_css_buf;
15740 data.markov_css_buf = markov_css_buf;
15741
15742 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15743
15744 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15745
15746 local_free (root_table_buf);
15747 local_free (markov_table_buf);
15748
15749 // copy + args
15750
15751 uint css_cnt_l = css_cnt;
15752 uint css_cnt_r;
15753
15754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15755 {
15756 if (save_css_cnt < 6)
15757 {
15758 css_cnt_r = 1;
15759 }
15760 else if (save_css_cnt == 6)
15761 {
15762 css_cnt_r = 2;
15763 }
15764 else
15765 {
15766 if (opts_type & OPTS_TYPE_PT_UNICODE)
15767 {
15768 if (save_css_cnt == 8 || save_css_cnt == 10)
15769 {
15770 css_cnt_r = 2;
15771 }
15772 else
15773 {
15774 css_cnt_r = 4;
15775 }
15776 }
15777 else
15778 {
15779 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15780 {
15781 css_cnt_r = 3;
15782 }
15783 else
15784 {
15785 css_cnt_r = 4;
15786 }
15787 }
15788 }
15789 }
15790 else
15791 {
15792 css_cnt_r = 1;
15793
15794 /* unfinished code?
15795 int sum = css_buf[css_cnt_r - 1].cs_len;
15796
15797 for (uint i = 1; i < 4 && i < css_cnt; i++)
15798 {
15799 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15800
15801 css_cnt_r++;
15802
15803 sum *= css_buf[css_cnt_r - 1].cs_len;
15804 }
15805 */
15806 }
15807
15808 css_cnt_l -= css_cnt_r;
15809
15810 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15811
15812 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15813 {
15814 hc_device_param_t *device_param = &data.devices_param[device_id];
15815
15816 if (device_param->skipped) continue;
15817
15818 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15819 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15820 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15821
15822 device_param->kernel_params_mp_l_buf64[3] = 0;
15823 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15824 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15825 device_param->kernel_params_mp_l_buf32[6] = 0;
15826 device_param->kernel_params_mp_l_buf32[7] = 0;
15827 device_param->kernel_params_mp_l_buf32[8] = 0;
15828
15829 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15830 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15831 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15832 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15833
15834 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15835 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15836 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15837
15838 device_param->kernel_params_mp_r_buf64[3] = 0;
15839 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15840 device_param->kernel_params_mp_r_buf32[5] = 0;
15841 device_param->kernel_params_mp_r_buf32[6] = 0;
15842 device_param->kernel_params_mp_r_buf32[7] = 0;
15843
15844 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]);
15845 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]);
15846 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]);
15847
15848 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]);
15849 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]);
15850 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]);
15851
15852 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);
15853 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);
15854 }
15855 }
15856
15857 u64 words_base = data.words_cnt;
15858
15859 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15860 {
15861 if (data.kernel_rules_cnt)
15862 {
15863 words_base /= data.kernel_rules_cnt;
15864 }
15865 }
15866 else if (data.attack_kern == ATTACK_KERN_COMBI)
15867 {
15868 if (data.combs_cnt)
15869 {
15870 words_base /= data.combs_cnt;
15871 }
15872 }
15873 else if (data.attack_kern == ATTACK_KERN_BF)
15874 {
15875 if (data.bfs_cnt)
15876 {
15877 words_base /= data.bfs_cnt;
15878 }
15879 }
15880
15881 data.words_base = words_base;
15882
15883 if (keyspace == 1)
15884 {
15885 log_info ("%llu", (unsigned long long int) words_base);
15886
15887 return (0);
15888 }
15889
15890 if (data.words_cur > data.words_base)
15891 {
15892 log_error ("ERROR: restore value greater keyspace");
15893
15894 return (-1);
15895 }
15896
15897 if (data.words_cur)
15898 {
15899 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15900 {
15901 for (uint i = 0; i < data.salts_cnt; i++)
15902 {
15903 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15904 }
15905 }
15906 else if (data.attack_kern == ATTACK_KERN_COMBI)
15907 {
15908 for (uint i = 0; i < data.salts_cnt; i++)
15909 {
15910 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15911 }
15912 }
15913 else if (data.attack_kern == ATTACK_KERN_BF)
15914 {
15915 for (uint i = 0; i < data.salts_cnt; i++)
15916 {
15917 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15918 }
15919 }
15920 }
15921
15922 /*
15923 * Inform user about possible slow speeds
15924 */
15925
15926 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15927 {
15928 if (data.words_base < kernel_blocks_all)
15929 {
15930 if (quiet == 0)
15931 {
15932 log_info ("");
15933 log_info ("ATTENTION!");
15934 log_info (" The wordlist or mask you are using is too small.");
15935 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15936 log_info (" The cracking speed will drop.");
15937 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15938 log_info ("");
15939 }
15940 }
15941 }
15942
15943 /*
15944 * Update loopback file
15945 */
15946
15947 if (loopback == 1)
15948 {
15949 time_t now;
15950
15951 time (&now);
15952
15953 uint random_num = get_random_num (0, 9999);
15954
15955 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15956
15957 data.loopback_file = loopback_file;
15958 }
15959
15960 /*
15961 * Update dictionary statistic
15962 */
15963
15964 if (keyspace == 0)
15965 {
15966 dictstat_fp = fopen (dictstat, "wb");
15967
15968 if (dictstat_fp)
15969 {
15970 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15971
15972 fclose (dictstat_fp);
15973 }
15974 }
15975
15976 data.devices_status = STATUS_RUNNING;
15977
15978 if (initial_restore_done == 0)
15979 {
15980 if (data.restore_disable == 0) cycle_restore ();
15981
15982 initial_restore_done = 1;
15983 }
15984
15985 hc_timer_set (&data.timer_running);
15986
15987 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15988 {
15989 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15990 {
15991 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15992 if (quiet == 0) fflush (stdout);
15993 }
15994 }
15995 else if (wordlist_mode == WL_MODE_STDIN)
15996 {
15997 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15998 if (data.quiet == 0) log_info ("");
15999 }
16000
16001 time_t runtime_start;
16002
16003 time (&runtime_start);
16004
16005 data.runtime_start = runtime_start;
16006
16007 /**
16008 * create cracker threads
16009 */
16010
16011 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
16012
16013 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16014 {
16015 hc_device_param_t *device_param = &devices_param[device_id];
16016
16017 if (wordlist_mode == WL_MODE_STDIN)
16018 {
16019 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
16020 }
16021 else
16022 {
16023 hc_thread_create (c_threads[device_id], thread_calc, device_param);
16024 }
16025 }
16026
16027 // wait for crack threads to exit
16028
16029 hc_thread_wait (devices_cnt, c_threads);
16030
16031 local_free (c_threads);
16032
16033 data.restore = 0;
16034
16035 // finalize task
16036
16037 logfile_sub_var_uint ("status-after-work", data.devices_status);
16038
16039 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16040
16041 if (data.devices_status == STATUS_CRACKED) break;
16042 if (data.devices_status == STATUS_ABORTED) break;
16043
16044 if (data.devices_status == STATUS_BYPASS)
16045 {
16046 data.devices_status = STATUS_RUNNING;
16047 }
16048
16049 if (induction_dictionaries_cnt)
16050 {
16051 unlink (induction_dictionaries[0]);
16052 }
16053
16054 free (induction_dictionaries);
16055
16056 if (attack_mode != ATTACK_MODE_BF)
16057 {
16058 induction_dictionaries = scan_directory (induction_directory);
16059
16060 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16061 }
16062
16063 if (benchmark == 0)
16064 {
16065 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
16066 {
16067 if (quiet == 0) clear_prompt ();
16068
16069 if (quiet == 0) log_info ("");
16070
16071 if (status == 1)
16072 {
16073 status_display ();
16074 }
16075 else
16076 {
16077 if (quiet == 0) status_display ();
16078 }
16079
16080 if (quiet == 0) log_info ("");
16081 }
16082 }
16083
16084 if (attack_mode == ATTACK_MODE_BF)
16085 {
16086 dictpos++;
16087
16088 rd->dictpos = dictpos;
16089 }
16090 else
16091 {
16092 if (induction_dictionaries_cnt)
16093 {
16094 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16095 }
16096 else
16097 {
16098 dictpos++;
16099
16100 rd->dictpos = dictpos;
16101 }
16102 }
16103
16104 time_t runtime_stop;
16105
16106 time (&runtime_stop);
16107
16108 data.runtime_stop = runtime_stop;
16109
16110 logfile_sub_uint (runtime_start);
16111 logfile_sub_uint (runtime_stop);
16112
16113 logfile_sub_msg ("STOP");
16114
16115 global_free (subid);
16116 }
16117
16118 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16119
16120 if (data.devices_status == STATUS_CRACKED) break;
16121 if (data.devices_status == STATUS_ABORTED) break;
16122 if (data.devices_status == STATUS_QUIT) break;
16123
16124 if (data.devices_status == STATUS_BYPASS)
16125 {
16126 data.devices_status = STATUS_RUNNING;
16127 }
16128 }
16129
16130 // 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
16131
16132 if (attack_mode == ATTACK_MODE_STRAIGHT)
16133 {
16134 if (data.wordlist_mode == WL_MODE_FILE)
16135 {
16136 if (data.dictfile == NULL)
16137 {
16138 if (dictfiles != NULL)
16139 {
16140 data.dictfile = dictfiles[0];
16141
16142 hc_timer_set (&data.timer_running);
16143 }
16144 }
16145 }
16146 }
16147 // NOTE: combi is okay because it is already set beforehand
16148 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16149 {
16150 if (data.dictfile == NULL)
16151 {
16152 if (dictfiles != NULL)
16153 {
16154 hc_timer_set (&data.timer_running);
16155
16156 data.dictfile = dictfiles[0];
16157 }
16158 }
16159 }
16160 else if (attack_mode == ATTACK_MODE_BF)
16161 {
16162 if (data.mask == NULL)
16163 {
16164 hc_timer_set (&data.timer_running);
16165
16166 data.mask = masks[0];
16167 }
16168 }
16169
16170 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16171 {
16172 data.devices_status = STATUS_EXHAUSTED;
16173 }
16174
16175 // if cracked / aborted remove last induction dictionary
16176
16177 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16178 {
16179 struct stat induct_stat;
16180
16181 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16182 {
16183 unlink (induction_dictionaries[file_pos]);
16184 }
16185 }
16186
16187 // wait for non-interactive threads
16188
16189 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16190 {
16191 hc_thread_wait (1, &ni_threads[thread_idx]);
16192 }
16193
16194 local_free (ni_threads);
16195
16196 // wait for interactive threads
16197
16198 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16199 {
16200 hc_thread_wait (1, &i_thread);
16201 }
16202
16203 // we dont need restore file anymore
16204 if (data.restore_disable == 0)
16205 {
16206 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16207 {
16208 unlink (eff_restore_file);
16209 unlink (new_restore_file);
16210 }
16211 else
16212 {
16213 cycle_restore ();
16214 }
16215 }
16216
16217 // finally save left hashes
16218
16219 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16220 {
16221 save_hash ();
16222 }
16223
16224 /**
16225 * Clean up
16226 */
16227
16228 if (benchmark == 1)
16229 {
16230 status_benchmark ();
16231
16232 log_info ("");
16233 }
16234 else
16235 {
16236 if (quiet == 0) clear_prompt ();
16237
16238 if (quiet == 0) log_info ("");
16239
16240 if (status == 1)
16241 {
16242 status_display ();
16243 }
16244 else
16245 {
16246 if (quiet == 0) status_display ();
16247 }
16248
16249 if (quiet == 0) log_info ("");
16250 }
16251
16252 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16253 {
16254 hc_device_param_t *device_param = &data.devices_param[device_id];
16255
16256 if (device_param->skipped) continue;
16257
16258 local_free (device_param->result);
16259
16260 local_free (device_param->pw_caches);
16261
16262 local_free (device_param->combs_buf);
16263
16264 local_free (device_param->hooks_buf);
16265
16266 local_free (device_param->device_name);
16267
16268 local_free (device_param->device_name_chksum);
16269
16270 local_free (device_param->device_version);
16271
16272 local_free (device_param->driver_version);
16273
16274 if (device_param->pws_buf) myfree (device_param->pws_buf);
16275 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16276 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16277 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16278 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16279 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16280 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16281 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16282 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16283 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16284 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16285 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16286 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16287 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16288 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16289 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16290 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16291 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16292 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16293 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16294 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16295 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16296 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16297 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16298 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16299 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16300 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16301 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16302 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16303
16304 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16305 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16306 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16307 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16308 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16309 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16310 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16311 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16312 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16313 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16314 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16315
16316 if (device_param->program) hc_clReleaseProgram (device_param->program);
16317 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16318 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16319
16320 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16321 if (device_param->context) hc_clReleaseContext (device_param->context);
16322 }
16323
16324 // reset default fan speed
16325
16326 if (gpu_temp_disable == 0)
16327 {
16328 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16329 {
16330 hc_thread_mutex_lock (mux_adl);
16331
16332 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16333 {
16334 hc_device_param_t *device_param = &data.devices_param[device_id];
16335
16336 if (device_param->skipped) continue;
16337
16338 if (data.hm_device[device_id].fan_supported == 1)
16339 {
16340 int fanspeed = temp_retain_fanspeed_value[device_id];
16341
16342 if (fanspeed == -1) continue;
16343
16344 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
16345
16346 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
16347 }
16348 }
16349
16350 hc_thread_mutex_unlock (mux_adl);
16351 }
16352 }
16353
16354 // reset power tuning
16355
16356 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16357 {
16358 hc_thread_mutex_lock (mux_adl);
16359
16360 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16361 {
16362 hc_device_param_t *device_param = &data.devices_param[device_id];
16363
16364 if (device_param->skipped) continue;
16365
16366 if (data.hm_device[device_id].od_version == 6)
16367 {
16368 // check powertune capabilities first, if not available then skip device
16369
16370 int powertune_supported = 0;
16371
16372 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
16373 {
16374 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16375
16376 return (-1);
16377 }
16378
16379 if (powertune_supported != 0)
16380 {
16381 // powercontrol settings
16382
16383 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)
16384 {
16385 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16386
16387 return (-1);
16388 }
16389
16390 // clocks
16391
16392 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16393
16394 performance_state->iNumberOfPerformanceLevels = 2;
16395
16396 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
16397 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
16398 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
16399 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
16400
16401 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)
16402 {
16403 log_info ("ERROR: Failed to restore ADL performance state");
16404
16405 return (-1);
16406 }
16407
16408 local_free (performance_state);
16409 }
16410 }
16411 }
16412
16413 hc_thread_mutex_unlock (mux_adl);
16414 }
16415
16416 if (gpu_temp_disable == 0)
16417 {
16418 #ifdef LINUX
16419 if (data.hm_dll_nv)
16420 {
16421 hc_NVML_nvmlShutdown (data.hm_dll_nv);
16422
16423 hm_close (data.hm_dll_nv);
16424 }
16425 #endif
16426
16427 #ifdef WIN
16428 NvAPI_Unload ();
16429 #endif
16430
16431 if (data.hm_dll_amd)
16432 {
16433 hc_ADL_Main_Control_Destroy (data.hm_dll_amd);
16434
16435 hm_close (data.hm_dll_amd);
16436 }
16437 }
16438
16439 // free memory
16440
16441 local_free (masks);
16442
16443 local_free (dictstat_base);
16444
16445 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16446 {
16447 pot_t *pot_ptr = &pot[pot_pos];
16448
16449 hash_t *hash = &pot_ptr->hash;
16450
16451 local_free (hash->digest);
16452
16453 if (isSalted)
16454 {
16455 local_free (hash->salt);
16456 }
16457 }
16458
16459 local_free (pot);
16460
16461 local_free (all_kernel_rules_cnt);
16462 local_free (all_kernel_rules_buf);
16463
16464 local_free (wl_data->buf);
16465 local_free (wl_data);
16466
16467 local_free (bitmap_s1_a);
16468 local_free (bitmap_s1_b);
16469 local_free (bitmap_s1_c);
16470 local_free (bitmap_s1_d);
16471 local_free (bitmap_s2_a);
16472 local_free (bitmap_s2_b);
16473 local_free (bitmap_s2_c);
16474 local_free (bitmap_s2_d);
16475
16476 local_free (temp_retain_fanspeed_value);
16477 local_free (od_clock_mem_status);
16478 local_free (od_power_control_status);
16479
16480 global_free (devices_param);
16481
16482 global_free (kernel_rules_buf);
16483
16484 global_free (root_css_buf);
16485 global_free (markov_css_buf);
16486
16487 global_free (digests_buf);
16488 global_free (digests_shown);
16489 global_free (digests_shown_tmp);
16490
16491 global_free (salts_buf);
16492 global_free (salts_shown);
16493
16494 global_free (esalts_buf);
16495
16496 global_free (words_progress_done);
16497 global_free (words_progress_rejected);
16498 global_free (words_progress_restored);
16499
16500 if (pot_fp) fclose (pot_fp);
16501
16502 if (data.devices_status == STATUS_QUIT) break;
16503 }
16504
16505 // destroy others mutex
16506
16507 hc_thread_mutex_delete (mux_dispatcher);
16508 hc_thread_mutex_delete (mux_counter);
16509 hc_thread_mutex_delete (mux_display);
16510 hc_thread_mutex_delete (mux_adl);
16511
16512 // free memory
16513
16514 local_free (eff_restore_file);
16515 local_free (new_restore_file);
16516
16517 local_free (rd);
16518
16519 // loopback
16520
16521 local_free (loopback_file);
16522
16523 if (loopback == 1) unlink (loopback_file);
16524
16525 // induction directory
16526
16527 if (induction_dir == NULL)
16528 {
16529 if (attack_mode != ATTACK_MODE_BF)
16530 {
16531 if (rmdir (induction_directory) == -1)
16532 {
16533 if (errno == ENOENT)
16534 {
16535 // good, we can ignore
16536 }
16537 else if (errno == ENOTEMPTY)
16538 {
16539 // good, we can ignore
16540 }
16541 else
16542 {
16543 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16544
16545 return (-1);
16546 }
16547 }
16548
16549 local_free (induction_directory);
16550 }
16551 }
16552
16553 // outfile-check directory
16554
16555 if (outfile_check_dir == NULL)
16556 {
16557 if (rmdir (outfile_check_directory) == -1)
16558 {
16559 if (errno == ENOENT)
16560 {
16561 // good, we can ignore
16562 }
16563 else if (errno == ENOTEMPTY)
16564 {
16565 // good, we can ignore
16566 }
16567 else
16568 {
16569 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16570
16571 return (-1);
16572 }
16573 }
16574
16575 local_free (outfile_check_directory);
16576 }
16577
16578 time_t proc_stop;
16579
16580 time (&proc_stop);
16581
16582 logfile_top_uint (proc_start);
16583 logfile_top_uint (proc_stop);
16584
16585 logfile_top_msg ("STOP");
16586
16587 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16588 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16589
16590 if (data.devices_status == STATUS_ABORTED) return 2;
16591 if (data.devices_status == STATUS_QUIT) return 2;
16592 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16593 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16594 if (data.devices_status == STATUS_CRACKED) return 0;
16595
16596 return -1;
16597 }
Hashcat additions to support pwdhash