projects / hashcat.git / blob
? search:


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