projects / hashcat.git / blob
? search:


63a8d6f1ef8cff696d7e8217cbbae446b2b67e9d
[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 128
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 6211,
253 6221,
254 6231,
255 6241,
256 8800,
257 12200,
258 9700,
259 9710,
260 9800,
261 9810,
262 9400,
263 9500,
264 9600,
265 10400,
266 10410,
267 10500,
268 10600,
269 10700,
270 9000,
271 5200,
272 6800,
273 6600,
274 8200,
275 11300,
276 12700
277 };
278
279 /**
280 * types
281 */
282
283 static void (*get_next_word_func) (char *, uint32_t, uint32_t *, uint32_t *);
284
285 /**
286 * globals
287 */
288
289 static unsigned int full01 = 0x01010101;
290 static unsigned int full80 = 0x80808080;
291
292 int SUPPRESS_OUTPUT = 0;
293
294 hc_thread_mutex_t mux_adl;
295 hc_thread_mutex_t mux_counter;
296 hc_thread_mutex_t mux_dispatcher;
297 hc_thread_mutex_t mux_display;
298
299 hc_global_data_t data;
300
301 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
302
303 const char *USAGE_MINI[] =
304 {
305 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
306 "",
307 "Try --help for more help.",
308 NULL
309 };
310
311 const char *USAGE_BIG[] =
312 {
313 "%s, advanced password recovery",
314 "",
315 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
316 "",
317 "=======",
318 "Options",
319 "=======",
320 "",
321 "* General:",
322 "",
323 " -m, --hash-type=NUM Hash-type, see references below",
324 " -a, --attack-mode=NUM Attack-mode, see references below",
325 " -V, --version Print version",
326 " -h, --help Print help",
327 " --quiet Suppress output",
328 "",
329 "* Benchmark:",
330 "",
331 " -b, --benchmark Run benchmark",
332 " --benchmark-mode=NUM Benchmark-mode, see references below",
333 "",
334 "* Misc:",
335 "",
336 " --hex-charset Assume charset is given in hex",
337 " --hex-salt Assume salt is given in hex",
338 " --hex-wordlist Assume words in wordlist is given in hex",
339 " --force Ignore warnings",
340 " --status Enable automatic update of the status-screen",
341 " --status-timer=NUM Seconds between status-screen update",
342 " --status-automat Display the status view in a machine readable format",
343 " --loopback Add new plains to induct directory",
344 " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts",
345 "",
346 "* Markov:",
347 "",
348 " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat",
349 " --markov-disable Disables markov-chains, emulates classic brute-force",
350 " --markov-classic Enables classic markov-chains, no per-position enhancement",
351 " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains",
352 "",
353 "* Session:",
354 "",
355 " --runtime=NUM Abort session after NUM seconds of runtime",
356 " --session=STR Define specific session name",
357 " --restore Restore session from --session",
358 " --restore-disable Do not write restore file",
359 "",
360 "* Files:",
361 "",
362 " -o, --outfile=FILE Define outfile for recovered hash",
363 " --outfile-format=NUM Define outfile-format for recovered hash, see references below",
364 " --outfile-autohex-disable Disable the use of $HEX[] in output plains",
365 " --outfile-check-timer=NUM Seconds between outfile checks",
366 " -p, --separator=CHAR Separator char for hashlists and outfile",
367 " --show Show cracked passwords only",
368 " --left Show un-cracked passwords only",
369 " --username Enable ignoring of usernames in hashfile (recommended: also use --show)",
370 " --remove Enable remove of hash once it is cracked",
371 " --remove-timer=NUM Update input hash file each NUM seconds",
372 " --potfile-disable Do not write potfile",
373 " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below",
374 " --debug-file=FILE Output file for debugging rules (see also --debug-mode)",
375 " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct",
376 " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles",
377 " --logfile-disable Disable the logfile",
378 " --truecrypt-keyfiles=FILE Keyfiles used, seperate with comma",
379 "",
380 "* Resources:",
381 "",
382 " -c, --segment-size=NUM Size in MB to cache from the wordfile",
383 " --bitmap-min=NUM Minimum number of bits allowed for bitmaps",
384 " --bitmap-max=NUM Maximum number of bits allowed for bitmaps",
385 " --cpu-affinity=STR Locks to CPU devices, seperate with comma",
386 " -d, --opencl-devices=STR OpenCL devices to use, separate with comma",
387 " --opencl-platform=NUM OpenCL platform to use, in case multiple platforms are present",
388 " -w, --workload-profile=NUM Enable a specific workload profile, see references below",
389 " -n, --kernel-accel=NUM Workload tuning: 1, 8, 40, 80, 160",
390 " -u, --kernel-loops=NUM Workload fine-tuning: 8 - 1024",
391 " --gpu-temp-disable Disable temperature and fanspeed readings and triggers",
392 " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius",
393 " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)",
394 " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)",
395 " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt",
396 "",
397 "* Distributed:",
398 "",
399 " -s, --skip=NUM Skip number of words",
400 " -l, --limit=NUM Limit number of words",
401 " --keyspace Show keyspace base:mod values and quit",
402 "",
403 "* Rules:",
404 "",
405 " -j, --rule-left=RULE Single rule applied to each word from left dict",
406 " -k, --rule-right=RULE Single rule applied to each word from right dict",
407 " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule",
408 " -g, --generate-rules=NUM Generate NUM random rules",
409 " --generate-rules-func-min=NUM Force NUM functions per random rule min",
410 " --generate-rules-func-max=NUM Force NUM functions per random rule max",
411 " --generate-rules-seed=NUM Force RNG seed to NUM",
412 "",
413 "* Custom charsets:",
414 "",
415 " -1, --custom-charset1=CS User-defined charsets",
416 " -2, --custom-charset2=CS Example:",
417 " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef",
418 " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file",
419 "",
420 "* Increment:",
421 "",
422 " -i, --increment Enable increment mode",
423 " --increment-min=NUM Start incrementing at NUM",
424 " --increment-max=NUM Stop incrementing at NUM",
425 "",
426 "==========",
427 "References",
428 "==========",
429 "",
430 "* Workload Profile:",
431 "",
432 " 1 = Reduced performance profile (low latency desktop)",
433 " 2 = Default performance profile",
434 " 3 = Tuned performance profile (high latency desktop)",
435 "",
436 "* Benchmark Settings:",
437 "",
438 " 0 = Manual Tuning",
439 " 1 = Performance Tuning, default",
440 "",
441 "* Outfile Formats:",
442 "",
443 " 1 = hash[:salt]",
444 " 2 = plain",
445 " 3 = hash[:salt]:plain",
446 " 4 = hex_plain",
447 " 5 = hash[:salt]:hex_plain",
448 " 6 = plain:hex_plain",
449 " 7 = hash[:salt]:plain:hex_plain",
450 " 8 = crackpos",
451 " 9 = hash[:salt]:crackpos",
452 " 10 = plain:crackpos",
453 " 11 = hash[:salt]:plain:crackpos",
454 " 12 = hex_plain:crackpos",
455 " 13 = hash[:salt]:hex_plain:crackpos",
456 " 14 = plain:hex_plain:crackpos",
457 " 15 = hash[:salt]:plain:hex_plain:crackpos",
458 "",
459 "* Debug mode output formats (for hybrid mode only, by using rules):",
460 "",
461 " 1 = save finding rule",
462 " 2 = save original word",
463 " 3 = save original word and finding rule",
464 " 4 = save original word, finding rule and modified plain",
465 "",
466 "* Built-in charsets:",
467 "",
468 " ?l = abcdefghijklmnopqrstuvwxyz",
469 " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ",
470 " ?d = 0123456789",
471 " ?s = !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
472 " ?a = ?l?u?d?s",
473 " ?b = 0x00 - 0xff",
474 "",
475 "* Attack modes:",
476 "",
477 " 0 = Straight",
478 " 1 = Combination",
479 " 3 = Brute-force",
480 " 6 = Hybrid dict + mask",
481 " 7 = Hybrid mask + dict",
482 "",
483 "* Hash types:",
484 "",
485 "[[ Roll-your-own: Raw Hashes ]]",
486 "",
487 " 900 = MD4",
488 " 0 = MD5",
489 " 5100 = Half MD5",
490 " 100 = SHA1",
491 " 10800 = SHA-384",
492 " 1400 = SHA-256",
493 " 1700 = SHA-512",
494 " 5000 = SHA-3(Keccak)",
495 " 10100 = SipHash",
496 " 6000 = RipeMD160",
497 " 6100 = Whirlpool",
498 " 6900 = GOST R 34.11-94",
499 " 11700 = GOST R 34.11-2012 (Streebog) 256-bit",
500 " 11800 = GOST R 34.11-2012 (Streebog) 512-bit",
501 "",
502 "[[ Roll-your-own: Iterated and / or Salted Hashes ]]",
503 "",
504 " 10 = md5($pass.$salt)",
505 " 20 = md5($salt.$pass)",
506 " 30 = md5(unicode($pass).$salt)",
507 " 40 = md5($salt.unicode($pass))",
508 " 3800 = md5($salt.$pass.$salt)",
509 " 3710 = md5($salt.md5($pass))",
510 " 2600 = md5(md5($pass)",
511 " 4300 = md5(strtoupper(md5($pass)))",
512 " 4400 = md5(sha1($pass))",
513 " 110 = sha1($pass.$salt)",
514 " 120 = sha1($salt.$pass)",
515 " 130 = sha1(unicode($pass).$salt)",
516 " 140 = sha1($salt.unicode($pass))",
517 " 4500 = sha1(sha1($pass)",
518 " 4700 = sha1(md5($pass))",
519 " 4900 = sha1($salt.$pass.$salt)",
520 " 1410 = sha256($pass.$salt)",
521 " 1420 = sha256($salt.$pass)",
522 " 1430 = sha256(unicode($pass).$salt)",
523 " 1440 = sha256($salt.unicode($pass))",
524 " 1710 = sha512($pass.$salt)",
525 " 1720 = sha512($salt.$pass)",
526 " 1730 = sha512(unicode($pass).$salt)",
527 " 1740 = sha512($salt.unicode($pass))",
528 "",
529 "[[ Roll-your-own: Authenticated Hashes ]]",
530 "",
531 " 50 = HMAC-MD5 (key = $pass)",
532 " 60 = HMAC-MD5 (key = $salt)",
533 " 150 = HMAC-SHA1 (key = $pass)",
534 " 160 = HMAC-SHA1 (key = $salt)",
535 " 1450 = HMAC-SHA256 (key = $pass)",
536 " 1460 = HMAC-SHA256 (key = $salt)",
537 " 1750 = HMAC-SHA512 (key = $pass)",
538 " 1760 = HMAC-SHA512 (key = $salt)",
539 "",
540 "[[ Generic KDF ]]",
541 "",
542 " 400 = phpass",
543 " 8900 = scrypt",
544 " 11900 = PBKDF2-HMAC-MD5",
545 " 12000 = PBKDF2-HMAC-SHA1",
546 " 10900 = PBKDF2-HMAC-SHA256",
547 " 12100 = PBKDF2-HMAC-SHA512",
548 "",
549 "[[ Network protocols, Challenge-Response ]]",
550 "",
551 " 23 = Skype",
552 " 2500 = WPA/WPA2",
553 " 4800 = iSCSI CHAP authentication, MD5(Chap)",
554 " 5300 = IKE-PSK MD5",
555 " 5400 = IKE-PSK SHA1",
556 " 5500 = NetNTLMv1",
557 " 5500 = NetNTLMv1 + ESS",
558 " 5600 = NetNTLMv2",
559 " 7300 = IPMI2 RAKP HMAC-SHA1",
560 " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23",
561 " 8300 = DNSSEC (NSEC3)",
562 " 10200 = Cram MD5",
563 " 11100 = PostgreSQL Challenge-Response Authentication (MD5)",
564 " 11200 = MySQL Challenge-Response Authentication (SHA1)",
565 " 11400 = SIP digest authentication (MD5)",
566 "",
567 "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]",
568 "",
569 " 121 = SMF (Simple Machines Forum)",
570 " 400 = phpBB3",
571 " 2611 = vBulletin < v3.8.5",
572 " 2711 = vBulletin > v3.8.5",
573 " 2811 = MyBB",
574 " 2811 = IPB (Invison Power Board)",
575 " 8400 = WBB3 (Woltlab Burning Board)",
576 " 11 = Joomla < 2.5.18",
577 " 400 = Joomla > 2.5.18",
578 " 400 = Wordpress",
579 " 2612 = PHPS",
580 " 7900 = Drupal7",
581 " 21 = osCommerce",
582 " 21 = xt:Commerce",
583 " 11000 = PrestaShop",
584 " 124 = Django (SHA-1)",
585 " 10000 = Django (PBKDF2-SHA256)",
586 " 3711 = Mediawiki B type",
587 " 7600 = Redmine",
588 "",
589 "[[ Database Server ]]",
590 "",
591 " 12 = PostgreSQL",
592 " 131 = MSSQL(2000)",
593 " 132 = MSSQL(2005)",
594 " 1731 = MSSQL(2012)",
595 " 1731 = MSSQL(2014)",
596 " 200 = MySQL323",
597 " 300 = MySQL4.1/MySQL5",
598 " 3100 = Oracle H: Type (Oracle 7+)",
599 " 112 = Oracle S: Type (Oracle 11+)",
600 " 12300 = Oracle T: Type (Oracle 12+)",
601 " 8000 = Sybase ASE",
602 "",
603 "[[ HTTP, SMTP, LDAP Server ]]",
604 "",
605 " 141 = EPiServer 6.x < v4",
606 " 1441 = EPiServer 6.x > v4",
607 " 1600 = Apache $apr1$",
608 " 12600 = ColdFusion 10+",
609 " 1421 = hMailServer",
610 " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA",
611 " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA",
612 " 1711 = SSHA-512(Base64), LDAP {SSHA512}",
613 "",
614 "[[ Checksums ]]",
615 "",
616 " 11500 = CRC32",
617 "",
618 "[[ Operating-Systems ]]",
619 "",
620 " 3000 = LM",
621 " 1000 = NTLM",
622 " 1100 = Domain Cached Credentials (DCC), MS Cache",
623 " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2",
624 " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256",
625 " 1500 = descrypt, DES(Unix), Traditional DES",
626 " 12400 = BSDiCrypt, Extended DES",
627 " 500 = md5crypt $1$, MD5(Unix)",
628 " 3200 = bcrypt $2*$, Blowfish(Unix)",
629 " 7400 = sha256crypt $5$, SHA256(Unix)",
630 " 1800 = sha512crypt $6$, SHA512(Unix)",
631 " 122 = OSX v10.4",
632 " 122 = OSX v10.5",
633 " 122 = OSX v10.6",
634 " 1722 = OSX v10.7",
635 " 7100 = OSX v10.8",
636 " 7100 = OSX v10.9",
637 " 7100 = OSX v10.10",
638 " 6300 = AIX {smd5}",
639 " 6700 = AIX {ssha1}",
640 " 6400 = AIX {ssha256}",
641 " 6500 = AIX {ssha512}",
642 " 2400 = Cisco-PIX",
643 " 2410 = Cisco-ASA",
644 " 500 = Cisco-IOS $1$",
645 " 5700 = Cisco-IOS $4$",
646 " 9200 = Cisco-IOS $8$",
647 " 9300 = Cisco-IOS $9$",
648 " 22 = Juniper Netscreen/SSG (ScreenOS)",
649 " 501 = Juniper IVE",
650 " 5800 = Android PIN",
651 " 8100 = Citrix Netscaler",
652 " 8500 = RACF",
653 " 7200 = GRUB 2",
654 " 9900 = Radmin2",
655 "",
656 "[[ Enterprise Application Software (EAS) ]]",
657 "",
658 " 7700 = SAP CODVN B (BCODE)",
659 " 7800 = SAP CODVN F/G (PASSCODE)",
660 " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1",
661 " 8600 = Lotus Notes/Domino 5",
662 " 8700 = Lotus Notes/Domino 6",
663 " 9100 = Lotus Notes/Domino 8",
664 " 133 = PeopleSoft",
665 "",
666 "[[ Archives ]]",
667 "",
668 " 11600 = 7-Zip",
669 " 12500 = RAR3-hp",
670 "",
671 "[[ Full-Disk encryptions (FDE) ]]",
672 "",
673 " 62XY = TrueCrypt 5.0+",
674 " X = 1 = PBKDF2-HMAC-RipeMD160",
675 " X = 2 = PBKDF2-HMAC-SHA512",
676 " X = 3 = PBKDF2-HMAC-Whirlpool",
677 " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode",
678 " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)",
679 " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)",
680 " Y = 3 = XTS 1536 bit (Ciphers: All)",
681 " 8800 = Android FDE < v4.3",
682 " 12200 = eCryptfs",
683 "",
684 "[[ Documents ]]",
685 "",
686 " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1",
687 " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1",
688 " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2",
689 " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4",
690 " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1",
691 " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2",
692 " 9400 = MS Office 2007",
693 " 9500 = MS Office 2010",
694 " 9600 = MS Office 2013",
695 " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)",
696 " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1",
697 " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2",
698 " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)",
699 " 10600 = PDF 1.7 Level 3 (Acrobat 9)",
700 " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)",
701 "",
702 "[[ Password Managers ]]",
703 "",
704 " 9000 = Password Safe v2",
705 " 5200 = Password Safe v3",
706 " 6800 = Lastpass",
707 " 6600 = 1Password, agilekeychain",
708 " 8200 = 1Password, cloudkeychain",
709 " 11300 = Bitcoin/Litecoin wallet.dat",
710 " 12700 = Blockchain, My Wallet",
711 "",
712 NULL
713 };
714
715 /**
716 * oclHashcat specific functions
717 */
718
719 void status_display_automat ()
720 {
721 FILE *out = stdout;
722
723 fprintf (out, "STATUS\t%u\t", data.devices_status);
724
725 /**
726 * speed new
727 */
728
729 fprintf (out, "SPEED\t");
730
731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
732 {
733 hc_device_param_t *device_param = &data.devices_param[device_id];
734
735 uint64_t speed_cnt = 0;
736 float speed_ms = 0;
737
738 for (int i = 0; i < SPEED_CACHE; i++)
739 {
740 float rec_ms;
741
742 hc_timer_get (device_param->speed_rec[i], rec_ms);
743
744 if (rec_ms > SPEED_MAXAGE) continue;
745
746 speed_cnt += device_param->speed_cnt[i];
747 speed_ms += device_param->speed_ms[i];
748 }
749
750 speed_cnt /= SPEED_CACHE;
751 speed_ms /= SPEED_CACHE;
752
753 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
754 }
755
756 /**
757 * words_cur
758 */
759
760 uint64_t words_cur = get_lowest_words_done ();
761
762 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
763
764 /**
765 * counter
766 */
767
768 uint salts_left = data.salts_cnt - data.salts_done;
769
770 if (salts_left == 0) salts_left = 1;
771
772 uint64_t progress_total = data.words_cnt * salts_left;
773
774 uint64_t all_done = 0;
775 uint64_t all_rejected = 0;
776 uint64_t all_restored = 0;
777
778 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
779 {
780 if (salts_left > 1)
781 {
782 // otherwise the final cracked status shows 0/XXX progress
783
784 if (data.salts_shown[salt_pos] == 1) continue;
785 }
786
787 all_done += data.words_progress_done[salt_pos];
788 all_rejected += data.words_progress_rejected[salt_pos];
789 all_restored += data.words_progress_restored[salt_pos];
790 }
791
792 uint64_t progress_cur = all_restored + all_done + all_rejected;
793 uint64_t progress_end = progress_total;
794
795 uint64_t progress_skip = 0;
796
797 if (data.skip)
798 {
799 progress_skip = MIN (data.skip, data.words_base) * salts_left;
800
801 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
802 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
803 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
804 }
805
806 if (data.limit)
807 {
808 progress_end = MIN (data.limit, data.words_base) * salts_left;
809
810 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
811 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
812 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
813 }
814
815 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
816 uint64_t progress_end_relative_skip = progress_end - progress_skip;
817
818 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
819
820 /**
821 * cracks
822 */
823
824 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
825 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
826
827 /**
828 * temperature
829 */
830
831 if (data.gpu_temp_disable == 0)
832 {
833 fprintf (out, "TEMP\t");
834
835 hc_thread_mutex_lock (mux_adl);
836
837 for (uint i = 0; i < data.devices_cnt; i++)
838 {
839 int temp = hm_get_temperature_with_device_id (i);
840
841 fprintf (out, "%d\t", temp);
842 }
843
844 hc_thread_mutex_unlock (mux_adl);
845 }
846
847 #ifdef _WIN
848 fputc ('\r', out);
849 fputc ('\n', out);
850 #endif
851
852 #ifdef _POSIX
853 fputc ('\n', out);
854 #endif
855
856 fflush (out);
857 }
858
859 void status_display ()
860 {
861 if (data.devices_status == STATUS_INIT) return;
862 if (data.devices_status == STATUS_STARTING) return;
863 if (data.devices_status == STATUS_BYPASS) return;
864
865 if (data.status_automat == 1)
866 {
867 status_display_automat ();
868
869 return;
870 }
871
872 char tmp_buf[1000];
873
874 uint tmp_len = 0;
875
876 log_info ("Session.Name...: %s", data.session);
877
878 char *status_type = strstatus (data.devices_status);
879
880 uint hash_mode = data.hash_mode;
881
882 char *hash_type = strhashtype (hash_mode); // not a bug
883
884 log_info ("Status.........: %s", status_type);
885
886 /**
887 * show rules
888 */
889
890 if (data.rp_files_cnt)
891 {
892 uint i;
893
894 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
895 {
896 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
897 }
898
899 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
900
901 log_info ("Rules.Type.....: %s", tmp_buf);
902
903 tmp_len = 0;
904 }
905
906 if (data.rp_gen)
907 {
908 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
909
910 if (data.rp_gen_seed)
911 {
912 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
913 }
914 }
915
916 /**
917 * show input
918 */
919
920 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
921 {
922 if (data.wordlist_mode == WL_MODE_FILE)
923 {
924 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
925 }
926 else if (data.wordlist_mode == WL_MODE_STDIN)
927 {
928 log_info ("Input.Mode.....: Pipe");
929 }
930 }
931 else if (data.attack_mode == ATTACK_MODE_COMBI)
932 {
933 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
934 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
935 }
936 else if (data.attack_mode == ATTACK_MODE_BF)
937 {
938 char *mask = data.mask;
939
940 if (mask != NULL)
941 {
942 uint mask_len = data.css_cnt;
943
944 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
945
946 if (mask_len > 0)
947 {
948 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
949 {
950 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
951 {
952 mask_len -= data.salts_buf[0].salt_len;
953 }
954 }
955
956 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
957
958 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
959 }
960
961 if (data.maskcnt > 1)
962 {
963 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
964
965 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
966 }
967
968 log_info ("Input.Mode.....: %s", tmp_buf);
969 }
970
971 tmp_len = 0;
972 }
973 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
974 {
975 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
976 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
977 }
978 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
979 {
980 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
981 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
982 }
983
984 if (data.digests_cnt == 1)
985 {
986 if (data.hash_mode == 2500)
987 {
988 wpa_t *wpa = (wpa_t *) data.esalts_buf;
989
990 uint pke[25];
991
992 char *pke_ptr = (char *) pke;
993
994 for (uint i = 0; i < 25; i++)
995 {
996 pke[i] = byte_swap_32 (wpa->pke[i]);
997 }
998
999 char mac1[6];
1000 char mac2[6];
1001
1002 memcpy (mac1, pke_ptr + 23, 6);
1003 memcpy (mac2, pke_ptr + 29, 6);
1004
1005 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1006 (char *) data.salts_buf[0].salt_buf,
1007 mac1[0] & 0xff,
1008 mac1[1] & 0xff,
1009 mac1[2] & 0xff,
1010 mac1[3] & 0xff,
1011 mac1[4] & 0xff,
1012 mac1[5] & 0xff,
1013 mac2[0] & 0xff,
1014 mac2[1] & 0xff,
1015 mac2[2] & 0xff,
1016 mac2[3] & 0xff,
1017 mac2[4] & 0xff,
1018 mac2[5] & 0xff);
1019 }
1020 else if (data.hash_mode == 5200)
1021 {
1022 log_info ("Hash.Target....: File (%s)", data.hashfile);
1023 }
1024 else if (data.hash_mode == 9000)
1025 {
1026 log_info ("Hash.Target....: File (%s)", data.hashfile);
1027 }
1028 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1029 {
1030 log_info ("Hash.Target....: File (%s)", data.hashfile);
1031 }
1032 else
1033 {
1034 char out_buf[4096];
1035
1036 ascii_digest (out_buf, 0, 0);
1037
1038 // limit length
1039 if (strlen (out_buf) > 40)
1040 {
1041 out_buf[41] = '.';
1042 out_buf[42] = '.';
1043 out_buf[43] = '.';
1044 out_buf[44] = 0;
1045 }
1046
1047 log_info ("Hash.Target....: %s", out_buf);
1048 }
1049 }
1050 else
1051 {
1052 if (data.hash_mode == 3000)
1053 {
1054 char out_buf1[4096];
1055 char out_buf2[4096];
1056
1057 ascii_digest (out_buf1, 0, 0);
1058 ascii_digest (out_buf2, 0, 1);
1059
1060 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1061 }
1062 else
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 }
1067
1068 log_info ("Hash.Type......: %s", hash_type);
1069
1070 /**
1071 * speed new
1072 */
1073
1074 uint64_t speed_cnt[DEVICES_MAX];
1075 float speed_ms[DEVICES_MAX];
1076
1077 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1078 {
1079 hc_device_param_t *device_param = &data.devices_param[device_id];
1080
1081 // we need to clear values (set to 0) because in case the device does
1082 // not get new candidates it idles around but speed display would
1083 // show it as working.
1084 // if we instantly set it to 0 after reading it happens that the
1085 // speed can be shown as zero if the users refreshs to fast.
1086 // therefore, we add a timestamp when a stat was recorded and if its
1087 // to old we will not use it
1088
1089 speed_cnt[device_id] = 0;
1090 speed_ms[device_id] = 0;
1091
1092 for (int i = 0; i < SPEED_CACHE; i++)
1093 {
1094 float rec_ms;
1095
1096 hc_timer_get (device_param->speed_rec[i], rec_ms);
1097
1098 if (rec_ms > SPEED_MAXAGE) continue;
1099
1100 speed_cnt[device_id] += device_param->speed_cnt[i];
1101 speed_ms[device_id] += device_param->speed_ms[i];
1102 }
1103
1104 speed_cnt[device_id] /= SPEED_CACHE;
1105 speed_ms[device_id] /= SPEED_CACHE;
1106 }
1107
1108 float hashes_all_ms = 0;
1109
1110 float hashes_dev_ms[DEVICES_MAX];
1111
1112 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1113 {
1114 hashes_dev_ms[device_id] = 0;
1115
1116 if (speed_ms[device_id])
1117 {
1118 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1119
1120 hashes_all_ms += hashes_dev_ms[device_id];
1121 }
1122 }
1123
1124 /**
1125 * timers
1126 */
1127
1128 float ms_running = 0;
1129
1130 hc_timer_get (data.timer_running, ms_running);
1131
1132 float ms_paused = data.ms_paused;
1133
1134 if (data.devices_status == STATUS_PAUSED)
1135 {
1136 float ms_paused_tmp = 0;
1137
1138 hc_timer_get (data.timer_paused, ms_paused_tmp);
1139
1140 ms_paused += ms_paused_tmp;
1141 }
1142
1143 #ifdef WIN
1144
1145 __time64_t sec_run = ms_running / 1000;
1146
1147 #else
1148
1149 time_t sec_run = ms_running / 1000;
1150
1151 #endif
1152
1153 if (sec_run)
1154 {
1155 char display_run[32];
1156
1157 struct tm tm_run;
1158
1159 struct tm *tmp;
1160
1161 #ifdef WIN
1162
1163 tmp = _gmtime64 (&sec_run);
1164
1165 #else
1166
1167 tmp = gmtime (&sec_run);
1168
1169 #endif
1170
1171 if (tmp != NULL)
1172 {
1173 memcpy (&tm_run, tmp, sizeof (struct tm));
1174
1175 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1176
1177 char *start = ctime (&data.proc_start);
1178
1179 size_t start_len = strlen (start);
1180
1181 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1182 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1183
1184 log_info ("Time.Started...: %s (%s)", start, display_run);
1185 }
1186 }
1187 else
1188 {
1189 log_info ("Time.Started...: 0 secs");
1190 }
1191
1192 /**
1193 * counters
1194 */
1195
1196 uint salts_left = data.salts_cnt - data.salts_done;
1197
1198 if (salts_left == 0) salts_left = 1;
1199
1200 uint64_t progress_total = data.words_cnt * salts_left;
1201
1202 uint64_t all_done = 0;
1203 uint64_t all_rejected = 0;
1204 uint64_t all_restored = 0;
1205
1206 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1207 {
1208 if (salts_left > 1)
1209 {
1210 // otherwise the final cracked status shows 0/XXX progress
1211
1212 if (data.salts_shown[salt_pos] == 1) continue;
1213 }
1214
1215 all_done += data.words_progress_done[salt_pos];
1216 all_rejected += data.words_progress_rejected[salt_pos];
1217 all_restored += data.words_progress_restored[salt_pos];
1218 }
1219
1220 uint64_t progress_cur = all_restored + all_done + all_rejected;
1221 uint64_t progress_end = progress_total;
1222
1223 uint64_t progress_skip = 0;
1224
1225 if (data.skip)
1226 {
1227 progress_skip = MIN (data.skip, data.words_base) * salts_left;
1228
1229 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1230 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1231 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1232 }
1233
1234 if (data.limit)
1235 {
1236 progress_end = MIN (data.limit, data.words_base) * salts_left;
1237
1238 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1239 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1240 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1241 }
1242
1243 uint64_t progress_cur_relative_skip = progress_cur - progress_skip;
1244 uint64_t progress_end_relative_skip = progress_end - progress_skip;
1245
1246 float speed_ms_real = ms_running - ms_paused;
1247 uint64_t speed_plains_real = all_done;
1248
1249 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1250 {
1251 if (data.devices_status != STATUS_CRACKED)
1252 {
1253 uint64_t words_per_ms = 0;
1254
1255 if (speed_plains_real && speed_ms_real)
1256 {
1257 words_per_ms = speed_plains_real / speed_ms_real;
1258 }
1259
1260 #ifdef WIN
1261 __time64_t sec_etc = 0;
1262 #else
1263 time_t sec_etc = 0;
1264 #endif
1265
1266 if (words_per_ms)
1267 {
1268 uint64_t progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1269
1270 uint64_t ms_left = progress_left_relative_skip / words_per_ms;
1271
1272 sec_etc = ms_left / 1000;
1273 }
1274
1275 if (sec_etc == 0)
1276 {
1277 log_info ("Time.Estimated.: 0 secs");
1278 }
1279 else if ((uint64_t) sec_etc > ETC_MAX)
1280 {
1281 log_info ("Time.Estimated.: > 10 Years");
1282 }
1283 else
1284 {
1285 char display_etc[32];
1286
1287 struct tm tm_etc;
1288
1289 struct tm *tmp;
1290
1291 #ifdef WIN
1292
1293 tmp = _gmtime64 (&sec_etc);
1294
1295 #else
1296
1297 tmp = gmtime (&sec_etc);
1298
1299 #endif
1300
1301 if (tmp != NULL)
1302 {
1303 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1304
1305 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1306
1307 time_t now;
1308
1309 time (&now);
1310
1311 now += sec_etc;
1312
1313 char *etc = ctime (&now);
1314
1315 size_t etc_len = strlen (etc);
1316
1317 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1318 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1319
1320 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1321 }
1322 }
1323 }
1324 }
1325
1326 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1327 {
1328 char display_dev_cur[16];
1329
1330 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1331
1332 strncpy (display_dev_cur, "0.00", 4);
1333
1334 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1335
1336 log_info ("Speed.Dev.#%d...: %9sH/s", device_id + 1, display_dev_cur);
1337 }
1338
1339 char display_all_cur[16];
1340
1341 memset (display_all_cur, 0, sizeof (display_all_cur));
1342
1343 strncpy (display_all_cur, "0.00", 4);
1344
1345 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1346
1347 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1348
1349 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1350 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1351
1352 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);
1353
1354 // crack-per-time
1355
1356 if (data.digests_cnt > 100)
1357 {
1358 time_t now = time (NULL);
1359
1360 int cpt_cur_min = 0;
1361 int cpt_cur_hour = 0;
1362 int cpt_cur_day = 0;
1363
1364 for (int i = 0; i < CPT_BUF; i++)
1365 {
1366 const uint cracked = data.cpt_buf[i].cracked;
1367 const time_t timestamp = data.cpt_buf[i].timestamp;
1368
1369 if ((timestamp + 60) > now)
1370 {
1371 cpt_cur_min += cracked;
1372 }
1373
1374 if ((timestamp + 3600) > now)
1375 {
1376 cpt_cur_hour += cracked;
1377 }
1378
1379 if ((timestamp + 86400) > now)
1380 {
1381 cpt_cur_day += cracked;
1382 }
1383 }
1384
1385 float cpt_avg_min = (float) data.cpt_total / ((speed_ms_real / 1000) / 60);
1386 float cpt_avg_hour = (float) data.cpt_total / ((speed_ms_real / 1000) / 3600);
1387 float cpt_avg_day = (float) data.cpt_total / ((speed_ms_real / 1000) / 86400);
1388
1389 if ((data.cpt_start + 86400) < now)
1390 {
1391 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1392 cpt_cur_min,
1393 cpt_cur_hour,
1394 cpt_cur_day,
1395 cpt_avg_min,
1396 cpt_avg_hour,
1397 cpt_avg_day);
1398 }
1399 else if ((data.cpt_start + 3600) < now)
1400 {
1401 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1402 cpt_cur_min,
1403 cpt_cur_hour,
1404 cpt_avg_min,
1405 cpt_avg_hour,
1406 cpt_avg_day);
1407 }
1408 else if ((data.cpt_start + 60) < now)
1409 {
1410 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1411 cpt_cur_min,
1412 cpt_avg_min,
1413 cpt_avg_hour,
1414 cpt_avg_day);
1415 }
1416 else
1417 {
1418 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1419 cpt_avg_min,
1420 cpt_avg_hour,
1421 cpt_avg_day);
1422 }
1423 }
1424
1425 // Restore point
1426
1427 uint64_t restore_point = get_lowest_words_done ();
1428
1429 uint64_t restore_total = data.words_base;
1430
1431 float percent_restore = 0;
1432
1433 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1434
1435 if (progress_end_relative_skip)
1436 {
1437 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1438 {
1439 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1440 float percent_rejected = 0.0;
1441
1442 if (progress_cur)
1443 {
1444 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1445 }
1446
1447 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);
1448 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1449
1450 if (data.restore_disable == 0)
1451 {
1452 if (percent_finished != 1)
1453 {
1454 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1455 }
1456 }
1457 }
1458 }
1459 else
1460 {
1461 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1462 {
1463 log_info ("Progress.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1464 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1465
1466 if (data.restore_disable == 0)
1467 {
1468 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (uint64_t) 0, (uint64_t) 0, (float) 100);
1469 }
1470 }
1471 else
1472 {
1473 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1474 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1475
1476 // --restore not allowed if stdin is used -- really? why?
1477
1478 //if (data.restore_disable == 0)
1479 //{
1480 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1481 //}
1482 }
1483 }
1484
1485 if (data.gpu_temp_disable == 0)
1486 {
1487 hc_thread_mutex_lock (mux_adl);
1488
1489 for (uint i = 0; i < data.devices_cnt; i++)
1490 {
1491 if (data.hm_device[i].fan_supported == 1)
1492 {
1493 const int temperature = hm_get_temperature_with_device_id (i);
1494 const int utilization = hm_get_utilization_with_device_id (i);
1495 const int fanspeed = hm_get_fanspeed_with_device_id (i);
1496
1497 if (data.vendor_id == VENDOR_ID_AMD)
1498 {
1499 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1500 }
1501
1502 if (data.vendor_id == VENDOR_ID_NV)
1503 {
1504 #ifdef LINUX
1505 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2d%% Fan", i + 1, utilization, temperature, fanspeed);
1506 #else
1507 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, %2drpm Fan", i + 1, utilization, temperature, fanspeed);
1508 #endif
1509 }
1510 }
1511 else
1512 {
1513 const int temperature = hm_get_temperature_with_device_id (i);
1514 const int utilization = hm_get_utilization_with_device_id (i);
1515
1516 log_info ("HWMon.GPU.#%d...: %2d%% Util, %2dc Temp, N/A Fan", i + 1, utilization, temperature);
1517 }
1518 }
1519
1520 hc_thread_mutex_unlock (mux_adl);
1521 }
1522 }
1523
1524 static void status_benchmark ()
1525 {
1526 if (data.devices_status == STATUS_INIT) return;
1527 if (data.devices_status == STATUS_STARTING) return;
1528
1529 if (data.words_cnt == 0) return;
1530
1531 uint64_t speed_cnt[DEVICES_MAX];
1532 float speed_ms[DEVICES_MAX];
1533
1534 uint device_id;
1535
1536 for (device_id = 0; device_id < data.devices_cnt; device_id++)
1537 {
1538 hc_device_param_t *device_param = &data.devices_param[device_id];
1539
1540 speed_cnt[device_id] = 0;
1541 speed_ms[device_id] = 0;
1542
1543 for (int i = 0; i < SPEED_CACHE; i++)
1544 {
1545 speed_cnt[device_id] += device_param->speed_cnt[i];
1546 speed_ms[device_id] += device_param->speed_ms[i];
1547 }
1548
1549 speed_cnt[device_id] /= SPEED_CACHE;
1550 speed_ms[device_id] /= SPEED_CACHE;
1551 }
1552
1553 float hashes_all_ms = 0;
1554
1555 float hashes_dev_ms[DEVICES_MAX];
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hashes_dev_ms[device_id] = 0;
1560
1561 if (speed_ms[device_id])
1562 {
1563 hashes_dev_ms[device_id] = speed_cnt[device_id] / speed_ms[device_id];
1564
1565 hashes_all_ms += hashes_dev_ms[device_id];
1566 }
1567 }
1568
1569 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1570 {
1571 char display_dev_cur[16];
1572
1573 memset (display_dev_cur, 0, sizeof (display_dev_cur));
1574
1575 strncpy (display_dev_cur, "0.00", 4);
1576
1577 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1578
1579 log_info ("Speed.Dev.#%d.: %9sH/s", device_id + 1, display_dev_cur);
1580 }
1581
1582 char display_all_cur[16];
1583
1584 memset (display_all_cur, 0, sizeof (display_all_cur));
1585
1586 strncpy (display_all_cur, "0.00", 4);
1587
1588 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1589
1590 if (data.devices_cnt > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1591 }
1592
1593 /**
1594 * oclHashcat -only- functions
1595 */
1596
1597 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1598 {
1599 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1600 {
1601 if (attack_kern == ATTACK_KERN_STRAIGHT)
1602 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1603 else if (attack_kern == ATTACK_KERN_COMBI)
1604 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1605 else if (attack_kern == ATTACK_KERN_BF)
1606 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1607 }
1608 else
1609 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1610 }
1611
1612 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, int vendor_id, char *cached_file)
1613 {
1614 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1615 {
1616 if (attack_kern == ATTACK_KERN_STRAIGHT)
1617 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a0.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1618 else if (attack_kern == ATTACK_KERN_COMBI)
1619 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a1.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1620 else if (attack_kern == ATTACK_KERN_BF)
1621 snprintf (cached_file, 255, "%s/kernels/%d/m%05d_a3.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1622 }
1623 else
1624 {
1625 snprintf (cached_file, 255, "%s/kernels/%d/m%05d.%s.kernel", profile_dir, vendor_id, (int) kern_type, device_name_chksum);
1626 }
1627 }
1628
1629 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1630 {
1631 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1632 {
1633 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1634 }
1635 else
1636 {
1637 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1638 }
1639 }
1640
1641 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1642 {
1643 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1644 {
1645 snprintf (cached_file, 255, "%s/kernels/%d/markov_be.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1646 }
1647 else
1648 {
1649 snprintf (cached_file, 255, "%s/kernels/%d/markov_le.%s.kernel", profile_dir, vendor_id, device_name_chksum);
1650 }
1651 }
1652
1653 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1654 {
1655 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1656 }
1657
1658 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, char *device_name_chksum, int vendor_id, char *cached_file)
1659 {
1660 snprintf (cached_file, 255, "%s/kernels/%d/amp_a%d.%s.kernel", profile_dir, vendor_id, attack_kern, device_name_chksum);
1661 }
1662
1663 static uint convert_from_hex (char *line_buf, const uint line_len)
1664 {
1665 if (line_len & 1) return (line_len); // not in hex
1666
1667 if (data.hex_wordlist == 1)
1668 {
1669 uint i;
1670 uint j;
1671
1672 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1673 {
1674 line_buf[i] = hex_to_char (&line_buf[j]);
1675 }
1676
1677 memset (line_buf + i, 0, line_len - i);
1678
1679 return (i);
1680 }
1681 else if (line_len >= 6) // $HEX[] = 6
1682 {
1683 if (line_buf[0] != '$') return (line_len);
1684 if (line_buf[1] != 'H') return (line_len);
1685 if (line_buf[2] != 'E') return (line_len);
1686 if (line_buf[3] != 'X') return (line_len);
1687 if (line_buf[4] != '[') return (line_len);
1688 if (line_buf[line_len - 1] != ']') return (line_len);
1689
1690 uint i;
1691 uint j;
1692
1693 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1694 {
1695 line_buf[i] = hex_to_char (&line_buf[j]);
1696 }
1697
1698 memset (line_buf + i, 0, line_len - i);
1699
1700 return (i);
1701 }
1702
1703 return (line_len);
1704 }
1705
1706 static uint count_lines (FILE *fd)
1707 {
1708 uint cnt = 0;
1709
1710 char *buf = (char *) mymalloc (BUFSIZ);
1711
1712 size_t nread_tmp = 0;
1713
1714 char *ptr = buf;
1715
1716 while (!feof (fd))
1717 {
1718 size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
1719 nread_tmp = nread;
1720
1721 if (nread < 1) continue;
1722
1723 ptr = buf;
1724
1725 do
1726 {
1727 if (*ptr++ == '\n') cnt++;
1728
1729 } while (nread--);
1730 }
1731
1732 // special case (if last line did not contain a newline char ... at the very end of the file)
1733
1734 if (nread_tmp > 3)
1735 {
1736 ptr -= 2;
1737
1738 if (*ptr != '\n')
1739 {
1740 ptr--;
1741
1742 if (*ptr != '\n') // needed ? different on windows systems?
1743 {
1744 cnt++;
1745 }
1746 }
1747 }
1748
1749 myfree (buf);
1750
1751 return cnt;
1752 }
1753
1754 static void clear_prompt ()
1755 {
1756 fputc ('\r', stdout);
1757
1758 for (size_t i = 0; i < strlen (PROMPT); i++)
1759 {
1760 fputc (' ', stdout);
1761 }
1762
1763 fputc ('\r', stdout);
1764
1765 fflush (stdout);
1766 }
1767
1768 static void gidd_to_pw_t (hc_device_param_t *device_param, const uint64_t gidd, pw_t *pw)
1769 {
1770 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1771 }
1772
1773 static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos)
1774 {
1775 char *outfile = data.outfile;
1776 uint quiet = data.quiet;
1777 FILE *pot_fp = data.pot_fp;
1778 uint loopback = data.loopback;
1779 uint debug_mode = data.debug_mode;
1780 char *debug_file = data.debug_file;
1781
1782 char debug_rule_buf[BLOCK_SIZE];
1783 int debug_rule_len = 0; // -1 error
1784 uint debug_plain_len = 0;
1785
1786 unsigned char debug_plain_ptr[BLOCK_SIZE];
1787
1788 // hash
1789
1790 char out_buf[4096]; memset (out_buf, 0, sizeof (out_buf));
1791
1792 ascii_digest (out_buf, salt_pos, digest_pos);
1793
1794 uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos;
1795
1796 // plain
1797
1798 plain_t plain;
1799
1800 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL);
1801
1802 uint gidvid = plain.gidvid;
1803 uint il_pos = plain.il_pos;
1804
1805 uint64_t crackpos = device_param->words_off;
1806
1807 uint plain_buf[16];
1808
1809 unsigned char *plain_ptr = (unsigned char *) plain_buf;
1810 unsigned int plain_len = 0;
1811
1812 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1813 {
1814 uint64_t gidd = gidvid;
1815 uint64_t gidm = 0;
1816
1817 pw_t pw;
1818
1819 gidd_to_pw_t (device_param, gidd, &pw);
1820
1821 for (int i = 0, j = gidm; i < 16; i++, j++)
1822 {
1823 plain_buf[i] = pw.hi1[0][j];
1824 }
1825
1826 plain_len = pw.pw_len;
1827
1828 const uint off = device_param->innerloop_pos + il_pos;
1829
1830 if (debug_mode > 0)
1831 {
1832 debug_rule_len = 0;
1833
1834 // save rule
1835 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1836 {
1837 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1838
1839 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1840 }
1841
1842 // save plain
1843 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1844 {
1845 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1846
1847 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1848
1849 debug_plain_len = plain_len;
1850 }
1851 }
1852
1853 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1854
1855 crackpos += gidvid;
1856 crackpos *= data.kernel_rules_cnt;
1857 crackpos += device_param->innerloop_pos + il_pos;
1858
1859 if (plain_len > data.pw_max) plain_len = data.pw_max;
1860 }
1861 else if (data.attack_mode == ATTACK_MODE_COMBI)
1862 {
1863 uint64_t gidd = gidvid;
1864 uint64_t gidm = 0;
1865
1866 pw_t pw;
1867
1868 gidd_to_pw_t (device_param, gidd, &pw);
1869
1870 for (int i = 0, j = gidm; i < 16; i++, j++)
1871 {
1872 plain_buf[i] = pw.hi1[0][j];
1873 }
1874
1875 plain_len = pw.pw_len;
1876
1877 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1878 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1879
1880 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1881 {
1882 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1883 }
1884 else
1885 {
1886 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1887
1888 memcpy (plain_ptr, comb_buf, comb_len);
1889 }
1890
1891 plain_len += comb_len;
1892
1893 crackpos += gidvid;
1894 crackpos *= data.combs_cnt;
1895 crackpos += device_param->innerloop_pos + il_pos;
1896
1897 if (data.pw_max != PW_DICTMAX1)
1898 {
1899 if (plain_len > data.pw_max) plain_len = data.pw_max;
1900 }
1901 }
1902 else if (data.attack_mode == ATTACK_MODE_BF)
1903 {
1904 uint64_t l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1905 uint64_t r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1906
1907 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1908 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1909
1910 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1911 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1912
1913 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1914 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1915
1916 plain_len = data.css_cnt;
1917
1918 crackpos += gidvid;
1919 crackpos *= data.bfs_cnt;
1920 crackpos += device_param->innerloop_pos + il_pos;
1921 }
1922 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1923 {
1924 uint64_t gidd = gidvid;
1925 uint64_t gidm = 0;
1926
1927 pw_t pw;
1928
1929 gidd_to_pw_t (device_param, gidd, &pw);
1930
1931 for (int i = 0, j = gidm; i < 16; i++, j++)
1932 {
1933 plain_buf[i] = pw.hi1[0][j];
1934 }
1935
1936 plain_len = pw.pw_len;
1937
1938 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1939
1940 uint start = 0;
1941 uint stop = device_param->kernel_params_mp_buf32[4];
1942
1943 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1944
1945 plain_len += start + stop;
1946
1947 crackpos += gidvid;
1948 crackpos *= data.combs_cnt;
1949 crackpos += device_param->innerloop_pos + il_pos;
1950
1951 if (data.pw_max != PW_DICTMAX1)
1952 {
1953 if (plain_len > data.pw_max) plain_len = data.pw_max;
1954 }
1955 }
1956 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1957 {
1958 uint64_t gidd = gidvid;
1959 uint64_t gidm = 0;
1960
1961 pw_t pw;
1962
1963 gidd_to_pw_t (device_param, gidd, &pw);
1964
1965 for (int i = 0, j = gidm; i < 16; i++, j++)
1966 {
1967 plain_buf[i] = pw.hi1[0][j];
1968 }
1969
1970 plain_len = pw.pw_len;
1971
1972 uint64_t off = device_param->kernel_params_mp_buf64[3] + il_pos;
1973
1974 uint start = 0;
1975 uint stop = device_param->kernel_params_mp_buf32[4];
1976
1977 memmove (plain_ptr + stop, plain_ptr, plain_len);
1978
1979 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
1980
1981 plain_len += start + stop;
1982
1983 crackpos += gidvid;
1984 crackpos *= data.combs_cnt;
1985 crackpos += device_param->innerloop_pos + il_pos;
1986
1987 if (data.pw_max != PW_DICTMAX1)
1988 {
1989 if (plain_len > data.pw_max) plain_len = data.pw_max;
1990 }
1991 }
1992
1993 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
1994 {
1995 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1996 {
1997 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1998 {
1999 plain_len = plain_len - data.salts_buf[0].salt_len;
2000 }
2001 }
2002
2003 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2004 {
2005 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2006 {
2007 plain_ptr[j] = plain_ptr[i];
2008 }
2009
2010 plain_len = plain_len / 2;
2011 }
2012 }
2013
2014 // if enabled, update also the potfile
2015
2016 if (pot_fp)
2017 {
2018 fprintf (pot_fp, "%s:", out_buf);
2019
2020 format_plain (pot_fp, plain_ptr, plain_len, 1);
2021
2022 fputc ('\n', pot_fp);
2023
2024 fflush (pot_fp);
2025 }
2026
2027 // outfile
2028
2029 FILE *out_fp = NULL;
2030
2031 if (outfile != NULL)
2032 {
2033 if ((out_fp = fopen (outfile, "ab")) == NULL)
2034 {
2035 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2036
2037 out_fp = stdout;
2038 }
2039 }
2040 else
2041 {
2042 out_fp = stdout;
2043
2044 if (quiet == 0) clear_prompt ();
2045 }
2046
2047 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2048
2049 if (outfile != NULL)
2050 {
2051 if (out_fp != stdout)
2052 {
2053 fclose (out_fp);
2054 }
2055 }
2056 else
2057 {
2058 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2059 {
2060 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2061 {
2062 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2063 if (quiet == 0) fflush (stdout);
2064 }
2065 }
2066 }
2067
2068 // loopback
2069
2070 if (loopback)
2071 {
2072 char *loopback_file = data.loopback_file;
2073
2074 FILE *fb_fp = NULL;
2075
2076 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2077 {
2078 format_plain (fb_fp, plain_ptr, plain_len, 1);
2079
2080 fputc ('\n', fb_fp);
2081
2082 fclose (fb_fp);
2083 }
2084 }
2085
2086 // (rule) debug mode
2087
2088 // the next check implies that:
2089 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2090 // - debug_mode > 0
2091
2092 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2093 {
2094 if (debug_rule_len < 0) debug_rule_len = 0;
2095
2096 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2097
2098 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2099
2100 if ((quiet == 0) && (debug_file == NULL))
2101 {
2102 fprintf (stdout, "%s", PROMPT);
2103 fflush (stdout);
2104 }
2105 }
2106 }
2107
2108 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2109 {
2110 salt_t *salt_buf = &data.salts_buf[salt_pos];
2111
2112 int found = 0;
2113
2114 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2115
2116 for (uint i = 0; i < KERNEL_THREADS; i++) if (device_param->result[i] == 1) found = 1;
2117
2118 if (found == 1)
2119 {
2120 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2121
2122 log_info_nn ("");
2123
2124 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);
2125
2126 uint cpt_cracked = 0;
2127
2128 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2129 {
2130 uint idx = salt_buf->digests_offset + digest_pos;
2131
2132 if (data.digests_shown_tmp[idx] == 0) continue;
2133
2134 if (data.digests_shown[idx] == 1) continue;
2135
2136 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2137 {
2138 data.digests_shown[idx] = 1;
2139
2140 data.digests_done++;
2141
2142 cpt_cracked++;
2143
2144 salt_buf->digests_done++;
2145
2146 if (salt_buf->digests_done == salt_buf->digests_cnt)
2147 {
2148 data.salts_shown[salt_pos] = 1;
2149
2150 data.salts_done++;
2151 }
2152 }
2153
2154 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2155
2156 check_hash (device_param, salt_pos, digest_pos);
2157 }
2158
2159 if (cpt_cracked > 0)
2160 {
2161 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2162 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2163
2164 data.cpt_pos++;
2165
2166 data.cpt_total += cpt_cracked;
2167
2168 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2169 }
2170
2171 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2172 {
2173 // we need to reset cracked state on the device
2174 // otherwise host thinks again and again the hash was cracked
2175 // and returns invalid password each time
2176
2177 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2178
2179 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);
2180 }
2181
2182 memset (device_param->result, 0, device_param->size_results);
2183
2184 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL);
2185 }
2186 }
2187
2188 static void save_hash ()
2189 {
2190 char *hashfile = data.hashfile;
2191
2192 char new_hashfile[256];
2193 char old_hashfile[256];
2194
2195 memset (new_hashfile, 0, sizeof (new_hashfile));
2196 memset (old_hashfile, 0, sizeof (old_hashfile));
2197
2198 snprintf (new_hashfile, 255, "%s.new", hashfile);
2199 snprintf (old_hashfile, 255, "%s.old", hashfile);
2200
2201 unlink (new_hashfile);
2202
2203 char separator = data.separator;
2204
2205 FILE *fp = fopen (new_hashfile, "wb");
2206
2207 if (fp == NULL)
2208 {
2209 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2210
2211 exit (-1);
2212 }
2213
2214 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2215 {
2216 if (data.salts_shown[salt_pos] == 1) continue;
2217
2218 salt_t *salt_buf = &data.salts_buf[salt_pos];
2219
2220 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2221 {
2222 uint idx = salt_buf->digests_offset + digest_pos;
2223
2224 if (data.digests_shown[idx] == 1) continue;
2225
2226 if (data.hash_mode != 2500)
2227 {
2228 char out_buf[4096];
2229
2230 memset (out_buf, 0, sizeof (out_buf));
2231
2232 if (data.username == 1)
2233 {
2234 user_t *user = data.hash_info[idx]->user;
2235
2236 uint i;
2237
2238 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2239
2240 fputc (separator, fp);
2241 }
2242
2243 ascii_digest (out_buf, salt_pos, digest_pos);
2244
2245 fputs (out_buf, fp);
2246
2247 log_out (fp, "");
2248 }
2249 else
2250 {
2251 hccap_t hccap;
2252
2253 to_hccap_t (&hccap, salt_pos, digest_pos);
2254
2255 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2256 }
2257 }
2258 }
2259
2260 fflush (fp);
2261
2262 fclose (fp);
2263
2264 unlink (old_hashfile);
2265
2266 if (rename (hashfile, old_hashfile) != 0)
2267 {
2268 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 unlink (hashfile);
2274
2275 if (rename (new_hashfile, hashfile) != 0)
2276 {
2277 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2278
2279 exit (-1);
2280 }
2281
2282 unlink (old_hashfile);
2283 }
2284
2285 static float find_kernel_blocks_div (const uint64_t total_left, const uint kernel_blocks_all)
2286 {
2287 // function called only in case kernel_blocks_all > words_left)
2288
2289 float kernel_blocks_div = (float) (total_left) / kernel_blocks_all;
2290
2291 kernel_blocks_div += kernel_blocks_div / 100;
2292
2293 uint32_t kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2294
2295 while (kernel_blocks_new < total_left)
2296 {
2297 kernel_blocks_div += kernel_blocks_div / 100;
2298
2299 kernel_blocks_new = (uint32_t) (kernel_blocks_all * kernel_blocks_div);
2300 }
2301
2302 if (data.quiet == 0)
2303 {
2304 clear_prompt ();
2305
2306 log_info ("");
2307
2308 log_info ("INFO: approaching final keyspace, workload adjusted");
2309
2310 log_info ("");
2311
2312 fprintf (stdout, "%s", PROMPT);
2313
2314 fflush (stdout);
2315 }
2316
2317 if ((kernel_blocks_all * kernel_blocks_div) < 8) return 1;
2318
2319 return kernel_blocks_div;
2320 }
2321
2322 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num)
2323 {
2324 uint num_elements = num;
2325
2326 device_param->kernel_params_buf32[30] = data.combs_mode;
2327 device_param->kernel_params_buf32[31] = num;
2328
2329 uint kernel_threads = device_param->kernel_threads;
2330
2331 while (num_elements % kernel_threads) num_elements++;
2332
2333 cl_kernel kernel = NULL;
2334
2335 switch (kern_run)
2336 {
2337 case KERN_RUN_1: kernel = device_param->kernel1; break;
2338 case KERN_RUN_12: kernel = device_param->kernel12; break;
2339 case KERN_RUN_2: kernel = device_param->kernel2; break;
2340 case KERN_RUN_23: kernel = device_param->kernel23; break;
2341 case KERN_RUN_3: kernel = device_param->kernel3; break;
2342 }
2343
2344 hc_clSetKernelArg (kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2345 hc_clSetKernelArg (kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2346 hc_clSetKernelArg (kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2347 hc_clSetKernelArg (kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2348 hc_clSetKernelArg (kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2349 hc_clSetKernelArg (kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2350 hc_clSetKernelArg (kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2351 hc_clSetKernelArg (kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2352 hc_clSetKernelArg (kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2353 hc_clSetKernelArg (kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2354 hc_clSetKernelArg (kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2355
2356 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2357 {
2358 const size_t global_work_size[3] = { num_elements, 32, 1 };
2359 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2360
2361 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2362 }
2363 else
2364 {
2365 const size_t global_work_size[3] = { num_elements, 1, 1 };
2366 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2367
2368 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2369 }
2370
2371 hc_clFlush (device_param->command_queue);
2372
2373 hc_clFinish (device_param->command_queue);
2374 }
2375
2376 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2377 {
2378 uint num_elements = num;
2379
2380 switch (kern_run)
2381 {
2382 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2383 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2384 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2385 }
2386
2387 // causes problems with special threads like in bcrypt
2388 // const uint kernel_threads = device_param->kernel_threads;
2389
2390 const uint kernel_threads = KERNEL_THREADS;
2391
2392 while (num_elements % kernel_threads) num_elements++;
2393
2394 cl_kernel kernel = NULL;
2395
2396 switch (kern_run)
2397 {
2398 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2399 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2400 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2401 }
2402
2403 switch (kern_run)
2404 {
2405 case KERN_RUN_MP: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2406 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2407 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2408 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2409 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2410 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2411 break;
2412 case KERN_RUN_MP_R: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2413 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2414 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2415 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2416 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2417 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2418 break;
2419 case KERN_RUN_MP_L: hc_clSetKernelArg (kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2420 hc_clSetKernelArg (kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2421 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2422 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2423 hc_clSetKernelArg (kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2424 hc_clSetKernelArg (kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2425 hc_clSetKernelArg (kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2426 break;
2427 }
2428
2429 const size_t global_work_size[3] = { num_elements, 1, 1 };
2430 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2431
2432 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2433
2434 hc_clFlush (device_param->command_queue);
2435
2436 hc_clFinish (device_param->command_queue);
2437 }
2438
2439 static void run_kernel_tb (hc_device_param_t *device_param, const uint num)
2440 {
2441 uint num_elements = num;
2442
2443 uint kernel_threads = device_param->kernel_threads;
2444
2445 while (num_elements % kernel_threads) num_elements++;
2446
2447 cl_kernel kernel = device_param->kernel_tb;
2448
2449 const size_t global_work_size[3] = { num_elements, 1, 1 };
2450 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2451
2452 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2453
2454 hc_clFlush (device_param->command_queue);
2455
2456 hc_clFinish (device_param->command_queue);
2457 }
2458
2459 static void run_kernel_tm (hc_device_param_t *device_param)
2460 {
2461 const uint num_elements = 1024; // fixed
2462
2463 const uint kernel_threads = 32;
2464
2465 cl_kernel kernel = device_param->kernel_tm;
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_amp (hc_device_param_t *device_param, const uint num)
2478 {
2479 uint num_elements = num;
2480
2481 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2482 device_param->kernel_params_amp_buf32[6] = num_elements;
2483
2484 // causes problems with special threads like in bcrypt
2485 // const uint kernel_threads = device_param->kernel_threads;
2486
2487 const uint kernel_threads = KERNEL_THREADS;
2488
2489 while (num_elements % kernel_threads) num_elements++;
2490
2491 cl_kernel kernel = device_param->kernel_amp;
2492
2493 hc_clSetKernelArg (kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2494 hc_clSetKernelArg (kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2495
2496 const size_t global_work_size[3] = { num_elements, 1, 1 };
2497 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2498
2499 hc_clEnqueueNDRangeKernel (device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2500
2501 hc_clFlush (device_param->command_queue);
2502
2503 hc_clFinish (device_param->command_queue);
2504 }
2505
2506 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const uint size)
2507 {
2508 if (data.vendor_id == VENDOR_ID_AMD)
2509 {
2510 const cl_uchar zero = 0;
2511
2512 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2513 }
2514
2515 if (data.vendor_id == VENDOR_ID_NV)
2516 {
2517 // NOTE: clEnqueueFillBuffer () always fails with -59
2518 // IOW, it's not supported by Nvidia ForceWare <= 352.21,
2519 // How's that possible, OpenCL 1.2 support is advertised??
2520 // We need to workaround...
2521
2522 #define FILLSZ 0x100000
2523
2524 char *tmp = (char *) mymalloc (FILLSZ);
2525
2526 memset (tmp, 0, FILLSZ);
2527
2528 for (uint i = 0; i < size; i += FILLSZ)
2529 {
2530 const int left = size - i;
2531
2532 const int fillsz = MIN (FILLSZ, left);
2533
2534 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2535 }
2536
2537 myfree (tmp);
2538 }
2539
2540 if (data.vendor_id == VENDOR_ID_POCL)
2541 {
2542 // NOTE: clEnqueueFillBuffer () segfaults with Ubuntu 15.04 pocl
2543 // We need to workaround...
2544
2545 #define FILLSZ 0x100000
2546
2547 char *tmp = (char *) mymalloc (FILLSZ);
2548
2549 memset (tmp, 0, FILLSZ);
2550
2551 for (uint i = 0; i < size; i += FILLSZ)
2552 {
2553 const int left = size - i;
2554
2555 const int fillsz = MIN (FILLSZ, left);
2556
2557 hc_clEnqueueWriteBuffer (device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2558 }
2559
2560 myfree (tmp);
2561 }
2562
2563 if (data.vendor_id == VENDOR_ID_UNKNOWN)
2564 {
2565 const cl_uchar zero = 0;
2566
2567 hc_clEnqueueFillBuffer (device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2568 }
2569 }
2570
2571 static int run_rule_engine (const int rule_len, const char *rule_buf)
2572 {
2573 if (rule_len == 0)
2574 {
2575 return 0;
2576 }
2577 else if (rule_len == 1)
2578 {
2579 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2580 }
2581
2582 return 1;
2583 }
2584
2585 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2586 {
2587 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2588 {
2589 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);
2590 }
2591 else if (data.attack_kern == ATTACK_KERN_COMBI)
2592 {
2593 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);
2594 }
2595 else if (data.attack_kern == ATTACK_KERN_BF)
2596 {
2597 const uint64_t off = device_param->words_off;
2598
2599 device_param->kernel_params_mp_l_buf64[3] = off;
2600
2601 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2602 }
2603 }
2604
2605 static void run_cracker (hc_device_param_t *device_param, const uint pw_cnt, const uint pws_cnt)
2606 {
2607 const uint kernel_loops = data.kernel_loops;
2608
2609 // init speed timer
2610
2611 uint speed_pos = device_param->speed_pos;
2612
2613 #ifdef _POSIX
2614 if (device_param->timer_speed.tv_sec == 0)
2615 {
2616 hc_timer_set (&device_param->timer_speed);
2617 }
2618 #endif
2619
2620 #ifdef _WIN
2621 if (device_param->timer_speed.QuadPart == 0)
2622 {
2623 hc_timer_set (&device_param->timer_speed);
2624 }
2625 #endif
2626
2627 // find higest password length, this is for optimization stuff
2628
2629 uint highest_pw_len = 0;
2630
2631 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2632 {
2633 }
2634 else if (data.attack_kern == ATTACK_KERN_COMBI)
2635 {
2636 }
2637 else if (data.attack_kern == ATTACK_KERN_BF)
2638 {
2639 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
2640 + device_param->kernel_params_mp_l_buf32[5];
2641 }
2642
2643 // bitslice optimization stuff
2644
2645 if (data.attack_mode == ATTACK_MODE_BF)
2646 {
2647 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2648 {
2649 run_kernel_tb (device_param, pws_cnt);
2650 }
2651 }
2652
2653 // iteration type
2654
2655 uint innerloop_step = 0;
2656 uint innerloop_cnt = 0;
2657
2658 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = kernel_loops;
2659 else innerloop_step = 1;
2660
2661 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
2662 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
2663 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
2664
2665 // loop start: most outer loop = salt iteration, then innerloops (if multi)
2666
2667 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2668 {
2669 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2670
2671 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2672
2673 if (data.devices_status == STATUS_CRACKED) break;
2674 if (data.devices_status == STATUS_ABORTED) break;
2675 if (data.devices_status == STATUS_QUIT) break;
2676 if (data.devices_status == STATUS_BYPASS) break;
2677
2678 if (data.salts_shown[salt_pos] == 1) continue;
2679
2680 salt_t *salt_buf = &data.salts_buf[salt_pos];
2681
2682 device_param->kernel_params_buf32[24] = salt_pos;
2683 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
2684 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
2685
2686 FILE *combs_fp = device_param->combs_fp;
2687
2688 if (data.attack_mode == ATTACK_MODE_COMBI)
2689 {
2690 rewind (combs_fp);
2691 }
2692
2693 // innerloops
2694
2695 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
2696 {
2697 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
2698
2699 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2700
2701 if (data.devices_status == STATUS_CRACKED) break;
2702 if (data.devices_status == STATUS_ABORTED) break;
2703 if (data.devices_status == STATUS_QUIT) break;
2704 if (data.devices_status == STATUS_BYPASS) break;
2705
2706 uint innerloop_left = innerloop_cnt - innerloop_pos;
2707
2708 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
2709
2710 device_param->innerloop_pos = innerloop_pos;
2711 device_param->innerloop_left = innerloop_left;
2712
2713 device_param->kernel_params_buf32[27] = innerloop_left;
2714
2715 if (innerloop_left == 0) continue;
2716
2717 // initialize amplifiers
2718
2719 if (data.attack_mode == ATTACK_MODE_COMBI)
2720 {
2721 char line_buf[BUFSIZ];
2722
2723 uint i = 0;
2724
2725 while (i < innerloop_left)
2726 {
2727 if (feof (combs_fp)) break;
2728
2729 int line_len = fgetl (combs_fp, line_buf);
2730
2731 if (line_len >= PW_MAX1) continue;
2732
2733 line_len = convert_from_hex (line_buf, line_len);
2734
2735 char *line_buf_new = line_buf;
2736
2737 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
2738 {
2739 char rule_buf_out[BLOCK_SIZE];
2740
2741 memset (rule_buf_out, 0, sizeof (rule_buf_out));
2742
2743 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
2744
2745 if (rule_len_out < 0)
2746 {
2747 data.words_progress_rejected[salt_pos] += pw_cnt;
2748
2749 continue;
2750 }
2751
2752 line_len = rule_len_out;
2753
2754 line_buf_new = rule_buf_out;
2755 }
2756
2757 line_len = MIN (line_len, PW_DICTMAX);
2758
2759 char *ptr = (char *) device_param->combs_buf[i].i;
2760
2761 memcpy (ptr, line_buf_new, line_len);
2762
2763 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
2764
2765 if (data.opts_type & OPTS_TYPE_PT_UPPER)
2766 {
2767 uppercase (ptr, line_len);
2768 }
2769
2770 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2771 {
2772 if (data.opts_type & OPTS_TYPE_PT_ADD80)
2773 {
2774 ptr[line_len] = 0x80;
2775 }
2776
2777 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2778 {
2779 ptr[line_len] = 0x01;
2780 }
2781 }
2782
2783 device_param->combs_buf[i].pw_len = line_len;
2784
2785 i++;
2786 }
2787
2788 for (uint j = i; j < innerloop_left; j++)
2789 {
2790 device_param->combs_buf[j].i[0] = 0;
2791 device_param->combs_buf[j].i[1] = 0;
2792 device_param->combs_buf[j].i[2] = 0;
2793 device_param->combs_buf[j].i[3] = 0;
2794 device_param->combs_buf[j].i[4] = 0;
2795 device_param->combs_buf[j].i[5] = 0;
2796 device_param->combs_buf[j].i[6] = 0;
2797 device_param->combs_buf[j].i[7] = 0;
2798
2799 device_param->combs_buf[j].pw_len = 0;
2800 }
2801
2802 innerloop_left = i;
2803 }
2804 else if (data.attack_mode == ATTACK_MODE_BF)
2805 {
2806 uint64_t off = innerloop_pos;
2807
2808 device_param->kernel_params_mp_r_buf64[3] = off;
2809
2810 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
2811 }
2812 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2813 {
2814 uint64_t off = innerloop_pos;
2815
2816 device_param->kernel_params_mp_buf64[3] = off;
2817
2818 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2821 {
2822 uint64_t off = innerloop_pos;
2823
2824 device_param->kernel_params_mp_buf64[3] = off;
2825
2826 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
2827 }
2828
2829 // copy amplifiers
2830
2831 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2832 {
2833 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);
2834 }
2835 else if (data.attack_mode == ATTACK_MODE_COMBI)
2836 {
2837 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);
2838 }
2839 else if (data.attack_mode == ATTACK_MODE_BF)
2840 {
2841 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);
2842 }
2843 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2844 {
2845 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);
2846 }
2847 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2848 {
2849 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);
2850 }
2851
2852 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2853 {
2854 if (data.attack_mode == ATTACK_MODE_BF)
2855 {
2856 if (data.opts_type & OPTS_TYPE_PT_BITSLICE)
2857 {
2858 const uint size_tm = 32 * sizeof (bs_word_t);
2859
2860 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2861
2862 run_kernel_tm (device_param);
2863
2864 hc_clEnqueueCopyBuffer (device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2865 }
2866 }
2867
2868 if (highest_pw_len < 16)
2869 {
2870 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2871 }
2872 else if (highest_pw_len < 32)
2873 {
2874 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2875 }
2876 else
2877 {
2878 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2879 }
2880 }
2881 else
2882 {
2883 run_kernel_amp (device_param, pws_cnt);
2884
2885 run_kernel (KERN_RUN_1, device_param, pws_cnt);
2886
2887 if (data.opts_type & OPTS_TYPE_HOOK12)
2888 {
2889 run_kernel (KERN_RUN_12, device_param, pws_cnt);
2890 }
2891
2892 uint iter = salt_buf->salt_iter;
2893
2894 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
2895 {
2896 uint loop_left = iter - loop_pos;
2897
2898 loop_left = MIN (loop_left, kernel_loops);
2899
2900 device_param->kernel_params_buf32[25] = loop_pos;
2901 device_param->kernel_params_buf32[26] = loop_left;
2902
2903 run_kernel (KERN_RUN_2, device_param, pws_cnt);
2904
2905 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2906
2907 if (data.devices_status == STATUS_CRACKED) break;
2908 if (data.devices_status == STATUS_ABORTED) break;
2909 if (data.devices_status == STATUS_QUIT) break;
2910 }
2911
2912 if (data.opts_type & OPTS_TYPE_HOOK23)
2913 {
2914 run_kernel (KERN_RUN_23, device_param, pws_cnt);
2915
2916 hc_clEnqueueReadBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2917
2918 // do something with data
2919
2920 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2921 }
2922
2923 run_kernel (KERN_RUN_3, device_param, pws_cnt);
2924 }
2925
2926 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
2927
2928 if (data.devices_status == STATUS_CRACKED) break;
2929 if (data.devices_status == STATUS_ABORTED) break;
2930 if (data.devices_status == STATUS_QUIT) break;
2931
2932 /**
2933 * result
2934 */
2935
2936 hc_thread_mutex_lock (mux_display);
2937
2938 check_cracked (device_param, salt_pos);
2939
2940 hc_thread_mutex_unlock (mux_display);
2941
2942 /**
2943 * progress
2944 */
2945
2946 uint64_t perf_sum_all = (uint64_t) pw_cnt * (uint64_t) innerloop_left;
2947
2948 hc_thread_mutex_lock (mux_counter);
2949
2950 data.words_progress_done[salt_pos] += perf_sum_all;
2951
2952 hc_thread_mutex_unlock (mux_counter);
2953
2954 /**
2955 * speed
2956 */
2957
2958 float speed_ms;
2959
2960 hc_timer_get (device_param->timer_speed, speed_ms);
2961
2962 hc_timer_set (&device_param->timer_speed);
2963
2964 hc_thread_mutex_lock (mux_display);
2965
2966 device_param->speed_cnt[speed_pos] = perf_sum_all;
2967
2968 device_param->speed_ms[speed_pos] = speed_ms;
2969
2970 device_param->speed_rec[speed_pos] = device_param->timer_speed;
2971
2972 hc_thread_mutex_unlock (mux_display);
2973
2974 speed_pos++;
2975
2976 if (speed_pos == SPEED_CACHE)
2977 {
2978 speed_pos = 0;
2979 }
2980 }
2981 }
2982
2983 device_param->speed_pos = speed_pos;
2984 }
2985
2986 static void load_segment (wl_data_t *wl_data, FILE *fd)
2987 {
2988 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
2989
2990 wl_data->pos = 0;
2991
2992 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
2993
2994 wl_data->buf[wl_data->cnt] = 0;
2995
2996 if (wl_data->cnt == 0) return;
2997
2998 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
2999
3000 while (!feof (fd))
3001 {
3002 if (wl_data->cnt == wl_data->avail)
3003 {
3004 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3005
3006 wl_data->avail += wl_data->incr;
3007 }
3008
3009 const int c = fgetc (fd);
3010
3011 if (c == EOF) break;
3012
3013 wl_data->buf[wl_data->cnt] = (char) c;
3014
3015 wl_data->cnt++;
3016
3017 if (c == '\n') break;
3018 }
3019
3020 // ensure stream ends with a newline
3021
3022 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3023 {
3024 wl_data->cnt++;
3025
3026 wl_data->buf[wl_data->cnt - 1] = '\n';
3027 }
3028
3029 return;
3030 }
3031
3032 static void get_next_word_lm (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3033 {
3034 char *ptr = buf;
3035
3036 for (uint32_t i = 0; i < sz; i++, ptr++)
3037 {
3038 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3039
3040 if (i == 7)
3041 {
3042 *off = i;
3043 *len = i;
3044
3045 return;
3046 }
3047
3048 if (*ptr != '\n') continue;
3049
3050 *off = i + 1;
3051
3052 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3053
3054 *len = i;
3055
3056 return;
3057 }
3058
3059 *off = sz;
3060 *len = sz;
3061 }
3062
3063 static void get_next_word_uc (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3064 {
3065 char *ptr = buf;
3066
3067 for (uint32_t i = 0; i < sz; i++, ptr++)
3068 {
3069 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3070
3071 if (*ptr != '\n') continue;
3072
3073 *off = i + 1;
3074
3075 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3076
3077 *len = i;
3078
3079 return;
3080 }
3081
3082 *off = sz;
3083 *len = sz;
3084 }
3085
3086 static void get_next_word_std (char *buf, uint32_t sz, uint32_t *len, uint32_t *off)
3087 {
3088 char *ptr = buf;
3089
3090 for (uint32_t i = 0; i < sz; i++, ptr++)
3091 {
3092 if (*ptr != '\n') continue;
3093
3094 *off = i + 1;
3095
3096 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3097
3098 *len = i;
3099
3100 return;
3101 }
3102
3103 *off = sz;
3104 *len = sz;
3105 }
3106
3107 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3108 {
3109 while (wl_data->pos < wl_data->cnt)
3110 {
3111 uint off;
3112 uint len;
3113
3114 char *ptr = wl_data->buf + wl_data->pos;
3115
3116 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3117
3118 wl_data->pos += off;
3119
3120 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3121 {
3122 char rule_buf_out[BLOCK_SIZE];
3123
3124 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3125
3126 int rule_len_out = -1;
3127
3128 if (len < BLOCK_SIZE)
3129 {
3130 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3131 }
3132
3133 if (rule_len_out < 0)
3134 {
3135 continue;
3136 }
3137
3138 if (rule_len_out > PW_MAX)
3139 {
3140 continue;
3141 }
3142 }
3143 else
3144 {
3145 if (len > PW_MAX)
3146 {
3147 continue;
3148 }
3149 }
3150
3151 *out_buf = ptr;
3152 *out_len = len;
3153
3154 return;
3155 }
3156
3157 if (feof (fd))
3158 {
3159 fprintf (stderr, "bug!!\n");
3160
3161 return;
3162 }
3163
3164 load_segment (wl_data, fd);
3165
3166 get_next_word (wl_data, fd, out_buf, out_len);
3167 }
3168
3169 #ifdef _POSIX
3170 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3171 #endif
3172
3173 #ifdef _WIN
3174 static uint64_t count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3175 #endif
3176 {
3177 hc_signal (NULL);
3178
3179 dictstat_t d;
3180
3181 d.cnt = 0;
3182
3183 #ifdef _POSIX
3184 fstat (fileno (fd), &d.stat);
3185 #endif
3186
3187 #ifdef _WIN
3188 _fstat64 (fileno (fd), &d.stat);
3189 #endif
3190
3191 d.stat.st_mode = 0;
3192 d.stat.st_nlink = 0;
3193 d.stat.st_uid = 0;
3194 d.stat.st_gid = 0;
3195 d.stat.st_rdev = 0;
3196 d.stat.st_atime = 0;
3197
3198 #ifdef _POSIX
3199 d.stat.st_blksize = 0;
3200 d.stat.st_blocks = 0;
3201 #endif
3202
3203 if (d.stat.st_size == 0) return 0;
3204
3205 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3206
3207 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3208 {
3209 if (d_cache)
3210 {
3211 uint64_t cnt = d_cache->cnt;
3212
3213 uint64_t keyspace = cnt;
3214
3215 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3216 {
3217 keyspace *= data.kernel_rules_cnt;
3218 }
3219 else if (data.attack_kern == ATTACK_KERN_COMBI)
3220 {
3221 keyspace *= data.combs_cnt;
3222 }
3223
3224 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);
3225 if (data.quiet == 0) log_info ("");
3226
3227 hc_signal (sigHandler_default);
3228
3229 return (keyspace);
3230 }
3231 }
3232
3233 time_t now = 0;
3234 time_t prev = 0;
3235
3236 uint64_t comp = 0;
3237 uint64_t cnt = 0;
3238 uint64_t cnt2 = 0;
3239
3240 while (!feof (fd))
3241 {
3242 load_segment (wl_data, fd);
3243
3244 comp += wl_data->cnt;
3245
3246 uint32_t i = 0;
3247
3248 while (i < wl_data->cnt)
3249 {
3250 uint32_t len;
3251 uint32_t off;
3252
3253 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3254
3255 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3256 {
3257 char rule_buf_out[BLOCK_SIZE];
3258
3259 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3260
3261 int rule_len_out = -1;
3262
3263 if (len < BLOCK_SIZE)
3264 {
3265 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3266 }
3267
3268 if (rule_len_out < 0)
3269 {
3270 len = PW_MAX1;
3271 }
3272 else
3273 {
3274 len = rule_len_out;
3275 }
3276 }
3277
3278 if (len < PW_MAX1)
3279 {
3280 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3281 {
3282 cnt += data.kernel_rules_cnt;
3283 }
3284 else if (data.attack_kern == ATTACK_KERN_COMBI)
3285 {
3286 cnt += data.combs_cnt;
3287 }
3288
3289 d.cnt++;
3290 }
3291
3292 i += off;
3293
3294 cnt2++;
3295 }
3296
3297 time (&now);
3298
3299 if ((now - prev) == 0) continue;
3300
3301 float percent = (float) comp / (float) d.stat.st_size;
3302
3303 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);
3304
3305 time (&prev);
3306 }
3307
3308 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);
3309 if (data.quiet == 0) log_info ("");
3310
3311 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3312
3313 hc_signal (sigHandler_default);
3314
3315 return (cnt);
3316 }
3317
3318 static void pw_transpose_to_hi1 (const pw_t *p1, pw_t *p2)
3319 {
3320 memcpy (p2->hi1, p1->hi1, 64 * sizeof (uint));
3321 }
3322
3323 static uint pw_add_to_hc1 (hc_device_param_t *device_param, const uint8_t *pw_buf, const uint pw_len)
3324 {
3325 if (data.devices_status == STATUS_BYPASS) return 0;
3326
3327 pw_cache_t *pw_cache = device_param->pw_caches + pw_len;
3328
3329 uint cache_cnt = pw_cache->cnt;
3330
3331 uint8_t *pw_hc1 = pw_cache->pw_buf.hc1[cache_cnt];
3332
3333 memcpy (pw_hc1, pw_buf, pw_len);
3334
3335 memset (pw_hc1 + pw_len, 0, 256 - pw_len);
3336
3337 uint pws_cnt = device_param->pws_cnt;
3338
3339 cache_cnt++;
3340
3341 pw_t *pw = device_param->pws_buf + pws_cnt;
3342
3343 device_param->pw_transpose (&pw_cache->pw_buf, pw);
3344
3345 pw->pw_len = pw_len;
3346
3347 pws_cnt++;
3348
3349 device_param->pws_cnt = pws_cnt;
3350 device_param->pw_cnt = pws_cnt * 1;
3351
3352 cache_cnt = 0;
3353
3354 pw_cache->cnt = cache_cnt;
3355
3356 return pws_cnt;
3357 }
3358
3359 static void *thread_monitor (void *p)
3360 {
3361 uint runtime_check = 0;
3362 uint remove_check = 0;
3363 uint status_check = 0;
3364 uint hwmon_check = 0;
3365 uint restore_check = 0;
3366
3367 uint restore_left = data.restore_timer;
3368 uint remove_left = data.remove_timer;
3369 uint status_left = data.status_timer;
3370
3371 // these variables are mainly used for fan control (AMD only)
3372
3373 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3374
3375 // temperature controller "loopback" values
3376
3377 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3378 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3379
3380 int temp_threshold = 1; // degrees celcius
3381
3382 int fan_speed_min = 15; // in percentage
3383 int fan_speed_max = 100;
3384
3385 time_t last_temp_check_time;
3386
3387 uint sleep_time = 1;
3388
3389 if (data.runtime)
3390 {
3391 runtime_check = 1;
3392 }
3393
3394 if (data.restore_timer)
3395 {
3396 restore_check = 1;
3397 }
3398
3399 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3400 {
3401 remove_check = 1;
3402 }
3403
3404 if (data.status == 1)
3405 {
3406 status_check = 1;
3407 }
3408
3409 if (data.gpu_temp_disable == 0)
3410 {
3411 time (&last_temp_check_time);
3412
3413 hwmon_check = 1;
3414 }
3415
3416 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (hwmon_check == 0) && (restore_check == 0))
3417 {
3418 return (p);
3419 }
3420
3421 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3422 {
3423 hc_sleep (sleep_time);
3424
3425 if (data.devices_status != STATUS_RUNNING) continue;
3426
3427 if (hwmon_check == 1)
3428 {
3429 hc_thread_mutex_lock (mux_adl);
3430
3431 time_t temp_check_time;
3432
3433 time (&temp_check_time);
3434
3435 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3436
3437 if (Ta == 0) Ta = 1;
3438
3439 for (uint i = 0; i < data.devices_cnt; i++)
3440 {
3441 const int temperature = hm_get_temperature_with_device_id (i);
3442
3443 if (temperature > (int) data.gpu_temp_abort)
3444 {
3445 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", i + 1);
3446
3447 if (data.devices_status != STATUS_QUIT) myabort ();
3448
3449 break;
3450 }
3451
3452 const int gpu_temp_retain = data.gpu_temp_retain;
3453
3454 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3455 {
3456 if (data.hm_device[i].fan_supported == 1)
3457 {
3458 int temp_cur = temperature;
3459
3460 int temp_diff_new = gpu_temp_retain - temp_cur;
3461
3462 temp_diff_sum[i] = temp_diff_sum[i] + temp_diff_new;
3463
3464 // calculate Ta value (time difference in seconds between the last check and this check)
3465
3466 last_temp_check_time = temp_check_time;
3467
3468 float Kp = 1.8;
3469 float Ki = 0.005;
3470 float Kd = 6;
3471
3472 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3473
3474 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[i] + Kd * ((float)(temp_diff_new - temp_diff_old[i])) / Ta);
3475
3476 if (abs (fan_diff_required) >= temp_threshold)
3477 {
3478 const int fan_speed_cur = hm_get_fanspeed_with_device_id (i);
3479
3480 int fan_speed_level = fan_speed_cur;
3481
3482 if (fan_speed_chgd[i] == 0) fan_speed_level = temp_cur;
3483
3484 int fan_speed_new = fan_speed_level - fan_diff_required;
3485
3486 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3487 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3488
3489 if (fan_speed_new != fan_speed_cur)
3490 {
3491 int freely_change_fan_speed = (fan_speed_chgd[i] == 1);
3492 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3493
3494 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3495 {
3496 hm_set_fanspeed_with_device_id_amd (i, fan_speed_new);
3497
3498 fan_speed_chgd[i] = 1;
3499 }
3500
3501 temp_diff_old[i] = temp_diff_new;
3502 }
3503 }
3504 }
3505 }
3506 }
3507
3508 hc_thread_mutex_unlock (mux_adl);
3509 }
3510
3511 if (restore_check == 1)
3512 {
3513 restore_left--;
3514
3515 if (restore_left == 0)
3516 {
3517 if (data.restore_disable == 0) cycle_restore ();
3518
3519 restore_left = data.restore_timer;
3520 }
3521 }
3522
3523 if ((runtime_check == 1) && (data.runtime_start > 0))
3524 {
3525 time_t runtime_cur;
3526
3527 time (&runtime_cur);
3528
3529 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3530
3531 if (runtime_left <= 0)
3532 {
3533 if (data.benchmark == 0)
3534 {
3535 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3536 }
3537
3538 if (data.devices_status != STATUS_QUIT) myabort ();
3539 }
3540 }
3541
3542 if (remove_check == 1)
3543 {
3544 remove_left--;
3545
3546 if (remove_left == 0)
3547 {
3548 if (data.digests_saved != data.digests_done)
3549 {
3550 data.digests_saved = data.digests_done;
3551
3552 save_hash ();
3553 }
3554
3555 remove_left = data.remove_timer;
3556 }
3557 }
3558
3559 if (status_check == 1)
3560 {
3561 status_left--;
3562
3563 if (status_left == 0)
3564 {
3565 hc_thread_mutex_lock (mux_display);
3566
3567 if (data.quiet == 0) clear_prompt ();
3568
3569 if (data.quiet == 0) log_info ("");
3570
3571 status_display ();
3572
3573 if (data.quiet == 0) log_info ("");
3574
3575 hc_thread_mutex_unlock (mux_display);
3576
3577 status_left = data.status_timer;
3578 }
3579 }
3580 }
3581
3582 myfree (fan_speed_chgd);
3583
3584 myfree (temp_diff_old);
3585 myfree (temp_diff_sum);
3586
3587 p = NULL;
3588
3589 return (p);
3590 }
3591
3592 static void *thread_outfile_remove (void *p)
3593 {
3594 // some hash-dependent constants
3595 char *outfile_dir = data.outfile_check_directory;
3596 uint dgst_size = data.dgst_size;
3597 uint isSalted = data.isSalted;
3598 uint esalt_size = data.esalt_size;
3599 uint hash_mode = data.hash_mode;
3600
3601 uint outfile_check_timer = data.outfile_check_timer;
3602
3603 char separator = data.separator;
3604
3605 // some hash-dependent functions
3606 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3607 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3608
3609 // buffers
3610 hash_t hash_buf;
3611
3612 memset (&hash_buf, 0, sizeof (hash_buf));
3613
3614 hash_buf.digest = mymalloc (dgst_size);
3615
3616 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3617
3618 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3619
3620 uint digest_buf[64];
3621
3622 outfile_data_t *out_info = NULL;
3623
3624 char **out_files = NULL;
3625
3626 time_t folder_mtime = 0;
3627
3628 int out_cnt = 0;
3629
3630 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3631
3632 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3633 {
3634 hc_sleep (1);
3635
3636 if (data.devices_status != STATUS_RUNNING) continue;
3637
3638 check_left--;
3639
3640 if (check_left == 0)
3641 {
3642 struct stat outfile_check_stat;
3643
3644 if (stat (outfile_dir, &outfile_check_stat) == 0)
3645 {
3646 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3647
3648 if (is_dir == 1)
3649 {
3650 if (outfile_check_stat.st_mtime > folder_mtime)
3651 {
3652 char **out_files_new = scan_directory (outfile_dir);
3653
3654 int out_cnt_new = count_dictionaries (out_files_new);
3655
3656 outfile_data_t *out_info_new = NULL;
3657
3658 if (out_cnt_new > 0)
3659 {
3660 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3661
3662 for (int i = 0; i < out_cnt_new; i++)
3663 {
3664 out_info_new[i].file_name = out_files_new[i];
3665
3666 // check if there are files that we have seen/checked before (and not changed)
3667
3668 for (int j = 0; j < out_cnt; j++)
3669 {
3670 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3671 {
3672 struct stat outfile_stat;
3673
3674 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
3675 {
3676 if (outfile_stat.st_ctime == out_info[j].ctime)
3677 {
3678 out_info_new[i].ctime = out_info[j].ctime;
3679 out_info_new[i].seek = out_info[j].seek;
3680 }
3681 }
3682 }
3683 }
3684 }
3685 }
3686
3687 local_free (out_info);
3688 local_free (out_files);
3689
3690 out_files = out_files_new;
3691 out_cnt = out_cnt_new;
3692 out_info = out_info_new;
3693
3694 folder_mtime = outfile_check_stat.st_mtime;
3695 }
3696
3697 for (int j = 0; j < out_cnt; j++)
3698 {
3699 FILE *fp = fopen (out_info[j].file_name, "rb");
3700
3701 if (fp != NULL)
3702 {
3703 //hc_thread_mutex_lock (mux_display);
3704
3705 #ifdef _POSIX
3706 struct stat outfile_stat;
3707
3708 fstat (fileno (fp), &outfile_stat);
3709 #endif
3710
3711 #ifdef _WIN
3712 struct stat64 outfile_stat;
3713
3714 _fstat64 (fileno (fp), &outfile_stat);
3715 #endif
3716
3717 if (outfile_stat.st_ctime > out_info[j].ctime)
3718 {
3719 out_info[j].ctime = outfile_stat.st_ctime;
3720 out_info[j].seek = 0;
3721 }
3722
3723 fseek (fp, out_info[j].seek, SEEK_SET);
3724
3725 while (!feof (fp))
3726 {
3727 char line_buf[BUFSIZ];
3728
3729 memset (line_buf, 0, BUFSIZ);
3730
3731 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
3732
3733 if (ptr == NULL) break;
3734
3735 int line_len = strlen (line_buf);
3736
3737 if (line_len <= 0) continue;
3738
3739 int iter = MAX_CUT_TRIES;
3740
3741 for (uint i = line_len - 1; i && iter; i--, line_len--)
3742 {
3743 if (line_buf[i] != separator) continue;
3744
3745 int parser_status = PARSER_OK;
3746
3747 if ((hash_mode != 2500) && (hash_mode != 6800))
3748 {
3749 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
3750 }
3751
3752 uint found = 0;
3753
3754 if (parser_status == PARSER_OK)
3755 {
3756 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
3757 {
3758 if (data.salts_shown[salt_pos] == 1) continue;
3759
3760 salt_t *salt_buf = &data.salts_buf[salt_pos];
3761
3762 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
3763 {
3764 uint idx = salt_buf->digests_offset + digest_pos;
3765
3766 if (data.digests_shown[idx] == 1) continue;
3767
3768 uint cracked = 0;
3769
3770 if (hash_mode == 6800)
3771 {
3772 if (i == salt_buf->salt_len)
3773 {
3774 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3775 }
3776 }
3777 else if (hash_mode == 2500)
3778 {
3779 // BSSID : MAC1 : MAC2 (:plain)
3780 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
3781 {
3782 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
3783
3784 if (!cracked) continue;
3785
3786 // now compare MAC1 and MAC2 too, since we have this additional info
3787 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
3788 char *mac2_pos = mac1_pos + 12 + 1;
3789
3790 wpa_t *wpas = (wpa_t *) data.esalts_buf;
3791 wpa_t *wpa = &wpas[salt_pos];
3792
3793 uint pke[25];
3794
3795 char *pke_ptr = (char *) pke;
3796
3797 for (uint i = 0; i < 25; i++)
3798 {
3799 pke[i] = byte_swap_32 (wpa->pke[i]);
3800 }
3801
3802 unsigned char mac1[6];
3803 unsigned char mac2[6];
3804
3805 memcpy (mac1, pke_ptr + 23, 6);
3806 memcpy (mac2, pke_ptr + 29, 6);
3807
3808 // compare hex string(s) vs binary MAC address(es)
3809
3810 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3811 {
3812 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
3813 {
3814 cracked = 0;
3815 break;
3816 }
3817 }
3818
3819 // early skip ;)
3820 if (!cracked) continue;
3821
3822 for (uint i = 0, j = 0; i < 6; i++, j += 2)
3823 {
3824 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
3825 {
3826 cracked = 0;
3827 break;
3828 }
3829 }
3830 }
3831 }
3832 else
3833 {
3834 char *digests_buf_ptr = (char *) data.digests_buf;
3835
3836 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
3837
3838 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
3839 }
3840
3841 if (cracked == 1)
3842 {
3843 found = 1;
3844
3845 data.digests_shown[idx] = 1;
3846
3847 data.digests_done++;
3848
3849 salt_buf->digests_done++;
3850
3851 if (salt_buf->digests_done == salt_buf->digests_cnt)
3852 {
3853 data.salts_shown[salt_pos] = 1;
3854
3855 data.salts_done++;
3856
3857 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
3858 }
3859 }
3860 }
3861
3862 if (data.devices_status == STATUS_CRACKED) break;
3863 }
3864 }
3865
3866 if (found) break;
3867
3868 if (data.devices_status == STATUS_CRACKED) break;
3869
3870 iter--;
3871 }
3872
3873 if (data.devices_status == STATUS_CRACKED) break;
3874 }
3875
3876 out_info[j].seek = ftell (fp);
3877
3878 //hc_thread_mutex_unlock (mux_display);
3879
3880 fclose (fp);
3881 }
3882 }
3883 }
3884 }
3885
3886 check_left = outfile_check_timer;
3887 }
3888 }
3889
3890 if (esalt_size) local_free (hash_buf.esalt);
3891
3892 if (isSalted) local_free (hash_buf.salt);
3893
3894 local_free (hash_buf.digest);
3895
3896 local_free (out_info);
3897
3898 local_free (out_files);
3899
3900 p = NULL;
3901
3902 return (p);
3903 }
3904
3905 static uint get_work (hc_device_param_t *device_param, const uint64_t max)
3906 {
3907 hc_thread_mutex_lock (mux_dispatcher);
3908
3909 const uint64_t words_cur = data.words_cur;
3910 const uint64_t words_base = (data.limit == 0) ? data.words_base : data.limit;
3911
3912 device_param->words_off = words_cur;
3913
3914 const uint64_t words_left = words_base - words_cur;
3915
3916 if (data.kernel_blocks_all > words_left)
3917 {
3918 if (data.kernel_blocks_div == 0)
3919 {
3920 data.kernel_blocks_div = find_kernel_blocks_div (words_left, data.kernel_blocks_all);
3921 }
3922 }
3923
3924 if (data.kernel_blocks_div)
3925 {
3926 if (device_param->kernel_blocks == device_param->kernel_blocks_user)
3927 {
3928 const uint32_t kernel_blocks_new = (float) device_param->kernel_blocks * data.kernel_blocks_div;
3929 const uint32_t kernel_power_new = kernel_blocks_new;
3930
3931 if (kernel_blocks_new < device_param->kernel_blocks)
3932 {
3933 device_param->kernel_blocks = kernel_blocks_new;
3934 device_param->kernel_power = kernel_power_new;
3935 }
3936 }
3937 }
3938
3939 const uint kernel_blocks = device_param->kernel_blocks;
3940
3941 uint work = MIN (words_left, kernel_blocks);
3942
3943 work = MIN (work, max);
3944
3945 data.words_cur += work;
3946
3947 hc_thread_mutex_unlock (mux_dispatcher);
3948
3949 return work;
3950 }
3951
3952 static void *thread_calc_stdin (void *p)
3953 {
3954 hc_device_param_t *device_param = (hc_device_param_t *) p;
3955
3956 const uint attack_kern = data.attack_kern;
3957
3958 const uint kernel_blocks = device_param->kernel_blocks;
3959
3960 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3961 {
3962 hc_thread_mutex_lock (mux_dispatcher);
3963
3964 if (feof (stdin) != 0)
3965 {
3966 hc_thread_mutex_unlock (mux_dispatcher);
3967
3968 break;
3969 }
3970
3971 uint words_cur = 0;
3972
3973 while (words_cur < kernel_blocks)
3974 {
3975 char buf[BUFSIZ];
3976
3977 char *line_buf = fgets (buf, sizeof (buf), stdin);
3978
3979 if (line_buf == NULL) break;
3980
3981 uint line_len = in_superchop (line_buf);
3982
3983 line_len = convert_from_hex (line_buf, line_len);
3984
3985 // post-process rule engine
3986
3987 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3988 {
3989 char rule_buf_out[BLOCK_SIZE];
3990
3991 memset (rule_buf_out, 0, sizeof (rule_buf_out));
3992
3993 int rule_len_out = -1;
3994
3995 if (line_len < BLOCK_SIZE)
3996 {
3997 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
3998 }
3999
4000 if (rule_len_out < 0) continue;
4001
4002 line_buf = rule_buf_out;
4003 line_len = rule_len_out;
4004 }
4005
4006 if (line_len > PW_MAX)
4007 {
4008 continue;
4009 }
4010
4011 if (attack_kern == ATTACK_KERN_STRAIGHT)
4012 {
4013 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4014 {
4015 hc_thread_mutex_lock (mux_counter);
4016
4017 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4018 {
4019 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4020 }
4021
4022 hc_thread_mutex_unlock (mux_counter);
4023
4024 continue;
4025 }
4026 }
4027 else if (attack_kern == ATTACK_KERN_COMBI)
4028 {
4029 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4030 // since we still need to combine the plains
4031
4032 if (line_len > data.pw_max)
4033 {
4034 hc_thread_mutex_lock (mux_counter);
4035
4036 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4037 {
4038 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4039 }
4040
4041 hc_thread_mutex_unlock (mux_counter);
4042
4043 continue;
4044 }
4045 }
4046
4047 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4048
4049 words_cur++;
4050
4051 if (data.devices_status == STATUS_CRACKED) break;
4052 if (data.devices_status == STATUS_ABORTED) break;
4053 if (data.devices_status == STATUS_QUIT) break;
4054 if (data.devices_status == STATUS_BYPASS) break;
4055 }
4056
4057 hc_thread_mutex_unlock (mux_dispatcher);
4058
4059 if (data.devices_status == STATUS_CRACKED) break;
4060 if (data.devices_status == STATUS_ABORTED) break;
4061 if (data.devices_status == STATUS_QUIT) break;
4062 if (data.devices_status == STATUS_BYPASS) break;
4063
4064 // we need 2 flushing because we have two independant caches and it can occur
4065 // that one buffer is already at threshold plus for that length also exists
4066 // more data in the 2nd buffer so it would overflow
4067
4068 // flush session 1
4069
4070 {
4071 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4072 {
4073 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4074
4075 const uint pw_cache_cnt = pw_cache->cnt;
4076
4077 if (pw_cache_cnt == 0) continue;
4078
4079 pw_cache->cnt = 0;
4080
4081 uint pws_cnt = device_param->pws_cnt;
4082
4083 pw_t *pw = device_param->pws_buf + pws_cnt;
4084
4085 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4086
4087 pw->pw_len = pw_len;
4088
4089 uint pw_cnt = device_param->pw_cnt;
4090
4091 pw_cnt += pw_cache_cnt;
4092
4093 device_param->pw_cnt = pw_cnt;
4094
4095 pws_cnt++;
4096
4097 device_param->pws_cnt = pws_cnt;
4098
4099 if (pws_cnt == device_param->kernel_power_user) break;
4100 }
4101
4102 const uint pw_cnt = device_param->pw_cnt;
4103 const uint pws_cnt = device_param->pws_cnt;
4104
4105 if (pws_cnt)
4106 {
4107 run_copy (device_param, pws_cnt);
4108
4109 run_cracker (device_param, pw_cnt, pws_cnt);
4110
4111 device_param->pw_cnt = 0;
4112 device_param->pws_cnt = 0;
4113 }
4114 }
4115
4116 // flush session 2
4117
4118 {
4119 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4120 {
4121 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4122
4123 const uint pw_cache_cnt = pw_cache->cnt;
4124
4125 if (pw_cache_cnt == 0) continue;
4126
4127 pw_cache->cnt = 0;
4128
4129 uint pws_cnt = device_param->pws_cnt;
4130
4131 pw_t *pw = device_param->pws_buf + pws_cnt;
4132
4133 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4134
4135 pw->pw_len = pw_len;
4136
4137 uint pw_cnt = device_param->pw_cnt;
4138
4139 pw_cnt += pw_cache_cnt;
4140
4141 device_param->pw_cnt = pw_cnt;
4142
4143 pws_cnt++;
4144
4145 device_param->pws_cnt = pws_cnt;
4146 }
4147
4148 const uint pw_cnt = device_param->pw_cnt;
4149 const uint pws_cnt = device_param->pws_cnt;
4150
4151 if (pws_cnt)
4152 {
4153 run_copy (device_param, pws_cnt);
4154
4155 run_cracker (device_param, pw_cnt, pws_cnt);
4156
4157 device_param->pw_cnt = 0;
4158 device_param->pws_cnt = 0;
4159 }
4160 }
4161 }
4162
4163 return NULL;
4164 }
4165
4166 static void *thread_calc (void *p)
4167 {
4168 hc_device_param_t *device_param = (hc_device_param_t *) p;
4169
4170 const uint attack_mode = data.attack_mode;
4171 const uint attack_kern = data.attack_kern;
4172
4173 if (attack_mode == ATTACK_MODE_BF)
4174 {
4175 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4176 {
4177 const uint work = get_work (device_param, -1);
4178
4179 if (work == 0) break;
4180
4181 const uint64_t words_off = device_param->words_off;
4182 const uint64_t words_fin = words_off + work;
4183
4184 const uint pw_cnt = work;
4185 const uint pws_cnt = work;
4186
4187 device_param->pw_cnt = pw_cnt;
4188 device_param->pws_cnt = pws_cnt;
4189
4190 if (pws_cnt)
4191 {
4192 run_copy (device_param, pws_cnt);
4193
4194 run_cracker (device_param, pw_cnt, pws_cnt);
4195
4196 device_param->pw_cnt = 0;
4197 device_param->pws_cnt = 0;
4198 }
4199
4200 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4201
4202 if (data.devices_status == STATUS_CRACKED) break;
4203 if (data.devices_status == STATUS_ABORTED) break;
4204 if (data.devices_status == STATUS_QUIT) break;
4205 if (data.devices_status == STATUS_BYPASS) break;
4206
4207 device_param->words_done = words_fin;
4208 }
4209 }
4210 else
4211 {
4212 const uint segment_size = data.segment_size;
4213
4214 char *dictfile = data.dictfile;
4215
4216 if (attack_mode == ATTACK_MODE_COMBI)
4217 {
4218 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4219 {
4220 dictfile = data.dictfile2;
4221 }
4222 }
4223
4224 FILE *fd = fopen (dictfile, "rb");
4225
4226 if (fd == NULL)
4227 {
4228 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4229
4230 return NULL;
4231 }
4232
4233 if (attack_mode == ATTACK_MODE_COMBI)
4234 {
4235 const uint combs_mode = data.combs_mode;
4236
4237 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4238 {
4239 const char *dictfilec = data.dictfile2;
4240
4241 FILE *combs_fp = fopen (dictfilec, "rb");
4242
4243 if (combs_fp == NULL)
4244 {
4245 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4246
4247 fclose (fd);
4248
4249 return NULL;
4250 }
4251
4252 device_param->combs_fp = combs_fp;
4253 }
4254 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4255 {
4256 const char *dictfilec = data.dictfile;
4257
4258 FILE *combs_fp = fopen (dictfilec, "rb");
4259
4260 if (combs_fp == NULL)
4261 {
4262 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4263
4264 fclose (fd);
4265
4266 return NULL;
4267 }
4268
4269 device_param->combs_fp = combs_fp;
4270 }
4271 }
4272
4273 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4274
4275 wl_data->buf = (char *) mymalloc (segment_size);
4276 wl_data->avail = segment_size;
4277 wl_data->incr = segment_size;
4278 wl_data->cnt = 0;
4279 wl_data->pos = 0;
4280
4281 uint64_t words_cur = 0;
4282
4283 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4284 {
4285 uint64_t words_off = 0;
4286 uint64_t words_fin = 0;
4287
4288 uint64_t max = -1;
4289
4290 while (max)
4291 {
4292 const uint work = get_work (device_param, max);
4293
4294 if (work == 0) break;
4295
4296 words_off = device_param->words_off;
4297 words_fin = words_off + work;
4298
4299 char *line_buf;
4300 uint line_len;
4301
4302 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4303
4304 max = 0;
4305
4306 for ( ; words_cur < words_fin; words_cur++)
4307 {
4308 get_next_word (wl_data, fd, &line_buf, &line_len);
4309
4310 line_len = convert_from_hex (line_buf, line_len);
4311
4312 // post-process rule engine
4313
4314 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4315 {
4316 char rule_buf_out[BLOCK_SIZE];
4317
4318 memset (rule_buf_out, 0, sizeof (rule_buf_out));
4319
4320 int rule_len_out = -1;
4321
4322 if (line_len < BLOCK_SIZE)
4323 {
4324 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4325 }
4326
4327 if (rule_len_out < 0) continue;
4328
4329 line_buf = rule_buf_out;
4330 line_len = rule_len_out;
4331 }
4332
4333 if (attack_kern == ATTACK_KERN_STRAIGHT)
4334 {
4335 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4336 {
4337 max++;
4338
4339 hc_thread_mutex_lock (mux_counter);
4340
4341 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4342 {
4343 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4344 }
4345
4346 hc_thread_mutex_unlock (mux_counter);
4347
4348 continue;
4349 }
4350 }
4351 else if (attack_kern == ATTACK_KERN_COMBI)
4352 {
4353 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4354 // since we still need to combine the plains
4355
4356 if (line_len > data.pw_max)
4357 {
4358 max++;
4359
4360 hc_thread_mutex_lock (mux_counter);
4361
4362 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4363 {
4364 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4365 }
4366
4367 hc_thread_mutex_unlock (mux_counter);
4368
4369 continue;
4370 }
4371 }
4372
4373 device_param->pw_add (device_param, (uint8_t *) line_buf, line_len);
4374
4375 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4376
4377 if (data.devices_status == STATUS_CRACKED) break;
4378 if (data.devices_status == STATUS_ABORTED) break;
4379 if (data.devices_status == STATUS_QUIT) break;
4380 if (data.devices_status == STATUS_BYPASS) break;
4381 }
4382
4383 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4384
4385 if (data.devices_status == STATUS_CRACKED) break;
4386 if (data.devices_status == STATUS_ABORTED) break;
4387 if (data.devices_status == STATUS_QUIT) break;
4388 if (data.devices_status == STATUS_BYPASS) break;
4389 }
4390
4391 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4392
4393 if (data.devices_status == STATUS_CRACKED) break;
4394 if (data.devices_status == STATUS_ABORTED) break;
4395 if (data.devices_status == STATUS_QUIT) break;
4396 if (data.devices_status == STATUS_BYPASS) break;
4397
4398 // we need 2 flushing because we have two independant caches and it can occur
4399 // that one buffer is already at threshold plus for that length also exists
4400 // more data in the 2nd buffer so it would overflow
4401
4402 //
4403 // flush session 1
4404 //
4405
4406 {
4407 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4408 {
4409 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4410
4411 const uint pw_cache_cnt = pw_cache->cnt;
4412
4413 if (pw_cache_cnt == 0) continue;
4414
4415 pw_cache->cnt = 0;
4416
4417 uint pws_cnt = device_param->pws_cnt;
4418
4419 pw_t *pw = device_param->pws_buf + pws_cnt;
4420
4421 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4422
4423 pw->pw_len = pw_len;
4424
4425 uint pw_cnt = device_param->pw_cnt;
4426
4427 pw_cnt += pw_cache_cnt;
4428
4429 device_param->pw_cnt = pw_cnt;
4430
4431 pws_cnt++;
4432
4433 device_param->pws_cnt = pws_cnt;
4434
4435 if (pws_cnt == device_param->kernel_power_user) break;
4436 }
4437
4438 const uint pw_cnt = device_param->pw_cnt;
4439 const uint pws_cnt = device_param->pws_cnt;
4440
4441 if (pws_cnt)
4442 {
4443 run_copy (device_param, pws_cnt);
4444
4445 run_cracker (device_param, pw_cnt, pws_cnt);
4446
4447 device_param->pw_cnt = 0;
4448 device_param->pws_cnt = 0;
4449 }
4450
4451 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4452
4453 if (data.devices_status == STATUS_CRACKED) break;
4454 if (data.devices_status == STATUS_ABORTED) break;
4455 if (data.devices_status == STATUS_QUIT) break;
4456 if (data.devices_status == STATUS_BYPASS) break;
4457 }
4458
4459 //
4460 // flush session 2
4461 //
4462
4463 {
4464 for (int pw_len = 0; pw_len < PW_MAX1; pw_len++)
4465 {
4466 pw_cache_t *pw_cache = &device_param->pw_caches[pw_len];
4467
4468 const uint pw_cache_cnt = pw_cache->cnt;
4469
4470 if (pw_cache_cnt == 0) continue;
4471
4472 pw_cache->cnt = 0;
4473
4474 uint pws_cnt = device_param->pws_cnt;
4475
4476 pw_t *pw = device_param->pws_buf + pws_cnt;
4477
4478 device_param->pw_transpose (&pw_cache->pw_buf, pw);
4479
4480 pw->pw_len = pw_len;
4481
4482 uint pw_cnt = device_param->pw_cnt;
4483
4484 pw_cnt += pw_cache_cnt;
4485
4486 device_param->pw_cnt = pw_cnt;
4487
4488 pws_cnt++;
4489
4490 device_param->pws_cnt = pws_cnt;
4491 }
4492
4493 const uint pw_cnt = device_param->pw_cnt;
4494 const uint pws_cnt = device_param->pws_cnt;
4495
4496 if (pws_cnt)
4497 {
4498 run_copy (device_param, pws_cnt);
4499
4500 run_cracker (device_param, pw_cnt, pws_cnt);
4501
4502 device_param->pw_cnt = 0;
4503 device_param->pws_cnt = 0;
4504 }
4505
4506 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4507
4508 if (data.devices_status == STATUS_CRACKED) break;
4509 if (data.devices_status == STATUS_ABORTED) break;
4510 if (data.devices_status == STATUS_QUIT) break;
4511 if (data.devices_status == STATUS_BYPASS) break;
4512 }
4513
4514 if (words_fin == 0) break;
4515
4516 device_param->words_done = words_fin;
4517 }
4518
4519 if (attack_mode == ATTACK_MODE_COMBI)
4520 {
4521 fclose (device_param->combs_fp);
4522 }
4523
4524 free (wl_data->buf);
4525 free (wl_data);
4526
4527 fclose (fd);
4528 }
4529
4530 return NULL;
4531 }
4532
4533 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos, const uint kernel_loops)
4534 {
4535 salt_t *salt_buf = &data.salts_buf[salt_pos];
4536
4537 device_param->kernel_params_buf32[24] = salt_pos;
4538 device_param->kernel_params_buf32[27] = 1;
4539 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4540 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4541 device_param->kernel_params_buf32[30] = 0;
4542 device_param->kernel_params_buf32[31] = 1;
4543
4544 char *dictfile_old = data.dictfile;
4545 char *dictfile2_old = data.dictfile2;
4546 char *mask_old = data.mask;
4547
4548 const char *weak_hash_check = "weak-hash-check";
4549
4550 data.dictfile = (char *) weak_hash_check;
4551 data.dictfile2 = (char *) weak_hash_check;
4552 data.mask = (char *) weak_hash_check;
4553
4554 /**
4555 * run the kernel
4556 */
4557
4558 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4559 {
4560 run_kernel (KERN_RUN_1, device_param, 1);
4561 }
4562 else
4563 {
4564 run_kernel (KERN_RUN_1, device_param, 1);
4565
4566 const uint iter = salt_buf->salt_iter;
4567
4568 for (uint loop_pos = 0; loop_pos < iter; loop_pos += kernel_loops)
4569 {
4570 uint loop_left = iter - loop_pos;
4571
4572 loop_left = MIN (loop_left, kernel_loops);
4573
4574 device_param->kernel_params_buf32[25] = loop_pos;
4575 device_param->kernel_params_buf32[26] = loop_left;
4576
4577 run_kernel (KERN_RUN_2, device_param, 1);
4578 }
4579
4580 run_kernel (KERN_RUN_3, device_param, 1);
4581 }
4582
4583 /**
4584 * result
4585 */
4586
4587 check_cracked (device_param, salt_pos);
4588
4589 /**
4590 * cleanup
4591 */
4592
4593 device_param->kernel_params_buf32[24] = 0;
4594 device_param->kernel_params_buf32[25] = 0;
4595 device_param->kernel_params_buf32[26] = 0;
4596 device_param->kernel_params_buf32[27] = 0;
4597 device_param->kernel_params_buf32[28] = 0;
4598 device_param->kernel_params_buf32[29] = 0;
4599 device_param->kernel_params_buf32[30] = 0;
4600 device_param->kernel_params_buf32[31] = 0;
4601
4602 data.dictfile = dictfile_old;
4603 data.dictfile2 = dictfile2_old;
4604 data.mask = mask_old;
4605 }
4606
4607 // hlfmt hashcat
4608
4609 static void hlfmt_hash_hashcat (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4610 {
4611 if (data.username == 0)
4612 {
4613 *hashbuf_pos = line_buf;
4614 *hashbuf_len = line_len;
4615 }
4616 else
4617 {
4618 char *pos = line_buf;
4619 int len = line_len;
4620
4621 for (int i = 0; i < line_len; i++, pos++, len--)
4622 {
4623 if (line_buf[i] == data.separator)
4624 {
4625 pos++;
4626
4627 len--;
4628
4629 break;
4630 }
4631 }
4632
4633 *hashbuf_pos = pos;
4634 *hashbuf_len = len;
4635 }
4636 }
4637
4638 static void hlfmt_user_hashcat (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4639 {
4640 char *pos = NULL;
4641 int len = 0;
4642
4643 int sep_cnt = 0;
4644
4645 for (int i = 0; i < line_len; i++)
4646 {
4647 if (line_buf[i] == data.separator)
4648 {
4649 sep_cnt++;
4650
4651 continue;
4652 }
4653
4654 if (sep_cnt == 0)
4655 {
4656 if (pos == NULL) pos = line_buf + i;
4657
4658 len++;
4659 }
4660 }
4661
4662 *userbuf_pos = pos;
4663 *userbuf_len = len;
4664 }
4665
4666 // hlfmt pwdump
4667
4668 static int hlfmt_detect_pwdump (char line_buf[BUFSIZ], int line_len)
4669 {
4670 int sep_cnt = 0;
4671
4672 int sep2_len = 0;
4673 int sep3_len = 0;
4674
4675 for (int i = 0; i < line_len; i++)
4676 {
4677 if (line_buf[i] == ':')
4678 {
4679 sep_cnt++;
4680
4681 continue;
4682 }
4683
4684 if (sep_cnt == 2) sep2_len++;
4685 if (sep_cnt == 3) sep3_len++;
4686 }
4687
4688 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4689
4690 return 0;
4691 }
4692
4693 static void hlfmt_hash_pwdump (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4694 {
4695 char *pos = NULL;
4696 int len = 0;
4697
4698 int sep_cnt = 0;
4699
4700 for (int i = 0; i < line_len; i++)
4701 {
4702 if (line_buf[i] == ':')
4703 {
4704 sep_cnt++;
4705
4706 continue;
4707 }
4708
4709 if (data.hash_mode == 1000)
4710 {
4711 if (sep_cnt == 3)
4712 {
4713 if (pos == NULL) pos = line_buf + i;
4714
4715 len++;
4716 }
4717 }
4718 else if (data.hash_mode == 3000)
4719 {
4720 if (sep_cnt == 2)
4721 {
4722 if (pos == NULL) pos = line_buf + i;
4723
4724 len++;
4725 }
4726 }
4727 }
4728
4729 *hashbuf_pos = pos;
4730 *hashbuf_len = len;
4731 }
4732
4733 static void hlfmt_user_pwdump (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4734 {
4735 char *pos = NULL;
4736 int len = 0;
4737
4738 int sep_cnt = 0;
4739
4740 for (int i = 0; i < line_len; i++)
4741 {
4742 if (line_buf[i] == ':')
4743 {
4744 sep_cnt++;
4745
4746 continue;
4747 }
4748
4749 if (sep_cnt == 0)
4750 {
4751 if (pos == NULL) pos = line_buf + i;
4752
4753 len++;
4754 }
4755 }
4756
4757 *userbuf_pos = pos;
4758 *userbuf_len = len;
4759 }
4760
4761 // hlfmt passwd
4762
4763 static int hlfmt_detect_passwd (char line_buf[BUFSIZ], int line_len)
4764 {
4765 int sep_cnt = 0;
4766
4767 char sep5_first = 0;
4768 char sep6_first = 0;
4769
4770 for (int i = 0; i < line_len; i++)
4771 {
4772 if (line_buf[i] == ':')
4773 {
4774 sep_cnt++;
4775
4776 continue;
4777 }
4778
4779 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4780 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4781 }
4782
4783 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4784
4785 return 0;
4786 }
4787
4788 static void hlfmt_hash_passwd (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4789 {
4790 char *pos = NULL;
4791 int len = 0;
4792
4793 int sep_cnt = 0;
4794
4795 for (int i = 0; i < line_len; i++)
4796 {
4797 if (line_buf[i] == ':')
4798 {
4799 sep_cnt++;
4800
4801 continue;
4802 }
4803
4804 if (sep_cnt == 1)
4805 {
4806 if (pos == NULL) pos = line_buf + i;
4807
4808 len++;
4809 }
4810 }
4811
4812 *hashbuf_pos = pos;
4813 *hashbuf_len = len;
4814 }
4815
4816 static void hlfmt_user_passwd (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4817 {
4818 char *pos = NULL;
4819 int len = 0;
4820
4821 int sep_cnt = 0;
4822
4823 for (int i = 0; i < line_len; i++)
4824 {
4825 if (line_buf[i] == ':')
4826 {
4827 sep_cnt++;
4828
4829 continue;
4830 }
4831
4832 if (sep_cnt == 0)
4833 {
4834 if (pos == NULL) pos = line_buf + i;
4835
4836 len++;
4837 }
4838 }
4839
4840 *userbuf_pos = pos;
4841 *userbuf_len = len;
4842 }
4843
4844 // hlfmt shadow
4845
4846 static int hlfmt_detect_shadow (char line_buf[BUFSIZ], int line_len)
4847 {
4848 int sep_cnt = 0;
4849
4850 for (int i = 0; i < line_len; i++)
4851 {
4852 if (line_buf[i] == ':') sep_cnt++;
4853 }
4854
4855 if (sep_cnt == 8) return 1;
4856
4857 return 0;
4858 }
4859
4860 static void hlfmt_hash_shadow (char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
4863 }
4864
4865 static void hlfmt_user_shadow (char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4866 {
4867 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
4868 }
4869
4870 // hlfmt main
4871
4872 static void hlfmt_hash (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **hashbuf_pos, int *hashbuf_len)
4873 {
4874 switch (hashfile_format)
4875 {
4876 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4877 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4878 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4879 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
4880 }
4881 }
4882
4883 static void hlfmt_user (uint hashfile_format, char line_buf[BUFSIZ], int line_len, char **userbuf_pos, int *userbuf_len)
4884 {
4885 switch (hashfile_format)
4886 {
4887 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
4888 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
4889 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
4890 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
4891 }
4892 }
4893
4894 static uint hlfmt_detect (FILE *fp, uint max_check)
4895 {
4896 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
4897
4898 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
4899 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
4900
4901 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
4902
4903 uint num_check = 0;
4904
4905 while (!feof (fp))
4906 {
4907 char line_buf[BUFSIZ];
4908
4909 int line_len = fgetl (fp, line_buf);
4910
4911 if (line_len == 0) continue;
4912
4913 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
4914 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
4915 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
4916
4917 if (num_check == max_check) break;
4918
4919 num_check++;
4920 }
4921
4922 uint hashlist_format = HLFMT_HASHCAT;
4923
4924 for (int i = 1; i < HLFMTS_CNT; i++)
4925 {
4926 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
4927
4928 hashlist_format = i;
4929 }
4930
4931 free (formats_cnt);
4932
4933 return hashlist_format;
4934 }
4935
4936 /**
4937 * some further helper function
4938 */
4939
4940 // wrapper around mymalloc for ADL
4941
4942 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
4943 {
4944 return mymalloc (iSize);
4945 }
4946
4947 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 uint64_t collisions_max)
4948 {
4949 uint64_t collisions = 0;
4950
4951 const uint dgst_pos0 = data.dgst_pos0;
4952 const uint dgst_pos1 = data.dgst_pos1;
4953 const uint dgst_pos2 = data.dgst_pos2;
4954 const uint dgst_pos3 = data.dgst_pos3;
4955
4956 memset (bitmap_a, 0, bitmap_size);
4957 memset (bitmap_b, 0, bitmap_size);
4958 memset (bitmap_c, 0, bitmap_size);
4959 memset (bitmap_d, 0, bitmap_size);
4960
4961 for (uint i = 0; i < digests_cnt; i++)
4962 {
4963 uint *digest_ptr = (uint *) digests_buf_ptr;
4964
4965 digests_buf_ptr += dgst_size;
4966
4967 const uint val0 = 1 << (digest_ptr[dgst_pos0] & 0x1f);
4968 const uint val1 = 1 << (digest_ptr[dgst_pos1] & 0x1f);
4969 const uint val2 = 1 << (digest_ptr[dgst_pos2] & 0x1f);
4970 const uint val3 = 1 << (digest_ptr[dgst_pos3] & 0x1f);
4971
4972 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
4973 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
4974 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
4975 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
4976
4977 if (bitmap_a[idx0] & val0) collisions++;
4978 if (bitmap_b[idx1] & val1) collisions++;
4979 if (bitmap_c[idx2] & val2) collisions++;
4980 if (bitmap_d[idx3] & val3) collisions++;
4981
4982 bitmap_a[idx0] |= val0;
4983 bitmap_b[idx1] |= val1;
4984 bitmap_c[idx2] |= val2;
4985 bitmap_d[idx3] |= val3;
4986
4987 if (collisions >= collisions_max) return 0x7fffffff;
4988 }
4989
4990 return collisions;
4991 }
4992
4993 /**
4994 * main
4995 */
4996
4997 int main (int argc, char **argv)
4998 {
4999 /**
5000 * To help users a bit
5001 */
5002
5003 char *compute = getenv ("COMPUTE");
5004
5005 if (compute)
5006 {
5007 char display[100];
5008
5009 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5010
5011 putenv (display);
5012 }
5013 else
5014 {
5015 if (getenv ("DISPLAY") == NULL)
5016 putenv ((char *) "DISPLAY=:0");
5017 }
5018
5019 /*
5020 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5021 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5022
5023 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5024 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5025 */
5026
5027 /**
5028 * Real init
5029 */
5030
5031 memset (&data, 0, sizeof (hc_global_data_t));
5032
5033 time_t proc_start;
5034
5035 time (&proc_start);
5036
5037 data.proc_start = proc_start;
5038
5039 int myargc = argc;
5040 char **myargv = argv;
5041
5042 hc_thread_mutex_init (mux_dispatcher);
5043 hc_thread_mutex_init (mux_counter);
5044 hc_thread_mutex_init (mux_display);
5045 hc_thread_mutex_init (mux_adl);
5046
5047 /**
5048 * commandline parameters
5049 */
5050
5051 uint usage = USAGE;
5052 uint version = VERSION;
5053 uint quiet = QUIET;
5054 uint benchmark = BENCHMARK;
5055 uint benchmark_mode = BENCHMARK_MODE;
5056 uint show = SHOW;
5057 uint left = LEFT;
5058 uint username = USERNAME;
5059 uint remove = REMOVE;
5060 uint remove_timer = REMOVE_TIMER;
5061 uint64_t skip = SKIP;
5062 uint64_t limit = LIMIT;
5063 uint keyspace = KEYSPACE;
5064 uint potfile_disable = POTFILE_DISABLE;
5065 uint debug_mode = DEBUG_MODE;
5066 char *debug_file = NULL;
5067 char *induction_dir = NULL;
5068 char *outfile_check_dir = NULL;
5069 uint force = FORCE;
5070 uint runtime = RUNTIME;
5071 uint hash_mode = HASH_MODE;
5072 uint attack_mode = ATTACK_MODE;
5073 uint markov_disable = MARKOV_DISABLE;
5074 uint markov_classic = MARKOV_CLASSIC;
5075 uint markov_threshold = MARKOV_THRESHOLD;
5076 char *markov_hcstat = NULL;
5077 char *outfile = NULL;
5078 uint outfile_format = OUTFILE_FORMAT;
5079 uint outfile_autohex = OUTFILE_AUTOHEX;
5080 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5081 uint restore = RESTORE;
5082 uint restore_timer = RESTORE_TIMER;
5083 uint restore_disable = RESTORE_DISABLE;
5084 uint status = STATUS;
5085 uint status_timer = STATUS_TIMER;
5086 uint status_automat = STATUS_AUTOMAT;
5087 uint loopback = LOOPBACK;
5088 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5089 char *session = NULL;
5090 uint hex_charset = HEX_CHARSET;
5091 uint hex_salt = HEX_SALT;
5092 uint hex_wordlist = HEX_WORDLIST;
5093 uint rp_gen = RP_GEN;
5094 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5095 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5096 uint rp_gen_seed = RP_GEN_SEED;
5097 char *rule_buf_l = (char *) RULE_BUF_L;
5098 char *rule_buf_r = (char *) RULE_BUF_R;
5099 uint increment = INCREMENT;
5100 uint increment_min = INCREMENT_MIN;
5101 uint increment_max = INCREMENT_MAX;
5102 char *cpu_affinity = NULL;
5103 char *opencl_devices = NULL;
5104 char *opencl_platform = NULL;
5105 char *truecrypt_keyfiles = NULL;
5106 uint workload_profile = WORKLOAD_PROFILE;
5107 uint kernel_accel = KERNEL_ACCEL;
5108 uint kernel_loops = KERNEL_LOOPS;
5109 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5110 uint gpu_temp_abort = GPU_TEMP_ABORT;
5111 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5112 uint powertune_enable = POWERTUNE_ENABLE;
5113 uint logfile_disable = LOGFILE_DISABLE;
5114 uint segment_size = SEGMENT_SIZE;
5115 uint scrypt_tmto = SCRYPT_TMTO;
5116 char separator = SEPARATOR;
5117 uint bitmap_min = BITMAP_MIN;
5118 uint bitmap_max = BITMAP_MAX;
5119 char *custom_charset_1 = NULL;
5120 char *custom_charset_2 = NULL;
5121 char *custom_charset_3 = NULL;
5122 char *custom_charset_4 = NULL;
5123
5124 #define IDX_HELP 'h'
5125 #define IDX_VERSION 'V'
5126 #define IDX_VERSION_LOWER 'v'
5127 #define IDX_QUIET 0xff02
5128 #define IDX_SHOW 0xff03
5129 #define IDX_LEFT 0xff04
5130 #define IDX_REMOVE 0xff05
5131 #define IDX_REMOVE_TIMER 0xff37
5132 #define IDX_SKIP 's'
5133 #define IDX_LIMIT 'l'
5134 #define IDX_KEYSPACE 0xff35
5135 #define IDX_POTFILE_DISABLE 0xff06
5136 #define IDX_DEBUG_MODE 0xff43
5137 #define IDX_DEBUG_FILE 0xff44
5138 #define IDX_INDUCTION_DIR 0xff46
5139 #define IDX_OUTFILE_CHECK_DIR 0xff47
5140 #define IDX_USERNAME 0xff07
5141 #define IDX_FORCE 0xff08
5142 #define IDX_RUNTIME 0xff09
5143 #define IDX_BENCHMARK 'b'
5144 #define IDX_BENCHMARK_MODE 0xff32
5145 #define IDX_HASH_MODE 'm'
5146 #define IDX_ATTACK_MODE 'a'
5147 #define IDX_RP_FILE 'r'
5148 #define IDX_RP_GEN 'g'
5149 #define IDX_RP_GEN_FUNC_MIN 0xff10
5150 #define IDX_RP_GEN_FUNC_MAX 0xff11
5151 #define IDX_RP_GEN_SEED 0xff34
5152 #define IDX_RULE_BUF_L 'j'
5153 #define IDX_RULE_BUF_R 'k'
5154 #define IDX_INCREMENT 'i'
5155 #define IDX_INCREMENT_MIN 0xff12
5156 #define IDX_INCREMENT_MAX 0xff13
5157 #define IDX_OUTFILE 'o'
5158 #define IDX_OUTFILE_FORMAT 0xff14
5159 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5160 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5161 #define IDX_RESTORE 0xff15
5162 #define IDX_RESTORE_DISABLE 0xff27
5163 #define IDX_STATUS 0xff17
5164 #define IDX_STATUS_TIMER 0xff18
5165 #define IDX_STATUS_AUTOMAT 0xff50
5166 #define IDX_LOOPBACK 0xff38
5167 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5168 #define IDX_SESSION 0xff19
5169 #define IDX_HEX_CHARSET 0xff20
5170 #define IDX_HEX_SALT 0xff21
5171 #define IDX_HEX_WORDLIST 0xff40
5172 #define IDX_MARKOV_DISABLE 0xff22
5173 #define IDX_MARKOV_CLASSIC 0xff23
5174 #define IDX_MARKOV_THRESHOLD 't'
5175 #define IDX_MARKOV_HCSTAT 0xff24
5176 #define IDX_CPU_AFFINITY 0xff25
5177 #define IDX_OPENCL_DEVICES 'd'
5178 #define IDX_OPENCL_PLATFORM 0xff72
5179 #define IDX_WORKLOAD_PROFILE 'w'
5180 #define IDX_KERNEL_ACCEL 'n'
5181 #define IDX_KERNEL_LOOPS 'u'
5182 #define IDX_GPU_TEMP_DISABLE 0xff29
5183 #define IDX_GPU_TEMP_ABORT 0xff30
5184 #define IDX_GPU_TEMP_RETAIN 0xff31
5185 #define IDX_POWERTUNE_ENABLE 0xff41
5186 #define IDX_LOGFILE_DISABLE 0xff51
5187 #define IDX_TRUECRYPT_KEYFILES 0xff52
5188 #define IDX_SCRYPT_TMTO 0xff61
5189 #define IDX_SEGMENT_SIZE 'c'
5190 #define IDX_SEPARATOR 'p'
5191 #define IDX_BITMAP_MIN 0xff70
5192 #define IDX_BITMAP_MAX 0xff71
5193 #define IDX_CUSTOM_CHARSET_1 '1'
5194 #define IDX_CUSTOM_CHARSET_2 '2'
5195 #define IDX_CUSTOM_CHARSET_3 '3'
5196 #define IDX_CUSTOM_CHARSET_4 '4'
5197
5198 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5199
5200 struct option long_options[] =
5201 {
5202 {"help", no_argument, 0, IDX_HELP},
5203 {"version", no_argument, 0, IDX_VERSION},
5204 {"quiet", no_argument, 0, IDX_QUIET},
5205 {"show", no_argument, 0, IDX_SHOW},
5206 {"left", no_argument, 0, IDX_LEFT},
5207 {"username", no_argument, 0, IDX_USERNAME},
5208 {"remove", no_argument, 0, IDX_REMOVE},
5209 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5210 {"skip", required_argument, 0, IDX_SKIP},
5211 {"limit", required_argument, 0, IDX_LIMIT},
5212 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5213 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5214 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5215 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5216 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5217 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5218 {"force", no_argument, 0, IDX_FORCE},
5219 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5220 {"benchmark-mode", required_argument, 0, IDX_BENCHMARK_MODE},
5221 {"restore", no_argument, 0, IDX_RESTORE},
5222 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5223 {"status", no_argument, 0, IDX_STATUS},
5224 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5225 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5226 {"loopback", no_argument, 0, IDX_LOOPBACK},
5227 {"weak-hash-threshold",
5228 required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5229 {"session", required_argument, 0, IDX_SESSION},
5230 {"runtime", required_argument, 0, IDX_RUNTIME},
5231 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5232 {"generate-rules-func-min",
5233 required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5234 {"generate-rules-func-max",
5235 required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5236 {"generate-rules-seed",
5237 required_argument, 0, IDX_RP_GEN_SEED},
5238 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5239 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5240 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5241 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5242 {"rules-file", required_argument, 0, IDX_RP_FILE},
5243 {"outfile", required_argument, 0, IDX_OUTFILE},
5244 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5245 {"outfile-autohex-disable",
5246 no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5247 {"outfile-check-timer",
5248 required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5249 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5250 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5251 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5252 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5253 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5254 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5255 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5256 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5257 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5258 {"opencl-platform", required_argument, 0, IDX_OPENCL_PLATFORM},
5259 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5260 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5261 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5262 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5263 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5264 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5265 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5266 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5267 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5268 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5269 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5270 // deprecated
5271 {"seperator", required_argument, 0, IDX_SEPARATOR},
5272 {"separator", required_argument, 0, IDX_SEPARATOR},
5273 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5274 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5275 {"increment", no_argument, 0, IDX_INCREMENT},
5276 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5277 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5278 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5279 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5280 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5281 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5282
5283 {0, 0, 0, 0}
5284 };
5285
5286 uint rp_files_cnt = 0;
5287
5288 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5289
5290 int option_index;
5291 int c;
5292
5293 optind = 1;
5294 optopt = 0;
5295 option_index = 0;
5296
5297 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5298 {
5299 switch (c)
5300 {
5301 case IDX_HELP: usage = 1; break;
5302 case IDX_VERSION:
5303 case IDX_VERSION_LOWER: version = 1; break;
5304 case IDX_RESTORE: restore = 1; break;
5305 case IDX_SESSION: session = optarg; break;
5306 case IDX_SHOW: show = 1; break;
5307 case IDX_LEFT: left = 1; break;
5308 case '?': return (-1);
5309 }
5310 }
5311
5312 if (optopt != 0)
5313 {
5314 log_error ("ERROR: Invalid argument specified");
5315
5316 return (-1);
5317 }
5318
5319 /**
5320 * exit functions
5321 */
5322
5323 if (version)
5324 {
5325 log_info (VERSION_TXT);
5326
5327 return (0);
5328 }
5329
5330 if (usage)
5331 {
5332 usage_big_print (PROGNAME);
5333
5334 return (0);
5335 }
5336
5337 /**
5338 * session needs to be set, always!
5339 */
5340
5341 if (session == NULL) session = (char *) PROGNAME;
5342
5343 /**
5344 * folders, as discussed on https://github.com/hashcat/oclHashcat/issues/20
5345 */
5346
5347 char *exec_path = get_exec_path ();
5348
5349 #ifdef LINUX
5350
5351 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5352 char *resolved_exec_path = realpath (exec_path, NULL);
5353
5354 char *install_dir = get_install_dir (resolved_exec_path);
5355 char *profile_dir = NULL;
5356 char *session_dir = NULL;
5357 char *shared_dir = NULL;
5358
5359 if (strcmp (install_dir, resolved_install_folder) == 0)
5360 {
5361 struct passwd *pw = getpwuid (getuid ());
5362
5363 const char *homedir = pw->pw_dir;
5364
5365 profile_dir = get_profile_dir (homedir);
5366 session_dir = get_session_dir (profile_dir);
5367 shared_dir = strdup (SHARED_FOLDER);
5368
5369 mkdir (profile_dir, 0700);
5370 mkdir (session_dir, 0700);
5371 }
5372 else
5373 {
5374 profile_dir = install_dir;
5375 session_dir = install_dir;
5376 shared_dir = install_dir;
5377 }
5378
5379 myfree (resolved_install_folder);
5380 myfree (resolved_exec_path);
5381
5382 #else
5383
5384 char *install_dir = get_install_dir (exec_path);
5385 char *profile_dir = install_dir;
5386 char *session_dir = install_dir;
5387 char *shared_dir = install_dir;
5388
5389 #endif
5390
5391 data.install_dir = install_dir;
5392 data.profile_dir = profile_dir;
5393 data.session_dir = session_dir;
5394 data.shared_dir = shared_dir;
5395
5396 myfree (exec_path);
5397
5398 /**
5399 * session
5400 */
5401
5402 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5403
5404 data.session = session;
5405
5406 char *eff_restore_file = (char *) mymalloc (session_size);
5407 char *new_restore_file = (char *) mymalloc (session_size);
5408
5409 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5410 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5411
5412 data.eff_restore_file = eff_restore_file;
5413 data.new_restore_file = new_restore_file;
5414
5415 if (((show == 1) || (left == 1)) && (restore == 1))
5416 {
5417 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5418 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5419
5420 return (-1);
5421 }
5422
5423 // this allows the user to use --show and --left while cracking (i.e. while another instance of oclHashcat is running)
5424 if ((show == 1) || (left == 1))
5425 {
5426 restore_disable = 1;
5427
5428 restore = 0;
5429 }
5430
5431 data.restore_disable = restore_disable;
5432
5433 restore_data_t *rd = init_restore (argc, argv);
5434
5435 data.rd = rd;
5436
5437 /**
5438 * restore file
5439 */
5440
5441 if (restore == 1)
5442 {
5443 read_restore (eff_restore_file, rd);
5444
5445 if (rd->version_bin < RESTORE_MIN)
5446 {
5447 log_error ("ERROR: Incompatible restore-file version");
5448
5449 return (-1);
5450 }
5451
5452 myargc = rd->argc;
5453 myargv = rd->argv;
5454
5455 #ifdef _POSIX
5456 rd->pid = getpid ();
5457 #elif _WIN
5458 rd->pid = GetCurrentProcessId ();
5459 #endif
5460 }
5461
5462 uint hash_mode_chgd = 0;
5463 uint runtime_chgd = 0;
5464 uint kernel_loops_chgd = 0;
5465 uint kernel_accel_chgd = 0;
5466 uint attack_mode_chgd = 0;
5467 uint outfile_format_chgd = 0;
5468 uint rp_gen_seed_chgd = 0;
5469 uint remove_timer_chgd = 0;
5470 uint increment_min_chgd = 0;
5471 uint increment_max_chgd = 0;
5472 uint gpu_temp_abort_chgd = 0;
5473 uint gpu_temp_retain_chgd = 0;
5474
5475 optind = 1;
5476 optopt = 0;
5477 option_index = 0;
5478
5479 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5480 {
5481 switch (c)
5482 {
5483 //case IDX_HELP: usage = 1; break;
5484 //case IDX_VERSION: version = 1; break;
5485 //case IDX_RESTORE: restore = 1; break;
5486 case IDX_QUIET: quiet = 1; break;
5487 //case IDX_SHOW: show = 1; break;
5488 case IDX_SHOW: break;
5489 //case IDX_LEFT: left = 1; break;
5490 case IDX_LEFT: break;
5491 case IDX_USERNAME: username = 1; break;
5492 case IDX_REMOVE: remove = 1; break;
5493 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5494 remove_timer_chgd = 1; break;
5495 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5496 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5497 case IDX_DEBUG_FILE: debug_file = optarg; break;
5498 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5499 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5500 case IDX_FORCE: force = 1; break;
5501 case IDX_SKIP: skip = atoll (optarg); break;
5502 case IDX_LIMIT: limit = atoll (optarg); break;
5503 case IDX_KEYSPACE: keyspace = 1; break;
5504 case IDX_BENCHMARK: benchmark = 1; break;
5505 case IDX_BENCHMARK_MODE: benchmark_mode = atoi (optarg); break;
5506 case IDX_RESTORE: break;
5507 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5508 case IDX_STATUS: status = 1; break;
5509 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5510 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5511 case IDX_LOOPBACK: loopback = 1; break;
5512 case IDX_WEAK_HASH_THRESHOLD:
5513 weak_hash_threshold = atoi (optarg); break;
5514 //case IDX_SESSION: session = optarg; break;
5515 case IDX_SESSION: break;
5516 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5517 hash_mode_chgd = 1; break;
5518 case IDX_RUNTIME: runtime = atoi (optarg);
5519 runtime_chgd = 1; break;
5520 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5521 attack_mode_chgd = 1; break;
5522 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5523 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5524 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5525 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5526 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5527 rp_gen_seed_chgd = 1; break;
5528 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5529 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5530 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5531 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5532 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5533 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5534 case IDX_OUTFILE: outfile = optarg; break;
5535 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5536 outfile_format_chgd = 1; break;
5537 case IDX_OUTFILE_AUTOHEX_DISABLE:
5538 outfile_autohex = 0; break;
5539 case IDX_OUTFILE_CHECK_TIMER:
5540 outfile_check_timer = atoi (optarg); break;
5541 case IDX_HEX_CHARSET: hex_charset = 1; break;
5542 case IDX_HEX_SALT: hex_salt = 1; break;
5543 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5544 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5545 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5546 case IDX_OPENCL_PLATFORM: opencl_platform = optarg; break;
5547 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); break;
5548 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5549 kernel_accel_chgd = 1; break;
5550 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5551 kernel_loops_chgd = 1; break;
5552 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5553 case IDX_GPU_TEMP_ABORT: gpu_temp_abort_chgd = 1;
5554 gpu_temp_abort = atoi (optarg); break;
5555 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain_chgd = 1;
5556 gpu_temp_retain = atoi (optarg); break;
5557 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5558 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5559 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5560 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5561 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5562 case IDX_SEPARATOR: separator = optarg[0]; break;
5563 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5564 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5565 case IDX_INCREMENT: increment = 1; break;
5566 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5567 increment_min_chgd = 1; break;
5568 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5569 increment_max_chgd = 1; break;
5570 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5571 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5572 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5573 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5574
5575 default:
5576 log_error ("ERROR: Invalid argument specified");
5577 return (-1);
5578 }
5579 }
5580
5581 if (optopt != 0)
5582 {
5583 log_error ("ERROR: Invalid argument specified");
5584
5585 return (-1);
5586 }
5587
5588 /**
5589 * Inform user things getting started,
5590 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5591 * - we do not need to check algorithm_pos
5592 */
5593
5594 if (quiet == 0)
5595 {
5596 if (benchmark == 1)
5597 {
5598 log_info ("%s v%.2f starting in benchmark-mode...", PROGNAME, (float) VERSION_BIN / 100);
5599
5600 log_info ("");
5601 }
5602 else if (restore == 1)
5603 {
5604 log_info ("%s v%.2f starting in restore-mode...", PROGNAME, (float) VERSION_BIN / 100);
5605
5606 log_info ("");
5607 }
5608 else
5609 {
5610 log_info ("%s v%.2f starting...", PROGNAME, (float) VERSION_BIN / 100);
5611
5612 log_info ("");
5613 }
5614 }
5615
5616 /**
5617 * sanity check
5618 */
5619
5620 if (attack_mode > 7)
5621 {
5622 log_error ("ERROR: Invalid attack-mode specified");
5623
5624 return (-1);
5625 }
5626
5627 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5628 {
5629 log_error ("ERROR: Invalid runtime specified");
5630
5631 return (-1);
5632 }
5633
5634 if (hash_mode_chgd && hash_mode > 12800) // just added to remove compiler warnings for hash_mode_chgd
5635 {
5636 log_error ("ERROR: Invalid hash-type specified");
5637
5638 return (-1);
5639 }
5640
5641 // renamed hash modes
5642
5643 if (hash_mode_chgd)
5644 {
5645 int n = -1;
5646
5647 switch (hash_mode)
5648 {
5649 case 123: n = 124;
5650 break;
5651 }
5652
5653 if (n >= 0)
5654 {
5655 log_error ("Old -m specified, use -m %d instead", n);
5656
5657 return (-1);
5658 }
5659 }
5660
5661 if (username == 1)
5662 {
5663 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)))
5664 {
5665 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5666
5667 return (-1);
5668 }
5669 }
5670
5671 if (outfile_format > 16)
5672 {
5673 log_error ("ERROR: Invalid outfile-format specified");
5674
5675 return (-1);
5676 }
5677
5678 if (left == 1)
5679 {
5680 if (outfile_format_chgd == 1)
5681 {
5682 if (outfile_format > 1)
5683 {
5684 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5685
5686 return (-1);
5687 }
5688 }
5689 else
5690 {
5691 outfile_format = OUTFILE_FMT_HASH;
5692 }
5693 }
5694
5695 if (show == 1)
5696 {
5697 if (outfile_format_chgd == 1)
5698 {
5699 if ((outfile_format > 7) && (outfile_format < 16))
5700 {
5701 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5702
5703 return (-1);
5704 }
5705 }
5706 }
5707
5708 if (increment_min < INCREMENT_MIN)
5709 {
5710 log_error ("ERROR: Invalid increment-min specified");
5711
5712 return (-1);
5713 }
5714
5715 if (increment_max > INCREMENT_MAX)
5716 {
5717 log_error ("ERROR: Invalid increment-max specified");
5718
5719 return (-1);
5720 }
5721
5722 if (increment_min > increment_max)
5723 {
5724 log_error ("ERROR: Invalid increment-min specified");
5725
5726 return (-1);
5727 }
5728
5729 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
5730 {
5731 log_error ("ERROR: increment is not allowed in attack-mode 0");
5732
5733 return (-1);
5734 }
5735
5736 if ((increment == 0) && (increment_min_chgd == 1))
5737 {
5738 log_error ("ERROR: increment-min is only supported together with increment switch");
5739
5740 return (-1);
5741 }
5742
5743 if ((increment == 0) && (increment_max_chgd == 1))
5744 {
5745 log_error ("ERROR: increment-max is only supported together with increment switch");
5746
5747 return (-1);
5748 }
5749
5750 if (rp_files_cnt && rp_gen)
5751 {
5752 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
5753
5754 return (-1);
5755 }
5756
5757 if (rp_files_cnt || rp_gen)
5758 {
5759 if (attack_mode != ATTACK_MODE_STRAIGHT)
5760 {
5761 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
5762
5763 return (-1);
5764 }
5765 }
5766
5767 if (rp_gen_func_min > rp_gen_func_max)
5768 {
5769 log_error ("ERROR: Invalid rp-gen-func-min specified");
5770
5771 return (-1);
5772 }
5773
5774 if (kernel_accel_chgd == 1)
5775 {
5776 if (workload_profile != WORKLOAD_PROFILE)
5777 {
5778 log_error ("ERROR: kernel-accel parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5779
5780 return (-1);
5781 }
5782
5783 if (kernel_accel < 1)
5784 {
5785 log_error ("ERROR: Invalid kernel-accel specified");
5786
5787 return (-1);
5788 }
5789
5790 if (kernel_accel > 800)
5791 {
5792 log_error ("ERROR: Invalid kernel-accel specified");
5793
5794 return (-1);
5795 }
5796 }
5797
5798 if (kernel_loops_chgd == 1)
5799 {
5800 if (workload_profile != WORKLOAD_PROFILE)
5801 {
5802 log_error ("ERROR: kernel-loops parameter can only be set when workload-profile %i is used", WORKLOAD_PROFILE);
5803
5804 return (-1);
5805 }
5806
5807 if (kernel_loops < 1)
5808 {
5809 log_error ("ERROR: Invalid kernel-loops specified");
5810
5811 return (-1);
5812 }
5813
5814 if (kernel_loops > 1024)
5815 {
5816 log_error ("ERROR: Invalid kernel-loops specified");
5817
5818 return (-1);
5819 }
5820 }
5821
5822 if (benchmark == 1)
5823 {
5824 if (workload_profile != WORKLOAD_PROFILE)
5825 {
5826 log_error ("ERROR: Using the workload-profile in benchmark mode is not allowed");
5827
5828 return (-1);
5829 }
5830 }
5831
5832 if ((workload_profile < 1) || (workload_profile > 3))
5833 {
5834 log_error ("ERROR: workload-profile %i not available", workload_profile);
5835
5836 return (-1);
5837 }
5838
5839 if (show == 1 || left == 1)
5840 {
5841 attack_mode = ATTACK_MODE_NONE;
5842
5843 if (remove == 1)
5844 {
5845 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
5846
5847 return (-1);
5848 }
5849
5850 if (potfile_disable == 1)
5851 {
5852 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
5853
5854 return (-1);
5855 }
5856 }
5857
5858 uint attack_kern = ATTACK_KERN_NONE;
5859
5860 switch (attack_mode)
5861 {
5862 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
5863 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
5864 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
5865 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
5866 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
5867 }
5868
5869 if (benchmark == 0)
5870 {
5871 if (keyspace == 1)
5872 {
5873 int num_additional_params = 1;
5874
5875 if (attack_kern == ATTACK_KERN_COMBI)
5876 {
5877 num_additional_params = 2;
5878 }
5879
5880 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
5881
5882 if (keyspace_wordlist_specified == 0) optind--;
5883 }
5884
5885 if (attack_kern == ATTACK_KERN_NONE)
5886 {
5887 if ((optind + 1) != myargc)
5888 {
5889 usage_mini_print (myargv[0]);
5890
5891 return (-1);
5892 }
5893 }
5894 else if (attack_kern == ATTACK_KERN_STRAIGHT)
5895 {
5896 if ((optind + 1) > myargc)
5897 {
5898 usage_mini_print (myargv[0]);
5899
5900 return (-1);
5901 }
5902 }
5903 else if (attack_kern == ATTACK_KERN_COMBI)
5904 {
5905 if ((optind + 3) != myargc)
5906 {
5907 usage_mini_print (myargv[0]);
5908
5909 return (-1);
5910 }
5911 }
5912 else if (attack_kern == ATTACK_KERN_BF)
5913 {
5914 if ((optind + 1) > myargc)
5915 {
5916 usage_mini_print (myargv[0]);
5917
5918 return (-1);
5919 }
5920 }
5921 else
5922 {
5923 usage_mini_print (myargv[0]);
5924
5925 return (-1);
5926 }
5927 }
5928 else
5929 {
5930 if (myargv[optind] != 0)
5931 {
5932 log_error ("ERROR: Invalid argument for benchmark mode specified");
5933
5934 return (-1);
5935 }
5936
5937 if (attack_mode_chgd == 1)
5938 {
5939 if (attack_mode != ATTACK_MODE_BF)
5940 {
5941 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
5942
5943 return (-1);
5944 }
5945 }
5946
5947 if (benchmark_mode == 0)
5948 {
5949 // nothing to do
5950 }
5951 else if (benchmark_mode == 1)
5952 {
5953 if (kernel_accel_chgd == 1 || kernel_loops_chgd == 1)
5954 {
5955 log_error ("ERROR: Benchmark-mode 1 does not allow kernel-accel or kernel-loops changed");
5956
5957 return (-1);
5958 }
5959 }
5960 else
5961 {
5962 log_error ("ERROR: Benchmark-mode must be 0 or 1");
5963
5964 return (-1);
5965 }
5966 }
5967
5968 if (skip != 0 && limit != 0)
5969 {
5970 limit += skip;
5971 }
5972
5973 if (keyspace == 1)
5974 {
5975 if (show == 1)
5976 {
5977 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
5978
5979 return (-1);
5980 }
5981 else if (left == 1)
5982 {
5983 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
5984
5985 return (-1);
5986 }
5987
5988 potfile_disable = 1;
5989
5990 restore_disable = 1;
5991
5992 restore = 0;
5993
5994 weak_hash_threshold = 0;
5995
5996 quiet = 1;
5997 }
5998
5999 if (remove_timer_chgd == 1)
6000 {
6001 if (remove == 0)
6002 {
6003 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6004
6005 return (-1);
6006 }
6007
6008 if (remove_timer < 1)
6009 {
6010 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6011
6012 return (-1);
6013 }
6014 }
6015
6016 if (loopback == 1)
6017 {
6018 if (attack_mode == ATTACK_MODE_BF)
6019 {
6020 log_error ("ERROR: Parameter loopback not allowed in attack-mode 3");
6021
6022 return (-1);
6023 }
6024 else if (attack_mode == ATTACK_MODE_STRAIGHT)
6025 {
6026 if ((rp_files_cnt == 0) && (rp_gen == 0))
6027 {
6028 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6029
6030 return (-1);
6031 }
6032 }
6033 }
6034
6035 if (debug_mode > 0)
6036 {
6037 if (attack_mode != ATTACK_MODE_STRAIGHT)
6038 {
6039 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6040
6041 return (-1);
6042 }
6043
6044 if ((rp_files_cnt == 0) && (rp_gen == 0))
6045 {
6046 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6047
6048 return (-1);
6049 }
6050 }
6051
6052 if (debug_mode > 4)
6053 {
6054 log_error ("ERROR: Invalid debug-mode specified");
6055
6056 return (-1);
6057 }
6058
6059 if (debug_file != NULL)
6060 {
6061 if (debug_mode < 1)
6062 {
6063 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6064
6065 return (-1);
6066 }
6067 }
6068
6069 if (induction_dir != NULL)
6070 {
6071 if (attack_mode == ATTACK_MODE_BF)
6072 {
6073 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6074
6075 return (-1);
6076 }
6077 }
6078
6079 /**
6080 * induction directory
6081 */
6082
6083 char *induction_directory = NULL;
6084
6085 if (attack_mode != ATTACK_MODE_BF)
6086 {
6087 if (induction_dir == NULL)
6088 {
6089 induction_directory = (char *) mymalloc (session_size);
6090
6091 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6092
6093 // create induction folder if it does not already exist
6094
6095 if (keyspace == 0)
6096 {
6097 if (rmdir (induction_directory) == -1)
6098 {
6099 if (errno == ENOENT)
6100 {
6101 // good, we can ignore
6102 }
6103 else if (errno == ENOTEMPTY)
6104 {
6105 char *induction_directory_mv = (char *) mymalloc (session_size);
6106
6107 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6108
6109 if (rename (induction_directory, induction_directory_mv) != 0)
6110 {
6111 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6112
6113 return (-1);
6114 }
6115 }
6116 else
6117 {
6118 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6119
6120 return (-1);
6121 }
6122 }
6123
6124 if (mkdir (induction_directory, 0700) == -1)
6125 {
6126 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6127
6128 return (-1);
6129 }
6130 }
6131 }
6132 else
6133 {
6134 induction_directory = induction_dir;
6135 }
6136 }
6137
6138 data.induction_directory = induction_directory;
6139
6140 /**
6141 * loopback
6142 */
6143
6144 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6145
6146 char *loopback_file = (char *) mymalloc (loopback_size);
6147
6148 /**
6149 * outfile-check directory
6150 */
6151
6152 char *outfile_check_directory = NULL;
6153
6154 if (outfile_check_dir == NULL)
6155 {
6156 outfile_check_directory = (char *) mymalloc (session_size);
6157
6158 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6159 }
6160 else
6161 {
6162 outfile_check_directory = outfile_check_dir;
6163 }
6164
6165 data.outfile_check_directory = outfile_check_directory;
6166
6167 if (keyspace == 0)
6168 {
6169 struct stat outfile_check_stat;
6170
6171 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6172 {
6173 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6174
6175 if (is_dir == 0)
6176 {
6177 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6178
6179 return (-1);
6180 }
6181 }
6182 else if (outfile_check_dir == NULL)
6183 {
6184 if (mkdir (outfile_check_directory, 0700) == -1)
6185 {
6186 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6187
6188 return (-1);
6189 }
6190 }
6191 }
6192
6193 /**
6194 * special other stuff
6195 */
6196
6197 if (hash_mode == 9710)
6198 {
6199 outfile_format = 5;
6200 outfile_format_chgd = 1;
6201 }
6202
6203 if (hash_mode == 9810)
6204 {
6205 outfile_format = 5;
6206 outfile_format_chgd = 1;
6207 }
6208
6209 if (hash_mode == 10410)
6210 {
6211 outfile_format = 5;
6212 outfile_format_chgd = 1;
6213 }
6214
6215 /**
6216 * store stuff
6217 */
6218
6219 data.hash_mode = hash_mode;
6220 data.restore = restore;
6221 data.restore_timer = restore_timer;
6222 data.restore_disable = restore_disable;
6223 data.status = status;
6224 data.status_timer = status_timer;
6225 data.status_automat = status_automat;
6226 data.loopback = loopback;
6227 data.runtime = runtime;
6228 data.remove = remove;
6229 data.remove_timer = remove_timer;
6230 data.debug_mode = debug_mode;
6231 data.debug_file = debug_file;
6232 data.username = username;
6233 data.quiet = quiet;
6234 data.outfile = outfile;
6235 data.outfile_format = outfile_format;
6236 data.outfile_autohex = outfile_autohex;
6237 data.hex_charset = hex_charset;
6238 data.hex_salt = hex_salt;
6239 data.hex_wordlist = hex_wordlist;
6240 data.separator = separator;
6241 data.rp_files = rp_files;
6242 data.rp_files_cnt = rp_files_cnt;
6243 data.rp_gen = rp_gen;
6244 data.rp_gen_seed = rp_gen_seed;
6245 data.force = force;
6246 data.benchmark = benchmark;
6247 data.skip = skip;
6248 data.limit = limit;
6249 data.powertune_enable = powertune_enable;
6250 data.logfile_disable = logfile_disable;
6251 data.truecrypt_keyfiles = truecrypt_keyfiles;
6252 data.scrypt_tmto = scrypt_tmto;
6253
6254 /**
6255 * cpu affinity
6256 */
6257
6258 if (cpu_affinity)
6259 {
6260 set_cpu_affinity (cpu_affinity);
6261 }
6262
6263 if (rp_gen_seed_chgd == 0)
6264 {
6265 srand (proc_start);
6266 }
6267 else
6268 {
6269 srand (rp_gen_seed);
6270 }
6271
6272 /**
6273 * logfile init
6274 */
6275
6276 if (logfile_disable == 0)
6277 {
6278 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6279
6280 char *logfile = (char *) mymalloc (logfile_size);
6281
6282 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6283
6284 data.logfile = logfile;
6285
6286 char *topid = logfile_generate_topid ();
6287
6288 data.topid = topid;
6289 }
6290
6291 // logfile_append() checks for logfile_disable internally to make it easier from here
6292
6293 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6294 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6295 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6296 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6297 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6298 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6299 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6300 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6301 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6302 #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));
6303
6304 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6305 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6306 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6307 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6308 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6309 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6310 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6311 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6312
6313 logfile_top_msg ("START");
6314
6315 logfile_top_uint (attack_mode);
6316 logfile_top_uint (attack_kern);
6317 logfile_top_uint (benchmark);
6318 logfile_top_uint (benchmark_mode);
6319 logfile_top_uint (bitmap_min);
6320 logfile_top_uint (bitmap_max);
6321 logfile_top_uint (debug_mode);
6322 logfile_top_uint (force);
6323 logfile_top_uint (kernel_accel);
6324 logfile_top_uint (kernel_loops);
6325 logfile_top_uint (gpu_temp_abort);
6326 logfile_top_uint (gpu_temp_disable);
6327 logfile_top_uint (gpu_temp_retain);
6328 logfile_top_uint (hash_mode);
6329 logfile_top_uint (hex_charset);
6330 logfile_top_uint (hex_salt);
6331 logfile_top_uint (hex_wordlist);
6332 logfile_top_uint (increment);
6333 logfile_top_uint (increment_max);
6334 logfile_top_uint (increment_min);
6335 logfile_top_uint (keyspace);
6336 logfile_top_uint (left);
6337 logfile_top_uint (logfile_disable);
6338 logfile_top_uint (loopback);
6339 logfile_top_uint (markov_classic);
6340 logfile_top_uint (markov_disable);
6341 logfile_top_uint (markov_threshold);
6342 logfile_top_uint (outfile_autohex);
6343 logfile_top_uint (outfile_check_timer);
6344 logfile_top_uint (outfile_format);
6345 logfile_top_uint (potfile_disable);
6346 logfile_top_uint (powertune_enable);
6347 logfile_top_uint (scrypt_tmto);
6348 logfile_top_uint (quiet);
6349 logfile_top_uint (remove);
6350 logfile_top_uint (remove_timer);
6351 logfile_top_uint (restore);
6352 logfile_top_uint (restore_disable);
6353 logfile_top_uint (restore_timer);
6354 logfile_top_uint (rp_gen);
6355 logfile_top_uint (rp_gen_func_max);
6356 logfile_top_uint (rp_gen_func_min);
6357 logfile_top_uint (rp_gen_seed);
6358 logfile_top_uint (runtime);
6359 logfile_top_uint (segment_size);
6360 logfile_top_uint (show);
6361 logfile_top_uint (status);
6362 logfile_top_uint (status_automat);
6363 logfile_top_uint (status_timer);
6364 logfile_top_uint (usage);
6365 logfile_top_uint (username);
6366 logfile_top_uint (version);
6367 logfile_top_uint (weak_hash_threshold);
6368 logfile_top_uint (workload_profile);
6369 logfile_top_uint64 (limit);
6370 logfile_top_uint64 (skip);
6371 logfile_top_char (separator);
6372 logfile_top_string (cpu_affinity);
6373 logfile_top_string (custom_charset_1);
6374 logfile_top_string (custom_charset_2);
6375 logfile_top_string (custom_charset_3);
6376 logfile_top_string (custom_charset_4);
6377 logfile_top_string (debug_file);
6378 logfile_top_string (opencl_devices);
6379 logfile_top_string (opencl_platform);
6380 logfile_top_string (induction_dir);
6381 logfile_top_string (markov_hcstat);
6382 logfile_top_string (outfile);
6383 logfile_top_string (outfile_check_dir);
6384 logfile_top_string (rule_buf_l);
6385 logfile_top_string (rule_buf_r);
6386 logfile_top_string (session);
6387 logfile_top_string (truecrypt_keyfiles);
6388
6389 /**
6390 * devices
6391 */
6392
6393 uint opencl_devicemask = devices_to_devicemask (opencl_devices);
6394
6395 /**
6396 * benchmark
6397 */
6398
6399 if (benchmark == 1)
6400 {
6401 /**
6402 * disable useless stuff for benchmark
6403 */
6404
6405 restore_timer = 0;
6406 status_timer = 0;
6407 restore_disable = 1;
6408 potfile_disable = 1;
6409 weak_hash_threshold = 0;
6410
6411 data.restore_timer = restore_timer;
6412 data.status_timer = status_timer;
6413 data.restore_disable = restore_disable;
6414
6415 if (benchmark_mode == 1)
6416 {
6417 markov_disable = 1;
6418 }
6419
6420 /**
6421 * force attack mode to be bruteforce
6422 */
6423
6424 attack_mode = ATTACK_MODE_BF;
6425 attack_kern = ATTACK_KERN_BF;
6426
6427 if (runtime_chgd == 0)
6428 {
6429 runtime = 4;
6430
6431 if (benchmark_mode == 1) runtime = 17;
6432
6433 data.runtime = runtime;
6434 }
6435 }
6436
6437 /**
6438 * config
6439 */
6440
6441 uint hash_type = 0;
6442 uint salt_type = 0;
6443 uint attack_exec = 0;
6444 uint opts_type = 0;
6445 uint kern_type = 0;
6446 uint dgst_size = 0;
6447 uint esalt_size = 0;
6448 uint opti_type = 0;
6449 uint dgst_pos0 = -1;
6450 uint dgst_pos1 = -1;
6451 uint dgst_pos2 = -1;
6452 uint dgst_pos3 = -1;
6453
6454 int (*parse_func) (char *, uint, hash_t *);
6455 int (*sort_by_digest) (const void *, const void *);
6456
6457 uint algorithm_pos = 0;
6458 uint algorithm_max = 1;
6459
6460 uint *algorithms = default_benchmark_algorithms;
6461
6462 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6463
6464 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6465 {
6466 /*
6467 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6468 * the following algos are skipped entirely
6469 */
6470
6471 if (algorithm_pos > 0)
6472 {
6473 local_free (rd);
6474
6475 rd = init_restore (argc, argv);
6476
6477 data.rd = rd;
6478 }
6479
6480 /**
6481 * update hash_mode in case of multihash benchmark
6482 */
6483
6484 if (benchmark == 1)
6485 {
6486 if (hash_mode_chgd == 0)
6487 {
6488 hash_mode = algorithms[algorithm_pos];
6489
6490 data.hash_mode = hash_mode;
6491 }
6492
6493 quiet = 1;
6494
6495 data.quiet = quiet;
6496 }
6497
6498 switch (hash_mode)
6499 {
6500 case 0: hash_type = HASH_TYPE_MD5;
6501 salt_type = SALT_TYPE_NONE;
6502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6503 opts_type = OPTS_TYPE_PT_GENERATE_LE
6504 | OPTS_TYPE_PT_ADD80
6505 | OPTS_TYPE_PT_ADDBITS14;
6506 kern_type = KERN_TYPE_MD5;
6507 dgst_size = DGST_SIZE_4_4;
6508 parse_func = md5_parse_hash;
6509 sort_by_digest = sort_by_digest_4_4;
6510 opti_type = OPTI_TYPE_ZERO_BYTE
6511 | OPTI_TYPE_PRECOMPUTE_INIT
6512 | OPTI_TYPE_PRECOMPUTE_MERKLE
6513 | OPTI_TYPE_MEET_IN_MIDDLE
6514 | OPTI_TYPE_EARLY_SKIP
6515 | OPTI_TYPE_NOT_ITERATED
6516 | OPTI_TYPE_NOT_SALTED
6517 | OPTI_TYPE_RAW_HASH;
6518 dgst_pos0 = 0;
6519 dgst_pos1 = 3;
6520 dgst_pos2 = 2;
6521 dgst_pos3 = 1;
6522 break;
6523
6524 case 10: hash_type = HASH_TYPE_MD5;
6525 salt_type = SALT_TYPE_INTERN;
6526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6527 opts_type = OPTS_TYPE_PT_GENERATE_LE
6528 | OPTS_TYPE_ST_ADD80
6529 | OPTS_TYPE_ST_ADDBITS14;
6530 kern_type = KERN_TYPE_MD5_PWSLT;
6531 dgst_size = DGST_SIZE_4_4;
6532 parse_func = md5s_parse_hash;
6533 sort_by_digest = sort_by_digest_4_4;
6534 opti_type = OPTI_TYPE_ZERO_BYTE
6535 | OPTI_TYPE_PRECOMPUTE_INIT
6536 | OPTI_TYPE_PRECOMPUTE_MERKLE
6537 | OPTI_TYPE_MEET_IN_MIDDLE
6538 | OPTI_TYPE_EARLY_SKIP
6539 | OPTI_TYPE_NOT_ITERATED
6540 | OPTI_TYPE_APPENDED_SALT
6541 | OPTI_TYPE_RAW_HASH;
6542 dgst_pos0 = 0;
6543 dgst_pos1 = 3;
6544 dgst_pos2 = 2;
6545 dgst_pos3 = 1;
6546 break;
6547
6548 case 11: hash_type = HASH_TYPE_MD5;
6549 salt_type = SALT_TYPE_INTERN;
6550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6551 opts_type = OPTS_TYPE_PT_GENERATE_LE
6552 | OPTS_TYPE_ST_ADD80
6553 | OPTS_TYPE_ST_ADDBITS14;
6554 kern_type = KERN_TYPE_MD5_PWSLT;
6555 dgst_size = DGST_SIZE_4_4;
6556 parse_func = joomla_parse_hash;
6557 sort_by_digest = sort_by_digest_4_4;
6558 opti_type = OPTI_TYPE_ZERO_BYTE
6559 | OPTI_TYPE_PRECOMPUTE_INIT
6560 | OPTI_TYPE_PRECOMPUTE_MERKLE
6561 | OPTI_TYPE_MEET_IN_MIDDLE
6562 | OPTI_TYPE_EARLY_SKIP
6563 | OPTI_TYPE_NOT_ITERATED
6564 | OPTI_TYPE_APPENDED_SALT
6565 | OPTI_TYPE_RAW_HASH;
6566 dgst_pos0 = 0;
6567 dgst_pos1 = 3;
6568 dgst_pos2 = 2;
6569 dgst_pos3 = 1;
6570 break;
6571
6572 case 12: hash_type = HASH_TYPE_MD5;
6573 salt_type = SALT_TYPE_INTERN;
6574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6575 opts_type = OPTS_TYPE_PT_GENERATE_LE
6576 | OPTS_TYPE_ST_ADD80
6577 | OPTS_TYPE_ST_ADDBITS14;
6578 kern_type = KERN_TYPE_MD5_PWSLT;
6579 dgst_size = DGST_SIZE_4_4;
6580 parse_func = postgresql_parse_hash;
6581 sort_by_digest = sort_by_digest_4_4;
6582 opti_type = OPTI_TYPE_ZERO_BYTE
6583 | OPTI_TYPE_PRECOMPUTE_INIT
6584 | OPTI_TYPE_PRECOMPUTE_MERKLE
6585 | OPTI_TYPE_MEET_IN_MIDDLE
6586 | OPTI_TYPE_EARLY_SKIP
6587 | OPTI_TYPE_NOT_ITERATED
6588 | OPTI_TYPE_APPENDED_SALT
6589 | OPTI_TYPE_RAW_HASH;
6590 dgst_pos0 = 0;
6591 dgst_pos1 = 3;
6592 dgst_pos2 = 2;
6593 dgst_pos3 = 1;
6594 break;
6595
6596 case 20: hash_type = HASH_TYPE_MD5;
6597 salt_type = SALT_TYPE_INTERN;
6598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6599 opts_type = OPTS_TYPE_PT_GENERATE_LE
6600 | OPTS_TYPE_PT_ADD80
6601 | OPTS_TYPE_PT_ADDBITS14;
6602 kern_type = KERN_TYPE_MD5_SLTPW;
6603 dgst_size = DGST_SIZE_4_4;
6604 parse_func = md5s_parse_hash;
6605 sort_by_digest = sort_by_digest_4_4;
6606 opti_type = OPTI_TYPE_ZERO_BYTE
6607 | OPTI_TYPE_PRECOMPUTE_INIT
6608 | OPTI_TYPE_PRECOMPUTE_MERKLE
6609 | OPTI_TYPE_EARLY_SKIP
6610 | OPTI_TYPE_NOT_ITERATED
6611 | OPTI_TYPE_PREPENDED_SALT
6612 | OPTI_TYPE_RAW_HASH;
6613 dgst_pos0 = 0;
6614 dgst_pos1 = 3;
6615 dgst_pos2 = 2;
6616 dgst_pos3 = 1;
6617 break;
6618
6619 case 21: hash_type = HASH_TYPE_MD5;
6620 salt_type = SALT_TYPE_INTERN;
6621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6622 opts_type = OPTS_TYPE_PT_GENERATE_LE
6623 | OPTS_TYPE_PT_ADD80
6624 | OPTS_TYPE_PT_ADDBITS14;
6625 kern_type = KERN_TYPE_MD5_SLTPW;
6626 dgst_size = DGST_SIZE_4_4;
6627 parse_func = osc_parse_hash;
6628 sort_by_digest = sort_by_digest_4_4;
6629 opti_type = OPTI_TYPE_ZERO_BYTE
6630 | OPTI_TYPE_PRECOMPUTE_INIT
6631 | OPTI_TYPE_PRECOMPUTE_MERKLE
6632 | OPTI_TYPE_EARLY_SKIP
6633 | OPTI_TYPE_NOT_ITERATED
6634 | OPTI_TYPE_PREPENDED_SALT
6635 | OPTI_TYPE_RAW_HASH;
6636 dgst_pos0 = 0;
6637 dgst_pos1 = 3;
6638 dgst_pos2 = 2;
6639 dgst_pos3 = 1;
6640 break;
6641
6642 case 22: hash_type = HASH_TYPE_MD5;
6643 salt_type = SALT_TYPE_EMBEDDED;
6644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6645 opts_type = OPTS_TYPE_PT_GENERATE_LE
6646 | OPTS_TYPE_PT_ADD80
6647 | OPTS_TYPE_PT_ADDBITS14;
6648 kern_type = KERN_TYPE_MD5_SLTPW;
6649 dgst_size = DGST_SIZE_4_4;
6650 parse_func = netscreen_parse_hash;
6651 sort_by_digest = sort_by_digest_4_4;
6652 opti_type = OPTI_TYPE_ZERO_BYTE
6653 | OPTI_TYPE_PRECOMPUTE_INIT
6654 | OPTI_TYPE_PRECOMPUTE_MERKLE
6655 | OPTI_TYPE_EARLY_SKIP
6656 | OPTI_TYPE_NOT_ITERATED
6657 | OPTI_TYPE_PREPENDED_SALT
6658 | OPTI_TYPE_RAW_HASH;
6659 dgst_pos0 = 0;
6660 dgst_pos1 = 3;
6661 dgst_pos2 = 2;
6662 dgst_pos3 = 1;
6663 break;
6664
6665 case 23: hash_type = HASH_TYPE_MD5;
6666 salt_type = SALT_TYPE_EMBEDDED;
6667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6668 opts_type = OPTS_TYPE_PT_GENERATE_LE
6669 | OPTS_TYPE_PT_ADD80
6670 | OPTS_TYPE_PT_ADDBITS14;
6671 kern_type = KERN_TYPE_MD5_SLTPW;
6672 dgst_size = DGST_SIZE_4_4;
6673 parse_func = skype_parse_hash;
6674 sort_by_digest = sort_by_digest_4_4;
6675 opti_type = OPTI_TYPE_ZERO_BYTE
6676 | OPTI_TYPE_PRECOMPUTE_INIT
6677 | OPTI_TYPE_PRECOMPUTE_MERKLE
6678 | OPTI_TYPE_EARLY_SKIP
6679 | OPTI_TYPE_NOT_ITERATED
6680 | OPTI_TYPE_PREPENDED_SALT
6681 | OPTI_TYPE_RAW_HASH;
6682 dgst_pos0 = 0;
6683 dgst_pos1 = 3;
6684 dgst_pos2 = 2;
6685 dgst_pos3 = 1;
6686 break;
6687
6688 case 30: hash_type = HASH_TYPE_MD5;
6689 salt_type = SALT_TYPE_INTERN;
6690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6691 opts_type = OPTS_TYPE_PT_GENERATE_LE
6692 | OPTS_TYPE_PT_UNICODE
6693 | OPTS_TYPE_ST_ADD80
6694 | OPTS_TYPE_ST_ADDBITS14;
6695 kern_type = KERN_TYPE_MD5_PWUSLT;
6696 dgst_size = DGST_SIZE_4_4;
6697 parse_func = md5s_parse_hash;
6698 sort_by_digest = sort_by_digest_4_4;
6699 opti_type = OPTI_TYPE_ZERO_BYTE
6700 | OPTI_TYPE_PRECOMPUTE_INIT
6701 | OPTI_TYPE_PRECOMPUTE_MERKLE
6702 | OPTI_TYPE_MEET_IN_MIDDLE
6703 | OPTI_TYPE_EARLY_SKIP
6704 | OPTI_TYPE_NOT_ITERATED
6705 | OPTI_TYPE_APPENDED_SALT
6706 | OPTI_TYPE_RAW_HASH;
6707 dgst_pos0 = 0;
6708 dgst_pos1 = 3;
6709 dgst_pos2 = 2;
6710 dgst_pos3 = 1;
6711 break;
6712
6713 case 40: hash_type = HASH_TYPE_MD5;
6714 salt_type = SALT_TYPE_INTERN;
6715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6716 opts_type = OPTS_TYPE_PT_GENERATE_LE
6717 | OPTS_TYPE_PT_ADD80
6718 | OPTS_TYPE_PT_ADDBITS14
6719 | OPTS_TYPE_PT_UNICODE;
6720 kern_type = KERN_TYPE_MD5_SLTPWU;
6721 dgst_size = DGST_SIZE_4_4;
6722 parse_func = md5s_parse_hash;
6723 sort_by_digest = sort_by_digest_4_4;
6724 opti_type = OPTI_TYPE_ZERO_BYTE
6725 | OPTI_TYPE_PRECOMPUTE_INIT
6726 | OPTI_TYPE_PRECOMPUTE_MERKLE
6727 | OPTI_TYPE_EARLY_SKIP
6728 | OPTI_TYPE_NOT_ITERATED
6729 | OPTI_TYPE_PREPENDED_SALT
6730 | OPTI_TYPE_RAW_HASH;
6731 dgst_pos0 = 0;
6732 dgst_pos1 = 3;
6733 dgst_pos2 = 2;
6734 dgst_pos3 = 1;
6735 break;
6736
6737 case 50: hash_type = HASH_TYPE_MD5;
6738 salt_type = SALT_TYPE_INTERN;
6739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6740 opts_type = OPTS_TYPE_PT_GENERATE_LE
6741 | OPTS_TYPE_ST_ADD80
6742 | OPTS_TYPE_ST_ADDBITS14;
6743 kern_type = KERN_TYPE_HMACMD5_PW;
6744 dgst_size = DGST_SIZE_4_4;
6745 parse_func = hmacmd5_parse_hash;
6746 sort_by_digest = sort_by_digest_4_4;
6747 opti_type = OPTI_TYPE_ZERO_BYTE
6748 | OPTI_TYPE_NOT_ITERATED;
6749 dgst_pos0 = 0;
6750 dgst_pos1 = 3;
6751 dgst_pos2 = 2;
6752 dgst_pos3 = 1;
6753 break;
6754
6755 case 60: hash_type = HASH_TYPE_MD5;
6756 salt_type = SALT_TYPE_INTERN;
6757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6758 opts_type = OPTS_TYPE_PT_GENERATE_LE
6759 | OPTS_TYPE_PT_ADD80
6760 | OPTS_TYPE_PT_ADDBITS14;
6761 kern_type = KERN_TYPE_HMACMD5_SLT;
6762 dgst_size = DGST_SIZE_4_4;
6763 parse_func = hmacmd5_parse_hash;
6764 sort_by_digest = sort_by_digest_4_4;
6765 opti_type = OPTI_TYPE_ZERO_BYTE
6766 | OPTI_TYPE_NOT_ITERATED;
6767 dgst_pos0 = 0;
6768 dgst_pos1 = 3;
6769 dgst_pos2 = 2;
6770 dgst_pos3 = 1;
6771 break;
6772
6773 case 100: hash_type = HASH_TYPE_SHA1;
6774 salt_type = SALT_TYPE_NONE;
6775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6776 opts_type = OPTS_TYPE_PT_GENERATE_BE
6777 | OPTS_TYPE_PT_ADD80
6778 | OPTS_TYPE_PT_ADDBITS15;
6779 kern_type = KERN_TYPE_SHA1;
6780 dgst_size = DGST_SIZE_4_5;
6781 parse_func = sha1_parse_hash;
6782 sort_by_digest = sort_by_digest_4_5;
6783 opti_type = OPTI_TYPE_ZERO_BYTE
6784 | OPTI_TYPE_PRECOMPUTE_INIT
6785 | OPTI_TYPE_PRECOMPUTE_MERKLE
6786 | OPTI_TYPE_EARLY_SKIP
6787 | OPTI_TYPE_NOT_ITERATED
6788 | OPTI_TYPE_NOT_SALTED
6789 | OPTI_TYPE_RAW_HASH;
6790 dgst_pos0 = 3;
6791 dgst_pos1 = 4;
6792 dgst_pos2 = 2;
6793 dgst_pos3 = 1;
6794 break;
6795
6796 case 101: hash_type = HASH_TYPE_SHA1;
6797 salt_type = SALT_TYPE_NONE;
6798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6799 opts_type = OPTS_TYPE_PT_GENERATE_BE
6800 | OPTS_TYPE_PT_ADD80
6801 | OPTS_TYPE_PT_ADDBITS15;
6802 kern_type = KERN_TYPE_SHA1;
6803 dgst_size = DGST_SIZE_4_5;
6804 parse_func = sha1b64_parse_hash;
6805 sort_by_digest = sort_by_digest_4_5;
6806 opti_type = OPTI_TYPE_ZERO_BYTE
6807 | OPTI_TYPE_PRECOMPUTE_INIT
6808 | OPTI_TYPE_PRECOMPUTE_MERKLE
6809 | OPTI_TYPE_EARLY_SKIP
6810 | OPTI_TYPE_NOT_ITERATED
6811 | OPTI_TYPE_NOT_SALTED
6812 | OPTI_TYPE_RAW_HASH;
6813 dgst_pos0 = 3;
6814 dgst_pos1 = 4;
6815 dgst_pos2 = 2;
6816 dgst_pos3 = 1;
6817 break;
6818
6819 case 110: hash_type = HASH_TYPE_SHA1;
6820 salt_type = SALT_TYPE_INTERN;
6821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6822 opts_type = OPTS_TYPE_PT_GENERATE_BE
6823 | OPTS_TYPE_ST_ADD80
6824 | OPTS_TYPE_ST_ADDBITS15;
6825 kern_type = KERN_TYPE_SHA1_PWSLT;
6826 dgst_size = DGST_SIZE_4_5;
6827 parse_func = sha1s_parse_hash;
6828 sort_by_digest = sort_by_digest_4_5;
6829 opti_type = OPTI_TYPE_ZERO_BYTE
6830 | OPTI_TYPE_PRECOMPUTE_INIT
6831 | OPTI_TYPE_PRECOMPUTE_MERKLE
6832 | OPTI_TYPE_EARLY_SKIP
6833 | OPTI_TYPE_NOT_ITERATED
6834 | OPTI_TYPE_APPENDED_SALT
6835 | OPTI_TYPE_RAW_HASH;
6836 dgst_pos0 = 3;
6837 dgst_pos1 = 4;
6838 dgst_pos2 = 2;
6839 dgst_pos3 = 1;
6840 break;
6841
6842 case 111: hash_type = HASH_TYPE_SHA1;
6843 salt_type = SALT_TYPE_EMBEDDED;
6844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6845 opts_type = OPTS_TYPE_PT_GENERATE_BE
6846 | OPTS_TYPE_ST_ADD80
6847 | OPTS_TYPE_ST_ADDBITS15;
6848 kern_type = KERN_TYPE_SHA1_PWSLT;
6849 dgst_size = DGST_SIZE_4_5;
6850 parse_func = sha1b64s_parse_hash;
6851 sort_by_digest = sort_by_digest_4_5;
6852 opti_type = OPTI_TYPE_ZERO_BYTE
6853 | OPTI_TYPE_PRECOMPUTE_INIT
6854 | OPTI_TYPE_PRECOMPUTE_MERKLE
6855 | OPTI_TYPE_EARLY_SKIP
6856 | OPTI_TYPE_NOT_ITERATED
6857 | OPTI_TYPE_APPENDED_SALT
6858 | OPTI_TYPE_RAW_HASH;
6859 dgst_pos0 = 3;
6860 dgst_pos1 = 4;
6861 dgst_pos2 = 2;
6862 dgst_pos3 = 1;
6863 break;
6864
6865 case 112: hash_type = HASH_TYPE_SHA1;
6866 salt_type = SALT_TYPE_INTERN;
6867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6868 opts_type = OPTS_TYPE_PT_GENERATE_BE
6869 | OPTS_TYPE_ST_ADD80
6870 | OPTS_TYPE_ST_ADDBITS15
6871 | OPTS_TYPE_ST_HEX;
6872 kern_type = KERN_TYPE_SHA1_PWSLT;
6873 dgst_size = DGST_SIZE_4_5;
6874 parse_func = oracles_parse_hash;
6875 sort_by_digest = sort_by_digest_4_5;
6876 opti_type = OPTI_TYPE_ZERO_BYTE
6877 | OPTI_TYPE_PRECOMPUTE_INIT
6878 | OPTI_TYPE_PRECOMPUTE_MERKLE
6879 | OPTI_TYPE_EARLY_SKIP
6880 | OPTI_TYPE_NOT_ITERATED
6881 | OPTI_TYPE_APPENDED_SALT
6882 | OPTI_TYPE_RAW_HASH;
6883 dgst_pos0 = 3;
6884 dgst_pos1 = 4;
6885 dgst_pos2 = 2;
6886 dgst_pos3 = 1;
6887 break;
6888
6889 case 120: hash_type = HASH_TYPE_SHA1;
6890 salt_type = SALT_TYPE_INTERN;
6891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6892 opts_type = OPTS_TYPE_PT_GENERATE_BE
6893 | OPTS_TYPE_PT_ADD80
6894 | OPTS_TYPE_PT_ADDBITS15;
6895 kern_type = KERN_TYPE_SHA1_SLTPW;
6896 dgst_size = DGST_SIZE_4_5;
6897 parse_func = sha1s_parse_hash;
6898 sort_by_digest = sort_by_digest_4_5;
6899 opti_type = OPTI_TYPE_ZERO_BYTE
6900 | OPTI_TYPE_PRECOMPUTE_INIT
6901 | OPTI_TYPE_PRECOMPUTE_MERKLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_PREPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 3;
6907 dgst_pos1 = 4;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 121: hash_type = HASH_TYPE_SHA1;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_BE
6916 | OPTS_TYPE_PT_ADD80
6917 | OPTS_TYPE_PT_ADDBITS15
6918 | OPTS_TYPE_ST_LOWER;
6919 kern_type = KERN_TYPE_SHA1_SLTPW;
6920 dgst_size = DGST_SIZE_4_5;
6921 parse_func = smf_parse_hash;
6922 sort_by_digest = sort_by_digest_4_5;
6923 opti_type = OPTI_TYPE_ZERO_BYTE
6924 | OPTI_TYPE_PRECOMPUTE_INIT
6925 | OPTI_TYPE_PRECOMPUTE_MERKLE
6926 | OPTI_TYPE_EARLY_SKIP
6927 | OPTI_TYPE_NOT_ITERATED
6928 | OPTI_TYPE_PREPENDED_SALT
6929 | OPTI_TYPE_RAW_HASH;
6930 dgst_pos0 = 3;
6931 dgst_pos1 = 4;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 122: hash_type = HASH_TYPE_SHA1;
6937 salt_type = SALT_TYPE_EMBEDDED;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_BE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS15
6942 | OPTS_TYPE_ST_HEX;
6943 kern_type = KERN_TYPE_SHA1_SLTPW;
6944 dgst_size = DGST_SIZE_4_5;
6945 parse_func = osx1_parse_hash;
6946 sort_by_digest = sort_by_digest_4_5;
6947 opti_type = OPTI_TYPE_ZERO_BYTE
6948 | OPTI_TYPE_PRECOMPUTE_INIT
6949 | OPTI_TYPE_PRECOMPUTE_MERKLE
6950 | OPTI_TYPE_EARLY_SKIP
6951 | OPTI_TYPE_NOT_ITERATED
6952 | OPTI_TYPE_PREPENDED_SALT
6953 | OPTI_TYPE_RAW_HASH;
6954 dgst_pos0 = 3;
6955 dgst_pos1 = 4;
6956 dgst_pos2 = 2;
6957 dgst_pos3 = 1;
6958 break;
6959
6960 case 124: hash_type = HASH_TYPE_SHA1;
6961 salt_type = SALT_TYPE_EMBEDDED;
6962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6963 opts_type = OPTS_TYPE_PT_GENERATE_BE
6964 | OPTS_TYPE_PT_ADD80
6965 | OPTS_TYPE_PT_ADDBITS15;
6966 kern_type = KERN_TYPE_SHA1_SLTPW;
6967 dgst_size = DGST_SIZE_4_5;
6968 parse_func = djangosha1_parse_hash;
6969 sort_by_digest = sort_by_digest_4_5;
6970 opti_type = OPTI_TYPE_ZERO_BYTE
6971 | OPTI_TYPE_PRECOMPUTE_INIT
6972 | OPTI_TYPE_PRECOMPUTE_MERKLE
6973 | OPTI_TYPE_EARLY_SKIP
6974 | OPTI_TYPE_NOT_ITERATED
6975 | OPTI_TYPE_PREPENDED_SALT
6976 | OPTI_TYPE_RAW_HASH;
6977 dgst_pos0 = 3;
6978 dgst_pos1 = 4;
6979 dgst_pos2 = 2;
6980 dgst_pos3 = 1;
6981 break;
6982
6983 case 130: hash_type = HASH_TYPE_SHA1;
6984 salt_type = SALT_TYPE_INTERN;
6985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6986 opts_type = OPTS_TYPE_PT_GENERATE_BE
6987 | OPTS_TYPE_PT_UNICODE
6988 | OPTS_TYPE_ST_ADD80
6989 | OPTS_TYPE_ST_ADDBITS15;
6990 kern_type = KERN_TYPE_SHA1_PWUSLT;
6991 dgst_size = DGST_SIZE_4_5;
6992 parse_func = sha1s_parse_hash;
6993 sort_by_digest = sort_by_digest_4_5;
6994 opti_type = OPTI_TYPE_ZERO_BYTE
6995 | OPTI_TYPE_PRECOMPUTE_INIT
6996 | OPTI_TYPE_PRECOMPUTE_MERKLE
6997 | OPTI_TYPE_EARLY_SKIP
6998 | OPTI_TYPE_NOT_ITERATED
6999 | OPTI_TYPE_APPENDED_SALT
7000 | OPTI_TYPE_RAW_HASH;
7001 dgst_pos0 = 3;
7002 dgst_pos1 = 4;
7003 dgst_pos2 = 2;
7004 dgst_pos3 = 1;
7005 break;
7006
7007 case 131: hash_type = HASH_TYPE_SHA1;
7008 salt_type = SALT_TYPE_EMBEDDED;
7009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7010 opts_type = OPTS_TYPE_PT_GENERATE_BE
7011 | OPTS_TYPE_PT_UNICODE
7012 | OPTS_TYPE_PT_UPPER
7013 | OPTS_TYPE_ST_ADD80
7014 | OPTS_TYPE_ST_ADDBITS15
7015 | OPTS_TYPE_ST_HEX;
7016 kern_type = KERN_TYPE_SHA1_PWUSLT;
7017 dgst_size = DGST_SIZE_4_5;
7018 parse_func = mssql2000_parse_hash;
7019 sort_by_digest = sort_by_digest_4_5;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_APPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 3;
7028 dgst_pos1 = 4;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 132: hash_type = HASH_TYPE_SHA1;
7034 salt_type = SALT_TYPE_EMBEDDED;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_BE
7037 | OPTS_TYPE_PT_UNICODE
7038 | OPTS_TYPE_ST_ADD80
7039 | OPTS_TYPE_ST_ADDBITS15
7040 | OPTS_TYPE_ST_HEX;
7041 kern_type = KERN_TYPE_SHA1_PWUSLT;
7042 dgst_size = DGST_SIZE_4_5;
7043 parse_func = mssql2005_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 133: 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_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS15;
7065 kern_type = KERN_TYPE_SHA1_PWUSLT;
7066 dgst_size = DGST_SIZE_4_5;
7067 parse_func = peoplesoft_parse_hash;
7068 sort_by_digest = sort_by_digest_4_5;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_APPENDED_SALT
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 3;
7077 dgst_pos1 = 4;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 140: hash_type = HASH_TYPE_SHA1;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_BE
7086 | OPTS_TYPE_PT_ADD80
7087 | OPTS_TYPE_PT_ADDBITS15
7088 | OPTS_TYPE_PT_UNICODE;
7089 kern_type = KERN_TYPE_SHA1_SLTPWU;
7090 dgst_size = DGST_SIZE_4_5;
7091 parse_func = sha1s_parse_hash;
7092 sort_by_digest = sort_by_digest_4_5;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_PREPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 3;
7101 dgst_pos1 = 4;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 141: hash_type = HASH_TYPE_SHA1;
7107 salt_type = SALT_TYPE_EMBEDDED;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_BE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS15
7112 | OPTS_TYPE_PT_UNICODE
7113 | OPTS_TYPE_ST_BASE64;
7114 kern_type = KERN_TYPE_SHA1_SLTPWU;
7115 dgst_size = DGST_SIZE_4_5;
7116 parse_func = episerver_parse_hash;
7117 sort_by_digest = sort_by_digest_4_5;
7118 opti_type = OPTI_TYPE_ZERO_BYTE
7119 | OPTI_TYPE_PRECOMPUTE_INIT
7120 | OPTI_TYPE_PRECOMPUTE_MERKLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_PREPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 3;
7126 dgst_pos1 = 4;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 150: hash_type = HASH_TYPE_SHA1;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_BE
7135 | OPTS_TYPE_ST_ADD80
7136 | OPTS_TYPE_ST_ADDBITS15;
7137 kern_type = KERN_TYPE_HMACSHA1_PW;
7138 dgst_size = DGST_SIZE_4_5;
7139 parse_func = hmacsha1_parse_hash;
7140 sort_by_digest = sort_by_digest_4_5;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_NOT_ITERATED;
7143 dgst_pos0 = 3;
7144 dgst_pos1 = 4;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 160: hash_type = HASH_TYPE_SHA1;
7150 salt_type = SALT_TYPE_INTERN;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_BE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS15;
7155 kern_type = KERN_TYPE_HMACSHA1_SLT;
7156 dgst_size = DGST_SIZE_4_5;
7157 parse_func = hmacsha1_parse_hash;
7158 sort_by_digest = sort_by_digest_4_5;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_NOT_ITERATED;
7161 dgst_pos0 = 3;
7162 dgst_pos1 = 4;
7163 dgst_pos2 = 2;
7164 dgst_pos3 = 1;
7165 break;
7166
7167 case 190: hash_type = HASH_TYPE_SHA1;
7168 salt_type = SALT_TYPE_NONE;
7169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7170 opts_type = OPTS_TYPE_PT_GENERATE_BE
7171 | OPTS_TYPE_PT_ADD80
7172 | OPTS_TYPE_PT_ADDBITS15;
7173 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7174 dgst_size = DGST_SIZE_4_5;
7175 parse_func = sha1linkedin_parse_hash;
7176 sort_by_digest = sort_by_digest_4_5;
7177 opti_type = OPTI_TYPE_ZERO_BYTE
7178 | OPTI_TYPE_PRECOMPUTE_INIT
7179 | OPTI_TYPE_EARLY_SKIP
7180 | OPTI_TYPE_NOT_ITERATED
7181 | OPTI_TYPE_NOT_SALTED;
7182 dgst_pos0 = 0;
7183 dgst_pos1 = 4;
7184 dgst_pos2 = 3;
7185 dgst_pos3 = 2;
7186 break;
7187
7188 case 200: hash_type = HASH_TYPE_MYSQL;
7189 salt_type = SALT_TYPE_NONE;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = 0;
7192 kern_type = KERN_TYPE_MYSQL;
7193 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7194 parse_func = mysql323_parse_hash;
7195 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7196 opti_type = OPTI_TYPE_ZERO_BYTE;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 1;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 3;
7201 break;
7202
7203 case 300: hash_type = HASH_TYPE_SHA1;
7204 salt_type = SALT_TYPE_NONE;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_BE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS15;
7209 kern_type = KERN_TYPE_MYSQL41;
7210 dgst_size = DGST_SIZE_4_5;
7211 parse_func = sha1_parse_hash;
7212 sort_by_digest = sort_by_digest_4_5;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_NOT_SALTED;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 400: hash_type = HASH_TYPE_MD5;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7229 kern_type = KERN_TYPE_PHPASS;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = phpass_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
7233 opti_type = OPTI_TYPE_ZERO_BYTE;
7234 dgst_pos0 = 0;
7235 dgst_pos1 = 1;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 3;
7238 break;
7239
7240 case 500: hash_type = HASH_TYPE_MD5;
7241 salt_type = SALT_TYPE_EMBEDDED;
7242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7244 kern_type = KERN_TYPE_MD5CRYPT;
7245 dgst_size = DGST_SIZE_4_4;
7246 parse_func = md5crypt_parse_hash;
7247 sort_by_digest = sort_by_digest_4_4;
7248 opti_type = OPTI_TYPE_ZERO_BYTE;
7249 dgst_pos0 = 0;
7250 dgst_pos1 = 1;
7251 dgst_pos2 = 2;
7252 dgst_pos3 = 3;
7253 break;
7254
7255 case 501: hash_type = HASH_TYPE_MD5;
7256 salt_type = SALT_TYPE_EMBEDDED;
7257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7258 opts_type = OPTS_TYPE_PT_GENERATE_LE
7259 | OPTS_TYPE_HASH_COPY;
7260 kern_type = KERN_TYPE_MD5CRYPT;
7261 dgst_size = DGST_SIZE_4_4;
7262 parse_func = juniper_parse_hash;
7263 sort_by_digest = sort_by_digest_4_4;
7264 opti_type = OPTI_TYPE_ZERO_BYTE;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 1;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 3;
7269 break;
7270
7271 case 900: hash_type = HASH_TYPE_MD4;
7272 salt_type = SALT_TYPE_NONE;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14;
7277 kern_type = KERN_TYPE_MD4;
7278 dgst_size = DGST_SIZE_4_4;
7279 parse_func = md4_parse_hash;
7280 sort_by_digest = sort_by_digest_4_4;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_MEET_IN_MIDDLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_NOT_SALTED
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 1000: hash_type = HASH_TYPE_MD4;
7296 salt_type = SALT_TYPE_NONE;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS14
7301 | OPTS_TYPE_PT_UNICODE;
7302 kern_type = KERN_TYPE_MD4_PWU;
7303 dgst_size = DGST_SIZE_4_4;
7304 parse_func = md4_parse_hash;
7305 sort_by_digest = sort_by_digest_4_4;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_MEET_IN_MIDDLE
7310 | OPTI_TYPE_EARLY_SKIP
7311 | OPTI_TYPE_NOT_ITERATED
7312 | OPTI_TYPE_NOT_SALTED
7313 | OPTI_TYPE_RAW_HASH;
7314 dgst_pos0 = 0;
7315 dgst_pos1 = 3;
7316 dgst_pos2 = 2;
7317 dgst_pos3 = 1;
7318 break;
7319
7320 case 1100: hash_type = HASH_TYPE_MD4;
7321 salt_type = SALT_TYPE_INTERN;
7322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7323 opts_type = OPTS_TYPE_PT_GENERATE_LE
7324 | OPTS_TYPE_PT_ADD80
7325 | OPTS_TYPE_PT_ADDBITS14
7326 | OPTS_TYPE_PT_UNICODE
7327 | OPTS_TYPE_ST_ADD80
7328 | OPTS_TYPE_ST_UNICODE
7329 | OPTS_TYPE_ST_LOWER;
7330 kern_type = KERN_TYPE_MD44_PWUSLT;
7331 dgst_size = DGST_SIZE_4_4;
7332 parse_func = dcc_parse_hash;
7333 sort_by_digest = sort_by_digest_4_4;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED;
7339 dgst_pos0 = 0;
7340 dgst_pos1 = 3;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 1400: hash_type = HASH_TYPE_SHA256;
7346 salt_type = SALT_TYPE_NONE;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_PT_ADD80
7350 | OPTS_TYPE_PT_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA256;
7352 dgst_size = DGST_SIZE_4_8;
7353 parse_func = sha256_parse_hash;
7354 sort_by_digest = sort_by_digest_4_8;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_NOT_SALTED
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 7;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 6;
7366 break;
7367
7368 case 1410: hash_type = HASH_TYPE_SHA256;
7369 salt_type = SALT_TYPE_INTERN;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15;
7374 kern_type = KERN_TYPE_SHA256_PWSLT;
7375 dgst_size = DGST_SIZE_4_8;
7376 parse_func = sha256s_parse_hash;
7377 sort_by_digest = sort_by_digest_4_8;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 7;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 6;
7389 break;
7390
7391 case 1420: hash_type = HASH_TYPE_SHA256;
7392 salt_type = SALT_TYPE_INTERN;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_ADD80
7396 | OPTS_TYPE_PT_ADDBITS15;
7397 kern_type = KERN_TYPE_SHA256_SLTPW;
7398 dgst_size = DGST_SIZE_4_8;
7399 parse_func = sha256s_parse_hash;
7400 sort_by_digest = sort_by_digest_4_8;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_PREPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 7;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 6;
7412 break;
7413
7414 case 1421: hash_type = HASH_TYPE_SHA256;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_PT_ADD80
7419 | OPTS_TYPE_PT_ADDBITS15;
7420 kern_type = KERN_TYPE_SHA256_SLTPW;
7421 dgst_size = DGST_SIZE_4_8;
7422 parse_func = hmailserver_parse_hash;
7423 sort_by_digest = sort_by_digest_4_8;
7424 opti_type = OPTI_TYPE_ZERO_BYTE
7425 | OPTI_TYPE_PRECOMPUTE_INIT
7426 | OPTI_TYPE_PRECOMPUTE_MERKLE
7427 | OPTI_TYPE_EARLY_SKIP
7428 | OPTI_TYPE_NOT_ITERATED
7429 | OPTI_TYPE_PREPENDED_SALT
7430 | OPTI_TYPE_RAW_HASH;
7431 dgst_pos0 = 3;
7432 dgst_pos1 = 7;
7433 dgst_pos2 = 2;
7434 dgst_pos3 = 6;
7435 break;
7436
7437 case 1430: hash_type = HASH_TYPE_SHA256;
7438 salt_type = SALT_TYPE_INTERN;
7439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7440 opts_type = OPTS_TYPE_PT_GENERATE_BE
7441 | OPTS_TYPE_PT_UNICODE
7442 | OPTS_TYPE_ST_ADD80
7443 | OPTS_TYPE_ST_ADDBITS15;
7444 kern_type = KERN_TYPE_SHA256_PWUSLT;
7445 dgst_size = DGST_SIZE_4_8;
7446 parse_func = sha256s_parse_hash;
7447 sort_by_digest = sort_by_digest_4_8;
7448 opti_type = OPTI_TYPE_ZERO_BYTE
7449 | OPTI_TYPE_PRECOMPUTE_INIT
7450 | OPTI_TYPE_PRECOMPUTE_MERKLE
7451 | OPTI_TYPE_EARLY_SKIP
7452 | OPTI_TYPE_NOT_ITERATED
7453 | OPTI_TYPE_APPENDED_SALT
7454 | OPTI_TYPE_RAW_HASH;
7455 dgst_pos0 = 3;
7456 dgst_pos1 = 7;
7457 dgst_pos2 = 2;
7458 dgst_pos3 = 6;
7459 break;
7460
7461 case 1440: hash_type = HASH_TYPE_SHA256;
7462 salt_type = SALT_TYPE_INTERN;
7463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7464 opts_type = OPTS_TYPE_PT_GENERATE_BE
7465 | OPTS_TYPE_PT_ADD80
7466 | OPTS_TYPE_PT_ADDBITS15
7467 | OPTS_TYPE_PT_UNICODE;
7468 kern_type = KERN_TYPE_SHA256_SLTPWU;
7469 dgst_size = DGST_SIZE_4_8;
7470 parse_func = sha256s_parse_hash;
7471 sort_by_digest = sort_by_digest_4_8;
7472 opti_type = OPTI_TYPE_ZERO_BYTE
7473 | OPTI_TYPE_PRECOMPUTE_INIT
7474 | OPTI_TYPE_PRECOMPUTE_MERKLE
7475 | OPTI_TYPE_EARLY_SKIP
7476 | OPTI_TYPE_NOT_ITERATED
7477 | OPTI_TYPE_PREPENDED_SALT
7478 | OPTI_TYPE_RAW_HASH;
7479 dgst_pos0 = 3;
7480 dgst_pos1 = 7;
7481 dgst_pos2 = 2;
7482 dgst_pos3 = 6;
7483 break;
7484
7485 case 1441: hash_type = HASH_TYPE_SHA256;
7486 salt_type = SALT_TYPE_EMBEDDED;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_BE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS15
7491 | OPTS_TYPE_PT_UNICODE
7492 | OPTS_TYPE_ST_BASE64;
7493 kern_type = KERN_TYPE_SHA256_SLTPWU;
7494 dgst_size = DGST_SIZE_4_8;
7495 parse_func = episerver4_parse_hash;
7496 sort_by_digest = sort_by_digest_4_8;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 7;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 6;
7508 break;
7509
7510 case 1450: hash_type = HASH_TYPE_SHA256;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_ST_ADD80;
7515 kern_type = KERN_TYPE_HMACSHA256_PW;
7516 dgst_size = DGST_SIZE_4_8;
7517 parse_func = hmacsha256_parse_hash;
7518 sort_by_digest = sort_by_digest_4_8;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_NOT_ITERATED;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 7;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 6;
7525 break;
7526
7527 case 1460: hash_type = HASH_TYPE_SHA256;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_PT_ADD80
7532 | OPTS_TYPE_PT_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA256_SLT;
7534 dgst_size = DGST_SIZE_4_8;
7535 parse_func = hmacsha256_parse_hash;
7536 sort_by_digest = sort_by_digest_4_8;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 7;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 6;
7543 break;
7544
7545 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7546 salt_type = SALT_TYPE_EMBEDDED;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_LE
7549 | OPTS_TYPE_PT_BITSLICE;
7550 kern_type = KERN_TYPE_DESCRYPT;
7551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7552 parse_func = descrypt_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7556 dgst_pos0 = 0;
7557 dgst_pos1 = 1;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 3;
7560 break;
7561
7562 case 1600: hash_type = HASH_TYPE_MD5;
7563 salt_type = SALT_TYPE_EMBEDDED;
7564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7566 kern_type = KERN_TYPE_APR1CRYPT;
7567 dgst_size = DGST_SIZE_4_4;
7568 parse_func = md5apr1_parse_hash;
7569 sort_by_digest = sort_by_digest_4_4;
7570 opti_type = OPTI_TYPE_ZERO_BYTE;
7571 dgst_pos0 = 0;
7572 dgst_pos1 = 1;
7573 dgst_pos2 = 2;
7574 dgst_pos3 = 3;
7575 break;
7576
7577 case 1700: hash_type = HASH_TYPE_SHA512;
7578 salt_type = SALT_TYPE_NONE;
7579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7580 opts_type = OPTS_TYPE_PT_GENERATE_BE
7581 | OPTS_TYPE_PT_ADD80
7582 | OPTS_TYPE_PT_ADDBITS15;
7583 kern_type = KERN_TYPE_SHA512;
7584 dgst_size = DGST_SIZE_8_8;
7585 parse_func = sha512_parse_hash;
7586 sort_by_digest = sort_by_digest_8_8;
7587 opti_type = OPTI_TYPE_ZERO_BYTE
7588 | OPTI_TYPE_PRECOMPUTE_INIT
7589 | OPTI_TYPE_PRECOMPUTE_MERKLE
7590 | OPTI_TYPE_EARLY_SKIP
7591 | OPTI_TYPE_NOT_ITERATED
7592 | OPTI_TYPE_NOT_SALTED
7593 | OPTI_TYPE_RAW_HASH;
7594 dgst_pos0 = 14;
7595 dgst_pos1 = 15;
7596 dgst_pos2 = 6;
7597 dgst_pos3 = 7;
7598 break;
7599
7600 case 1710: hash_type = HASH_TYPE_SHA512;
7601 salt_type = SALT_TYPE_INTERN;
7602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7603 opts_type = OPTS_TYPE_PT_GENERATE_BE
7604 | OPTS_TYPE_ST_ADD80
7605 | OPTS_TYPE_ST_ADDBITS15;
7606 kern_type = KERN_TYPE_SHA512_PWSLT;
7607 dgst_size = DGST_SIZE_8_8;
7608 parse_func = sha512s_parse_hash;
7609 sort_by_digest = sort_by_digest_8_8;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_APPENDED_SALT
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 14;
7618 dgst_pos1 = 15;
7619 dgst_pos2 = 6;
7620 dgst_pos3 = 7;
7621 break;
7622
7623 case 1711: hash_type = HASH_TYPE_SHA512;
7624 salt_type = SALT_TYPE_EMBEDDED;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_ST_ADD80
7628 | OPTS_TYPE_ST_ADDBITS15;
7629 kern_type = KERN_TYPE_SHA512_PWSLT;
7630 dgst_size = DGST_SIZE_8_8;
7631 parse_func = sha512b64s_parse_hash;
7632 sort_by_digest = sort_by_digest_8_8;
7633 opti_type = OPTI_TYPE_ZERO_BYTE
7634 | OPTI_TYPE_PRECOMPUTE_INIT
7635 | OPTI_TYPE_PRECOMPUTE_MERKLE
7636 | OPTI_TYPE_EARLY_SKIP
7637 | OPTI_TYPE_NOT_ITERATED
7638 | OPTI_TYPE_APPENDED_SALT
7639 | OPTI_TYPE_RAW_HASH;
7640 dgst_pos0 = 14;
7641 dgst_pos1 = 15;
7642 dgst_pos2 = 6;
7643 dgst_pos3 = 7;
7644 break;
7645
7646 case 1720: hash_type = HASH_TYPE_SHA512;
7647 salt_type = SALT_TYPE_INTERN;
7648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7649 opts_type = OPTS_TYPE_PT_GENERATE_BE
7650 | OPTS_TYPE_PT_ADD80
7651 | OPTS_TYPE_PT_ADDBITS15;
7652 kern_type = KERN_TYPE_SHA512_SLTPW;
7653 dgst_size = DGST_SIZE_8_8;
7654 parse_func = sha512s_parse_hash;
7655 sort_by_digest = sort_by_digest_8_8;
7656 opti_type = OPTI_TYPE_ZERO_BYTE
7657 | OPTI_TYPE_PRECOMPUTE_INIT
7658 | OPTI_TYPE_PRECOMPUTE_MERKLE
7659 | OPTI_TYPE_EARLY_SKIP
7660 | OPTI_TYPE_NOT_ITERATED
7661 | OPTI_TYPE_PREPENDED_SALT
7662 | OPTI_TYPE_RAW_HASH;
7663 dgst_pos0 = 14;
7664 dgst_pos1 = 15;
7665 dgst_pos2 = 6;
7666 dgst_pos3 = 7;
7667 break;
7668
7669 case 1722: hash_type = HASH_TYPE_SHA512;
7670 salt_type = SALT_TYPE_EMBEDDED;
7671 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7672 opts_type = OPTS_TYPE_PT_GENERATE_BE
7673 | OPTS_TYPE_PT_ADD80
7674 | OPTS_TYPE_PT_ADDBITS15
7675 | OPTS_TYPE_ST_HEX;
7676 kern_type = KERN_TYPE_SHA512_SLTPW;
7677 dgst_size = DGST_SIZE_8_8;
7678 parse_func = osx512_parse_hash;
7679 sort_by_digest = sort_by_digest_8_8;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 14;
7688 dgst_pos1 = 15;
7689 dgst_pos2 = 6;
7690 dgst_pos3 = 7;
7691 break;
7692
7693 case 1730: hash_type = HASH_TYPE_SHA512;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_PT_UNICODE
7698 | OPTS_TYPE_ST_ADD80
7699 | OPTS_TYPE_ST_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA512_PWSLTU;
7701 dgst_size = DGST_SIZE_8_8;
7702 parse_func = sha512s_parse_hash;
7703 sort_by_digest = sort_by_digest_8_8;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_PRECOMPUTE_MERKLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_APPENDED_SALT
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 14;
7712 dgst_pos1 = 15;
7713 dgst_pos2 = 6;
7714 dgst_pos3 = 7;
7715 break;
7716
7717 case 1731: hash_type = HASH_TYPE_SHA512;
7718 salt_type = SALT_TYPE_EMBEDDED;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_BE
7721 | OPTS_TYPE_PT_UNICODE
7722 | OPTS_TYPE_ST_ADD80
7723 | OPTS_TYPE_ST_ADDBITS15
7724 | OPTS_TYPE_ST_HEX;
7725 kern_type = KERN_TYPE_SHA512_PWSLTU;
7726 dgst_size = DGST_SIZE_8_8;
7727 parse_func = mssql2012_parse_hash;
7728 sort_by_digest = sort_by_digest_8_8;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_APPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 14;
7737 dgst_pos1 = 15;
7738 dgst_pos2 = 6;
7739 dgst_pos3 = 7;
7740 break;
7741
7742 case 1740: hash_type = HASH_TYPE_SHA512;
7743 salt_type = SALT_TYPE_INTERN;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15
7748 | OPTS_TYPE_PT_UNICODE;
7749 kern_type = KERN_TYPE_SHA512_SLTPWU;
7750 dgst_size = DGST_SIZE_8_8;
7751 parse_func = sha512s_parse_hash;
7752 sort_by_digest = sort_by_digest_8_8;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 14;
7761 dgst_pos1 = 15;
7762 dgst_pos2 = 6;
7763 dgst_pos3 = 7;
7764 break;
7765
7766 case 1750: hash_type = HASH_TYPE_SHA512;
7767 salt_type = SALT_TYPE_INTERN;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_ST_ADD80;
7771 kern_type = KERN_TYPE_HMACSHA512_PW;
7772 dgst_size = DGST_SIZE_8_8;
7773 parse_func = hmacsha512_parse_hash;
7774 sort_by_digest = sort_by_digest_8_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_NOT_ITERATED;
7777 dgst_pos0 = 14;
7778 dgst_pos1 = 15;
7779 dgst_pos2 = 6;
7780 dgst_pos3 = 7;
7781 break;
7782
7783 case 1760: hash_type = HASH_TYPE_SHA512;
7784 salt_type = SALT_TYPE_INTERN;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_BE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS15;
7789 kern_type = KERN_TYPE_HMACSHA512_SLT;
7790 dgst_size = DGST_SIZE_8_8;
7791 parse_func = hmacsha512_parse_hash;
7792 sort_by_digest = sort_by_digest_8_8;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_NOT_ITERATED;
7795 dgst_pos0 = 14;
7796 dgst_pos1 = 15;
7797 dgst_pos2 = 6;
7798 dgst_pos3 = 7;
7799 break;
7800
7801 case 1800: hash_type = HASH_TYPE_SHA512;
7802 salt_type = SALT_TYPE_EMBEDDED;
7803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7805 kern_type = KERN_TYPE_SHA512CRYPT;
7806 dgst_size = DGST_SIZE_8_8;
7807 parse_func = sha512crypt_parse_hash;
7808 sort_by_digest = sort_by_digest_8_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 2100: hash_type = HASH_TYPE_DCC2;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
7820 | OPTS_TYPE_ST_LOWER
7821 | OPTS_TYPE_ST_UNICODE;
7822 kern_type = KERN_TYPE_DCC2;
7823 dgst_size = DGST_SIZE_4_4;
7824 parse_func = dcc2_parse_hash;
7825 sort_by_digest = sort_by_digest_4_4;
7826 opti_type = OPTI_TYPE_ZERO_BYTE;
7827 dgst_pos0 = 0;
7828 dgst_pos1 = 1;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 3;
7831 break;
7832
7833 case 2400: hash_type = HASH_TYPE_MD5;
7834 salt_type = SALT_TYPE_NONE;
7835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7837 kern_type = KERN_TYPE_MD5PIX;
7838 dgst_size = DGST_SIZE_4_4;
7839 parse_func = md5pix_parse_hash;
7840 sort_by_digest = sort_by_digest_4_4;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_NOT_SALTED;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 2410: hash_type = HASH_TYPE_MD5;
7854 salt_type = SALT_TYPE_INTERN;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7857 kern_type = KERN_TYPE_MD5ASA;
7858 dgst_size = DGST_SIZE_4_4;
7859 parse_func = md5asa_parse_hash;
7860 sort_by_digest = sort_by_digest_4_4;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED;
7866 dgst_pos0 = 0;
7867 dgst_pos1 = 3;
7868 dgst_pos2 = 2;
7869 dgst_pos3 = 1;
7870 break;
7871
7872 case 2500: hash_type = HASH_TYPE_WPA;
7873 salt_type = SALT_TYPE_EMBEDDED;
7874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
7876 kern_type = KERN_TYPE_WPA;
7877 dgst_size = DGST_SIZE_4_4;
7878 parse_func = wpa_parse_hash;
7879 sort_by_digest = sort_by_digest_4_4;
7880 opti_type = OPTI_TYPE_ZERO_BYTE;
7881 dgst_pos0 = 0;
7882 dgst_pos1 = 1;
7883 dgst_pos2 = 2;
7884 dgst_pos3 = 3;
7885 break;
7886
7887 case 2600: hash_type = HASH_TYPE_MD5;
7888 salt_type = SALT_TYPE_VIRTUAL;
7889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7890 opts_type = OPTS_TYPE_PT_GENERATE_LE
7891 | OPTS_TYPE_PT_ADD80
7892 | OPTS_TYPE_PT_ADDBITS14
7893 | OPTS_TYPE_ST_ADD80;
7894 kern_type = KERN_TYPE_MD55_PWSLT1;
7895 dgst_size = DGST_SIZE_4_4;
7896 parse_func = md5md5_parse_hash;
7897 sort_by_digest = sort_by_digest_4_4;
7898 opti_type = OPTI_TYPE_ZERO_BYTE
7899 | OPTI_TYPE_PRECOMPUTE_INIT
7900 | OPTI_TYPE_PRECOMPUTE_MERKLE
7901 | OPTI_TYPE_EARLY_SKIP;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 2611: hash_type = HASH_TYPE_MD5;
7909 salt_type = SALT_TYPE_INTERN;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_LE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS14
7914 | OPTS_TYPE_ST_ADD80;
7915 kern_type = KERN_TYPE_MD55_PWSLT1;
7916 dgst_size = DGST_SIZE_4_4;
7917 parse_func = vb3_parse_hash;
7918 sort_by_digest = sort_by_digest_4_4;
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_INIT
7921 | OPTI_TYPE_PRECOMPUTE_MERKLE
7922 | OPTI_TYPE_EARLY_SKIP;
7923 dgst_pos0 = 0;
7924 dgst_pos1 = 3;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 2612: hash_type = HASH_TYPE_MD5;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_LE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS14
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_HEX;
7937 kern_type = KERN_TYPE_MD55_PWSLT1;
7938 dgst_size = DGST_SIZE_4_4;
7939 parse_func = phps_parse_hash;
7940 sort_by_digest = sort_by_digest_4_4;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP;
7945 dgst_pos0 = 0;
7946 dgst_pos1 = 3;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 1;
7949 break;
7950
7951 case 2711: hash_type = HASH_TYPE_MD5;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_LE
7955 | OPTS_TYPE_PT_ADD80
7956 | OPTS_TYPE_PT_ADDBITS14
7957 | OPTS_TYPE_ST_ADD80;
7958 kern_type = KERN_TYPE_MD55_PWSLT2;
7959 dgst_size = DGST_SIZE_4_4;
7960 parse_func = vb30_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4;
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_INIT
7964 | OPTI_TYPE_EARLY_SKIP;
7965 dgst_pos0 = 0;
7966 dgst_pos1 = 3;
7967 dgst_pos2 = 2;
7968 dgst_pos3 = 1;
7969 break;
7970
7971 case 2811: hash_type = HASH_TYPE_MD5;
7972 salt_type = SALT_TYPE_INTERN;
7973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7974 opts_type = OPTS_TYPE_PT_GENERATE_LE
7975 | OPTS_TYPE_PT_ADD80
7976 | OPTS_TYPE_PT_ADDBITS14;
7977 kern_type = KERN_TYPE_MD55_SLTPW;
7978 dgst_size = DGST_SIZE_4_4;
7979 parse_func = ipb2_parse_hash;
7980 sort_by_digest = sort_by_digest_4_4;
7981 opti_type = OPTI_TYPE_ZERO_BYTE
7982 | OPTI_TYPE_PRECOMPUTE_INIT
7983 | OPTI_TYPE_EARLY_SKIP;
7984 dgst_pos0 = 0;
7985 dgst_pos1 = 3;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 1;
7988 break;
7989
7990 case 3000: hash_type = HASH_TYPE_LM;
7991 salt_type = SALT_TYPE_NONE;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_LE
7994 | OPTS_TYPE_PT_UPPER
7995 | OPTS_TYPE_PT_BITSLICE;
7996 kern_type = KERN_TYPE_LM;
7997 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7998 parse_func = lm_parse_hash;
7999 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8002 dgst_pos0 = 0;
8003 dgst_pos1 = 1;
8004 dgst_pos2 = 2;
8005 dgst_pos3 = 3;
8006 break;
8007
8008 case 3100: hash_type = HASH_TYPE_ORACLEH;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_LE
8012 | OPTS_TYPE_PT_UPPER
8013 | OPTS_TYPE_ST_UPPER;
8014 kern_type = KERN_TYPE_ORACLEH;
8015 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8016 parse_func = oracleh_parse_hash;
8017 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8018 opti_type = OPTI_TYPE_ZERO_BYTE;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 1;
8021 dgst_pos2 = 2;
8022 dgst_pos3 = 3;
8023 break;
8024
8025 case 3200: hash_type = HASH_TYPE_BCRYPT;
8026 salt_type = SALT_TYPE_EMBEDDED;
8027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8028 opts_type = OPTS_TYPE_PT_GENERATE_LE
8029 | OPTS_TYPE_ST_GENERATE_LE;
8030 kern_type = KERN_TYPE_BCRYPT;
8031 dgst_size = DGST_SIZE_4_6;
8032 parse_func = bcrypt_parse_hash;
8033 sort_by_digest = sort_by_digest_4_6;
8034 opti_type = OPTI_TYPE_ZERO_BYTE;
8035 dgst_pos0 = 0;
8036 dgst_pos1 = 1;
8037 dgst_pos2 = 2;
8038 dgst_pos3 = 3;
8039 break;
8040
8041 case 3710: hash_type = HASH_TYPE_MD5;
8042 salt_type = SALT_TYPE_INTERN;
8043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8044 opts_type = OPTS_TYPE_PT_GENERATE_LE
8045 | OPTS_TYPE_PT_ADD80
8046 | OPTS_TYPE_PT_ADDBITS14;
8047 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8048 dgst_size = DGST_SIZE_4_4;
8049 parse_func = md5s_parse_hash;
8050 sort_by_digest = sort_by_digest_4_4;
8051 opti_type = OPTI_TYPE_ZERO_BYTE
8052 | OPTI_TYPE_PRECOMPUTE_INIT
8053 | OPTI_TYPE_PRECOMPUTE_MERKLE
8054 | OPTI_TYPE_EARLY_SKIP;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 3;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 1;
8059 break;
8060
8061 case 3711: hash_type = HASH_TYPE_MD5;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE
8065 | OPTS_TYPE_PT_ADD80
8066 | OPTS_TYPE_PT_ADDBITS14;
8067 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8068 dgst_size = DGST_SIZE_4_4;
8069 parse_func = mediawiki_b_parse_hash;
8070 sort_by_digest = sort_by_digest_4_4;
8071 opti_type = OPTI_TYPE_ZERO_BYTE
8072 | OPTI_TYPE_PRECOMPUTE_INIT
8073 | OPTI_TYPE_PRECOMPUTE_MERKLE
8074 | OPTI_TYPE_EARLY_SKIP;
8075 dgst_pos0 = 0;
8076 dgst_pos1 = 3;
8077 dgst_pos2 = 2;
8078 dgst_pos3 = 1;
8079 break;
8080
8081 case 3800: hash_type = HASH_TYPE_MD5;
8082 salt_type = SALT_TYPE_INTERN;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_LE
8085 | OPTS_TYPE_ST_ADDBITS14;
8086 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8087 dgst_size = DGST_SIZE_4_4;
8088 parse_func = md5s_parse_hash;
8089 sort_by_digest = sort_by_digest_4_4;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_RAW_HASH;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 3;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 1;
8100 break;
8101
8102 case 4300: hash_type = HASH_TYPE_MD5;
8103 salt_type = SALT_TYPE_VIRTUAL;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS14
8108 | OPTS_TYPE_ST_ADD80;
8109 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8110 dgst_size = DGST_SIZE_4_4;
8111 parse_func = md5md5_parse_hash;
8112 sort_by_digest = sort_by_digest_4_4;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_PRECOMPUTE_INIT
8115 | OPTI_TYPE_PRECOMPUTE_MERKLE
8116 | OPTI_TYPE_EARLY_SKIP;
8117 dgst_pos0 = 0;
8118 dgst_pos1 = 3;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 1;
8121 break;
8122
8123
8124 case 4400: hash_type = HASH_TYPE_MD5;
8125 salt_type = SALT_TYPE_NONE;
8126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8127 opts_type = OPTS_TYPE_PT_GENERATE_BE
8128 | OPTS_TYPE_PT_ADD80
8129 | OPTS_TYPE_PT_ADDBITS15;
8130 kern_type = KERN_TYPE_MD5_SHA1;
8131 dgst_size = DGST_SIZE_4_4;
8132 parse_func = md5_parse_hash;
8133 sort_by_digest = sort_by_digest_4_4;
8134 opti_type = OPTI_TYPE_ZERO_BYTE
8135 | OPTI_TYPE_PRECOMPUTE_INIT
8136 | OPTI_TYPE_PRECOMPUTE_MERKLE
8137 | OPTI_TYPE_EARLY_SKIP
8138 | OPTI_TYPE_NOT_ITERATED
8139 | OPTI_TYPE_NOT_SALTED
8140 | OPTI_TYPE_RAW_HASH;
8141 dgst_pos0 = 0;
8142 dgst_pos1 = 3;
8143 dgst_pos2 = 2;
8144 dgst_pos3 = 1;
8145 break;
8146
8147 case 4500: hash_type = HASH_TYPE_SHA1;
8148 salt_type = SALT_TYPE_NONE;
8149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8150 opts_type = OPTS_TYPE_PT_GENERATE_BE
8151 | OPTS_TYPE_PT_ADD80
8152 | OPTS_TYPE_PT_ADDBITS15;
8153 kern_type = KERN_TYPE_SHA11;
8154 dgst_size = DGST_SIZE_4_5;
8155 parse_func = sha1_parse_hash;
8156 sort_by_digest = sort_by_digest_4_5;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_SALTED;
8162 dgst_pos0 = 3;
8163 dgst_pos1 = 4;
8164 dgst_pos2 = 2;
8165 dgst_pos3 = 1;
8166 break;
8167
8168 case 4700: hash_type = HASH_TYPE_SHA1;
8169 salt_type = SALT_TYPE_NONE;
8170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8171 opts_type = OPTS_TYPE_PT_GENERATE_LE
8172 | OPTS_TYPE_PT_ADD80
8173 | OPTS_TYPE_PT_ADDBITS14;
8174 kern_type = KERN_TYPE_SHA1_MD5;
8175 dgst_size = DGST_SIZE_4_5;
8176 parse_func = sha1_parse_hash;
8177 sort_by_digest = sort_by_digest_4_5;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_PRECOMPUTE_INIT
8180 | OPTI_TYPE_PRECOMPUTE_MERKLE
8181 | OPTI_TYPE_EARLY_SKIP
8182 | OPTI_TYPE_NOT_ITERATED
8183 | OPTI_TYPE_NOT_SALTED
8184 | OPTI_TYPE_RAW_HASH;
8185 dgst_pos0 = 3;
8186 dgst_pos1 = 4;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 1;
8189 break;
8190
8191 case 4800: hash_type = HASH_TYPE_MD5;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_LE
8195 | OPTS_TYPE_PT_ADDBITS14;
8196 kern_type = KERN_TYPE_MD5_CHAP;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = chap_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_PRECOMPUTE_INIT
8202 | OPTI_TYPE_PRECOMPUTE_MERKLE
8203 | OPTI_TYPE_MEET_IN_MIDDLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_RAW_HASH;
8207 dgst_pos0 = 0;
8208 dgst_pos1 = 3;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 4900: hash_type = HASH_TYPE_SHA1;
8214 salt_type = SALT_TYPE_INTERN;
8215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8217 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8218 dgst_size = DGST_SIZE_4_5;
8219 parse_func = sha1s_parse_hash;
8220 sort_by_digest = sort_by_digest_4_5;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP;
8225 dgst_pos0 = 3;
8226 dgst_pos1 = 4;
8227 dgst_pos2 = 2;
8228 dgst_pos3 = 1;
8229 break;
8230
8231 case 5000: hash_type = HASH_TYPE_KECCAK;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_LE
8235 | OPTS_TYPE_PT_ADD01;
8236 kern_type = KERN_TYPE_KECCAK;
8237 dgst_size = DGST_SIZE_8_25;
8238 parse_func = keccak_parse_hash;
8239 sort_by_digest = sort_by_digest_8_25;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_RAW_HASH;
8242 dgst_pos0 = 2;
8243 dgst_pos1 = 3;
8244 dgst_pos2 = 4;
8245 dgst_pos3 = 5;
8246 break;
8247
8248 case 5100: hash_type = HASH_TYPE_MD5H;
8249 salt_type = SALT_TYPE_NONE;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE
8252 | OPTS_TYPE_PT_ADD80
8253 | OPTS_TYPE_PT_ADDBITS14;
8254 kern_type = KERN_TYPE_MD5H;
8255 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8256 parse_func = md5half_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_RAW_HASH;
8260 dgst_pos0 = 0;
8261 dgst_pos1 = 1;
8262 dgst_pos2 = 2;
8263 dgst_pos3 = 3;
8264 break;
8265
8266 case 5200: hash_type = HASH_TYPE_SHA256;
8267 salt_type = SALT_TYPE_EMBEDDED;
8268 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8269 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8270 kern_type = KERN_TYPE_PSAFE3;
8271 dgst_size = DGST_SIZE_4_8;
8272 parse_func = psafe3_parse_hash;
8273 sort_by_digest = sort_by_digest_4_8;
8274 opti_type = OPTI_TYPE_ZERO_BYTE;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 1;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 3;
8279 break;
8280
8281 case 5300: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_ST_ADD80;
8286 kern_type = KERN_TYPE_IKEPSK_MD5;
8287 dgst_size = DGST_SIZE_4_4;
8288 parse_func = ikepsk_md5_parse_hash;
8289 sort_by_digest = sort_by_digest_4_4;
8290 opti_type = OPTI_TYPE_ZERO_BYTE;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 3;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 5400: hash_type = HASH_TYPE_SHA1;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_BE
8301 | OPTS_TYPE_ST_ADD80;
8302 kern_type = KERN_TYPE_IKEPSK_SHA1;
8303 dgst_size = DGST_SIZE_4_5;
8304 parse_func = ikepsk_sha1_parse_hash;
8305 sort_by_digest = sort_by_digest_4_5;
8306 opti_type = OPTI_TYPE_ZERO_BYTE;
8307 dgst_pos0 = 3;
8308 dgst_pos1 = 4;
8309 dgst_pos2 = 2;
8310 dgst_pos3 = 1;
8311 break;
8312
8313 case 5500: hash_type = HASH_TYPE_NETNTLM;
8314 salt_type = SALT_TYPE_EMBEDDED;
8315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8316 opts_type = OPTS_TYPE_PT_GENERATE_LE
8317 | OPTS_TYPE_PT_ADD80
8318 | OPTS_TYPE_PT_ADDBITS14
8319 | OPTS_TYPE_PT_UNICODE
8320 | OPTS_TYPE_ST_HEX;
8321 kern_type = KERN_TYPE_NETNTLMv1;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = netntlmv1_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8327 dgst_pos0 = 0;
8328 dgst_pos1 = 1;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 3;
8331 break;
8332
8333 case 5600: hash_type = HASH_TYPE_MD5;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_LE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS14
8339 | OPTS_TYPE_PT_UNICODE;
8340 kern_type = KERN_TYPE_NETNTLMv2;
8341 dgst_size = DGST_SIZE_4_4;
8342 parse_func = netntlmv2_parse_hash;
8343 sort_by_digest = sort_by_digest_4_4;
8344 opti_type = OPTI_TYPE_ZERO_BYTE;
8345 dgst_pos0 = 0;
8346 dgst_pos1 = 3;
8347 dgst_pos2 = 2;
8348 dgst_pos3 = 1;
8349 break;
8350
8351 case 5700: hash_type = HASH_TYPE_SHA256;
8352 salt_type = SALT_TYPE_NONE;
8353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8354 opts_type = OPTS_TYPE_PT_GENERATE_BE
8355 | OPTS_TYPE_PT_ADD80
8356 | OPTS_TYPE_PT_ADDBITS15;
8357 kern_type = KERN_TYPE_SHA256;
8358 dgst_size = DGST_SIZE_4_8;
8359 parse_func = cisco4_parse_hash;
8360 sort_by_digest = sort_by_digest_4_8;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_PRECOMPUTE_INIT
8363 | OPTI_TYPE_PRECOMPUTE_MERKLE
8364 | OPTI_TYPE_EARLY_SKIP
8365 | OPTI_TYPE_NOT_ITERATED
8366 | OPTI_TYPE_NOT_SALTED
8367 | OPTI_TYPE_RAW_HASH;
8368 dgst_pos0 = 3;
8369 dgst_pos1 = 7;
8370 dgst_pos2 = 2;
8371 dgst_pos3 = 6;
8372 break;
8373
8374 case 5800: hash_type = HASH_TYPE_SHA1;
8375 salt_type = SALT_TYPE_INTERN;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8378 | OPTS_TYPE_ST_ADD80;
8379 kern_type = KERN_TYPE_ANDROIDPIN;
8380 dgst_size = DGST_SIZE_4_5;
8381 parse_func = androidpin_parse_hash;
8382 sort_by_digest = sort_by_digest_4_5;
8383 opti_type = OPTI_TYPE_ZERO_BYTE;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8391 salt_type = SALT_TYPE_NONE;
8392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE
8394 | OPTS_TYPE_PT_ADD80;
8395 kern_type = KERN_TYPE_RIPEMD160;
8396 dgst_size = DGST_SIZE_4_5;
8397 parse_func = ripemd160_parse_hash;
8398 sort_by_digest = sort_by_digest_4_5;
8399 opti_type = OPTI_TYPE_ZERO_BYTE;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 1;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 3;
8404 break;
8405
8406 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_BE
8410 | OPTS_TYPE_PT_ADD80;
8411 kern_type = KERN_TYPE_WHIRLPOOL;
8412 dgst_size = DGST_SIZE_4_16;
8413 parse_func = whirlpool_parse_hash;
8414 sort_by_digest = sort_by_digest_4_16;
8415 opti_type = OPTI_TYPE_ZERO_BYTE;
8416 dgst_pos0 = 0;
8417 dgst_pos1 = 1;
8418 dgst_pos2 = 2;
8419 dgst_pos3 = 3;
8420 break;
8421
8422 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8423 salt_type = SALT_TYPE_EMBEDDED;
8424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8426 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8427 dgst_size = DGST_SIZE_4_5;
8428 parse_func = truecrypt_parse_hash_2k;
8429 sort_by_digest = sort_by_digest_4_5;
8430 opti_type = OPTI_TYPE_ZERO_BYTE;
8431 dgst_pos0 = 0;
8432 dgst_pos1 = 1;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 3;
8435 break;
8436
8437 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8438 salt_type = SALT_TYPE_EMBEDDED;
8439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8441 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8442 dgst_size = DGST_SIZE_4_5;
8443 parse_func = truecrypt_parse_hash_2k;
8444 sort_by_digest = sort_by_digest_4_5;
8445 opti_type = OPTI_TYPE_ZERO_BYTE;
8446 dgst_pos0 = 0;
8447 dgst_pos1 = 1;
8448 dgst_pos2 = 2;
8449 dgst_pos3 = 3;
8450 break;
8451
8452 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8453 salt_type = SALT_TYPE_EMBEDDED;
8454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8456 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8457 dgst_size = DGST_SIZE_4_5;
8458 parse_func = truecrypt_parse_hash_2k;
8459 sort_by_digest = sort_by_digest_4_5;
8460 opti_type = OPTI_TYPE_ZERO_BYTE;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 1;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 3;
8465 break;
8466
8467 case 6221: hash_type = HASH_TYPE_SHA512;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_TCSHA512_XTS512;
8472 dgst_size = DGST_SIZE_8_8;
8473 parse_func = truecrypt_parse_hash_1k;
8474 sort_by_digest = sort_by_digest_8_8;
8475 opti_type = OPTI_TYPE_ZERO_BYTE;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 1;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 3;
8480 break;
8481
8482 case 6222: hash_type = HASH_TYPE_SHA512;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8486 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8487 dgst_size = DGST_SIZE_8_8;
8488 parse_func = truecrypt_parse_hash_1k;
8489 sort_by_digest = sort_by_digest_8_8;
8490 opti_type = OPTI_TYPE_ZERO_BYTE;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 1;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 3;
8495 break;
8496
8497 case 6223: hash_type = HASH_TYPE_SHA512;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8501 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8502 dgst_size = DGST_SIZE_8_8;
8503 parse_func = truecrypt_parse_hash_1k;
8504 sort_by_digest = sort_by_digest_8_8;
8505 opti_type = OPTI_TYPE_ZERO_BYTE;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 1;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 3;
8510 break;
8511
8512 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8513 salt_type = SALT_TYPE_EMBEDDED;
8514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8516 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8517 dgst_size = DGST_SIZE_4_8;
8518 parse_func = truecrypt_parse_hash_1k;
8519 sort_by_digest = sort_by_digest_4_8;
8520 opti_type = OPTI_TYPE_ZERO_BYTE;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 1;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 3;
8525 break;
8526
8527 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8528 salt_type = SALT_TYPE_EMBEDDED;
8529 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8531 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8532 dgst_size = DGST_SIZE_4_8;
8533 parse_func = truecrypt_parse_hash_1k;
8534 sort_by_digest = sort_by_digest_4_8;
8535 opti_type = OPTI_TYPE_ZERO_BYTE;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 1;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 3;
8540 break;
8541
8542 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8543 salt_type = SALT_TYPE_EMBEDDED;
8544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8546 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8547 dgst_size = DGST_SIZE_4_8;
8548 parse_func = truecrypt_parse_hash_1k;
8549 sort_by_digest = sort_by_digest_4_8;
8550 opti_type = OPTI_TYPE_ZERO_BYTE;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 1;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 3;
8555 break;
8556
8557 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8558 salt_type = SALT_TYPE_EMBEDDED;
8559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8561 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8562 dgst_size = DGST_SIZE_4_5;
8563 parse_func = truecrypt_parse_hash_1k;
8564 sort_by_digest = sort_by_digest_4_5;
8565 opti_type = OPTI_TYPE_ZERO_BYTE;
8566 dgst_pos0 = 0;
8567 dgst_pos1 = 1;
8568 dgst_pos2 = 2;
8569 dgst_pos3 = 3;
8570 break;
8571
8572 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8573 salt_type = SALT_TYPE_EMBEDDED;
8574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8576 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8577 dgst_size = DGST_SIZE_4_5;
8578 parse_func = truecrypt_parse_hash_1k;
8579 sort_by_digest = sort_by_digest_4_5;
8580 opti_type = OPTI_TYPE_ZERO_BYTE;
8581 dgst_pos0 = 0;
8582 dgst_pos1 = 1;
8583 dgst_pos2 = 2;
8584 dgst_pos3 = 3;
8585 break;
8586
8587 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8588 salt_type = SALT_TYPE_EMBEDDED;
8589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8591 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8592 dgst_size = DGST_SIZE_4_5;
8593 parse_func = truecrypt_parse_hash_1k;
8594 sort_by_digest = sort_by_digest_4_5;
8595 opti_type = OPTI_TYPE_ZERO_BYTE;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 1;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 3;
8600 break;
8601
8602 case 6300: hash_type = HASH_TYPE_MD5;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8606 kern_type = KERN_TYPE_MD5AIX;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = md5aix_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 6400: hash_type = HASH_TYPE_SHA256;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8621 kern_type = KERN_TYPE_SHA256AIX;
8622 dgst_size = DGST_SIZE_4_8;
8623 parse_func = sha256aix_parse_hash;
8624 sort_by_digest = sort_by_digest_4_8;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 6500: hash_type = HASH_TYPE_SHA512;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8636 kern_type = KERN_TYPE_SHA512AIX;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = sha512aix_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE;
8641 dgst_pos0 = 0;
8642 dgst_pos1 = 1;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 3;
8645 break;
8646
8647 case 6600: hash_type = HASH_TYPE_AES;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8651 kern_type = KERN_TYPE_AGILEKEY;
8652 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
8653 parse_func = agilekey_parse_hash;
8654 sort_by_digest = sort_by_digest_4_5;
8655 opti_type = OPTI_TYPE_ZERO_BYTE;
8656 dgst_pos0 = 0;
8657 dgst_pos1 = 1;
8658 dgst_pos2 = 2;
8659 dgst_pos3 = 3;
8660 break;
8661
8662 case 6700: hash_type = HASH_TYPE_SHA1;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8666 kern_type = KERN_TYPE_SHA1AIX;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = sha1aix_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 6800: hash_type = HASH_TYPE_AES;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8681 kern_type = KERN_TYPE_LASTPASS;
8682 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
8683 parse_func = lastpass_parse_hash;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 6900: hash_type = HASH_TYPE_GOST;
8693 salt_type = SALT_TYPE_NONE;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8696 kern_type = KERN_TYPE_GOST;
8697 dgst_size = DGST_SIZE_4_8;
8698 parse_func = gost_parse_hash;
8699 sort_by_digest = sort_by_digest_4_8;
8700 opti_type = OPTI_TYPE_ZERO_BYTE;
8701 dgst_pos0 = 0;
8702 dgst_pos1 = 1;
8703 dgst_pos2 = 2;
8704 dgst_pos3 = 3;
8705 break;
8706
8707 case 7100: hash_type = HASH_TYPE_SHA512;
8708 salt_type = SALT_TYPE_EMBEDDED;
8709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8710 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8711 kern_type = KERN_TYPE_PBKDF2_SHA512;
8712 dgst_size = DGST_SIZE_8_16;
8713 parse_func = sha512osx_parse_hash;
8714 sort_by_digest = sort_by_digest_8_16;
8715 opti_type = OPTI_TYPE_ZERO_BYTE;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 1;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 3;
8720 break;
8721
8722 case 7200: hash_type = HASH_TYPE_SHA512;
8723 salt_type = SALT_TYPE_EMBEDDED;
8724 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8726 kern_type = KERN_TYPE_PBKDF2_SHA512;
8727 dgst_size = DGST_SIZE_8_16;
8728 parse_func = sha512grub_parse_hash;
8729 sort_by_digest = sort_by_digest_8_16;
8730 opti_type = OPTI_TYPE_ZERO_BYTE;
8731 dgst_pos0 = 0;
8732 dgst_pos1 = 1;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 3;
8735 break;
8736
8737 case 7300: hash_type = HASH_TYPE_SHA1;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_BE
8741 | OPTS_TYPE_ST_ADD80
8742 | OPTS_TYPE_ST_ADDBITS15;
8743 kern_type = KERN_TYPE_RAKP;
8744 dgst_size = DGST_SIZE_4_5;
8745 parse_func = rakp_parse_hash;
8746 sort_by_digest = sort_by_digest_4_5;
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_NOT_ITERATED;
8749 dgst_pos0 = 3;
8750 dgst_pos1 = 4;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 1;
8753 break;
8754
8755 case 7400: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8759 kern_type = KERN_TYPE_SHA256CRYPT;
8760 dgst_size = DGST_SIZE_4_8;
8761 parse_func = sha256crypt_parse_hash;
8762 sort_by_digest = sort_by_digest_4_8;
8763 opti_type = OPTI_TYPE_ZERO_BYTE;
8764 dgst_pos0 = 0;
8765 dgst_pos1 = 1;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 3;
8768 break;
8769
8770 case 7500: hash_type = HASH_TYPE_KRB5PA;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8774 kern_type = KERN_TYPE_KRB5PA;
8775 dgst_size = DGST_SIZE_4_4;
8776 parse_func = krb5pa_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_NOT_ITERATED;
8780 dgst_pos0 = 3;
8781 dgst_pos1 = 7;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 6;
8784 break;
8785
8786 case 7600: hash_type = HASH_TYPE_SHA1;
8787 salt_type = SALT_TYPE_INTERN;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_BE
8790 | OPTS_TYPE_PT_ADD80
8791 | OPTS_TYPE_PT_ADDBITS15;
8792 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
8793 dgst_size = DGST_SIZE_4_5;
8794 parse_func = redmine_parse_hash;
8795 sort_by_digest = sort_by_digest_4_5;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_EARLY_SKIP
8799 | OPTI_TYPE_NOT_ITERATED
8800 | OPTI_TYPE_PREPENDED_SALT;
8801 dgst_pos0 = 3;
8802 dgst_pos1 = 4;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 1;
8805 break;
8806
8807 case 7700: hash_type = HASH_TYPE_SAPB;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_UPPER
8812 | OPTS_TYPE_ST_UPPER;
8813 kern_type = KERN_TYPE_SAPB;
8814 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8815 parse_func = sapb_parse_hash;
8816 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_NOT_ITERATED;
8820 dgst_pos0 = 0;
8821 dgst_pos1 = 1;
8822 dgst_pos2 = 2;
8823 dgst_pos3 = 3;
8824 break;
8825
8826 case 7800: hash_type = HASH_TYPE_SAPG;
8827 salt_type = SALT_TYPE_EMBEDDED;
8828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8829 opts_type = OPTS_TYPE_PT_GENERATE_BE
8830 | OPTS_TYPE_ST_ADD80
8831 | OPTS_TYPE_ST_UPPER;
8832 kern_type = KERN_TYPE_SAPG;
8833 dgst_size = DGST_SIZE_4_5;
8834 parse_func = sapg_parse_hash;
8835 sort_by_digest = sort_by_digest_4_5;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_PRECOMPUTE_INIT
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 3;
8840 dgst_pos1 = 4;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 1;
8843 break;
8844
8845 case 7900: hash_type = HASH_TYPE_SHA512;
8846 salt_type = SALT_TYPE_EMBEDDED;
8847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8849 kern_type = KERN_TYPE_DRUPAL7;
8850 dgst_size = DGST_SIZE_8_8;
8851 parse_func = drupal7_parse_hash;
8852 sort_by_digest = sort_by_digest_8_8;
8853 opti_type = OPTI_TYPE_ZERO_BYTE;
8854 dgst_pos0 = 0;
8855 dgst_pos1 = 1;
8856 dgst_pos2 = 2;
8857 dgst_pos3 = 3;
8858 break;
8859
8860 case 8000: hash_type = HASH_TYPE_SHA256;
8861 salt_type = SALT_TYPE_EMBEDDED;
8862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8863 opts_type = OPTS_TYPE_PT_GENERATE_BE
8864 | OPTS_TYPE_PT_UNICODE
8865 | OPTS_TYPE_ST_ADD80
8866 | OPTS_TYPE_ST_HEX;
8867 kern_type = KERN_TYPE_SYBASEASE;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = sybasease_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE
8872 | OPTI_TYPE_PRECOMPUTE_INIT
8873 | OPTI_TYPE_EARLY_SKIP
8874 | OPTI_TYPE_NOT_ITERATED
8875 | OPTI_TYPE_RAW_HASH;
8876 dgst_pos0 = 3;
8877 dgst_pos1 = 7;
8878 dgst_pos2 = 2;
8879 dgst_pos3 = 6;
8880 break;
8881
8882 case 8100: hash_type = HASH_TYPE_SHA1;
8883 salt_type = SALT_TYPE_EMBEDDED;
8884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8885 opts_type = OPTS_TYPE_PT_GENERATE_BE;
8886 kern_type = KERN_TYPE_NETSCALER;
8887 dgst_size = DGST_SIZE_4_5;
8888 parse_func = netscaler_parse_hash;
8889 sort_by_digest = sort_by_digest_4_5;
8890 opti_type = OPTI_TYPE_ZERO_BYTE
8891 | OPTI_TYPE_PRECOMPUTE_INIT
8892 | OPTI_TYPE_PRECOMPUTE_MERKLE
8893 | OPTI_TYPE_EARLY_SKIP
8894 | OPTI_TYPE_NOT_ITERATED
8895 | OPTI_TYPE_PREPENDED_SALT
8896 | OPTI_TYPE_RAW_HASH;
8897 dgst_pos0 = 3;
8898 dgst_pos1 = 4;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 1;
8901 break;
8902
8903 case 8200: hash_type = HASH_TYPE_SHA256;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8907 kern_type = KERN_TYPE_CLOUDKEY;
8908 dgst_size = DGST_SIZE_4_8;
8909 parse_func = cloudkey_parse_hash;
8910 sort_by_digest = sort_by_digest_4_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 8300: hash_type = HASH_TYPE_SHA1;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE
8922 | OPTS_TYPE_ST_HEX
8923 | OPTS_TYPE_ST_ADD80;
8924 kern_type = KERN_TYPE_NSEC3;
8925 dgst_size = DGST_SIZE_4_5;
8926 parse_func = nsec3_parse_hash;
8927 sort_by_digest = sort_by_digest_4_5;
8928 opti_type = OPTI_TYPE_ZERO_BYTE;
8929 dgst_pos0 = 3;
8930 dgst_pos1 = 4;
8931 dgst_pos2 = 2;
8932 dgst_pos3 = 1;
8933 break;
8934
8935 case 8400: hash_type = HASH_TYPE_SHA1;
8936 salt_type = SALT_TYPE_INTERN;
8937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8938 opts_type = OPTS_TYPE_PT_GENERATE_BE
8939 | OPTS_TYPE_PT_ADD80
8940 | OPTS_TYPE_PT_ADDBITS15;
8941 kern_type = KERN_TYPE_WBB3;
8942 dgst_size = DGST_SIZE_4_5;
8943 parse_func = wbb3_parse_hash;
8944 sort_by_digest = sort_by_digest_4_5;
8945 opti_type = OPTI_TYPE_ZERO_BYTE
8946 | OPTI_TYPE_PRECOMPUTE_INIT
8947 | OPTI_TYPE_NOT_ITERATED;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 4;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 8500: hash_type = HASH_TYPE_DESRACF;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE
8958 | OPTS_TYPE_ST_UPPER;
8959 kern_type = KERN_TYPE_RACF;
8960 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8961 parse_func = racf_parse_hash;
8962 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8963 opti_type = OPTI_TYPE_ZERO_BYTE
8964 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 8600: hash_type = HASH_TYPE_LOTUS5;
8972 salt_type = SALT_TYPE_NONE;
8973 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_LOTUS5;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = lotus5_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_EARLY_SKIP
8980 | OPTI_TYPE_NOT_ITERATED
8981 | OPTI_TYPE_NOT_SALTED
8982 | OPTI_TYPE_RAW_HASH;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 1;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 3;
8987 break;
8988
8989 case 8700: hash_type = HASH_TYPE_LOTUS6;
8990 salt_type = SALT_TYPE_EMBEDDED;
8991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8993 kern_type = KERN_TYPE_LOTUS6;
8994 dgst_size = DGST_SIZE_4_4;
8995 parse_func = lotus6_parse_hash;
8996 sort_by_digest = sort_by_digest_4_4;
8997 opti_type = OPTI_TYPE_EARLY_SKIP
8998 | OPTI_TYPE_NOT_ITERATED
8999 | OPTI_TYPE_RAW_HASH;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 1;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 3;
9004 break;
9005
9006 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9007 salt_type = SALT_TYPE_EMBEDDED;
9008 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9010 kern_type = KERN_TYPE_ANDROIDFDE;
9011 dgst_size = DGST_SIZE_4_4;
9012 parse_func = androidfde_parse_hash;
9013 sort_by_digest = sort_by_digest_4_4;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 8900: hash_type = HASH_TYPE_SCRYPT;
9022 salt_type = SALT_TYPE_EMBEDDED;
9023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9025 kern_type = KERN_TYPE_SCRYPT;
9026 dgst_size = DGST_SIZE_4_8;
9027 parse_func = scrypt_parse_hash;
9028 sort_by_digest = sort_by_digest_4_8;
9029 opti_type = OPTI_TYPE_ZERO_BYTE;
9030 dgst_pos0 = 0;
9031 dgst_pos1 = 1;
9032 dgst_pos2 = 2;
9033 dgst_pos3 = 3;
9034 break;
9035
9036 case 9000: hash_type = HASH_TYPE_SHA1;
9037 salt_type = SALT_TYPE_EMBEDDED;
9038 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9039 opts_type = OPTS_TYPE_PT_GENERATE_LE
9040 | OPTS_TYPE_ST_GENERATE_LE;
9041 kern_type = KERN_TYPE_PSAFE2;
9042 dgst_size = DGST_SIZE_4_5;
9043 parse_func = psafe2_parse_hash;
9044 sort_by_digest = sort_by_digest_4_5;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 9100: hash_type = HASH_TYPE_LOTUS8;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9056 kern_type = KERN_TYPE_LOTUS8;
9057 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9058 parse_func = lotus8_parse_hash;
9059 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9060 opti_type = OPTI_TYPE_ZERO_BYTE;
9061 dgst_pos0 = 0;
9062 dgst_pos1 = 1;
9063 dgst_pos2 = 2;
9064 dgst_pos3 = 3;
9065 break;
9066
9067 case 9200: hash_type = HASH_TYPE_SHA256;
9068 salt_type = SALT_TYPE_EMBEDDED;
9069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9071 kern_type = KERN_TYPE_PBKDF2_SHA256;
9072 dgst_size = DGST_SIZE_4_32;
9073 parse_func = cisco8_parse_hash;
9074 sort_by_digest = sort_by_digest_4_32;
9075 opti_type = OPTI_TYPE_ZERO_BYTE;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 1;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 3;
9080 break;
9081
9082 case 9300: hash_type = HASH_TYPE_SCRYPT;
9083 salt_type = SALT_TYPE_EMBEDDED;
9084 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9086 kern_type = KERN_TYPE_SCRYPT;
9087 dgst_size = DGST_SIZE_4_8;
9088 parse_func = cisco9_parse_hash;
9089 sort_by_digest = sort_by_digest_4_8;
9090 opti_type = OPTI_TYPE_ZERO_BYTE;
9091 dgst_pos0 = 0;
9092 dgst_pos1 = 1;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 3;
9095 break;
9096
9097 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9101 kern_type = KERN_TYPE_OFFICE2007;
9102 dgst_size = DGST_SIZE_4_4;
9103 parse_func = office2007_parse_hash;
9104 sort_by_digest = sort_by_digest_4_4;
9105 opti_type = OPTI_TYPE_ZERO_BYTE;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_OFFICE2010;
9117 dgst_size = DGST_SIZE_4_4;
9118 parse_func = office2010_parse_hash;
9119 sort_by_digest = sort_by_digest_4_4;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_OFFICE2013;
9132 dgst_size = DGST_SIZE_4_4;
9133 parse_func = office2013_parse_hash;
9134 sort_by_digest = sort_by_digest_4_4;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE
9146 | OPTS_TYPE_PT_ADD80
9147 | OPTS_TYPE_PT_UNICODE;
9148 kern_type = KERN_TYPE_OLDOFFICE01;
9149 dgst_size = DGST_SIZE_4_4;
9150 parse_func = oldoffice01_parse_hash;
9151 sort_by_digest = sort_by_digest_4_4;
9152 opti_type = OPTI_TYPE_ZERO_BYTE
9153 | OPTI_TYPE_PRECOMPUTE_INIT
9154 | OPTI_TYPE_NOT_ITERATED;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE
9165 | OPTS_TYPE_PT_ADD80;
9166 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = oldoffice01cm1_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_PRECOMPUTE_INIT
9172 | OPTI_TYPE_NOT_ITERATED;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE
9183 | OPTS_TYPE_PT_ADD80
9184 | OPTS_TYPE_PT_UNICODE
9185 | OPTS_TYPE_PT_NEVERCRACK;
9186 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = oldoffice01cm2_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE
9191 | OPTI_TYPE_PRECOMPUTE_INIT
9192 | OPTI_TYPE_NOT_ITERATED;
9193 dgst_pos0 = 0;
9194 dgst_pos1 = 1;
9195 dgst_pos2 = 2;
9196 dgst_pos3 = 3;
9197 break;
9198
9199 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9200 salt_type = SALT_TYPE_EMBEDDED;
9201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9202 opts_type = OPTS_TYPE_PT_GENERATE_BE
9203 | OPTS_TYPE_PT_ADD80
9204 | OPTS_TYPE_PT_UNICODE;
9205 kern_type = KERN_TYPE_OLDOFFICE34;
9206 dgst_size = DGST_SIZE_4_4;
9207 parse_func = oldoffice34_parse_hash;
9208 sort_by_digest = sort_by_digest_4_4;
9209 opti_type = OPTI_TYPE_ZERO_BYTE
9210 | OPTI_TYPE_PRECOMPUTE_INIT
9211 | OPTI_TYPE_NOT_ITERATED;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 1;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 3;
9216 break;
9217
9218 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9219 salt_type = SALT_TYPE_EMBEDDED;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9222 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9223 dgst_size = DGST_SIZE_4_4;
9224 parse_func = oldoffice34cm1_parse_hash;
9225 sort_by_digest = sort_by_digest_4_4;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_NOT_ITERATED;
9229 dgst_pos0 = 0;
9230 dgst_pos1 = 1;
9231 dgst_pos2 = 2;
9232 dgst_pos3 = 3;
9233 break;
9234
9235 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9236 salt_type = SALT_TYPE_EMBEDDED;
9237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9238 opts_type = OPTS_TYPE_PT_GENERATE_BE
9239 | OPTS_TYPE_PT_ADD80
9240 | OPTS_TYPE_PT_UNICODE
9241 | OPTS_TYPE_PT_NEVERCRACK;
9242 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9243 dgst_size = DGST_SIZE_4_4;
9244 parse_func = oldoffice34cm2_parse_hash;
9245 sort_by_digest = sort_by_digest_4_4;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_NOT_ITERATED;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 9900: hash_type = HASH_TYPE_MD5;
9256 salt_type = SALT_TYPE_NONE;
9257 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9259 kern_type = KERN_TYPE_RADMIN2;
9260 dgst_size = DGST_SIZE_4_4;
9261 parse_func = radmin2_parse_hash;
9262 sort_by_digest = sort_by_digest_4_4;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_PRECOMPUTE_INIT
9265 | OPTI_TYPE_EARLY_SKIP
9266 | OPTI_TYPE_NOT_ITERATED
9267 | OPTI_TYPE_NOT_SALTED;
9268 dgst_pos0 = 0;
9269 dgst_pos1 = 3;
9270 dgst_pos2 = 2;
9271 dgst_pos3 = 1;
9272 break;
9273
9274 case 10000: hash_type = HASH_TYPE_SHA256;
9275 salt_type = SALT_TYPE_EMBEDDED;
9276 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9278 kern_type = KERN_TYPE_PBKDF2_SHA256;
9279 dgst_size = DGST_SIZE_4_32;
9280 parse_func = djangopbkdf2_parse_hash;
9281 sort_by_digest = sort_by_digest_4_32;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 10100: hash_type = HASH_TYPE_SIPHASH;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_SIPHASH;
9294 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9295 parse_func = siphash_parse_hash;
9296 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED
9299 | OPTI_TYPE_RAW_HASH;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 10200: hash_type = HASH_TYPE_MD5;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_LE
9310 | OPTS_TYPE_ST_ADD80
9311 | OPTS_TYPE_ST_ADDBITS14;
9312 kern_type = KERN_TYPE_HMACMD5_PW;
9313 dgst_size = DGST_SIZE_4_4;
9314 parse_func = crammd5_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_NOT_ITERATED;
9318 dgst_pos0 = 0;
9319 dgst_pos1 = 3;
9320 dgst_pos2 = 2;
9321 dgst_pos3 = 1;
9322 break;
9323
9324 case 10300: hash_type = HASH_TYPE_SHA1;
9325 salt_type = SALT_TYPE_EMBEDDED;
9326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9327 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9328 kern_type = KERN_TYPE_SAPH_SHA1;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = saph_sha1_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 0;
9334 dgst_pos1 = 1;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 3;
9337 break;
9338
9339 case 10400: hash_type = HASH_TYPE_PDFU16;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9343 kern_type = KERN_TYPE_PDF11;
9344 dgst_size = DGST_SIZE_4_4;
9345 parse_func = pdf11_parse_hash;
9346 sort_by_digest = sort_by_digest_4_4;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_NOT_ITERATED;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 10410: hash_type = HASH_TYPE_PDFU16;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_PDF11CM1;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = pdf11cm1_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 10420: hash_type = HASH_TYPE_PDFU16;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9375 kern_type = KERN_TYPE_PDF11CM2;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = pdf11cm2_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_NOT_ITERATED;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 10500: hash_type = HASH_TYPE_PDFU16;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_PDF14;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = pdf14_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_ZERO_BYTE
9396 | OPTI_TYPE_NOT_ITERATED;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 10600: hash_type = HASH_TYPE_SHA256;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_BE
9407 | OPTS_TYPE_ST_ADD80
9408 | OPTS_TYPE_ST_ADDBITS15
9409 | OPTS_TYPE_HASH_COPY;
9410 kern_type = KERN_TYPE_SHA256_PWSLT;
9411 dgst_size = DGST_SIZE_4_8;
9412 parse_func = pdf17l3_parse_hash;
9413 sort_by_digest = sort_by_digest_4_8;
9414 opti_type = OPTI_TYPE_ZERO_BYTE
9415 | OPTI_TYPE_PRECOMPUTE_INIT
9416 | OPTI_TYPE_PRECOMPUTE_MERKLE
9417 | OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_APPENDED_SALT
9420 | OPTI_TYPE_RAW_HASH;
9421 dgst_pos0 = 3;
9422 dgst_pos1 = 7;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 6;
9425 break;
9426
9427 case 10700: hash_type = HASH_TYPE_PDFU32;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_HASH_COPY;
9432 kern_type = KERN_TYPE_PDF17L8;
9433 dgst_size = DGST_SIZE_4_8;
9434 parse_func = pdf17l8_parse_hash;
9435 sort_by_digest = sort_by_digest_4_8;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_NOT_ITERATED;
9438 dgst_pos0 = 0;
9439 dgst_pos1 = 1;
9440 dgst_pos2 = 2;
9441 dgst_pos3 = 3;
9442 break;
9443
9444 case 10800: hash_type = HASH_TYPE_SHA384;
9445 salt_type = SALT_TYPE_NONE;
9446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9447 opts_type = OPTS_TYPE_PT_GENERATE_BE
9448 | OPTS_TYPE_PT_ADD80
9449 | OPTS_TYPE_PT_ADDBITS15;
9450 kern_type = KERN_TYPE_SHA384;
9451 dgst_size = DGST_SIZE_8_8;
9452 parse_func = sha384_parse_hash;
9453 sort_by_digest = sort_by_digest_8_8;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_PRECOMPUTE_MERKLE
9457 | OPTI_TYPE_EARLY_SKIP
9458 | OPTI_TYPE_NOT_ITERATED
9459 | OPTI_TYPE_NOT_SALTED
9460 | OPTI_TYPE_RAW_HASH;
9461 dgst_pos0 = 6;
9462 dgst_pos1 = 7;
9463 dgst_pos2 = 4;
9464 dgst_pos3 = 5;
9465 break;
9466
9467 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_ST_BASE64
9472 | OPTS_TYPE_HASH_COPY;
9473 kern_type = KERN_TYPE_PBKDF2_SHA256;
9474 dgst_size = DGST_SIZE_4_32;
9475 parse_func = pbkdf2_sha256_parse_hash;
9476 sort_by_digest = sort_by_digest_4_32;
9477 opti_type = OPTI_TYPE_ZERO_BYTE;
9478 dgst_pos0 = 0;
9479 dgst_pos1 = 1;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 3;
9482 break;
9483
9484 case 11000: hash_type = HASH_TYPE_MD5;
9485 salt_type = SALT_TYPE_INTERN;
9486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE
9488 | OPTS_TYPE_PT_ADD80;
9489 kern_type = KERN_TYPE_PRESTASHOP;
9490 dgst_size = DGST_SIZE_4_4;
9491 parse_func = prestashop_parse_hash;
9492 sort_by_digest = sort_by_digest_4_4;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_PRECOMPUTE_INIT
9495 | OPTI_TYPE_NOT_ITERATED
9496 | OPTI_TYPE_PREPENDED_SALT;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 3;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 1;
9501 break;
9502
9503 case 11100: hash_type = HASH_TYPE_MD5;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE
9507 | OPTS_TYPE_ST_ADD80;
9508 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9509 dgst_size = DGST_SIZE_4_4;
9510 parse_func = postgresql_auth_parse_hash;
9511 sort_by_digest = sort_by_digest_4_4;
9512 opti_type = OPTI_TYPE_ZERO_BYTE
9513 | OPTI_TYPE_PRECOMPUTE_INIT
9514 | OPTI_TYPE_PRECOMPUTE_MERKLE
9515 | OPTI_TYPE_EARLY_SKIP;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 3;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 1;
9520 break;
9521
9522 case 11200: hash_type = HASH_TYPE_SHA1;
9523 salt_type = SALT_TYPE_EMBEDDED;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_BE
9526 | OPTS_TYPE_PT_ADD80
9527 | OPTS_TYPE_ST_HEX;
9528 kern_type = KERN_TYPE_MYSQL_AUTH;
9529 dgst_size = DGST_SIZE_4_5;
9530 parse_func = mysql_auth_parse_hash;
9531 sort_by_digest = sort_by_digest_4_5;
9532 opti_type = OPTI_TYPE_ZERO_BYTE
9533 | OPTI_TYPE_EARLY_SKIP;
9534 dgst_pos0 = 3;
9535 dgst_pos1 = 4;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 1;
9538 break;
9539
9540 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_HEX
9545 | OPTS_TYPE_ST_ADD80;
9546 kern_type = KERN_TYPE_BITCOIN_WALLET;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = bitcoin_wallet_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_ZERO_BYTE;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 11400: hash_type = HASH_TYPE_MD5;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE
9561 | OPTS_TYPE_PT_ADD80
9562 | OPTS_TYPE_HASH_COPY;
9563 kern_type = KERN_TYPE_SIP_AUTH;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = sip_auth_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 3;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 1;
9572 break;
9573
9574 case 11500: hash_type = HASH_TYPE_CRC32;
9575 salt_type = SALT_TYPE_INTERN;
9576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_ST_GENERATE_LE
9579 | OPTS_TYPE_ST_HEX;
9580 kern_type = KERN_TYPE_CRC32;
9581 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9582 parse_func = crc32_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9584 opti_type = OPTI_TYPE_ZERO_BYTE;
9585 dgst_pos0 = 0;
9586 dgst_pos1 = 1;
9587 dgst_pos2 = 2;
9588 dgst_pos3 = 3;
9589 break;
9590
9591 case 11600: hash_type = HASH_TYPE_AES;
9592 salt_type = SALT_TYPE_EMBEDDED;
9593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9594 opts_type = OPTS_TYPE_PT_GENERATE_LE
9595 | OPTS_TYPE_PT_NEVERCRACK;
9596 kern_type = KERN_TYPE_SEVEN_ZIP;
9597 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9598 parse_func = seven_zip_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9600 opti_type = OPTI_TYPE_ZERO_BYTE;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9608 salt_type = SALT_TYPE_NONE;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE
9611 | OPTS_TYPE_PT_ADD01;
9612 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9613 dgst_size = DGST_SIZE_4_8;
9614 parse_func = gost2012sbog_256_parse_hash;
9615 sort_by_digest = sort_by_digest_4_8;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
9624 salt_type = SALT_TYPE_NONE;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE
9627 | OPTS_TYPE_PT_ADD01;
9628 kern_type = KERN_TYPE_GOST_2012SBOG_512;
9629 dgst_size = DGST_SIZE_4_16;
9630 parse_func = gost2012sbog_512_parse_hash;
9631 sort_by_digest = sort_by_digest_4_16;
9632 opti_type = OPTI_TYPE_ZERO_BYTE;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE
9643 | OPTS_TYPE_ST_BASE64
9644 | OPTS_TYPE_HASH_COPY;
9645 kern_type = KERN_TYPE_PBKDF2_MD5;
9646 dgst_size = DGST_SIZE_4_32;
9647 parse_func = pbkdf2_md5_parse_hash;
9648 sort_by_digest = sort_by_digest_4_32;
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE
9660 | OPTS_TYPE_ST_BASE64
9661 | OPTS_TYPE_HASH_COPY;
9662 kern_type = KERN_TYPE_PBKDF2_SHA1;
9663 dgst_size = DGST_SIZE_4_32;
9664 parse_func = pbkdf2_sha1_parse_hash;
9665 sort_by_digest = sort_by_digest_4_32;
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE
9677 | OPTS_TYPE_ST_BASE64
9678 | OPTS_TYPE_HASH_COPY;
9679 kern_type = KERN_TYPE_PBKDF2_SHA512;
9680 dgst_size = DGST_SIZE_8_16;
9681 parse_func = pbkdf2_sha512_parse_hash;
9682 sort_by_digest = sort_by_digest_8_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 12200: hash_type = HASH_TYPE_ECRYPTFS;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9694 kern_type = KERN_TYPE_ECRYPTFS;
9695 dgst_size = DGST_SIZE_8_8;
9696 parse_func = ecryptfs_parse_hash;
9697 sort_by_digest = sort_by_digest_8_8;
9698 opti_type = OPTI_TYPE_ZERO_BYTE;
9699 dgst_pos0 = 0;
9700 dgst_pos1 = 1;
9701 dgst_pos2 = 2;
9702 dgst_pos3 = 3;
9703 break;
9704
9705 case 12300: hash_type = HASH_TYPE_ORACLET;
9706 salt_type = SALT_TYPE_EMBEDDED;
9707 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9708 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9709 kern_type = KERN_TYPE_ORACLET;
9710 dgst_size = DGST_SIZE_8_16;
9711 parse_func = oraclet_parse_hash;
9712 sort_by_digest = sort_by_digest_8_16;
9713 opti_type = OPTI_TYPE_ZERO_BYTE;
9714 dgst_pos0 = 0;
9715 dgst_pos1 = 1;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 3;
9718 break;
9719
9720 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9724 kern_type = KERN_TYPE_BSDICRYPT;
9725 dgst_size = DGST_SIZE_4_4;
9726 parse_func = bsdicrypt_parse_hash;
9727 sort_by_digest = sort_by_digest_4_4;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 12500: hash_type = HASH_TYPE_RAR3HP;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9740 kern_type = KERN_TYPE_RAR3;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = rar3hp_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 12600: hash_type = HASH_TYPE_SHA256;
9752 salt_type = SALT_TYPE_INTERN;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_PT_ADD80;
9756 kern_type = KERN_TYPE_CF10;
9757 dgst_size = DGST_SIZE_4_8;
9758 parse_func = cf10_parse_hash;
9759 sort_by_digest = sort_by_digest_4_8;
9760 opti_type = OPTI_TYPE_ZERO_BYTE
9761 | OPTI_TYPE_PRECOMPUTE_INIT
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 3;
9765 dgst_pos1 = 7;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 6;
9768 break;
9769
9770 case 12700: hash_type = HASH_TYPE_AES;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE
9774 | OPTS_TYPE_HASH_COPY;
9775 kern_type = KERN_TYPE_MYWALLET;
9776 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9777 parse_func = mywallet_parse_hash;
9778 sort_by_digest = sort_by_digest_4_5;
9779 opti_type = OPTI_TYPE_ZERO_BYTE;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9790 kern_type = KERN_TYPE_MS_DRSR;
9791 dgst_size = DGST_SIZE_4_8;
9792 parse_func = ms_drsr_parse_hash;
9793 sort_by_digest = sort_by_digest_4_8;
9794 opti_type = OPTI_TYPE_ZERO_BYTE;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 default: usage_mini_print (PROGNAME); return (-1);
9802 }
9803
9804 /**
9805 * transpose
9806 */
9807
9808 data.parse_func = parse_func;
9809
9810 /**
9811 * misc stuff
9812 */
9813
9814 if (hex_salt)
9815 {
9816 if (salt_type == SALT_TYPE_INTERN)
9817 {
9818 opts_type |= OPTS_TYPE_ST_HEX;
9819 }
9820 else
9821 {
9822 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
9823
9824 return (-1);
9825 }
9826 }
9827
9828 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
9829 | (salt_type == SALT_TYPE_EXTERN)
9830 | (salt_type == SALT_TYPE_EMBEDDED)
9831 | (salt_type == SALT_TYPE_VIRTUAL));
9832
9833 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
9834
9835 data.hash_type = hash_type;
9836 data.attack_mode = attack_mode;
9837 data.attack_kern = attack_kern;
9838 data.attack_exec = attack_exec;
9839 data.kern_type = kern_type;
9840 data.opts_type = opts_type;
9841 data.dgst_size = dgst_size;
9842 data.salt_type = salt_type;
9843 data.isSalted = isSalted;
9844 data.sort_by_digest = sort_by_digest;
9845 data.dgst_pos0 = dgst_pos0;
9846 data.dgst_pos1 = dgst_pos1;
9847 data.dgst_pos2 = dgst_pos2;
9848 data.dgst_pos3 = dgst_pos3;
9849
9850 esalt_size = 0;
9851
9852 switch (hash_mode)
9853 {
9854 case 2500: esalt_size = sizeof (wpa_t); break;
9855 case 5300: esalt_size = sizeof (ikepsk_t); break;
9856 case 5400: esalt_size = sizeof (ikepsk_t); break;
9857 case 5500: esalt_size = sizeof (netntlm_t); break;
9858 case 5600: esalt_size = sizeof (netntlm_t); break;
9859 case 6211:
9860 case 6212:
9861 case 6213:
9862 case 6221:
9863 case 6222:
9864 case 6223:
9865 case 6231:
9866 case 6232:
9867 case 6233:
9868 case 6241:
9869 case 6242:
9870 case 6243: esalt_size = sizeof (tc_t); break;
9871 case 6600: esalt_size = sizeof (agilekey_t); break;
9872 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9873 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
9874 case 7300: esalt_size = sizeof (rakp_t); break;
9875 case 7500: esalt_size = sizeof (krb5pa_t); break;
9876 case 8200: esalt_size = sizeof (cloudkey_t); break;
9877 case 8800: esalt_size = sizeof (androidfde_t); break;
9878 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
9879 case 9400: esalt_size = sizeof (office2007_t); break;
9880 case 9500: esalt_size = sizeof (office2010_t); break;
9881 case 9600: esalt_size = sizeof (office2013_t); break;
9882 case 9700: esalt_size = sizeof (oldoffice01_t); break;
9883 case 9710: esalt_size = sizeof (oldoffice01_t); break;
9884 case 9720: esalt_size = sizeof (oldoffice01_t); break;
9885 case 9800: esalt_size = sizeof (oldoffice34_t); break;
9886 case 9810: esalt_size = sizeof (oldoffice34_t); break;
9887 case 9820: esalt_size = sizeof (oldoffice34_t); break;
9888 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
9889 case 10200: esalt_size = sizeof (cram_md5_t); break;
9890 case 10400: esalt_size = sizeof (pdf_t); break;
9891 case 10410: esalt_size = sizeof (pdf_t); break;
9892 case 10420: esalt_size = sizeof (pdf_t); break;
9893 case 10500: esalt_size = sizeof (pdf_t); break;
9894 case 10600: esalt_size = sizeof (pdf_t); break;
9895 case 10700: esalt_size = sizeof (pdf_t); break;
9896 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
9897 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
9898 case 11400: esalt_size = sizeof (sip_t); break;
9899 case 11600: esalt_size = sizeof (seven_zip_t); break;
9900 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
9901 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
9902 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
9903 }
9904
9905 data.esalt_size = esalt_size;
9906
9907 /**
9908 * choose dictionary parser
9909 */
9910
9911 if (hash_type == HASH_TYPE_LM)
9912 {
9913 get_next_word_func = get_next_word_lm;
9914 }
9915 else if (opts_type & OPTS_TYPE_PT_UPPER)
9916 {
9917 get_next_word_func = get_next_word_uc;
9918 }
9919 else
9920 {
9921 get_next_word_func = get_next_word_std;
9922 }
9923
9924 /**
9925 * dictstat
9926 */
9927
9928 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
9929
9930 #ifdef _POSIX
9931 size_t dictstat_nmemb = 0;
9932 #endif
9933
9934 #ifdef _WIN
9935 uint dictstat_nmemb = 0;
9936 #endif
9937
9938 char dictstat[256];
9939
9940 FILE *dictstat_fp = NULL;
9941
9942 if (keyspace == 0)
9943 {
9944 memset (dictstat, 0, sizeof (dictstat));
9945
9946 snprintf (dictstat, sizeof (dictstat) - 1, "%s/hashcat.dictstat", profile_dir);
9947
9948 dictstat_fp = fopen (dictstat, "rb");
9949
9950 if (dictstat_fp)
9951 {
9952 #ifdef _POSIX
9953 struct stat tmpstat;
9954
9955 fstat (fileno (dictstat_fp), &tmpstat);
9956 #endif
9957
9958 #ifdef _WIN
9959 struct stat64 tmpstat;
9960
9961 _fstat64 (fileno (dictstat_fp), &tmpstat);
9962 #endif
9963
9964 if (tmpstat.st_mtime < COMPTIME)
9965 {
9966 /* with v0.15 the format changed so we have to ensure user is using a good version
9967 since there is no version-header in the dictstat file */
9968
9969 fclose (dictstat_fp);
9970
9971 unlink (dictstat);
9972 }
9973 else
9974 {
9975 while (!feof (dictstat_fp))
9976 {
9977 dictstat_t d;
9978
9979 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
9980
9981 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
9982
9983 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
9984 {
9985 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
9986
9987 return -1;
9988 }
9989 }
9990
9991 fclose (dictstat_fp);
9992 }
9993 }
9994 }
9995
9996 /**
9997 * potfile
9998 */
9999
10000 char potfile[256];
10001
10002 memset (potfile, 0, sizeof (potfile));
10003
10004 snprintf (potfile, sizeof (potfile) - 1, "%s/%s.pot", session_dir, session);
10005
10006 data.pot_fp = NULL;
10007
10008 FILE *out_fp = NULL;
10009 FILE *pot_fp = NULL;
10010
10011 if (show == 1 || left == 1)
10012 {
10013 pot_fp = fopen (potfile, "rb");
10014
10015 if (pot_fp == NULL)
10016 {
10017 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10018
10019 return (-1);
10020 }
10021
10022 if (outfile != NULL)
10023 {
10024 if ((out_fp = fopen (outfile, "ab")) == NULL)
10025 {
10026 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10027
10028 fclose (pot_fp);
10029
10030 return (-1);
10031 }
10032 }
10033 else
10034 {
10035 out_fp = stdout;
10036 }
10037 }
10038 else
10039 {
10040 if (potfile_disable == 0)
10041 {
10042 pot_fp = fopen (potfile, "ab");
10043
10044 if (pot_fp == NULL)
10045 {
10046 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10047
10048 return (-1);
10049 }
10050
10051 data.pot_fp = pot_fp;
10052 }
10053 }
10054
10055 pot_t *pot = NULL;
10056
10057 uint pot_cnt = 0;
10058 uint pot_avail = 0;
10059
10060 if (show == 1 || left == 1)
10061 {
10062 SUPPRESS_OUTPUT = 1;
10063
10064 pot_avail = count_lines (pot_fp);
10065
10066 rewind (pot_fp);
10067
10068 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10069
10070 uint pot_hashes_avail = 0;
10071
10072 uint line_num = 0;
10073
10074 while (!feof (pot_fp))
10075 {
10076 line_num++;
10077
10078 char line_buf[BUFSIZ];
10079
10080 int line_len = fgetl (pot_fp, line_buf);
10081
10082 if (line_len == 0) continue;
10083
10084 char *plain_buf = line_buf + line_len;
10085
10086 pot_t *pot_ptr = &pot[pot_cnt];
10087
10088 hash_t *hashes_buf = &pot_ptr->hash;
10089
10090 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10091 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10092
10093 if (pot_cnt == pot_hashes_avail)
10094 {
10095 uint pos = 0;
10096
10097 for (pos = 0; pos < INCR_POT; pos++)
10098 {
10099 if ((pot_cnt + pos) >= pot_avail) break;
10100
10101 pot_t *tmp_pot = &pot[pot_cnt + pos];
10102
10103 hash_t *tmp_hash = &tmp_pot->hash;
10104
10105 tmp_hash->digest = mymalloc (dgst_size);
10106
10107 if (isSalted)
10108 {
10109 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10110 }
10111
10112 if (esalt_size)
10113 {
10114 tmp_hash->esalt = mymalloc (esalt_size);
10115 }
10116
10117 pot_hashes_avail++;
10118 }
10119 }
10120
10121 int plain_len = 0;
10122
10123 int parser_status;
10124
10125 int iter = MAX_CUT_TRIES;
10126
10127 do
10128 {
10129 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10130 {
10131 if (line_buf[i] == ':')
10132 {
10133 line_len--;
10134
10135 break;
10136 }
10137 }
10138
10139 if (data.hash_mode != 2500)
10140 {
10141 parser_status = parse_func (line_buf, line_len, hashes_buf);
10142 }
10143 else
10144 {
10145 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10146
10147 if (line_len > max_salt_size)
10148 {
10149 parser_status = PARSER_GLOBAL_LENGTH;
10150 }
10151 else
10152 {
10153 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10154
10155 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10156
10157 hashes_buf->salt->salt_len = line_len;
10158
10159 parser_status = PARSER_OK;
10160 }
10161 }
10162
10163 // if NOT parsed without error, we add the ":" to the plain
10164
10165 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10166 {
10167 plain_len++;
10168 plain_buf--;
10169 }
10170
10171 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10172
10173 if (parser_status < PARSER_GLOBAL_ZERO)
10174 {
10175 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
10176
10177 continue;
10178 }
10179
10180 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
10181
10182 pot_ptr->plain_len = plain_len;
10183
10184 pot_cnt++;
10185 }
10186
10187 fclose (pot_fp);
10188
10189 SUPPRESS_OUTPUT = 0;
10190
10191 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
10192 }
10193
10194 /**
10195 * kernel accel and loops auto adjustment
10196 */
10197
10198 if (kernel_accel_chgd == 0) kernel_accel = set_kernel_accel (hash_mode);
10199 if (kernel_loops_chgd == 0) kernel_loops = set_kernel_loops (hash_mode);
10200
10201 if (workload_profile == 1)
10202 {
10203 kernel_loops /= 8;
10204 kernel_accel /= 4;
10205
10206 if (kernel_loops == 0) kernel_loops = 8;
10207 if (kernel_accel == 0) kernel_accel = 2;
10208 }
10209 else if (workload_profile == 3)
10210 {
10211 kernel_loops *= 8;
10212 kernel_accel *= 4;
10213
10214 if (kernel_loops > 1024) kernel_loops = 1024;
10215 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
10216 }
10217
10218 // those hashes *must* run at a specific kernel_loops count because of some optimization inside the kernel
10219
10220 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
10221 {
10222 kernel_loops = 1024;
10223 }
10224
10225 if (hash_mode == 12500)
10226 {
10227 kernel_loops = ROUNDS_RAR3 / 16;
10228 }
10229
10230 data.kernel_accel = kernel_accel;
10231 data.kernel_loops = kernel_loops;
10232
10233 /**
10234 * word len
10235 */
10236
10237 uint pw_min = PW_MIN;
10238 uint pw_max = PW_MAX;
10239
10240 switch (hash_mode)
10241 {
10242 case 400: if (pw_max > 40) pw_max = 40;
10243 break;
10244 case 500: if (pw_max > 16) pw_max = 16;
10245 break;
10246 case 1500: if (pw_max > 8) pw_max = 8;
10247 break;
10248 case 1600: if (pw_max > 16) pw_max = 16;
10249 break;
10250 case 1800: if (pw_max > 16) pw_max = 16;
10251 break;
10252 case 2100: if (pw_max > 16) pw_max = 16;
10253 break;
10254 case 2500: if (pw_min < 8) pw_min = 8;
10255 break;
10256 case 3000: if (pw_max > 7) pw_max = 7;
10257 break;
10258 case 5200: if (pw_max > 24) pw_max = 24;
10259 break;
10260 case 5800: if (pw_max > 16) pw_max = 16;
10261 break;
10262 case 6300: if (pw_max > 16) pw_max = 16;
10263 break;
10264 case 7400: if (pw_max > 16) pw_max = 16;
10265 break;
10266 case 7900: if (pw_max > 48) pw_max = 48;
10267 break;
10268 case 8500: if (pw_max > 8) pw_max = 8;
10269 break;
10270 case 8600: if (pw_max > 16) pw_max = 16;
10271 break;
10272 case 9710: pw_min = 5;
10273 pw_max = 5;
10274 break;
10275 case 9810: pw_min = 5;
10276 pw_max = 5;
10277 break;
10278 case 10410: pw_min = 5;
10279 pw_max = 5;
10280 break;
10281 case 10300: if (pw_max < 3) pw_min = 3;
10282 if (pw_max > 40) pw_max = 40;
10283 break;
10284 case 10500: if (pw_max < 3) pw_min = 3;
10285 if (pw_max > 40) pw_max = 40;
10286 break;
10287 case 10700: if (pw_max > 16) pw_max = 16;
10288 break;
10289 case 11300: if (pw_max > 40) pw_max = 40;
10290 break;
10291 case 12500: if (pw_max > 20) pw_max = 20;
10292 break;
10293 case 12800: if (pw_max > 24) pw_max = 24;
10294 break;
10295 }
10296
10297 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
10298 {
10299 switch (attack_kern)
10300 {
10301 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10302 break;
10303 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
10304 break;
10305 }
10306 }
10307
10308 /**
10309 * charsets : keep them together for more easy maintainnce
10310 */
10311
10312 cs_t mp_sys[6];
10313 cs_t mp_usr[4];
10314
10315 memset (mp_sys, 0, sizeof (mp_sys));
10316 memset (mp_usr, 0, sizeof (mp_usr));
10317
10318 mp_setup_sys (mp_sys);
10319
10320 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
10321 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
10322 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
10323 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
10324
10325 /**
10326 * load hashes, part I: find input mode, count hashes
10327 */
10328
10329 uint hashlist_mode = 0;
10330 uint hashlist_format = HLFMT_HASHCAT;
10331
10332 uint hashes_avail = 0;
10333
10334 if (benchmark == 0)
10335 {
10336 struct stat f;
10337
10338 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
10339
10340 if ((hash_mode == 2500) ||
10341 (hash_mode == 5200) ||
10342 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
10343 (hash_mode == 9000))
10344 {
10345 hashlist_mode = HL_MODE_ARG;
10346
10347 char *hashfile = myargv[optind];
10348
10349 data.hashfile = hashfile;
10350
10351 logfile_top_var_string ("target", hashfile);
10352 }
10353
10354 if (hashlist_mode == HL_MODE_ARG)
10355 {
10356 if (hash_mode == 2500)
10357 {
10358 struct stat st;
10359
10360 if (stat (data.hashfile, &st) == -1)
10361 {
10362 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
10363
10364 return (-1);
10365 }
10366
10367 hashes_avail = st.st_size / sizeof (hccap_t);
10368 }
10369 else
10370 {
10371 hashes_avail = 1;
10372 }
10373 }
10374 else if (hashlist_mode == HL_MODE_FILE)
10375 {
10376 char *hashfile = myargv[optind];
10377
10378 data.hashfile = hashfile;
10379
10380 logfile_top_var_string ("target", hashfile);
10381
10382 FILE *fp = NULL;
10383
10384 if ((fp = fopen (hashfile, "rb")) == NULL)
10385 {
10386 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10387
10388 return (-1);
10389 }
10390
10391 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
10392
10393 hashes_avail = count_lines (fp);
10394
10395 rewind (fp);
10396
10397 if (hashes_avail == 0)
10398 {
10399 log_error ("ERROR: hashfile is empty or corrupt");
10400
10401 fclose (fp);
10402
10403 return (-1);
10404 }
10405
10406 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
10407
10408 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
10409 {
10410 log_error ("ERROR: remove not supported in native hashfile-format mode");
10411
10412 fclose (fp);
10413
10414 return (-1);
10415 }
10416
10417 fclose (fp);
10418 }
10419 }
10420 else
10421 {
10422 hashlist_mode = HL_MODE_ARG;
10423
10424 hashes_avail = 1;
10425 }
10426
10427 if (hash_mode == 3000) hashes_avail *= 2;
10428
10429 data.hashlist_mode = hashlist_mode;
10430 data.hashlist_format = hashlist_format;
10431
10432 logfile_top_uint (hashlist_mode);
10433 logfile_top_uint (hashlist_format);
10434
10435 /**
10436 * load hashes, part II: allocate required memory, set pointers
10437 */
10438
10439 hash_t *hashes_buf = NULL;
10440 void *digests_buf = NULL;
10441 salt_t *salts_buf = NULL;
10442 void *esalts_buf = NULL;
10443
10444 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
10445
10446 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
10447
10448 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
10449 {
10450 uint32_t hash_pos;
10451
10452 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10453 {
10454 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
10455
10456 hashes_buf[hash_pos].hash_info = hash_info;
10457
10458 if (username && (remove || show || left))
10459 {
10460 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
10461 }
10462
10463 if (benchmark)
10464 {
10465 hash_info->orighash = (char *) mymalloc (256);
10466 }
10467 }
10468 }
10469
10470 if (isSalted)
10471 {
10472 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
10473
10474 if (esalt_size)
10475 {
10476 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
10477 }
10478 }
10479 else
10480 {
10481 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
10482 }
10483
10484 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
10485 {
10486 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
10487
10488 if (isSalted)
10489 {
10490 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
10491
10492 if (esalt_size)
10493 {
10494 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
10495 }
10496 }
10497 else
10498 {
10499 hashes_buf[hash_pos].salt = &salts_buf[0];
10500 }
10501 }
10502
10503 /**
10504 * load hashes, part III: parse hashes or generate them if benchmark
10505 */
10506
10507 uint hashes_cnt = 0;
10508
10509 if (benchmark == 0)
10510 {
10511 if (keyspace == 1)
10512 {
10513 // useless to read hash file for keyspace, cheat a little bit w/ optind
10514 }
10515 else if (hashes_avail == 0)
10516 {
10517 }
10518 else if (hashlist_mode == HL_MODE_ARG)
10519 {
10520 char *input_buf = myargv[optind];
10521
10522 uint input_len = strlen (input_buf);
10523
10524 logfile_top_var_string ("target", input_buf);
10525
10526 char *hash_buf = NULL;
10527 int hash_len = 0;
10528
10529 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
10530
10531 if (hash_len)
10532 {
10533 if (opts_type & OPTS_TYPE_HASH_COPY)
10534 {
10535 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10536
10537 hash_info_tmp->orighash = mystrdup (hash_buf);
10538 }
10539
10540 if (isSalted)
10541 {
10542 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
10543 }
10544
10545 int parser_status = PARSER_OK;
10546
10547 if (hash_mode == 2500)
10548 {
10549 if (hash_len == 0)
10550 {
10551 log_error ("ERROR: hccap file not specified");
10552
10553 return (-1);
10554 }
10555
10556 hashlist_mode = HL_MODE_FILE;
10557
10558 data.hashlist_mode = hashlist_mode;
10559
10560 FILE *fp = fopen (hash_buf, "rb");
10561
10562 if (fp == NULL)
10563 {
10564 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
10565
10566 return (-1);
10567 }
10568
10569 if (hashes_avail < 1)
10570 {
10571 log_error ("ERROR: hccap file is empty or corrupt");
10572
10573 fclose (fp);
10574
10575 return (-1);
10576 }
10577
10578 uint hccap_size = sizeof (hccap_t);
10579
10580 char in[hccap_size];
10581
10582 while (!feof (fp))
10583 {
10584 int n = fread (&in, hccap_size, 1, fp);
10585
10586 if (n != 1)
10587 {
10588 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
10589
10590 break;
10591 }
10592
10593 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
10594
10595 if (parser_status != PARSER_OK)
10596 {
10597 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
10598
10599 continue;
10600 }
10601
10602 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
10603
10604 if ((show == 1) || (left == 1))
10605 {
10606 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
10607
10608 char *salt_ptr = (char *) tmp_salt->salt_buf;
10609
10610 int cur_pos = tmp_salt->salt_len;
10611 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10612
10613 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
10614
10615 unsigned char *pke_ptr = (unsigned char *) wpa->pke;
10616
10617 // do the appending task
10618
10619 snprintf (salt_ptr + cur_pos,
10620 rem_len,
10621 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
10622 pke_ptr[20], pke_ptr[27], pke_ptr[26], pke_ptr[25], pke_ptr[24], pke_ptr[31], // MAC1
10623 pke_ptr[30], pke_ptr[29], pke_ptr[28], pke_ptr[35], pke_ptr[34], pke_ptr[33]); // MAC2
10624
10625
10626 // memset () the remaining part of the salt
10627
10628 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
10629 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
10630
10631 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
10632
10633 tmp_salt->salt_len += 1 + 12 + 1 + 12;
10634 }
10635
10636 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);
10637 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);
10638
10639 hashes_cnt++;
10640 }
10641
10642 fclose (fp);
10643 }
10644 else if (hash_mode == 3000)
10645 {
10646 if (hash_len == 32)
10647 {
10648 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10649
10650 hash_t *lm_hash_left = NULL;
10651
10652 if (parser_status == PARSER_OK)
10653 {
10654 lm_hash_left = &hashes_buf[hashes_cnt];
10655
10656 hashes_cnt++;
10657 }
10658 else
10659 {
10660 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10661 }
10662
10663
10664 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10665
10666 hash_t *lm_hash_right = NULL;
10667
10668 if (parser_status == PARSER_OK)
10669 {
10670 lm_hash_right = &hashes_buf[hashes_cnt];
10671
10672 hashes_cnt++;
10673 }
10674 else
10675 {
10676 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10677 }
10678
10679 // show / left
10680
10681 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
10682 {
10683 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);
10684 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);
10685 }
10686 }
10687 else
10688 {
10689 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10690
10691 if (parser_status == PARSER_OK)
10692 {
10693 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10694 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10695 }
10696
10697 if (parser_status == PARSER_OK)
10698 {
10699 hashes_cnt++;
10700 }
10701 else
10702 {
10703 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10704 }
10705 }
10706 }
10707 else
10708 {
10709 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10710
10711 if (parser_status == PARSER_OK)
10712 {
10713 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10714 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10715 }
10716
10717 if (parser_status == PARSER_OK)
10718 {
10719 hashes_cnt++;
10720 }
10721 else
10722 {
10723 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
10724 }
10725 }
10726 }
10727 }
10728 else if (hashlist_mode == HL_MODE_FILE)
10729 {
10730 char *hashfile = data.hashfile;
10731
10732 FILE *fp;
10733
10734 if ((fp = fopen (hashfile, "rb")) == NULL)
10735 {
10736 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
10737
10738 return (-1);
10739 }
10740
10741 uint line_num = 0;
10742
10743 while (!feof (fp))
10744 {
10745 line_num++;
10746
10747 char line_buf[BUFSIZ];
10748
10749 int line_len = fgetl (fp, line_buf);
10750
10751 if (line_len == 0) continue;
10752
10753 char *hash_buf = NULL;
10754 int hash_len = 0;
10755
10756 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
10757
10758 if (username)
10759 {
10760 char *user_buf = NULL;
10761 int user_len = 0;
10762
10763 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
10764
10765 if (remove || show)
10766 {
10767 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
10768
10769 *user = (user_t *) malloc (sizeof (user_t));
10770
10771 user_t *user_ptr = *user;
10772
10773 if (user_buf != NULL)
10774 {
10775 user_ptr->user_name = mystrdup (user_buf);
10776 }
10777 else
10778 {
10779 user_ptr->user_name = mystrdup ("");
10780 }
10781
10782 user_ptr->user_len = user_len;
10783 }
10784 }
10785
10786 if (opts_type & OPTS_TYPE_HASH_COPY)
10787 {
10788 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
10789
10790 hash_info_tmp->orighash = mystrdup (hash_buf);
10791 }
10792
10793 if (isSalted)
10794 {
10795 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
10796 }
10797
10798 if (hash_mode == 3000)
10799 {
10800 if (hash_len == 32)
10801 {
10802 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
10803
10804 if (parser_status < PARSER_GLOBAL_ZERO)
10805 {
10806 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10807
10808 continue;
10809 }
10810
10811 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
10812
10813 hashes_cnt++;
10814
10815 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
10816
10817 if (parser_status < PARSER_GLOBAL_ZERO)
10818 {
10819 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10820
10821 continue;
10822 }
10823
10824 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
10825
10826 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);
10827
10828 hashes_cnt++;
10829
10830 // show / left
10831
10832 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);
10833 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);
10834 }
10835 else
10836 {
10837 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10838
10839 if (parser_status < PARSER_GLOBAL_ZERO)
10840 {
10841 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10842
10843 continue;
10844 }
10845
10846 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);
10847
10848 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10849 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10850
10851 hashes_cnt++;
10852 }
10853 }
10854 else
10855 {
10856 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
10857
10858 if (parser_status < PARSER_GLOBAL_ZERO)
10859 {
10860 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
10861
10862 continue;
10863 }
10864
10865 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);
10866
10867 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10868 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
10869
10870 hashes_cnt++;
10871 }
10872 }
10873
10874 fclose (fp);
10875
10876 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
10877
10878 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
10879 }
10880 }
10881 else
10882 {
10883 if (isSalted)
10884 {
10885 hashes_buf[0].salt->salt_len = 8;
10886
10887 // special salt handling
10888
10889 switch (hash_mode)
10890 {
10891 case 1500: hashes_buf[0].salt->salt_len = 2;
10892 break;
10893 case 1731: hashes_buf[0].salt->salt_len = 4;
10894 break;
10895 case 2410: hashes_buf[0].salt->salt_len = 4;
10896 break;
10897 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
10898 break;
10899 case 3100: hashes_buf[0].salt->salt_len = 1;
10900 break;
10901 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
10902 break;
10903 case 5800: hashes_buf[0].salt->salt_len = 16;
10904 break;
10905 case 6800: hashes_buf[0].salt->salt_len = 32;
10906 break;
10907 case 8400: hashes_buf[0].salt->salt_len = 40;
10908 break;
10909 case 8800: hashes_buf[0].salt->salt_len = 16;
10910 break;
10911 case 8900: hashes_buf[0].salt->salt_len = 16;
10912 hashes_buf[0].salt->scrypt_N = 1024;
10913 hashes_buf[0].salt->scrypt_r = 1;
10914 hashes_buf[0].salt->scrypt_p = 1;
10915 break;
10916 case 9100: hashes_buf[0].salt->salt_len = 16;
10917 break;
10918 case 9300: hashes_buf[0].salt->salt_len = 14;
10919 hashes_buf[0].salt->scrypt_N = 16384;
10920 hashes_buf[0].salt->scrypt_r = 1;
10921 hashes_buf[0].salt->scrypt_p = 1;
10922 break;
10923 case 9400: hashes_buf[0].salt->salt_len = 16;
10924 break;
10925 case 9500: hashes_buf[0].salt->salt_len = 16;
10926 break;
10927 case 9600: hashes_buf[0].salt->salt_len = 16;
10928 break;
10929 case 9700: hashes_buf[0].salt->salt_len = 16;
10930 break;
10931 case 9710: hashes_buf[0].salt->salt_len = 16;
10932 break;
10933 case 9720: hashes_buf[0].salt->salt_len = 16;
10934 break;
10935 case 9800: hashes_buf[0].salt->salt_len = 16;
10936 break;
10937 case 9810: hashes_buf[0].salt->salt_len = 16;
10938 break;
10939 case 9820: hashes_buf[0].salt->salt_len = 16;
10940 break;
10941 case 10300: hashes_buf[0].salt->salt_len = 12;
10942 break;
10943 case 11500: hashes_buf[0].salt->salt_len = 4;
10944 break;
10945 case 11600: hashes_buf[0].salt->salt_len = 4;
10946 break;
10947 case 12400: hashes_buf[0].salt->salt_len = 4;
10948 break;
10949 case 12500: hashes_buf[0].salt->salt_len = 8;
10950 break;
10951 case 12600: hashes_buf[0].salt->salt_len = 64;
10952 break;
10953 }
10954
10955 // special esalt handling
10956
10957 switch (hash_mode)
10958 {
10959 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
10960 break;
10961 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10962 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10963 break;
10964 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
10965 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
10966 break;
10967 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10968 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10969 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10970 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10971 break;
10972 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
10973 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
10974 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
10975 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
10976 break;
10977 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
10978 break;
10979 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10980 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10981 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10982 break;
10983 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10984 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10985 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10986 break;
10987 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10988 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10989 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10990 break;
10991 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10992 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
10993 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
10994 break;
10995 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
10996 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
10997 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
10998 break;
10999 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11000 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11001 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11002 break;
11003 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11004 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11005 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11006 break;
11007 }
11008 }
11009
11010 // set hashfile
11011
11012 switch (hash_mode)
11013 {
11014 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11015 break;
11016 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11017 break;
11018 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11019 break;
11020 case 6211:
11021 case 6212:
11022 case 6213:
11023 case 6221:
11024 case 6222:
11025 case 6223:
11026 case 6231:
11027 case 6232:
11028 case 6233:
11029 case 6241:
11030 case 6242:
11031 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11032 break;
11033 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11034 break;
11035 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11036 break;
11037 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11038 break;
11039 }
11040
11041 // set default iterations
11042
11043 switch (hash_mode)
11044 {
11045 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11046 break;
11047 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11048 break;
11049 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11050 break;
11051 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11052 break;
11053 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11054 break;
11055 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11056 break;
11057 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11058 break;
11059 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11060 break;
11061 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11062 break;
11063 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11064 break;
11065 case 6211:
11066 case 6212:
11067 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11068 break;
11069 case 6221:
11070 case 6222:
11071 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11072 break;
11073 case 6231:
11074 case 6232:
11075 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11076 break;
11077 case 6241:
11078 case 6242:
11079 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11080 break;
11081 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11082 break;
11083 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11084 break;
11085 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11086 break;
11087 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11088 break;
11089 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11090 break;
11091 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11092 break;
11093 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11094 break;
11095 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11096 break;
11097 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11098 break;
11099 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11100 break;
11101 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11102 break;
11103 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11104 break;
11105 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11106 break;
11107 case 8900: hashes_buf[0].salt->salt_iter = 1;
11108 break;
11109 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11110 break;
11111 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
11112 break;
11113 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
11114 break;
11115 case 9300: hashes_buf[0].salt->salt_iter = 1;
11116 break;
11117 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
11118 break;
11119 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
11120 break;
11121 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
11122 break;
11123 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
11124 break;
11125 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
11126 break;
11127 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
11128 break;
11129 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
11130 break;
11131 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
11132 break;
11133 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
11134 break;
11135 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
11136 break;
11137 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
11138 break;
11139 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
11140 break;
11141 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
11142 break;
11143 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
11144 break;
11145 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
11146 break;
11147 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
11148 break;
11149 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
11150 break;
11151 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
11152 break;
11153 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
11154 break;
11155 }
11156
11157 // set special tuning for benchmark-mode 1
11158
11159 if (benchmark_mode == 1)
11160 {
11161 kernel_loops *= 8;
11162 kernel_accel *= 4;
11163
11164 switch (hash_mode)
11165 {
11166 case 400: kernel_loops = ROUNDS_PHPASS;
11167 kernel_accel = 32;
11168 break;
11169 case 500: kernel_loops = ROUNDS_MD5CRYPT;
11170 kernel_accel = 32;
11171 break;
11172 case 501: kernel_loops = ROUNDS_MD5CRYPT;
11173 kernel_accel = 32;
11174 break;
11175 case 1600: kernel_loops = ROUNDS_MD5CRYPT;
11176 kernel_accel = 32;
11177 break;
11178 case 1800: kernel_loops = ROUNDS_SHA512CRYPT;
11179 kernel_accel = 16;
11180 break;
11181 case 2100: kernel_loops = ROUNDS_DCC2;
11182 kernel_accel = 16;
11183 break;
11184 case 2500: kernel_loops = ROUNDS_WPA2;
11185 kernel_accel = 32;
11186 break;
11187 case 3200: kernel_loops = ROUNDS_BCRYPT;
11188 kernel_accel = 8;
11189 break;
11190 case 5200: kernel_loops = ROUNDS_PSAFE3;
11191 kernel_accel = 16;
11192 break;
11193 case 5800: kernel_loops = ROUNDS_ANDROIDPIN;
11194 kernel_accel = 16;
11195 break;
11196 case 6211: kernel_loops = ROUNDS_TRUECRYPT_2K;
11197 kernel_accel = 64;
11198 break;
11199 case 6212: kernel_loops = ROUNDS_TRUECRYPT_2K;
11200 kernel_accel = 32;
11201 break;
11202 case 6213: kernel_loops = ROUNDS_TRUECRYPT_2K;
11203 kernel_accel = 32;
11204 break;
11205 case 6221: kernel_loops = ROUNDS_TRUECRYPT_1K;
11206 kernel_accel = 8;
11207 break;
11208 case 6222: kernel_loops = ROUNDS_TRUECRYPT_1K;
11209 kernel_accel = 8;
11210 break;
11211 case 6223: kernel_loops = ROUNDS_TRUECRYPT_1K;
11212 kernel_accel = 8;
11213 break;
11214 case 6231: kernel_loops = ROUNDS_TRUECRYPT_1K;
11215 kernel_accel = 8;
11216 break;
11217 case 6232: kernel_loops = ROUNDS_TRUECRYPT_1K;
11218 kernel_accel = 8;
11219 break;
11220 case 6233: kernel_loops = ROUNDS_TRUECRYPT_1K;
11221 kernel_accel = 8;
11222 break;
11223 case 6241: kernel_loops = ROUNDS_TRUECRYPT_1K;
11224 kernel_accel = 128;
11225 break;
11226 case 6242: kernel_loops = ROUNDS_TRUECRYPT_1K;
11227 kernel_accel = 64;
11228 break;
11229 case 6243: kernel_loops = ROUNDS_TRUECRYPT_1K;
11230 kernel_accel = 64;
11231 break;
11232 case 6300: kernel_loops = ROUNDS_MD5CRYPT;
11233 kernel_accel = 32;
11234 break;
11235 case 6700: kernel_loops = ROUNDS_SHA1AIX;
11236 kernel_accel = 128;
11237 break;
11238 case 6400: kernel_loops = ROUNDS_SHA256AIX;
11239 kernel_accel = 128;
11240 break;
11241 case 6500: kernel_loops = ROUNDS_SHA512AIX;
11242 kernel_accel = 32;
11243 break;
11244 case 6600: kernel_loops = ROUNDS_AGILEKEY;
11245 kernel_accel = 64;
11246 break;
11247 case 6800: kernel_loops = ROUNDS_LASTPASS;
11248 kernel_accel = 64;
11249 break;
11250 case 7100: kernel_loops = ROUNDS_SHA512OSX;
11251 kernel_accel = 8;
11252 break;
11253 case 7200: kernel_loops = ROUNDS_GRUB;
11254 kernel_accel = 16;
11255 break;
11256 case 7400: kernel_loops = ROUNDS_SHA256CRYPT;
11257 kernel_accel = 8;
11258 break;
11259 case 7900: kernel_loops = ROUNDS_DRUPAL7;
11260 kernel_accel = 8;
11261 break;
11262 case 8200: kernel_loops = ROUNDS_CLOUDKEY;
11263 kernel_accel = 8;
11264 break;
11265 case 8800: kernel_loops = ROUNDS_ANDROIDFDE;
11266 kernel_accel = 32;
11267 break;
11268 case 8900: kernel_loops = 1;
11269 kernel_accel = 64;
11270 break;
11271 case 9000: kernel_loops = ROUNDS_PSAFE2;
11272 kernel_accel = 16;
11273 break;
11274 case 9100: kernel_loops = ROUNDS_LOTUS8;
11275 kernel_accel = 64;
11276 break;
11277 case 9200: kernel_loops = ROUNDS_CISCO8;
11278 kernel_accel = 8;
11279 break;
11280 case 9300: kernel_loops = 1;
11281 kernel_accel = 4;
11282 break;
11283 case 9400: kernel_loops = ROUNDS_OFFICE2007;
11284 kernel_accel = 32;
11285 break;
11286 case 9500: kernel_loops = ROUNDS_OFFICE2010;
11287 kernel_accel = 32;
11288 break;
11289 case 9600: kernel_loops = ROUNDS_OFFICE2013;
11290 kernel_accel = 8;
11291 break;
11292 case 10000: kernel_loops = ROUNDS_DJANGOPBKDF2;
11293 kernel_accel = 8;
11294 break;
11295 case 10300: kernel_loops = ROUNDS_SAPH_SHA1;
11296 kernel_accel = 16;
11297 break;
11298 case 10500: kernel_loops = ROUNDS_PDF14;
11299 kernel_accel = 256;
11300 break;
11301 case 10700: kernel_loops = ROUNDS_PDF17L8;
11302 kernel_accel = 8;
11303 break;
11304 case 10900: kernel_loops = ROUNDS_PBKDF2_SHA256;
11305 kernel_accel = 8;
11306 break;
11307 case 11300: kernel_loops = ROUNDS_BITCOIN_WALLET;
11308 kernel_accel = 8;
11309 break;
11310 case 11600: kernel_loops = ROUNDS_SEVEN_ZIP;
11311 kernel_accel = 8;
11312 break;
11313 case 11900: kernel_loops = ROUNDS_PBKDF2_MD5;
11314 kernel_accel = 8;
11315 break;
11316 case 12000: kernel_loops = ROUNDS_PBKDF2_SHA1;
11317 kernel_accel = 8;
11318 break;
11319 case 12100: kernel_loops = ROUNDS_PBKDF2_SHA512;
11320 kernel_accel = 8;
11321 break;
11322 case 12200: kernel_loops = ROUNDS_ECRYPTFS;
11323 kernel_accel = 8;
11324 break;
11325 case 12300: kernel_loops = ROUNDS_ORACLET;
11326 kernel_accel = 8;
11327 break;
11328 case 12500: kernel_loops = ROUNDS_RAR3;
11329 kernel_accel = 32;
11330 break;
11331 case 12700: kernel_loops = ROUNDS_MYWALLET;
11332 kernel_accel = 512;
11333 break;
11334 case 12800: kernel_loops = ROUNDS_MS_DRSR;
11335 kernel_accel = 512;
11336 break;
11337 }
11338
11339 // some algorithm collide too fast, make that impossible
11340
11341 switch (hash_mode)
11342 {
11343 case 11500: ((uint *) digests_buf)[1] = 1;
11344 break;
11345 }
11346
11347 if (kernel_loops > 1024) kernel_loops = 1024;
11348 if (kernel_accel > 256) kernel_accel = 256; // causes memory problems otherwise
11349 }
11350
11351 if ((opts_type & OPTS_TYPE_PT_BITSLICE) && (attack_mode == ATTACK_MODE_BF))
11352 {
11353 kernel_loops = 1024;
11354 }
11355
11356 if (hash_mode == 12500)
11357 {
11358 kernel_loops = ROUNDS_RAR3 / 16;
11359 }
11360
11361 data.kernel_accel = kernel_accel;
11362 data.kernel_loops = kernel_loops;
11363
11364 hashes_cnt = 1;
11365 }
11366
11367 if (show == 1 || left == 1)
11368 {
11369 for (uint i = 0; i < pot_cnt; i++)
11370 {
11371 pot_t *pot_ptr = &pot[i];
11372
11373 hash_t *hashes_buf = &pot_ptr->hash;
11374
11375 local_free (hashes_buf->digest);
11376
11377 if (isSalted)
11378 {
11379 local_free (hashes_buf->salt);
11380 }
11381 }
11382
11383 local_free (pot);
11384
11385 if (data.quiet == 0) log_info_nn ("");
11386
11387 return (0);
11388 }
11389
11390 if (keyspace == 0)
11391 {
11392 if (hashes_cnt == 0)
11393 {
11394 log_error ("ERROR: No hashes loaded");
11395
11396 return (-1);
11397 }
11398 }
11399
11400 /**
11401 * Sanity check for hashfile vs outfile (should not point to the same physical file)
11402 */
11403
11404 if (data.outfile != NULL)
11405 {
11406 if (data.hashfile != NULL)
11407 {
11408 #ifdef _POSIX
11409 struct stat tmpstat_outfile;
11410 struct stat tmpstat_hashfile;
11411 #endif
11412
11413 #ifdef _WIN
11414 struct stat64 tmpstat_outfile;
11415 struct stat64 tmpstat_hashfile;
11416 #endif
11417
11418 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
11419
11420 if (tmp_outfile_fp)
11421 {
11422 #ifdef _POSIX
11423 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
11424 #endif
11425
11426 #ifdef _WIN
11427 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
11428 #endif
11429
11430 fclose (tmp_outfile_fp);
11431 }
11432
11433 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
11434
11435 if (tmp_hashfile_fp)
11436 {
11437 #ifdef _POSIX
11438 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11439 #endif
11440
11441 #ifdef _WIN
11442 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
11443 #endif
11444
11445 fclose (tmp_hashfile_fp);
11446 }
11447
11448 if (tmp_outfile_fp && tmp_outfile_fp)
11449 {
11450 tmpstat_outfile.st_mode = 0;
11451 tmpstat_outfile.st_nlink = 0;
11452 tmpstat_outfile.st_uid = 0;
11453 tmpstat_outfile.st_gid = 0;
11454 tmpstat_outfile.st_rdev = 0;
11455 tmpstat_outfile.st_atime = 0;
11456
11457 tmpstat_hashfile.st_mode = 0;
11458 tmpstat_hashfile.st_nlink = 0;
11459 tmpstat_hashfile.st_uid = 0;
11460 tmpstat_hashfile.st_gid = 0;
11461 tmpstat_hashfile.st_rdev = 0;
11462 tmpstat_hashfile.st_atime = 0;
11463
11464 #ifdef _POSIX
11465 tmpstat_outfile.st_blksize = 0;
11466 tmpstat_outfile.st_blocks = 0;
11467
11468 tmpstat_hashfile.st_blksize = 0;
11469 tmpstat_hashfile.st_blocks = 0;
11470 #endif
11471
11472 #ifdef _POSIX
11473 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
11474 {
11475 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11476
11477 return (-1);
11478 }
11479 #endif
11480
11481 #ifdef _WIN
11482 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
11483 {
11484 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
11485
11486 return (-1);
11487 }
11488 #endif
11489 }
11490 }
11491 }
11492
11493 /**
11494 * Remove duplicates
11495 */
11496
11497 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
11498
11499 if (isSalted)
11500 {
11501 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11502 }
11503 else
11504 {
11505 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11506 }
11507
11508 uint hashes_cnt_orig = hashes_cnt;
11509
11510 hashes_cnt = 1;
11511
11512 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
11513 {
11514 if (isSalted)
11515 {
11516 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
11517 {
11518 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11519 }
11520 }
11521 else
11522 {
11523 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
11524 }
11525
11526 if (hashes_pos > hashes_cnt)
11527 {
11528 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
11529 }
11530
11531 hashes_cnt++;
11532 }
11533
11534 /**
11535 * Potfile removes
11536 */
11537
11538 uint potfile_remove_cracks = 0;
11539
11540 if (potfile_disable == 0)
11541 {
11542 hash_t hash_buf;
11543
11544 hash_buf.digest = mymalloc (dgst_size);
11545 hash_buf.salt = NULL;
11546 hash_buf.esalt = NULL;
11547 hash_buf.hash_info = NULL;
11548 hash_buf.cracked = 0;
11549
11550 if (isSalted)
11551 {
11552 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
11553 }
11554
11555 if (esalt_size)
11556 {
11557 hash_buf.esalt = mymalloc (esalt_size);
11558 }
11559
11560 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
11561
11562 // no solution for these special hash types (for instane because they use hashfile in output etc)
11563 if ((hash_mode != 5200) &&
11564 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
11565 (hash_mode != 9000))
11566 {
11567 FILE *fp = fopen (potfile, "rb");
11568
11569 if (fp != NULL)
11570 {
11571 while (!feof (fp))
11572 {
11573 char line_buf[BUFSIZ];
11574
11575 memset (line_buf, 0, BUFSIZ);
11576
11577 char *ptr = fgets (line_buf, BUFSIZ - 1, fp);
11578
11579 if (ptr == NULL) break;
11580
11581 int line_len = strlen (line_buf);
11582
11583 if (line_len == 0) continue;
11584
11585 int iter = MAX_CUT_TRIES;
11586
11587 for (int i = line_len - 1; i && iter; i--, line_len--)
11588 {
11589 if (line_buf[i] != ':') continue;
11590
11591 if (isSalted)
11592 {
11593 memset (hash_buf.salt, 0, sizeof (salt_t));
11594 }
11595
11596 hash_t *found = NULL;
11597
11598 if (hash_mode == 6800)
11599 {
11600 if (i < 48) // 48 = 12 * uint in salt_buf[]
11601 {
11602 // manipulate salt_buf
11603 memcpy (hash_buf.salt->salt_buf, line_buf, i);
11604
11605 hash_buf.salt->salt_len = i;
11606
11607 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
11608 }
11609 }
11610 else if (hash_mode == 2500)
11611 {
11612 if (i < 48) // 48 = 12 * uint in salt_buf[]
11613 {
11614 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
11615 // manipulate salt_buf
11616
11617 // to be safe work with a copy (because of line_len loop, i etc)
11618
11619 char line_buf_cpy[BUFSIZ];
11620 memset (line_buf_cpy, 0, BUFSIZ);
11621
11622 memset (line_buf_cpy, 0, sizeof (line_buf_cpy));
11623
11624 memcpy (line_buf_cpy, line_buf, i);
11625
11626 char *mac2_pos = strrchr (line_buf_cpy, ':');
11627
11628 if (mac2_pos == NULL) continue;
11629
11630 mac2_pos[0] = 0;
11631 mac2_pos++;
11632
11633 if (strlen (mac2_pos) != 12) continue;
11634
11635 char *mac1_pos = strrchr (line_buf_cpy, ':');
11636
11637 if (mac1_pos == NULL) continue;
11638
11639 mac1_pos[0] = 0;
11640 mac1_pos++;
11641
11642 if (strlen (mac1_pos) != 12) continue;
11643
11644 uint essid_length = mac1_pos - line_buf_cpy - 1;
11645
11646 // here we need the ESSID
11647 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
11648
11649 hash_buf.salt->salt_len = essid_length;
11650
11651 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
11652
11653 if (found)
11654 {
11655 wpa_t *wpa = (wpa_t *) found->esalt;
11656
11657 uint pke[25];
11658
11659 char *pke_ptr = (char *) pke;
11660
11661 for (uint i = 0; i < 25; i++)
11662 {
11663 pke[i] = byte_swap_32 (wpa->pke[i]);
11664 }
11665
11666 unsigned char mac1[6];
11667 unsigned char mac2[6];
11668
11669 memcpy (mac1, pke_ptr + 23, 6);
11670 memcpy (mac2, pke_ptr + 29, 6);
11671
11672 // compare hex string(s) vs binary MAC address(es)
11673
11674 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11675 {
11676 if (mac1[i] != (unsigned char) hex_to_char (&mac1_pos[j]))
11677 {
11678 found = NULL;
11679 break;
11680 }
11681 }
11682
11683 // early skip ;)
11684 if (!found) continue;
11685
11686 for (uint i = 0, j = 0; i < 6; i++, j += 2)
11687 {
11688 if (mac2[i] != (unsigned char) hex_to_char (&mac2_pos[j]))
11689 {
11690 found = NULL;
11691 break;
11692 }
11693 }
11694 }
11695 }
11696 }
11697 else
11698 {
11699 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
11700
11701 if (parser_status == PARSER_OK)
11702 {
11703 if (isSalted)
11704 {
11705 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
11706 }
11707 else
11708 {
11709 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
11710 }
11711 }
11712 }
11713
11714 if (found == NULL) continue;
11715
11716 if (!found->cracked) potfile_remove_cracks++;
11717
11718 found->cracked = 1;
11719
11720 if (found) break;
11721
11722 iter--;
11723 }
11724 }
11725
11726 fclose (fp);
11727 }
11728 }
11729
11730 if (esalt_size)
11731 {
11732 local_free (hash_buf.esalt);
11733 }
11734
11735 if (isSalted)
11736 {
11737 local_free (hash_buf.salt);
11738 }
11739
11740 local_free (hash_buf.digest);
11741 }
11742
11743 /**
11744 * Now generate all the buffers required for later
11745 */
11746
11747 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
11748
11749 salt_t *salts_buf_new = NULL;
11750 void *esalts_buf_new = NULL;
11751
11752 if (isSalted)
11753 {
11754 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11755
11756 if (esalt_size)
11757 {
11758 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
11759 }
11760 }
11761 else
11762 {
11763 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
11764 }
11765
11766 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
11767
11768 uint digests_cnt = hashes_cnt;
11769 uint digests_done = 0;
11770
11771 uint size_digests = digests_cnt * dgst_size;
11772 uint size_shown = digests_cnt * sizeof (uint);
11773
11774 uint *digests_shown = (uint *) mymalloc (size_shown);
11775 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
11776
11777 uint salts_cnt = 0;
11778 uint salts_done = 0;
11779
11780 hashinfo_t **hash_info = NULL;
11781
11782 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11783 {
11784 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
11785
11786 if (username && (remove || show))
11787 {
11788 uint user_pos;
11789
11790 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
11791 {
11792 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
11793
11794 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
11795 }
11796 }
11797 }
11798
11799 uint *salts_shown = (uint *) mymalloc (size_shown);
11800
11801 salt_t *salt_buf;
11802
11803 {
11804 // copied from inner loop
11805
11806 salt_buf = &salts_buf_new[salts_cnt];
11807
11808 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
11809
11810 if (esalt_size)
11811 {
11812 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
11813 }
11814
11815 salt_buf->digests_cnt = 0;
11816 salt_buf->digests_done = 0;
11817 salt_buf->digests_offset = 0;
11818
11819 salts_cnt++;
11820 }
11821
11822 if (hashes_buf[0].cracked == 1)
11823 {
11824 digests_shown[0] = 1;
11825
11826 digests_done++;
11827
11828 salt_buf->digests_done++;
11829 }
11830
11831 salt_buf->digests_cnt++;
11832
11833 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
11834
11835 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11836 {
11837 hash_info[0] = hashes_buf[0].hash_info;
11838 }
11839
11840 // copy from inner loop
11841
11842 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
11843 {
11844 if (isSalted)
11845 {
11846 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
11847 {
11848 salt_buf = &salts_buf_new[salts_cnt];
11849
11850 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
11851
11852 if (esalt_size)
11853 {
11854 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
11855 }
11856
11857 salt_buf->digests_cnt = 0;
11858 salt_buf->digests_done = 0;
11859 salt_buf->digests_offset = hashes_pos;
11860
11861 salts_cnt++;
11862 }
11863 }
11864
11865 if (hashes_buf[hashes_pos].cracked == 1)
11866 {
11867 digests_shown[hashes_pos] = 1;
11868
11869 digests_done++;
11870
11871 salt_buf->digests_done++;
11872 }
11873
11874 salt_buf->digests_cnt++;
11875
11876 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
11877
11878 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11879 {
11880 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
11881 }
11882 }
11883
11884 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
11885 {
11886 salt_t *salt_buf = &salts_buf_new[salt_pos];
11887
11888 if (salt_buf->digests_done == salt_buf->digests_cnt)
11889 {
11890 salts_shown[salt_pos] = 1;
11891
11892 salts_done++;
11893 }
11894
11895 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
11896 }
11897
11898 local_free (digests_buf);
11899 local_free (salts_buf);
11900 local_free (esalts_buf);
11901
11902 digests_buf = digests_buf_new;
11903 salts_buf = salts_buf_new;
11904 esalts_buf = esalts_buf_new;
11905
11906 local_free (hashes_buf);
11907
11908 /**
11909 * special modification not set from parser
11910 */
11911
11912 switch (hash_mode)
11913 {
11914 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
11915 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
11916 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
11917 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
11918 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
11919 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
11920 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
11921 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
11922 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
11923 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
11924 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
11925 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
11926 }
11927
11928 if (truecrypt_keyfiles)
11929 {
11930 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
11931
11932 char *keyfiles = strdup (truecrypt_keyfiles);
11933
11934 char *keyfile = strtok (keyfiles, ",");
11935
11936 do
11937 {
11938 truecrypt_crc32 (keyfile, (unsigned char *) keyfile_buf);
11939
11940 } while ((keyfile = strtok (NULL, ",")) != NULL);
11941
11942 free (keyfiles);
11943 }
11944
11945 data.digests_cnt = digests_cnt;
11946 data.digests_done = digests_done;
11947 data.digests_buf = digests_buf;
11948 data.digests_shown = digests_shown;
11949 data.digests_shown_tmp = digests_shown_tmp;
11950
11951 data.salts_cnt = salts_cnt;
11952 data.salts_done = salts_done;
11953 data.salts_buf = salts_buf;
11954 data.salts_shown = salts_shown;
11955
11956 data.esalts_buf = esalts_buf;
11957 data.hash_info = hash_info;
11958
11959 /**
11960 * Automatic Optimizers
11961 */
11962
11963 if (salts_cnt == 1)
11964 opti_type |= OPTI_TYPE_SINGLE_SALT;
11965
11966 if (digests_cnt == 1)
11967 opti_type |= OPTI_TYPE_SINGLE_HASH;
11968
11969 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11970 opti_type |= OPTI_TYPE_NOT_ITERATED;
11971
11972 if (attack_mode == ATTACK_MODE_BF)
11973 opti_type |= OPTI_TYPE_BRUTE_FORCE;
11974
11975 data.opti_type = opti_type;
11976
11977 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
11978 {
11979 if (opti_type & OPTI_TYPE_SINGLE_HASH)
11980 {
11981 if (opti_type & OPTI_TYPE_APPENDED_SALT)
11982 {
11983 if (opts_type & OPTS_TYPE_ST_ADD80)
11984 {
11985 opts_type &= ~OPTS_TYPE_ST_ADD80;
11986 opts_type |= OPTS_TYPE_PT_ADD80;
11987 }
11988
11989 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
11990 {
11991 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
11992 opts_type |= OPTS_TYPE_PT_ADDBITS14;
11993 }
11994
11995 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
11996 {
11997 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
11998 opts_type |= OPTS_TYPE_PT_ADDBITS15;
11999 }
12000 }
12001 }
12002 }
12003
12004 /**
12005 * Some algorithm, like descrypt, can benefit from JIT compilation
12006 */
12007
12008 uint force_jit_compilation = 0;
12009
12010 if (hash_mode == 8900)
12011 {
12012 force_jit_compilation = 8900;
12013 }
12014 else if (hash_mode == 9300)
12015 {
12016 force_jit_compilation = 8900;
12017 }
12018 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12019 {
12020 force_jit_compilation = 1500;
12021 }
12022
12023 /**
12024 * generate bitmap tables
12025 */
12026
12027 const uint bitmap_shift1 = 5;
12028 const uint bitmap_shift2 = 13;
12029
12030 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12031
12032 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12033 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12034 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12035 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12036 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12037 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12038 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12039 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12040
12041 uint bitmap_bits;
12042 uint bitmap_nums;
12043 uint bitmap_mask;
12044 uint bitmap_size;
12045
12046 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12047 {
12048 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12049
12050 bitmap_nums = 1 << bitmap_bits;
12051
12052 bitmap_mask = bitmap_nums - 1;
12053
12054 bitmap_size = bitmap_nums * sizeof (uint);
12055
12056 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12057
12058 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;
12059 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;
12060
12061 break;
12062 }
12063
12064 bitmap_nums = 1 << bitmap_bits;
12065
12066 bitmap_mask = bitmap_nums - 1;
12067
12068 bitmap_size = bitmap_nums * sizeof (uint);
12069
12070 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);
12071 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);
12072
12073 /**
12074 * prepare quick rule
12075 */
12076
12077 data.rule_buf_l = rule_buf_l;
12078 data.rule_buf_r = rule_buf_r;
12079
12080 int rule_len_l = (int) strlen (rule_buf_l);
12081 int rule_len_r = (int) strlen (rule_buf_r);
12082
12083 data.rule_len_l = rule_len_l;
12084 data.rule_len_r = rule_len_r;
12085
12086 /**
12087 * load rules
12088 */
12089
12090 uint *all_kernel_rules_cnt = NULL;
12091
12092 kernel_rule_t **all_kernel_rules_buf = NULL;
12093
12094 if (rp_files_cnt)
12095 {
12096 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12097
12098 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12099 }
12100
12101 char rule_buf[BUFSIZ];
12102
12103 int rule_len = 0;
12104
12105 for (uint i = 0; i < rp_files_cnt; i++)
12106 {
12107 uint kernel_rules_avail = 0;
12108
12109 uint kernel_rules_cnt = 0;
12110
12111 kernel_rule_t *kernel_rules_buf = NULL;
12112
12113 char *rp_file = rp_files[i];
12114
12115 char in[BLOCK_SIZE];
12116 char out[BLOCK_SIZE];
12117
12118 FILE *fp = NULL;
12119
12120 uint rule_line = 0;
12121
12122 if ((fp = fopen (rp_file, "rb")) == NULL)
12123 {
12124 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12125
12126 return (-1);
12127 }
12128
12129 while (!feof (fp))
12130 {
12131 memset (rule_buf, 0, BUFSIZ);
12132
12133 rule_len = fgetl (fp, rule_buf);
12134
12135 rule_line++;
12136
12137 if (rule_len == 0) continue;
12138
12139 if (rule_buf[0] == '#') continue;
12140
12141 if (kernel_rules_avail == kernel_rules_cnt)
12142 {
12143 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12144
12145 kernel_rules_avail += INCR_RULES;
12146 }
12147
12148 memset (in, 0, BLOCK_SIZE);
12149 memset (out, 0, BLOCK_SIZE);
12150
12151 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12152
12153 if (result == -1)
12154 {
12155 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12156
12157 continue;
12158 }
12159
12160 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12161 {
12162 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12163
12164 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12165
12166 continue;
12167 }
12168
12169 /* its so slow
12170 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12171 {
12172 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12173
12174 continue;
12175 }
12176 */
12177
12178 kernel_rules_cnt++;
12179 }
12180
12181 fclose (fp);
12182
12183 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12184
12185 all_kernel_rules_buf[i] = kernel_rules_buf;
12186 }
12187
12188 /**
12189 * merge rules or automatic rule generator
12190 */
12191
12192 uint kernel_rules_cnt = 0;
12193
12194 kernel_rule_t *kernel_rules_buf = NULL;
12195
12196 if (attack_mode == ATTACK_MODE_STRAIGHT)
12197 {
12198 if (rp_files_cnt)
12199 {
12200 kernel_rules_cnt = 1;
12201
12202 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12203
12204 repeats[0] = kernel_rules_cnt;
12205
12206 for (uint i = 0; i < rp_files_cnt; i++)
12207 {
12208 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12209
12210 repeats[i + 1] = kernel_rules_cnt;
12211 }
12212
12213 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12214
12215 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12216
12217 for (uint i = 0; i < kernel_rules_cnt; i++)
12218 {
12219 uint out_pos = 0;
12220
12221 kernel_rule_t *out = &kernel_rules_buf[i];
12222
12223 for (uint j = 0; j < rp_files_cnt; j++)
12224 {
12225 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12226 uint in_pos;
12227
12228 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12229
12230 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12231 {
12232 if (out_pos == RULES_MAX - 1)
12233 {
12234 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12235
12236 break;
12237 }
12238
12239 out->cmds[out_pos] = in->cmds[in_pos];
12240 }
12241 }
12242 }
12243
12244 local_free (repeats);
12245 }
12246 else if (rp_gen)
12247 {
12248 uint kernel_rules_avail = 0;
12249
12250 while (kernel_rules_cnt < rp_gen)
12251 {
12252 if (kernel_rules_avail == kernel_rules_cnt)
12253 {
12254 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12255
12256 kernel_rules_avail += INCR_RULES;
12257 }
12258
12259 memset (rule_buf, 0, BLOCK_SIZE);
12260
12261 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
12262
12263 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
12264
12265 kernel_rules_cnt++;
12266 }
12267 }
12268 }
12269
12270 /**
12271 * generate NOP rules
12272 */
12273
12274 if (kernel_rules_cnt == 0)
12275 {
12276 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
12277
12278 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
12279
12280 kernel_rules_cnt++;
12281 }
12282
12283 data.kernel_rules_cnt = kernel_rules_cnt;
12284 data.kernel_rules_buf = kernel_rules_buf;
12285
12286 /**
12287 * platform
12288 */
12289
12290 cl_platform_id CL_platforms[CL_PLATFORMS_MAX];
12291
12292 uint CL_platforms_cnt = 0;
12293
12294 hc_clGetPlatformIDs (CL_PLATFORMS_MAX, CL_platforms, &CL_platforms_cnt);
12295
12296 if (CL_platforms_cnt == 0)
12297 {
12298 log_error ("ERROR: No OpenCL compatible platform found");
12299
12300 return (-1);
12301 }
12302
12303 uint CL_platform_sel = 0;
12304
12305 if (CL_platforms_cnt > 1)
12306 {
12307 if (opencl_platform == NULL)
12308 {
12309 log_error ("ERROR: Too many OpenCL compatible platforms found");
12310
12311 log_info ("Please select a single platform using the --opencl-platform option");
12312 log_info ("");
12313 log_info ("Available OpenCL platforms:");
12314 log_info ("");
12315
12316 for (uint i = 0; i < CL_platforms_cnt; i++)
12317 {
12318 char CL_platform_vendor[INFOSZ];
12319
12320 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12321
12322 hc_clGetPlatformInfo (CL_platforms[i], CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12323
12324 log_info ("* %d = %s", i + 1, CL_platform_vendor);
12325 }
12326
12327 log_info ("");
12328
12329 return (-1);
12330 }
12331 else
12332 {
12333 CL_platform_sel = atoi (opencl_platform);
12334
12335 if (CL_platform_sel > CL_platforms_cnt)
12336 {
12337 log_error ("ERROR: invalid OpenCL platforms selected");
12338
12339 return (-1);
12340 }
12341
12342 // user does not count with zero
12343
12344 CL_platform_sel -= 1;
12345 }
12346 }
12347
12348 cl_platform_id CL_platform = CL_platforms[CL_platform_sel];
12349
12350 char CL_platform_vendor[INFOSZ];
12351
12352 memset (CL_platform_vendor, 0, sizeof (CL_platform_vendor));
12353
12354 hc_clGetPlatformInfo (CL_platform, CL_PLATFORM_VENDOR, sizeof (CL_platform_vendor), CL_platform_vendor, NULL);
12355
12356 cl_device_type device_type;
12357
12358 uint vendor_id;
12359
12360 if (strcmp (CL_platform_vendor, CL_VENDOR_AMD) == 0)
12361 {
12362 vendor_id = VENDOR_ID_AMD;
12363
12364 device_type = CL_DEVICE_TYPE_GPU;
12365 }
12366 else if (strcmp (CL_platform_vendor, CL_VENDOR_NV) == 0)
12367 {
12368 vendor_id = VENDOR_ID_NV;
12369
12370 device_type = CL_DEVICE_TYPE_GPU;
12371
12372 // make sure that we do not directly control the fan for NVidia
12373
12374 gpu_temp_retain = 0;
12375
12376 data.gpu_temp_retain = gpu_temp_retain;
12377 }
12378 else if (strcmp (CL_platform_vendor, CL_VENDOR_POCL) == 0)
12379 {
12380 vendor_id = VENDOR_ID_POCL;
12381
12382 device_type = CL_DEVICE_TYPE_CPU;
12383
12384 gpu_temp_disable = 1;
12385 }
12386 else
12387 {
12388 vendor_id = VENDOR_ID_UNKNOWN;
12389
12390 device_type = CL_DEVICE_TYPE_DEFAULT;
12391 }
12392
12393 if (vendor_id == VENDOR_ID_UNKNOWN)
12394 {
12395 log_error ("Warning: unknown OpenCL vendor '%s' detected", CL_platform_vendor);
12396
12397 gpu_temp_disable = 1;
12398 }
12399
12400 data.vendor_id = vendor_id;
12401
12402 /**
12403 * cached kernel path depends on vendor_id which we don't know, so create it here
12404 */
12405
12406 int vendor_id_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 10 + 1;
12407
12408 char *vendor_id_folder = (char *) mymalloc (vendor_id_folder_size);
12409
12410 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels", profile_dir);
12411
12412 mkdir (vendor_id_folder, 0700);
12413
12414 snprintf (vendor_id_folder, vendor_id_folder_size - 1, "%s/kernels/%d", profile_dir, vendor_id);
12415
12416 mkdir (vendor_id_folder, 0700);
12417
12418 myfree (vendor_id_folder);
12419
12420 /**
12421 * devices
12422 */
12423
12424 cl_device_id devices_all[DEVICES_MAX];
12425 cl_device_id devices[DEVICES_MAX];
12426
12427 uint devices_all_cnt = 0;
12428
12429 hc_clGetDeviceIDs (CL_platform, device_type, DEVICES_MAX, devices_all, (uint *) &devices_all_cnt);
12430
12431 int hm_adapters_all = devices_all_cnt;
12432
12433 hm_attrs_t hm_adapter_all[DEVICES_MAX];
12434
12435 memset (hm_adapter_all, 0, sizeof (hm_adapter_all));
12436
12437 if (gpu_temp_disable == 0)
12438 {
12439 if (vendor_id == VENDOR_ID_NV)
12440 {
12441 #ifdef LINUX
12442 HM_LIB hm_dll = hm_init ();
12443
12444 data.hm_dll = hm_dll;
12445
12446 if (hc_NVML_nvmlInit (hm_dll) == NVML_SUCCESS)
12447 {
12448 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12449
12450 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12451
12452 int tmp_out = 0;
12453
12454 for (int i = 0; i < tmp_in; i++)
12455 {
12456 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12457 }
12458
12459 hm_adapters_all = tmp_out;
12460
12461 for (int i = 0; i < tmp_out; i++)
12462 {
12463 unsigned int speed;
12464
12465 if (hc_NVML_nvmlDeviceGetFanSpeed (hm_dll, 1, hm_adapter_all[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12466 }
12467 }
12468 #endif
12469
12470 #ifdef WIN
12471 if (NvAPI_Initialize () == NVAPI_OK)
12472 {
12473 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX];
12474
12475 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
12476
12477 int tmp_out = 0;
12478
12479 for (int i = 0; i < tmp_in; i++)
12480 {
12481 hm_adapter_all[tmp_out++].adapter_index.nv = nvGPUHandle[i];
12482 }
12483
12484 hm_adapters_all = tmp_out;
12485
12486 for (int i = 0; i < tmp_out; i++)
12487 {
12488 NvU32 speed;
12489
12490 if (NvAPI_GPU_GetTachReading (hm_adapter_all[i].adapter_index.nv, &speed) != NVAPI_NOT_SUPPORTED) hm_adapter_all[i].fan_supported = 1;
12491 }
12492 }
12493 #endif
12494 }
12495
12496 if (vendor_id == VENDOR_ID_AMD)
12497 {
12498 HM_LIB hm_dll = hm_init ();
12499
12500 data.hm_dll = hm_dll;
12501
12502 if (hc_ADL_Main_Control_Create (hm_dll, ADL_Main_Memory_Alloc, 0) == ADL_OK)
12503 {
12504 // total number of adapters
12505
12506 int hm_adapters_num;
12507
12508 if (get_adapters_num_amd (hm_dll, &hm_adapters_num) != 0) return (-1);
12509
12510 // adapter info
12511
12512 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (hm_dll, hm_adapters_num);
12513
12514 if (lpAdapterInfo == NULL) return (-1);
12515
12516 // get a list (of ids of) valid/usable adapters
12517
12518 int num_adl_adapters = 0;
12519
12520 uint32_t *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
12521
12522 if (num_adl_adapters > 0)
12523 {
12524 hc_thread_mutex_lock (mux_adl);
12525
12526 // hm_get_opencl_busid_devid (hm_adapter_all, devices_all_cnt, devices_all);
12527
12528 hm_get_adapter_index_amd (hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12529
12530 hm_get_overdrive_version (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12531 hm_check_fanspeed_control (hm_dll, hm_adapter_all, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
12532
12533 hc_thread_mutex_unlock (mux_adl);
12534 }
12535
12536 hm_adapters_all = num_adl_adapters;
12537
12538 myfree (valid_adl_device_list);
12539 myfree (lpAdapterInfo);
12540 }
12541 }
12542 }
12543
12544 if (hm_adapters_all == 0)
12545 {
12546 gpu_temp_disable = 1;
12547 }
12548
12549 if (gpu_temp_disable == 1)
12550 {
12551 gpu_temp_abort = 0;
12552 gpu_temp_retain = 0;
12553 }
12554
12555 /**
12556 * enable custom signal handler(s)
12557 */
12558
12559 if (benchmark == 0)
12560 {
12561 hc_signal (sigHandler_default);
12562 }
12563 else
12564 {
12565 hc_signal (sigHandler_benchmark);
12566 }
12567
12568 /**
12569 * devices mask and properties
12570 */
12571
12572 uint devices_cnt = 0;
12573
12574 for (uint device_all_id = 0; device_all_id < devices_all_cnt; device_all_id++)
12575 {
12576 if (opencl_devicemask)
12577 {
12578 uint device_all_id_mask = 1 << device_all_id;
12579
12580 if ((device_all_id_mask & opencl_devicemask) != device_all_id_mask)
12581 {
12582 if (quiet == 0 && algorithm_pos == 0) log_info ("Device #%d: skipped by user", device_all_id_mask + 1);
12583
12584 continue;
12585 }
12586 }
12587
12588 const uint device_id = devices_cnt;
12589
12590 devices[device_id] = devices_all[device_all_id];
12591
12592 memcpy (&data.hm_device[device_id], &hm_adapter_all[device_all_id], sizeof (hm_attrs_t));
12593
12594 char device_name[INFOSZ];
12595
12596 memset (device_name, 0, sizeof (device_name));
12597
12598 cl_ulong global_mem_size;
12599 cl_ulong max_mem_alloc_size;
12600 cl_uint max_clock_frequency;
12601 cl_uint max_compute_units;
12602
12603 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_NAME, sizeof (device_name), &device_name, NULL);
12604 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (global_mem_size), &global_mem_size, NULL);
12605 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12606 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (max_clock_frequency), &max_clock_frequency, NULL);
12607 hc_clGetDeviceInfo (devices[device_id], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12608
12609 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12610 {
12611 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
12612 device_all_id + 1,
12613 device_name,
12614 (unsigned int) (max_mem_alloc_size / 1024 / 1024),
12615 (unsigned int) (global_mem_size / 1024 / 1024),
12616 (unsigned int) (max_clock_frequency),
12617 (unsigned int) max_compute_units);
12618 }
12619
12620 devices_cnt++;
12621 }
12622
12623 if (devices_cnt == 0)
12624 {
12625 log_error ("ERROR: No devices left that matches your specification.");
12626
12627 return (-1);
12628 }
12629
12630 data.devices_cnt = devices_cnt;
12631
12632 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
12633 {
12634 log_info ("");
12635 }
12636
12637 /**
12638 * inform the user
12639 */
12640
12641 // gpu temp sanity check
12642
12643 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
12644 {
12645 if (gpu_temp_abort < gpu_temp_retain)
12646 {
12647 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
12648
12649 return (-1);
12650 }
12651 }
12652
12653 data.gpu_temp_disable = gpu_temp_disable;
12654 data.gpu_temp_abort = gpu_temp_abort;
12655 data.gpu_temp_retain = gpu_temp_retain;
12656
12657 if (data.quiet == 0)
12658 {
12659 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
12660
12661 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);
12662
12663 if (attack_mode == ATTACK_MODE_STRAIGHT)
12664 {
12665 log_info ("Rules: %u", kernel_rules_cnt);
12666 }
12667
12668 if (opti_type)
12669 {
12670 log_info ("Applicable Optimizers:");
12671
12672 for (uint i = 0; i < 32; i++)
12673 {
12674 const uint opti_bit = 1 << i;
12675
12676 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
12677 }
12678 }
12679
12680 /**
12681 * Watchdog and Temperature balance
12682 */
12683
12684 if (gpu_temp_abort == 0)
12685 {
12686 log_info ("Watchdog: Temperature abort trigger disabled");
12687 }
12688 else
12689 {
12690 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
12691 }
12692
12693 if (gpu_temp_retain == 0)
12694 {
12695 log_info ("Watchdog: Temperature retain trigger disabled");
12696 }
12697 else
12698 {
12699 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
12700 }
12701 }
12702
12703 /**
12704 * devices init
12705 */
12706
12707 int *temp_retain_fanspeed_value = (int *) mycalloc (devices_cnt, sizeof (int));
12708
12709 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (devices_cnt, sizeof (ADLOD6MemClockState));
12710
12711 int *od_power_control_status = (int *) mycalloc (devices_cnt, sizeof (int));
12712
12713 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (devices_cnt, sizeof (hc_device_param_t));
12714
12715 data.devices_param = devices_param;
12716
12717 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12718 {
12719 hc_device_param_t *device_param = &data.devices_param[device_id];
12720
12721 cl_device_id device = devices[device_id];
12722
12723 device_param->device = device;
12724
12725 cl_device_type device_type = 0;
12726
12727 hc_clGetDeviceInfo (device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
12728
12729 device_param->device_type = device_type;
12730
12731 cl_uint max_compute_units = 0;
12732
12733 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (max_compute_units), &max_compute_units, NULL);
12734
12735 device_param->device_processors = max_compute_units;
12736
12737 cl_ulong max_mem_alloc_size = 0;
12738
12739 hc_clGetDeviceInfo (device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (max_mem_alloc_size), &max_mem_alloc_size, NULL);
12740
12741 device_param->device_maxmem_alloc = max_mem_alloc_size;
12742
12743 char tmp[INFOSZ], t1[64];
12744
12745 memset (tmp, 0, sizeof (tmp));
12746
12747 hc_clGetDeviceInfo (device, CL_DEVICE_NAME, sizeof (tmp), &tmp, NULL);
12748
12749 device_param->device_name = mystrdup (tmp);
12750
12751 memset (tmp, 0, sizeof (tmp));
12752
12753 hc_clGetDeviceInfo (device, CL_DEVICE_VERSION, sizeof (tmp), &tmp, NULL);
12754
12755 memset (t1, 0, sizeof (t1));
12756
12757 sscanf (tmp, "%*16s %*16s %*16s (%[^)]16s)", t1);
12758
12759 device_param->device_version = mystrdup (t1);
12760
12761 memset (tmp, 0, sizeof (tmp));
12762
12763 hc_clGetDeviceInfo (device, CL_DRIVER_VERSION, sizeof (tmp), &tmp, NULL);
12764
12765 device_param->driver_version = mystrdup (tmp);
12766
12767 // create some filename that is easier to read on cached folder
12768
12769 snprintf (tmp, sizeof (tmp) - 1, "%s-%s-%s-%d", device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
12770
12771 uint device_name_digest[4];
12772
12773 device_name_digest[0] = 0;
12774 device_name_digest[1] = 0;
12775 device_name_digest[2] = 0;
12776 device_name_digest[3] = 0;
12777
12778 md5_64 ((uint *) tmp, device_name_digest);
12779
12780 sprintf (tmp, "%08x", device_name_digest[0]);
12781
12782 device_param->device_name_chksum = mystrdup (tmp);
12783
12784 if (device_type == CL_DEVICE_TYPE_CPU)
12785 {
12786 cl_uint device_processor_cores = 1;
12787
12788 device_param->device_processor_cores = device_processor_cores;
12789 }
12790
12791 if (device_type == CL_DEVICE_TYPE_GPU)
12792 {
12793 if (vendor_id == VENDOR_ID_AMD)
12794 {
12795 cl_uint device_processor_cores = 0;
12796
12797 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
12798
12799 hc_clGetDeviceInfo (device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
12800
12801 device_param->device_processor_cores = device_processor_cores;
12802 }
12803
12804 if (vendor_id == VENDOR_ID_NV)
12805 {
12806 cl_uint kernel_exec_timeout = 0;
12807
12808 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
12809
12810 hc_clGetDeviceInfo (device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
12811
12812 device_param->kernel_exec_timeout = kernel_exec_timeout;
12813
12814 cl_uint device_processor_cores = 0;
12815
12816 #define CL_DEVICE_WARP_SIZE_NV 0x4003
12817
12818 hc_clGetDeviceInfo (device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
12819
12820 device_param->device_processor_cores = device_processor_cores;
12821
12822 cl_uint sm_minor = 0;
12823 cl_uint sm_major = 0;
12824
12825 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
12826 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
12827
12828 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
12829 hc_clGetDeviceInfo (device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
12830
12831 device_param->sm_minor = sm_minor;
12832 device_param->sm_major = sm_major;
12833 }
12834 }
12835
12836 /**
12837 * common driver check
12838 */
12839
12840 if (device_type == CL_DEVICE_TYPE_GPU)
12841 {
12842 if (vendor_id == VENDOR_ID_NV)
12843 {
12844 if (device_param->kernel_exec_timeout != 0)
12845 {
12846 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);
12847 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
12848 }
12849 }
12850
12851 if (vendor_id == VENDOR_ID_AMD)
12852 {
12853 int catalyst_check = (force == 1) ? 0 : 1;
12854
12855 int catalyst_warn = 0;
12856
12857 int catalyst_broken = 0;
12858
12859 if (catalyst_check == 1)
12860 {
12861 catalyst_warn = 1;
12862
12863 // v14.9 and higher
12864 if ((atoi (device_param->device_version) >= 1573)
12865 && (atoi (device_param->driver_version) >= 1573))
12866 {
12867 catalyst_warn = 0;
12868 }
12869
12870 catalyst_check = 0;
12871 }
12872
12873 if (catalyst_broken == 1)
12874 {
12875 log_error ("");
12876 log_error ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
12877 log_error ("It will pass over cracked hashes and does not report them as cracked");
12878 log_error ("You are STRONGLY encouraged not to use it");
12879 log_error ("You can use --force to override this but do not post error reports if you do so");
12880
12881 return (-1);
12882 }
12883
12884 if (catalyst_warn == 1)
12885 {
12886 log_error ("");
12887 log_error ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
12888 log_error ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
12889 log_error ("See oclHashcat's homepage for official supported catalyst drivers");
12890 #ifdef _WIN
12891 log_error ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
12892 #endif
12893 log_error ("You can use --force to override this but do not post error reports if you do so");
12894
12895 return (-1);
12896 }
12897 }
12898 }
12899 }
12900
12901 /*
12902 * Temporary fix:
12903 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
12904 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
12905 * were not working @ full speed (setting hc_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
12906 * Driver / ADL bug?
12907 */
12908
12909 if (vendor_id == VENDOR_ID_AMD)
12910 {
12911 if (powertune_enable == 1)
12912 {
12913 hc_thread_mutex_lock (mux_adl);
12914
12915 for (uint i = 0; i < devices_cnt; i++)
12916 {
12917 if (data.hm_device[i].od_version == 6)
12918 {
12919 // set powertune value only
12920
12921 int powertune_supported = 0;
12922
12923 int ADL_rc = 0;
12924
12925 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
12926 {
12927 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
12928
12929 return (-1);
12930 }
12931
12932 if (powertune_supported != 0)
12933 {
12934 // powertune set
12935 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
12936
12937 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune)) != ADL_OK)
12938 {
12939 log_error ("ERROR: Failed to get current ADL PowerControl settings");
12940
12941 return (-1);
12942 }
12943
12944 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
12945 {
12946 log_error ("ERROR: Failed to set new ADL PowerControl values");
12947
12948 return (-1);
12949 }
12950 }
12951 }
12952 }
12953
12954 hc_thread_mutex_unlock (mux_adl);
12955 }
12956 }
12957
12958 uint kernel_blocks_all = 0;
12959
12960 for (uint device_id = 0; device_id < devices_cnt; device_id++)
12961 {
12962 /**
12963 * host buffer
12964 */
12965
12966 hc_device_param_t *device_param = &data.devices_param[device_id];
12967
12968 /**
12969 * device properties
12970 */
12971
12972 char *device_name_chksum = device_param->device_name_chksum;
12973
12974 uint device_processors = device_param->device_processors;
12975
12976 uint device_processor_cores = device_param->device_processor_cores;
12977
12978 /**
12979 * create context for each device
12980 */
12981
12982 device_param->context = hc_clCreateContext (NULL, 1, &device_param->device, NULL, NULL);
12983
12984 /**
12985 * create command-queue
12986 */
12987
12988 // not support with NV
12989 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
12990
12991 device_param->command_queue = hc_clCreateCommandQueue (device_param->context, device_param->device, 0);
12992
12993 /**
12994 * create input buffers on device
12995 */
12996
12997 uint kernel_threads = KERNEL_THREADS;
12998
12999 // bcrypt
13000 if (hash_mode == 3200) kernel_threads = 8;
13001 if (hash_mode == 9000) kernel_threads = 8;
13002
13003 if (device_type == CL_DEVICE_TYPE_CPU)
13004 {
13005 // CPU still need lots of workitems, don't know why...
13006
13007 kernel_accel = (kernel_accel >= 8) ? kernel_accel / 8 : 1;
13008 }
13009
13010 uint kernel_power = device_processors * kernel_threads * kernel_accel;
13011 uint kernel_blocks = kernel_power;
13012
13013 device_param->kernel_threads = kernel_threads;
13014 device_param->kernel_power_user = kernel_power;
13015 device_param->kernel_blocks_user = kernel_blocks;
13016
13017 kernel_blocks_all += kernel_blocks;
13018
13019 uint size_pws = kernel_power * sizeof (pw_t);
13020
13021 uint size_tmps = 4;
13022
13023 switch (hash_mode)
13024 {
13025 case 400: size_tmps = kernel_blocks * sizeof (phpass_tmp_t); break;
13026 case 500: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13027 case 501: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13028 case 1600: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13029 case 1800: size_tmps = kernel_blocks * sizeof (sha512crypt_tmp_t); break;
13030 case 2100: size_tmps = kernel_blocks * sizeof (dcc2_tmp_t); break;
13031 case 2500: size_tmps = kernel_blocks * sizeof (wpa_tmp_t); break;
13032 case 3200: size_tmps = kernel_blocks * sizeof (bcrypt_tmp_t); break;
13033 case 5200: size_tmps = kernel_blocks * sizeof (pwsafe3_tmp_t); break;
13034 case 5800: size_tmps = kernel_blocks * sizeof (androidpin_tmp_t); break;
13035 case 6211:
13036 case 6212:
13037 case 6213: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13038 case 6221:
13039 case 6222:
13040 case 6223: size_tmps = kernel_blocks * sizeof (tc64_tmp_t); break;
13041 case 6231:
13042 case 6232:
13043 case 6233: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13044 case 6241:
13045 case 6242:
13046 case 6243: size_tmps = kernel_blocks * sizeof (tc_tmp_t); break;
13047 case 6300: size_tmps = kernel_blocks * sizeof (md5crypt_tmp_t); break;
13048 case 6400: size_tmps = kernel_blocks * sizeof (sha256aix_tmp_t); break;
13049 case 6500: size_tmps = kernel_blocks * sizeof (sha512aix_tmp_t); break;
13050 case 6600: size_tmps = kernel_blocks * sizeof (agilekey_tmp_t); break;
13051 case 6700: size_tmps = kernel_blocks * sizeof (sha1aix_tmp_t); break;
13052 case 6800: size_tmps = kernel_blocks * sizeof (lastpass_tmp_t); break;
13053 case 7100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13054 case 7200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13055 case 7400: size_tmps = kernel_blocks * sizeof (sha256crypt_tmp_t); break;
13056 case 7900: size_tmps = kernel_blocks * sizeof (drupal7_tmp_t); break;
13057 case 8200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13058 case 8800: size_tmps = kernel_blocks * sizeof (androidfde_tmp_t); break;
13059 case 8900: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13060 case 9000: size_tmps = kernel_blocks * sizeof (pwsafe2_tmp_t); break;
13061 case 9100: size_tmps = kernel_blocks * sizeof (lotus8_tmp_t); break;
13062 case 9200: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13063 case 9300: size_tmps = kernel_blocks * sizeof (scrypt_tmp_t); break;
13064 case 9400: size_tmps = kernel_blocks * sizeof (office2007_tmp_t); break;
13065 case 9500: size_tmps = kernel_blocks * sizeof (office2010_tmp_t); break;
13066 case 9600: size_tmps = kernel_blocks * sizeof (office2013_tmp_t); break;
13067 case 10000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13068 case 10200: size_tmps = kernel_blocks * sizeof (cram_md5_t); break;
13069 case 10300: size_tmps = kernel_blocks * sizeof (saph_sha1_tmp_t); break;
13070 case 10500: size_tmps = kernel_blocks * sizeof (pdf14_tmp_t); break;
13071 case 10700: size_tmps = kernel_blocks * sizeof (pdf17l8_tmp_t); break;
13072 case 10900: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13073 case 11300: size_tmps = kernel_blocks * sizeof (bitcoin_wallet_tmp_t); break;
13074 case 11600: size_tmps = kernel_blocks * sizeof (seven_zip_tmp_t); break;
13075 case 11900: size_tmps = kernel_blocks * sizeof (pbkdf2_md5_tmp_t); break;
13076 case 12000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha1_tmp_t); break;
13077 case 12100: size_tmps = kernel_blocks * sizeof (pbkdf2_sha512_tmp_t); break;
13078 case 12200: size_tmps = kernel_blocks * sizeof (ecryptfs_tmp_t); break;
13079 case 12300: size_tmps = kernel_blocks * sizeof (oraclet_tmp_t); break;
13080 case 12400: size_tmps = kernel_blocks * sizeof (bsdicrypt_tmp_t); break;
13081 case 12500: size_tmps = kernel_blocks * sizeof (rar3_tmp_t); break;
13082 case 12700: size_tmps = kernel_blocks * sizeof (mywallet_tmp_t); break;
13083 case 12800: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
13084 };
13085
13086 uint size_hooks = 4;
13087
13088 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
13089 {
13090 // insert correct hook size
13091 }
13092
13093 // we can optimize some stuff here...
13094
13095 device_param->size_pws = size_pws;
13096 device_param->size_tmps = size_tmps;
13097 device_param->size_hooks = size_hooks;
13098
13099 uint size_root_css = SP_PW_MAX * sizeof (cs_t);
13100 uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
13101
13102 device_param->size_root_css = size_root_css;
13103 device_param->size_markov_css = size_markov_css;
13104
13105 uint size_results = KERNEL_THREADS * sizeof (uint);
13106
13107 device_param->size_results = size_results;
13108
13109 uint size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
13110 uint size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
13111
13112 uint size_plains = digests_cnt * sizeof (plain_t);
13113 uint size_salts = salts_cnt * sizeof (salt_t);
13114 uint size_esalts = salts_cnt * esalt_size;
13115
13116 device_param->size_plains = size_plains;
13117 device_param->size_digests = size_digests;
13118 device_param->size_shown = size_shown;
13119 device_param->size_salts = size_salts;
13120
13121 uint size_combs = KERNEL_COMBS * sizeof (comb_t);
13122 uint size_bfs = KERNEL_BFS * sizeof (bf_t);
13123 uint size_tm = 32 * sizeof (bs_word_t);
13124
13125 uint64_t size_scryptV = 1;
13126
13127 if ((hash_mode == 8900) || (hash_mode == 9300))
13128 {
13129 uint tmto_start = 0;
13130 uint tmto_stop = 10;
13131
13132 if (scrypt_tmto)
13133 {
13134 tmto_start = scrypt_tmto;
13135 }
13136 else
13137 {
13138 // in case the user did not specify the tmto manually
13139 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
13140 // but set the lower end only in case the user has a device with too less memory
13141
13142 if (hash_mode == 8900)
13143 {
13144 if (vendor_id == VENDOR_ID_AMD)
13145 {
13146 tmto_start = 1;
13147 }
13148 else if (vendor_id == VENDOR_ID_NV)
13149 {
13150 tmto_start = 3;
13151 }
13152 }
13153 else if (hash_mode == 9300)
13154 {
13155 if (vendor_id == VENDOR_ID_AMD)
13156 {
13157 tmto_start = 3;
13158 }
13159 else if (vendor_id == VENDOR_ID_NV)
13160 {
13161 tmto_start = 5;
13162 }
13163 }
13164 }
13165
13166 if (quiet == 0) log_info ("");
13167
13168 uint shader_per_mp = 1;
13169
13170 if (vendor_id == VENDOR_ID_AMD)
13171 {
13172 shader_per_mp = 8;
13173 }
13174
13175 if (vendor_id == VENDOR_ID_NV)
13176 {
13177 shader_per_mp = 32;
13178 }
13179
13180 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
13181 {
13182 // TODO: in theory the following calculation needs to be done per salt, not global
13183 // we assume all hashes have the same scrypt settings
13184
13185 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
13186
13187 size_scryptV /= 1 << tmto;
13188
13189 size_scryptV *= device_processors * device_processor_cores * shader_per_mp;
13190
13191 if (size_scryptV > device_param->device_maxmem_alloc)
13192 {
13193 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
13194
13195 continue;
13196 }
13197
13198 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
13199 {
13200 data.salts_buf[salts_pos].scrypt_tmto = tmto;
13201 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores * shader_per_mp;
13202 }
13203
13204 break;
13205 }
13206
13207 if (data.salts_buf[0].scrypt_phy == 0)
13208 {
13209 log_error ("ERROR: can't allocate enough device memory");
13210
13211 return -1;
13212 }
13213
13214 if (quiet == 0) log_info ("");
13215 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
13216 }
13217
13218 /**
13219 * default building options
13220 */
13221
13222 char build_opts[1024];
13223
13224 // we don't have sm_* on AMD but it doesn't matter
13225
13226 sprintf (build_opts, "-I%s/ -DVENDOR_ID=%d -DCUDA_ARCH=%d", shared_dir, vendor_id, (device_param->sm_major * 100) + device_param->sm_minor);
13227
13228 /**
13229 * main kernel
13230 */
13231
13232 {
13233 /**
13234 * kernel source filename
13235 */
13236
13237 char source_file[256];
13238
13239 memset (source_file, 0, sizeof (source_file));
13240
13241 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
13242
13243 struct stat sst;
13244
13245 if (stat (source_file, &sst) == -1)
13246 {
13247 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13248
13249 return -1;
13250 }
13251
13252 /**
13253 * kernel cached filename
13254 */
13255
13256 char cached_file[256];
13257
13258 memset (cached_file, 0, sizeof (cached_file));
13259
13260 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13261
13262 int cached = 1;
13263
13264 struct stat cst;
13265
13266 if (stat (cached_file, &cst) == -1)
13267 {
13268 cached = 0;
13269 }
13270
13271 /**
13272 * kernel compile or load
13273 */
13274
13275 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13276
13277 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13278
13279 if (force_jit_compilation == 0)
13280 {
13281 if (cached == 0)
13282 {
13283 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13284
13285 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13286
13287 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13288
13289 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13290
13291 size_t binary_size;
13292
13293 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13294
13295 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13296
13297 clGetProgramInfo (device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13298
13299 writeProgramBin (cached_file, binary, binary_size);
13300
13301 local_free (binary);
13302 }
13303 else
13304 {
13305 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13306
13307 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13308
13309 device_param->program = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13310
13311 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13312 }
13313 }
13314 else
13315 {
13316 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
13317
13318 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13319
13320 device_param->program = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13321
13322 if (force_jit_compilation == 1500)
13323 {
13324 sprintf (build_opts, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
13325 }
13326 else if (force_jit_compilation == 8900)
13327 {
13328 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);
13329 }
13330
13331 hc_clBuildProgram (device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
13332 }
13333
13334 local_free (kernel_lengths);
13335 local_free (kernel_sources[0]);
13336 local_free (kernel_sources);
13337
13338 // this is mostly for debug
13339
13340 size_t ret_val_size = 0;
13341
13342 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13343
13344 if (ret_val_size > 2)
13345 {
13346 char *build_log = (char *) mymalloc (ret_val_size + 1);
13347
13348 memset (build_log, 0, ret_val_size + 1);
13349
13350 clGetProgramBuildInfo (device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13351
13352 puts (build_log);
13353
13354 myfree (build_log);
13355 }
13356 }
13357
13358 /**
13359 * word generator kernel
13360 */
13361
13362 if (attack_mode != ATTACK_MODE_STRAIGHT)
13363 {
13364 /**
13365 * kernel mp source filename
13366 */
13367
13368 char source_file[256];
13369
13370 memset (source_file, 0, sizeof (source_file));
13371
13372 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
13373
13374 struct stat sst;
13375
13376 if (stat (source_file, &sst) == -1)
13377 {
13378 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13379
13380 return -1;
13381 }
13382
13383 /**
13384 * kernel mp cached filename
13385 */
13386
13387 char cached_file[256];
13388
13389 memset (cached_file, 0, sizeof (cached_file));
13390
13391 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, vendor_id, cached_file);
13392
13393 int cached = 1;
13394
13395 struct stat cst;
13396
13397 if (stat (cached_file, &cst) == -1)
13398 {
13399 cached = 0;
13400 }
13401
13402 /**
13403 * kernel compile or load
13404 */
13405
13406 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13407
13408 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13409
13410 if (cached == 0)
13411 {
13412 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13413
13414 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13415
13416 device_param->program_mp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13417
13418 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13419
13420 size_t binary_size;
13421
13422 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13423
13424 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13425
13426 clGetProgramInfo (device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13427
13428 writeProgramBin (cached_file, binary, binary_size);
13429
13430 local_free (binary);
13431 }
13432 else
13433 {
13434 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13435
13436 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13437
13438 device_param->program_mp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13439
13440 hc_clBuildProgram (device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
13441 }
13442
13443 local_free (kernel_lengths);
13444 local_free (kernel_sources[0]);
13445 local_free (kernel_sources);
13446
13447 // this is mostly for debug
13448
13449 size_t ret_val_size = 0;
13450
13451 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13452
13453 if (ret_val_size > 2)
13454 {
13455 char *build_log = (char *) mymalloc (ret_val_size + 1);
13456
13457 memset (build_log, 0, ret_val_size + 1);
13458
13459 clGetProgramBuildInfo (device_param->program_mp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13460
13461 puts (build_log);
13462
13463 myfree (build_log);
13464 }
13465 }
13466
13467 /**
13468 * amplifier kernel
13469 */
13470
13471 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13472 {
13473
13474 }
13475 else
13476 {
13477 /**
13478 * kernel amp source filename
13479 */
13480
13481 char source_file[256];
13482
13483 memset (source_file, 0, sizeof (source_file));
13484
13485 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
13486
13487 struct stat sst;
13488
13489 if (stat (source_file, &sst) == -1)
13490 {
13491 log_error ("ERROR: %s: %s", source_file, strerror (errno));
13492
13493 return -1;
13494 }
13495
13496 /**
13497 * kernel amp cached filename
13498 */
13499
13500 char cached_file[256];
13501
13502 memset (cached_file, 0, sizeof (cached_file));
13503
13504 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, vendor_id, cached_file);
13505
13506 int cached = 1;
13507
13508 struct stat cst;
13509
13510 if (stat (cached_file, &cst) == -1)
13511 {
13512 cached = 0;
13513 }
13514
13515 /**
13516 * kernel compile or load
13517 */
13518
13519 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
13520
13521 const unsigned char **kernel_sources = (const unsigned char **) mymalloc (sizeof (unsigned char *));
13522
13523 if (cached == 0)
13524 {
13525 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
13526
13527 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
13528
13529 device_param->program_amp = hc_clCreateProgramWithSource (device_param->context, 1, (const char **) kernel_sources, NULL);
13530
13531 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13532
13533 size_t binary_size;
13534
13535 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
13536
13537 unsigned char *binary = (unsigned char *) mymalloc (binary_size);
13538
13539 clGetProgramInfo (device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
13540
13541 writeProgramBin (cached_file, binary, binary_size);
13542
13543 local_free (binary);
13544 }
13545 else
13546 {
13547 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
13548
13549 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
13550
13551 device_param->program_amp = hc_clCreateProgramWithBinary (device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL);
13552
13553 hc_clBuildProgram (device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
13554 }
13555
13556 local_free (kernel_lengths);
13557 local_free (kernel_sources[0]);
13558 local_free (kernel_sources);
13559
13560 // this is mostly for debug
13561
13562 size_t ret_val_size = 0;
13563
13564 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &ret_val_size);
13565
13566 if (ret_val_size > 2)
13567 {
13568 char *build_log = (char *) mymalloc (ret_val_size + 1);
13569
13570 memset (build_log, 0, ret_val_size + 1);
13571
13572 clGetProgramBuildInfo (device_param->program_amp, device_param->device, CL_PROGRAM_BUILD_LOG, ret_val_size, build_log, NULL);
13573
13574 puts (build_log);
13575
13576 myfree (build_log);
13577 }
13578 }
13579
13580 /**
13581 * global buffers
13582 */
13583
13584 device_param->d_pws_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13585 device_param->d_pws_amp_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
13586 device_param->d_tmps = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
13587 device_param->d_hooks = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
13588 device_param->d_bitmap_s1_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13589 device_param->d_bitmap_s1_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13590 device_param->d_bitmap_s1_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13591 device_param->d_bitmap_s1_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13592 device_param->d_bitmap_s2_a = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13593 device_param->d_bitmap_s2_b = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13594 device_param->d_bitmap_s2_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13595 device_param->d_bitmap_s2_d = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
13596 device_param->d_plain_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
13597 device_param->d_digests_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
13598 device_param->d_digests_shown = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
13599 device_param->d_salt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
13600 device_param->d_result = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
13601 device_param->d_scryptV_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
13602
13603 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
13604 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
13605 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
13606 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
13607 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
13608 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
13609 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
13610 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
13611 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
13612 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
13613 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
13614
13615 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
13616 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
13617 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
13618 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
13619 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
13620 run_kernel_bzero (device_param, device_param->d_result, size_results);
13621
13622 /**
13623 * special buffers
13624 */
13625
13626 if (attack_kern == ATTACK_KERN_STRAIGHT)
13627 {
13628 device_param->d_rules = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
13629 device_param->d_rules_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
13630
13631 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
13632
13633 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
13634 }
13635 else if (attack_kern == ATTACK_KERN_COMBI)
13636 {
13637 device_param->d_combs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13638 device_param->d_combs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
13639 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13640 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13641
13642 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
13643 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
13644 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13645 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13646 }
13647 else if (attack_kern == ATTACK_KERN_BF)
13648 {
13649 device_param->d_bfs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13650 device_param->d_bfs_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
13651 device_param->d_tm_c = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
13652 device_param->d_root_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
13653 device_param->d_markov_css_buf = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
13654
13655 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
13656 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
13657 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
13658 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
13659 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
13660 }
13661
13662 if (size_esalts)
13663 {
13664 device_param->d_esalt_bufs = hc_clCreateBuffer (device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
13665
13666 hc_clEnqueueWriteBuffer (device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
13667 }
13668
13669 /**
13670 * main host data
13671 */
13672
13673 uint *result = (uint *) mymalloc (size_results);
13674
13675 memset (result, 0, size_results);
13676
13677 device_param->result = result;
13678
13679 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
13680
13681 memset (pws_buf, 0, size_pws);
13682
13683 device_param->pws_buf = pws_buf;
13684
13685 pw_cache_t *pw_caches = (pw_cache_t *) mycalloc (64, sizeof (pw_cache_t));
13686
13687 for (int i = 0; i < 64; i++)
13688 {
13689 pw_caches[i].pw_buf.pw_len = i;
13690 pw_caches[i].cnt = 0;
13691 }
13692
13693 device_param->pw_caches = pw_caches;
13694
13695 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
13696
13697 device_param->combs_buf = combs_buf;
13698
13699 void *hooks_buf = mymalloc (size_hooks);
13700
13701 device_param->hooks_buf = hooks_buf;
13702
13703 device_param->pw_transpose = pw_transpose_to_hi1;
13704 device_param->pw_add = pw_add_to_hc1;
13705
13706 /**
13707 * kernel args
13708 */
13709
13710 device_param->kernel_params_buf32[21] = bitmap_mask;
13711 device_param->kernel_params_buf32[22] = bitmap_shift1;
13712 device_param->kernel_params_buf32[23] = bitmap_shift2;
13713 device_param->kernel_params_buf32[24] = 0; // salt_pos
13714 device_param->kernel_params_buf32[25] = 0; // loop_pos
13715 device_param->kernel_params_buf32[26] = 0; // loop_cnt
13716 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
13717 device_param->kernel_params_buf32[28] = 0; // digests_cnt
13718 device_param->kernel_params_buf32[29] = 0; // digests_offset
13719 device_param->kernel_params_buf32[30] = 0; // combs_mode
13720 device_param->kernel_params_buf32[31] = 0; // gid_max
13721
13722 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13723 ? &device_param->d_pws_buf
13724 : &device_param->d_pws_amp_buf;
13725 device_param->kernel_params[ 1] = &device_param->d_rules_c;
13726 device_param->kernel_params[ 2] = &device_param->d_combs_c;
13727 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
13728 device_param->kernel_params[ 4] = &device_param->d_tmps;
13729 device_param->kernel_params[ 5] = &device_param->d_hooks;
13730 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
13731 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
13732 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
13733 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
13734 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
13735 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
13736 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
13737 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
13738 device_param->kernel_params[14] = &device_param->d_plain_bufs;
13739 device_param->kernel_params[15] = &device_param->d_digests_buf;
13740 device_param->kernel_params[16] = &device_param->d_digests_shown;
13741 device_param->kernel_params[17] = &device_param->d_salt_bufs;
13742 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
13743 device_param->kernel_params[19] = &device_param->d_result;
13744 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
13745 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
13746 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
13747 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
13748 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
13749 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
13750 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
13751 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
13752 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
13753 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
13754 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
13755 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
13756
13757 device_param->kernel_params_mp_buf64[3] = 0;
13758 device_param->kernel_params_mp_buf32[4] = 0;
13759 device_param->kernel_params_mp_buf32[5] = 0;
13760 device_param->kernel_params_mp_buf32[6] = 0;
13761 device_param->kernel_params_mp_buf32[7] = 0;
13762 device_param->kernel_params_mp_buf32[8] = 0;
13763
13764 device_param->kernel_params_mp[0] = NULL;
13765 device_param->kernel_params_mp[1] = NULL;
13766 device_param->kernel_params_mp[2] = NULL;
13767 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
13768 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
13769 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
13770 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
13771 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
13772 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
13773
13774 device_param->kernel_params_mp_l_buf64[3] = 0;
13775 device_param->kernel_params_mp_l_buf32[4] = 0;
13776 device_param->kernel_params_mp_l_buf32[5] = 0;
13777 device_param->kernel_params_mp_l_buf32[6] = 0;
13778 device_param->kernel_params_mp_l_buf32[7] = 0;
13779 device_param->kernel_params_mp_l_buf32[8] = 0;
13780 device_param->kernel_params_mp_l_buf32[9] = 0;
13781
13782 device_param->kernel_params_mp_l[0] = NULL;
13783 device_param->kernel_params_mp_l[1] = NULL;
13784 device_param->kernel_params_mp_l[2] = NULL;
13785 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
13786 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
13787 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
13788 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
13789 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
13790 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
13791 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
13792
13793 device_param->kernel_params_mp_r_buf64[3] = 0;
13794 device_param->kernel_params_mp_r_buf32[4] = 0;
13795 device_param->kernel_params_mp_r_buf32[5] = 0;
13796 device_param->kernel_params_mp_r_buf32[6] = 0;
13797 device_param->kernel_params_mp_r_buf32[7] = 0;
13798 device_param->kernel_params_mp_r_buf32[8] = 0;
13799
13800 device_param->kernel_params_mp_r[0] = NULL;
13801 device_param->kernel_params_mp_r[1] = NULL;
13802 device_param->kernel_params_mp_r[2] = NULL;
13803 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
13804 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
13805 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
13806 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
13807 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
13808 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
13809
13810 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
13811 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
13812
13813 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
13814 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
13815 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
13816 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
13817 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
13818 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
13819 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
13820
13821 device_param->kernel_params_tb[0] = &device_param->d_pws_buf;
13822
13823 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
13824 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
13825
13826 /**
13827 * kernel name
13828 */
13829
13830 char kernel_name[64];
13831
13832 memset (kernel_name, 0, sizeof (kernel_name));
13833
13834 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13835 {
13836 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13837 {
13838 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
13839
13840 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13841
13842 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
13843
13844 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13845
13846 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
13847
13848 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13849 }
13850 else
13851 {
13852 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
13853
13854 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13855
13856 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
13857
13858 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13859
13860 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
13861
13862 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13863 }
13864
13865 if (data.attack_mode == ATTACK_MODE_BF)
13866 {
13867 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13868 {
13869 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tb", kern_type);
13870
13871 device_param->kernel_tb = hc_clCreateKernel (device_param->program, kernel_name);
13872
13873 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
13874
13875 device_param->kernel_tm = hc_clCreateKernel (device_param->program, kernel_name);
13876 }
13877 }
13878 }
13879 else
13880 {
13881 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
13882
13883 device_param->kernel1 = hc_clCreateKernel (device_param->program, kernel_name);
13884
13885 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
13886
13887 device_param->kernel2 = hc_clCreateKernel (device_param->program, kernel_name);
13888
13889 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
13890
13891 device_param->kernel3 = hc_clCreateKernel (device_param->program, kernel_name);
13892
13893 if (opts_type & OPTS_TYPE_HOOK12)
13894 {
13895 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
13896
13897 device_param->kernel12 = hc_clCreateKernel (device_param->program, kernel_name);
13898 }
13899
13900 if (opts_type & OPTS_TYPE_HOOK23)
13901 {
13902 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
13903
13904 device_param->kernel23 = hc_clCreateKernel (device_param->program, kernel_name);
13905 }
13906 }
13907
13908 for (uint i = 0; i <= 20; i++)
13909 {
13910 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
13911 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
13912 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
13913
13914 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
13915 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
13916 }
13917
13918 for (uint i = 21; i <= 31; i++)
13919 {
13920 hc_clSetKernelArg (device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
13921 hc_clSetKernelArg (device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
13922 hc_clSetKernelArg (device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
13923
13924 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
13925 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
13926 }
13927
13928 if (attack_mode == ATTACK_MODE_BF)
13929 {
13930 device_param->kernel_mp_l = hc_clCreateKernel (device_param->program_mp, "l_markov");
13931 device_param->kernel_mp_r = hc_clCreateKernel (device_param->program_mp, "r_markov");
13932
13933 if (opts_type & OPTS_TYPE_PT_BITSLICE)
13934 {
13935 hc_clSetKernelArg (device_param->kernel_tb, 0, sizeof (cl_mem), device_param->kernel_params_tb[0]);
13936
13937 hc_clSetKernelArg (device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
13938 hc_clSetKernelArg (device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
13939 }
13940 }
13941 else if (attack_mode == ATTACK_MODE_HYBRID1)
13942 {
13943 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13944 }
13945 else if (attack_mode == ATTACK_MODE_HYBRID2)
13946 {
13947 device_param->kernel_mp = hc_clCreateKernel (device_param->program_mp, "C_markov");
13948 }
13949
13950 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13951 {
13952 // nothing to do
13953 }
13954 else
13955 {
13956 device_param->kernel_amp = hc_clCreateKernel (device_param->program_amp, "amp");
13957 }
13958
13959 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13960 {
13961 // nothing to do
13962 }
13963 else
13964 {
13965 for (uint i = 0; i < 5; i++)
13966 {
13967 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
13968 }
13969
13970 for (uint i = 5; i < 7; i++)
13971 {
13972 hc_clSetKernelArg (device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
13973 }
13974 }
13975
13976 /**
13977 * Store initial fanspeed if gpu_temp_retain is enabled
13978 */
13979
13980 int gpu_temp_retain_set = 0;
13981
13982 if (gpu_temp_disable == 0)
13983 {
13984 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
13985 {
13986 hc_thread_mutex_lock (mux_adl);
13987
13988 if (data.hm_device[device_id].fan_supported == 1)
13989 {
13990 if (gpu_temp_retain_chgd == 0)
13991 {
13992 uint cur_temp = 0;
13993 uint default_temp = 0;
13994
13995 int ADL_rc = hc_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
13996
13997 if (ADL_rc == ADL_OK)
13998 {
13999 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
14000
14001 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
14002
14003 // special case with multi gpu setups: always use minimum retain
14004
14005 if (gpu_temp_retain_set == 0)
14006 {
14007 gpu_temp_retain = gpu_temp_retain_target;
14008 gpu_temp_retain_set = 1;
14009 }
14010 else
14011 {
14012 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
14013 }
14014
14015 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
14016 }
14017 }
14018
14019 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
14020
14021 temp_retain_fanspeed_value[device_id] = fan_speed;
14022
14023 if (fan_speed == -1)
14024 {
14025 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
14026
14027 temp_retain_fanspeed_value[device_id] = 0;
14028 }
14029 }
14030
14031 hc_thread_mutex_unlock (mux_adl);
14032 }
14033 }
14034
14035 /**
14036 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
14037 */
14038
14039 if (powertune_enable == 1) // VENDOR_ID_AMD implied
14040 {
14041 hc_thread_mutex_lock (mux_adl);
14042
14043 if (data.hm_device[device_id].od_version == 6)
14044 {
14045 int ADL_rc;
14046
14047 // check powertune capabilities first, if not available then skip device
14048
14049 int powertune_supported = 0;
14050
14051 if ((ADL_rc = hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14052 {
14053 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14054
14055 return (-1);
14056 }
14057
14058 if (powertune_supported != 0)
14059 {
14060 // powercontrol settings
14061
14062 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14063
14064 if ((ADL_rc = hc_ADL_Overdrive_PowerControlInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14065 {
14066 ADL_rc = hc_ADL_Overdrive_PowerControl_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14067 }
14068
14069 if (ADL_rc != ADL_OK)
14070 {
14071 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14072
14073 return (-1);
14074 }
14075
14076 if ((ADL_rc = hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14077 {
14078 log_error ("ERROR: Failed to set new ADL PowerControl values");
14079
14080 return (-1);
14081 }
14082
14083 // clocks
14084
14085 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14086
14087 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14088
14089 if ((ADL_rc = hc_ADL_Overdrive_StateInfo_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14090 {
14091 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14092
14093 return (-1);
14094 }
14095
14096 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14097
14098 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14099
14100 if ((ADL_rc = hc_ADL_Overdrive_Capabilities_Get (data.hm_dll, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14101 {
14102 log_error ("ERROR: Failed to get ADL device capabilities");
14103
14104 return (-1);
14105 }
14106
14107 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14108 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14109
14110 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14111 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14112
14113 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14114 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14115
14116 // warning if profile has to low max values
14117
14118 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14119 {
14120 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14121 }
14122
14123 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14124 {
14125 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14126 }
14127
14128 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14129
14130 performance_state->iNumberOfPerformanceLevels = 2;
14131
14132 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14133 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14134 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14135 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14136
14137 if ((ADL_rc = hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14138 {
14139 log_info ("ERROR: Failed to set ADL performance state");
14140
14141 return (-1);
14142 }
14143
14144 local_free (performance_state);
14145 }
14146 }
14147
14148 hc_thread_mutex_unlock (mux_adl);
14149 }
14150 }
14151
14152 data.kernel_blocks_all = kernel_blocks_all;
14153
14154 if (data.quiet == 0) log_info ("");
14155
14156 /**
14157 * Inform user which algorithm is checked and at which workload setting
14158 */
14159
14160 if (benchmark == 1)
14161 {
14162 quiet = 0;
14163
14164 data.quiet = quiet;
14165
14166 char *hash_type = strhashtype (data.hash_mode); // not a bug
14167
14168 log_info ("Hashtype: %s", hash_type);
14169 log_info ("Workload: %u loops, %u accel", kernel_loops, kernel_accel);
14170 log_info ("");
14171 }
14172
14173 /**
14174 * keep track of the progress
14175 */
14176
14177 data.words_progress_done = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14178 data.words_progress_rejected = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14179 data.words_progress_restored = (uint64_t *) mycalloc (data.salts_cnt, sizeof (uint64_t));
14180
14181 /**
14182 * open filehandles
14183 */
14184
14185 #if _WIN
14186 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
14187 {
14188 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
14189
14190 return (-1);
14191 }
14192
14193 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
14194 {
14195 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
14196
14197 return (-1);
14198 }
14199
14200 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
14201 {
14202 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
14203
14204 return (-1);
14205 }
14206 #endif
14207
14208 /**
14209 * dictionary pad
14210 */
14211
14212 segment_size *= (1024 * 1024);
14213
14214 data.segment_size = segment_size;
14215
14216 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
14217
14218 wl_data->buf = (char *) mymalloc (segment_size);
14219 wl_data->avail = segment_size;
14220 wl_data->incr = segment_size;
14221 wl_data->cnt = 0;
14222 wl_data->pos = 0;
14223
14224 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
14225
14226 data.wordlist_mode = wordlist_mode;
14227
14228 cs_t *css_buf = NULL;
14229 uint css_cnt = 0;
14230 uint dictcnt = 0;
14231 uint maskcnt = 1;
14232 char **masks = NULL;
14233 char **dictfiles = NULL;
14234
14235 uint mask_from_file = 0;
14236
14237 if (attack_mode == ATTACK_MODE_STRAIGHT)
14238 {
14239 if (wordlist_mode == WL_MODE_FILE)
14240 {
14241 int wls_left = myargc - (optind + 1);
14242
14243 for (int i = 0; i < wls_left; i++)
14244 {
14245 char *l0_filename = myargv[optind + 1 + i];
14246
14247 struct stat l0_stat;
14248
14249 if (stat (l0_filename, &l0_stat) == -1)
14250 {
14251 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
14252
14253 return (-1);
14254 }
14255
14256 uint is_dir = S_ISDIR (l0_stat.st_mode);
14257
14258 if (is_dir == 0)
14259 {
14260 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14261
14262 dictcnt++;
14263
14264 dictfiles[dictcnt - 1] = l0_filename;
14265 }
14266 else
14267 {
14268 // do not allow --keyspace w/ a directory
14269
14270 if (keyspace == 1)
14271 {
14272 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14273
14274 return (-1);
14275 }
14276
14277 char **dictionary_files = NULL;
14278
14279 dictionary_files = scan_directory (l0_filename);
14280
14281 if (dictionary_files != NULL)
14282 {
14283 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14284
14285 for (int d = 0; dictionary_files[d] != NULL; d++)
14286 {
14287 char *l1_filename = dictionary_files[d];
14288
14289 struct stat l1_stat;
14290
14291 if (stat (l1_filename, &l1_stat) == -1)
14292 {
14293 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14294
14295 return (-1);
14296 }
14297
14298 if (S_ISREG (l1_stat.st_mode))
14299 {
14300 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14301
14302 dictcnt++;
14303
14304 dictfiles[dictcnt - 1] = strdup (l1_filename);
14305 }
14306 }
14307 }
14308
14309 local_free (dictionary_files);
14310 }
14311 }
14312
14313 if (dictcnt < 1)
14314 {
14315 log_error ("ERROR: No usable dictionary file found.");
14316
14317 return (-1);
14318 }
14319 }
14320 else if (wordlist_mode == WL_MODE_STDIN)
14321 {
14322 dictcnt = 1;
14323 }
14324 }
14325 else if (attack_mode == ATTACK_MODE_COMBI)
14326 {
14327 // display
14328
14329 char *dictfile1 = myargv[optind + 1 + 0];
14330 char *dictfile2 = myargv[optind + 1 + 1];
14331
14332 // find the bigger dictionary and use as base
14333
14334 FILE *fp1;
14335 FILE *fp2;
14336
14337 struct stat tmp_stat;
14338
14339 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
14340 {
14341 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14342
14343 return (-1);
14344 }
14345
14346 if (stat (dictfile1, &tmp_stat) == -1)
14347 {
14348 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
14349
14350 fclose (fp1);
14351
14352 return (-1);
14353 }
14354
14355 if (S_ISDIR (tmp_stat.st_mode))
14356 {
14357 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
14358
14359 fclose (fp1);
14360
14361 return (-1);
14362 }
14363
14364 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
14365 {
14366 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14367
14368 fclose (fp1);
14369
14370 return (-1);
14371 }
14372
14373 if (stat (dictfile2, &tmp_stat) == -1)
14374 {
14375 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
14376
14377 fclose (fp1);
14378 fclose (fp2);
14379
14380 return (-1);
14381 }
14382
14383 if (S_ISDIR (tmp_stat.st_mode))
14384 {
14385 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
14386
14387 fclose (fp1);
14388 fclose (fp2);
14389
14390 return (-1);
14391 }
14392
14393 data.combs_cnt = 1;
14394
14395 data.quiet = 1;
14396
14397 const uint64_t words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
14398
14399 data.quiet = quiet;
14400
14401 if (words1_cnt == 0)
14402 {
14403 log_error ("ERROR: %s: empty file", dictfile1);
14404
14405 fclose (fp1);
14406 fclose (fp2);
14407
14408 return (-1);
14409 }
14410
14411 data.combs_cnt = 1;
14412
14413 data.quiet = 1;
14414
14415 const uint64_t words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
14416
14417 data.quiet = quiet;
14418
14419 if (words2_cnt == 0)
14420 {
14421 log_error ("ERROR: %s: empty file", dictfile2);
14422
14423 fclose (fp1);
14424 fclose (fp2);
14425
14426 return (-1);
14427 }
14428
14429 fclose (fp1);
14430 fclose (fp2);
14431
14432 data.dictfile = dictfile1;
14433 data.dictfile2 = dictfile2;
14434
14435 if (words1_cnt >= words2_cnt)
14436 {
14437 data.combs_cnt = words2_cnt;
14438 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14439
14440 dictfiles = &data.dictfile;
14441
14442 dictcnt = 1;
14443 }
14444 else
14445 {
14446 data.combs_cnt = words1_cnt;
14447 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14448
14449 dictfiles = &data.dictfile2;
14450
14451 dictcnt = 1;
14452
14453 // we also have to switch wordlist related rules!
14454
14455 char *tmpc = data.rule_buf_l;
14456
14457 data.rule_buf_l = data.rule_buf_r;
14458 data.rule_buf_r = tmpc;
14459
14460 int tmpi = data.rule_len_l;
14461
14462 data.rule_len_l = data.rule_len_r;
14463 data.rule_len_r = tmpi;
14464 }
14465 }
14466 else if (attack_mode == ATTACK_MODE_BF)
14467 {
14468 char *mask = NULL;
14469
14470 maskcnt = 0;
14471
14472 if (benchmark == 0)
14473 {
14474 mask = myargv[optind + 1];
14475
14476 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
14477
14478 if ((optind + 2) <= myargc)
14479 {
14480 struct stat file_stat;
14481
14482 if (stat (mask, &file_stat) == -1)
14483 {
14484 maskcnt = 1;
14485
14486 masks[maskcnt - 1] = mystrdup (mask);
14487 }
14488 else
14489 {
14490 int wls_left = myargc - (optind + 1);
14491
14492 uint masks_avail = INCR_MASKS;
14493
14494 for (int i = 0; i < wls_left; i++)
14495 {
14496 if (i != 0)
14497 {
14498 mask = myargv[optind + 1 + i];
14499
14500 if (stat (mask, &file_stat) == -1)
14501 {
14502 log_error ("ERROR: %s: %s", mask, strerror (errno));
14503
14504 return (-1);
14505 }
14506 }
14507
14508 uint is_file = S_ISREG (file_stat.st_mode);
14509
14510 if (is_file == 1)
14511 {
14512 FILE *mask_fp;
14513
14514 if ((mask_fp = fopen (mask, "r")) == NULL)
14515 {
14516 log_error ("ERROR: %s: %s", mask, strerror (errno));
14517
14518 return (-1);
14519 }
14520
14521 char line_buf[BUFSIZ];
14522
14523 while (!feof (mask_fp))
14524 {
14525 memset (line_buf, 0, BUFSIZ);
14526
14527 int line_len = fgetl (mask_fp, line_buf);
14528
14529 if (line_len == 0) continue;
14530
14531 if (line_buf[0] == '#') continue;
14532
14533 if (masks_avail == maskcnt)
14534 {
14535 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14536
14537 masks_avail += INCR_MASKS;
14538 }
14539
14540 masks[maskcnt] = mystrdup (line_buf);
14541
14542 maskcnt++;
14543 }
14544
14545 fclose (mask_fp);
14546 }
14547 else
14548 {
14549 log_error ("ERROR: %s: unsupported file-type", mask);
14550
14551 return (-1);
14552 }
14553 }
14554
14555 mask_from_file = 1;
14556 }
14557 }
14558 else
14559 {
14560 custom_charset_1 = (char *) "?l?d?u";
14561 custom_charset_2 = (char *) "?l?d";
14562 custom_charset_3 = (char *) "?l?d*!$@_";
14563
14564 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
14565 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
14566 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
14567
14568 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
14569
14570 wordlist_mode = WL_MODE_MASK;
14571
14572 data.wordlist_mode = wordlist_mode;
14573
14574 increment = 1;
14575
14576 maskcnt = 1;
14577 }
14578 }
14579 else
14580 {
14581 /**
14582 * generate full masks and charsets
14583 */
14584
14585 masks = (char **) mymalloc (sizeof (char *));
14586
14587 switch (hash_mode)
14588 {
14589 case 1731: pw_min = 5;
14590 pw_max = 5;
14591 mask = mystrdup ("?b?b?b?b?b");
14592 break;
14593 case 12500: pw_min = 5;
14594 pw_max = 5;
14595 mask = mystrdup ("?b?b?b?b?b");
14596 break;
14597 default: pw_min = 7;
14598 pw_max = 7;
14599 mask = mystrdup ("?b?b?b?b?b?b?b");
14600 break;
14601 }
14602
14603 maskcnt = 1;
14604
14605 masks[maskcnt - 1] = mystrdup (mask);
14606
14607 wordlist_mode = WL_MODE_MASK;
14608
14609 data.wordlist_mode = wordlist_mode;
14610
14611 increment = 1;
14612 }
14613
14614 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
14615
14616 if (increment)
14617 {
14618 if (increment_min > pw_min) pw_min = increment_min;
14619
14620 if (increment_max < pw_max) pw_max = increment_max;
14621 }
14622 }
14623 else if (attack_mode == ATTACK_MODE_HYBRID1)
14624 {
14625 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
14626
14627 // display
14628
14629 char *mask = myargv[myargc - 1];
14630
14631 maskcnt = 0;
14632
14633 masks = (char **) mymalloc (1 * sizeof (char *));
14634
14635 // mod
14636
14637 struct stat file_stat;
14638
14639 if (stat (mask, &file_stat) == -1)
14640 {
14641 maskcnt = 1;
14642
14643 masks[maskcnt - 1] = mystrdup (mask);
14644 }
14645 else
14646 {
14647 uint is_file = S_ISREG (file_stat.st_mode);
14648
14649 if (is_file == 1)
14650 {
14651 FILE *mask_fp;
14652
14653 if ((mask_fp = fopen (mask, "r")) == NULL)
14654 {
14655 log_error ("ERROR: %s: %s", mask, strerror (errno));
14656
14657 return (-1);
14658 }
14659
14660 char line_buf[BUFSIZ];
14661
14662 uint masks_avail = 1;
14663
14664 while (!feof (mask_fp))
14665 {
14666 memset (line_buf, 0, BUFSIZ);
14667
14668 int line_len = fgetl (mask_fp, line_buf);
14669
14670 if (line_len == 0) continue;
14671
14672 if (line_buf[0] == '#') continue;
14673
14674 if (masks_avail == maskcnt)
14675 {
14676 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14677
14678 masks_avail += INCR_MASKS;
14679 }
14680
14681 masks[maskcnt] = mystrdup (line_buf);
14682
14683 maskcnt++;
14684 }
14685
14686 fclose (mask_fp);
14687
14688 mask_from_file = 1;
14689 }
14690 else
14691 {
14692 maskcnt = 1;
14693
14694 masks[maskcnt - 1] = mystrdup (mask);
14695 }
14696 }
14697
14698 // base
14699
14700 int wls_left = myargc - (optind + 2);
14701
14702 for (int i = 0; i < wls_left; i++)
14703 {
14704 char *filename = myargv[optind + 1 + i];
14705
14706 struct stat file_stat;
14707
14708 if (stat (filename, &file_stat) == -1)
14709 {
14710 log_error ("ERROR: %s: %s", filename, strerror (errno));
14711
14712 return (-1);
14713 }
14714
14715 uint is_dir = S_ISDIR (file_stat.st_mode);
14716
14717 if (is_dir == 0)
14718 {
14719 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14720
14721 dictcnt++;
14722
14723 dictfiles[dictcnt - 1] = filename;
14724 }
14725 else
14726 {
14727 // do not allow --keyspace w/ a directory
14728
14729 if (keyspace == 1)
14730 {
14731 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14732
14733 return (-1);
14734 }
14735
14736 char **dictionary_files = NULL;
14737
14738 dictionary_files = scan_directory (filename);
14739
14740 if (dictionary_files != NULL)
14741 {
14742 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14743
14744 for (int d = 0; dictionary_files[d] != NULL; d++)
14745 {
14746 char *l1_filename = dictionary_files[d];
14747
14748 struct stat l1_stat;
14749
14750 if (stat (l1_filename, &l1_stat) == -1)
14751 {
14752 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14753
14754 return (-1);
14755 }
14756
14757 if (S_ISREG (l1_stat.st_mode))
14758 {
14759 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14760
14761 dictcnt++;
14762
14763 dictfiles[dictcnt - 1] = strdup (l1_filename);
14764 }
14765 }
14766 }
14767
14768 local_free (dictionary_files);
14769 }
14770 }
14771
14772 if (dictcnt < 1)
14773 {
14774 log_error ("ERROR: No usable dictionary file found.");
14775
14776 return (-1);
14777 }
14778
14779 if (increment)
14780 {
14781 maskcnt = 0;
14782
14783 uint mask_min = increment_min; // we can't reject smaller masks here
14784 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14785
14786 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14787 {
14788 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14789
14790 if (cur_mask == NULL) break;
14791
14792 masks[maskcnt] = cur_mask;
14793
14794 maskcnt++;
14795
14796 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14797 }
14798 }
14799 }
14800 else if (attack_mode == ATTACK_MODE_HYBRID2)
14801 {
14802 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
14803
14804 // display
14805
14806 char *mask = myargv[optind + 1 + 0];
14807
14808 maskcnt = 0;
14809
14810 masks = (char **) mymalloc (1 * sizeof (char *));
14811
14812 // mod
14813
14814 struct stat file_stat;
14815
14816 if (stat (mask, &file_stat) == -1)
14817 {
14818 maskcnt = 1;
14819
14820 masks[maskcnt - 1] = mystrdup (mask);
14821 }
14822 else
14823 {
14824 uint is_file = S_ISREG (file_stat.st_mode);
14825
14826 if (is_file == 1)
14827 {
14828 FILE *mask_fp;
14829
14830 if ((mask_fp = fopen (mask, "r")) == NULL)
14831 {
14832 log_error ("ERROR: %s: %s", mask, strerror (errno));
14833
14834 return (-1);
14835 }
14836
14837 char line_buf[BUFSIZ];
14838
14839 uint masks_avail = 1;
14840
14841 while (!feof (mask_fp))
14842 {
14843 memset (line_buf, 0, BUFSIZ);
14844
14845 int line_len = fgetl (mask_fp, line_buf);
14846
14847 if (line_len == 0) continue;
14848
14849 if (line_buf[0] == '#') continue;
14850
14851 if (masks_avail == maskcnt)
14852 {
14853 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
14854
14855 masks_avail += INCR_MASKS;
14856 }
14857
14858 masks[maskcnt] = mystrdup (line_buf);
14859
14860 maskcnt++;
14861 }
14862
14863 fclose (mask_fp);
14864
14865 mask_from_file = 1;
14866 }
14867 else
14868 {
14869 maskcnt = 1;
14870
14871 masks[maskcnt - 1] = mystrdup (mask);
14872 }
14873 }
14874
14875 // base
14876
14877 int wls_left = myargc - (optind + 2);
14878
14879 for (int i = 0; i < wls_left; i++)
14880 {
14881 char *filename = myargv[optind + 2 + i];
14882
14883 struct stat file_stat;
14884
14885 if (stat (filename, &file_stat) == -1)
14886 {
14887 log_error ("ERROR: %s: %s", filename, strerror (errno));
14888
14889 return (-1);
14890 }
14891
14892 uint is_dir = S_ISDIR (file_stat.st_mode);
14893
14894 if (is_dir == 0)
14895 {
14896 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14897
14898 dictcnt++;
14899
14900 dictfiles[dictcnt - 1] = filename;
14901 }
14902 else
14903 {
14904 // do not allow --keyspace w/ a directory
14905
14906 if (keyspace == 1)
14907 {
14908 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
14909
14910 return (-1);
14911 }
14912
14913 char **dictionary_files = NULL;
14914
14915 dictionary_files = scan_directory (filename);
14916
14917 if (dictionary_files != NULL)
14918 {
14919 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
14920
14921 for (int d = 0; dictionary_files[d] != NULL; d++)
14922 {
14923 char *l1_filename = dictionary_files[d];
14924
14925 struct stat l1_stat;
14926
14927 if (stat (l1_filename, &l1_stat) == -1)
14928 {
14929 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
14930
14931 return (-1);
14932 }
14933
14934 if (S_ISREG (l1_stat.st_mode))
14935 {
14936 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
14937
14938 dictcnt++;
14939
14940 dictfiles[dictcnt - 1] = strdup (l1_filename);
14941 }
14942 }
14943 }
14944
14945 local_free (dictionary_files);
14946 }
14947 }
14948
14949 if (dictcnt < 1)
14950 {
14951 log_error ("ERROR: No usable dictionary file found.");
14952
14953 return (-1);
14954 }
14955
14956 if (increment)
14957 {
14958 maskcnt = 0;
14959
14960 uint mask_min = increment_min; // we can't reject smaller masks here
14961 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
14962
14963 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
14964 {
14965 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
14966
14967 if (cur_mask == NULL) break;
14968
14969 masks[maskcnt] = cur_mask;
14970
14971 maskcnt++;
14972
14973 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
14974 }
14975 }
14976 }
14977
14978 data.pw_min = pw_min;
14979 data.pw_max = pw_max;
14980
14981 /**
14982 * weak hash check
14983 */
14984
14985 if (weak_hash_threshold >= salts_cnt)
14986 {
14987 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
14988
14989 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
14990 {
14991 weak_hash_check (&data.devices_param[0], salt_pos, kernel_loops);
14992 }
14993 }
14994
14995 // Display hack, guarantee that there is at least one \r before real start
14996
14997 if (data.quiet == 0) log_info_nn ("");
14998
14999 /**
15000 * status and monitor threads
15001 */
15002
15003 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
15004
15005 hc_thread_t i_thread = 0;
15006
15007 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
15008 {
15009 hc_thread_create (i_thread, thread_keypress, &benchmark);
15010 }
15011
15012 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
15013
15014 uint ni_threads_cnt = 0;
15015
15016 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
15017
15018 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
15019
15020 ni_threads_cnt++;
15021
15022 /**
15023 * Outfile remove
15024 */
15025
15026 if (keyspace == 0)
15027 {
15028 if (outfile_check_timer != 0)
15029 {
15030 if (data.outfile_check_directory != NULL)
15031 {
15032 if ((hash_mode != 5200) &&
15033 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
15034 (hash_mode != 9000))
15035 {
15036 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
15037
15038 ni_threads_cnt++;
15039 }
15040 else
15041 {
15042 outfile_check_timer = 0;
15043 }
15044 }
15045 else
15046 {
15047 outfile_check_timer = 0;
15048 }
15049 }
15050 }
15051
15052 /**
15053 * Inform the user if we got some hashes remove because of the pot file remove feature
15054 */
15055
15056 if (data.quiet == 0)
15057 {
15058 if (potfile_remove_cracks > 0)
15059 {
15060 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
15061 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
15062 }
15063 }
15064
15065 data.outfile_check_timer = outfile_check_timer;
15066
15067 /**
15068 * main loop
15069 */
15070
15071 char **induction_dictionaries = NULL;
15072
15073 int induction_dictionaries_cnt = 0;
15074
15075 hcstat_table_t *root_table_buf = NULL;
15076 hcstat_table_t *markov_table_buf = NULL;
15077
15078 uint initial_restore_done = 0;
15079
15080 data.maskcnt = maskcnt;
15081
15082 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
15083 {
15084 if (data.devices_status == STATUS_CRACKED) break;
15085
15086 data.devices_status = STATUS_INIT;
15087
15088 if (maskpos > rd->maskpos)
15089 {
15090 rd->dictpos = 0;
15091 }
15092
15093 rd->maskpos = maskpos;
15094 data.maskpos = maskpos;
15095
15096 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
15097 {
15098 char *mask = masks[maskpos];
15099
15100 if (mask_from_file == 1)
15101 {
15102 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
15103
15104 char *str_ptr;
15105 uint str_pos;
15106
15107 uint mask_offset = 0;
15108
15109 uint separator_cnt;
15110
15111 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
15112 {
15113 str_ptr = strstr (mask + mask_offset, ",");
15114
15115 if (str_ptr == NULL) break;
15116
15117 str_pos = str_ptr - mask;
15118
15119 // escaped separator, i.e. "\,"
15120
15121 if (str_pos > 0)
15122 {
15123 if (mask[str_pos - 1] == '\\')
15124 {
15125 separator_cnt --;
15126
15127 mask_offset = str_pos + 1;
15128
15129 continue;
15130 }
15131 }
15132
15133 // reset the offset
15134
15135 mask_offset = 0;
15136
15137 mask[str_pos] = '\0';
15138
15139 switch (separator_cnt)
15140 {
15141 case 0:
15142 mp_reset_usr (mp_usr, 0);
15143
15144 custom_charset_1 = mask;
15145 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15146 break;
15147
15148 case 1:
15149 mp_reset_usr (mp_usr, 1);
15150
15151 custom_charset_2 = mask;
15152 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15153 break;
15154
15155 case 2:
15156 mp_reset_usr (mp_usr, 2);
15157
15158 custom_charset_3 = mask;
15159 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15160 break;
15161
15162 case 3:
15163 mp_reset_usr (mp_usr, 3);
15164
15165 custom_charset_4 = mask;
15166 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
15167 break;
15168 }
15169
15170 mask = mask + str_pos + 1;
15171 }
15172 }
15173
15174 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15175 {
15176 if (maskpos > 0)
15177 {
15178 local_free (css_buf);
15179 local_free (data.root_css_buf);
15180 local_free (data.markov_css_buf);
15181
15182 local_free (masks[maskpos - 1]);
15183 }
15184
15185 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15186
15187 data.mask = mask;
15188 data.css_cnt = css_cnt;
15189 data.css_buf = css_buf;
15190
15191 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15192
15193 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15194
15195 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15196
15197 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15198 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15199
15200 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15201
15202 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15203
15204 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15205 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15206
15207 data.root_css_buf = root_css_buf;
15208 data.markov_css_buf = markov_css_buf;
15209
15210 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15211
15212 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15213
15214 local_free (root_table_buf);
15215 local_free (markov_table_buf);
15216
15217 // args
15218
15219 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15220 {
15221 hc_device_param_t *device_param = &data.devices_param[device_id];
15222
15223 device_param->kernel_params_mp[0] = &device_param->d_combs;
15224 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
15225 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
15226
15227 device_param->kernel_params_mp_buf64[3] = 0;
15228 device_param->kernel_params_mp_buf32[4] = css_cnt;
15229 device_param->kernel_params_mp_buf32[5] = 0;
15230 device_param->kernel_params_mp_buf32[6] = 0;
15231 device_param->kernel_params_mp_buf32[7] = 0;
15232
15233 if (attack_mode == ATTACK_MODE_HYBRID1)
15234 {
15235 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
15236 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
15237 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
15238 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
15239 }
15240 else if (attack_mode == ATTACK_MODE_HYBRID2)
15241 {
15242 device_param->kernel_params_mp_buf32[5] = 0;
15243 device_param->kernel_params_mp_buf32[6] = 0;
15244 device_param->kernel_params_mp_buf32[7] = 0;
15245 }
15246
15247 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
15248 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
15249 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
15250
15251 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);
15252 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);
15253 }
15254 }
15255 else if (attack_mode == ATTACK_MODE_BF)
15256 {
15257 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
15258
15259 if (increment)
15260 {
15261 for (uint i = 0; i < dictcnt; i++)
15262 {
15263 local_free (dictfiles[i]);
15264 }
15265
15266 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
15267 {
15268 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
15269
15270 if (l1_filename == NULL) break;
15271
15272 dictcnt++;
15273
15274 dictfiles[dictcnt - 1] = l1_filename;
15275 }
15276 }
15277 else
15278 {
15279 dictcnt++;
15280
15281 dictfiles[dictcnt - 1] = mask;
15282 }
15283
15284 if (dictcnt == 0)
15285 {
15286 log_error ("ERROR: Mask is too small");
15287
15288 return (-1);
15289 }
15290 }
15291 }
15292
15293 free (induction_dictionaries);
15294
15295 // induction_dictionaries_cnt = 0; // implied
15296
15297 if (attack_mode != ATTACK_MODE_BF)
15298 {
15299 if (keyspace == 0)
15300 {
15301 induction_dictionaries = scan_directory (induction_directory);
15302
15303 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15304 }
15305 }
15306
15307 if (induction_dictionaries_cnt)
15308 {
15309 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
15310 }
15311
15312 /**
15313 * prevent the user from using --keyspace together w/ maskfile and or dictfile
15314 */
15315 if (keyspace == 1)
15316 {
15317 if ((maskcnt > 1) || (dictcnt > 1))
15318 {
15319 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
15320
15321 return (-1);
15322 }
15323 }
15324
15325 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
15326 {
15327 char *subid = logfile_generate_subid ();
15328
15329 data.subid = subid;
15330
15331 logfile_sub_msg ("START");
15332
15333 data.devices_status = STATUS_INIT;
15334
15335 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (uint64_t));
15336 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (uint64_t));
15337 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (uint64_t));
15338
15339 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
15340
15341 data.cpt_pos = 0;
15342
15343 data.cpt_start = time (NULL);
15344
15345 data.cpt_total = 0;
15346
15347 if (data.restore == 0)
15348 {
15349 rd->words_cur = skip;
15350
15351 skip = 0;
15352
15353 data.skip = 0;
15354 }
15355
15356 data.ms_paused = 0;
15357
15358 data.words_cur = rd->words_cur;
15359
15360 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15361 {
15362 hc_device_param_t *device_param = &data.devices_param[device_id];
15363
15364 device_param->speed_pos = 0;
15365
15366 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (uint64_t));
15367 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (float));
15368 memset (device_param->speed_rec, 0, SPEED_CACHE * sizeof (hc_timer_t));
15369
15370 device_param->kernel_power = device_param->kernel_power_user;
15371 device_param->kernel_blocks = device_param->kernel_blocks_user;
15372
15373 device_param->outerloop_pos = 0;
15374 device_param->outerloop_left = 0;
15375 device_param->innerloop_pos = 0;
15376 device_param->innerloop_left = 0;
15377
15378 // some more resets:
15379
15380 memset (device_param->pw_caches, 0, 64 * sizeof (pw_cache_t));
15381
15382 memset (device_param->pws_buf, 0, device_param->size_pws);
15383
15384 device_param->pw_cnt = 0;
15385 device_param->pws_cnt = 0;
15386
15387 device_param->words_off = 0;
15388 device_param->words_done = 0;
15389 }
15390
15391 data.kernel_blocks_div = 0;
15392
15393 // figure out some workload
15394
15395 if (attack_mode == ATTACK_MODE_STRAIGHT)
15396 {
15397 if (data.wordlist_mode == WL_MODE_FILE)
15398 {
15399 char *dictfile = NULL;
15400
15401 if (induction_dictionaries_cnt)
15402 {
15403 dictfile = induction_dictionaries[0];
15404 }
15405 else
15406 {
15407 dictfile = dictfiles[dictpos];
15408 }
15409
15410 data.dictfile = dictfile;
15411
15412 logfile_sub_string (dictfile);
15413
15414 for (uint i = 0; i < rp_files_cnt; i++)
15415 {
15416 logfile_sub_var_string ("rulefile", rp_files[i]);
15417 }
15418
15419 FILE *fd2 = fopen (dictfile, "rb");
15420
15421 if (fd2 == NULL)
15422 {
15423 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15424
15425 return (-1);
15426 }
15427
15428 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15429
15430 fclose (fd2);
15431
15432 if (data.words_cnt == 0)
15433 {
15434 if (data.devices_status == STATUS_CRACKED) break;
15435 if (data.devices_status == STATUS_ABORTED) break;
15436
15437 dictpos++;
15438
15439 continue;
15440 }
15441 }
15442 }
15443 else if (attack_mode == ATTACK_MODE_COMBI)
15444 {
15445 char *dictfile = data.dictfile;
15446 char *dictfile2 = data.dictfile2;
15447
15448 logfile_sub_string (dictfile);
15449 logfile_sub_string (dictfile2);
15450
15451 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
15452 {
15453 FILE *fd2 = fopen (dictfile, "rb");
15454
15455 if (fd2 == NULL)
15456 {
15457 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15458
15459 return (-1);
15460 }
15461
15462 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15463
15464 fclose (fd2);
15465 }
15466 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
15467 {
15468 FILE *fd2 = fopen (dictfile2, "rb");
15469
15470 if (fd2 == NULL)
15471 {
15472 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15473
15474 return (-1);
15475 }
15476
15477 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
15478
15479 fclose (fd2);
15480 }
15481
15482 if (data.words_cnt == 0)
15483 {
15484 if (data.devices_status == STATUS_CRACKED) break;
15485 if (data.devices_status == STATUS_ABORTED) break;
15486
15487 dictpos++;
15488
15489 continue;
15490 }
15491 }
15492 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
15493 {
15494 char *dictfile = NULL;
15495
15496 if (induction_dictionaries_cnt)
15497 {
15498 dictfile = induction_dictionaries[0];
15499 }
15500 else
15501 {
15502 dictfile = dictfiles[dictpos];
15503 }
15504
15505 data.dictfile = dictfile;
15506
15507 char *mask = data.mask;
15508
15509 logfile_sub_string (dictfile);
15510 logfile_sub_string (mask);
15511
15512 FILE *fd2 = fopen (dictfile, "rb");
15513
15514 if (fd2 == NULL)
15515 {
15516 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
15517
15518 return (-1);
15519 }
15520
15521 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
15522
15523 fclose (fd2);
15524
15525 if (data.words_cnt == 0)
15526 {
15527 if (data.devices_status == STATUS_CRACKED) break;
15528 if (data.devices_status == STATUS_ABORTED) break;
15529
15530 dictpos++;
15531
15532 continue;
15533 }
15534 }
15535 else if (attack_mode == ATTACK_MODE_BF)
15536 {
15537 local_free (css_buf);
15538 local_free (data.root_css_buf);
15539 local_free (data.markov_css_buf);
15540
15541 char *mask = dictfiles[dictpos];
15542
15543 logfile_sub_string (mask);
15544
15545 // base
15546
15547 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
15548
15549 if (opts_type & OPTS_TYPE_PT_UNICODE)
15550 {
15551 uint css_cnt_unicode = css_cnt * 2;
15552
15553 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
15554
15555 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
15556 {
15557 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
15558
15559 css_buf_unicode[j + 1].cs_buf[0] = 0;
15560 css_buf_unicode[j + 1].cs_len = 1;
15561 }
15562
15563 free (css_buf);
15564
15565 css_buf = css_buf_unicode;
15566 css_cnt = css_cnt_unicode;
15567 }
15568
15569 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
15570
15571 uint mask_min = pw_min;
15572 uint mask_max = pw_max;
15573
15574 if (opts_type & OPTS_TYPE_PT_UNICODE)
15575 {
15576 mask_min *= 2;
15577 mask_max *= 2;
15578 }
15579
15580 if ((css_cnt < mask_min) || (css_cnt > mask_max))
15581 {
15582 if (css_cnt < mask_min)
15583 {
15584 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
15585 }
15586
15587 if (css_cnt > mask_max)
15588 {
15589 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
15590 }
15591
15592 // skip to next mask
15593
15594 dictpos++;
15595
15596 rd->dictpos = dictpos;
15597
15598 logfile_sub_msg ("STOP");
15599
15600 continue;
15601 }
15602
15603 uint save_css_cnt = css_cnt;
15604
15605 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15606 {
15607 if (opti_type & OPTI_TYPE_APPENDED_SALT)
15608 {
15609 uint salt_len = (uint) data.salts_buf[0].salt_len;
15610 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
15611
15612 uint css_cnt_salt = css_cnt + salt_len;
15613
15614 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
15615
15616 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
15617
15618 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
15619 {
15620 css_buf_salt[j].cs_buf[0] = salt_buf[i];
15621 css_buf_salt[j].cs_len = 1;
15622 }
15623
15624 free (css_buf);
15625
15626 css_buf = css_buf_salt;
15627 css_cnt = css_cnt_salt;
15628 }
15629 }
15630
15631 data.mask = mask;
15632 data.css_cnt = css_cnt;
15633 data.css_buf = css_buf;
15634
15635 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
15636
15637 uint uniq_tbls[SP_PW_MAX][CHARSIZ];
15638
15639 memset (uniq_tbls, 0, sizeof (uniq_tbls));
15640
15641 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
15642
15643 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
15644 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
15645
15646 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
15647
15648 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
15649
15650 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
15651 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
15652
15653 data.root_css_buf = root_css_buf;
15654 data.markov_css_buf = markov_css_buf;
15655
15656 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
15657
15658 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
15659
15660 local_free (root_table_buf);
15661 local_free (markov_table_buf);
15662
15663 // copy + args
15664
15665 uint css_cnt_l = css_cnt;
15666 uint css_cnt_r;
15667
15668 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15669 {
15670 if (save_css_cnt < 6)
15671 {
15672 css_cnt_r = 1;
15673 }
15674 else if (save_css_cnt == 6)
15675 {
15676 css_cnt_r = 2;
15677 }
15678 else
15679 {
15680 if (opts_type & OPTS_TYPE_PT_UNICODE)
15681 {
15682 if (save_css_cnt == 8 || save_css_cnt == 10)
15683 {
15684 css_cnt_r = 2;
15685 }
15686 else
15687 {
15688 css_cnt_r = 4;
15689 }
15690 }
15691 else
15692 {
15693 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
15694 {
15695 css_cnt_r = 3;
15696 }
15697 else
15698 {
15699 css_cnt_r = 4;
15700 }
15701 }
15702 }
15703 }
15704 else
15705 {
15706 css_cnt_r = 1;
15707
15708 /* unfinished code?
15709 int sum = css_buf[css_cnt_r - 1].cs_len;
15710
15711 for (uint i = 1; i < 4 && i < css_cnt; i++)
15712 {
15713 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
15714
15715 css_cnt_r++;
15716
15717 sum *= css_buf[css_cnt_r - 1].cs_len;
15718 }
15719 */
15720 }
15721
15722 css_cnt_l -= css_cnt_r;
15723
15724 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
15725
15726 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15727 {
15728 hc_device_param_t *device_param = &data.devices_param[device_id];
15729
15730 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
15731 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
15732 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
15733
15734 device_param->kernel_params_mp_l_buf64[3] = 0;
15735 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
15736 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
15737 device_param->kernel_params_mp_l_buf32[6] = 0;
15738 device_param->kernel_params_mp_l_buf32[7] = 0;
15739 device_param->kernel_params_mp_l_buf32[8] = 0;
15740
15741 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
15742 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
15743 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
15744 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
15745
15746 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
15747 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
15748 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
15749
15750 device_param->kernel_params_mp_r_buf64[3] = 0;
15751 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
15752 device_param->kernel_params_mp_r_buf32[5] = 0;
15753 device_param->kernel_params_mp_r_buf32[6] = 0;
15754 device_param->kernel_params_mp_r_buf32[7] = 0;
15755
15756 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]);
15757 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]);
15758 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]);
15759
15760 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]);
15761 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]);
15762 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]);
15763
15764 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);
15765 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);
15766 }
15767 }
15768
15769 uint64_t words_base = data.words_cnt;
15770
15771 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15772 {
15773 if (data.kernel_rules_cnt)
15774 {
15775 words_base /= data.kernel_rules_cnt;
15776 }
15777 }
15778 else if (data.attack_kern == ATTACK_KERN_COMBI)
15779 {
15780 if (data.combs_cnt)
15781 {
15782 words_base /= data.combs_cnt;
15783 }
15784 }
15785 else if (data.attack_kern == ATTACK_KERN_BF)
15786 {
15787 if (data.bfs_cnt)
15788 {
15789 words_base /= data.bfs_cnt;
15790 }
15791 }
15792
15793 data.words_base = words_base;
15794
15795 if (keyspace == 1)
15796 {
15797 log_info ("%llu", (unsigned long long int) words_base);
15798
15799 return (0);
15800 }
15801
15802 if (data.words_cur > data.words_base)
15803 {
15804 log_error ("ERROR: restore value greater keyspace");
15805
15806 return (-1);
15807 }
15808
15809 if (data.words_cur)
15810 {
15811 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
15812 {
15813 for (uint i = 0; i < data.salts_cnt; i++)
15814 {
15815 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
15816 }
15817 }
15818 else if (data.attack_kern == ATTACK_KERN_COMBI)
15819 {
15820 for (uint i = 0; i < data.salts_cnt; i++)
15821 {
15822 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
15823 }
15824 }
15825 else if (data.attack_kern == ATTACK_KERN_BF)
15826 {
15827 for (uint i = 0; i < data.salts_cnt; i++)
15828 {
15829 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
15830 }
15831 }
15832 }
15833
15834 /*
15835 * Inform user about possible slow speeds
15836 */
15837
15838 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15839 {
15840 if (data.words_base < kernel_blocks_all)
15841 {
15842 if (quiet == 0)
15843 {
15844 log_info ("");
15845 log_info ("ATTENTION!");
15846 log_info (" The wordlist or mask you are using is too small.");
15847 log_info (" Therefore, oclHashcat is unable to utilize the full parallelization power of your device(s).");
15848 log_info (" The cracking speed will drop.");
15849 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
15850 log_info ("");
15851 }
15852 }
15853 }
15854
15855 /*
15856 * Update loopback file
15857 */
15858
15859 if (loopback == 1)
15860 {
15861 time_t now;
15862
15863 time (&now);
15864
15865 uint random_num = get_random_num (0, 9999);
15866
15867 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
15868
15869 data.loopback_file = loopback_file;
15870 }
15871
15872 /*
15873 * Update dictionary statistic
15874 */
15875
15876 if (keyspace == 0)
15877 {
15878 dictstat_fp = fopen (dictstat, "wb");
15879
15880 if (dictstat_fp)
15881 {
15882 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
15883
15884 fclose (dictstat_fp);
15885 }
15886 }
15887
15888 data.devices_status = STATUS_RUNNING;
15889
15890 if (initial_restore_done == 0)
15891 {
15892 if (data.restore_disable == 0) cycle_restore ();
15893
15894 initial_restore_done = 1;
15895 }
15896
15897 hc_timer_set (&data.timer_running);
15898
15899 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
15900 {
15901 if ((quiet == 0) && (status == 0) && (benchmark == 0))
15902 {
15903 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
15904 if (quiet == 0) fflush (stdout);
15905 }
15906 }
15907 else if (wordlist_mode == WL_MODE_STDIN)
15908 {
15909 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
15910 if (data.quiet == 0) log_info ("");
15911 }
15912
15913 time_t runtime_start;
15914
15915 time (&runtime_start);
15916
15917 data.runtime_start = runtime_start;
15918
15919 /**
15920 * create cracker threads
15921 */
15922
15923 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (devices_cnt, sizeof (hc_thread_t));
15924
15925 for (uint device_id = 0; device_id < devices_cnt; device_id++)
15926 {
15927 hc_device_param_t *device_param = &devices_param[device_id];
15928
15929 device_param->device_id = device_id;
15930
15931 if (wordlist_mode == WL_MODE_STDIN)
15932 {
15933 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
15934 }
15935 else
15936 {
15937 hc_thread_create (c_threads[device_id], thread_calc, device_param);
15938 }
15939 }
15940
15941 // wait for crack threads to exit
15942
15943 hc_thread_wait (devices_cnt, c_threads);
15944
15945 local_free (c_threads);
15946
15947 data.restore = 0;
15948
15949 // finalize task
15950
15951 logfile_sub_var_uint ("status-after-work", data.devices_status);
15952
15953 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
15954
15955 if (data.devices_status == STATUS_CRACKED) break;
15956 if (data.devices_status == STATUS_ABORTED) break;
15957
15958 if (data.devices_status == STATUS_BYPASS)
15959 {
15960 data.devices_status = STATUS_RUNNING;
15961 }
15962
15963 if (induction_dictionaries_cnt)
15964 {
15965 unlink (induction_dictionaries[0]);
15966 }
15967
15968 free (induction_dictionaries);
15969
15970 if (attack_mode != ATTACK_MODE_BF)
15971 {
15972 induction_dictionaries = scan_directory (induction_directory);
15973
15974 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
15975 }
15976
15977 if (benchmark == 0)
15978 {
15979 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
15980 {
15981 if (quiet == 0) clear_prompt ();
15982
15983 if (quiet == 0) log_info ("");
15984
15985 if (status == 1)
15986 {
15987 status_display ();
15988 }
15989 else
15990 {
15991 if (quiet == 0) status_display ();
15992 }
15993
15994 if (quiet == 0) log_info ("");
15995 }
15996 }
15997
15998 if (attack_mode == ATTACK_MODE_BF)
15999 {
16000 dictpos++;
16001
16002 rd->dictpos = dictpos;
16003 }
16004 else
16005 {
16006 if (induction_dictionaries_cnt)
16007 {
16008 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16009 }
16010 else
16011 {
16012 dictpos++;
16013
16014 rd->dictpos = dictpos;
16015 }
16016 }
16017
16018 time_t runtime_stop;
16019
16020 time (&runtime_stop);
16021
16022 data.runtime_stop = runtime_stop;
16023
16024 logfile_sub_uint (runtime_start);
16025 logfile_sub_uint (runtime_stop);
16026
16027 logfile_sub_msg ("STOP");
16028
16029 global_free (subid);
16030 }
16031
16032 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
16033
16034 if (data.devices_status == STATUS_CRACKED) break;
16035 if (data.devices_status == STATUS_ABORTED) break;
16036 if (data.devices_status == STATUS_QUIT) break;
16037
16038 if (data.devices_status == STATUS_BYPASS)
16039 {
16040 data.devices_status = STATUS_RUNNING;
16041 }
16042 }
16043
16044 // 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
16045
16046 if (attack_mode == ATTACK_MODE_STRAIGHT)
16047 {
16048 if (data.wordlist_mode == WL_MODE_FILE)
16049 {
16050 if (data.dictfile == NULL)
16051 {
16052 if (dictfiles != NULL)
16053 {
16054 data.dictfile = dictfiles[0];
16055
16056 hc_timer_set (&data.timer_running);
16057 }
16058 }
16059 }
16060 }
16061 // NOTE: combi is okay because it is already set beforehand
16062 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
16063 {
16064 if (data.dictfile == NULL)
16065 {
16066 if (dictfiles != NULL)
16067 {
16068 hc_timer_set (&data.timer_running);
16069
16070 data.dictfile = dictfiles[0];
16071 }
16072 }
16073 }
16074 else if (attack_mode == ATTACK_MODE_BF)
16075 {
16076 if (data.mask == NULL)
16077 {
16078 hc_timer_set (&data.timer_running);
16079
16080 data.mask = masks[0];
16081 }
16082 }
16083
16084 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
16085 {
16086 data.devices_status = STATUS_EXHAUSTED;
16087 }
16088
16089 // if cracked / aborted remove last induction dictionary
16090
16091 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
16092 {
16093 struct stat induct_stat;
16094
16095 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
16096 {
16097 unlink (induction_dictionaries[file_pos]);
16098 }
16099 }
16100
16101 // wait for non-interactive threads
16102
16103 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
16104 {
16105 hc_thread_wait (1, &ni_threads[thread_idx]);
16106 }
16107
16108 local_free (ni_threads);
16109
16110 // wait for interactive threads
16111
16112 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16113 {
16114 hc_thread_wait (1, &i_thread);
16115 }
16116
16117 // we dont need restore file anymore
16118 if (data.restore_disable == 0)
16119 {
16120 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
16121 {
16122 unlink (eff_restore_file);
16123 unlink (new_restore_file);
16124 }
16125 else
16126 {
16127 cycle_restore ();
16128 }
16129 }
16130
16131 // finally save left hashes
16132
16133 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
16134 {
16135 save_hash ();
16136 }
16137
16138 /**
16139 * Clean up
16140 */
16141
16142 if (benchmark == 1)
16143 {
16144 status_benchmark ();
16145
16146 log_info ("");
16147 }
16148 else
16149 {
16150 if (quiet == 0) clear_prompt ();
16151
16152 if (quiet == 0) log_info ("");
16153
16154 if (status == 1)
16155 {
16156 status_display ();
16157 }
16158 else
16159 {
16160 if (quiet == 0) status_display ();
16161 }
16162
16163 if (quiet == 0) log_info ("");
16164 }
16165
16166 for (uint device_id = 0; device_id < devices_cnt; device_id++)
16167 {
16168 hc_device_param_t *device_param = &data.devices_param[device_id];
16169
16170 local_free (device_param->result);
16171
16172 local_free (device_param->pw_caches);
16173
16174 local_free (device_param->combs_buf);
16175
16176 local_free (device_param->hooks_buf);
16177
16178 local_free (device_param->device_name);
16179
16180 local_free (device_param->device_name_chksum);
16181
16182 local_free (device_param->device_version);
16183
16184 local_free (device_param->driver_version);
16185
16186 if (device_param->pws_buf) myfree (device_param->pws_buf);
16187 if (device_param->d_pws_buf) hc_clReleaseMemObject (device_param->d_pws_buf);
16188 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (device_param->d_pws_amp_buf);
16189 if (device_param->d_rules) hc_clReleaseMemObject (device_param->d_rules);
16190 if (device_param->d_rules_c) hc_clReleaseMemObject (device_param->d_rules_c);
16191 if (device_param->d_combs) hc_clReleaseMemObject (device_param->d_combs);
16192 if (device_param->d_combs_c) hc_clReleaseMemObject (device_param->d_combs_c);
16193 if (device_param->d_bfs) hc_clReleaseMemObject (device_param->d_bfs);
16194 if (device_param->d_bfs_c) hc_clReleaseMemObject (device_param->d_bfs_c);
16195 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (device_param->d_bitmap_s1_a);
16196 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (device_param->d_bitmap_s1_b);
16197 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (device_param->d_bitmap_s1_c);
16198 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (device_param->d_bitmap_s1_d);
16199 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (device_param->d_bitmap_s2_a);
16200 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (device_param->d_bitmap_s2_b);
16201 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (device_param->d_bitmap_s2_c);
16202 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (device_param->d_bitmap_s2_d);
16203 if (device_param->d_plain_bufs) hc_clReleaseMemObject (device_param->d_plain_bufs);
16204 if (device_param->d_digests_buf) hc_clReleaseMemObject (device_param->d_digests_buf);
16205 if (device_param->d_digests_shown) hc_clReleaseMemObject (device_param->d_digests_shown);
16206 if (device_param->d_salt_bufs) hc_clReleaseMemObject (device_param->d_salt_bufs);
16207 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (device_param->d_esalt_bufs);
16208 if (device_param->d_tmps) hc_clReleaseMemObject (device_param->d_tmps);
16209 if (device_param->d_hooks) hc_clReleaseMemObject (device_param->d_hooks);
16210 if (device_param->d_result) hc_clReleaseMemObject (device_param->d_result);
16211 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (device_param->d_scryptV_buf);
16212 if (device_param->d_root_css_buf) hc_clReleaseMemObject (device_param->d_root_css_buf);
16213 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (device_param->d_markov_css_buf);
16214 if (device_param->d_tm_c) hc_clReleaseMemObject (device_param->d_tm_c);
16215
16216 if (device_param->kernel1) hc_clReleaseKernel (device_param->kernel1);
16217 if (device_param->kernel12) hc_clReleaseKernel (device_param->kernel12);
16218 if (device_param->kernel2) hc_clReleaseKernel (device_param->kernel2);
16219 if (device_param->kernel23) hc_clReleaseKernel (device_param->kernel23);
16220 if (device_param->kernel3) hc_clReleaseKernel (device_param->kernel3);
16221 if (device_param->kernel_mp) hc_clReleaseKernel (device_param->kernel_mp);
16222 if (device_param->kernel_mp_l) hc_clReleaseKernel (device_param->kernel_mp_l);
16223 if (device_param->kernel_mp_r) hc_clReleaseKernel (device_param->kernel_mp_r);
16224 if (device_param->kernel_tb) hc_clReleaseKernel (device_param->kernel_tb);
16225 if (device_param->kernel_tm) hc_clReleaseKernel (device_param->kernel_tm);
16226 if (device_param->kernel_amp) hc_clReleaseKernel (device_param->kernel_amp);
16227
16228 if (device_param->program) hc_clReleaseProgram (device_param->program);
16229 if (device_param->program_mp) hc_clReleaseProgram (device_param->program_mp);
16230 if (device_param->program_amp) hc_clReleaseProgram (device_param->program_amp);
16231 if (device_param->command_queue) hc_clReleaseCommandQueue (device_param->command_queue);
16232 if (device_param->context) hc_clReleaseContext (device_param->context);
16233 }
16234
16235 // reset default fan speed
16236
16237 if (gpu_temp_disable == 0)
16238 {
16239 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
16240 {
16241 hc_thread_mutex_lock (mux_adl);
16242
16243 for (uint i = 0; i < data.devices_cnt; i++)
16244 {
16245 if (data.hm_device[i].fan_supported == 1)
16246 {
16247 int fanspeed = temp_retain_fanspeed_value[i];
16248
16249 if (fanspeed == -1) continue;
16250
16251 int rc = hm_set_fanspeed_with_device_id_amd (i, fanspeed);
16252
16253 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", i);
16254 }
16255 }
16256
16257 hc_thread_mutex_unlock (mux_adl);
16258 }
16259 }
16260
16261 // reset power tuning
16262
16263 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
16264 {
16265 hc_thread_mutex_lock (mux_adl);
16266
16267 for (uint i = 0; i < data.devices_cnt; i++)
16268 {
16269 if (data.hm_device[i].od_version == 6)
16270 {
16271 // check powertune capabilities first, if not available then skip device
16272
16273 int powertune_supported = 0;
16274
16275 if ((hc_ADL_Overdrive6_PowerControl_Caps (data.hm_dll, data.hm_device[i].adapter_index.amd, &powertune_supported)) != ADL_OK)
16276 {
16277 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
16278
16279 return (-1);
16280 }
16281
16282 if (powertune_supported != 0)
16283 {
16284 // powercontrol settings
16285
16286 if ((hc_ADL_Overdrive_PowerControl_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, od_power_control_status[i])) != ADL_OK)
16287 {
16288 log_info ("ERROR: Failed to restore the ADL PowerControl values");
16289
16290 return (-1);
16291 }
16292
16293 // clocks
16294
16295 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
16296
16297 performance_state->iNumberOfPerformanceLevels = 2;
16298
16299 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[i].state.aLevels[0].iEngineClock;
16300 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[i].state.aLevels[1].iEngineClock;
16301 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[i].state.aLevels[0].iMemoryClock;
16302 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[i].state.aLevels[1].iMemoryClock;
16303
16304 if ((hc_ADL_Overdrive_State_Set (data.hm_dll, data.hm_device[i].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
16305 {
16306 log_info ("ERROR: Failed to restore ADL performance state");
16307
16308 return (-1);
16309 }
16310
16311 local_free (performance_state);
16312 }
16313 }
16314 }
16315
16316 hc_thread_mutex_unlock (mux_adl);
16317 }
16318
16319 if (gpu_temp_disable == 0)
16320 {
16321 if (vendor_id == VENDOR_ID_NV)
16322 {
16323 #ifdef LINUX
16324 hc_NVML_nvmlShutdown (data.hm_dll);
16325 #endif
16326
16327 #ifdef WIN
16328 NvAPI_Unload ();
16329 #endif
16330 }
16331
16332 if (vendor_id == VENDOR_ID_AMD)
16333 {
16334 hc_ADL_Main_Control_Destroy (data.hm_dll);
16335
16336 hm_close (data.hm_dll);
16337 }
16338
16339 #ifdef LINUX
16340 if (vendor_id == VENDOR_ID_NV)
16341 {
16342 hm_close (data.hm_dll);
16343 }
16344 #endif
16345 }
16346
16347 // free memory
16348
16349 local_free (masks);
16350
16351 local_free (dictstat_base);
16352
16353 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
16354 {
16355 pot_t *pot_ptr = &pot[pot_pos];
16356
16357 hash_t *hash = &pot_ptr->hash;
16358
16359 local_free (hash->digest);
16360
16361 if (isSalted)
16362 {
16363 local_free (hash->salt);
16364 }
16365 }
16366
16367 local_free (pot);
16368
16369 local_free (all_kernel_rules_cnt);
16370 local_free (all_kernel_rules_buf);
16371
16372 local_free (wl_data->buf);
16373 local_free (wl_data);
16374
16375 local_free (bitmap_s1_a);
16376 local_free (bitmap_s1_b);
16377 local_free (bitmap_s1_c);
16378 local_free (bitmap_s1_d);
16379 local_free (bitmap_s2_a);
16380 local_free (bitmap_s2_b);
16381 local_free (bitmap_s2_c);
16382 local_free (bitmap_s2_d);
16383
16384 local_free (temp_retain_fanspeed_value);
16385 local_free (od_clock_mem_status);
16386 local_free (od_power_control_status);
16387
16388 global_free (devices_param);
16389
16390 global_free (kernel_rules_buf);
16391
16392 global_free (root_css_buf);
16393 global_free (markov_css_buf);
16394
16395 global_free (digests_buf);
16396 global_free (digests_shown);
16397 global_free (digests_shown_tmp);
16398
16399 global_free (salts_buf);
16400 global_free (salts_shown);
16401
16402 global_free (esalts_buf);
16403
16404 global_free (words_progress_done);
16405 global_free (words_progress_rejected);
16406 global_free (words_progress_restored);
16407
16408 if (pot_fp) fclose (pot_fp);
16409
16410 if (data.devices_status == STATUS_QUIT) break;
16411 }
16412
16413 // destroy others mutex
16414
16415 hc_thread_mutex_delete (mux_dispatcher);
16416 hc_thread_mutex_delete (mux_counter);
16417 hc_thread_mutex_delete (mux_display);
16418 hc_thread_mutex_delete (mux_adl);
16419
16420 // free memory
16421
16422 local_free (eff_restore_file);
16423 local_free (new_restore_file);
16424
16425 local_free (rd);
16426
16427 // loopback
16428
16429 local_free (loopback_file);
16430
16431 if (loopback == 1) unlink (loopback_file);
16432
16433 // induction directory
16434
16435 if (induction_dir == NULL)
16436 {
16437 if (attack_mode != ATTACK_MODE_BF)
16438 {
16439 if (rmdir (induction_directory) == -1)
16440 {
16441 if (errno == ENOENT)
16442 {
16443 // good, we can ignore
16444 }
16445 else if (errno == ENOTEMPTY)
16446 {
16447 // good, we can ignore
16448 }
16449 else
16450 {
16451 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
16452
16453 return (-1);
16454 }
16455 }
16456
16457 local_free (induction_directory);
16458 }
16459 }
16460
16461 // outfile-check directory
16462
16463 if (outfile_check_dir == NULL)
16464 {
16465 if (rmdir (outfile_check_directory) == -1)
16466 {
16467 if (errno == ENOENT)
16468 {
16469 // good, we can ignore
16470 }
16471 else if (errno == ENOTEMPTY)
16472 {
16473 // good, we can ignore
16474 }
16475 else
16476 {
16477 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
16478
16479 return (-1);
16480 }
16481 }
16482
16483 local_free (outfile_check_directory);
16484 }
16485
16486 time_t proc_stop;
16487
16488 time (&proc_stop);
16489
16490 logfile_top_uint (proc_start);
16491 logfile_top_uint (proc_stop);
16492
16493 logfile_top_msg ("STOP");
16494
16495 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
16496 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
16497
16498 if (data.devices_status == STATUS_ABORTED) return 2;
16499 if (data.devices_status == STATUS_QUIT) return 2;
16500 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
16501 if (data.devices_status == STATUS_EXHAUSTED) return 1;
16502 if (data.devices_status == STATUS_CRACKED) return 0;
16503
16504 return -1;
16505 }
Hashcat additions to support pwdhash